signal.c (bdfa75ad70e93633e18b1ed2b3866c01aa9bf9d2) signal.c (1bdda24c4af64cd2d65dec5192ab624c5fee7ca0)
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * linux/kernel/signal.c
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 *

--- 412 unchanged lines hidden (view full) ---

421 * callers hold rcu read lock.
422 *
423 * NOTE! A pending signal will hold on to the user refcount,
424 * and we get/put the refcount only when the sigpending count
425 * changes from/to zero.
426 */
427 rcu_read_lock();
428 ucounts = task_ucounts(t);
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * linux/kernel/signal.c
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 *

--- 412 unchanged lines hidden (view full) ---

421 * callers hold rcu read lock.
422 *
423 * NOTE! A pending signal will hold on to the user refcount,
424 * and we get/put the refcount only when the sigpending count
425 * changes from/to zero.
426 */
427 rcu_read_lock();
428 ucounts = task_ucounts(t);
429 sigpending = inc_rlimit_get_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING);
430 rcu_read_unlock();
431 if (!sigpending)
429 sigpending = inc_rlimit_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING, 1);
430 switch (sigpending) {
431 case 1:
432 if (likely(get_ucounts(ucounts)))
433 break;
434 fallthrough;
435 case LONG_MAX:
436 /*
437 * we need to decrease the ucount in the userns tree on any
438 * failure to avoid counts leaking.
439 */
440 dec_rlimit_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING, 1);
441 rcu_read_unlock();
432 return NULL;
442 return NULL;
443 }
444 rcu_read_unlock();
433
434 if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING))) {
435 q = kmem_cache_alloc(sigqueue_cachep, gfp_flags);
436 } else {
437 print_dropped_signal(sig);
438 }
439
440 if (unlikely(q == NULL)) {
445
446 if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING))) {
447 q = kmem_cache_alloc(sigqueue_cachep, gfp_flags);
448 } else {
449 print_dropped_signal(sig);
450 }
451
452 if (unlikely(q == NULL)) {
441 dec_rlimit_put_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING);
453 if (dec_rlimit_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING, 1))
454 put_ucounts(ucounts);
442 } else {
443 INIT_LIST_HEAD(&q->list);
444 q->flags = sigqueue_flags;
445 q->ucounts = ucounts;
446 }
447 return q;
448}
449
450static void __sigqueue_free(struct sigqueue *q)
451{
452 if (q->flags & SIGQUEUE_PREALLOC)
453 return;
455 } else {
456 INIT_LIST_HEAD(&q->list);
457 q->flags = sigqueue_flags;
458 q->ucounts = ucounts;
459 }
460 return q;
461}
462
463static void __sigqueue_free(struct sigqueue *q)
464{
465 if (q->flags & SIGQUEUE_PREALLOC)
466 return;
454 if (q->ucounts) {
455 dec_rlimit_put_ucounts(q->ucounts, UCOUNT_RLIMIT_SIGPENDING);
467 if (q->ucounts && dec_rlimit_ucounts(q->ucounts, UCOUNT_RLIMIT_SIGPENDING, 1)) {
468 put_ucounts(q->ucounts);
456 q->ucounts = NULL;
457 }
458 kmem_cache_free(sigqueue_cachep, q);
459}
460
461void flush_sigqueue(struct sigpending *queue)
462{
463 struct sigqueue *q;

--- 3669 unchanged lines hidden (view full) ---

4133 flush_sigqueue_mask(&mask, &t->pending);
4134 }
4135 }
4136
4137 spin_unlock_irq(&p->sighand->siglock);
4138 return 0;
4139}
4140
469 q->ucounts = NULL;
470 }
471 kmem_cache_free(sigqueue_cachep, q);
472}
473
474void flush_sigqueue(struct sigpending *queue)
475{
476 struct sigqueue *q;

--- 3669 unchanged lines hidden (view full) ---

4146 flush_sigqueue_mask(&mask, &t->pending);
4147 }
4148 }
4149
4150 spin_unlock_irq(&p->sighand->siglock);
4151 return 0;
4152}
4153
4154#ifdef CONFIG_DYNAMIC_SIGFRAME
4155static inline void sigaltstack_lock(void)
4156 __acquires(&current->sighand->siglock)
4157{
4158 spin_lock_irq(&current->sighand->siglock);
4159}
4160
4161static inline void sigaltstack_unlock(void)
4162 __releases(&current->sighand->siglock)
4163{
4164 spin_unlock_irq(&current->sighand->siglock);
4165}
4166#else
4167static inline void sigaltstack_lock(void) { }
4168static inline void sigaltstack_unlock(void) { }
4169#endif
4170
4141static int
4142do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp,
4143 size_t min_ss_size)
4144{
4145 struct task_struct *t = current;
4171static int
4172do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp,
4173 size_t min_ss_size)
4174{
4175 struct task_struct *t = current;
4176 int ret = 0;
4146
4147 if (oss) {
4148 memset(oss, 0, sizeof(stack_t));
4149 oss->ss_sp = (void __user *) t->sas_ss_sp;
4150 oss->ss_size = t->sas_ss_size;
4151 oss->ss_flags = sas_ss_flags(sp) |
4152 (current->sas_ss_flags & SS_FLAG_BITS);
4153 }

--- 7 unchanged lines hidden (view full) ---

4161 if (unlikely(on_sig_stack(sp)))
4162 return -EPERM;
4163
4164 ss_mode = ss_flags & ~SS_FLAG_BITS;
4165 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
4166 ss_mode != 0))
4167 return -EINVAL;
4168
4177
4178 if (oss) {
4179 memset(oss, 0, sizeof(stack_t));
4180 oss->ss_sp = (void __user *) t->sas_ss_sp;
4181 oss->ss_size = t->sas_ss_size;
4182 oss->ss_flags = sas_ss_flags(sp) |
4183 (current->sas_ss_flags & SS_FLAG_BITS);
4184 }

--- 7 unchanged lines hidden (view full) ---

4192 if (unlikely(on_sig_stack(sp)))
4193 return -EPERM;
4194
4195 ss_mode = ss_flags & ~SS_FLAG_BITS;
4196 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
4197 ss_mode != 0))
4198 return -EINVAL;
4199
4200 sigaltstack_lock();
4169 if (ss_mode == SS_DISABLE) {
4170 ss_size = 0;
4171 ss_sp = NULL;
4172 } else {
4173 if (unlikely(ss_size < min_ss_size))
4201 if (ss_mode == SS_DISABLE) {
4202 ss_size = 0;
4203 ss_sp = NULL;
4204 } else {
4205 if (unlikely(ss_size < min_ss_size))
4174 return -ENOMEM;
4206 ret = -ENOMEM;
4207 if (!sigaltstack_size_valid(ss_size))
4208 ret = -ENOMEM;
4175 }
4209 }
4176
4177 t->sas_ss_sp = (unsigned long) ss_sp;
4178 t->sas_ss_size = ss_size;
4179 t->sas_ss_flags = ss_flags;
4210 if (!ret) {
4211 t->sas_ss_sp = (unsigned long) ss_sp;
4212 t->sas_ss_size = ss_size;
4213 t->sas_ss_flags = ss_flags;
4214 }
4215 sigaltstack_unlock();
4180 }
4216 }
4181 return 0;
4217 return ret;
4182}
4183
4184SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
4185{
4186 stack_t new, old;
4187 int err;
4188 if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
4189 return -EFAULT;

--- 568 unchanged lines hidden --- 		4218}
4219
4220SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
4221{
4222 stack_t new, old;
4223 int err;
4224 if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
4225 return -EFAULT;

--- 568 unchanged lines hidden ---