sys.c 37.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 *  linux/kernel/sys.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/module.h>
#include <linux/mm.h>
#include <linux/utsname.h>
#include <linux/mman.h>
#include <linux/smp_lock.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/prctl.h>
#include <linux/highuid.h>
#include <linux/fs.h>
17
#include <linux/perf_event.h>
18
#include <linux/resource.h>
19 20
#include <linux/kernel.h>
#include <linux/kexec.h>
L
Linus Torvalds 已提交
21
#include <linux/workqueue.h>
22
#include <linux/capability.h>
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30
#include <linux/device.h>
#include <linux/key.h>
#include <linux/times.h>
#include <linux/posix-timers.h>
#include <linux/security.h>
#include <linux/dcookies.h>
#include <linux/suspend.h>
#include <linux/tty.h>
31
#include <linux/signal.h>
M
Matt Helsley 已提交
32
#include <linux/cn_proc.h>
33
#include <linux/getcpu.h>
34
#include <linux/task_io_accounting_ops.h>
35
#include <linux/seccomp.h>
M
Mark Lord 已提交
36
#include <linux/cpu.h>
37
#include <linux/ptrace.h>
38
#include <linux/fs_struct.h>
L
Linus Torvalds 已提交
39 40 41

#include <linux/compat.h>
#include <linux/syscalls.h>
42
#include <linux/kprobes.h>
43
#include <linux/user_namespace.h>
L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/unistd.h>

#ifndef SET_UNALIGN_CTL
# define SET_UNALIGN_CTL(a,b)	(-EINVAL)
#endif
#ifndef GET_UNALIGN_CTL
# define GET_UNALIGN_CTL(a,b)	(-EINVAL)
#endif
#ifndef SET_FPEMU_CTL
# define SET_FPEMU_CTL(a,b)	(-EINVAL)
#endif
#ifndef GET_FPEMU_CTL
# define GET_FPEMU_CTL(a,b)	(-EINVAL)
#endif
#ifndef SET_FPEXC_CTL
# define SET_FPEXC_CTL(a,b)	(-EINVAL)
#endif
#ifndef GET_FPEXC_CTL
# define GET_FPEXC_CTL(a,b)	(-EINVAL)
#endif
67 68 69 70 71 72
#ifndef GET_ENDIAN
# define GET_ENDIAN(a,b)	(-EINVAL)
#endif
#ifndef SET_ENDIAN
# define SET_ENDIAN(a,b)	(-EINVAL)
#endif
73 74 75 76 77 78
#ifndef GET_TSC_CTL
# define GET_TSC_CTL(a)		(-EINVAL)
#endif
#ifndef SET_TSC_CTL
# define SET_TSC_CTL(a)		(-EINVAL)
#endif
L
Linus Torvalds 已提交
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

/*
 * this is where the system-wide overflow UID and GID are defined, for
 * architectures that now have 32-bit UID/GID but didn't in the past
 */

int overflowuid = DEFAULT_OVERFLOWUID;
int overflowgid = DEFAULT_OVERFLOWGID;

#ifdef CONFIG_UID16
EXPORT_SYMBOL(overflowuid);
EXPORT_SYMBOL(overflowgid);
#endif

/*
 * the same as above, but for filesystems which can only store a 16-bit
 * UID and GID. as such, this is needed on all architectures
 */

int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;

EXPORT_SYMBOL(fs_overflowuid);
EXPORT_SYMBOL(fs_overflowgid);

/*
 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
 */

int C_A_D = 1;
109 110
struct pid *cad_pid;
EXPORT_SYMBOL(cad_pid);
L
Linus Torvalds 已提交
111

112 113 114 115 116 117
/*
 * If set, this is used for preparing the system to power off.
 */

void (*pm_power_off_prepare)(void);

118 119 120 121
/*
 * set the priority of a task
 * - the caller must hold the RCU read lock
 */
L
Linus Torvalds 已提交
122 123
static int set_one_prio(struct task_struct *p, int niceval, int error)
{
124
	const struct cred *cred = current_cred(), *pcred = __task_cred(p);
L
Linus Torvalds 已提交
125 126
	int no_nice;

127 128
	if (pcred->uid  != cred->euid &&
	    pcred->euid != cred->euid && !capable(CAP_SYS_NICE)) {
L
Linus Torvalds 已提交
129 130 131
		error = -EPERM;
		goto out;
	}
M
Matt Mackall 已提交
132
	if (niceval < task_nice(p) && !can_nice(p, niceval)) {
L
Linus Torvalds 已提交
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
		error = -EACCES;
		goto out;
	}
	no_nice = security_task_setnice(p, niceval);
	if (no_nice) {
		error = no_nice;
		goto out;
	}
	if (error == -ESRCH)
		error = 0;
	set_user_nice(p, niceval);
out:
	return error;
}

148
SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
L
Linus Torvalds 已提交
149 150 151
{
	struct task_struct *g, *p;
	struct user_struct *user;
152
	const struct cred *cred = current_cred();
L
Linus Torvalds 已提交
153
	int error = -EINVAL;
154
	struct pid *pgrp;
L
Linus Torvalds 已提交
155

156
	if (which > PRIO_USER || which < PRIO_PROCESS)
L
Linus Torvalds 已提交
157 158 159 160 161 162 163 164 165 166 167 168
		goto out;

	/* normalize: avoid signed division (rounding problems) */
	error = -ESRCH;
	if (niceval < -20)
		niceval = -20;
	if (niceval > 19)
		niceval = 19;

	read_lock(&tasklist_lock);
	switch (which) {
		case PRIO_PROCESS:
169
			if (who)
170
				p = find_task_by_vpid(who);
171 172
			else
				p = current;
L
Linus Torvalds 已提交
173 174 175 176
			if (p)
				error = set_one_prio(p, niceval, error);
			break;
		case PRIO_PGRP:
177
			if (who)
178
				pgrp = find_vpid(who);
179 180
			else
				pgrp = task_pgrp(current);
181
			do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
L
Linus Torvalds 已提交
182
				error = set_one_prio(p, niceval, error);
183
			} while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
184 185
			break;
		case PRIO_USER:
D
David Howells 已提交
186
			user = (struct user_struct *) cred->user;
L
Linus Torvalds 已提交
187
			if (!who)
188 189 190 191
				who = cred->uid;
			else if ((who != cred->uid) &&
				 !(user = find_user(who)))
				goto out_unlock;	/* No processes for this user */
L
Linus Torvalds 已提交
192 193

			do_each_thread(g, p)
194
				if (__task_cred(p)->uid == who)
L
Linus Torvalds 已提交
195 196
					error = set_one_prio(p, niceval, error);
			while_each_thread(g, p);
197
			if (who != cred->uid)
L
Linus Torvalds 已提交
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
				free_uid(user);		/* For find_user() */
			break;
	}
out_unlock:
	read_unlock(&tasklist_lock);
out:
	return error;
}

/*
 * Ugh. To avoid negative return values, "getpriority()" will
 * not return the normal nice-value, but a negated value that
 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
 * to stay compatible.
 */
