blob: f2a4513669536d6370783c798d5fea460121aee3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/sys.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/module.h>
8#include <linux/mm.h>
9#include <linux/utsname.h>
10#include <linux/mman.h>
11#include <linux/smp_lock.h>
12#include <linux/notifier.h>
13#include <linux/reboot.h>
14#include <linux/prctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/highuid.h>
16#include <linux/fs.h>
Daniel Walker3e88c552007-05-10 22:22:53 -070017#include <linux/resource.h>
Eric W. Biedermandc009d92005-06-25 14:57:52 -070018#include <linux/kernel.h>
19#include <linux/kexec.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/workqueue.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080021#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/device.h>
23#include <linux/key.h>
24#include <linux/times.h>
25#include <linux/posix-timers.h>
26#include <linux/security.h>
27#include <linux/dcookies.h>
28#include <linux/suspend.h>
29#include <linux/tty.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070030#include <linux/signal.h>
Matt Helsley9f460802005-11-07 00:59:16 -080031#include <linux/cn_proc.h>
Andi Kleen3cfc3482006-09-26 10:52:28 +020032#include <linux/getcpu.h>
Eric Dumazet6eaeeab2007-05-10 22:22:37 -070033#include <linux/task_io_accounting_ops.h>
Andrea Arcangeli1d9d02f2007-07-15 23:41:32 -070034#include <linux/seccomp.h>
Mark Lord40477272007-10-01 01:20:10 -070035#include <linux/cpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37#include <linux/compat.h>
38#include <linux/syscalls.h>
Keshavamurthy Anil S00d7c052005-12-12 00:37:33 -080039#include <linux/kprobes.h>
Cedric Le Goateracce2922007-07-15 23:40:59 -070040#include <linux/user_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <asm/uaccess.h>
43#include <asm/io.h>
44#include <asm/unistd.h>
45
46#ifndef SET_UNALIGN_CTL
47# define SET_UNALIGN_CTL(a,b) (-EINVAL)
48#endif
49#ifndef GET_UNALIGN_CTL
50# define GET_UNALIGN_CTL(a,b) (-EINVAL)
51#endif
52#ifndef SET_FPEMU_CTL
53# define SET_FPEMU_CTL(a,b) (-EINVAL)
54#endif
55#ifndef GET_FPEMU_CTL
56# define GET_FPEMU_CTL(a,b) (-EINVAL)
57#endif
58#ifndef SET_FPEXC_CTL
59# define SET_FPEXC_CTL(a,b) (-EINVAL)
60#endif
61#ifndef GET_FPEXC_CTL
62# define GET_FPEXC_CTL(a,b) (-EINVAL)
63#endif
Anton Blanchard651d7652006-06-07 16:10:19 +100064#ifndef GET_ENDIAN
65# define GET_ENDIAN(a,b) (-EINVAL)
66#endif
67#ifndef SET_ENDIAN
68# define SET_ENDIAN(a,b) (-EINVAL)
69#endif
Erik Bosman8fb402b2008-04-11 18:54:17 +020070#ifndef GET_TSC_CTL
71# define GET_TSC_CTL(a) (-EINVAL)
72#endif
73#ifndef SET_TSC_CTL
74# define SET_TSC_CTL(a) (-EINVAL)
75#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77/*
78 * this is where the system-wide overflow UID and GID are defined, for
79 * architectures that now have 32-bit UID/GID but didn't in the past
80 */
81
82int overflowuid = DEFAULT_OVERFLOWUID;
83int overflowgid = DEFAULT_OVERFLOWGID;
84
85#ifdef CONFIG_UID16
86EXPORT_SYMBOL(overflowuid);
87EXPORT_SYMBOL(overflowgid);
88#endif
89
90/*
91 * the same as above, but for filesystems which can only store a 16-bit
92 * UID and GID. as such, this is needed on all architectures
93 */
94
95int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
96int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;
97
98EXPORT_SYMBOL(fs_overflowuid);
99EXPORT_SYMBOL(fs_overflowgid);
100
101/*
102 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
103 */
104
105int C_A_D = 1;
Cedric Le Goater9ec52092006-10-02 02:19:00 -0700106struct pid *cad_pid;
107EXPORT_SYMBOL(cad_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109/*
Rafael J. Wysockibd804eb2007-07-19 01:47:40 -0700110 * If set, this is used for preparing the system to power off.
111 */
112
113void (*pm_power_off_prepare)(void);
Rafael J. Wysockibd804eb2007-07-19 01:47:40 -0700114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115static int set_one_prio(struct task_struct *p, int niceval, int error)
116{
117 int no_nice;
118
119 if (p->uid != current->euid &&
120 p->euid != current->euid && !capable(CAP_SYS_NICE)) {
121 error = -EPERM;
122 goto out;
123 }
Matt Mackalle43379f2005-05-01 08:59:00 -0700124 if (niceval < task_nice(p) && !can_nice(p, niceval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 error = -EACCES;
126 goto out;
127 }
128 no_nice = security_task_setnice(p, niceval);
129 if (no_nice) {
130 error = no_nice;
131 goto out;
132 }
133 if (error == -ESRCH)
134 error = 0;
135 set_user_nice(p, niceval);
136out:
137 return error;
138}
139
140asmlinkage long sys_setpriority(int which, int who, int niceval)
141{
142 struct task_struct *g, *p;
143 struct user_struct *user;
144 int error = -EINVAL;
Eric W. Biederman41487c62007-02-12 00:53:01 -0800145 struct pid *pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Daniel Walker3e88c552007-05-10 22:22:53 -0700147 if (which > PRIO_USER || which < PRIO_PROCESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 goto out;
149
150 /* normalize: avoid signed division (rounding problems) */
151 error = -ESRCH;
152 if (niceval < -20)
153 niceval = -20;
154 if (niceval > 19)
155 niceval = 19;
156
157 read_lock(&tasklist_lock);
158 switch (which) {
159 case PRIO_PROCESS:
Eric W. Biederman41487c62007-02-12 00:53:01 -0800160 if (who)
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -0700161 p = find_task_by_vpid(who);
Eric W. Biederman41487c62007-02-12 00:53:01 -0800162 else
163 p = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 if (p)
165 error = set_one_prio(p, niceval, error);
166 break;
167 case PRIO_PGRP:
Eric W. Biederman41487c62007-02-12 00:53:01 -0800168 if (who)
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700169 pgrp = find_vpid(who);
Eric W. Biederman41487c62007-02-12 00:53:01 -0800170 else
171 pgrp = task_pgrp(current);
172 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 error = set_one_prio(p, niceval, error);
Eric W. Biederman41487c62007-02-12 00:53:01 -0800174 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 break;
176 case PRIO_USER:
177 user = current->user;
178 if (!who)
179 who = current->uid;
180 else
181 if ((who != current->uid) && !(user = find_user(who)))
182 goto out_unlock; /* No processes for this user */
183
184 do_each_thread(g, p)
185 if (p->uid == who)
186 error = set_one_prio(p, niceval, error);
187 while_each_thread(g, p);
188 if (who != current->uid)
189 free_uid(user); /* For find_user() */
190 break;
191 }
192out_unlock:
193 read_unlock(&tasklist_lock);
194out:
195 return error;
196}
197
198/*
199 * Ugh. To avoid negative return values, "getpriority()" will
200 * not return the normal nice-value, but a negated value that
201 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
202 * to stay compatible.
203 */
204asmlinkage long sys_getpriority(int which, int who)
205{
206 struct task_struct *g, *p;
207 struct user_struct *user;
208 long niceval, retval = -ESRCH;
Eric W. Biederman41487c62007-02-12 00:53:01 -0800209 struct pid *pgrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Daniel Walker3e88c552007-05-10 22:22:53 -0700211 if (which > PRIO_USER || which < PRIO_PROCESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return -EINVAL;
213
214 read_lock(&tasklist_lock);
215 switch (which) {
216 case PRIO_PROCESS:
Eric W. Biederman41487c62007-02-12 00:53:01 -0800217 if (who)
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -0700218 p = find_task_by_vpid(who);
Eric W. Biederman41487c62007-02-12 00:53:01 -0800219 else
220 p = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 if (p) {
222 niceval = 20 - task_nice(p);
223 if (niceval > retval)
224 retval = niceval;
225 }
226 break;
227 case PRIO_PGRP:
Eric W. Biederman41487c62007-02-12 00:53:01 -0800228 if (who)
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700229 pgrp = find_vpid(who);
Eric W. Biederman41487c62007-02-12 00:53:01 -0800230 else
231 pgrp = task_pgrp(current);
232 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 niceval = 20 - task_nice(p);
234 if (niceval > retval)
235 retval = niceval;
Eric W. Biederman41487c62007-02-12 00:53:01 -0800236 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 break;
238 case PRIO_USER:
239 user = current->user;
240 if (!who)
241 who = current->uid;
242 else
243 if ((who != current->uid) && !(user = find_user(who)))
244 goto out_unlock; /* No processes for this user */
245
246 do_each_thread(g, p)
247 if (p->uid == who) {
248 niceval = 20 - task_nice(p);
249 if (niceval > retval)
250 retval = niceval;
251 }
252 while_each_thread(g, p);
253 if (who != current->uid)
254 free_uid(user); /* for find_user() */
255 break;
256 }
257out_unlock:
258 read_unlock(&tasklist_lock);
259
260 return retval;
261}
262
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700263/**
264 * emergency_restart - reboot the system
265 *
266 * Without shutting down any hardware or taking any locks
267 * reboot the system. This is called when we know we are in
268 * trouble so this is our best effort to reboot. This is
269 * safe to call in interrupt context.
270 */
Eric W. Biederman7c903472005-07-26 11:29:55 -0600271void emergency_restart(void)
272{
273 machine_emergency_restart();
274}
275EXPORT_SYMBOL_GPL(emergency_restart);
276
Adrian Bunk83cc5ed2006-06-25 05:47:41 -0700277static void kernel_restart_prepare(char *cmd)
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600278{
Alan Sterne041c682006-03-27 01:16:30 -0800279 blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600280 system_state = SYSTEM_RESTART;
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600281 device_shutdown();
Rafael J. Wysocki58b3b712007-07-26 16:29:55 +0200282 sysdev_shutdown();
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700283}
Randy Dunlap1e5d5332005-11-07 01:01:06 -0800284
285/**
286 * kernel_restart - reboot the system
287 * @cmd: pointer to buffer containing command to execute for restart
Randy Dunlapb8887e62005-11-07 01:01:07 -0800288 * or %NULL
Randy Dunlap1e5d5332005-11-07 01:01:06 -0800289 *
290 * Shutdown everything and perform a clean reboot.
291 * This is not safe to call in interrupt context.
292 */
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700293void kernel_restart(char *cmd)
294{
295 kernel_restart_prepare(cmd);
Cal Peake756184b2006-09-30 23:27:24 -0700296 if (!cmd)
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600297 printk(KERN_EMERG "Restarting system.\n");
Cal Peake756184b2006-09-30 23:27:24 -0700298 else
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600299 printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600300 machine_restart(cmd);
301}
302EXPORT_SYMBOL_GPL(kernel_restart);
303
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700304/**
305 * kernel_kexec - reboot the system
306 *
307 * Move into place and start executing a preloaded standalone
308 * executable. If nothing was preloaded return an error.
309 */
Adrian Bunk83cc5ed2006-06-25 05:47:41 -0700310static void kernel_kexec(void)
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600311{
312#ifdef CONFIG_KEXEC
313 struct kimage *image;
Al Viro4bb80892006-02-01 05:57:32 -0500314 image = xchg(&kexec_image, NULL);
Cal Peake756184b2006-09-30 23:27:24 -0700315 if (!image)
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600316 return;
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700317 kernel_restart_prepare(NULL);
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600318 printk(KERN_EMERG "Starting new kernel\n");
319 machine_shutdown();
320 machine_kexec(image);
321#endif
322}
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600323
Adrian Bunk4ef72292008-02-04 22:30:06 -0800324static void kernel_shutdown_prepare(enum system_states state)
Alexey Starikovskiy729b4d42005-12-01 04:29:00 -0500325{
Alan Sterne041c682006-03-27 01:16:30 -0800326 blocking_notifier_call_chain(&reboot_notifier_list,
Alexey Starikovskiy729b4d42005-12-01 04:29:00 -0500327 (state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL);
328 system_state = state;
329 device_shutdown();
330}
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700331/**
332 * kernel_halt - halt the system
333 *
334 * Shutdown everything and perform a clean system halt.
335 */
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700336void kernel_halt(void)
337{
Alexey Starikovskiy729b4d42005-12-01 04:29:00 -0500338 kernel_shutdown_prepare(SYSTEM_HALT);
Rafael J. Wysocki58b3b712007-07-26 16:29:55 +0200339 sysdev_shutdown();
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600340 printk(KERN_EMERG "System halted.\n");
341 machine_halt();
342}
Alexey Starikovskiy729b4d42005-12-01 04:29:00 -0500343
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600344EXPORT_SYMBOL_GPL(kernel_halt);
345
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700346/**
347 * kernel_power_off - power_off the system
348 *
349 * Shutdown everything and perform a clean system power_off.
350 */
Eric W. Biedermane4c94332005-09-22 21:43:45 -0700351void kernel_power_off(void)
352{
Alexey Starikovskiy729b4d42005-12-01 04:29:00 -0500353 kernel_shutdown_prepare(SYSTEM_POWER_OFF);
Rafael J. Wysockibd804eb2007-07-19 01:47:40 -0700354 if (pm_power_off_prepare)
355 pm_power_off_prepare();
Mark Lord40477272007-10-01 01:20:10 -0700356 disable_nonboot_cpus();
Rafael J. Wysocki58b3b712007-07-26 16:29:55 +0200357 sysdev_shutdown();
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600358 printk(KERN_EMERG "Power down.\n");
359 machine_power_off();
360}
361EXPORT_SYMBOL_GPL(kernel_power_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362/*
363 * Reboot system call: for obvious reasons only root may call it,
364 * and even root needs to set up some magic numbers in the registers
365 * so that some mistake won't make this reboot the whole machine.
366 * You can also set the meaning of the ctrl-alt-del-key here.
367 *
368 * reboot doesn't sync: do that yourself before calling this.
369 */
370asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user * arg)
371{
372 char buffer[256];
373
374 /* We only trust the superuser with rebooting the system. */
375 if (!capable(CAP_SYS_BOOT))
376 return -EPERM;
377
378 /* For safety, we require "magic" arguments. */
379 if (magic1 != LINUX_REBOOT_MAGIC1 ||
380 (magic2 != LINUX_REBOOT_MAGIC2 &&
381 magic2 != LINUX_REBOOT_MAGIC2A &&
382 magic2 != LINUX_REBOOT_MAGIC2B &&
383 magic2 != LINUX_REBOOT_MAGIC2C))
384 return -EINVAL;
385
Eric W. Biederman5e382912006-01-08 01:03:46 -0800386 /* Instead of trying to make the power_off code look like
387 * halt when pm_power_off is not set do it the easy way.
388 */
389 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
390 cmd = LINUX_REBOOT_CMD_HALT;
391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 lock_kernel();
393 switch (cmd) {
394 case LINUX_REBOOT_CMD_RESTART:
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600395 kernel_restart(NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 break;
397
398 case LINUX_REBOOT_CMD_CAD_ON:
399 C_A_D = 1;
400 break;
401
402 case LINUX_REBOOT_CMD_CAD_OFF:
403 C_A_D = 0;
404 break;
405
406 case LINUX_REBOOT_CMD_HALT:
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600407 kernel_halt();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 unlock_kernel();
409 do_exit(0);
410 break;
411
412 case LINUX_REBOOT_CMD_POWER_OFF:
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600413 kernel_power_off();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 unlock_kernel();
415 do_exit(0);
416 break;
417
418 case LINUX_REBOOT_CMD_RESTART2:
419 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
420 unlock_kernel();
421 return -EFAULT;
422 }
423 buffer[sizeof(buffer) - 1] = '\0';
424
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600425 kernel_restart(buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 break;
427
Eric W. Biedermandc009d92005-06-25 14:57:52 -0700428 case LINUX_REBOOT_CMD_KEXEC:
Eric W. Biederman4a00ea12005-07-26 11:24:14 -0600429 kernel_kexec();
430 unlock_kernel();
431 return -EINVAL;
432
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200433#ifdef CONFIG_HIBERNATION
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 case LINUX_REBOOT_CMD_SW_SUSPEND:
435 {
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700436 int ret = hibernate();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 unlock_kernel();
438 return ret;
439 }
440#endif
441
442 default:
443 unlock_kernel();
444 return -EINVAL;
445 }
446 unlock_kernel();
447 return 0;
448}
449
David Howells65f27f32006-11-22 14:55:48 +0000450static void deferred_cad(struct work_struct *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Eric W. Biedermanabcd9e52005-07-26 11:27:34 -0600452 kernel_restart(NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
455/*
456 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
457 * As it's called within an interrupt, it may NOT sync: the only choice
458 * is whether to reboot at once, or just ignore the ctrl-alt-del.
459 */
460void ctrl_alt_del(void)
461{
David Howells65f27f32006-11-22 14:55:48 +0000462 static DECLARE_WORK(cad_work, deferred_cad);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 if (C_A_D)
465 schedule_work(&cad_work);
466 else
Cedric Le Goater9ec52092006-10-02 02:19:00 -0700467 kill_cad_pid(SIGINT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470/*
471 * Unprivileged users may change the real gid to the effective gid
472 * or vice versa. (BSD-style)
473 *
474 * If you set the real gid at all, or set the effective gid to a value not
475 * equal to the real gid, then the saved gid is set to the new effective gid.
476 *
477 * This makes it possible for a setgid program to completely drop its
478 * privileges, which is often a useful assertion to make when you are doing
479 * a security audit over a program.
480 *
481 * The general idea is that a program which uses just setregid() will be
482 * 100% compatible with BSD. A program which uses just setgid() will be
483 * 100% compatible with POSIX with saved IDs.
484 *
485 * SMP: There are not races, the GIDs are checked only by filesystem
486 * operations (as far as semantic preservation is concerned).
487 */
488asmlinkage long sys_setregid(gid_t rgid, gid_t egid)
489{
490 int old_rgid = current->gid;
491 int old_egid = current->egid;
492 int new_rgid = old_rgid;
493 int new_egid = old_egid;
494 int retval;
495
496 retval = security_task_setgid(rgid, egid, (gid_t)-1, LSM_SETID_RE);
497 if (retval)
498 return retval;
499
500 if (rgid != (gid_t) -1) {
501 if ((old_rgid == rgid) ||
502 (current->egid==rgid) ||
503 capable(CAP_SETGID))
504 new_rgid = rgid;
505 else
506 return -EPERM;
507 }
508 if (egid != (gid_t) -1) {
509 if ((old_rgid == egid) ||
510 (current->egid == egid) ||
511 (current->sgid == egid) ||
512 capable(CAP_SETGID))
513 new_egid = egid;
Cal Peake756184b2006-09-30 23:27:24 -0700514 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 }
Cal Peake756184b2006-09-30 23:27:24 -0700517 if (new_egid != old_egid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700518 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700519 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 }
521 if (rgid != (gid_t) -1 ||
522 (egid != (gid_t) -1 && egid != old_rgid))
523 current->sgid = new_egid;
524 current->fsgid = new_egid;
525 current->egid = new_egid;
526 current->gid = new_rgid;
527 key_fsgid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800528 proc_id_connector(current, PROC_EVENT_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 return 0;
530}
531
532/*
533 * setgid() is implemented like SysV w/ SAVED_IDS
534 *
535 * SMP: Same implicit races as above.
536 */
537asmlinkage long sys_setgid(gid_t gid)
538{
539 int old_egid = current->egid;
540 int retval;
541
542 retval = security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_ID);
543 if (retval)
544 return retval;
545
Cal Peake756184b2006-09-30 23:27:24 -0700546 if (capable(CAP_SETGID)) {
547 if (old_egid != gid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700548 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700549 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 }
551 current->gid = current->egid = current->sgid = current->fsgid = gid;
Cal Peake756184b2006-09-30 23:27:24 -0700552 } else if ((gid == current->gid) || (gid == current->sgid)) {
553 if (old_egid != gid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700554 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700555 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
557 current->egid = current->fsgid = gid;
558 }
559 else
560 return -EPERM;
561
562 key_fsgid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800563 proc_id_connector(current, PROC_EVENT_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 return 0;
565}
566
567static int set_user(uid_t new_ruid, int dumpclear)
568{
569 struct user_struct *new_user;
570
Cedric Le Goateracce2922007-07-15 23:40:59 -0700571 new_user = alloc_uid(current->nsproxy->user_ns, new_ruid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (!new_user)
573 return -EAGAIN;
574
575 if (atomic_read(&new_user->processes) >=
576 current->signal->rlim[RLIMIT_NPROC].rlim_cur &&
Cedric Le Goateracce2922007-07-15 23:40:59 -0700577 new_user != current->nsproxy->user_ns->root_user) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 free_uid(new_user);
579 return -EAGAIN;
580 }
581
582 switch_uid(new_user);
583
Cal Peake756184b2006-09-30 23:27:24 -0700584 if (dumpclear) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700585 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700586 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
588 current->uid = new_ruid;
589 return 0;
590}
591
592/*
593 * Unprivileged users may change the real uid to the effective uid
594 * or vice versa. (BSD-style)
595 *
596 * If you set the real uid at all, or set the effective uid to a value not
597 * equal to the real uid, then the saved uid is set to the new effective uid.
598 *
599 * This makes it possible for a setuid program to completely drop its
600 * privileges, which is often a useful assertion to make when you are doing
601 * a security audit over a program.
602 *
603 * The general idea is that a program which uses just setreuid() will be
604 * 100% compatible with BSD. A program which uses just setuid() will be
605 * 100% compatible with POSIX with saved IDs.
606 */
607asmlinkage long sys_setreuid(uid_t ruid, uid_t euid)
608{
609 int old_ruid, old_euid, old_suid, new_ruid, new_euid;
610 int retval;
611
612 retval = security_task_setuid(ruid, euid, (uid_t)-1, LSM_SETID_RE);
613 if (retval)
614 return retval;
615
616 new_ruid = old_ruid = current->uid;
617 new_euid = old_euid = current->euid;
618 old_suid = current->suid;
619
620 if (ruid != (uid_t) -1) {
621 new_ruid = ruid;
622 if ((old_ruid != ruid) &&
623 (current->euid != ruid) &&
624 !capable(CAP_SETUID))
625 return -EPERM;
626 }
627
628 if (euid != (uid_t) -1) {
629 new_euid = euid;
630 if ((old_ruid != euid) &&
631 (current->euid != euid) &&
632 (current->suid != euid) &&
633 !capable(CAP_SETUID))
634 return -EPERM;
635 }
636
637 if (new_ruid != old_ruid && set_user(new_ruid, new_euid != old_euid) < 0)
638 return -EAGAIN;
639
Cal Peake756184b2006-09-30 23:27:24 -0700640 if (new_euid != old_euid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700641 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700642 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
644 current->fsuid = current->euid = new_euid;
645 if (ruid != (uid_t) -1 ||
646 (euid != (uid_t) -1 && euid != old_ruid))
647 current->suid = current->euid;
648 current->fsuid = current->euid;
649
650 key_fsuid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800651 proc_id_connector(current, PROC_EVENT_UID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_RE);
654}
655
656
657
658/*
659 * setuid() is implemented like SysV with SAVED_IDS
660 *
661 * Note that SAVED_ID's is deficient in that a setuid root program
662 * like sendmail, for example, cannot set its uid to be a normal
663 * user and then switch back, because if you're root, setuid() sets
664 * the saved uid too. If you don't like this, blame the bright people
665 * in the POSIX committee and/or USG. Note that the BSD-style setreuid()
666 * will allow a root program to temporarily drop privileges and be able to
667 * regain them by swapping the real and effective uid.
668 */
669asmlinkage long sys_setuid(uid_t uid)
670{
671 int old_euid = current->euid;
David Rientjesa09c17a2006-12-06 20:40:18 -0800672 int old_ruid, old_suid, new_suid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 int retval;
674
675 retval = security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_ID);
676 if (retval)
677 return retval;
678
David Rientjesa09c17a2006-12-06 20:40:18 -0800679 old_ruid = current->uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 old_suid = current->suid;
681 new_suid = old_suid;
682
683 if (capable(CAP_SETUID)) {
684 if (uid != old_ruid && set_user(uid, old_euid != uid) < 0)
685 return -EAGAIN;
686 new_suid = uid;
687 } else if ((uid != current->uid) && (uid != new_suid))
688 return -EPERM;
689
Cal Peake756184b2006-09-30 23:27:24 -0700690 if (old_euid != uid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700691 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700692 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
694 current->fsuid = current->euid = uid;
695 current->suid = new_suid;
696
697 key_fsuid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800698 proc_id_connector(current, PROC_EVENT_UID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_ID);
701}
702
703
704/*
705 * This function implements a generic ability to update ruid, euid,
706 * and suid. This allows you to implement the 4.4 compatible seteuid().
707 */
708asmlinkage long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
709{
710 int old_ruid = current->uid;
711 int old_euid = current->euid;
712 int old_suid = current->suid;
713 int retval;
714
715 retval = security_task_setuid(ruid, euid, suid, LSM_SETID_RES);
716 if (retval)
717 return retval;
718
719 if (!capable(CAP_SETUID)) {
720 if ((ruid != (uid_t) -1) && (ruid != current->uid) &&
721 (ruid != current->euid) && (ruid != current->suid))
722 return -EPERM;
723 if ((euid != (uid_t) -1) && (euid != current->uid) &&
724 (euid != current->euid) && (euid != current->suid))
725 return -EPERM;
726 if ((suid != (uid_t) -1) && (suid != current->uid) &&
727 (suid != current->euid) && (suid != current->suid))
728 return -EPERM;
729 }
730 if (ruid != (uid_t) -1) {
731 if (ruid != current->uid && set_user(ruid, euid != current->euid) < 0)
732 return -EAGAIN;
733 }
734 if (euid != (uid_t) -1) {
Cal Peake756184b2006-09-30 23:27:24 -0700735 if (euid != current->euid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700736 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700737 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 }
739 current->euid = euid;
740 }
741 current->fsuid = current->euid;
742 if (suid != (uid_t) -1)
743 current->suid = suid;
744
745 key_fsuid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800746 proc_id_connector(current, PROC_EVENT_UID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_RES);
749}
750
751asmlinkage long sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __user *suid)
752{
753 int retval;
754
755 if (!(retval = put_user(current->uid, ruid)) &&
756 !(retval = put_user(current->euid, euid)))
757 retval = put_user(current->suid, suid);
758
759 return retval;
760}
761
762/*
763 * Same as above, but for rgid, egid, sgid.
764 */
765asmlinkage long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
766{
767 int retval;
768
769 retval = security_task_setgid(rgid, egid, sgid, LSM_SETID_RES);
770 if (retval)
771 return retval;
772
773 if (!capable(CAP_SETGID)) {
774 if ((rgid != (gid_t) -1) && (rgid != current->gid) &&
775 (rgid != current->egid) && (rgid != current->sgid))
776 return -EPERM;
777 if ((egid != (gid_t) -1) && (egid != current->gid) &&
778 (egid != current->egid) && (egid != current->sgid))
779 return -EPERM;
780 if ((sgid != (gid_t) -1) && (sgid != current->gid) &&
781 (sgid != current->egid) && (sgid != current->sgid))
782 return -EPERM;
783 }
784 if (egid != (gid_t) -1) {
Cal Peake756184b2006-09-30 23:27:24 -0700785 if (egid != current->egid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700786 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700787 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 }
789 current->egid = egid;
790 }
791 current->fsgid = current->egid;
792 if (rgid != (gid_t) -1)
793 current->gid = rgid;
794 if (sgid != (gid_t) -1)
795 current->sgid = sgid;
796
797 key_fsgid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800798 proc_id_connector(current, PROC_EVENT_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 return 0;
800}
801
802asmlinkage long sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __user *sgid)
803{
804 int retval;
805
806 if (!(retval = put_user(current->gid, rgid)) &&
807 !(retval = put_user(current->egid, egid)))
808 retval = put_user(current->sgid, sgid);
809
810 return retval;
811}
812
813
814/*
815 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
816 * is used for "access()" and for the NFS daemon (letting nfsd stay at
817 * whatever uid it wants to). It normally shadows "euid", except when
818 * explicitly set by setfsuid() or for access..
819 */
820asmlinkage long sys_setfsuid(uid_t uid)
821{
822 int old_fsuid;
823
824 old_fsuid = current->fsuid;
825 if (security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS))
826 return old_fsuid;
827
828 if (uid == current->uid || uid == current->euid ||
829 uid == current->suid || uid == current->fsuid ||
Cal Peake756184b2006-09-30 23:27:24 -0700830 capable(CAP_SETUID)) {
831 if (uid != old_fsuid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700832 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700833 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 }
835 current->fsuid = uid;
836 }
837
838 key_fsuid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800839 proc_id_connector(current, PROC_EVENT_UID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 security_task_post_setuid(old_fsuid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS);
842
843 return old_fsuid;
844}
845
846/*
John Anthony Kazos Jrf42df9e2007-05-09 08:23:08 +0200847 * Samma på svenska..
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 */
849asmlinkage long sys_setfsgid(gid_t gid)
850{
851 int old_fsgid;
852
853 old_fsgid = current->fsgid;
854 if (security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_FS))
855 return old_fsgid;
856
857 if (gid == current->gid || gid == current->egid ||
858 gid == current->sgid || gid == current->fsgid ||
Cal Peake756184b2006-09-30 23:27:24 -0700859 capable(CAP_SETGID)) {
860 if (gid != old_fsgid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700861 set_dumpable(current->mm, suid_dumpable);
akpm@osdl.orgd59dd462005-05-01 08:58:47 -0700862 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
864 current->fsgid = gid;
865 key_fsgid_changed(current);
Matt Helsley9f460802005-11-07 00:59:16 -0800866 proc_id_connector(current, PROC_EVENT_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
868 return old_fsgid;
869}
870
871asmlinkage long sys_times(struct tms __user * tbuf)
872{
873 /*
874 * In the SMP world we might just be unlucky and have one of
875 * the times increment as we use it. Since the value is an
876 * atomically safe type this is just fine. Conceptually its
877 * as if the syscall took an instant longer to occur.
878 */
879 if (tbuf) {
880 struct tms tmp;
Oleg Nesterov35f5cad2006-03-28 16:11:19 -0800881 struct task_struct *tsk = current;
882 struct task_struct *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 cputime_t utime, stime, cutime, cstime;
884
Oleg Nesterov7d7185c2006-03-28 16:11:21 -0800885 spin_lock_irq(&tsk->sighand->siglock);
Oleg Nesterov35f5cad2006-03-28 16:11:19 -0800886 utime = tsk->signal->utime;
887 stime = tsk->signal->stime;
888 t = tsk;
889 do {
890 utime = cputime_add(utime, t->utime);
891 stime = cputime_add(stime, t->stime);
892 t = next_thread(t);
893 } while (t != tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
Oleg Nesterov35f5cad2006-03-28 16:11:19 -0800895 cutime = tsk->signal->cutime;
896 cstime = tsk->signal->cstime;
897 spin_unlock_irq(&tsk->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899 tmp.tms_utime = cputime_to_clock_t(utime);
900 tmp.tms_stime = cputime_to_clock_t(stime);
901 tmp.tms_cutime = cputime_to_clock_t(cutime);
902 tmp.tms_cstime = cputime_to_clock_t(cstime);
903 if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
904 return -EFAULT;
905 }
906 return (long) jiffies_64_to_clock_t(get_jiffies_64());
907}
908
909/*
910 * This needs some heavy checking ...
911 * I just haven't the stomach for it. I also don't fully
912 * understand sessions/pgrp etc. Let somebody who does explain it.
913 *
914 * OK, I think I have the protection semantics right.... this is really
915 * only important on a multi-user system anyway, to make sure one user
916 * can't send a signal to a process owned by another. -TYT, 12/12/91
917 *
918 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
919 * LBT 04.03.94
920 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
922{
923 struct task_struct *p;
Oleg Nesterovee0acf92006-01-08 01:03:53 -0800924 struct task_struct *group_leader = current->group_leader;
Oleg Nesterov4e021302008-02-08 04:19:08 -0800925 struct pid *pgrp;
926 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
928 if (!pid)
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700929 pid = task_pid_vnr(group_leader);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 if (!pgid)
931 pgid = pid;
932 if (pgid < 0)
933 return -EINVAL;
934
935 /* From this point forward we keep holding onto the tasklist lock
936 * so that our parent does not change from under us. -DaveM
937 */
938 write_lock_irq(&tasklist_lock);
939
940 err = -ESRCH;
Oleg Nesterov4e021302008-02-08 04:19:08 -0800941 p = find_task_by_vpid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (!p)
943 goto out;
944
945 err = -EINVAL;
946 if (!thread_group_leader(p))
947 goto out;
948
Oleg Nesterov4e021302008-02-08 04:19:08 -0800949 if (same_thread_group(p->real_parent, group_leader)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 err = -EPERM;
Eric W. Biederman41487c62007-02-12 00:53:01 -0800951 if (task_session(p) != task_session(group_leader))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 goto out;
953 err = -EACCES;
954 if (p->did_exec)
955 goto out;
956 } else {
957 err = -ESRCH;
Oleg Nesterovee0acf92006-01-08 01:03:53 -0800958 if (p != group_leader)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 goto out;
960 }
961
962 err = -EPERM;
963 if (p->signal->leader)
964 goto out;
965
Oleg Nesterov4e021302008-02-08 04:19:08 -0800966 pgrp = task_pid(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (pgid != pid) {
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700968 struct task_struct *g;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
Oleg Nesterov4e021302008-02-08 04:19:08 -0800970 pgrp = find_vpid(pgid);
971 g = pid_task(pgrp, PIDTYPE_PGID);
Eric W. Biederman41487c62007-02-12 00:53:01 -0800972 if (!g || task_session(g) != task_session(group_leader))
Oleg Nesterovf020bc42006-12-08 02:38:02 -0800973 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 err = security_task_setpgid(p, pgid);
977 if (err)
978 goto out;
979
Oleg Nesterov4e021302008-02-08 04:19:08 -0800980 if (task_pgrp(p) != pgrp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 detach_pid(p, PIDTYPE_PGID);
Oleg Nesterov4e021302008-02-08 04:19:08 -0800982 attach_pid(p, PIDTYPE_PGID, pgrp);
983 set_task_pgrp(p, pid_nr(pgrp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985
986 err = 0;
987out:
988 /* All paths lead to here, thus we are safe. -DaveM */
989 write_unlock_irq(&tasklist_lock);
990 return err;
991}
992
993asmlinkage long sys_getpgid(pid_t pid)
994{
Cal Peake756184b2006-09-30 23:27:24 -0700995 if (!pid)
Pavel Emelyanovb4888932007-10-18 23:40:14 -0700996 return task_pgrp_vnr(current);
Cal Peake756184b2006-09-30 23:27:24 -0700997 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 int retval;
999 struct task_struct *p;
1000
1001 read_lock(&tasklist_lock);
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08001002 p = find_task_by_vpid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 retval = -ESRCH;
1004 if (p) {
1005 retval = security_task_getpgid(p);
1006 if (!retval)
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08001007 retval = task_pgrp_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 }
1009 read_unlock(&tasklist_lock);
1010 return retval;
1011 }
1012}
1013
1014#ifdef __ARCH_WANT_SYS_GETPGRP
1015
1016asmlinkage long sys_getpgrp(void)
1017{
1018 /* SMP - assuming writes are word atomic this is fine */
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001019 return task_pgrp_vnr(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020}
1021
1022#endif
1023
1024asmlinkage long sys_getsid(pid_t pid)
1025{
Cal Peake756184b2006-09-30 23:27:24 -07001026 if (!pid)
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001027 return task_session_vnr(current);
Cal Peake756184b2006-09-30 23:27:24 -07001028 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 int retval;
1030 struct task_struct *p;
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001031
Oleg Nesterovac9a8e32008-02-08 04:19:15 -08001032 rcu_read_lock();
1033 p = find_task_by_vpid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 retval = -ESRCH;
Cal Peake756184b2006-09-30 23:27:24 -07001035 if (p) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 retval = security_task_getsid(p);
1037 if (!retval)
Oleg Nesterovac9a8e32008-02-08 04:19:15 -08001038 retval = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 }
Oleg Nesterovac9a8e32008-02-08 04:19:15 -08001040 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 return retval;
1042 }
1043}
1044
1045asmlinkage long sys_setsid(void)
1046{
Oren Laadane19f2472006-01-08 01:03:58 -08001047 struct task_struct *group_leader = current->group_leader;
Oleg Nesterove4cc0a92008-02-08 04:19:09 -08001048 struct pid *sid = task_pid(group_leader);
1049 pid_t session = pid_vnr(sid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 int err = -EPERM;
1051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 write_lock_irq(&tasklist_lock);
Eric W. Biederman390e2ff2006-03-31 02:31:33 -08001053 /* Fail if I am already a session leader */
1054 if (group_leader->signal->leader)
1055 goto out;
1056
Oleg Nesterov430c6232008-02-08 04:19:11 -08001057 /* Fail if a process group id already exists that equals the
1058 * proposed session id.
Eric W. Biederman390e2ff2006-03-31 02:31:33 -08001059 */
Oleg Nesterov6806aac2008-02-08 04:19:12 -08001060 if (pid_task(sid, PIDTYPE_PGID))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 goto out;
1062
Oren Laadane19f2472006-01-08 01:03:58 -08001063 group_leader->signal->leader = 1;
Oleg Nesterov8520d7c2008-02-08 04:19:09 -08001064 __set_special_pids(sid);
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001065
1066 spin_lock(&group_leader->sighand->siglock);
Oren Laadane19f2472006-01-08 01:03:58 -08001067 group_leader->signal->tty = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001068 spin_unlock(&group_leader->sighand->siglock);
1069
Oleg Nesterove4cc0a92008-02-08 04:19:09 -08001070 err = session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071out:
1072 write_unlock_irq(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 return err;
1074}
1075
1076/*
1077 * Supplementary group IDs
1078 */
1079
1080/* init to 2 - one for init_task, one to ensure it is never freed */
1081struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
1082
1083struct group_info *groups_alloc(int gidsetsize)
1084{
1085 struct group_info *group_info;
1086 int nblocks;
1087 int i;
1088
1089 nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;
1090 /* Make sure we always allocate at least one indirect block pointer */
1091 nblocks = nblocks ? : 1;
1092 group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);
1093 if (!group_info)
1094 return NULL;
1095 group_info->ngroups = gidsetsize;
1096 group_info->nblocks = nblocks;
1097 atomic_set(&group_info->usage, 1);
1098
Cal Peake756184b2006-09-30 23:27:24 -07001099 if (gidsetsize <= NGROUPS_SMALL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 group_info->blocks[0] = group_info->small_block;
Cal Peake756184b2006-09-30 23:27:24 -07001101 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 for (i = 0; i < nblocks; i++) {
1103 gid_t *b;
1104 b = (void *)__get_free_page(GFP_USER);
1105 if (!b)
1106 goto out_undo_partial_alloc;
1107 group_info->blocks[i] = b;
1108 }
1109 }
1110 return group_info;
1111
1112out_undo_partial_alloc:
1113 while (--i >= 0) {
1114 free_page((unsigned long)group_info->blocks[i]);
1115 }
1116 kfree(group_info);
1117 return NULL;
1118}
1119
1120EXPORT_SYMBOL(groups_alloc);
1121
1122void groups_free(struct group_info *group_info)
1123{
1124 if (group_info->blocks[0] != group_info->small_block) {
1125 int i;
1126 for (i = 0; i < group_info->nblocks; i++)
1127 free_page((unsigned long)group_info->blocks[i]);
1128 }
1129 kfree(group_info);
1130}
1131
1132EXPORT_SYMBOL(groups_free);
1133
1134/* export the group_info to a user-space array */
1135static int groups_to_user(gid_t __user *grouplist,
1136 struct group_info *group_info)
1137{
1138 int i;
Eric Dumazet1bf47342008-02-06 01:37:56 -08001139 unsigned int count = group_info->ngroups;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
1141 for (i = 0; i < group_info->nblocks; i++) {
Eric Dumazet1bf47342008-02-06 01:37:56 -08001142 unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);
1143 unsigned int len = cp_count * sizeof(*grouplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Eric Dumazet1bf47342008-02-06 01:37:56 -08001145 if (copy_to_user(grouplist, group_info->blocks[i], len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 return -EFAULT;
1147
Eric Dumazet1bf47342008-02-06 01:37:56 -08001148 grouplist += NGROUPS_PER_BLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 count -= cp_count;
1150 }
1151 return 0;
1152}
1153
1154/* fill a group_info from a user-space array - it must be allocated already */
1155static int groups_from_user(struct group_info *group_info,
1156 gid_t __user *grouplist)
Cal Peake756184b2006-09-30 23:27:24 -07001157{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 int i;
Eric Dumazet1bf47342008-02-06 01:37:56 -08001159 unsigned int count = group_info->ngroups;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
1161 for (i = 0; i < group_info->nblocks; i++) {
Eric Dumazet1bf47342008-02-06 01:37:56 -08001162 unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);
1163 unsigned int len = cp_count * sizeof(*grouplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Eric Dumazet1bf47342008-02-06 01:37:56 -08001165 if (copy_from_user(group_info->blocks[i], grouplist, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 return -EFAULT;
1167
Eric Dumazet1bf47342008-02-06 01:37:56 -08001168 grouplist += NGROUPS_PER_BLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 count -= cp_count;
1170 }
1171 return 0;
1172}
1173
Domen Puncerebe8b542005-05-05 16:16:19 -07001174/* a simple Shell sort */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175static void groups_sort(struct group_info *group_info)
1176{
1177 int base, max, stride;
1178 int gidsetsize = group_info->ngroups;
1179
1180 for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
1181 ; /* nothing */
1182 stride /= 3;
1183
1184 while (stride) {
1185 max = gidsetsize - stride;
1186 for (base = 0; base < max; base++) {
1187 int left = base;
1188 int right = left + stride;
1189 gid_t tmp = GROUP_AT(group_info, right);
1190
1191 while (left >= 0 && GROUP_AT(group_info, left) > tmp) {
1192 GROUP_AT(group_info, right) =
1193 GROUP_AT(group_info, left);
1194 right = left;
1195 left -= stride;
1196 }
1197 GROUP_AT(group_info, right) = tmp;
1198 }
1199 stride /= 3;
1200 }
1201}
1202
1203/* a simple bsearch */
David Howells3e301482005-06-23 22:00:56 -07001204int groups_search(struct group_info *group_info, gid_t grp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205{
Eric Dumazetd74beb9f2006-03-25 03:08:19 -08001206 unsigned int left, right;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 if (!group_info)
1209 return 0;
1210
1211 left = 0;
1212 right = group_info->ngroups;
1213 while (left < right) {
Eric Dumazetd74beb9f2006-03-25 03:08:19 -08001214 unsigned int mid = (left+right)/2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 int cmp = grp - GROUP_AT(group_info, mid);
1216 if (cmp > 0)
1217 left = mid + 1;
1218 else if (cmp < 0)
1219 right = mid;
1220 else
1221 return 1;
1222 }
1223 return 0;
1224}
1225
1226/* validate and set current->group_info */
1227int set_current_groups(struct group_info *group_info)
1228{
1229 int retval;
1230 struct group_info *old_info;
1231
1232 retval = security_task_setgroups(group_info);
1233 if (retval)
1234 return retval;
1235
1236 groups_sort(group_info);
1237 get_group_info(group_info);
1238
1239 task_lock(current);
1240 old_info = current->group_info;
1241 current->group_info = group_info;
1242 task_unlock(current);
1243
1244 put_group_info(old_info);
1245
1246 return 0;
1247}
1248
1249EXPORT_SYMBOL(set_current_groups);
1250
1251asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist)
1252{
1253 int i = 0;
1254
1255 /*
1256 * SMP: Nobody else can change our grouplist. Thus we are
1257 * safe.
1258 */
1259
1260 if (gidsetsize < 0)
1261 return -EINVAL;
1262
1263 /* no need to grab task_lock here; it cannot change */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 i = current->group_info->ngroups;
1265 if (gidsetsize) {
1266 if (i > gidsetsize) {
1267 i = -EINVAL;
1268 goto out;
1269 }
1270 if (groups_to_user(grouplist, current->group_info)) {
1271 i = -EFAULT;
1272 goto out;
1273 }
1274 }
1275out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 return i;
1277}
1278
1279/*
1280 * SMP: Our groups are copy-on-write. We can set them safely
1281 * without another task interfering.
1282 */
1283
1284asmlinkage long sys_setgroups(int gidsetsize, gid_t __user *grouplist)
1285{
1286 struct group_info *group_info;
1287 int retval;
1288
1289 if (!capable(CAP_SETGID))
1290 return -EPERM;
1291 if ((unsigned)gidsetsize > NGROUPS_MAX)
1292 return -EINVAL;
1293
1294 group_info = groups_alloc(gidsetsize);
1295 if (!group_info)
1296 return -ENOMEM;
1297 retval = groups_from_user(group_info, grouplist);
1298 if (retval) {
1299 put_group_info(group_info);
1300 return retval;
1301 }
1302
1303 retval = set_current_groups(group_info);
1304 put_group_info(group_info);
1305
1306 return retval;
1307}
1308
1309/*
1310 * Check whether we're fsgid/egid or in the supplemental group..
1311 */
1312int in_group_p(gid_t grp)
1313{
1314 int retval = 1;
Cal Peake756184b2006-09-30 23:27:24 -07001315 if (grp != current->fsgid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 retval = groups_search(current->group_info, grp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 return retval;
1318}
1319
1320EXPORT_SYMBOL(in_group_p);
1321
1322int in_egroup_p(gid_t grp)
1323{
1324 int retval = 1;
Cal Peake756184b2006-09-30 23:27:24 -07001325 if (grp != current->egid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 retval = groups_search(current->group_info, grp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 return retval;
1328}
1329
1330EXPORT_SYMBOL(in_egroup_p);
1331
1332DECLARE_RWSEM(uts_sem);
1333
David S. Miller393b0722005-11-10 12:47:50 -08001334EXPORT_SYMBOL(uts_sem);
1335
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336asmlinkage long sys_newuname(struct new_utsname __user * name)
1337{
1338 int errno = 0;
1339
1340 down_read(&uts_sem);
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07001341 if (copy_to_user(name, utsname(), sizeof *name))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 errno = -EFAULT;
1343 up_read(&uts_sem);
1344 return errno;
1345}
1346
1347asmlinkage long sys_sethostname(char __user *name, int len)
1348{
1349 int errno;
1350 char tmp[__NEW_UTS_LEN];
1351
1352 if (!capable(CAP_SYS_ADMIN))
1353 return -EPERM;
1354 if (len < 0 || len > __NEW_UTS_LEN)
1355 return -EINVAL;
1356 down_write(&uts_sem);
1357 errno = -EFAULT;
1358 if (!copy_from_user(tmp, name, len)) {
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07001359 memcpy(utsname()->nodename, tmp, len);
1360 utsname()->nodename[len] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 errno = 0;
1362 }
1363 up_write(&uts_sem);
1364 return errno;
1365}
1366
1367#ifdef __ARCH_WANT_SYS_GETHOSTNAME
1368
1369asmlinkage long sys_gethostname(char __user *name, int len)
1370{
1371 int i, errno;
1372
1373 if (len < 0)
1374 return -EINVAL;
1375 down_read(&uts_sem);
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07001376 i = 1 + strlen(utsname()->nodename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 if (i > len)
1378 i = len;
1379 errno = 0;
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07001380 if (copy_to_user(name, utsname()->nodename, i))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 errno = -EFAULT;
1382 up_read(&uts_sem);
1383 return errno;
1384}
1385
1386#endif
1387
1388/*
1389 * Only setdomainname; getdomainname can be implemented by calling
1390 * uname()
1391 */
1392asmlinkage long sys_setdomainname(char __user *name, int len)
1393{
1394 int errno;
1395 char tmp[__NEW_UTS_LEN];
1396
1397 if (!capable(CAP_SYS_ADMIN))
1398 return -EPERM;
1399 if (len < 0 || len > __NEW_UTS_LEN)
1400 return -EINVAL;
1401
1402 down_write(&uts_sem);
1403 errno = -EFAULT;
1404 if (!copy_from_user(tmp, name, len)) {
Serge E. Hallyne9ff3992006-10-02 02:18:11 -07001405 memcpy(utsname()->domainname, tmp, len);
1406 utsname()->domainname[len] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 errno = 0;
1408 }
1409 up_write(&uts_sem);
1410 return errno;
1411}
1412
1413asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit __user *rlim)
1414{
1415 if (resource >= RLIM_NLIMITS)
1416 return -EINVAL;
1417 else {
1418 struct rlimit value;
1419 task_lock(current->group_leader);
1420 value = current->signal->rlim[resource];
1421 task_unlock(current->group_leader);
1422 return copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
1423 }
1424}
1425
1426#ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1427
1428/*
1429 * Back compatibility for getrlimit. Needed for some apps.
1430 */
1431
1432asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim)
1433{
1434 struct rlimit x;
1435 if (resource >= RLIM_NLIMITS)
1436 return -EINVAL;
1437
1438 task_lock(current->group_leader);
1439 x = current->signal->rlim[resource];
1440 task_unlock(current->group_leader);
Cal Peake756184b2006-09-30 23:27:24 -07001441 if (x.rlim_cur > 0x7FFFFFFF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 x.rlim_cur = 0x7FFFFFFF;
Cal Peake756184b2006-09-30 23:27:24 -07001443 if (x.rlim_max > 0x7FFFFFFF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 x.rlim_max = 0x7FFFFFFF;
1445 return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0;
1446}
1447
1448#endif
1449
1450asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit __user *rlim)
1451{
1452 struct rlimit new_rlim, *old_rlim;
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001453 unsigned long it_prof_secs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 int retval;
1455
1456 if (resource >= RLIM_NLIMITS)
1457 return -EINVAL;
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001458 if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 return -EFAULT;
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001460 if (new_rlim.rlim_cur > new_rlim.rlim_max)
1461 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 old_rlim = current->signal->rlim + resource;
1463 if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
1464 !capable(CAP_SYS_RESOURCE))
1465 return -EPERM;
Eric Dumazet9cfe0152008-02-06 01:37:16 -08001466 if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > sysctl_nr_open)
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001467 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469 retval = security_task_setrlimit(resource, &new_rlim);
1470 if (retval)
1471 return retval;
1472
Tom Alsberg9926e4c2007-05-08 00:30:31 -07001473 if (resource == RLIMIT_CPU && new_rlim.rlim_cur == 0) {
1474 /*
1475 * The caller is asking for an immediate RLIMIT_CPU
1476 * expiry. But we use the zero value to mean "it was
1477 * never set". So let's cheat and make it one second
1478 * instead
1479 */
1480 new_rlim.rlim_cur = 1;
1481 }
1482
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 task_lock(current->group_leader);
1484 *old_rlim = new_rlim;
1485 task_unlock(current->group_leader);
1486
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001487 if (resource != RLIMIT_CPU)
1488 goto out;
Andrew Mortond3561f72006-03-24 03:18:36 -08001489
1490 /*
1491 * RLIMIT_CPU handling. Note that the kernel fails to return an error
1492 * code if it rejected the user's attempt to set RLIMIT_CPU. This is a
1493 * very long-standing error, and fixing it now risks breakage of
1494 * applications, so we live with it
1495 */
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001496 if (new_rlim.rlim_cur == RLIM_INFINITY)
1497 goto out;
1498
1499 it_prof_secs = cputime_to_secs(current->signal->it_prof_expires);
1500 if (it_prof_secs == 0 || new_rlim.rlim_cur <= it_prof_secs) {
Andrew Mortone0661112006-03-24 03:18:35 -08001501 unsigned long rlim_cur = new_rlim.rlim_cur;
1502 cputime_t cputime;
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001503
Andrew Mortone0661112006-03-24 03:18:35 -08001504 cputime = secs_to_cputime(rlim_cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 read_lock(&tasklist_lock);
1506 spin_lock_irq(&current->sighand->siglock);
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001507 set_process_cpu_timer(current, CPUCLOCK_PROF, &cputime, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 spin_unlock_irq(&current->sighand->siglock);
1509 read_unlock(&tasklist_lock);
1510 }
Andrew Mortonec9e16b2006-03-24 03:18:34 -08001511out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 return 0;
1513}
1514
1515/*
1516 * It would make sense to put struct rusage in the task_struct,
1517 * except that would make the task_struct be *really big*. After
1518 * task_struct gets moved into malloc'ed memory, it would
1519 * make sense to do this. It will make moving the rest of the information
1520 * a lot simpler! (Which we're not doing right now because we're not
1521 * measuring them yet).
1522 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1524 * races with threads incrementing their own counters. But since word
1525 * reads are atomic, we either get new values or old values and we don't
1526 * care which for the sums. We always take the siglock to protect reading
1527 * the c* fields from p->signal from races with exit.c updating those
1528 * fields when reaping, so a sample either gets all the additions of a
1529 * given child after it's reaped, or none so this sample is before reaping.
Ravikiran G Thirumalai2dd0ebc2006-03-23 03:00:13 -08001530 *
Ravikiran G Thirumalaide047c12006-06-22 14:47:26 -07001531 * Locking:
1532 * We need to take the siglock for CHILDEREN, SELF and BOTH
1533 * for the cases current multithreaded, non-current single threaded
1534 * non-current multithreaded. Thread traversal is now safe with
1535 * the siglock held.
1536 * Strictly speaking, we donot need to take the siglock if we are current and
1537 * single threaded, as no one else can take our signal_struct away, no one
1538 * else can reap the children to update signal->c* counters, and no one else
1539 * can race with the signal-> fields. If we do not take any lock, the
1540 * signal-> fields could be read out of order while another thread was just
1541 * exiting. So we should place a read memory barrier when we avoid the lock.
1542 * On the writer side, write memory barrier is implied in __exit_signal
1543 * as __exit_signal releases the siglock spinlock after updating the signal->
1544 * fields. But we don't do this yet to keep things simple.
Ravikiran G Thirumalai2dd0ebc2006-03-23 03:00:13 -08001545 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 */
1547
1548static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
1549{
1550 struct task_struct *t;
1551 unsigned long flags;
1552 cputime_t utime, stime;
1553
1554 memset((char *) r, 0, sizeof *r);
Oleg Nesterov0f59cc42006-01-08 01:05:15 -08001555 utime = stime = cputime_zero;
1556
Ravikiran G Thirumalaide047c12006-06-22 14:47:26 -07001557 rcu_read_lock();
1558 if (!lock_task_sighand(p, &flags)) {
1559 rcu_read_unlock();
1560 return;
1561 }
Ravikiran G Thirumalai2dd0ebc2006-03-23 03:00:13 -08001562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 switch (who) {
Oleg Nesterov0f59cc42006-01-08 01:05:15 -08001564 case RUSAGE_BOTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 case RUSAGE_CHILDREN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 utime = p->signal->cutime;
1567 stime = p->signal->cstime;
1568 r->ru_nvcsw = p->signal->cnvcsw;
1569 r->ru_nivcsw = p->signal->cnivcsw;
1570 r->ru_minflt = p->signal->cmin_flt;
1571 r->ru_majflt = p->signal->cmaj_flt;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -07001572 r->ru_inblock = p->signal->cinblock;
1573 r->ru_oublock = p->signal->coublock;
Oleg Nesterov0f59cc42006-01-08 01:05:15 -08001574
1575 if (who == RUSAGE_CHILDREN)
1576 break;
1577
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 case RUSAGE_SELF:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 utime = cputime_add(utime, p->signal->utime);
1580 stime = cputime_add(stime, p->signal->stime);
1581 r->ru_nvcsw += p->signal->nvcsw;
1582 r->ru_nivcsw += p->signal->nivcsw;
1583 r->ru_minflt += p->signal->min_flt;
1584 r->ru_majflt += p->signal->maj_flt;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -07001585 r->ru_inblock += p->signal->inblock;
1586 r->ru_oublock += p->signal->oublock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 t = p;
1588 do {
1589 utime = cputime_add(utime, t->utime);
1590 stime = cputime_add(stime, t->stime);
1591 r->ru_nvcsw += t->nvcsw;
1592 r->ru_nivcsw += t->nivcsw;
1593 r->ru_minflt += t->min_flt;
1594 r->ru_majflt += t->maj_flt;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -07001595 r->ru_inblock += task_io_get_inblock(t);
1596 r->ru_oublock += task_io_get_oublock(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 t = next_thread(t);
1598 } while (t != p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 break;
Oleg Nesterov0f59cc42006-01-08 01:05:15 -08001600
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 default:
1602 BUG();
1603 }
Oleg Nesterov0f59cc42006-01-08 01:05:15 -08001604
Ravikiran G Thirumalaide047c12006-06-22 14:47:26 -07001605 unlock_task_sighand(p, &flags);
1606 rcu_read_unlock();
1607
Oleg Nesterov0f59cc42006-01-08 01:05:15 -08001608 cputime_to_timeval(utime, &r->ru_utime);
1609 cputime_to_timeval(stime, &r->ru_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610}
1611
1612int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
1613{
1614 struct rusage r;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 k_getrusage(p, who, &r);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1617}
1618
1619asmlinkage long sys_getrusage(int who, struct rusage __user *ru)
1620{
1621 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN)
1622 return -EINVAL;
1623 return getrusage(current, who, ru);
1624}
1625
1626asmlinkage long sys_umask(int mask)
1627{
1628 mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
1629 return mask;
1630}
Serge E. Hallyn3b7391d2008-02-04 22:29:45 -08001631
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
1633 unsigned long arg4, unsigned long arg5)
1634{
Andrew G. Morgan3898b1b2008-04-28 02:13:40 -07001635 long uninitialized_var(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
Andrew G. Morgan3898b1b2008-04-28 02:13:40 -07001637 if (security_task_prctl(option, arg2, arg3, arg4, arg5, &error))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 return error;
1639
1640 switch (option) {
1641 case PR_SET_PDEATHSIG:
Jesper Juhl0730ded2005-09-06 15:17:37 -07001642 if (!valid_signal(arg2)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 error = -EINVAL;
1644 break;
1645 }
Jesper Juhl0730ded2005-09-06 15:17:37 -07001646 current->pdeath_signal = arg2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 break;
1648 case PR_GET_PDEATHSIG:
1649 error = put_user(current->pdeath_signal, (int __user *)arg2);
1650 break;
1651 case PR_GET_DUMPABLE:
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -07001652 error = get_dumpable(current->mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 break;
1654 case PR_SET_DUMPABLE:
Marcel Holtmannabf75a52006-07-12 13:12:00 +02001655 if (arg2 < 0 || arg2 > 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 error = -EINVAL;
1657 break;
1658 }
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -07001659 set_dumpable(current->mm, arg2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 break;
1661
1662 case PR_SET_UNALIGN:
1663 error = SET_UNALIGN_CTL(current, arg2);
1664 break;
1665 case PR_GET_UNALIGN:
1666 error = GET_UNALIGN_CTL(current, arg2);
1667 break;
1668 case PR_SET_FPEMU:
1669 error = SET_FPEMU_CTL(current, arg2);
1670 break;
1671 case PR_GET_FPEMU:
1672 error = GET_FPEMU_CTL(current, arg2);
1673 break;
1674 case PR_SET_FPEXC:
1675 error = SET_FPEXC_CTL(current, arg2);
1676 break;
1677 case PR_GET_FPEXC:
1678 error = GET_FPEXC_CTL(current, arg2);
1679 break;
1680 case PR_GET_TIMING:
1681 error = PR_TIMING_STATISTICAL;
1682 break;
1683 case PR_SET_TIMING:
1684 if (arg2 == PR_TIMING_STATISTICAL)
1685 error = 0;
1686 else
1687 error = -EINVAL;
1688 break;
1689
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 case PR_SET_NAME: {
1691 struct task_struct *me = current;
1692 unsigned char ncomm[sizeof(me->comm)];
1693
1694 ncomm[sizeof(me->comm)-1] = 0;
1695 if (strncpy_from_user(ncomm, (char __user *)arg2,
1696 sizeof(me->comm)-1) < 0)
1697 return -EFAULT;
1698 set_task_comm(me, ncomm);
1699 return 0;
1700 }
1701 case PR_GET_NAME: {
1702 struct task_struct *me = current;
1703 unsigned char tcomm[sizeof(me->comm)];
1704
1705 get_task_comm(tcomm, me);
1706 if (copy_to_user((char __user *)arg2, tcomm, sizeof(tcomm)))
1707 return -EFAULT;
1708 return 0;
1709 }
Anton Blanchard651d7652006-06-07 16:10:19 +10001710 case PR_GET_ENDIAN:
1711 error = GET_ENDIAN(current, arg2);
1712 break;
1713 case PR_SET_ENDIAN:
1714 error = SET_ENDIAN(current, arg2);
1715 break;
1716
Andrea Arcangeli1d9d02f2007-07-15 23:41:32 -07001717 case PR_GET_SECCOMP:
1718 error = prctl_get_seccomp();
1719 break;
1720 case PR_SET_SECCOMP:
1721 error = prctl_set_seccomp(arg2);
1722 break;
Erik Bosman8fb402b2008-04-11 18:54:17 +02001723 case PR_GET_TSC:
1724 error = GET_TSC_CTL(arg2);
1725 break;
1726 case PR_SET_TSC:
1727 error = SET_TSC_CTL(arg2);
1728 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 default:
1730 error = -EINVAL;
1731 break;
1732 }
1733 return error;
1734}
Andi Kleen3cfc3482006-09-26 10:52:28 +02001735
1736asmlinkage long sys_getcpu(unsigned __user *cpup, unsigned __user *nodep,
Ingo Molnar4307d1e2007-11-07 18:37:48 +01001737 struct getcpu_cache __user *unused)
Andi Kleen3cfc3482006-09-26 10:52:28 +02001738{
1739 int err = 0;
1740 int cpu = raw_smp_processor_id();
1741 if (cpup)
1742 err |= put_user(cpu, cpup);
1743 if (nodep)
1744 err |= put_user(cpu_to_node(cpu), nodep);
Andi Kleen3cfc3482006-09-26 10:52:28 +02001745 return err ? -EFAULT : 0;
1746}
Jeremy Fitzhardinge10a0a8d2007-07-17 18:37:02 -07001747
1748char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
1749
1750static void argv_cleanup(char **argv, char **envp)
1751{
1752 argv_free(argv);
1753}
1754
1755/**
1756 * orderly_poweroff - Trigger an orderly system poweroff
1757 * @force: force poweroff if command execution fails
1758 *
1759 * This may be called from any context to trigger a system shutdown.
1760 * If the orderly shutdown fails, it will force an immediate shutdown.
1761 */
1762int orderly_poweroff(bool force)
1763{
1764 int argc;
1765 char **argv = argv_split(GFP_ATOMIC, poweroff_cmd, &argc);
1766 static char *envp[] = {
1767 "HOME=/",
1768 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
1769 NULL
1770 };
1771 int ret = -ENOMEM;
1772 struct subprocess_info *info;
1773
1774 if (argv == NULL) {
1775 printk(KERN_WARNING "%s failed to allocate memory for \"%s\"\n",
1776 __func__, poweroff_cmd);
1777 goto out;
1778 }
1779
1780 info = call_usermodehelper_setup(argv[0], argv, envp);
1781 if (info == NULL) {
1782 argv_free(argv);
1783 goto out;
1784 }
1785
1786 call_usermodehelper_setcleanup(info, argv_cleanup);
1787
Jeremy Fitzhardinge86313c42007-07-17 18:37:03 -07001788 ret = call_usermodehelper_exec(info, UMH_NO_WAIT);
Jeremy Fitzhardinge10a0a8d2007-07-17 18:37:02 -07001789
1790 out:
1791 if (ret && force) {
1792 printk(KERN_WARNING "Failed to start orderly shutdown: "
1793 "forcing the issue\n");
1794
1795 /* I guess this should try to kick off some daemon to
1796 sync and poweroff asap. Or not even bother syncing
1797 if we're doing an emergency shutdown? */
1798 emergency_sync();
1799 kernel_power_off();
1800 }
1801
1802 return ret;
1803}
1804EXPORT_SYMBOL_GPL(orderly_poweroff);