* [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage @ 2010-01-27 16:34 Jiri Slaby 2010-01-27 16:34 ` [PATCH 2/2] core: use helpers for rlimits Jiri Slaby 2010-01-28 1:13 ` [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Andrew Morton 0 siblings, 2 replies; 6+ messages in thread From: Jiri Slaby @ 2010-01-27 16:34 UTC (permalink / raw) To: mingo; +Cc: akpm, linux-kernel, jirislaby, Peter Zijlstra Fetch rlimit (both hard and soft) values only once and work on them. It removes many accesses through sig structure and makes the code cleaner. Mostly a preparation for writable resource limits support. Signed-off-by: Jiri Slaby <jslaby@suse.cz> Cc: Ingo Molnar <mingo@elte.hu> Cc: Peter Zijlstra <peterz@infradead.org> --- kernel/posix-cpu-timers.c | 32 +++++++++++++++++--------------- 1 files changed, 17 insertions(+), 15 deletions(-) diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c index 9931a64..92c4fa1 100644 --- a/kernel/posix-cpu-timers.c +++ b/kernel/posix-cpu-timers.c @@ -982,6 +982,7 @@ static void check_thread_timers(struct task_struct *tsk, int maxfire; struct list_head *timers = tsk->cpu_timers; struct signal_struct *const sig = tsk->signal; + unsigned long soft; maxfire = 20; tsk->cputime_expires.prof_exp = cputime_zero; @@ -1030,9 +1031,9 @@ static void check_thread_timers(struct task_struct *tsk, /* * Check for the special case thread timers. */ - if (sig->rlim[RLIMIT_RTTIME].rlim_cur != RLIM_INFINITY) { + soft = sig->rlim[RLIMIT_RTTIME].rlim_cur; + if (soft != RLIM_INFINITY) { unsigned long hard = sig->rlim[RLIMIT_RTTIME].rlim_max; - unsigned long *soft = &sig->rlim[RLIMIT_RTTIME].rlim_cur; if (hard != RLIM_INFINITY && tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) { @@ -1043,14 +1044,13 @@ static void check_thread_timers(struct task_struct *tsk, __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk); return; } - if (tsk->rt.timeout > DIV_ROUND_UP(*soft, USEC_PER_SEC/HZ)) { + if (tsk->rt.timeout > DIV_ROUND_UP(soft, USEC_PER_SEC/HZ)) { /* * At the soft limit, send a SIGXCPU every second. */ - if (sig->rlim[RLIMIT_RTTIME].rlim_cur - < sig->rlim[RLIMIT_RTTIME].rlim_max) { - sig->rlim[RLIMIT_RTTIME].rlim_cur += - USEC_PER_SEC; + if (soft < hard) { + soft += USEC_PER_SEC; + sig->rlim[RLIMIT_RTTIME].rlim_cur = soft; } printk(KERN_INFO "RT Watchdog Timeout: %s[%d]\n", @@ -1125,13 +1125,14 @@ static void check_process_timers(struct task_struct *tsk, unsigned long long sum_sched_runtime, sched_expires; struct list_head *timers = sig->cpu_timers; struct task_cputime cputime; + unsigned long cpu_cur_lim = sig->rlim[RLIMIT_CPU].rlim_cur; /* * Don't sample the current process CPU clocks if there are no timers. */ if (list_empty(&timers[CPUCLOCK_PROF]) && cputime_eq(sig->it[CPUCLOCK_PROF].expires, cputime_zero) && - sig->rlim[RLIMIT_CPU].rlim_cur == RLIM_INFINITY && + cpu_cur_lim == RLIM_INFINITY && list_empty(&timers[CPUCLOCK_VIRT]) && cputime_eq(sig->it[CPUCLOCK_VIRT].expires, cputime_zero) && list_empty(&timers[CPUCLOCK_SCHED])) { @@ -1198,10 +1199,11 @@ static void check_process_timers(struct task_struct *tsk, check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime, SIGVTALRM); - if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) { + if (cpu_cur_lim != RLIM_INFINITY) { unsigned long psecs = cputime_to_secs(ptime); + unsigned long hard = sig->rlim[RLIMIT_CPU].rlim_max; cputime_t x; - if (psecs >= sig->rlim[RLIMIT_CPU].rlim_max) { + if (psecs >= hard) { /* * At the hard limit, we just die. * No need to calculate anything else now. @@ -1209,17 +1211,17 @@ static void check_process_timers(struct task_struct *tsk, __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk); return; } - if (psecs >= sig->rlim[RLIMIT_CPU].rlim_cur) { + if (psecs >= cpu_cur_lim) { /* * At the soft limit, send a SIGXCPU every second. */ __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk); - if (sig->rlim[RLIMIT_CPU].rlim_cur - < sig->rlim[RLIMIT_CPU].rlim_max) { - sig->rlim[RLIMIT_CPU].rlim_cur++; + if (cpu_cur_lim < hard) { + cpu_cur_lim++; + sig->rlim[RLIMIT_CPU].rlim_cur = cpu_cur_lim; } } - x = secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur); + x = secs_to_cputime(cpu_cur_lim); if (cputime_eq(prof_expires, cputime_zero) || cputime_lt(x, prof_expires)) { prof_expires = x; -- 1.6.6.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] core: use helpers for rlimits 2010-01-27 16:34 [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Jiri Slaby @ 2010-01-27 16:34 ` Jiri Slaby 2010-01-28 1:13 ` [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Andrew Morton 1 sibling, 0 replies; 6+ messages in thread From: Jiri Slaby @ 2010-01-27 16:34 UTC (permalink / raw) To: mingo; +Cc: akpm, linux-kernel, jirislaby Make sure compiler won't do weird things with limits. E.g. fetching them twice may return 2 different values after writable limits are implemented. I.e. either use rlimit helpers added in 3e10e716abf3c71bdb5d86b8f507f9e72236c9cd or ACCESS_ONCE if not applicable. Signed-off-by: Jiri Slaby <jslaby@suse.cz> Cc: Ingo Molnar <mingo@elte.hu> Cc: Andrew Morton <akpm@linux-foundation.org> --- kernel/fork.c | 10 ++++++---- kernel/perf_event.c | 2 +- kernel/posix-cpu-timers.c | 16 +++++++++------- kernel/sched.c | 4 ++-- kernel/sched_rt.c | 5 +++-- kernel/signal.c | 2 +- kernel/sys.c | 3 +-- 7 files changed, 23 insertions(+), 19 deletions(-) diff --git a/kernel/fork.c b/kernel/fork.c index 3d66564..6fca655 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -824,12 +824,14 @@ void __cleanup_sighand(struct sighand_struct *sighand) */ static void posix_cpu_timers_init_group(struct signal_struct *sig) { + unsigned long cpu_limit; + /* Thread group counters. */ thread_group_cputime_init(sig); - if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) { - sig->cputime_expires.prof_exp = - secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur); + cpu_limit = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); + if (cpu_limit != RLIM_INFINITY) { + sig->cputime_expires.prof_exp = secs_to_cputime(cpu_limit); sig->cputimer.running = 1; } @@ -999,7 +1001,7 @@ static struct task_struct *copy_process(unsigned long clone_flags, #endif retval = -EAGAIN; if (atomic_read(&p->real_cred->user->processes) >= - p->signal->rlim[RLIMIT_NPROC].rlim_cur) { + 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 faaa9e6..09e92ba 100644 --- a/kernel/perf_event.c +++ b/kernel/perf_event.c @@ -2463,7 +2463,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 = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur; + 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 92c4fa1..be3fc00 100644 --- a/kernel/posix-cpu-timers.c +++ b/kernel/posix-cpu-timers.c @@ -639,7 +639,7 @@ static void arm_timer(struct k_itimer *timer, union cpu_time_count now) if (expires_le(sig->it[CPUCLOCK_PROF].expires, exp->cpu)) break; - i = sig->rlim[RLIMIT_CPU].rlim_cur; + i = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); if (i != RLIM_INFINITY && i <= cputime_to_secs(exp->cpu)) break; @@ -1031,9 +1031,10 @@ static void check_thread_timers(struct task_struct *tsk, /* * Check for the special case thread timers. */ - soft = sig->rlim[RLIMIT_RTTIME].rlim_cur; + soft = ACCESS_ONCE(sig->rlim[RLIMIT_RTTIME].rlim_cur); if (soft != RLIM_INFINITY) { - unsigned long hard = sig->rlim[RLIMIT_RTTIME].rlim_max; + unsigned long hard = ACCESS_ONCE(sig->rlim[RLIMIT_RTTIME]. + rlim_max); if (hard != RLIM_INFINITY && tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) { @@ -1125,7 +1126,7 @@ static void check_process_timers(struct task_struct *tsk, unsigned long long sum_sched_runtime, sched_expires; struct list_head *timers = sig->cpu_timers; struct task_cputime cputime; - unsigned long cpu_cur_lim = sig->rlim[RLIMIT_CPU].rlim_cur; + unsigned long cpu_cur_lim = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); /* * Don't sample the current process CPU clocks if there are no timers. @@ -1201,7 +1202,8 @@ static void check_process_timers(struct task_struct *tsk, if (cpu_cur_lim != RLIM_INFINITY) { unsigned long psecs = cputime_to_secs(ptime); - unsigned long hard = sig->rlim[RLIMIT_CPU].rlim_max; + unsigned long hard = + ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_max); cputime_t x; if (psecs >= hard) { /* @@ -1388,7 +1390,7 @@ static inline int fastpath_timer_check(struct task_struct *tsk) return 1; } - return sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY; + return ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur) != RLIM_INFINITY; } /* @@ -1486,7 +1488,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 (tsk->signal->rlim[RLIMIT_CPU].rlim_cur + if (task_rlimit(tsk, RLIMIT_CPU) < cputime_to_secs(*newval)) return; } diff --git a/kernel/sched.c b/kernel/sched.c index 86b49f9..467fc1a 100644 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -6138,7 +6138,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 <= p->signal->rlim[RLIMIT_NICE].rlim_cur || + return (nice_rlim <= task_rlimit(p, RLIMIT_NICE) || capable(CAP_SYS_NICE)); } @@ -6315,7 +6315,7 @@ recheck: if (!lock_task_sighand(p, &flags)) return -ESRCH; - rlim_rtprio = p->signal->rlim[RLIMIT_RTPRIO].rlim_cur; + 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 f48328a..552c71e 100644 --- a/kernel/sched_rt.c +++ b/kernel/sched_rt.c @@ -1670,8 +1670,9 @@ static void watchdog(struct rq *rq, struct task_struct *p) if (!p->signal) return; - soft = p->signal->rlim[RLIMIT_RTTIME].rlim_cur; - hard = p->signal->rlim[RLIMIT_RTTIME].rlim_max; + /* max may change after cur was read, this will be fixed next tick */ + 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 278704b..2213bb4 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -228,7 +228,7 @@ __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimi if (override_rlimit || atomic_read(&user->sigpending) <= - t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur) { + task_rlimit(t, RLIMIT_SIGPENDING)) { q = kmem_cache_alloc(sigqueue_cachep, flags); } else { print_dropped_signal(sig); diff --git a/kernel/sys.c b/kernel/sys.c index ef286ab..c9da91a 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -574,8 +574,7 @@ static int set_user(struct cred *new) return -EINVAL; } - if (atomic_read(&new_user->processes) >= - current->signal->rlim[RLIMIT_NPROC].rlim_cur && + if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) && new_user != INIT_USER) { free_uid(new_user); return -EAGAIN; -- 1.6.6.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage 2010-01-27 16:34 [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Jiri Slaby 2010-01-27 16:34 ` [PATCH 2/2] core: use helpers for rlimits Jiri Slaby @ 2010-01-28 1:13 ` Andrew Morton 2010-01-28 6:23 ` Jiri Slaby 1 sibling, 1 reply; 6+ messages in thread From: Andrew Morton @ 2010-01-28 1:13 UTC (permalink / raw) To: Jiri Slaby; +Cc: mingo, linux-kernel, jirislaby, Peter Zijlstra On Wed, 27 Jan 2010 17:34:30 +0100 Jiri Slaby <jslaby@suse.cz> wrote: > Fetch rlimit (both hard and soft) values only once and work on them. > It removes many accesses through sig structure and makes the code > cleaner. The patch doesn't apply for me in semi-serious ways because I applied rather a lot of timer-related patches: timer-stats-fix-del_timer_sync-and-try_to_del_timer_sync.patch posix-cpu-timers-reset-expire-cache-when-no-timer-is-running.patch hrtimer-correct-a-few-numbers-in-comments.patch clockevents-ensure-taht-min_delta_ns-is-increased-in-error-path.patch clocksource-add-argument-to-resume-callback.patch clocksource-start-cmt-at-clocksource-resume.patch clocksource-add-suspend-callback.patch posix-timersc-dont-export-local-functions.patch timers-introduce-the-concept-of-timer-slack-for-legacy-timers.patch cpu-timers-simplify-rlimit_cpu-handling.patch cpu-timers-cleanup-arm_timer.patch cpu-timers-return-correct-previous-timer-reload-value.patch cpu-timers-change-sigev_none-timer-implementation.patch cpu-timers-assure-to-not-iterate-over-all-threads-in-fastpath_timer_check.patch cpu-timers-optimize-run_posix_cpu_timers.patch (The above patches are up to six months old. Something isn't working right). ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage 2010-01-28 1:13 ` [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Andrew Morton @ 2010-01-28 6:23 ` Jiri Slaby 2010-01-28 22:04 ` Jiri Slaby 2010-01-28 22:04 ` [PATCH 2/2] core: use helpers for rlimits Jiri Slaby 0 siblings, 2 replies; 6+ messages in thread From: Jiri Slaby @ 2010-01-28 6:23 UTC (permalink / raw) To: Andrew Morton; +Cc: mingo, linux-kernel, Peter Zijlstra On 01/28/2010 02:13 AM, Andrew Morton wrote: > posix-timersc-dont-export-local-functions.patch > cpu-timers-simplify-rlimit_cpu-handling.patch > cpu-timers-cleanup-arm_timer.patch > cpu-timers-return-correct-previous-timer-reload-value.patch > cpu-timers-change-sigev_none-timer-implementation.patch > cpu-timers-assure-to-not-iterate-over-all-threads-in-fastpath_timer_check.patch > cpu-timers-optimize-run_posix_cpu_timers.patch I don't have these in the current mmotm. > (The above patches are up to six months old. Something isn't working right). Could you submit a new mmotm, please? -- js ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage 2010-01-28 6:23 ` Jiri Slaby @ 2010-01-28 22:04 ` Jiri Slaby 2010-01-28 22:04 ` [PATCH 2/2] core: use helpers for rlimits Jiri Slaby 1 sibling, 0 replies; 6+ messages in thread From: Jiri Slaby @ 2010-01-28 22:04 UTC (permalink / raw) To: akpm; +Cc: linux-kernel, jirislaby, Ingo Molnar, Peter Zijlstra Rebased on the top of mmotm 2010-01-28-01-36. Hopefully this time it will work out. -- Fetch rlimit (both hard and soft) values only once and work on them. It removes many accesses through sig structure and makes the code cleaner. Mostly a preparation for writable resource limits support. Signed-off-by: Jiri Slaby <jslaby@suse.cz> Cc: Ingo Molnar <mingo@elte.hu> Cc: Peter Zijlstra <peterz@infradead.org> --- kernel/posix-cpu-timers.c | 32 +++++++++++++++++--------------- 1 files changed, 17 insertions(+), 15 deletions(-) diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c index ffba8f4..417fe38 100644 --- a/kernel/posix-cpu-timers.c +++ b/kernel/posix-cpu-timers.c @@ -917,6 +917,7 @@ static void check_thread_timers(struct task_struct *tsk, int maxfire; struct list_head *timers = tsk->cpu_timers; struct signal_struct *const sig = tsk->signal; + unsigned long soft; maxfire = 20; tsk->cputime_expires.prof_exp = cputime_zero; @@ -965,9 +966,9 @@ static void check_thread_timers(struct task_struct *tsk, /* * Check for the special case thread timers. */ - if (sig->rlim[RLIMIT_RTTIME].rlim_cur != RLIM_INFINITY) { + soft = sig->rlim[RLIMIT_RTTIME].rlim_cur; + if (soft != RLIM_INFINITY) { unsigned long hard = sig->rlim[RLIMIT_RTTIME].rlim_max; - unsigned long *soft = &sig->rlim[RLIMIT_RTTIME].rlim_cur; if (hard != RLIM_INFINITY && tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) { @@ -978,14 +979,13 @@ static void check_thread_timers(struct task_struct *tsk, __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk); return; } - if (tsk->rt.timeout > DIV_ROUND_UP(*soft, USEC_PER_SEC/HZ)) { + if (tsk->rt.timeout > DIV_ROUND_UP(soft, USEC_PER_SEC/HZ)) { /* * At the soft limit, send a SIGXCPU every second. */ - if (sig->rlim[RLIMIT_RTTIME].rlim_cur - < sig->rlim[RLIMIT_RTTIME].rlim_max) { - sig->rlim[RLIMIT_RTTIME].rlim_cur += - USEC_PER_SEC; + if (soft < hard) { + soft += USEC_PER_SEC; + sig->rlim[RLIMIT_RTTIME].rlim_cur = soft; } printk(KERN_INFO "RT Watchdog Timeout: %s[%d]\n", @@ -1070,6 +1070,7 @@ static void check_process_timers(struct task_struct *tsk, unsigned long long sum_sched_runtime, sched_expires; struct list_head *timers = sig->cpu_timers; struct task_cputime cputime; + unsigned long soft; /* * Collect the current process totals. @@ -1129,11 +1130,12 @@ static void check_process_timers(struct task_struct *tsk, SIGPROF); check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime, SIGVTALRM); - - if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) { + soft = sig->rlim[RLIMIT_CPU].rlim_cur; + if (soft != RLIM_INFINITY) { unsigned long psecs = cputime_to_secs(ptime); + unsigned long hard = sig->rlim[RLIMIT_CPU].rlim_max; cputime_t x; - if (psecs >= sig->rlim[RLIMIT_CPU].rlim_max) { + if (psecs >= hard) { /* * At the hard limit, we just die. * No need to calculate anything else now. @@ -1141,17 +1143,17 @@ static void check_process_timers(struct task_struct *tsk, __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk); return; } - if (psecs >= sig->rlim[RLIMIT_CPU].rlim_cur) { + if (psecs >= soft) { /* * At the soft limit, send a SIGXCPU every second. */ __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk); - if (sig->rlim[RLIMIT_CPU].rlim_cur - < sig->rlim[RLIMIT_CPU].rlim_max) { - sig->rlim[RLIMIT_CPU].rlim_cur++; + if (soft < hard) { + soft++; + sig->rlim[RLIMIT_CPU].rlim_cur = soft; } } - x = secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur); + x = secs_to_cputime(soft); if (cputime_eq(prof_expires, cputime_zero) || cputime_lt(x, prof_expires)) { prof_expires = x; -- 1.6.6.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH 2/2] core: use helpers for rlimits 2010-01-28 6:23 ` Jiri Slaby 2010-01-28 22:04 ` Jiri Slaby @ 2010-01-28 22:04 ` Jiri Slaby 1 sibling, 0 replies; 6+ messages in thread From: Jiri Slaby @ 2010-01-28 22:04 UTC (permalink / raw) To: akpm; +Cc: linux-kernel, jirislaby, Ingo Molnar Make sure compiler won't do weird things with limits. E.g. fetching them twice may return 2 different values after writable limits are implemented. I.e. either use rlimit helpers added in 3e10e716abf3c71bdb5d86b8f507f9e72236c9cd or ACCESS_ONCE if not applicable. Signed-off-by: Jiri Slaby <jslaby@suse.cz> Cc: Ingo Molnar <mingo@elte.hu> Cc: Andrew Morton <akpm@linux-foundation.org> --- kernel/fork.c | 10 ++++++---- kernel/perf_event.c | 2 +- kernel/posix-cpu-timers.c | 10 ++++++---- kernel/sched.c | 4 ++-- kernel/sched_rt.c | 5 +++-- kernel/signal.c | 2 +- kernel/sys.c | 3 +-- 7 files changed, 20 insertions(+), 16 deletions(-) diff --git a/kernel/fork.c b/kernel/fork.c index 3d66564..6fca655 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -824,12 +824,14 @@ void __cleanup_sighand(struct sighand_struct *sighand) */ static void posix_cpu_timers_init_group(struct signal_struct *sig) { + unsigned long cpu_limit; + /* Thread group counters. */ thread_group_cputime_init(sig); - if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) { - sig->cputime_expires.prof_exp = - secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur); + cpu_limit = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); + if (cpu_limit != RLIM_INFINITY) { + sig->cputime_expires.prof_exp = secs_to_cputime(cpu_limit); sig->cputimer.running = 1; } @@ -999,7 +1001,7 @@ static struct task_struct *copy_process(unsigned long clone_flags, #endif retval = -EAGAIN; if (atomic_read(&p->real_cred->user->processes) >= - p->signal->rlim[RLIMIT_NPROC].rlim_cur) { + 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 f1d4b25..0da8415 100644 --- a/kernel/perf_event.c +++ b/kernel/perf_event.c @@ -2481,7 +2481,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 = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur; + 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 417fe38..fd6ea9b 100644 --- a/kernel/posix-cpu-timers.c +++ b/kernel/posix-cpu-timers.c @@ -966,9 +966,10 @@ static void check_thread_timers(struct task_struct *tsk, /* * Check for the special case thread timers. */ - soft = sig->rlim[RLIMIT_RTTIME].rlim_cur; + soft = ACCESS_ONCE(sig->rlim[RLIMIT_RTTIME].rlim_cur); if (soft != RLIM_INFINITY) { - unsigned long hard = sig->rlim[RLIMIT_RTTIME].rlim_max; + unsigned long hard = + ACCESS_ONCE(sig->rlim[RLIMIT_RTTIME].rlim_max); if (hard != RLIM_INFINITY && tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) { @@ -1130,10 +1131,11 @@ static void check_process_timers(struct task_struct *tsk, SIGPROF); check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime, SIGVTALRM); - soft = sig->rlim[RLIMIT_CPU].rlim_cur; + soft = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); if (soft != RLIM_INFINITY) { unsigned long psecs = cputime_to_secs(ptime); - unsigned long hard = sig->rlim[RLIMIT_CPU].rlim_max; + unsigned long hard = + ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_max); cputime_t x; if (psecs >= hard) { /* diff --git a/kernel/sched.c b/kernel/sched.c index 854dd03..c8fd5e1 100644 --- a/kernel/sched.c +++ b/kernel/sched.c @@ -6141,7 +6141,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 <= p->signal->rlim[RLIMIT_NICE].rlim_cur || + return (nice_rlim <= task_rlimit(p, RLIMIT_NICE) || capable(CAP_SYS_NICE)); } @@ -6318,7 +6318,7 @@ recheck: if (!lock_task_sighand(p, &flags)) return -ESRCH; - rlim_rtprio = p->signal->rlim[RLIMIT_RTPRIO].rlim_cur; + 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 072b3fc..5a86793 100644 --- a/kernel/sched_rt.c +++ b/kernel/sched_rt.c @@ -1670,8 +1670,9 @@ static void watchdog(struct rq *rq, struct task_struct *p) if (!p->signal) return; - soft = p->signal->rlim[RLIMIT_RTTIME].rlim_cur; - hard = p->signal->rlim[RLIMIT_RTTIME].rlim_max; + /* max may change after cur was read, this will be fixed next tick */ + 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 278704b..2213bb4 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -228,7 +228,7 @@ __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimi if (override_rlimit || atomic_read(&user->sigpending) <= - t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur) { + task_rlimit(t, RLIMIT_SIGPENDING)) { q = kmem_cache_alloc(sigqueue_cachep, flags); } else { print_dropped_signal(sig); diff --git a/kernel/sys.c b/kernel/sys.c index ef286ab..c9da91a 100644 --- a/kernel/sys.c +++ b/kernel/sys.c @@ -574,8 +574,7 @@ static int set_user(struct cred *new) return -EINVAL; } - if (atomic_read(&new_user->processes) >= - current->signal->rlim[RLIMIT_NPROC].rlim_cur && + if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) && new_user != INIT_USER) { free_uid(new_user); return -EAGAIN; -- 1.6.6.1 ^ permalink raw reply related [flat|nested] 6+ messages in thread
end of thread, other threads:[~2010-01-28 22:04 UTC | newest] Thread overview: 6+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2010-01-27 16:34 [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Jiri Slaby 2010-01-27 16:34 ` [PATCH 2/2] core: use helpers for rlimits Jiri Slaby 2010-01-28 1:13 ` [PATCH 1/2] core: posix-cpu-timers, cleanup rlimits usage Andrew Morton 2010-01-28 6:23 ` Jiri Slaby 2010-01-28 22:04 ` Jiri Slaby 2010-01-28 22:04 ` [PATCH 2/2] core: use helpers for rlimits Jiri Slaby
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.