213
SYSCALL_DEFINE2(getpriority, int, which, int, who)
L
Linus Torvalds 已提交
214 215 216
{
	struct task_struct *g, *p;
	struct user_struct *user;
217
	const struct cred *cred = current_cred();
L
Linus Torvalds 已提交
218
	long niceval, retval = -ESRCH;
219
	struct pid *pgrp;
L
Linus Torvalds 已提交
220

221
	if (which > PRIO_USER || which < PRIO_PROCESS)
L
Linus Torvalds 已提交
222 223 224 225 226
		return -EINVAL;

	read_lock(&tasklist_lock);
	switch (which) {
		case PRIO_PROCESS:
227
			if (who)
228
				p = find_task_by_vpid(who);
229 230
			else
				p = current;
L
Linus Torvalds 已提交
231 232 233 234 235 236 237
			if (p) {
				niceval = 20 - task_nice(p);
				if (niceval > retval)
					retval = niceval;
			}
			break;
		case PRIO_PGRP:
238
			if (who)
239
				pgrp = find_vpid(who);
240 241
			else
				pgrp = task_pgrp(current);
242
			do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
L
Linus Torvalds 已提交
243 244 245
				niceval = 20 - task_nice(p);
				if (niceval > retval)
					retval = niceval;
246
			} while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
L
Linus Torvalds 已提交
247 248
			break;
		case PRIO_USER:
249
			user = (struct user_struct *) cred->user;
L
Linus Torvalds 已提交
250
			if (!who)
251 252 253 254
				who = cred->uid;
			else if ((who != cred->uid) &&
				 !(user = find_user(who)))
				goto out_unlock;	/* No processes for this user */
L
Linus Torvalds 已提交
255 256

			do_each_thread(g, p)
257
				if (__task_cred(p)->uid == who) {
L
Linus Torvalds 已提交
258 259 260 261 262
					niceval = 20 - task_nice(p);
					if (niceval > retval)
						retval = niceval;
				}
			while_each_thread(g, p);
263
			if (who != cred->uid)
L
Linus Torvalds 已提交
264 265 266 267 268 269 270 271 272
				free_uid(user);		/* for find_user() */
			break;
	}
out_unlock:
	read_unlock(&tasklist_lock);

	return retval;
}

273 274 275 276 277 278 279 280
/**
 *	emergency_restart - reboot the system
 *
 *	Without shutting down any hardware or taking any locks
 *	reboot the system.  This is called when we know we are in
 *	trouble so this is our best effort to reboot.  This is
 *	safe to call in interrupt context.
 */
281 282 283 284 285 286
void emergency_restart(void)
{
	machine_emergency_restart();
}
EXPORT_SYMBOL_GPL(emergency_restart);

287
void kernel_restart_prepare(char *cmd)
288
{
289
	blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
290 291
	system_state = SYSTEM_RESTART;
	device_shutdown();
292
	sysdev_shutdown();
293
}
294 295 296 297

/**
 *	kernel_restart - reboot the system
 *	@cmd: pointer to buffer containing command to execute for restart
298
 *		or %NULL
299 300 301 302
 *
 *	Shutdown everything and perform a clean reboot.
 *	This is not safe to call in interrupt context.
 */
303 304 305
void kernel_restart(char *cmd)
{
	kernel_restart_prepare(cmd);
306
	if (!cmd)
307
		printk(KERN_EMERG "Restarting system.\n");
308
	else
309 310 311 312 313
		printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
	machine_restart(cmd);
}
EXPORT_SYMBOL_GPL(kernel_restart);

314
static void kernel_shutdown_prepare(enum system_states state)
315
{
316
	blocking_notifier_call_chain(&reboot_notifier_list,
317 318 319 320
		(state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL);
	system_state = state;
	device_shutdown();
}
321 322 323 324 325 326 327
/**
 *	kernel_halt - halt the system
 *
 *	Shutdown everything and perform a clean system halt.
 */
void kernel_halt(void)
{
328
	kernel_shutdown_prepare(SYSTEM_HALT);
329
	sysdev_shutdown();
330 331 332
	printk(KERN_EMERG "System halted.\n");
	machine_halt();
}
333

334 335
EXPORT_SYMBOL_GPL(kernel_halt);

336 337 338 339 340 341 342
/**
 *	kernel_power_off - power_off the system
 *
 *	Shutdown everything and perform a clean system power_off.
 */
void kernel_power_off(void)
{
343
	kernel_shutdown_prepare(SYSTEM_POWER_OFF);
344 345
	if (pm_power_off_prepare)
		pm_power_off_prepare();
M
Mark Lord 已提交
346
	disable_nonboot_cpus();
347
	sysdev_shutdown();
348 349 350 351
	printk(KERN_EMERG "Power down.\n");
	machine_power_off();
}
EXPORT_SYMBOL_GPL(kernel_power_off);
L
Linus Torvalds 已提交
352 353 354 355 356 357 358 359
/*
 * Reboot system call: for obvious reasons only root may call it,
 * and even root needs to set up some magic numbers in the registers
 * so that some mistake won't make this reboot the whole machine.
 * You can also set the meaning of the ctrl-alt-del-key here.
 *
 * reboot doesn't sync: do that yourself before calling this.
 */
360 361
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
		void __user *, arg)
L
Linus Torvalds 已提交
362 363
{
	char buffer[256];
364
	int ret = 0;
L
Linus Torvalds 已提交
365 366 367 368 369 370 371 372 373 374 375 376 377

	/* We only trust the superuser with rebooting the system. */
	if (!capable(CAP_SYS_BOOT))
		return -EPERM;

	/* For safety, we require "magic" arguments. */
	if (magic1 != LINUX_REBOOT_MAGIC1 ||
	    (magic2 != LINUX_REBOOT_MAGIC2 &&
	                magic2 != LINUX_REBOOT_MAGIC2A &&
			magic2 != LINUX_REBOOT_MAGIC2B &&
	                magic2 != LINUX_REBOOT_MAGIC2C))
		return -EINVAL;

378 379 380 381 382 383
	/* Instead of trying to make the power_off code look like
	 * halt when pm_power_off is not set do it the easy way.
	 */
	if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
		cmd = LINUX_REBOOT_CMD_HALT;

L
Linus Torvalds 已提交
384 385 386
	lock_kernel();
	switch (cmd) {
	case LINUX_REBOOT_CMD_RESTART:
387
		kernel_restart(NULL);
L
Linus Torvalds 已提交
388 389 390 391 392 393 394 395 396 397 398
		break;

	case LINUX_REBOOT_CMD_CAD_ON:
		C_A_D = 1;
		break;

	case LINUX_REBOOT_CMD_CAD_OFF:
		C_A_D = 0;
		break;

	case LINUX_REBOOT_CMD_HALT:
399
		kernel_halt();
L
Linus Torvalds 已提交
400 401
		unlock_kernel();
		do_exit(0);
402
		panic("cannot halt");
L
Linus Torvalds 已提交
403 404

	case LINUX_REBOOT_CMD_POWER_OFF:
405
		kernel_power_off();
L
Linus Torvalds 已提交
406 407 408 409 410 411 412 413 414 415 416
		unlock_kernel();
		do_exit(0);
		break;

	case LINUX_REBOOT_CMD_RESTART2:
		if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
			unlock_kernel();
			return -EFAULT;
		}
		buffer[sizeof(buffer) - 1] = '\0';

417
		kernel_restart(buffer);
L
Linus Torvalds 已提交
418 419
		break;

H
Huang Ying 已提交
420
#ifdef CONFIG_KEXEC
421
	case LINUX_REBOOT_CMD_KEXEC:
422 423
		ret = kernel_kexec();
		break;
H
Huang Ying 已提交
424
#endif
425

426
#ifdef CONFIG_HIBERNATION
L
Linus Torvalds 已提交
427
	case LINUX_REBOOT_CMD_SW_SUSPEND:
428 429
		ret = hibernate();
		break;
L
Linus Torvalds 已提交
430 431 432
#endif

	default:
433 434
		ret = -EINVAL;
		break;
L
Linus Torvalds 已提交
435 436
	}
	unlock_kernel();
437
	return ret;
L
Linus Torvalds 已提交
438 439
}

440
static void deferred_cad(struct work_struct *dummy)
L
Linus Torvalds 已提交
441
{
442
	kernel_restart(NULL);
L
Linus Torvalds 已提交
443 444 445 446 447 448 449 450 451
}

/*
 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
 * As it's called within an interrupt, it may NOT sync: the only choice
 * is whether to reboot at once, or just ignore the ctrl-alt-del.
 */
void ctrl_alt_del(void)
{
452
	static DECLARE_WORK(cad_work, deferred_cad);
L
Linus Torvalds 已提交
453 454 455 456

	if (C_A_D)
		schedule_work(&cad_work);
	else
457
		kill_cad_pid(SIGINT, 1);
L
Linus Torvalds 已提交
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
}
	
