hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

whitespace fixes: capability syscalls 

Large chunks of 5 spaces instead of tabs.

Signed-off-by: Daniel Walker <dwalker@mvista.com>
Cc: Chris Wright <chrisw@sous-sol.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Daniel Walker 2007-10-18 03:06:08 -07:00 committed by Linus Torvalds
parent c277e63fbe
commit 314f70fd96
1 changed files with 83 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
kernel/capability.c
View File

@ -5,7 +5,7 @@
* *
* Integrated into 2.1.97+, Andrew G. Morgan <morgan@kernel.org> * Integrated into 2.1.97+, Andrew G. Morgan <morgan@kernel.org>
* 30 May 2002: Cleanup, Robert M. Love <rml@tech9.net> * 30 May 2002: Cleanup, Robert M. Love <rml@tech9.net>
*/ */
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/mm.h> #include <linux/mm.h>
@ -37,49 +37,49 @@ static DEFINE_SPINLOCK(task_capability_lock);
*/ */
asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr) asmlinkage long sys_capget(cap_user_header_t header, cap_user_data_t dataptr)
{ {
int ret = 0; int ret = 0;
pid_t pid; pid_t pid;
__u32 version; __u32 version;
struct task_struct *target; struct task_struct *target;
struct __user_cap_data_struct data; struct __user_cap_data_struct data;
if (get_user(version, &header->version)) if (get_user(version, &header->version))
return -EFAULT; return -EFAULT;
if (version != _LINUX_CAPABILITY_VERSION) { if (version != _LINUX_CAPABILITY_VERSION) {
if (put_user(_LINUX_CAPABILITY_VERSION, &header->version)) if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
return -EFAULT; return -EFAULT;
return -EINVAL; return -EINVAL;
} }
if (get_user(pid, &header->pid)) if (get_user(pid, &header->pid))
return -EFAULT; return -EFAULT;
if (pid < 0) if (pid < 0)
return -EINVAL; return -EINVAL;
spin_lock(&task_capability_lock); spin_lock(&task_capability_lock);
read_lock(&tasklist_lock); read_lock(&tasklist_lock);
if (pid && pid != current->pid) { if (pid && pid != current->pid) {
target = find_task_by_pid(pid); target = find_task_by_pid(pid);
if (!target) { if (!target) {
ret = -ESRCH; ret = -ESRCH;
goto out; goto out;
} }
} else } else
target = current; target = current;
ret = security_capget(target, &data.effective, &data.inheritable, &data.permitted); ret = security_capget(target, &data.effective, &data.inheritable, &data.permitted);
out: out:
read_unlock(&tasklist_lock); read_unlock(&tasklist_lock);
spin_unlock(&task_capability_lock); spin_unlock(&task_capability_lock);
if (!ret && copy_to_user(dataptr, &data, sizeof data)) if (!ret && copy_to_user(dataptr, &data, sizeof data))
return -EFAULT; return -EFAULT;
return ret; return ret;
} }
/* /*
@ -112,7 +112,7 @@ static inline int cap_set_pg(int pgrp_nr, kernel_cap_t *effective,
} while_each_pid_task(pgrp, PIDTYPE_PGID, g); } while_each_pid_task(pgrp, PIDTYPE_PGID, g);
if (!found) if (!found)
ret = 0; ret = 0;
return ret; return ret;
} }
@ -166,68 +166,68 @@ static inline int cap_set_all(kernel_cap_t *effective,
*/ */
asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data) asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
{ {
kernel_cap_t inheritable, permitted, effective; kernel_cap_t inheritable, permitted, effective;
__u32 version; __u32 version;
struct task_struct *target; struct task_struct *target;
int ret; int ret;
pid_t pid; pid_t pid;
if (get_user(version, &header->version)) if (get_user(version, &header->version))
return -EFAULT; return -EFAULT;
if (version != _LINUX_CAPABILITY_VERSION) { if (version != _LINUX_CAPABILITY_VERSION) {
if (put_user(_LINUX_CAPABILITY_VERSION, &header->version)) if (put_user(_LINUX_CAPABILITY_VERSION, &header->version))
return -EFAULT; return -EFAULT;
return -EINVAL; return -EINVAL;
} }
if (get_user(pid, &header->pid)) if (get_user(pid, &header->pid))
return -EFAULT; return -EFAULT;
if (pid && pid != current->pid && !capable(CAP_SETPCAP)) if (pid && pid != current->pid && !capable(CAP_SETPCAP))
return -EPERM; return -EPERM;
if (copy_from_user(&effective, &data->effective, sizeof(effective)) || if (copy_from_user(&effective, &data->effective, sizeof(effective)) ||
copy_from_user(&inheritable, &data->inheritable, sizeof(inheritable)) || copy_from_user(&inheritable, &data->inheritable, sizeof(inheritable)) ||
copy_from_user(&permitted, &data->permitted, sizeof(permitted))) copy_from_user(&permitted, &data->permitted, sizeof(permitted)))
return -EFAULT; return -EFAULT;
spin_lock(&task_capability_lock); spin_lock(&task_capability_lock);
read_lock(&tasklist_lock); read_lock(&tasklist_lock);
if (pid > 0 && pid != current->pid) { if (pid > 0 && pid != current->pid) {
target = find_task_by_pid(pid); target = find_task_by_pid(pid);
if (!target) { if (!target) {
ret = -ESRCH; ret = -ESRCH;
goto out; goto out;
} }
} else } else
target = current; target = current;
ret = 0; ret = 0;
/* having verified that the proposed changes are legal, /* having verified that the proposed changes are legal,
we now put them into effect. */ we now put them into effect. */
if (pid < 0) { if (pid < 0) {
if (pid == -1) /* all procs other than current and init */ if (pid == -1) /* all procs other than current and init */
ret = cap_set_all(&effective, &inheritable, &permitted); ret = cap_set_all(&effective, &inheritable, &permitted);
else /* all procs in process group */ else /* all procs in process group */
ret = cap_set_pg(-pid, &effective, &inheritable, ret = cap_set_pg(-pid, &effective, &inheritable,
&permitted); &permitted);
} else { } else {
ret = security_capset_check(target, &effective, &inheritable, ret = security_capset_check(target, &effective, &inheritable,
&permitted); &permitted);
if (!ret) if (!ret)
security_capset_set(target, &effective, &inheritable, security_capset_set(target, &effective, &inheritable,
&permitted); &permitted);
} }
out: out:
read_unlock(&tasklist_lock); read_unlock(&tasklist_lock);
spin_unlock(&task_capability_lock); spin_unlock(&task_capability_lock);
return ret; return ret;
} }
int __capable(struct task_struct *t, int cap) int __capable(struct task_struct *t, int cap)