Merge branch 'next-seccomp' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 31 Jan 2018 21:44:45 +0000 (13:44 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 31 Jan 2018 21:44:45 +0000 (13:44 -0800)
Pull seccomp updates from James Morris:
 "Add support for retrieving seccomp metadata"

* 'next-seccomp' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security:
  ptrace, seccomp: add support for retrieving seccomp metadata
  seccomp: hoist out filter resolving logic

1  2 
kernel/ptrace.c
kernel/seccomp.c

diff --combined kernel/ptrace.c
index f3c82e26b995877709b34fa77bf5b569be1658ee,58291e9f3276b23cff0f67e770f914cff02e9ba3..5e1d713c8e61f92e77fd0b3e4f46a678f2500a15
@@@ -659,7 -659,7 +659,7 @@@ static int ptrace_getsiginfo(struct tas
        if (lock_task_sighand(child, &flags)) {
                error = -EINVAL;
                if (likely(child->last_siginfo != NULL)) {
 -                      *info = *child->last_siginfo;
 +                      copy_siginfo(info, child->last_siginfo);
                        error = 0;
                }
                unlock_task_sighand(child, &flags);
@@@ -675,7 -675,7 +675,7 @@@ static int ptrace_setsiginfo(struct tas
        if (lock_task_sighand(child, &flags)) {
                error = -EINVAL;
                if (likely(child->last_siginfo != NULL)) {
 -                      *child->last_siginfo = *info;
 +                      copy_siginfo(child->last_siginfo, info);
                        error = 0;
                }
                unlock_task_sighand(child, &flags);
@@@ -1092,6 -1092,10 +1092,10 @@@ int ptrace_request(struct task_struct *
                ret = seccomp_get_filter(child, addr, datavp);
                break;
  
+       case PTRACE_SECCOMP_GET_METADATA:
+               ret = seccomp_get_metadata(child, addr, datavp);
+               break;
        default:
                break;
        }
@@@ -1226,6 -1230,7 +1230,6 @@@ int compat_ptrace_request(struct task_s
                break;
  
        case PTRACE_SETSIGINFO:
 -              memset(&siginfo, 0, sizeof siginfo);
                if (copy_siginfo_from_user32(
                            &siginfo, (struct compat_siginfo __user *) datap))
                        ret = -EFAULT;
diff --combined kernel/seccomp.c
index 3153c9ea51bfb5b7bc28cb8773c5f24030df1556,61bd9dc260c8ea6cc880e6f27bd552eb2e075586..940fa408a288f778fed1e61fa004cbf6e8fdac75
@@@ -515,7 -515,7 +515,7 @@@ void put_seccomp_filter(struct task_str
  
  static void seccomp_init_siginfo(siginfo_t *info, int syscall, int reason)
  {
 -      memset(info, 0, sizeof(*info));
 +      clear_siginfo(info);
        info->si_signo = SIGSYS;
        info->si_code = SYS_SECCOMP;
        info->si_call_addr = (void __user *)KSTK_EIP(current);
@@@ -978,49 -978,68 +978,68 @@@ long prctl_set_seccomp(unsigned long se
  }
  
  #if defined(CONFIG_SECCOMP_FILTER) && defined(CONFIG_CHECKPOINT_RESTORE)
long seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
-                       void __user *data)
static struct seccomp_filter *get_nth_filter(struct task_struct *task,
+                                            unsigned long filter_off)
  {
-       struct seccomp_filter *filter;
-       struct sock_fprog_kern *fprog;
-       long ret;
-       unsigned long count = 0;
-       if (!capable(CAP_SYS_ADMIN) ||
-           current->seccomp.mode != SECCOMP_MODE_DISABLED) {
-               return -EACCES;
-       }
+       struct seccomp_filter *orig, *filter;
+       unsigned long count;
  
+       /*
+        * Note: this is only correct because the caller should be the (ptrace)
+        * tracer of the task, otherwise lock_task_sighand is needed.
+        */
        spin_lock_irq(&task->sighand->siglock);
        if (task->seccomp.mode != SECCOMP_MODE_FILTER) {
-               ret = -EINVAL;
-               goto out;
+               spin_unlock_irq(&task->sighand->siglock);
+               return ERR_PTR(-EINVAL);
        }
  
-       filter = task->seccomp.filter;
-       while (filter) {
-               filter = filter->prev;
+       orig = task->seccomp.filter;
+       __get_seccomp_filter(orig);
+       spin_unlock_irq(&task->sighand->siglock);
+       count = 0;
+       for (filter = orig; filter; filter = filter->prev)
                count++;
-       }
  
        if (filter_off >= count) {
-               ret = -ENOENT;
+               filter = ERR_PTR(-ENOENT);
                goto out;
        }
-       count -= filter_off;
  
-       filter = task->seccomp.filter;
-       while (filter && count > 1) {
-               filter = filter->prev;
+       count -= filter_off;
+       for (filter = orig; filter && count > 1; filter = filter->prev)
                count--;
-       }
  
        if (WARN_ON(count != 1 || !filter)) {
-               /* The filter tree shouldn't shrink while we're using it. */
-               ret = -ENOENT;
+               filter = ERR_PTR(-ENOENT);
                goto out;
        }
  
+       __get_seccomp_filter(filter);
+ out:
+       __put_seccomp_filter(orig);
+       return filter;
+ }
+ long seccomp_get_filter(struct task_struct *task, unsigned long filter_off,
+                       void __user *data)
+ {
+       struct seccomp_filter *filter;
+       struct sock_fprog_kern *fprog;
+       long ret;
+       if (!capable(CAP_SYS_ADMIN) ||
+           current->seccomp.mode != SECCOMP_MODE_DISABLED) {
+               return -EACCES;
+       }
+       filter = get_nth_filter(task, filter_off);
+       if (IS_ERR(filter))
+               return PTR_ERR(filter);
        fprog = filter->prog->orig_prog;
        if (!fprog) {
                /* This must be a new non-cBPF filter, since we save
        if (!data)
                goto out;
  
-       __get_seccomp_filter(filter);
-       spin_unlock_irq(&task->sighand->siglock);
        if (copy_to_user(data, fprog->filter, bpf_classic_proglen(fprog)))
                ret = -EFAULT;
  
+ out:
        __put_seccomp_filter(filter);
        return ret;
+ }
  
- out:
-       spin_unlock_irq(&task->sighand->siglock);
+ long seccomp_get_metadata(struct task_struct *task,
+                         unsigned long size, void __user *data)
+ {
+       long ret;
+       struct seccomp_filter *filter;
+       struct seccomp_metadata kmd = {};
+       if (!capable(CAP_SYS_ADMIN) ||
+           current->seccomp.mode != SECCOMP_MODE_DISABLED) {
+               return -EACCES;
+       }
+       size = min_t(unsigned long, size, sizeof(kmd));
+       if (copy_from_user(&kmd, data, size))
+               return -EFAULT;
+       filter = get_nth_filter(task, kmd.filter_off);
+       if (IS_ERR(filter))
+               return PTR_ERR(filter);
+       memset(&kmd, 0, sizeof(kmd));
+       if (filter->log)
+               kmd.flags |= SECCOMP_FILTER_FLAG_LOG;
+       ret = size;
+       if (copy_to_user(data, &kmd, size))
+               ret = -EFAULT;
+       __put_seccomp_filter(filter);
        return ret;
  }
  #endif