/*
 * Unprivileged users may change the real gid to the effective gid
 * or vice versa.  (BSD-style)
 *
 * If you set the real gid at all, or set the effective gid to a value not
 * equal to the real gid, then the saved gid is set to the new effective gid.
 *
 * This makes it possible for a setgid program to completely drop its
 * privileges, which is often a useful assertion to make when you are doing
 * a security audit over a program.
 *
 * The general idea is that a program which uses just setregid() will be
 * 100% compatible with BSD.  A program which uses just setgid() will be
 * 100% compatible with POSIX with saved IDs. 
 *
 * SMP: There are not races, the GIDs are checked only by filesystem
 *      operations (as far as semantic preservation is concerned).
 */
478
SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
L
Linus Torvalds 已提交
479
{
D
David Howells 已提交
480 481
	const struct cred *old;
	struct cred *new;
L
Linus Torvalds 已提交
482 483
	int retval;

D
David Howells 已提交
484 485 486 487 488
	new = prepare_creds();
	if (!new)
		return -ENOMEM;
	old = current_cred();

L
Linus Torvalds 已提交
489 490
	retval = security_task_setgid(rgid, egid, (gid_t)-1, LSM_SETID_RE);
	if (retval)
D
David Howells 已提交
491
		goto error;
L
Linus Torvalds 已提交
492

D
David Howells 已提交
493
	retval = -EPERM;
L
Linus Torvalds 已提交
494
	if (rgid != (gid_t) -1) {
D
David Howells 已提交
495 496
		if (old->gid == rgid ||
		    old->egid == rgid ||
L
Linus Torvalds 已提交
497
		    capable(CAP_SETGID))
D
David Howells 已提交
498
			new->gid = rgid;
L
Linus Torvalds 已提交
499
		else
D
David Howells 已提交
500
			goto error;
L
Linus Torvalds 已提交
501 502
	}
	if (egid != (gid_t) -1) {
D
David Howells 已提交
503 504 505
		if (old->gid == egid ||
		    old->egid == egid ||
		    old->sgid == egid ||
L
Linus Torvalds 已提交
506
		    capable(CAP_SETGID))
D
David Howells 已提交
507
			new->egid = egid;
508
		else
D
David Howells 已提交
509
			goto error;
L
Linus Torvalds 已提交
510
	}
D
David Howells 已提交
511

L
Linus Torvalds 已提交
512
	if (rgid != (gid_t) -1 ||
D
David Howells 已提交
513 514 515 516 517 518 519 520 521
	    (egid != (gid_t) -1 && egid != old->gid))
		new->sgid = new->egid;
	new->fsgid = new->egid;

	return commit_creds(new);

error:
	abort_creds(new);
	return retval;
L
Linus Torvalds 已提交
522 523 524 525 526 527 528
}

/*
 * setgid() is implemented like SysV w/ SAVED_IDS 
 *
 * SMP: Same implicit races as above.
 */
529
SYSCALL_DEFINE1(setgid, gid_t, gid)
L
Linus Torvalds 已提交
530
{
D
David Howells 已提交
531 532
	const struct cred *old;
	struct cred *new;
L
Linus Torvalds 已提交
533 534
	int retval;

D
David Howells 已提交
535 536 537 538 539
	new = prepare_creds();
	if (!new)
		return -ENOMEM;
	old = current_cred();

L
Linus Torvalds 已提交
540 541
	retval = security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_ID);
	if (retval)
D
David Howells 已提交
542
		goto error;
L
Linus Torvalds 已提交
543

D
David Howells 已提交
544 545 546 547 548
	retval = -EPERM;
	if (capable(CAP_SETGID))
		new->gid = new->egid = new->sgid = new->fsgid = gid;
	else if (gid == old->gid || gid == old->sgid)
		new->egid = new->fsgid = gid;
L
Linus Torvalds 已提交
549
	else
D
David Howells 已提交
550
		goto error;
L
Linus Torvalds 已提交
551

D
David Howells 已提交
552 553 554 555 556
	return commit_creds(new);

error:
	abort_creds(new);
	return retval;
L
Linus Torvalds 已提交
557
}
558

D
David Howells 已提交
559 560 561 562
/*
 * change the user struct in a credentials set to match the new UID
 */
static int set_user(struct cred *new)
L
Linus Torvalds 已提交
563 564 565
{
	struct user_struct *new_user;

566
	new_user = alloc_uid(current_user_ns(), new->uid);
L
Linus Torvalds 已提交
567 568 569
	if (!new_user)
		return -EAGAIN;

570 571 572 573 574
	if (!task_can_switch_user(new_user, current)) {
		free_uid(new_user);
		return -EINVAL;
	}

L
Linus Torvalds 已提交
575 576
	if (atomic_read(&new_user->processes) >=
				current->signal->rlim[RLIMIT_NPROC].rlim_cur &&
577
			new_user != INIT_USER) {
L
Linus Torvalds 已提交
578 579 580 581
		free_uid(new_user);
		return -EAGAIN;
	}

D
David Howells 已提交
582 583
	free_uid(new->user);
	new->user = new_user;
L
Linus Torvalds 已提交
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
	return 0;
}

/*
 * Unprivileged users may change the real uid to the effective uid
 * or vice versa.  (BSD-style)
 *
 * If you set the real uid at all, or set the effective uid to a value not
 * equal to the real uid, then the saved uid is set to the new effective uid.
 *
 * This makes it possible for a setuid program to completely drop its
 * privileges, which is often a useful assertion to make when you are doing
 * a security audit over a program.
 *
 * The general idea is that a program which uses just setreuid() will be
 * 100% compatible with BSD.  A program which uses just setuid() will be
 * 100% compatible with POSIX with saved IDs. 
 */
602
SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
L
Linus Torvalds 已提交
603
{
D
David Howells 已提交
604 605
	const struct cred *old;
	struct cred *new;
L
Linus Torvalds 已提交
606 607
	int retval;

D
David Howells 已提交
608 609 610 611 612
	new = prepare_creds();
	if (!new)
		return -ENOMEM;
	old = current_cred();

L
Linus Torvalds 已提交
613 614
	retval = security_task_setuid(ruid, euid, (uid_t)-1, LSM_SETID_RE);
	if (retval)
D
David Howells 已提交
615
		goto error;
L
Linus Torvalds 已提交
616

D
David Howells 已提交
617
	retval = -EPERM;
L
Linus Torvalds 已提交
618
	if (ruid != (uid_t) -1) {
D
David Howells 已提交
619 620 621
		new->uid = ruid;
		if (old->uid != ruid &&
		    old->euid != ruid &&
L
Linus Torvalds 已提交
622
		    !capable(CAP_SETUID))
D
David Howells 已提交
623
			goto error;
L
Linus Torvalds 已提交
624 625 626
	}

	if (euid != (uid_t) -1) {
D
David Howells 已提交
627 628 629 630
		new->euid = euid;
		if (old->uid != euid &&
		    old->euid != euid &&
		    old->suid != euid &&
L
Linus Torvalds 已提交
631
		    !capable(CAP_SETUID))
D
David Howells 已提交
632
			goto error;
L
Linus Torvalds 已提交
633 634
	}

635 636 637 638 639
	if (new->uid != old->uid) {
		retval = set_user(new);
		if (retval < 0)
			goto error;
	}
L
Linus Torvalds 已提交
640
	if (ruid != (uid_t) -1 ||
D
David Howells 已提交
641 642 643
	    (euid != (uid_t) -1 && euid != old->uid))
		new->suid = new->euid;
	new->fsuid = new->euid;
L
Linus Torvalds 已提交
644

D
David Howells 已提交
645 646 647
	retval = security_task_fix_setuid(new, old, LSM_SETID_RE);
	if (retval < 0)
		goto error;
L
Linus Torvalds 已提交
648

D
David Howells 已提交
649
	return commit_creds(new);
L
Linus Torvalds 已提交
650

D
David Howells 已提交
651 652 653 654
error:
	abort_creds(new);
	return retval;
}
L
Linus Torvalds 已提交
655 656 657 658 659 660 661 662 663 664 665 666
		
