commit ulimit

27 Oct 2008

Hello community,

here is the log from the commit of package ulimit
checked in at Tue Oct 28 00:40:59 CET 2008.


--------

--- ulimit/ulimit.changes	2007-08-14 00:07:56.000000000 +0200
+++ /d/STABLE/ulimit/ulimit.changes	2008-10-27 17:48:57.932293000 +0100
@@ -1,0 +2,11 @@
+Mon Oct 27 17:35:08 CET 2008 - garloff@suse.de
+
+- ulimit-1.2:
+  * Allow unlimited limits (bnc 382908, bnc 375673)
+  * Allow absolute memory limits
+  * Refactor (shorten file significantly and clean up environment)
+  * Document changes in sysconfig.ulimit file
+  * Much more conservative locked memory defaults (still more than
+    the kernel default).
+
+-------------------------------------------------------------------

calling whatdependson for head-i586


Old:
----
  ulimit-1.1.tar.gz
  ulimit-emptymeminfo.diff
  ulimit-evalexec.diff
  ulimit-kernel26.diff
  ulimit-nolocklimit.diff
  ulimit-stackcomment.diff
  ulimit-sysconfig-typo.diff

New:
----
  ulimit-1.2.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ ulimit.spec ++++++
--- /var/tmp/diff_new_pack.W15735/_old	2008-10-28 00:40:26.000000000 +0100
+++ /var/tmp/diff_new_pack.W15735/_new	2008-10-28 00:40:26.000000000 +0100
@@ -1,39 +1,39 @@
 #
-# spec file for package ulimit (Version 1.1)
+# spec file for package ulimit (Version 1.2)
 #
-# Copyright (c) 2007 SUSE LINUX Products GmbH, Nuernberg, Germany.
-# This file and all modifications and additions to the pristine
-# package are under the same license as the package itself.
+# Copyright (c) 2008 SUSE LINUX Products GmbH, Nuernberg, Germany.
 #
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
+
 # Please submit bugfixes or comments via http://bugs.opensuse.org/
 #
 
 # norootforbuild
 
+
 Name:           ulimit
 License:        Artistic License
 Group:          System/Base
-Autoreqprov:    on
-Summary:        Set per-process limits (ulimits)
-Version:        1.1
-Release:        199
+AutoReqProv:    on
+Summary:        Set system-wide per-process limits (rlimits)
+Version:        1.2
+Release:        1
 Source:         %{name}-%{version}.tar.gz
-Patch:          ulimit-evalexec.diff
-Patch2:         ulimit-kernel26.diff
-Patch3:         ulimit-nolocklimit.diff
-Patch4:         ulimit-stackcomment.diff
-Patch5:         ulimit-emptymeminfo.diff
-Patch6:         ulimit-sysconfig-typo.diff
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build
 BuildArch:	noarch
-%if %suse_version > 800
 PreReq:         %fillup_prereq
-%endif
 
 %description
 The file /etc/initscript is used by init to execute the commands in
 /etc/inittab. As any process it started from init, it is a convenient
-place to adjust per process limits (ulimits).
+place to adjust per process limits (rlimits).
 
 The script provided here does set limits on the memory usage per
 process (amongst setting other limits) and thus prevents that a single
@@ -46,6 +46,12 @@
 
 Configuration is done in file /etc/sysconfig/ulimit.
 
+Per user rlimit settings can be configured by filling in
+/etc/security/limits.conf and using the pam_limits.so functionality.
+
+More finegrained resource management (per process group), can be done
+via control groups (containers) with SLE11/openSUSE11.1 or newer.
+
 
 
 Authors:
@@ -54,12 +60,6 @@
 
 %prep
 %setup -n ulimit
-%patch -p1
-%patch2 -p1
-%patch3 -p1
-%patch4 -p1
-%patch5 -p1
-%patch6 -p1
 
 %build
 # nothing to be done
@@ -83,37 +83,45 @@
 rm -rf $RPM_BUILD_DIR/ulimit
 
 %changelog
