- patches.suse/perfmon2.patch: Refresh.

- patches.suse/rlim-0001-SECURITY-selinux-fix-update_rlimit_cpu-parameter.patch:
  Refresh.
- patches.suse/rlim-0002-resource-move-kernel-function-inside-__KERNEL__.patch:
  resource: move kernel function inside __KERNEL__ (FATE#305733).
- patches.suse/rlim-0003-resource-add-helpers-for-fetching-rlimits.patch:
  resource: add helpers for fetching rlimits (FATE#305733).
- patches.suse/rlim-0004-IA64-use-helpers-for-rlimits.patch:
  [IA64] use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0005-core-posix-cpu-timers-cleanup-rlimits-usage.patch:
  core: posix-cpu-timers, cleanup rlimits usage (FATE#305733).
- patches.suse/rlim-0006-PPC-use-helpers-for-rlimits.patch: PPC:
  use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0007-S390-use-helpers-for-rlimits.patch:
  S390: use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0008-SPARC-use-helpers-for-rlimits.patch:
  SPARC: use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0009-X86-use-helpers-for-rlimits.patch: X86:
  use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0010-FS-use-helpers-for-rlimits.patch: FS:
  use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0011-MM-use-helpers-for-rlimits.patch: MM:
  use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0012-core-use-helpers-for-rlimits.patch:
  core: use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0013-infiniband-use-helpers-for-rlimits.patch:
  infiniband: use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0014-ipc-use-helpers-for-rlimits.patch: ipc:
  use helpers for rlimits (FATE#305733).
- patches.suse/rlim-0015-SECURITY-add-task_struct-to-setrlimit.patch:
  SECURITY: add task_struct to setrlimit (FATE#305733).
- patches.suse/rlim-0016-core-add-task_struct-to-update_rlimit_cpu.patch:
  core: add task_struct to update_rlimit_cpu (FATE#305733).
- patches.suse/rlim-0017-sys_setrlimit-make-sure-rlim_max-never-grows.patch:
  sys_setrlimit: make sure ->rlim_max never grows (FATE#305733).
- patches.suse/rlim-0018-core-split-sys_setrlimit.patch: core:
  split sys_setrlimit (FATE#305733).
- patches.suse/rlim-0019-core-allow-setrlimit-to-non-current-tasks.patch:
  core: allow setrlimit to non-current tasks (FATE#305733).
- patches.suse/rlim-0020-core-optimize-setrlimit-for-current-task.patch:
  core: optimize setrlimit for current task (FATE#305733).
- patches.suse/rlim-0021-FS-proc-switch-limits-reading-to-fops.patch:
  FS: proc, switch limits reading to fops (FATE#305733).
- patches.suse/rlim-0022-FS-proc-make-limits-writable.patch:
  FS: proc, make limits writable (FATE#305733).
- patches.suse/rlim-0023-core-do-security-check-under-task_lock.patch:
  core: do security check under task_lock (FATE#305733).
- patches.suse/rlim-0002-SECURITY-add-task_struct-to-setrlimit.patch:
  Delete.
- patches.suse/rlim-0003-core-add-task_struct-to-update_rlimit_cpu.patch:
  Delete.
- patches.suse/rlim-0004-sys_setrlimit-make-sure-rlim_max-never-grows.patch:
  Delete.
- patches.suse/rlim-0005-core-split-sys_setrlimit.patch: Delete.
- patches.suse/rlim-0006-core-allow-setrlimit-to-non-current-tasks.patch:
  Delete.
- patches.suse/rlim-0007-core-optimize-setrlimit-for-current-task.patch:
  Delete.
- patches.suse/rlim-0008-FS-proc-make-limits-writable.patch:
  Delete.
- patches.suse/rlim-0009-core-posix-cpu-timers-cleanup-rlimits-usage.patch:
  Delete.
- patches.suse/rlim-0010-core-do-security-check-under-task_lock.patch:
  Delete.
- patches.suse/rlim-0011-resource-add-helpers-for-fetching-rlimits.patch:
  Delete.
- patches.suse/rlim-0012-IA64-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0013-PPC-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0014-S390-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0015-SPARC-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0016-X86-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0017-FS-use-helpers-for-rlimits.patch: Delete.
- patches.suse/rlim-0018-MM-use-helpers-for-rlimits.patch: Delete.
- patches.suse/rlim-0019-core-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0020-misc-use-helpers-for-rlimits.patch:
  Delete.
- patches.suse/rlim-0021-core-rename-setrlimit-to-do_setrlimit.patch:
  Delete.
- patches.suse/rlim-0022-core-implement-getprlimit-and-setprlimit-syscalls.patch:
  Delete.
- patches.suse/rlim-0023-unistd-add-__NR_-get-set-prlimit-syscall-numbers.patch:
  Delete.
- patches.suse/rlim-0024-COMPAT-add-get-put_compat_rlimit.patch:
  Delete.
- patches.suse/rlim-0025-x86-add-ia32-compat-prlimit-syscalls.patch:
  Delete.

  Sync with upstream. Drop limits syscalls altogether.

suse-commit: 1445f51813f12ddfcb4c1b091d625cf036f76b1b

diff --git a/arch/ia64/kernel/sys_ia64.c b/arch/ia64/kernel/sys_ia64.c
index 60b43a5..1c6647b 100644 (file)
--- a/arch/ia64/kernel/sys_ia64.c
+++ b/arch/ia64/kernel/sys_ia64.c
@@ -138,7 +138,7 @@ ia64_brk (unsigned long brk)
                goto out;
 
        /* Check against rlimit.. */
-       rlim = rlim_get_cur(RLIMIT_DATA);
+       rlim = current->signal->rlim[RLIMIT_DATA].rlim_cur;
        if (rlim < RLIM_INFINITY && brk - mm->start_data > rlim)
                goto out;
 

diff --git a/arch/ia64/mm/init.c b/arch/ia64/mm/init.c
index 0995019..dcd8eb7 100644 (file)
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -91,7 +91,7 @@ dma_mark_clean(void *addr, size_t size)
 inline void
 ia64_set_rbs_bot (void)
 {
-       unsigned long stack_size = rlim_get_max(RLIMIT_STACK) & -16;
+       unsigned long stack_size = rlimit_max(RLIMIT_STACK) & -16;
 
        if (stack_size > MAX_USER_STACK_SIZE)
                stack_size = MAX_USER_STACK_SIZE;

diff --git a/arch/powerpc/mm/mmap_64.c b/arch/powerpc/mm/mmap_64.c
index 8df1299..5a783d8 100644 (file)
--- a/arch/powerpc/mm/mmap_64.c
+++ b/arch/powerpc/mm/mmap_64.c
@@ -47,7 +47,7 @@ static inline int mmap_is_legacy(void)
        if (current->personality & ADDR_COMPAT_LAYOUT)
                return 1;
 
-       if (rlim_get_cur(RLIMIT_STACK) == RLIM_INFINITY)
+       if (rlimit(RLIMIT_STACK) == RLIM_INFINITY)
                return 1;
 
        return sysctl_legacy_va_layout;
@@ -77,7 +77,7 @@ static unsigned long mmap_rnd(void)
 
 static inline unsigned long mmap_base(void)
 {
-       unsigned long gap = rlim_get_cur(RLIMIT_STACK);
+       unsigned long gap = rlimit(RLIMIT_STACK);
 
        if (gap < MIN_GAP)
                gap = MIN_GAP;

diff --git a/arch/powerpc/platforms/cell/spufs/coredump.c b/arch/powerpc/platforms/cell/spufs/coredump.c
index 4ef1c92..eea1202 100644 (file)
--- a/arch/powerpc/platforms/cell/spufs/coredump.c
+++ b/arch/powerpc/platforms/cell/spufs/coredump.c
@@ -54,7 +54,7 @@ static ssize_t do_coredump_read(int num, struct spu_context *ctx, void *buffer,
  */
 static int spufs_dump_write(struct file *file, const void *addr, int nr, loff_t *foffset)
 {
-       unsigned long limit = rlim_get_cur(RLIMIT_CORE);
+       unsigned long limit = rlimit(RLIMIT_CORE);
        ssize_t written;
 
        if (*foffset + nr > limit)

diff --git a/arch/s390/mm/mmap.c b/arch/s390/mm/mmap.c
index 0acf3aa..869efba 100644 (file)
--- a/arch/s390/mm/mmap.c
+++ b/arch/s390/mm/mmap.c
@@ -40,7 +40,7 @@
 
 static inline unsigned long mmap_base(void)
 {
-       unsigned long gap = rlim_get_cur(RLIMIT_STACK);
+       unsigned long gap = rlimit(RLIMIT_STACK);
 
        if (gap < MIN_GAP)
                gap = MIN_GAP;
@@ -61,7 +61,7 @@ static inline int mmap_is_legacy(void)
 #endif
        return sysctl_legacy_va_layout ||
            (current->personality & ADDR_COMPAT_LAYOUT) ||
-           rlim_get_cur(RLIMIT_STACK) == RLIM_INFINITY;
+           rlimit(RLIMIT_STACK) == RLIM_INFINITY;
 }
 
 #ifndef CONFIG_64BIT

diff --git a/arch/sparc/kernel/sys_sparc_64.c b/arch/sparc/kernel/sys_sparc_64.c
index d53870c..f439283 100644 (file)
--- a/arch/sparc/kernel/sys_sparc_64.c
+++ b/arch/sparc/kernel/sys_sparc_64.c
@@ -376,7 +376,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm)
         * Fall back to the standard layout if the personality
         * bit is set, or if the expected stack growth is unlimited:
         */
-       gap = rlim_get_cur(RLIMIT_STACK);
+       gap = rlimit(RLIMIT_STACK);
        if (!test_thread_flag(TIF_32BIT) ||
            (current->personality & ADDR_COMPAT_LAYOUT) ||
            gap == RLIM_INFINITY ||

diff --git a/arch/x86/ia32/ia32_aout.c b/arch/x86/ia32/ia32_aout.c
index d311ec5..0647478 100644 (file)
--- a/arch/x86/ia32/ia32_aout.c
+++ b/arch/x86/ia32/ia32_aout.c
@@ -297,7 +297,7 @@ static int load_aout_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         * size limits imposed on them by creating programs with large
         * arrays in the data or bss.
         */
-       rlim = rlim_get_cur(RLIMIT_DATA);
+       rlim = rlimit(RLIMIT_DATA);
        if (rlim >= RLIM_INFINITY)
                rlim = ~0;
        if (ex.a_data + ex.a_bss > rlim)

diff --git a/arch/x86/mm/mmap.c b/arch/x86/mm/mmap.c
index d6e0e36..1dab519 100644 (file)
--- a/arch/x86/mm/mmap.c
+++ b/arch/x86/mm/mmap.c
@@ -71,8 +71,7 @@ static int mmap_is_legacy(void)
        if (current->personality & ADDR_COMPAT_LAYOUT)
                return 1;
 
-       if (rlim_get_cur(RLIMIT_STACK)
-                       == RLIM_INFINITY)
+       if (rlimit(RLIMIT_STACK) == RLIM_INFINITY)
                return 1;
 
        return sysctl_legacy_va_layout;
@@ -97,8 +96,7 @@ static unsigned long mmap_rnd(void)
 
 static unsigned long mmap_base(void)
 {
-       unsigned long gap =
-               rlim_get_cur(RLIMIT_STACK);
+       unsigned long gap = rlimit(RLIMIT_STACK);
 
        if (gap < MIN_GAP)
                gap = MIN_GAP;

diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c
index 2a8338a..4f906f0 100644 (file)
--- a/drivers/infiniband/core/umem.c
+++ b/drivers/infiniband/core/umem.c
@@ -136,7 +136,7 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
        down_write(&current->mm->mmap_sem);
 
        locked     = npages + current->mm->locked_vm;
-       lock_limit = rlim_get_cur(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
+       lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 
        if ((locked > lock_limit) && !capable(CAP_IPC_LOCK)) {
                ret = -ENOMEM;

diff --git a/drivers/infiniband/hw/ipath/ipath_user_pages.c b/drivers/infiniband/hw/ipath/ipath_user_pages.c
index 431ec61..eb7d59a 100644 (file)
--- a/drivers/infiniband/hw/ipath/ipath_user_pages.c
+++ b/drivers/infiniband/hw/ipath/ipath_user_pages.c
@@ -59,7 +59,7 @@ static int __get_user_pages(unsigned long start_page, size_t num_pages,
        size_t got;
        int ret;
 
-       lock_limit = rlim_get_cur(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
+       lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 
        if (num_pages > lock_limit) {
                ret = -ENOMEM;

diff --git a/fs/attr.c b/fs/attr.c
index 3554042..34ade0e 100644 (file)
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -82,7 +82,7 @@ int inode_newsize_ok(const struct inode *inode, loff_t offset)
        if (inode->i_size < offset) {
                unsigned long limit;
 
-               limit = rlim_get_cur(RLIMIT_FSIZE);
+               limit = rlimit(RLIMIT_FSIZE);
                if (limit != RLIM_INFINITY && offset > limit)
                        goto out_sig;
                if (offset > inode->i_sb->s_maxbytes)

diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index dc3f316..06d892e 100644 (file)
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -246,7 +246,7 @@ static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
         * size limits imposed on them by creating programs with large
         * arrays in the data or bss.
         */
-       rlim = rlim_get_cur(RLIMIT_DATA);
+       rlim = rlimit(RLIMIT_DATA);
        if (rlim >= RLIM_INFINITY)
                rlim = ~0;
        if (ex.a_data + ex.a_bss > rlim)

diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index 0161f3c..b78b9de 100644 (file)
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -501,7 +501,7 @@ static int load_flat_file(struct linux_binprm * bprm,
         * size limits imposed on them by creating programs with large
         * arrays in the data or bss.
         */
-       rlim = rlim_get_cur(RLIMIT_DATA);
+       rlim = rlimit(RLIMIT_DATA);
        if (rlim >= RLIM_INFINITY)
                rlim = ~0;
        if (data_len + bss_len > rlim) {

diff --git a/fs/exec.c b/fs/exec.c
index 6ad49a3..077a075 100644 (file)
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -581,7 +581,7 @@ int setup_arg_pages(struct linux_binprm *bprm,
 
 #ifdef CONFIG_STACK_GROWSUP
        /* Limit stack size to 1GB */
-       stack_base = rlim_get_max(RLIMIT_STACK);
+       stack_base = rlimit_max(RLIMIT_STACK);
        if (stack_base > (1 << 30))
                stack_base = 1 << 30;
 
@@ -1516,7 +1516,7 @@ static int format_corename(char *corename, long signr)
                        /* core limit size */
                        case 'c':
                                rc = snprintf(out_ptr, out_end - out_ptr,
-                                       "%lu", rlim_get_cur(RLIMIT_CORE));
+                                             "%lu", rlimit(RLIMIT_CORE));
                                if (rc > out_end - out_ptr)
                                        goto out;
                                out_ptr += rc;
@@ -1775,7 +1775,7 @@ void do_coredump(long signr, int exit_code, struct pt_regs *regs)
        int retval = 0;
        int flag = 0;
        int ispipe = 0;
-       unsigned long core_limit = rlim_get_cur(RLIMIT_CORE);
+       unsigned long core_limit = rlimit(RLIMIT_CORE);
        char **helper_argv = NULL;
        int helper_argc = 0;
        int dump_count = 0;

diff --git a/fs/fcntl.c b/fs/fcntl.c
index 8dd4b4f..09c6271 100644 (file)
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -344,7 +344,7 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
        switch (cmd) {
        case F_DUPFD:
        case F_DUPFD_CLOEXEC:
-               if (arg >= rlim_get_cur(RLIMIT_NOFILE))
+               if (arg >= rlimit(RLIMIT_NOFILE))
                        break;
                err = alloc_fd(arg, cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0);
                if (err >= 0) {

diff --git a/fs/file.c b/fs/file.c
index 0a472ff..d1c21d8 100644 (file)
--- a/fs/file.c
+++ b/fs/file.c
@@ -257,7 +257,7 @@ int expand_files(struct files_struct *files, int nr)
         * N.B. For clone tasks sharing a files structure, this test
         * will limit the total number of files that can be opened.
         */
-       if (nr >= rlim_get_cur(RLIMIT_NOFILE))
+       if (nr >= rlimit(RLIMIT_NOFILE))
                return -EMFILE;
 
        /* Do we need to expand? */

diff --git a/fs/proc/array.c b/fs/proc/array.c
index 3fe444e..06ae950 100644 (file)
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -269,7 +269,7 @@ static inline void task_sig(struct seq_file *m, struct task_struct *p)
                collect_sigign_sigcatch(p, &ignored, &caught);
                num_threads = atomic_read(&p->signal->count);
                qsize = atomic_read(&__task_cred(p)->user->sigpending);
-               qlim = task_rlim_get_cur(p, RLIMIT_SIGPENDING);
+               qlim = task_rlimit(p, RLIMIT_SIGPENDING);
                unlock_task_sighand(p, &flags);
        }
 

diff --git a/fs/proc/base.c b/fs/proc/base.c
index c6589fb..9fdb990 100644 (file)
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -128,8 +128,6 @@ struct pid_entry {
                NULL, &proc_single_file_operations,     \
                { .proc_show = show } )
 
-static ssize_t proc_info_read(struct file * file, char __user * buf,
-                         size_t count, loff_t *ppos);
 /*
  * Count the number of hardlinks for the pid_entry table, excluding the .
  * and .. links.
@@ -479,19 +477,30 @@ static const struct limit_names lnames[RLIM_NLIMITS] = {
 };
 
 /* Display limits for a process */
-static int proc_pid_limits(struct task_struct *task, char *buffer)
+static ssize_t limits_read(struct file *file, char __user *buf, size_t rcount,
+               loff_t *ppos)
 {
-       unsigned int i;
-       int count = 0;
-       unsigned long flags;
-       char *bufptr = buffer;
-
        struct rlimit rlim[RLIM_NLIMITS];
+       struct task_struct *task;
+       unsigned long flags;
+       unsigned int i;
+       ssize_t count = 0;
+       char *bufptr;
 
-       if (!lock_task_sighand(task, &flags))
+       task = get_proc_task(file->f_path.dentry->d_inode);
+       if (!task)
+               return -ESRCH;
+       if (!lock_task_sighand(task, &flags)) {
+               put_task_struct(task);
                return 0;
+       }
        memcpy(rlim, task->signal->rlim, sizeof(struct rlimit) * RLIM_NLIMITS);
        unlock_task_sighand(task, &flags);
+       put_task_struct(task);
+
+       bufptr = (char *)__get_free_page(GFP_TEMPORARY);
+       if (!bufptr)
+               return -ENOMEM;
 
        /*
         * print the file header
@@ -520,6 +529,10 @@ static int proc_pid_limits(struct task_struct *task, char *buffer)
                        count += sprintf(&bufptr[count], "\n");
        }
 
+       count = simple_read_from_buffer(buf, rcount, ppos, bufptr, count);
+
+       free_page((unsigned long)bufptr);
+
        return count;
 }
 
@@ -587,8 +600,8 @@ out:
 }
 
 static const struct file_operations proc_pid_limits_operations = {
-       .read           = proc_info_read,
-       .write          = limits_write,
+       .read   = limits_read,
+       .write  = limits_write,
 };
 
 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
@@ -2570,9 +2583,7 @@ static const struct pid_entry tgid_base_stuff[] = {
        INF("auxv",       S_IRUSR, proc_pid_auxv),
        ONE("status",     S_IRUGO, proc_pid_status),
        ONE("personality", S_IRUSR, proc_pid_personality),
-       NOD("limits",     S_IFREG|S_IRUSR|S_IWUSR, NULL,
-                       &proc_pid_limits_operations,
-                       { .proc_read = proc_pid_limits }),
+       REG("limits",     S_IRUSR|S_IWUSR, proc_pid_limits_operations),
 #ifdef CONFIG_SCHED_DEBUG
        REG("sched",      S_IRUGO|S_IWUSR, proc_pid_sched_operations),
 #endif
@@ -2906,9 +2917,7 @@ static const struct pid_entry tid_base_stuff[] = {
        INF("auxv",      S_IRUSR, proc_pid_auxv),
        ONE("status",    S_IRUGO, proc_pid_status),
        ONE("personality", S_IRUSR, proc_pid_personality),
-       NOD("limits",     S_IFREG|S_IRUSR|S_IWUSR, NULL,
-                       &proc_pid_limits_operations,
-                       { .proc_read = proc_pid_limits }),
+       REG("limits",     S_IRUSR|S_IWUSR, proc_pid_limits_operations),
 #ifdef CONFIG_SCHED_DEBUG
        REG("sched",     S_IRUGO|S_IWUSR, proc_pid_sched_operations),
 #endif

diff --git a/fs/select.c b/fs/select.c
index ce85db0..5e9cf2a 100644 (file)
--- a/fs/select.c
+++ b/fs/select.c
@@ -827,7 +827,7 @@ int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
        struct poll_list *walk = head;
        unsigned long todo = nfds;
 
-       if (nfds > rlim_get_cur(RLIMIT_NOFILE))
+       if (nfds > rlimit(RLIMIT_NOFILE))
                return -EINVAL;
 
        len = min_t(unsigned int, nfds, N_STACK_PPS);

diff --git a/include/linux/resource.h b/include/linux/resource.h
index 08beb1a..cf8dc96 100644 (file)
--- a/include/linux/resource.h
+++ b/include/linux/resource.h
@@ -3,8 +3,6 @@
 
 #include <linux/time.h>
 
-struct task_struct;
-
 /*
  * Resource control/accounting header file for linux
  */
@@ -70,8 +68,14 @@ struct rlimit {
  */
 #include <asm/resource.h>
 
+#ifdef __KERNEL__
+
+struct task_struct;
+
 int getrusage(struct task_struct *p, int who, struct rusage __user *ru);
 int do_setrlimit(struct task_struct *tsk, unsigned int resource,
                struct rlimit *new_rlim);
 
+#endif /* __KERNEL__ */
+
 #endif

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 5ad2b6a..8b99555 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -2607,30 +2607,30 @@ static inline void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
 }
 #endif /* CONFIG_MM_OWNER */
 
-static inline unsigned long task_rlim_get_cur(const struct task_struct *tsk,
+#define TASK_STATE_TO_CHAR_STR "RSDTtZX"
+
+static inline unsigned long task_rlimit(const struct task_struct *tsk,
                unsigned int limit)
 {
        return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
 }
 
-static inline unsigned long task_rlim_get_max(const struct task_struct *tsk,
+static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
                unsigned int limit)
 {
        return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
 }
 
-static inline unsigned long rlim_get_cur(unsigned int limit)
+static inline unsigned long rlimit(unsigned int limit)
 {
-       return task_rlim_get_cur(current, limit);
+       return task_rlimit(current, limit);
 }
 
-static inline unsigned long rlim_get_max(unsigned int limit)
+static inline unsigned long rlimit_max(unsigned int limit)
 {
-       return task_rlim_get_max(current, limit);
+       return task_rlimit_max(current, limit);
 }
 
-#define TASK_STATE_TO_CHAR_STR "RSDTtZX"
-
 #endif /* __KERNEL__ */
 
 #endif

diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 365df75..f7966ec 100644 (file)
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -709,15 +709,11 @@ asmlinkage long sys_newuname(struct new_utsname __user *name);
 
 asmlinkage long sys_getrlimit(unsigned int resource,
                                struct rlimit __user *rlim);
-asmlinkage long sys_getprlimit(pid_t pid, unsigned int resource,
-                               struct rlimit __user *rlim);
 #if defined(COMPAT_RLIM_OLD_INFINITY) || !(defined(CONFIG_IA64))
 asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim);
 #endif
 asmlinkage long sys_setrlimit(unsigned int resource,
                                struct rlimit __user *rlim);
-asmlinkage long sys_setprlimit(pid_t pid, unsigned int resource,
-                               struct rlimit __user *rlim);
 asmlinkage long sys_getrusage(int who, struct rusage __user *ru);
 asmlinkage long sys_umask(int mask);
 

diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 0e18cde..f5d4bd2 100644 (file)
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -153,7 +153,7 @@ static struct inode *mqueue_get_inode(struct super_block *sb,
                        spin_lock(&mq_lock);
                        if (u->mq_bytes + mq_bytes < u->mq_bytes ||
                            u->mq_bytes + mq_bytes >
-                           task_rlim_get_cur(p, RLIMIT_MSGQUEUE)) {
+                           task_rlimit(p, RLIMIT_MSGQUEUE)) {
                                spin_unlock(&mq_lock);
                                goto out_inode;
                        }

diff --git a/ipc/shm.c b/ipc/shm.c
index 9d855ae..4714b52 100644 (file)
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -768,7 +768,7 @@ SYSCALL_DEFINE3(shmctl, int, shmid, int, cmd, struct shmid_ds __user *, buf)
                        if (euid != shp->shm_perm.uid &&
                            euid != shp->shm_perm.cuid)
                                goto out_unlock;
-                       if (cmd == SHM_LOCK && !rlim_get_cur(RLIMIT_MEMLOCK))
+                       if (cmd == SHM_LOCK && !rlimit(RLIMIT_MEMLOCK))
                                goto out_unlock;
                }
 

diff --git a/kernel/fork.c b/kernel/fork.c
index 9f0773d..a20889d 100644 (file)
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1030,7 +1030,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
 #endif
        retval = -EAGAIN;
        if (atomic_read(&p->real_cred->user->processes) >=
-                       task_rlim_get_cur(p, RLIMIT_NPROC)) {
+                       task_rlimit(p, RLIMIT_NPROC)) {
                if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
                    p->real_cred->user != INIT_USER)
                        goto bad_fork_free;

diff --git a/kernel/perf_event.c b/kernel/perf_event.c
index e4847e8..8890120 100644 (file)
--- a/kernel/perf_event.c
+++ b/kernel/perf_event.c
@@ -2421,7 +2421,7 @@ static int perf_mmap(struct file *file, struct vm_area_struct *vma)
        if (user_locked > user_lock_limit)
                extra = user_locked - user_lock_limit;
 
-       lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+       lock_limit = rlimit(RLIMIT_MEMLOCK);
        lock_limit >>= PAGE_SHIFT;
        locked = vma->vm_mm->locked_vm + extra;
 

diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 79d4cb3..11dc3f0 100644 (file)
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -1485,7 +1485,7 @@ void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx,
                 * If the RLIMIT_CPU timer will expire before the
                 * ITIMER_PROF timer, we have nothing else to do.
                 */
-               if (task_rlim_get_cur(tsk, RLIMIT_CPU)
+               if (task_rlimit(tsk, RLIMIT_CPU)
                    < cputime_to_secs(*newval))
                        return;
        }

diff --git a/kernel/sched.c b/kernel/sched.c
index 386df6c..1b23692 100644 (file)
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -6096,7 +6096,7 @@ int can_nice(const struct task_struct *p, const int nice)
        /* convert nice value [19,-20] to rlimit style value [1,40] */
        int nice_rlim = 20 - nice;
 
-       return (nice_rlim <= task_rlim_get_cur(p, RLIMIT_NICE) ||
+       return (nice_rlim <= task_rlimit(p, RLIMIT_NICE) ||
                capable(CAP_SYS_NICE));
 }
 
@@ -6281,7 +6281,7 @@ recheck:
 
                        if (!lock_task_sighand(p, &flags))
                                return -ESRCH;
-                       rlim_rtprio = task_rlim_get_cur(p, RLIMIT_RTPRIO);
+                       rlim_rtprio = task_rlimit(p, RLIMIT_RTPRIO);
                        unlock_task_sighand(p, &flags);
 
                        /* can't set/change the rt policy */

diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index ab41715..31a5917 100644 (file)
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -1684,8 +1684,8 @@ static void watchdog(struct rq *rq, struct task_struct *p)
                return;
 
        /* max may change after cur was read, this will be fixed next tick */
-       soft = task_rlim_get_cur(p, RLIMIT_RTTIME);
-       hard = task_rlim_get_max(p, RLIMIT_RTTIME);
+       soft = task_rlimit(p, RLIMIT_RTTIME);
+       hard = task_rlimit_max(p, RLIMIT_RTTIME);
 
        if (soft != RLIM_INFINITY) {
                unsigned long next;

diff --git a/kernel/signal.c b/kernel/signal.c
index d5e5c06..f8ee0bc 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -209,7 +209,7 @@ static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
        atomic_inc(&user->sigpending);
        if (override_rlimit ||
            atomic_read(&user->sigpending) <=
-                       task_rlim_get_cur(t, RLIMIT_SIGPENDING))
+                       task_rlimit(t, RLIMIT_SIGPENDING))
                q = kmem_cache_alloc(sigqueue_cachep, flags);
        if (unlikely(q == NULL)) {
                atomic_dec(&user->sigpending);

diff --git a/kernel/sys.c b/kernel/sys.c
index 626148f..c85270d 100644 (file)
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -572,7 +572,7 @@ static int set_user(struct cred *new)
                return -EINVAL;
        }
 
-       if (atomic_read(&new_user->processes) >= rlim_get_cur(RLIMIT_NPROC) &&
+       if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) &&
                        new_user != INIT_USER) {
                free_uid(new_user);
                return -EAGAIN;
@@ -1212,61 +1212,6 @@ SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
        }
 }
 
-static int check_prlimit_permission(struct task_struct *task)
-{
-       const struct cred *cred = current_cred(), *tcred;
-       int ret = 0;
-
-       rcu_read_lock();
-       tcred = __task_cred(task);
-       if ((cred->uid != tcred->euid ||
-            cred->uid != tcred->suid ||
-            cred->uid != tcred->uid  ||
-            cred->gid != tcred->egid ||
-            cred->gid != tcred->sgid ||
-            cred->gid != tcred->gid) &&
-            !capable(CAP_SYS_RESOURCE)) {
-               ret = -EPERM;
-       }
-       rcu_read_unlock();
-       return ret;
-}
-
-SYSCALL_DEFINE3(getprlimit, pid_t, pid, unsigned int, resource,
-               struct rlimit __user *, rlim)
-{
-       struct rlimit val;
-       struct task_struct *tsk;
-       int ret;
-
-       if (resource >= RLIM_NLIMITS)
-               return -EINVAL;
-
-       read_lock(&tasklist_lock);
-
-       tsk = find_task_by_vpid(pid);
-       if (!tsk || !tsk->sighand) {
-               ret = -ESRCH;
-               goto err_unlock;
-       }
-
-       ret = check_prlimit_permission(tsk);
-       if (ret)
-               goto err_unlock;
-
-       task_lock(tsk->group_leader);
-       val = tsk->signal->rlim[resource];
-       task_unlock(tsk->group_leader);
-
-       read_unlock(&tasklist_lock);
-
-       return copy_to_user(rlim, &val, sizeof(*rlim)) ? -EFAULT : 0;
-err_unlock:
-       read_unlock(&tasklist_lock);
-       return ret;
-}
-
-
 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
 
 /*
@@ -1299,6 +1244,8 @@ int do_setrlimit(struct task_struct *tsk, unsigned int resource,
        struct rlimit *old_rlim;
        int retval = 0;
 
+       if (resource >= RLIM_NLIMITS)
+               return -EINVAL;
        if (new_rlim->rlim_cur > new_rlim->rlim_max)
                return -EINVAL;
        if (resource == RLIMIT_NOFILE && new_rlim->rlim_max > sysctl_nr_open)
@@ -1358,44 +1305,11 @@ SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
 {
        struct rlimit new_rlim;
 
-       if (resource >= RLIM_NLIMITS)
-               return -EINVAL;
        if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
                return -EFAULT;
        return do_setrlimit(current, resource, &new_rlim);
 }
 
-SYSCALL_DEFINE3(setprlimit, pid_t, pid, unsigned int, resource,
-               struct rlimit __user *, rlim)
-{
-       struct task_struct *tsk;
-       struct rlimit new_rlim;
-       int ret;
-
-       if (resource >= RLIM_NLIMITS)
-               return -EINVAL;
-
-       if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
-               return -EFAULT;
-
-       rcu_read_lock();
-       tsk = find_task_by_vpid(pid);
-       if (!tsk) {
-               rcu_read_unlock();
-               return -ESRCH;
-       }
-       get_task_struct(tsk);
-       rcu_read_unlock();
-
-       ret = check_prlimit_permission(tsk);
-       if (!ret)
-               ret = do_setrlimit(tsk, resource, &new_rlim);
-
-       put_task_struct(tsk);
-
-       return ret;
-}
-
 /*
  * It would make sense to put struct rusage in the task_struct,
  * except that would make the task_struct be *really big*.  After

diff --git a/mm/filemap.c b/mm/filemap.c
index 8d9e2a0..065f13b 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2110,7 +2110,7 @@ EXPORT_SYMBOL(iov_iter_single_seg_count);
 inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk)
 {
        struct inode *inode = file->f_mapping->host;
-       unsigned long limit = rlim_get_cur(RLIMIT_FSIZE);
+       unsigned long limit = rlimit(RLIMIT_FSIZE);
 
         if (unlikely(*pos < 0))
                 return -EINVAL;

diff --git a/mm/mlock.c b/mm/mlock.c
index e340842..4cf1a10 100644 (file)
--- a/mm/mlock.c
+++ b/mm/mlock.c
@@ -25,7 +25,7 @@ int can_do_mlock(void)
 {
        if (capable(CAP_IPC_LOCK))
                return 1;
-       if (rlim_get_cur(RLIMIT_MEMLOCK) != 0)
+       if (rlimit(RLIMIT_MEMLOCK) != 0)
                return 1;
        return 0;
 }
@@ -490,7 +490,7 @@ SYSCALL_DEFINE2(mlock, unsigned long, start, size_t, len)
        locked = len >> PAGE_SHIFT;
        locked += current->mm->locked_vm;
 
-       lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+       lock_limit = rlimit(RLIMIT_MEMLOCK);
        lock_limit >>= PAGE_SHIFT;
 
        /* check against resource limits */
@@ -553,7 +553,7 @@ SYSCALL_DEFINE1(mlockall, int, flags)
 
        down_write(&current->mm->mmap_sem);
 
-       lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+       lock_limit = rlimit(RLIMIT_MEMLOCK);
        lock_limit >>= PAGE_SHIFT;
 
        ret = -ENOMEM;
@@ -587,7 +587,7 @@ int user_shm_lock(size_t size, struct user_struct *user)
        int allowed = 0;
 
        locked = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
-       lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+       lock_limit = rlimit(RLIMIT_MEMLOCK);
        if (lock_limit == RLIM_INFINITY)
                allowed = 1;
        lock_limit >>= PAGE_SHIFT;

diff --git a/mm/mmap.c b/mm/mmap.c
index f560ee9..51eb770 100644 (file)
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -267,7 +267,7 @@ SYSCALL_DEFINE1(brk, unsigned long, brk)
         * segment grow beyond its set limit the in case where the limit is
         * not page aligned -Ram Gupta
         */
-       rlim = rlim_get_cur(RLIMIT_DATA);
+       rlim = rlimit(RLIMIT_DATA);
        if (rlim < RLIM_INFINITY && (brk - mm->start_brk) +
                        (mm->end_data - mm->start_data) > rlim)
                goto out;
@@ -991,7 +991,7 @@ unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
                unsigned long locked, lock_limit;
                locked = len >> PAGE_SHIFT;
                locked += mm->locked_vm;
-               lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+               lock_limit = rlimit(RLIMIT_MEMLOCK);
                lock_limit >>= PAGE_SHIFT;
                if (locked > lock_limit && !capable(CAP_IPC_LOCK))
                        return -EAGAIN;
@@ -2093,7 +2093,7 @@ unsigned long do_brk(unsigned long addr, unsigned long len)
                unsigned long locked, lock_limit;
                locked = len >> PAGE_SHIFT;
                locked += mm->locked_vm;
-               lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+               lock_limit = rlimit(RLIMIT_MEMLOCK);
                lock_limit >>= PAGE_SHIFT;
                if (locked > lock_limit && !capable(CAP_IPC_LOCK))
                        return -EAGAIN;
@@ -2312,7 +2312,7 @@ int may_expand_vm(struct mm_struct *mm, unsigned long npages)
        unsigned long cur = mm->total_vm;       /* pages */
        unsigned long lim;
 
-       lim = rlim_get_cur(RLIMIT_AS) >> PAGE_SHIFT;
+       lim = rlimit(RLIMIT_AS) >> PAGE_SHIFT;
 
        if (cur + npages > lim)
                return 0;

diff --git a/mm/mremap.c b/mm/mremap.c
index 00a384c..d6740a1 100644 (file)
--- a/mm/mremap.c
+++ b/mm/mremap.c
@@ -358,7 +358,7 @@ unsigned long do_mremap(unsigned long addr,
        if (vma->vm_flags & VM_LOCKED) {
                unsigned long locked, lock_limit;
                locked = mm->locked_vm << PAGE_SHIFT;
-               lock_limit = rlim_get_cur(RLIMIT_MEMLOCK);
+               lock_limit = rlimit(RLIMIT_MEMLOCK);
                locked += new_len - old_len;
                ret = -EAGAIN;
                if (locked > lock_limit && !capable(CAP_IPC_LOCK))

diff --git a/perfmon/perfmon_res.c b/perfmon/perfmon_res.c
index 4762c80..9c75e32 100644 (file)
--- a/perfmon/perfmon_res.c
+++ b/perfmon/perfmon_res.c
@@ -111,11 +111,11 @@ int pfm_smpl_buf_space_acquire(struct pfm_context *ctx, size_t size)
        locked  = mm->locked_vm << PAGE_SHIFT;
        locked += size;
 
-       if (locked > rlim_get_cur(RLIMIT_MEMLOCK)) {
+       if (locked > rlimit(RLIMIT_MEMLOCK)) {
 
                PFM_DBG("RLIMIT_MEMLOCK reached ask_locked=%lu rlim_cur=%lu",
                        locked,
-                       rlim_get_cur(RLIMIT_MEMLOCK));
+                       rlimit(RLIMIT_MEMLOCK));
 
                up_write(&mm->mmap_sem);
                mmput(mm);