/*
 * setuid() is implemented like SysV with SAVED_IDS 
 * 
 * Note that SAVED_ID's is deficient in that a setuid root program
 * like sendmail, for example, cannot set its uid to be a normal 
 * user and then switch back, because if you're root, setuid() sets
 * the saved uid too.  If you don't like this, blame the bright people
 * in the POSIX committee and/or USG.  Note that the BSD-style setreuid()
 * will allow a root program to temporarily drop privileges and be able to
 * regain them by swapping the real and effective uid.  
 */
667
SYSCALL_DEFINE1(setuid, uid_t, uid)
L
Linus Torvalds 已提交
668
{
D
David Howells 已提交
669 670
	const struct cred *old;
	struct cred *new;
L
Linus Torvalds 已提交
671 672
	int retval;

D
David Howells 已提交
673 674 675 676 677
	new = prepare_creds();
	if (!new)
		return -ENOMEM;
	old = current_cred();

L
Linus Torvalds 已提交
678 679
	retval = security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_ID);
	if (retval)
D
David Howells 已提交
680
		goto error;
L
Linus Torvalds 已提交
681

D
David Howells 已提交
682
	retval = -EPERM;
L
Linus Torvalds 已提交
683
	if (capable(CAP_SETUID)) {
D
David Howells 已提交
684
		new->suid = new->uid = uid;
685 686 687 688
		if (uid != old->uid) {
			retval = set_user(new);
			if (retval < 0)
				goto error;
D
David Howells 已提交
689 690 691
		}
	} else if (uid != old->uid && uid != new->suid) {
		goto error;
L
Linus Torvalds 已提交
692 693
	}

D
David Howells 已提交
694 695 696 697 698
	new->fsuid = new->euid = uid;

	retval = security_task_fix_setuid(new, old, LSM_SETID_ID);
	if (retval < 0)
		goto error;
L
Linus Torvalds 已提交
699

D
David Howells 已提交
700
	return commit_creds(new);
L
Linus Torvalds 已提交
701

D
David Howells 已提交
702 703 704
error:
	abort_creds(new);
	return retval;
L
Linus Torvalds 已提交
705 706 707 708 709 710 711
}


/*
 * This function implements a generic ability to update ruid, euid,
 * and suid.  This allows you to implement the 4.4 compatible seteuid().
 */
712
SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
L
Linus Torvalds 已提交
713
{
D
David Howells 已提交
714 715
	const struct cred *old;
	struct cred *new;
L
Linus Torvalds 已提交
716 717
	int retval;

D
David Howells 已提交
718 719 720 721
	new = prepare_creds();
	if (!new)
		return -ENOMEM;

L
Linus Torvalds 已提交
722 723
	retval = security_task_setuid(ruid, euid, suid, LSM_SETID_RES);
	if (retval)
D
David Howells 已提交
724 725
		goto error;
	old = current_cred();
L
Linus Torvalds 已提交
726

D
David Howells 已提交
727
	retval = -EPERM;
L
Linus Torvalds 已提交
728
	if (!capable(CAP_SETUID)) {
D
David Howells 已提交
729 730 731 732 733 734 735 736 737
		if (ruid != (uid_t) -1 && ruid != old->uid &&
		    ruid != old->euid  && ruid != old->suid)
			goto error;
		if (euid != (uid_t) -1 && euid != old->uid &&
		    euid != old->euid  && euid != old->suid)
			goto error;
		if (suid != (uid_t) -1 && suid != old->uid &&
		    suid != old->euid  && suid != old->suid)
			goto error;
L
Linus Torvalds 已提交
738
	}
D
David Howells 已提交
739

L
Linus Torvalds 已提交
740
	if (ruid != (uid_t) -1) {
D
David Howells 已提交
741
		new->uid = ruid;
742 743 744 745 746
		if (ruid != old->uid) {
			retval = set_user(new);
			if (retval < 0)
				goto error;
		}
L
Linus Torvalds 已提交
747
	}
D
David Howells 已提交
748 749
	if (euid != (uid_t) -1)
		new->euid = euid;
L
Linus Torvalds 已提交
750
	if (suid != (uid_t) -1)
D
David Howells 已提交
751 752
		new->suid = suid;
	new->fsuid = new->euid;
L
Linus Torvalds 已提交
753

D
David Howells 已提交
754 755 756
	retval = security_task_fix_setuid(new, old, LSM_SETID_RES);
	if (retval < 0)
		goto error;
L
Linus Torvalds 已提交
757

D
David Howells 已提交
758
	return commit_creds(new);
L
Linus Torvalds 已提交
759

D
David Howells 已提交
760 761 762
error:
	abort_creds(new);
	return retval;
L
Linus Torvalds 已提交
763 764
}

765
SYSCALL_DEFINE3(getresuid, uid_t __user *, ruid, uid_t __user *, euid, uid_t __user *, suid)
L
Linus Torvalds 已提交
766
{
767
	const struct cred *cred = current_cred();
L
Linus Torvalds 已提交
768 769
	int retval;

770 771
	if (!(retval   = put_user(cred->uid,  ruid)) &&
	    !(retval   = put_user(cred->euid, euid)))
772
		retval = put_user(cred->suid, suid);
L
Linus Torvalds 已提交
773 774 775 776 777 778 779

	return retval;
}

/*
 * Same as above, but for rgid, egid, sgid.
 */
780
SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
L
Linus Torvalds 已提交
781
{
D
David Howells 已提交
782 783
	const struct cred *old;
	struct cred *new;
L
Linus Torvalds 已提交
784 785
	int retval;

D
David Howells 已提交
786 787 788 789 790
	new = prepare_creds();
	if (!new)
		return -ENOMEM;
	old = current_cred();

L
Linus Torvalds 已提交
791 792
	retval = security_task_setgid(rgid, egid, sgid, LSM_SETID_RES);
	if (retval)
D
David Howells 已提交
793
		goto error;
L
Linus Torvalds 已提交
794

D
David Howells 已提交
795
	retval = -EPERM;
L
Linus Torvalds 已提交
796
	if (!capable(CAP_SETGID)) {
D
David Howells 已提交
797 798 799 800 801 802 803 804 805
		if (rgid != (gid_t) -1 && rgid != old->gid &&
		    rgid != old->egid  && rgid != old->sgid)
			goto error;
		if (egid != (gid_t) -1 && egid != old->gid &&
		    egid != old->egid  && egid != old->sgid)
			goto error;
		if (sgid != (gid_t) -1 && sgid != old->gid &&
		    sgid != old->egid  && sgid != old->sgid)
			goto error;
L
Linus Torvalds 已提交
806
	}
D
David Howells 已提交
807

L
Linus Torvalds 已提交
808
	if (rgid != (gid_t) -1)
D
David Howells 已提交
809 810 811
		new->gid = rgid;
	if (egid != (gid_t) -1)
		new->egid = egid;
L
Linus Torvalds 已提交
812
	if (sgid != (gid_t) -1)
D
David Howells 已提交
813 814
		new->sgid = sgid;
	new->fsgid = new->egid;
L
Linus Torvalds 已提交
815

D
David Howells 已提交
816 817 818 819 820
	return commit_creds(new);

error:
	abort_creds(new);
	return retval;
L
Linus Torvalds 已提交
821 822
}

823
SYSCALL_DEFINE3(getresgid, gid_t __user *, rgid, gid_t __user *, egid, gid_t __user *, sgid)
L
Linus Torvalds 已提交
824
{
825
	const struct cred *cred = current_cred();
L
Linus Torvalds 已提交
826 827
	int retval;

828 829
	if (!(retval   = put_user(cred->gid,  rgid)) &&
	    !(retval   = put_user(cred->egid, egid)))
830
		retval = put_user(cred->sgid, sgid);
L
Linus Torvalds 已提交
831 832 833 834 835 836 837 838 839 840 841

	return retval;
}