-* Tue Aug 14 2007 - garloff@suse.de
+* Mon Oct 27 2008 garloff@suse.de
+- ulimit-1.2:
+  * Allow unlimited limits (bnc 382908, bnc 375673)
+  * Allow absolute memory limits
+  * Refactor (shorten file significantly and clean up environment)
+  * Document changes in sysconfig.ulimit file
+  * Much more conservative locked memory defaults (still more than
+  the kernel default).
+* Tue Aug 14 2007 garloff@suse.de
 - sysconfig Path missed a colon (299847)
-* Sat Jan 20 2007 - garloff@suse.de
+* Sat Jan 20 2007 garloff@suse.de
 - Make robust against existing and empty /proc/meminfo (227742)
   (and avoid forks for sed at the same time)
-* Wed Jan 25 2006 - mls@suse.de
+* Wed Jan 25 2006 mls@suse.de
 - converted neededforbuild to BuildRequires
-* Mon Nov 28 2005 - garloff@suse.de
+* Mon Nov 28 2005 garloff@suse.de
 - Fix comment for the stack limit (#132902).
-* Fri Apr 01 2005 - garloff@suse.de
+* Fri Apr 01 2005 garloff@suse.de
 - Make script work with both pre- and post 2.6.8 kernels. (#74085)
-* Sat Mar 26 2005 - garloff@suse.de
+* Sat Mar 26 2005 garloff@suse.de
 - Adapt order of applying soft vs hard limits to peculiar 2.6
   requirements for all limits. (#74085, #49323, #60650)
-* Sat Mar 26 2005 - garloff@suse.de
+* Sat Mar 26 2005 garloff@suse.de
 - Use eval exec "$4" to invoke binary (#74221, #60650).
-* Fri Sep 24 2004 - garloff@suse.de
+* Fri Sep 24 2004 garloff@suse.de
 - Don't set a limit for locked mem by default. Triggers warning
   with latest 2.6.9-rc kernels. (#SUSE45650)
 - Document that the stack limit should not be set either, as
   NPTL uses this a stack size for multithreade programs.
-* Sun Mar 28 2004 - garloff@suse.de
+* Sun Mar 28 2004 garloff@suse.de
 - Kernel 2.6 needs the soft limits before the hard ones. (#SUSE34323)
-* Fri Feb 06 2004 - hmacht@suse.de
+* Fri Feb 06 2004 hmacht@suse.de
 - building as non root (#norootforbuild)
-* Fri Aug 15 2003 - garloff@suse.de
+* Fri Aug 15 2003 garloff@suse.de
 - Remove left-over debug output to /tmp
 - Specify Command: killall mingetty to restart some service using
   the new limits. (We miss sshd and xdm.)
-* Tue Aug 12 2003 - garloff@suse.de
+* Tue Aug 12 2003 garloff@suse.de
 - Update to 1.1: Collect arguments first to reduce the number of
   calls to ulimit. (Performance improvement.)
-* Fri Aug 08 2003 - garloff@suse.de
+* Sat Aug 09 2003 garloff@suse.de
 - Creation of SuSE package.

++++++ ulimit-1.1.tar.gz -> ulimit-1.2.tar.gz ++++++
diff -urN --exclude=CVS --exclude=.cvsignore --exclude=.svn --exclude=.svnignore old/ulimit/initscript new/ulimit/initscript
--- old/ulimit/initscript	2003-08-15 21:05:04.000000000 +0200
+++ new/ulimit/initscript	2008-10-27 17:49:10.000000000 +0100
@@ -5,86 +5,129 @@
 #              /bin/sh /etc/initscript <id> <level> <action> <process>
 #
 # Set ulimits from sysconfig
-# (c) garloff@suse.de, 1996, 2003
+# (c) garloff@suse.de, 1996, 2003, 2008
 # License: Artistic
 
-# Set umask to safe level, and enable core dumps.
+# Set umask to safe level, and set ulimits
 umask 022
 PATH=/bin:/sbin:/usr/bin:/usr/sbin
 export PATH
+unset HARGS SARGS SARGS2 RC
+
+# Call with OPTION LIMIT BASE
+# if BASE is not set, then LIMIT will be treated as absolute value,
+# otherwise as percentage of BASE.
+# Return value in RC
+calc_limit()
+{
+  local lim
+  unset RC
+  if test "$2" = "0" -o -z "$2"; then
+    return 1
+  else
+    if test "$2" = "unlimited" -o "${2:0:1}" = "@" -o -z "$3"; then
+      RC="-$1 ${2#@}"
+    else
+      lim=$((($3+99)/100*$2))
+      let lim-=$((lim%4))
+      RC="-$1 $lim"
+    fi
+    #echo "(\"$1\" \"$2\" \"$3\" -> \"$RC\""
+    return 0
+  fi
+}
+
+get_mem()
+{
+  TOT=0
+  if test -r /proc/meminfo; then
+  # Get memory & swap sizes to evaluate the percentages
+    MEMTOT=0; SWPTOT=0
+    while read tag num unit; do
+      case $tag in
+        MemTotal:)
+	  MEMTOT=$num
+	  ;;
+        SwapTotal:)
+	  SWPTOT=$num
+	  ;;
+      esac
+    done < /proc/meminfo
+    TOT=$(($MEMTOT+$SWPTOT))
+  fi
+}
+
+kern_ver()
+{
+  unset NEW268LOCKLIMIT
+  case $(uname -r) in
+    2.[0-5].*|2.6.[0-7]|2.6.[0-7][.-]*)
+	;;
+    *)
+	NEW268LOCKLIMIT=1
+	;;
+  esac
+}
 
 if test -r /etc/sysconfig/ulimit; then
   . /etc/sysconfig/ulimit
-  unset HARGS SARGS
   # Max CPU time (not recommended)
-  test -z "$HARDCPULIMIT" -o "$HARDCPULIMIT" = "0" ||
-  HARGS="-Ht $HARDCPULIMIT"
-  test -z "$SOFTCPULIMIT" -o "$SOFTCPULIMIT" = "0" ||
-  SARGS="-St $SOFTCPULIMIT"
+  calc_limit "Ht" "$HARDCPULIMIT" && HARGS="$RC"
+  calc_limit "St" "$SOFTCPULIMIT" && SARGS="$RC"
   # File descriptors
-  test -z "$HARDFDLIMIT" -o "$HARDFDLIMIT" = "0" ||
-  HARGS="$HARGS -Hn $HARDFDLIMIT"
-  test -z "$SOFTFDLIMIT" -o "$SOFTFDLIMIT" = "0" ||
-  SARGS="$SARGS -Sn $SOFTFDLIMIT"
+  calc_limit "Hn" "$HARDFDLIMIT" && HARGS="$HARGS $RC"
+  calc_limit "Sn" "$SOFTFDLIMIT" && SARGS="$SARGS $RC"
   # Core files (0 makes sense here!)
-  test -z "$HARDCORELIMIT" ||
-  HARGS="$HARGS -Hc $HARDCORELIMIT"
-  test -z "$SOFTCORELIMIT" ||
-  SARGS="$SARGS -Sc $SOFTCORELIMIT"
+  test -z "$HARDCORELIMIT" || HARGS="$HARGS -Hc $HARDCORELIMIT"
+  test -z "$SOFTCORELIMIT" || SARGS="$SARGS -Sc $SOFTCORELIMIT"
   # File sizes
-  test -z "$HARDFILESZLIMIT" -o "$HARDFILESZLIMIT" = "0" ||
-  HARGS="$HARGS -Hf $HARDFILESZLIMIT"
-  test -z "$SOFTFILESZLIMIT" -o "$SOFTFILESZLIMIT" = "0" ||
-  SARGS="$SARGS -Sf $SOFTFILESZLIMIT"
+  calc_limit "Hf" "$HARDFILESIZELIMIT" && HARGS="$HARGS $RC"
+  calc_limit "Sf" "$SOFTFILESIZELIMIT" && SARGS="$SARGS $RC"
   # User processes
-  test -z "$HARDPROCESSLIMIT" -o "$HARDPROCESSLIMIT" = "0" ||
-  HARGS="$HARGS -Hu $HARDPROCESSLIMIT"
-  test -z "$SOFTPROCESSLIMIT" -o "$SOFTPROCESSLIMIT" = "0" ||
-  SARGS="$SARGS -Su $SOFTPROCESSLIMIT"
+  calc_limit "Hu" "$HARDPROCESSLIMIT" && HARGS="$HARGS $RC"
+  calc_limit "Su" "$SOFTPROCESSLIMIT" && SARGS="$SARGS $RC"
   # Apply
-  test -z "$HARGS" || ulimit $HARGS
-  test -z "$SARGS" || ulimit $SARGS
-fi
-
-if test -r /proc/meminfo -a -r /etc/sysconfig/ulimit; then
-  # Get memory & swap sizes to evaluate the percentages
-  MEMTOT=$(sed -e '/^MemTotal:/!d;s/^MemTotal*:[ 	]*\([0-9]*\) .*/\1/'  /proc/meminfo)
-  SWPTOT=$(sed -e '/^SwapTotal:/!d;s/^SwapTotal*:[ 	]*\([0-9]*\) .*/\1/'  /proc/meminfo)
-  TOT=$(($MEMTOT+$SWPTOT))
-  
-  unset HARGS SARGS
-  # SINGLE process limits to prevent a process from killing the machine
-  # by making it go OOM
-
-  # Maximum No more than VIRTUALLIMIT % of all virtual memory
-  test -z "$HARDVIRTUALLIMIT" -o "$HARDVIRTUALLIMIT" = "0" ||
-  HARGS="-Hv $((($TOT+99)/100*$HARDVIRTUALLIMIT))"
-  test -z "$SOFTVIRTUALLIMIT" -o "$SOFTVIRTUALLIMIT" = "0" ||
-  SARGS="-Sv $((($TOT+99)/100*$SOFTVIRTUALLIMIT))"
-  # Maximum resident size is $RESIDENTLIMIT % of physical RAM
-  test -z "$HARDRESIDENTLIMIT" -o "$HARDRESIDENTLIMIT" = "0" ||
-  HARGS="$HARGS -Hm $((($MEMTOT+99)/100*$HARDRESIDENTLIMIT))"
-  test -z "$SOFTRESIDENTLIMIT" -o "$SOFTRESIDENTLIMIT" = "0" ||
-  SARGS="$SARGS -Sm $((($MEMTOT+99)/100*$SOFTRESIDENTLIMIT))"
-  # Limit locked mem to $LOCKLIMIT % of phys RAM
-  test -z "$HARDLOCKLIMIT" -o "$HARDLOCKLIMIT" = "0" ||
-  HARGS="$HARGS -Hl $((($MEMTOT+99)/100*$HARDLOCKLIMIT))"
-  test -z "$SOFTLOCKLIMIT" -o "$SOFTLOCKLIMIT" = "0" ||
-  SARGS="$SARGS -Sl $((($MEMTOT+99)/100*$SOFTLOCKLIMIT))"
-  # Optional: Limit stack and data segment sizes ($STACKLIMIT, $DATALIMIT) 
-  test -z "$HARDSTACKLIMIT" -o "$HARDSTACKLIMIT" = "0" || 
-  HARGS="$HARGS -Hs $((($MEMTOT+99)/100*$HARDSTACKLIMIT))"
-  test -z "$SOFTSTACKLIMIT" -o "$SOFTSTACKLIMIT" = "0" || 
-  SARGS="$SARGS -Ss $((($MEMTOT+99)/100*$SOFTSTACKLIMIT))"
-  test -z "$HARDDATALIMIT" -o "$HARDDATALIMIT" = "0" || 
-  HARGS="$HARGS -Hd $((($MEMTOT+99)/100*$HARDDATALIMIT))"
-  test -z "$SOFTDATALIMIT" -o "$SOFTDATALIMIT" = "0" || 
-  SARGS="$SARGS -Sd $((($MEMTOT+99)/100*$SOFTDATALIMIT))"
-  # Apply
-  test -z "$HARGS" || ulimit $HARGS
-  test -z "$SARGS" || ulimit $SARGS
+  test -z "$SARGS"  || ulimit $SARGS
+  test -z "$HARGS"  || ulimit $HARGS
+  #test -z "$SARGS2" || ulimit $SARGS2
+  unset HARGS SARGS RC
+
+  # Memory dependent limits
+  get_mem
+  if test $TOT != 0; then
+    kern_ver
+
+    # SINGLE process limits to prevent a process from killing the machine
+    # by making it go OOM
+
+    # Maximum No more than VIRTUALLIMIT % of all virtual memory
+    calc_limit "Hv" "$HARDVIRTUALLIMIT" "$TOT" && HARGS="$HARGS $RC"
+    calc_limit "Sv" "$SOFTVIRTUALLIMIT" "$TOT" && SARGS="$SARGS $RC"
+    # Maximum resident size is $RESIDENTLIMIT % of physical RAM
+    calc_limit "Hm" "$HARDRESIDENTLIMIT" "$MEMTOT" && HARGS="$HARGS $RC"
+    calc_limit "Sm" "$SOFTRESIDENTLIMIT" "$MEMTOT" && SARGS="$SARGS $RC"
+    # Limit locked mem to $LOCKLIMIT % of phys RAM
+    calc_limit "Hl" "$HARDLOCKLIMIT" "$MEMTOT" && HARGS="$HARGS $RC"
+    if test -z "$NEW268LOCKLIMIT"; then
+      calc_limit "Sl" "$SOFTLOCKLIMIT" "$MEMTOT" && SARGS="$SARGS $RC"
+    else
+      calc_limit "Sl" "$SOFTLOCKLIMIT" "$MEMTOT" && SARGS2="$SARGS2 $RC"
+    fi
+    # Optional: Limit stack and data segment sizes ($STACKLIMIT, $DATALIMIT)
+    calc_limit "Hs" "$HARDSTACKLIMIT" "$MEMTOT" && HARGS="$HARGS $RC"
+    calc_limit "Ss" "$SOFTSTACKLIMIT" "$MEMTOT" && SARGS="$SARGS $RC"
+    calc_limit "Hd" "$HARDDATALIMIT" "$MEMTOT" && HARGS="$HARGS $RC"
+    calc_limit "Sd" "$SOFTDATALIMIT" "$MEMTOT" && SARGS="$SARGS $RC"
+    # Apply
+    test -z "$SARGS"  || ulimit $SARGS
+    test -z "$HARGS"  || ulimit $HARGS
+    test -z "$SARGS2" || ulimit $SARGS2
+    unset SARGS HARGS SARGS2 RC NEW268LOCKLIMIT
+  fi
+  unset TOT MEMTOT SWPTOT
 fi
+# cleanup environment
+unset calc_limit get_mem kern_ver
 
 # Execute the program.
-exec $4
-
+eval exec "$4"
diff -urN --exclude=CVS --exclude=.cvsignore --exclude=.svn --exclude=.svnignore old/ulimit/sysconfig.ulimit new/ulimit/sysconfig.ulimit
--- old/ulimit/sysconfig.ulimit	2003-08-15 21:09:10.000000000 +0200
+++ new/ulimit/sysconfig.ulimit	2008-10-27 17:33:43.000000000 +0100
@@ -1,4 +1,4 @@
-## Path System/Limits
+## Path: System/Limits
 ## Description: Set single process limits (memory, CPU, core ...)
 ## Command: killall mingetty	
 #
@@ -10,39 +10,44 @@
 # only partially effective: Memory limits are per process, not per
 # user. 
 # A setting of 0 will skip the adjustment of the particular limit
-# (except for core file sizes), thus the default will remain in
-# place, which is "unlimited" for most limits. If a value is unset,
-# no adjustment will be made either.
+# (except for core file sizes), thus the default will remain in place,
+# which is "unlimited" for most (but not all) limits. If a value is
+# undefined, no adjustment will be made either.
 # The memory sizes are percentages, the other values are absolute
-# numbers.
+# numbers. You can force absolute values for memory limits (in kB)
+# by prefixing the limit with @.
+# Additionally, the limits can be set to "unlimited" which will 
+# set them to unlimited. (Soft limits only if the hard limit allows it.)
 # Note that the limits only get effective after a session is 
 # restarted by init. Thus exiting mingetty (^D on console login)
 # or changing runlevel to 3 and back to 5 for xdm is needed.
 # Rebooting helps as well, of course.
 #  
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	0
 # 
 # Limit the amount of virtual memory a single process may allocate.
 # Hard limit: Can not be increased by non-root.
 # This value corresponds to ulimit -Hv
-# Parameter is in percent of virtual (phys+swap) memory, 0 means 
-# no adjustment (unlimited).
+# Parameter is in percent of virtual (phys+swap) memory (unless you 
+# prefix it by @, in which case it means kilobytes), 0 means 
+# no adjustment.
 #
-HARDVIRTUALLIMIT=0
+HARDVIRTUALLIMIT="0"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	80
 # 
 # Limit the amount of virtual memory a single process may allocate.
 # Soft limit: Can be increased by non-root up to the hard limit.
 # This value corresponds to ulimit -Sv
-# Parameter is in percent of virtual (phys+swap) memory, 0 means 
-# no adjustment (unlimited).
+# Parameter is in percent of virtual (phys+swap) memory (unless you 
+# prefix it by @, in which case it means kilobytes), 0 means 
+# no adjustment. "unlimited" will attempt to set this to umlimited.
 #
-SOFTVIRTUALLIMIT=80
+SOFTVIRTUALLIMIT="80"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	0
 #
 # Limit the amount of resident memory a single process may occupy.
@@ -50,12 +55,12 @@
 # it can not get more resident memory. 
 # Hard limit: Can not be increased by non-root.
 # This value corresponds to ulimit -Hm
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment.
 #
-HARDRESIDENTLIMIT=0
+HARDRESIDENTLIMIT="0"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	85
 #
 # Limit the amount of resident memory a single process may occupy.
@@ -63,106 +68,118 @@
 # it can not get more resident memory. 
 # Soft limit: Can be increased by non-root up to the hard limit.
 # This value corresponds to ulimit -Sm
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment.
+# "unlimited" will attempt to set this to unlimited.
 #
-SOFTRESIDENTLIMIT=85
+SOFTRESIDENTLIMIT="85"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	0
 #
 # Limit the size of the stack that a single process may allocate.
 # Normally, it should be enough to limit virtual and resident size.
+# Note that with NPTL, the stack limit determines the stack SIZE
+# of multithreaded programs and should thus better not be set.
 # Hard limit: Can not be increased by non-root.
 # This value corresponds to ulimit -Hs
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment
+# (the kernel default, arch-dependent, typically 8192kB).
 #
-HARDSTACKLIMIT=0
+HARDSTACKLIMIT="0"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	0
 #
 # Limit the size of the stack that a single process may allocate.
 # Normally, it should be enough to limit virtual and resident size.
+# Note that with NPTL, the stack limit determines the stack SIZE
+# of multithreaded programs and should thus better not be set.
 # Soft limit: Can be increased by non-root up to the hard limit.
 # This value corresponds to ulimit -Ss
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment
+# (the kernel default, arch-dependent, typically 8192kB).
+# "unlimited" will attempt to set this to unlimited.
 #
-SOFTSTACKLIMIT=0
+SOFTSTACKLIMIT="0"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	0
 #
 # Limit the size of the data segment that a single process may allocate.
 # Normally, it should be enough to limit virtual and resident size.
 # Hard limit: Can not be increased by non-root.
 # This value corresponds to ulimit -Hd
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment.
 #
-HARDDATALIMIT=0
+HARDDATALIMIT="0"
 
-## Type:	integer(0:99)
+## Type:	string
 ## Default:	0
 #
 # Limit the size of the data segment that a single process may allocate.
 # Normally, it should be enough to limit virtual and resident size.
 # Soft limit: Can be increased by non-root up to the hard limit.
 # This value corresponds to ulimit -Sd
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment.
+# "unlimited" will attempt to set this to unlimited.
 #
-SOFTDATALIMIT=0
+SOFTDATALIMIT="0"
 
-## Type:	integer(0:99)
-## Default:	42
+## Type:	string
+## Default:	5
 #
 # Limit the size of the memory that a single process may lock in
 # physical memory (thus preventing it to be swapped out).
 # Hard limit: Can not be increased by non-root.
 # This value corresponds to ulimit -Hl
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment.
 #
-HARDLOCKLIMIT=42
+HARDLOCKLIMIT="@256"
 
-## Type:	integer(0:99)
-## Default:	42
+## Type:	string
+## Default:	@128
 #
 # Limit the size of the memory that a single process may lock in
 # physical memory (thus preventing it to be swapped out).
 # Soft limit: Can be increased by non-root up to the hard limit.
 # This value corresponds to ulimit -Sl
-# Parameter is in percent of physical memory, 0 means no adjustment
-# (unlimited).
+# Parameter is in percent of physical memory (unless you prefix
+# it by @, in which case it means kilobytes), 0 means no adjustment.
+# (Kernel default is architecture dependent, typically 32 or 64kB.)
+# "unlimited" will attempt to set this to unlimited -- not a good idea.
 #
-SOFTLOCKLIMIT=42
+SOFTLOCKLIMIT="@64"
 
-## Type:	integer
+## Type:	string
 ## Default:	0
 #
 # Limit the amount of CPU time for a single process.
 # Should not normally be set to non-zero values.
 # Hard limit: Process will be killed.
 # Corresponds to ulimit -Ht.
-# Parameter is in seconds, 0 means no adjustment (unlimited).
+# Parameter is in seconds, 0 means no adjustment.
 # 
-HARDCPULIMIT=0
+HARDCPULIMIT="unlimited"
 
-## Type:	integer
+## Type:	string
 ## Default:	0
 #
 # Limit the amount of CPU time for a single process.
 # Should not normally be set to non-zero values.
 # Soft limit: Process will be sent SIGXCPU.
 # Corresponds to ulimit -St.
-# Parameter is in seconds, 0 means no adjustment (unlimited).
+# Parameter is in seconds, 0 means no adjustment.
+# "unlimited" will attempt to set this to unlimited.
 # 
-SOFTCPULIMIT=0
+SOFTCPULIMIT="0"
 
-## Type:	integer
+## Type:	string
 ## Default:	8192
 #
 # Limit the amount of file descriptors that a process 
@@ -171,9 +188,9 @@
 # Corresponds to ulimit -Hn.
 # 0 means no adjustment (system default: 1024).
 # 
-HARDFDLIMIT=8192
+HARDFDLIMIT="8192"
 
-## Type:	integer
+## Type:	string
 ## Default:	1024
 #
 # Limit the amount of file descriptors that a process 
@@ -182,7 +199,7 @@
 # Corresponds to ulimit -Sn.
 # 0 means no adjustment (system default: 1024).
 # 
-SOFTFDLIMIT=1024
+SOFTFDLIMIT="1024"
 
 ## Type:	string
 ## Default:	"unlimited"
@@ -200,7 +217,8 @@
 # Limit the size of core dump files. 0 turns them off.
 # Soft limit: Can be increased by non-root up to the hard limit.
 # Corresponds to ulimit -Sc.
-# Parameter is in blocks (1k), 0 means turning core files off.
+# Parameter is in blocks (1k), 0 means turning core files off,
+# "unlimited" allows arbitrarily huge core files.
 # 
 SOFTCORELIMIT="0"
 
@@ -210,7 +228,8 @@
 # Limit the size of files a user may create.
 # Hard limit: Can not be increased by non-root.
 # Corresponds to ulimit -Hf.
-# Parameter is in blocks (1k), 0 means no adjustment (unlimited).
+# Parameter is in blocks (1k), 0 means no adjustment
+# "unlimited" will set this to unlimited.
 # 
 HARDFILESZLIMIT="unlimited"
 
@@ -220,7 +239,8 @@
 # Limit the size of files a user may create.
 # Soft limit: Can be increased by non-root up to the hard limit.
 # Corresponds to ulimit -Sf.
-# Parameter is in blocks (1k), 0 means no adjustment (unlimited).
+# Parameter is in blocks (1k), 0 means no adjustment.
+# "unlimited" will attempt to set this to unlimited.
 # 
 SOFTFILESZLIMIT="unlimited"
 
@@ -245,6 +265,7 @@
 # Corresponds to ulimit -Su.
 # 0 means no adjustment (system default is a few thousands, exact 
 # value depends on the architecture).
+# "unlimited" will attempt to set this to unlimited.
 # 
 SOFTPROCESSLIMIT="0"
 


++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



Remember to have fun...

-- 
To unsubscribe, e-mail: opensuse-commit+unsubscribe@opensuse.org
For additional commands, e-mail: opensuse-commit+help@opensuse.org

    

commit ulimit

root＠Hilbert.suse.de