/*
 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
 * is used for "access()" and for the NFS daemon (letting nfsd stay at
 * whatever uid it wants to). It normally shadows "euid", except when
 * explicitly set by setfsuid() or for access..
 */
842
SYSCALL_DEFINE1(setfsuid, uid_t, uid)
L
Linus Torvalds 已提交
843
{
D
David Howells 已提交
844 845 846
	const struct cred *old;
	struct cred *new;
	uid_t old_fsuid;
L
Linus Torvalds 已提交
847

D
David Howells 已提交
848 849 850 851 852
	new = prepare_creds();
	if (!new)
		return current_fsuid();
	old = current_cred();
	old_fsuid = old->fsuid;
L
Linus Torvalds 已提交
853

D
David Howells 已提交
854 855
	if (security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS) < 0)
		goto error;
L
Linus Torvalds 已提交
856

D
David Howells 已提交
857 858
	if (uid == old->uid  || uid == old->euid  ||
	    uid == old->suid || uid == old->fsuid ||
859 860
	    capable(CAP_SETUID)) {
		if (uid != old_fsuid) {
D
David Howells 已提交
861 862 863
			new->fsuid = uid;
			if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0)
				goto change_okay;
L
Linus Torvalds 已提交
864 865 866
		}
	}

D
David Howells 已提交
867 868 869
error:
	abort_creds(new);
	return old_fsuid;
L
Linus Torvalds 已提交
870

D
David Howells 已提交
871 872
change_okay:
	commit_creds(new);
L
Linus Torvalds 已提交
873 874 875 876
	return old_fsuid;
}

/*
877
 * Samma på svenska..
L
Linus Torvalds 已提交
878
 */
879
SYSCALL_DEFINE1(setfsgid, gid_t, gid)
L
Linus Torvalds 已提交
880
{
D
David Howells 已提交
881 882 883 884 885 886 887 888 889
	const struct cred *old;
	struct cred *new;
	gid_t old_fsgid;

	new = prepare_creds();
	if (!new)
		return current_fsgid();
	old = current_cred();
	old_fsgid = old->fsgid;
L
Linus Torvalds 已提交
890 891

	if (security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_FS))
D
David Howells 已提交
892
		goto error;
L
Linus Torvalds 已提交
893

D
David Howells 已提交
894 895
	if (gid == old->gid  || gid == old->egid  ||
	    gid == old->sgid || gid == old->fsgid ||
896 897
	    capable(CAP_SETGID)) {
		if (gid != old_fsgid) {
D
David Howells 已提交
898 899
			new->fsgid = gid;
			goto change_okay;
L
Linus Torvalds 已提交
900 901
		}
	}
D
David Howells 已提交
902 903 904 905 906 907 908

error:
	abort_creds(new);
	return old_fsgid;

change_okay:
	commit_creds(new);
L
Linus Torvalds 已提交
909 910 911
	return old_fsgid;
}

912 913
void do_sys_times(struct tms *tms)
{
914
	cputime_t tgutime, tgstime, cutime, cstime;
915

916
	spin_lock_irq(&current->sighand->siglock);
917
	thread_group_times(current, &tgutime, &tgstime);
918 919 920
	cutime = current->signal->cutime;
	cstime = current->signal->cstime;
	spin_unlock_irq(&current->sighand->siglock);
921 922
	tms->tms_utime = cputime_to_clock_t(tgutime);
	tms->tms_stime = cputime_to_clock_t(tgstime);
923 924 925 926
	tms->tms_cutime = cputime_to_clock_t(cutime);
	tms->tms_cstime = cputime_to_clock_t(cstime);
}

927
SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
L
Linus Torvalds 已提交
928 929 930
{
	if (tbuf) {
		struct tms tmp;
931 932

		do_sys_times(&tmp);
L
Linus Torvalds 已提交
933 934 935
		if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
			return -EFAULT;
	}
936
	force_successful_syscall_return();
L
Linus Torvalds 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
	return (long) jiffies_64_to_clock_t(get_jiffies_64());
}

/*
 * This needs some heavy checking ...
 * I just haven't the stomach for it. I also don't fully
 * understand sessions/pgrp etc. Let somebody who does explain it.
 *
 * OK, I think I have the protection semantics right.... this is really
 * only important on a multi-user system anyway, to make sure one user
 * can't send a signal to a process owned by another.  -TYT, 12/12/91
 *
 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
 * LBT 04.03.94
 */
952
SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid)
L
Linus Torvalds 已提交
953 954
{
	struct task_struct *p;
955
	struct task_struct *group_leader = current->group_leader;
956 957
	struct pid *pgrp;
	int err;
L
Linus Torvalds 已提交
958 959

	if (!pid)
960
		pid = task_pid_vnr(group_leader);
L
Linus Torvalds 已提交
961 962 963 964 965 966 967 968 969 970 971
	if (!pgid)
		pgid = pid;
	if (pgid < 0)
		return -EINVAL;

	/* From this point forward we keep holding onto the tasklist lock
	 * so that our parent does not change from under us. -DaveM
	 */
	write_lock_irq(&tasklist_lock);

	err = -ESRCH;
972
	p = find_task_by_vpid(pid);
L
Linus Torvalds 已提交
973 974 975 976 977 978 979
	if (!p)
		goto out;

	err = -EINVAL;
	if (!thread_group_leader(p))
		goto out;

980
	if (same_thread_group(p->real_parent, group_leader)) {
L
Linus Torvalds 已提交
981
		err = -EPERM;
982
		if (task_session(p) != task_session(group_leader))
L
Linus Torvalds 已提交
983 984 985 986 987 988
			goto out;
		err = -EACCES;
		if (p->did_exec)
			goto out;
	} else {
		err = -ESRCH;
989
		if (p != group_leader)
L
Linus Torvalds 已提交
990 991 992 993 994 995 996
			goto out;
	}

	err = -EPERM;
	if (p->signal->leader)
		goto out;

997
	pgrp = task_pid(p);
L
Linus Torvalds 已提交
998
	if (pgid != pid) {
999
		struct task_struct *g;
L
Linus Torvalds 已提交
1000

1001 1002
		pgrp = find_vpid(pgid);
		g = pid_task(pgrp, PIDTYPE_PGID);
1003
		if (!g || task_session(g) != task_session(group_leader))
1004
			goto out;
L
Linus Torvalds 已提交
1005 1006 1007 1008 1009 1010
	}

	err = security_task_setpgid(p, pgid);
	if (err)
		goto out;

1011
	if (task_pgrp(p) != pgrp)
1012
		change_pid(p, PIDTYPE_PGID, pgrp);
L
Linus Torvalds 已提交
1013 1014 1015 1016 1017 1018 1019 1020

	err = 0;
out:
	/* All paths lead to here, thus we are safe. -DaveM */
	write_unlock_irq(&tasklist_lock);
	return err;
}

1021
SYSCALL_DEFINE1(getpgid, pid_t, pid)
L
Linus Torvalds 已提交
1022
{
1023 1024 1025 1026 1027
	struct task_struct *p;
	struct pid *grp;
	int retval;

	rcu_read_lock();
1028
	if (!pid)
1029
		grp = task_pgrp(current);
1030
	else {
L
Linus Torvalds 已提交
1031
		retval = -ESRCH;
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
		p = find_task_by_vpid(pid);
		if (!p)
			goto out;
		grp = task_pgrp(p);
		if (!grp)
			goto out;

		retval = security_task_getpgid(p);
		if (retval)
			goto out;
L
Linus Torvalds 已提交
1042
	}
1043 1044 1045 1046
	retval = pid_vnr(grp);
out:
	rcu_read_unlock();
	return retval;
L
Linus Torvalds 已提交
1047 1048 1049 1050
}

#ifdef __ARCH_WANT_SYS_GETPGRP

1051
SYSCALL_DEFINE0(getpgrp)
L
Linus Torvalds 已提交
1052
{
1053
	return sys_getpgid(0);
L
Linus Torvalds 已提交
1054 1055 1056 1057
}

#endif

1058
SYSCALL_DEFINE1(getsid, pid_t, pid)
L
Linus Torvalds 已提交
1059
{
1060 1061 1062 1063 1064
	struct task_struct *p;
	struct pid *sid;
	int retval;

	rcu_read_lock();
1065
	if (!pid)
1066
		sid = task_session(current);
1067
	else {
L
Linus Torvalds 已提交
1068
		retval = -ESRCH;
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
		p = find_task_by_vpid(pid);
		if (!p)
			goto out;
		sid = task_session(p);
		if (!sid)
			goto out;

		retval = security_task_getsid(p);
		if (retval)
			goto out;
L
Linus Torvalds 已提交
1079
	}
1080 1081 1082 1083
	retval = pid_vnr(sid);
out:
	rcu_read_unlock();
	return retval;
L
Linus Torvalds 已提交
1084 1085
}

1086
SYSCALL_DEFINE0(setsid)
L
Linus Torvalds 已提交
1087
{
1088
	struct task_struct *group_leader = current->group_leader;
1089 1090
	struct pid *sid = task_pid(group_leader);
	pid_t session = pid_vnr(sid);
L
Linus Torvalds 已提交
1091 1092 1093
	int err = -EPERM;

	write_lock_irq(&tasklist_lock);
1094 1095 1096 1097
	/* Fail if I am already a session leader */
	if (group_leader->signal->leader)
		goto out;

1098 1099
	/* Fail if a process group id already exists that equals the
	 * proposed session id.
1100
	 */
1101
	if (pid_task(sid, PIDTYPE_PGID))
L
Linus Torvalds 已提交
1102 1103
		goto out;

1104
	group_leader->signal->leader = 1;
1105
	__set_special_pids(sid);
1106

A
Alan Cox 已提交
1107
	proc_clear_tty(group_leader);
1108

1109
	err = session;
L
Linus Torvalds 已提交
1110 1111
out:
	write_unlock_irq(&tasklist_lock);
1112 1113
	if (err > 0)
		proc_sid_connector(group_leader);
L
Linus Torvalds 已提交
1114 1115 1116 1117 1118
	return err;
}

DECLARE_RWSEM(uts_sem);

1119
SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
L
Linus Torvalds 已提交
1120 1121 1122 1123
{
	int errno = 0;

	down_read(&uts_sem);
1124
	if (copy_to_user(name, utsname(), sizeof *name))
L
Linus Torvalds 已提交
1125 1126 1127 1128 1129
		errno = -EFAULT;
	up_read(&uts_sem);
	return errno;
}

1130
SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
L
Linus Torvalds 已提交
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
{
	int errno;
	char tmp[__NEW_UTS_LEN];

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	if (len < 0 || len > __NEW_UTS_LEN)
		return -EINVAL;
	down_write(&uts_sem);
	errno = -EFAULT;
	if (!copy_from_user(tmp, name, len)) {
1142 1143 1144 1145
		struct new_utsname *u = utsname();

		memcpy(u->nodename, tmp, len);
		memset(u->nodename + len, 0, sizeof(u->nodename) - len);
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151 1152 1153
		errno = 0;
	}
	up_write(&uts_sem);
	return errno;
}

#ifdef __ARCH_WANT_SYS_GETHOSTNAME

1154
SYSCALL_DEFINE2(gethostname, char __user *, name, int, len)
L
Linus Torvalds 已提交
1155 1156
{
	int i, errno;
1157
	struct new_utsname *u;
L
Linus Torvalds 已提交
1158 1159 1160 1161

	if (len < 0)
		return -EINVAL;
	down_read(&uts_sem);
1162 1163
	u = utsname();
	i = 1 + strlen(u->nodename);
L
Linus Torvalds 已提交
1164 1165 1166
	if (i > len)
		i = len;
	errno = 0;
1167
	if (copy_to_user(name, u->nodename, i))
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
		errno = -EFAULT;
	up_read(&uts_sem);
	return errno;
}

#endif

/*
 * Only setdomainname; getdomainname can be implemented by calling
 * uname()
 */
1179
SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len)
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
{
	int errno;
	char tmp[__NEW_UTS_LEN];

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	if (len < 0 || len > __NEW_UTS_LEN)
		return -EINVAL;

	down_write(&uts_sem);
	errno = -EFAULT;
	if (!copy_from_user(tmp, name, len)) {
1192 1193 1194 1195
		struct new_utsname *u = utsname();

		memcpy(u->domainname, tmp, len);
		memset(u->domainname + len, 0, sizeof(u->domainname) - len);
L
Linus Torvalds 已提交
1196 1197 1198 1199 1200 1201
		errno = 0;
	}
	up_write(&uts_sem);
	return errno;
}

1202
SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
L
Linus Torvalds 已提交
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
{
	if (resource >= RLIM_NLIMITS)
		return -EINVAL;
	else {
		struct rlimit value;
		task_lock(current->group_leader);
		value = current->signal->rlim[resource];
		task_unlock(current->group_leader);
		return copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
	}
}

#ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT

/*
 *	Back compatibility for getrlimit. Needed for some apps.
 */
 
1221 1222
SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
		struct rlimit __user *, rlim)
L
Linus Torvalds 已提交
1223 1224 1225 1226 1227 1228 1229 1230
{
	struct rlimit x;
	if (resource >= RLIM_NLIMITS)
		return -EINVAL;

	task_lock(current->group_leader);
	x = current->signal->rlim[resource];
	task_unlock(current->group_leader);
1231
	if (x.rlim_cur > 0x7FFFFFFF)
L
Linus Torvalds 已提交
1232
		x.rlim_cur = 0x7FFFFFFF;
1233
	if (x.rlim_max > 0x7FFFFFFF)
L
Linus Torvalds 已提交
1234 1235 1236 1237 1238 1239
		x.rlim_max = 0x7FFFFFFF;
	return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0;
}

#endif

1240
SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
L
Linus Torvalds 已提交
1241 1242 1243 1244 1245 1246
{
	struct rlimit new_rlim, *old_rlim;
	int retval;

	if (resource >= RLIM_NLIMITS)
		return -EINVAL;
A
Andrew Morton 已提交
1247
	if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
L
Linus Torvalds 已提交
1248
		return -EFAULT;
1249 1250
	if (new_rlim.rlim_cur > new_rlim.rlim_max)
		return -EINVAL;
L
Linus Torvalds 已提交
1251 1252 1253 1254
	old_rlim = current->signal->rlim + resource;
	if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
	    !capable(CAP_SYS_RESOURCE))
		return -EPERM;
1255 1256
	if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > sysctl_nr_open)
		return -EPERM;
L
Linus Torvalds 已提交
1257 1258 1259 1260 1261

	retval = security_task_setrlimit(resource, &new_rlim);
	if (retval)
		return retval;

1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	if (resource == RLIMIT_CPU && new_rlim.rlim_cur == 0) {
		/*
		 * The caller is asking for an immediate RLIMIT_CPU
		 * expiry.  But we use the zero value to mean "it was
		 * never set".  So let's cheat and make it one second
		 * instead
		 */
		new_rlim.rlim_cur = 1;
	}

L
Linus Torvalds 已提交
1272 1273 1274 1275
	task_lock(current->group_leader);
	*old_rlim = new_rlim;
	task_unlock(current->group_leader);

A
Andrew Morton 已提交
1276 1277
	if (resource != RLIMIT_CPU)
		goto out;
1278 1279 1280 1281 1282 1283 1284

	/*
	 * RLIMIT_CPU handling.   Note that the kernel fails to return an error
	 * code if it rejected the user's attempt to set RLIMIT_CPU.  This is a
	 * very long-standing error, and fixing it now risks breakage of
	 * applications, so we live with it
	 */
A
Andrew Morton 已提交
1285 1286 1287
	if (new_rlim.rlim_cur == RLIM_INFINITY)
		goto out;

1288
	update_rlimit_cpu(new_rlim.rlim_cur);
A
Andrew Morton 已提交
1289
out:
L
Linus Torvalds 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
	return 0;
}

/*
 * It would make sense to put struct rusage in the task_struct,
 * except that would make the task_struct be *really big*.  After
 * task_struct gets moved into malloc'ed memory, it would
 * make sense to do this.  It will make moving the rest of the information
 * a lot simpler!  (Which we're not doing right now because we're not
 * measuring them yet).
 *
 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
 * races with threads incrementing their own counters.  But since word
 * reads are atomic, we either get new values or old values and we don't
 * care which for the sums.  We always take the siglock to protect reading
 * the c* fields from p->signal from races with exit.c updating those
 * fields when reaping, so a sample either gets all the additions of a
 * given child after it's reaped, or none so this sample is before reaping.
1308
 *
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
 * Locking:
 * We need to take the siglock for CHILDEREN, SELF and BOTH
 * for  the cases current multithreaded, non-current single threaded
 * non-current multithreaded.  Thread traversal is now safe with
 * the siglock held.
 * Strictly speaking, we donot need to take the siglock if we are current and
 * single threaded,  as no one else can take our signal_struct away, no one
 * else can  reap the  children to update signal->c* counters, and no one else
 * can race with the signal-> fields. If we do not take any lock, the
 * signal-> fields could be read out of order while another thread was just
 * exiting. So we should  place a read memory barrier when we avoid the lock.
 * On the writer side,  write memory barrier is implied in  __exit_signal
 * as __exit_signal releases  the siglock spinlock after updating the signal->
 * fields. But we don't do this yet to keep things simple.
1323
 *
L
Linus Torvalds 已提交
1324 1325
 */

1326
static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r)
S
Sripathi Kodi 已提交
1327 1328 1329 1330 1331 1332 1333 1334 1335
{
	r->ru_nvcsw += t->nvcsw;
	r->ru_nivcsw += t->nivcsw;
	r->ru_minflt += t->min_flt;
	r->ru_majflt += t->maj_flt;
	r->ru_inblock += task_io_get_inblock(t);
	r->ru_oublock += task_io_get_oublock(t);
}

L
Linus Torvalds 已提交
1336 1337 1338 1339
static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
{
	struct task_struct *t;
	unsigned long flags;
1340
	cputime_t tgutime, tgstime, utime, stime;
J
Jiri Pirko 已提交
1341
	unsigned long maxrss = 0;
L
Linus Torvalds 已提交
1342 1343

	memset((char *) r, 0, sizeof *r);
1344
	utime = stime = cputime_zero;
L
Linus Torvalds 已提交
1345

S
Sripathi Kodi 已提交
1346
	if (who == RUSAGE_THREAD) {
1347
		task_times(current, &utime, &stime);
1348
		accumulate_thread_rusage(p, r);
J
Jiri Pirko 已提交
1349
		maxrss = p->signal->maxrss;
S
Sripathi Kodi 已提交
1350 1351 1352
		goto out;
	}

1353
	if (!lock_task_sighand(p, &flags))
1354
		return;
O
Oleg Nesterov 已提交
1355

L
Linus Torvalds 已提交
1356
	switch (who) {
O
Oleg Nesterov 已提交
1357
		case RUSAGE_BOTH:
L
Linus Torvalds 已提交
1358 1359 1360 1361 1362 1363 1364
		case RUSAGE_CHILDREN:
			utime = p->signal->cutime;
			stime = p->signal->cstime;
			r->ru_nvcsw = p->signal->cnvcsw;
			r->ru_nivcsw = p->signal->cnivcsw;
			r->ru_minflt = p->signal->cmin_flt;
			r->ru_majflt = p->signal->cmaj_flt;
1365 1366
			r->ru_inblock = p->signal->cinblock;
			r->ru_oublock = p->signal->coublock;
J
Jiri Pirko 已提交
1367
			maxrss = p->signal->cmaxrss;
O
Oleg Nesterov 已提交
1368 1369 1370 1371

			if (who == RUSAGE_CHILDREN)
				break;

L
Linus Torvalds 已提交
1372
		case RUSAGE_SELF:
1373 1374 1375
			thread_group_times(p, &tgutime, &tgstime);
			utime = cputime_add(utime, tgutime);
			stime = cputime_add(stime, tgstime);
L
Linus Torvalds 已提交
1376 1377 1378 1379
			r->ru_nvcsw += p->signal->nvcsw;
			r->ru_nivcsw += p->signal->nivcsw;
			r->ru_minflt += p->signal->min_flt;
			r->ru_majflt += p->signal->maj_flt;
1380 1381
			r->ru_inblock += p->signal->inblock;
			r->ru_oublock += p->signal->oublock;
J
Jiri Pirko 已提交
1382 1383
			if (maxrss < p->signal->maxrss)
				maxrss = p->signal->maxrss;
L
Linus Torvalds 已提交
1384 1385
			t = p;
			do {
1386
				accumulate_thread_rusage(t, r);
L
Linus Torvalds 已提交
1387 1388 1389
				t = next_thread(t);
			} while (t != p);
			break;
O
Oleg Nesterov 已提交
1390

L
Linus Torvalds 已提交
1391 1392 1393
		default:
			BUG();
	}
1394 1395
	unlock_task_sighand(p, &flags);

S
Sripathi Kodi 已提交
1396
out:
O
Oleg Nesterov 已提交
1397 1398
	cputime_to_timeval(utime, &r->ru_utime);
	cputime_to_timeval(stime, &r->ru_stime);
J
Jiri Pirko 已提交
1399 1400 1401 1402 1403 1404 1405 1406 1407

	if (who != RUSAGE_CHILDREN) {
		struct mm_struct *mm = get_task_mm(p);
		if (mm) {
			setmax_mm_hiwater_rss(&maxrss, mm);
			mmput(mm);
		}
	}
	r->ru_maxrss = maxrss * (PAGE_SIZE / 1024); /* convert pages to KBs */
L
Linus Torvalds 已提交
1408 1409 1410 1411 1412 1413 1414 1415 1416
}

int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
{
	struct rusage r;
	k_getrusage(p, who, &r);
	return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
}

1417
SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
L
Linus Torvalds 已提交
1418
{
S
Sripathi Kodi 已提交
1419 1420
	if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
	    who != RUSAGE_THREAD)
L
Linus Torvalds 已提交
1421 1422 1423 1424
		return -EINVAL;
	return getrusage(current, who, ru);
}

1425
SYSCALL_DEFINE1(umask, int, mask)
L
Linus Torvalds 已提交
1426 1427 1428 1429
{
	mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
	return mask;
}
1430

1431 1432
SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
		unsigned long, arg4, unsigned long, arg5)
L
Linus Torvalds 已提交
1433
{
1434 1435 1436
	struct task_struct *me = current;
	unsigned char comm[sizeof(me->comm)];
	long error;
L
Linus Torvalds 已提交
1437

D
David Howells 已提交
1438 1439
	error = security_task_prctl(option, arg2, arg3, arg4, arg5);
	if (error != -ENOSYS)
L
Linus Torvalds 已提交
1440 1441
		return error;

D
David Howells 已提交
1442
	error = 0;
L
Linus Torvalds 已提交
1443 1444
	switch (option) {
		case PR_SET_PDEATHSIG:
1445
			if (!valid_signal(arg2)) {
L
Linus Torvalds 已提交
1446 1447 1448
				error = -EINVAL;
				break;
			}
1449 1450
			me->pdeath_signal = arg2;
			error = 0;
L
Linus Torvalds 已提交
1451 1452
			break;
		case PR_GET_PDEATHSIG:
1453
			error = put_user(me->pdeath_signal, (int __user *)arg2);
L
Linus Torvalds 已提交
1454 1455
			break;
		case PR_GET_DUMPABLE:
1456
			error = get_dumpable(me->mm);
L
Linus Torvalds 已提交
1457 1458
			break;
		case PR_SET_DUMPABLE:
1459
			if (arg2 < 0 || arg2 > 1) {
L
Linus Torvalds 已提交
1460 1461 1462
				error = -EINVAL;
				break;
			}
1463 1464
			set_dumpable(me->mm, arg2);
			error = 0;
L
Linus Torvalds 已提交
1465 1466 1467
			break;

		case PR_SET_UNALIGN:
1468
			error = SET_UNALIGN_CTL(me, arg2);
L
Linus Torvalds 已提交
1469 1470
			break;
		case PR_GET_UNALIGN:
1471
			error = GET_UNALIGN_CTL(me, arg2);
L
Linus Torvalds 已提交
1472 1473
			break;
		case PR_SET_FPEMU:
1474
			error = SET_FPEMU_CTL(me, arg2);
L
Linus Torvalds 已提交
1475 1476
			break;
		case PR_GET_FPEMU:
1477
			error = GET_FPEMU_CTL(me, arg2);
L
Linus Torvalds 已提交
1478 1479
			break;
		case PR_SET_FPEXC:
1480
			error = SET_FPEXC_CTL(me, arg2);
L
Linus Torvalds 已提交
1481 1482
			break;
		case PR_GET_FPEXC:
1483
			error = GET_FPEXC_CTL(me, arg2);
L
Linus Torvalds 已提交
1484 1485 1486 1487 1488
			break;
		case PR_GET_TIMING:
			error = PR_TIMING_STATISTICAL;
			break;
		case PR_SET_TIMING:
1489
			if (arg2 != PR_TIMING_STATISTICAL)
L
Linus Torvalds 已提交
1490
				error = -EINVAL;
1491 1492
			else
				error = 0;
L
Linus Torvalds 已提交
1493 1494
			break;

1495 1496 1497 1498
		case PR_SET_NAME:
			comm[sizeof(me->comm)-1] = 0;
			if (strncpy_from_user(comm, (char __user *)arg2,
					      sizeof(me->comm) - 1) < 0)
L
Linus Torvalds 已提交
1499
				return -EFAULT;
1500
			set_task_comm(me, comm);
L
Linus Torvalds 已提交
1501
			return 0;
1502 1503 1504 1505
		case PR_GET_NAME:
			get_task_comm(comm, me);
			if (copy_to_user((char __user *)arg2, comm,
					 sizeof(comm)))
L
Linus Torvalds 已提交
1506 1507
				return -EFAULT;
			return 0;
1508
		case PR_GET_ENDIAN:
1509
			error = GET_ENDIAN(me, arg2);
1510 1511
			break;
		case PR_SET_ENDIAN:
1512
			error = SET_ENDIAN(me, arg2);
1513 1514
			break;

1515 1516 1517 1518 1519 1520
		case PR_GET_SECCOMP:
			error = prctl_get_seccomp();
			break;
		case PR_SET_SECCOMP:
			error = prctl_set_seccomp(arg2);
			break;
1521 1522 1523 1524 1525 1526
		case PR_GET_TSC:
			error = GET_TSC_CTL(arg2);
			break;
		case PR_SET_TSC:
			error = SET_TSC_CTL(arg2);
			break;
1527 1528
		case PR_TASK_PERF_EVENTS_DISABLE:
			error = perf_event_task_disable();
1529
			break;
1530 1531
		case PR_TASK_PERF_EVENTS_ENABLE:
			error = perf_event_task_enable();
1532
			break;
1533 1534 1535 1536 1537 1538 1539 1540 1541
		case PR_GET_TIMERSLACK:
			error = current->timer_slack_ns;
			break;
		case PR_SET_TIMERSLACK:
			if (arg2 <= 0)
				current->timer_slack_ns =
					current->default_timer_slack_ns;
			else
				current->timer_slack_ns = arg2;
1542
			error = 0;
1543
			break;
1544 1545 1546 1547
		case PR_MCE_KILL:
			if (arg4 | arg5)
				return -EINVAL;
			switch (arg2) {
1548
			case PR_MCE_KILL_CLEAR:
1549 1550 1551 1552
				if (arg3 != 0)
					return -EINVAL;
				current->flags &= ~PF_MCE_PROCESS;
				break;
1553
			case PR_MCE_KILL_SET:
1554
				current->flags |= PF_MCE_PROCESS;
1555
				if (arg3 == PR_MCE_KILL_EARLY)
1556
					current->flags |= PF_MCE_EARLY;
1557
				else if (arg3 == PR_MCE_KILL_LATE)
1558
					current->flags &= ~PF_MCE_EARLY;
1559 1560 1561 1562 1563
				else if (arg3 == PR_MCE_KILL_DEFAULT)
					current->flags &=
						~(PF_MCE_EARLY|PF_MCE_PROCESS);
				else
					return -EINVAL;
1564 1565 1566 1567 1568 1569
				break;
			default:
				return -EINVAL;
			}
			error = 0;
			break;
1570 1571 1572 1573 1574 1575 1576 1577 1578
		case PR_MCE_KILL_GET:
			if (arg2 | arg3 | arg4 | arg5)
				return -EINVAL;
			if (current->flags & PF_MCE_PROCESS)
				error = (current->flags & PF_MCE_EARLY) ?
					PR_MCE_KILL_EARLY : PR_MCE_KILL_LATE;
			else
				error = PR_MCE_KILL_DEFAULT;
			break;
L
Linus Torvalds 已提交
1579 1580 1581 1582 1583 1584
		default:
			error = -EINVAL;
			break;
	}
	return error;
}
1585

1586 1587
SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep,
		struct getcpu_cache __user *, unused)
1588 1589 1590 1591 1592 1593 1594 1595 1596
{
	int err = 0;
	int cpu = raw_smp_processor_id();
	if (cpup)
		err |= put_user(cpu, cpup);
	if (nodep)
		err |= put_user(cpu_to_node(cpu), nodep);
	return err ? -EFAULT : 0;
}
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629

char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";

static void argv_cleanup(char **argv, char **envp)
{
	argv_free(argv);
}

/**
 * orderly_poweroff - Trigger an orderly system poweroff
 * @force: force poweroff if command execution fails
 *
 * This may be called from any context to trigger a system shutdown.
 * If the orderly shutdown fails, it will force an immediate shutdown.
 */
int orderly_poweroff(bool force)
{
	int argc;
	char **argv = argv_split(GFP_ATOMIC, poweroff_cmd, &argc);
	static char *envp[] = {
		"HOME=/",
		"PATH=/sbin:/bin:/usr/sbin:/usr/bin",
		NULL
	};
	int ret = -ENOMEM;
	struct subprocess_info *info;

	if (argv == NULL) {
		printk(KERN_WARNING "%s failed to allocate memory for \"%s\"\n",
		       __func__, poweroff_cmd);
		goto out;
	}

1630
	info = call_usermodehelper_setup(argv[0], argv, envp, GFP_ATOMIC);
1631 1632 1633 1634 1635 1636 1637
	if (info == NULL) {
		argv_free(argv);
		goto out;
	}

	call_usermodehelper_setcleanup(info, argv_cleanup);

1638
	ret = call_usermodehelper_exec(info, UMH_NO_WAIT);
1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654

  out:
	if (ret && force) {
		printk(KERN_WARNING "Failed to start orderly shutdown: "
		       "forcing the issue\n");

		/* I guess this should try to kick off some daemon to
		   sync and poweroff asap.  Or not even bother syncing
		   if we're doing an emergency shutdown? */
		emergency_sync();
		kernel_power_off();
	}

	return ret;
}
EXPORT_SYMBOL_GPL(orderly_poweroff);