projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.10.55' into update
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / kernel / sys.c
1 /*
2 * linux/kernel/sys.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7 #include <linux/export.h>
8 #include <linux/mm.h>
9 #include <linux/utsname.h>
10 #include <linux/mman.h>
11 #include <linux/reboot.h>
12 #include <linux/prctl.h>
13 #include <linux/highuid.h>
14 #include <linux/fs.h>
15 #include <linux/kmod.h>
16 #include <linux/perf_event.h>
17 #include <linux/resource.h>
18 #include <linux/kernel.h>
19 #include <linux/kexec.h>
20 #include <linux/workqueue.h>
21 #include <linux/capability.h>
22 #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>
30 #include <linux/signal.h>
31 #include <linux/cn_proc.h>
32 #include <linux/getcpu.h>
33 #include <linux/task_io_accounting_ops.h>
34 #include <linux/seccomp.h>
35 #include <linux/cpu.h>
36 #include <linux/personality.h>
37 #include <linux/ptrace.h>
38 #include <linux/fs_struct.h>
39 #include <linux/file.h>
40 #include <linux/mount.h>
41 #include <linux/gfp.h>
42 #include <linux/syscore_ops.h>
43 #include <linux/version.h>
44 #include <linux/ctype.h>
45 #include <linux/mm.h>
46 #include <linux/mempolicy.h>
47 #include <linux/sched.h>
48
49 #include <linux/compat.h>
50 #include <linux/syscalls.h>
51 #include <linux/kprobes.h>
52 #include <linux/user_namespace.h>
53 #include <linux/binfmts.h>
54
55 #include <linux/sched.h>
56 #include <linux/rcupdate.h>
57 #include <linux/uidgid.h>
58 #include <linux/cred.h>
59
60 #include <linux/kmsg_dump.h>
61 /* Move somewhere else to avoid recompiling? */
62 #include <generated/utsrelease.h>
63
64 #include <asm/uaccess.h>
65 #include <asm/io.h>
66 #include <asm/unistd.h>
67
68 #ifdef CONFIG_MT_PRIO_TRACER
69 # include <linux/prio_tracer.h>
70 #endif
71
72 #ifndef SET_UNALIGN_CTL
73 # define SET_UNALIGN_CTL(a,b) (-EINVAL)
74 #endif
75 #ifndef GET_UNALIGN_CTL
76 # define GET_UNALIGN_CTL(a,b) (-EINVAL)
77 #endif
78 #ifndef SET_FPEMU_CTL
79 # define SET_FPEMU_CTL(a,b) (-EINVAL)
80 #endif
81 #ifndef GET_FPEMU_CTL
82 # define GET_FPEMU_CTL(a,b) (-EINVAL)
83 #endif
84 #ifndef SET_FPEXC_CTL
85 # define SET_FPEXC_CTL(a,b) (-EINVAL)
86 #endif
87 #ifndef GET_FPEXC_CTL
88 # define GET_FPEXC_CTL(a,b) (-EINVAL)
89 #endif
90 #ifndef GET_ENDIAN
91 # define GET_ENDIAN(a,b) (-EINVAL)
92 #endif
93 #ifndef SET_ENDIAN
94 # define SET_ENDIAN(a,b) (-EINVAL)
95 #endif
96 #ifndef GET_TSC_CTL
97 # define GET_TSC_CTL(a) (-EINVAL)
98 #endif
99 #ifndef SET_TSC_CTL
100 # define SET_TSC_CTL(a) (-EINVAL)
101 #endif
102
103 /*
104 * this is where the system-wide overflow UID and GID are defined, for
105 * architectures that now have 32-bit UID/GID but didn't in the past
106 */
107
108 int overflowuid = DEFAULT_OVERFLOWUID;
109 int overflowgid = DEFAULT_OVERFLOWGID;
110
111 EXPORT_SYMBOL(overflowuid);
112 EXPORT_SYMBOL(overflowgid);
113
114 /*
115 * the same as above, but for filesystems which can only store a 16-bit
116 * UID and GID. as such, this is needed on all architectures
117 */
118
119 int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
120 int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;
121
122 EXPORT_SYMBOL(fs_overflowuid);
123 EXPORT_SYMBOL(fs_overflowgid);
124
125 /*
126 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
127 */
128
129 int C_A_D = 1;
130 struct pid *cad_pid;
131 EXPORT_SYMBOL(cad_pid);
132
133 /*
134 * If set, this is used for preparing the system to power off.
135 */
136
137 void (*pm_power_off_prepare)(void);
138
139 /*
140 * Returns true if current's euid is same as p's uid or euid,
141 * or has CAP_SYS_NICE to p's user_ns.
142 *
143 * Called with rcu_read_lock, creds are safe
144 */
145 static bool set_one_prio_perm(struct task_struct *p)
146 {
147 const struct cred *cred = current_cred(), *pcred = __task_cred(p);
148
149 if (uid_eq(pcred->uid, cred->euid) ||
150 uid_eq(pcred->euid, cred->euid))
151 return true;
152 if (ns_capable(pcred->user_ns, CAP_SYS_NICE))
153 return true;
154 return false;
155 }
156
157 /*
158 * set the priority of a task
159 * - the caller must hold the RCU read lock
160 */
161 static int set_one_prio(struct task_struct *p, int niceval, int error)
162 {
163 int no_nice;
164
165 if (!set_one_prio_perm(p)) {
166 error = -EPERM;
167 goto out;
168 }
169 if (niceval < task_nice(p) && !can_nice(p, niceval)) {
170 error = -EACCES;
171 goto out;
172 }
173 no_nice = security_task_setnice(p, niceval);
174 if (no_nice) {
175 error = no_nice;
176 goto out;
177 }
178 if (error == -ESRCH)
179 error = 0;
180 #ifdef CONFIG_MT_PRIO_TRACER
181 set_user_nice_syscall(p, niceval);
182 #else
183 set_user_nice(p, niceval);
184 #endif
185 out:
186 return error;
187 }
188
189 SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
190 {
191 struct task_struct *g, *p;
192 struct user_struct *user;
193 const struct cred *cred = current_cred();
194 int error = -EINVAL;
195 struct pid *pgrp;
196 kuid_t uid;
197
198 if (which > PRIO_USER || which < PRIO_PROCESS)
199 goto out;
200
201 /* normalize: avoid signed division (rounding problems) */
202 error = -ESRCH;
203 if (niceval < -20)
204 niceval = -20;
205 if (niceval > 19)
206 niceval = 19;
207
208 rcu_read_lock();
209 read_lock(&tasklist_lock);
210 switch (which) {
211 case PRIO_PROCESS:
212 if (who)
213 p = find_task_by_vpid(who);
214 else
215 p = current;
216 if (p)
217 error = set_one_prio(p, niceval, error);
218 break;
219 case PRIO_PGRP:
220 if (who)
221 pgrp = find_vpid(who);
222 else
223 pgrp = task_pgrp(current);
224 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
225 error = set_one_prio(p, niceval, error);
226 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
227 break;
228 case PRIO_USER:
229 uid = make_kuid(cred->user_ns, who);
230 user = cred->user;
231 if (!who)
232 uid = cred->uid;
233 else if (!uid_eq(uid, cred->uid) &&
234 !(user = find_user(uid)))
235 goto out_unlock; /* No processes for this user */
236
237 do_each_thread(g, p) {
238 if (uid_eq(task_uid(p), uid))
239 error = set_one_prio(p, niceval, error);
240 } while_each_thread(g, p);
241 if (!uid_eq(uid, cred->uid))
242 free_uid(user); /* For find_user() */
243 break;
244 }
245 out_unlock:
246 read_unlock(&tasklist_lock);
247 rcu_read_unlock();
248 out:
249 return error;
250 }
251
252 /*
253 * Ugh. To avoid negative return values, "getpriority()" will
254 * not return the normal nice-value, but a negated value that
255 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
256 * to stay compatible.
257 */
258 SYSCALL_DEFINE2(getpriority, int, which, int, who)
259 {
260 struct task_struct *g, *p;
261 struct user_struct *user;
262 const struct cred *cred = current_cred();
263 long niceval, retval = -ESRCH;
264 struct pid *pgrp;
265 kuid_t uid;
266
267 if (which > PRIO_USER || which < PRIO_PROCESS)
268 return -EINVAL;
269
270 rcu_read_lock();
271 read_lock(&tasklist_lock);
272 switch (which) {
273 case PRIO_PROCESS:
274 if (who)
275 p = find_task_by_vpid(who);
276 else
277 p = current;
278 if (p) {
279 niceval = 20 - task_nice(p);
280 if (niceval > retval)
281 retval = niceval;
282 }
283 break;
284 case PRIO_PGRP:
285 if (who)
286 pgrp = find_vpid(who);
287 else
288 pgrp = task_pgrp(current);
289 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
290 niceval = 20 - task_nice(p);
291 if (niceval > retval)
292 retval = niceval;
293 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
294 break;
295 case PRIO_USER:
296 uid = make_kuid(cred->user_ns, who);
297 user = cred->user;
298 if (!who)
299 uid = cred->uid;
300 else if (!uid_eq(uid, cred->uid) &&
301 !(user = find_user(uid)))
302 goto out_unlock; /* No processes for this user */
303
304 do_each_thread(g, p) {
305 if (uid_eq(task_uid(p), uid)) {
306 niceval = 20 - task_nice(p);
307 if (niceval > retval)
308 retval = niceval;
309 }
310 } while_each_thread(g, p);
311 if (!uid_eq(uid, cred->uid))
312 free_uid(user); /* for find_user() */
313 break;
314 }
315 out_unlock:
316 read_unlock(&tasklist_lock);
317 rcu_read_unlock();
318
319 return retval;
320 }
321
322 /**
323 * emergency_restart - reboot the system
324 *
325 * Without shutting down any hardware or taking any locks
326 * reboot the system. This is called when we know we are in
327 * trouble so this is our best effort to reboot. This is
328 * safe to call in interrupt context.
329 */
330 void emergency_restart(void)
331 {
332 kmsg_dump(KMSG_DUMP_EMERG);
333 machine_emergency_restart();
334 }
335 EXPORT_SYMBOL_GPL(emergency_restart);
336
337 void kernel_restart_prepare(char *cmd)
338 {
339 blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
340 system_state = SYSTEM_RESTART;
341 usermodehelper_disable();
342 device_shutdown();
343 }
344
345 /**
346 * register_reboot_notifier - Register function to be called at reboot time
347 * @nb: Info about notifier function to be called
348 *
349 * Registers a function with the list of functions
350 * to be called at reboot time.
351 *
352 * Currently always returns zero, as blocking_notifier_chain_register()
353 * always returns zero.
354 */
355 int register_reboot_notifier(struct notifier_block *nb)
356 {
357 return blocking_notifier_chain_register(&reboot_notifier_list, nb);
358 }
359 EXPORT_SYMBOL(register_reboot_notifier);
360
361 /**
362 * unregister_reboot_notifier - Unregister previously registered reboot notifier
363 * @nb: Hook to be unregistered
364 *
365 * Unregisters a previously registered reboot
366 * notifier function.
367 *
368 * Returns zero on success, or %-ENOENT on failure.
369 */
370 int unregister_reboot_notifier(struct notifier_block *nb)
371 {
372 return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
373 }
374 EXPORT_SYMBOL(unregister_reboot_notifier);
375
376 /* Add backwards compatibility for stable trees. */
377 #ifndef PF_NO_SETAFFINITY
378 #define PF_NO_SETAFFINITY PF_THREAD_BOUND
379 #endif
380
381 static void migrate_to_reboot_cpu(void)
382 {
383 /* The boot cpu is always logical cpu 0 */
384 int cpu = 0;
385
386 cpu_hotplug_disable();
387
388 /* Make certain the cpu I'm about to reboot on is online */
389 if (!cpu_online(cpu))
390 cpu = cpumask_first(cpu_online_mask);
391
392 /* Prevent races with other tasks migrating this task */
393 current->flags |= PF_NO_SETAFFINITY;
394
395 /* Make certain I only run on the appropriate processor */
396 set_cpus_allowed_ptr(current, cpumask_of(cpu));
397 }
398
399 /**
400 * kernel_restart - reboot the system
401 * @cmd: pointer to buffer containing command to execute for restart
402 * or %NULL
403 *
404 * Shutdown everything and perform a clean reboot.
405 * This is not safe to call in interrupt context.
406 */
407 void kernel_restart(char *cmd)
408 {
409 kernel_restart_prepare(cmd);
410 migrate_to_reboot_cpu();
411 syscore_shutdown();
412 if (!cmd)
413 printk(KERN_EMERG "Restarting system.\n");
414 else
415 printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
416 kmsg_dump(KMSG_DUMP_RESTART);
417 machine_restart(cmd);
418 }
419 EXPORT_SYMBOL_GPL(kernel_restart);
420
421 static void kernel_shutdown_prepare(enum system_states state)
422 {
423 blocking_notifier_call_chain(&reboot_notifier_list,
424 (state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL);
425 system_state = state;
426 usermodehelper_disable();
427 device_shutdown();
428 }
429 /**
430 * kernel_halt - halt the system
431 *
432 * Shutdown everything and perform a clean system halt.
433 */
434 void kernel_halt(void)
435 {
436 kernel_shutdown_prepare(SYSTEM_HALT);
437 migrate_to_reboot_cpu();
438 syscore_shutdown();
439 printk(KERN_EMERG "System halted.\n");
440 kmsg_dump(KMSG_DUMP_HALT);
441 machine_halt();
442 }
443
444 EXPORT_SYMBOL_GPL(kernel_halt);
445
446 /**
447 * kernel_power_off - power_off the system
448 *
449 * Shutdown everything and perform a clean system power_off.
450 */
451 void kernel_power_off(void)
452 {
453 kernel_shutdown_prepare(SYSTEM_POWER_OFF);
454 if (pm_power_off_prepare)
455 pm_power_off_prepare();
456 migrate_to_reboot_cpu();
457 syscore_shutdown();
458 printk(KERN_EMERG "Power down.\n");
459 kmsg_dump(KMSG_DUMP_POWEROFF);
460 machine_power_off();
461 }
462 EXPORT_SYMBOL_GPL(kernel_power_off);
463
464 static DEFINE_MUTEX(reboot_mutex);
465
466 /*
467 * Reboot system call: for obvious reasons only root may call it,
468 * and even root needs to set up some magic numbers in the registers
469 * so that some mistake won't make this reboot the whole machine.
470 * You can also set the meaning of the ctrl-alt-del-key here.
471 *
472 * reboot doesn't sync: do that yourself before calling this.
473 */
474 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
475 void __user *, arg)
476 {
477 struct pid_namespace *pid_ns = task_active_pid_ns(current);
478 char buffer[256];
479 int ret = 0;
480
481 /* We only trust the superuser with rebooting the system. */
482 if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
483 return -EPERM;
484
485 /* For safety, we require "magic" arguments. */
486 if (magic1 != LINUX_REBOOT_MAGIC1 ||
487 (magic2 != LINUX_REBOOT_MAGIC2 &&
488 magic2 != LINUX_REBOOT_MAGIC2A &&
489 magic2 != LINUX_REBOOT_MAGIC2B &&
490 magic2 != LINUX_REBOOT_MAGIC2C))
491 return -EINVAL;
492
493 /*
494 * If pid namespaces are enabled and the current task is in a child
495 * pid_namespace, the command is handled by reboot_pid_ns() which will
496 * call do_exit().
497 */
498 ret = reboot_pid_ns(pid_ns, cmd);
499 if (ret)
500 return ret;
501
502 /* Instead of trying to make the power_off code look like
503 * halt when pm_power_off is not set do it the easy way.
504 */
505 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
506 cmd = LINUX_REBOOT_CMD_HALT;
507
508 mutex_lock(&reboot_mutex);
509 switch (cmd) {
510 case LINUX_REBOOT_CMD_RESTART:
511 kernel_restart(NULL);
512 break;
513
514 case LINUX_REBOOT_CMD_CAD_ON:
515 C_A_D = 1;
516 break;
517
518 case LINUX_REBOOT_CMD_CAD_OFF:
519 C_A_D = 0;
520 break;
521
522 case LINUX_REBOOT_CMD_HALT:
523 kernel_halt();
524 do_exit(0);
525 panic("cannot halt");
526
527 case LINUX_REBOOT_CMD_POWER_OFF:
528 kernel_power_off();
529 do_exit(0);
530 break;
531
532 case LINUX_REBOOT_CMD_RESTART2:
533 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
534 ret = -EFAULT;
535 break;
536 }
537 buffer[sizeof(buffer) - 1] = '\0';
538
539 kernel_restart(buffer);
540 break;
541
542 #ifdef CONFIG_KEXEC
543 case LINUX_REBOOT_CMD_KEXEC:
544 ret = kernel_kexec();
545 break;
546 #endif
547
548 #ifdef CONFIG_HIBERNATION
549 case LINUX_REBOOT_CMD_SW_SUSPEND:
550 ret = hibernate();
551 break;
552 #endif
553
554 default:
555 ret = -EINVAL;
556 break;
557 }
558 mutex_unlock(&reboot_mutex);
559 return ret;
560 }
561
562 static void deferred_cad(struct work_struct *dummy)
563 {
564 kernel_restart(NULL);
565 }
566
567 /*
568 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
569 * As it's called within an interrupt, it may NOT sync: the only choice
570 * is whether to reboot at once, or just ignore the ctrl-alt-del.
571 */
572 void ctrl_alt_del(void)
573 {
574 static DECLARE_WORK(cad_work, deferred_cad);
575
576 if (C_A_D)
577 schedule_work(&cad_work);
578 else
579 kill_cad_pid(SIGINT, 1);
580 }
581
582 /*
583 * Unprivileged users may change the real gid to the effective gid
584 * or vice versa. (BSD-style)
585 *
586 * If you set the real gid at all, or set the effective gid to a value not
587 * equal to the real gid, then the saved gid is set to the new effective gid.
588 *
589 * This makes it possible for a setgid program to completely drop its
590 * privileges, which is often a useful assertion to make when you are doing
591 * a security audit over a program.
592 *
593 * The general idea is that a program which uses just setregid() will be
594 * 100% compatible with BSD. A program which uses just setgid() will be
595 * 100% compatible with POSIX with saved IDs.
596 *
597 * SMP: There are not races, the GIDs are checked only by filesystem
598 * operations (as far as semantic preservation is concerned).
599 */
600 SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
601 {
602 struct user_namespace *ns = current_user_ns();
603 const struct cred *old;
604 struct cred *new;
605 int retval;
606 kgid_t krgid, kegid;
607
608 krgid = make_kgid(ns, rgid);
609 kegid = make_kgid(ns, egid);
610
611 if ((rgid != (gid_t) -1) && !gid_valid(krgid))
612 return -EINVAL;
613 if ((egid != (gid_t) -1) && !gid_valid(kegid))
614 return -EINVAL;
615
616 new = prepare_creds();
617 if (!new)
618 return -ENOMEM;
619 old = current_cred();
620
621 retval = -EPERM;
622 if (rgid != (gid_t) -1) {
623 if (gid_eq(old->gid, krgid) ||
624 gid_eq(old->egid, krgid) ||
625 nsown_capable(CAP_SETGID))
626 new->gid = krgid;
627 else
628 goto error;
629 }
630 if (egid != (gid_t) -1) {
631 if (gid_eq(old->gid, kegid) ||
632 gid_eq(old->egid, kegid) ||
633 gid_eq(old->sgid, kegid) ||
634 nsown_capable(CAP_SETGID))
635 new->egid = kegid;
636 else
637 goto error;
638 }
639
640 if (rgid != (gid_t) -1 ||
641 (egid != (gid_t) -1 && !gid_eq(kegid, old->gid)))
642 new->sgid = new->egid;
643 new->fsgid = new->egid;
644
645 return commit_creds(new);
646
647 error:
648 abort_creds(new);
649 return retval;
650 }
651
652 /*
653 * setgid() is implemented like SysV w/ SAVED_IDS
654 *
655 * SMP: Same implicit races as above.
656 */
657 SYSCALL_DEFINE1(setgid, gid_t, gid)
658 {
659 struct user_namespace *ns = current_user_ns();
660 const struct cred *old;
661 struct cred *new;
662 int retval;
663 kgid_t kgid;
664
665 kgid = make_kgid(ns, gid);
666 if (!gid_valid(kgid))
667 return -EINVAL;
668
669 new = prepare_creds();
670 if (!new)
671 return -ENOMEM;
672 old = current_cred();
673
674 retval = -EPERM;
675 if (nsown_capable(CAP_SETGID))
676 new->gid = new->egid = new->sgid = new->fsgid = kgid;
677 else if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->sgid))
678 new->egid = new->fsgid = kgid;
679 else
680 goto error;
681
682 return commit_creds(new);
683
684 error:
685 abort_creds(new);
686 return retval;
687 }
688
689 /*
690 * change the user struct in a credentials set to match the new UID
691 */
692 static int set_user(struct cred *new)
693 {
694 struct user_struct *new_user;
695
696 new_user = alloc_uid(new->uid);
697 if (!new_user)
698 return -EAGAIN;
699
700 /*
701 * We don't fail in case of NPROC limit excess here because too many
702 * poorly written programs don't check set*uid() return code, assuming
703 * it never fails if called by root. We may still enforce NPROC limit
704 * for programs doing set*uid()+execve() by harmlessly deferring the
705 * failure to the execve() stage.
706 */
707 if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) &&
708 new_user != INIT_USER)
709 current->flags |= PF_NPROC_EXCEEDED;
710 else
711 current->flags &= ~PF_NPROC_EXCEEDED;
712
713 free_uid(new->user);
714 new->user = new_user;
715 return 0;
716 }
717
718 /*
719 * Unprivileged users may change the real uid to the effective uid
720 * or vice versa. (BSD-style)
721 *
722 * If you set the real uid at all, or set the effective uid to a value not
723 * equal to the real uid, then the saved uid is set to the new effective uid.
724 *
725 * This makes it possible for a setuid program to completely drop its
726 * privileges, which is often a useful assertion to make when you are doing
727 * a security audit over a program.
728 *
729 * The general idea is that a program which uses just setreuid() will be
730 * 100% compatible with BSD. A program which uses just setuid() will be
731 * 100% compatible with POSIX with saved IDs.
732 */
733 SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
734 {
735 struct user_namespace *ns = current_user_ns();
736 const struct cred *old;
737 struct cred *new;
738 int retval;
739 kuid_t kruid, keuid;
740
741 kruid = make_kuid(ns, ruid);
742 keuid = make_kuid(ns, euid);
743
744 if ((ruid != (uid_t) -1) && !uid_valid(kruid))
745 return -EINVAL;
746 if ((euid != (uid_t) -1) && !uid_valid(keuid))
747 return -EINVAL;
748
749 new = prepare_creds();
750 if (!new)
751 return -ENOMEM;
752 old = current_cred();
753
754 retval = -EPERM;
755 if (ruid != (uid_t) -1) {
756 new->uid = kruid;
757 if (!uid_eq(old->uid, kruid) &&
758 !uid_eq(old->euid, kruid) &&
759 !nsown_capable(CAP_SETUID))
760 goto error;
761 }
762
763 if (euid != (uid_t) -1) {
764 new->euid = keuid;
765 if (!uid_eq(old->uid, keuid) &&
766 !uid_eq(old->euid, keuid) &&
767 !uid_eq(old->suid, keuid) &&
768 !nsown_capable(CAP_SETUID))
769 goto error;
770 }
771
772 if (!uid_eq(new->uid, old->uid)) {
773 retval = set_user(new);
774 if (retval < 0)
775 goto error;
776 }
777 if (ruid != (uid_t) -1 ||
778 (euid != (uid_t) -1 && !uid_eq(keuid, old->uid)))
779 new->suid = new->euid;
780 new->fsuid = new->euid;
781
782 retval = security_task_fix_setuid(new, old, LSM_SETID_RE);
783 if (retval < 0)
784 goto error;
785
786 return commit_creds(new);
787
788 error:
789 abort_creds(new);
790 return retval;
791 }
792
793 /*
794 * setuid() is implemented like SysV with SAVED_IDS
795 *
796 * Note that SAVED_ID's is deficient in that a setuid root program
797 * like sendmail, for example, cannot set its uid to be a normal
798 * user and then switch back, because if you're root, setuid() sets
799 * the saved uid too. If you don't like this, blame the bright people
800 * in the POSIX committee and/or USG. Note that the BSD-style setreuid()
801 * will allow a root program to temporarily drop privileges and be able to
802 * regain them by swapping the real and effective uid.
803 */
804 SYSCALL_DEFINE1(setuid, uid_t, uid)
805 {
806 struct user_namespace *ns = current_user_ns();
807 const struct cred *old;
808 struct cred *new;
809 int retval;
810 kuid_t kuid;
811
812 kuid = make_kuid(ns, uid);
813 if (!uid_valid(kuid))
814 return -EINVAL;
815
816 new = prepare_creds();
817 if (!new)
818 return -ENOMEM;
819 old = current_cred();
820
821 retval = -EPERM;
822 if (nsown_capable(CAP_SETUID)) {
823 new->suid = new->uid = kuid;
824 if (!uid_eq(kuid, old->uid)) {
825 retval = set_user(new);
826 if (retval < 0)
827 goto error;
828 }
829 } else if (!uid_eq(kuid, old->uid) && !uid_eq(kuid, new->suid)) {
830 goto error;
831 }
832
833 new->fsuid = new->euid = kuid;
834
835 retval = security_task_fix_setuid(new, old, LSM_SETID_ID);
836 if (retval < 0)
837 goto error;
838
839 return commit_creds(new);
840
841 error:
842 abort_creds(new);
843 return retval;
844 }
845
846
847 /*
848 * This function implements a generic ability to update ruid, euid,
849 * and suid. This allows you to implement the 4.4 compatible seteuid().
850 */
851 SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
852 {
853 struct user_namespace *ns = current_user_ns();
854 const struct cred *old;
855 struct cred *new;
856 int retval;
857 kuid_t kruid, keuid, ksuid;
858
859 kruid = make_kuid(ns, ruid);
860 keuid = make_kuid(ns, euid);
861 ksuid = make_kuid(ns, suid);
862
863 if ((ruid != (uid_t) -1) && !uid_valid(kruid))
864 return -EINVAL;
865
866 if ((euid != (uid_t) -1) && !uid_valid(keuid))
867 return -EINVAL;
868
869 if ((suid != (uid_t) -1) && !uid_valid(ksuid))
870 return -EINVAL;
871
872 new = prepare_creds();
873 if (!new)
874 return -ENOMEM;
875
876 old = current_cred();
877
878 retval = -EPERM;
879 if (!nsown_capable(CAP_SETUID)) {
880 if (ruid != (uid_t) -1 && !uid_eq(kruid, old->uid) &&
881 !uid_eq(kruid, old->euid) && !uid_eq(kruid, old->suid))
882 goto error;
883 if (euid != (uid_t) -1 && !uid_eq(keuid, old->uid) &&
884 !uid_eq(keuid, old->euid) && !uid_eq(keuid, old->suid))
885 goto error;
886 if (suid != (uid_t) -1 && !uid_eq(ksuid, old->uid) &&
887 !uid_eq(ksuid, old->euid) && !uid_eq(ksuid, old->suid))
888 goto error;
889 }
890
891 if (ruid != (uid_t) -1) {
892 new->uid = kruid;
893 if (!uid_eq(kruid, old->uid)) {
894 retval = set_user(new);
895 if (retval < 0)
896 goto error;
897 }
898 }
899 if (euid != (uid_t) -1)
900 new->euid = keuid;
901 if (suid != (uid_t) -1)
902 new->suid = ksuid;
903 new->fsuid = new->euid;
904
905 retval = security_task_fix_setuid(new, old, LSM_SETID_RES);
906 if (retval < 0)
907 goto error;
908
909 return commit_creds(new);
910
911 error:
912 abort_creds(new);
913 return retval;
914 }
915
916 SYSCALL_DEFINE3(getresuid, uid_t __user *, ruidp, uid_t __user *, euidp, uid_t __user *, suidp)
917 {
918 const struct cred *cred = current_cred();
919 int retval;
920 uid_t ruid, euid, suid;
921
922 ruid = from_kuid_munged(cred->user_ns, cred->uid);
923 euid = from_kuid_munged(cred->user_ns, cred->euid);
924 suid = from_kuid_munged(cred->user_ns, cred->suid);
925
926 if (!(retval = put_user(ruid, ruidp)) &&
927 !(retval = put_user(euid, euidp)))
928 retval = put_user(suid, suidp);
929
930 return retval;
931 }
932
933 /*
934 * Same as above, but for rgid, egid, sgid.
935 */
936 SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
937 {
938 struct user_namespace *ns = current_user_ns();
939 const struct cred *old;
940 struct cred *new;
941 int retval;
942 kgid_t krgid, kegid, ksgid;
943
944 krgid = make_kgid(ns, rgid);
945 kegid = make_kgid(ns, egid);
946 ksgid = make_kgid(ns, sgid);
947
948 if ((rgid != (gid_t) -1) && !gid_valid(krgid))
949 return -EINVAL;
950 if ((egid != (gid_t) -1) && !gid_valid(kegid))
951 return -EINVAL;
952 if ((sgid != (gid_t) -1) && !gid_valid(ksgid))
953 return -EINVAL;
954
955 new = prepare_creds();
956 if (!new)
957 return -ENOMEM;
958 old = current_cred();
959
960 retval = -EPERM;
961 if (!nsown_capable(CAP_SETGID)) {
962 if (rgid != (gid_t) -1 && !gid_eq(krgid, old->gid) &&
963 !gid_eq(krgid, old->egid) && !gid_eq(krgid, old->sgid))
964 goto error;
965 if (egid != (gid_t) -1 && !gid_eq(kegid, old->gid) &&
966 !gid_eq(kegid, old->egid) && !gid_eq(kegid, old->sgid))
967 goto error;
968 if (sgid != (gid_t) -1 && !gid_eq(ksgid, old->gid) &&
969 !gid_eq(ksgid, old->egid) && !gid_eq(ksgid, old->sgid))
970 goto error;
971 }
972
973 if (rgid != (gid_t) -1)
974 new->gid = krgid;
975 if (egid != (gid_t) -1)
976 new->egid = kegid;
977 if (sgid != (gid_t) -1)
978 new->sgid = ksgid;
979 new->fsgid = new->egid;
980
981 return commit_creds(new);
982
983 error:
984 abort_creds(new);
985 return retval;
986 }
987
988 SYSCALL_DEFINE3(getresgid, gid_t __user *, rgidp, gid_t __user *, egidp, gid_t __user *, sgidp)
989 {
990 const struct cred *cred = current_cred();
991 int retval;
992 gid_t rgid, egid, sgid;
993
994 rgid = from_kgid_munged(cred->user_ns, cred->gid);
995 egid = from_kgid_munged(cred->user_ns, cred->egid);
996 sgid = from_kgid_munged(cred->user_ns, cred->sgid);
997
998 if (!(retval = put_user(rgid, rgidp)) &&
999 !(retval = put_user(egid, egidp)))
1000 retval = put_user(sgid, sgidp);
1001
1002 return retval;
1003 }
1004
1005
1006 /*
1007 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
1008 * is used for "access()" and for the NFS daemon (letting nfsd stay at
1009 * whatever uid it wants to). It normally shadows "euid", except when
1010 * explicitly set by setfsuid() or for access..
1011 */
1012 SYSCALL_DEFINE1(setfsuid, uid_t, uid)
1013 {
1014 const struct cred *old;
1015 struct cred *new;
1016 uid_t old_fsuid;
1017 kuid_t kuid;
1018
1019 old = current_cred();
1020 old_fsuid = from_kuid_munged(old->user_ns, old->fsuid);
1021
1022 kuid = make_kuid(old->user_ns, uid);
1023 if (!uid_valid(kuid))
1024 return old_fsuid;
1025
1026 new = prepare_creds();
1027 if (!new)
1028 return old_fsuid;
1029
1030 if (uid_eq(kuid, old->uid) || uid_eq(kuid, old->euid) ||
1031 uid_eq(kuid, old->suid) || uid_eq(kuid, old->fsuid) ||
1032 nsown_capable(CAP_SETUID)) {
1033 if (!uid_eq(kuid, old->fsuid)) {
1034 new->fsuid = kuid;
1035 if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0)
1036 goto change_okay;
1037 }
1038 }
1039
1040 abort_creds(new);
1041 return old_fsuid;
1042
1043 change_okay:
1044 commit_creds(new);
1045 return old_fsuid;
1046 }
1047
1048 /*
1049 * Samma pa svenska..
1050 */
1051 SYSCALL_DEFINE1(setfsgid, gid_t, gid)
1052 {
1053 const struct cred *old;
1054 struct cred *new;
1055 gid_t old_fsgid;
1056 kgid_t kgid;
1057
1058 old = current_cred();
1059 old_fsgid = from_kgid_munged(old->user_ns, old->fsgid);
1060
1061 kgid = make_kgid(old->user_ns, gid);
1062 if (!gid_valid(kgid))
1063 return old_fsgid;
1064
1065 new = prepare_creds();
1066 if (!new)
1067 return old_fsgid;
1068
1069 if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->egid) ||
1070 gid_eq(kgid, old->sgid) || gid_eq(kgid, old->fsgid) ||
1071 nsown_capable(CAP_SETGID)) {
1072 if (!gid_eq(kgid, old->fsgid)) {
1073 new->fsgid = kgid;
1074 goto change_okay;
1075 }
1076 }
1077
1078 abort_creds(new);
1079 return old_fsgid;
1080
1081 change_okay:
1082 commit_creds(new);
1083 return old_fsgid;
1084 }
1085
1086 /**
1087 * sys_getpid - return the thread group id of the current process
1088 *
1089 * Note, despite the name, this returns the tgid not the pid. The tgid and
1090 * the pid are identical unless CLONE_THREAD was specified on clone() in
1091 * which case the tgid is the same in all threads of the same group.
1092 *
1093 * This is SMP safe as current->tgid does not change.
1094 */
1095 SYSCALL_DEFINE0(getpid)
1096 {
1097 return task_tgid_vnr(current);
1098 }
1099
1100 /* Thread ID - the internal kernel "pid" */
1101 SYSCALL_DEFINE0(gettid)
1102 {
1103 return task_pid_vnr(current);
1104 }
1105
1106 /*
1107 * Accessing ->real_parent is not SMP-safe, it could
1108 * change from under us. However, we can use a stale
1109 * value of ->real_parent under rcu_read_lock(), see
1110 * release_task()->call_rcu(delayed_put_task_struct).
1111 */
1112 SYSCALL_DEFINE0(getppid)
1113 {
1114 int pid;
1115
1116 rcu_read_lock();
1117 pid = task_tgid_vnr(rcu_dereference(current->real_parent));
1118 rcu_read_unlock();
1119
1120 return pid;
1121 }
1122
1123 SYSCALL_DEFINE0(getuid)
1124 {
1125 /* Only we change this so SMP safe */
1126 return from_kuid_munged(current_user_ns(), current_uid());
1127 }
1128
1129 SYSCALL_DEFINE0(geteuid)
1130 {
1131 /* Only we change this so SMP safe */
1132 return from_kuid_munged(current_user_ns(), current_euid());
1133 }
1134
1135 SYSCALL_DEFINE0(getgid)
1136 {
1137 /* Only we change this so SMP safe */
1138 return from_kgid_munged(current_user_ns(), current_gid());
1139 }
1140
1141 SYSCALL_DEFINE0(getegid)
1142 {
1143 /* Only we change this so SMP safe */
1144 return from_kgid_munged(current_user_ns(), current_egid());
1145 }
1146
1147 void do_sys_times(struct tms *tms)
1148 {
1149 cputime_t tgutime, tgstime, cutime, cstime;
1150
1151 spin_lock_irq(&current->sighand->siglock);
1152 thread_group_cputime_adjusted(current, &tgutime, &tgstime);
1153 cutime = current->signal->cutime;
1154 cstime = current->signal->cstime;
1155 spin_unlock_irq(&current->sighand->siglock);
1156 tms->tms_utime = cputime_to_clock_t(tgutime);
1157 tms->tms_stime = cputime_to_clock_t(tgstime);
1158 tms->tms_cutime = cputime_to_clock_t(cutime);
1159 tms->tms_cstime = cputime_to_clock_t(cstime);
1160 }
1161
1162 SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
1163 {
1164 if (tbuf) {
1165 struct tms tmp;
1166
1167 do_sys_times(&tmp);
1168 if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
1169 return -EFAULT;
1170 }
1171 force_successful_syscall_return();
1172 return (long) jiffies_64_to_clock_t(get_jiffies_64());
1173 }
1174
1175 /*
1176 * This needs some heavy checking ...
1177 * I just haven't the stomach for it. I also don't fully
1178 * understand sessions/pgrp etc. Let somebody who does explain it.
1179 *
1180 * OK, I think I have the protection semantics right.... this is really
1181 * only important on a multi-user system anyway, to make sure one user
1182 * can't send a signal to a process owned by another. -TYT, 12/12/91
1183 *
1184 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
1185 * LBT 04.03.94
1186 */
1187 SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid)
1188 {
1189 struct task_struct *p;
1190 struct task_struct *group_leader = current->group_leader;
1191 struct pid *pgrp;
1192 int err;
1193
1194 if (!pid)
1195 pid = task_pid_vnr(group_leader);
1196 if (!pgid)
1197 pgid = pid;
1198 if (pgid < 0)
1199 return -EINVAL;
1200 rcu_read_lock();
1201
1202 /* From this point forward we keep holding onto the tasklist lock
1203 * so that our parent does not change from under us. -DaveM
1204 */
1205 write_lock_irq(&tasklist_lock);
1206
1207 err = -ESRCH;
1208 p = find_task_by_vpid(pid);
1209 if (!p)
1210 goto out;
1211
1212 err = -EINVAL;
1213 if (!thread_group_leader(p))
1214 goto out;
1215
1216 if (same_thread_group(p->real_parent, group_leader)) {
1217 err = -EPERM;
1218 if (task_session(p) != task_session(group_leader))
1219 goto out;
1220 err = -EACCES;
1221 if (p->did_exec)
1222 goto out;
1223 } else {
1224 err = -ESRCH;
1225 if (p != group_leader)
1226 goto out;
1227 }
1228
1229 err = -EPERM;
1230 if (p->signal->leader)
1231 goto out;
1232
1233 pgrp = task_pid(p);
1234 if (pgid != pid) {
1235 struct task_struct *g;
1236
1237 pgrp = find_vpid(pgid);
1238 g = pid_task(pgrp, PIDTYPE_PGID);
1239 if (!g || task_session(g) != task_session(group_leader))
1240 goto out;
1241 }
1242
1243 err = security_task_setpgid(p, pgid);
1244 if (err)
1245 goto out;
1246
1247 if (task_pgrp(p) != pgrp)
1248 change_pid(p, PIDTYPE_PGID, pgrp);
1249
1250 err = 0;
1251 out:
1252 /* All paths lead to here, thus we are safe. -DaveM */
1253 write_unlock_irq(&tasklist_lock);
1254 rcu_read_unlock();
1255 return err;
1256 }
1257
1258 SYSCALL_DEFINE1(getpgid, pid_t, pid)
1259 {
1260 struct task_struct *p;
1261 struct pid *grp;
1262 int retval;
1263
1264 rcu_read_lock();
1265 if (!pid)
1266 grp = task_pgrp(current);
1267 else {
1268 retval = -ESRCH;
1269 p = find_task_by_vpid(pid);
1270 if (!p)
1271 goto out;
1272 grp = task_pgrp(p);
1273 if (!grp)
1274 goto out;
1275
1276 retval = security_task_getpgid(p);
1277 if (retval)
1278 goto out;
1279 }
1280 retval = pid_vnr(grp);
1281 out:
1282 rcu_read_unlock();
1283 return retval;
1284 }
1285
1286 #ifdef __ARCH_WANT_SYS_GETPGRP
1287
1288 SYSCALL_DEFINE0(getpgrp)
1289 {
1290 return sys_getpgid(0);
1291 }
1292
1293 #endif
1294
1295 SYSCALL_DEFINE1(getsid, pid_t, pid)
1296 {
1297 struct task_struct *p;
1298 struct pid *sid;
1299 int retval;
1300
1301 rcu_read_lock();
1302 if (!pid)
1303 sid = task_session(current);
1304 else {
1305 retval = -ESRCH;
1306 p = find_task_by_vpid(pid);
1307 if (!p)
1308 goto out;
1309 sid = task_session(p);
1310 if (!sid)
1311 goto out;
1312
1313 retval = security_task_getsid(p);
1314 if (retval)
1315 goto out;
1316 }
1317 retval = pid_vnr(sid);
1318 out:
1319 rcu_read_unlock();
1320 return retval;
1321 }
1322
1323 SYSCALL_DEFINE0(setsid)
1324 {
1325 struct task_struct *group_leader = current->group_leader;
1326 struct pid *sid = task_pid(group_leader);
1327 pid_t session = pid_vnr(sid);
1328 int err = -EPERM;
1329
1330 write_lock_irq(&tasklist_lock);
1331 /* Fail if I am already a session leader */
1332 if (group_leader->signal->leader)
1333 goto out;
1334
1335 /* Fail if a process group id already exists that equals the
1336 * proposed session id.
1337 */
1338 if (pid_task(sid, PIDTYPE_PGID))
1339 goto out;
1340
1341 group_leader->signal->leader = 1;
1342 __set_special_pids(sid);
1343
1344 proc_clear_tty(group_leader);
1345
1346 err = session;
1347 out:
1348 write_unlock_irq(&tasklist_lock);
1349 if (err > 0) {
1350 proc_sid_connector(group_leader);
1351 sched_autogroup_create_attach(group_leader);
1352 }
1353 return err;
1354 }
1355
1356 DECLARE_RWSEM(uts_sem);
1357
1358 #ifdef COMPAT_UTS_MACHINE
1359 #define override_architecture(name) \
1360 (personality(current->personality) == PER_LINUX32 && \
1361 copy_to_user(name->machine, COMPAT_UTS_MACHINE, \
1362 sizeof(COMPAT_UTS_MACHINE)))
1363 #else
1364 #define override_architecture(name) 0
1365 #endif
1366
1367 /*
1368 * Work around broken programs that cannot handle "Linux 3.0".
1369 * Instead we map 3.x to 2.6.40+x, so e.g. 3.0 would be 2.6.40
1370 */
1371 static int override_release(char __user *release, size_t len)
1372 {
1373 int ret = 0;
1374
1375 if (current->personality & UNAME26) {
1376 const char *rest = UTS_RELEASE;
1377 char buf[65] = { 0 };
1378 int ndots = 0;
1379 unsigned v;
1380 size_t copy;
1381
1382 while (*rest) {
1383 if (*rest == '.' && ++ndots >= 3)
1384 break;
1385 if (!isdigit(*rest) && *rest != '.')
1386 break;
1387 rest++;
1388 }
1389 v = ((LINUX_VERSION_CODE >> 8) & 0xff) + 40;
1390 copy = clamp_t(size_t, len, 1, sizeof(buf));
1391 copy = scnprintf(buf, copy, "2.6.%u%s", v, rest);
1392 ret = copy_to_user(release, buf, copy + 1);
1393 }
1394 return ret;
1395 }
1396
1397 SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
1398 {
1399 int errno = 0;
1400
1401 down_read(&uts_sem);
1402 if (copy_to_user(name, utsname(), sizeof *name))
1403 errno = -EFAULT;
1404 up_read(&uts_sem);
1405
1406 if (!errno && override_release(name->release, sizeof(name->release)))
1407 errno = -EFAULT;
1408 if (!errno && override_architecture(name))
1409 errno = -EFAULT;
1410 return errno;
1411 }
1412
1413 #ifdef __ARCH_WANT_SYS_OLD_UNAME
1414 /*
1415 * Old cruft
1416 */
1417 SYSCALL_DEFINE1(uname, struct old_utsname __user *, name)
1418 {
1419 int error = 0;
1420
1421 if (!name)
1422 return -EFAULT;
1423
1424 down_read(&uts_sem);
1425 if (copy_to_user(name, utsname(), sizeof(*name)))
1426 error = -EFAULT;
1427 up_read(&uts_sem);
1428
1429 if (!error && override_release(name->release, sizeof(name->release)))
1430 error = -EFAULT;
1431 if (!error && override_architecture(name))
1432 error = -EFAULT;
1433 return error;
1434 }
1435
1436 SYSCALL_DEFINE1(olduname, struct oldold_utsname __user *, name)
1437 {
1438 int error;
1439
1440 if (!name)
1441 return -EFAULT;
1442 if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
1443 return -EFAULT;
1444
1445 down_read(&uts_sem);
1446 error = __copy_to_user(&name->sysname, &utsname()->sysname,
1447 __OLD_UTS_LEN);
1448 error |= __put_user(0, name->sysname + __OLD_UTS_LEN);
1449 error |= __copy_to_user(&name->nodename, &utsname()->nodename,
1450 __OLD_UTS_LEN);
1451 error |= __put_user(0, name->nodename + __OLD_UTS_LEN);
1452 error |= __copy_to_user(&name->release, &utsname()->release,
1453 __OLD_UTS_LEN);
1454 error |= __put_user(0, name->release + __OLD_UTS_LEN);
1455 error |= __copy_to_user(&name->version, &utsname()->version,
1456 __OLD_UTS_LEN);
1457 error |= __put_user(0, name->version + __OLD_UTS_LEN);
1458 error |= __copy_to_user(&name->machine, &utsname()->machine,
1459 __OLD_UTS_LEN);
1460 error |= __put_user(0, name->machine + __OLD_UTS_LEN);
1461 up_read(&uts_sem);
1462
1463 if (!error && override_architecture(name))
1464 error = -EFAULT;
1465 if (!error && override_release(name->release, sizeof(name->release)))
1466 error = -EFAULT;
1467 return error ? -EFAULT : 0;
1468 }
1469 #endif
1470
1471 SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
1472 {
1473 int errno;
1474 char tmp[__NEW_UTS_LEN];
1475
1476 if (!ns_capable(current->nsproxy->uts_ns->user_ns, CAP_SYS_ADMIN))
1477 return -EPERM;
1478
1479 if (len < 0 || len > __NEW_UTS_LEN)
1480 return -EINVAL;
1481 down_write(&uts_sem);
1482 errno = -EFAULT;
1483 if (!copy_from_user(tmp, name, len)) {
1484 struct new_utsname *u = utsname();
1485
1486 memcpy(u->nodename, tmp, len);
1487 memset(u->nodename + len, 0, sizeof(u->nodename) - len);
1488 errno = 0;
1489 uts_proc_notify(UTS_PROC_HOSTNAME);
1490 }
1491 up_write(&uts_sem);
1492 return errno;
1493 }
1494
1495 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
1496
1497 SYSCALL_DEFINE2(gethostname, char __user *, name, int, len)
1498 {
1499 int i, errno;
1500 struct new_utsname *u;
1501
1502 if (len < 0)
1503 return -EINVAL;
1504 down_read(&uts_sem);
1505 u = utsname();
1506 i = 1 + strlen(u->nodename);
1507 if (i > len)
1508 i = len;
1509 errno = 0;
1510 if (copy_to_user(name, u->nodename, i))
1511 errno = -EFAULT;
1512 up_read(&uts_sem);
1513 return errno;
1514 }
1515
1516 #endif
1517
1518 /*
1519 * Only setdomainname; getdomainname can be implemented by calling
1520 * uname()
1521 */
1522 SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len)
1523 {
1524 int errno;
1525 char tmp[__NEW_UTS_LEN];
1526
1527 if (!ns_capable(current->nsproxy->uts_ns->user_ns, CAP_SYS_ADMIN))
1528 return -EPERM;
1529 if (len < 0 || len > __NEW_UTS_LEN)
1530 return -EINVAL;
1531
1532 down_write(&uts_sem);
1533 errno = -EFAULT;
1534 if (!copy_from_user(tmp, name, len)) {
1535 struct new_utsname *u = utsname();
1536
1537 memcpy(u->domainname, tmp, len);
1538 memset(u->domainname + len, 0, sizeof(u->domainname) - len);
1539 errno = 0;
1540 uts_proc_notify(UTS_PROC_DOMAINNAME);
1541 }
1542 up_write(&uts_sem);
1543 return errno;
1544 }
1545
1546 SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
1547 {
1548 struct rlimit value;
1549 int ret;
1550
1551 ret = do_prlimit(current, resource, NULL, &value);
1552 if (!ret)
1553 ret = copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
1554
1555 return ret;
1556 }
1557
1558 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1559
1560 /*
1561 * Back compatibility for getrlimit. Needed for some apps.
1562 */
1563
1564 SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
1565 struct rlimit __user *, rlim)
1566 {
1567 struct rlimit x;
1568 if (resource >= RLIM_NLIMITS)
1569 return -EINVAL;
1570
1571 task_lock(current->group_leader);
1572 x = current->signal->rlim[resource];
1573 task_unlock(current->group_leader);
1574 if (x.rlim_cur > 0x7FFFFFFF)
1575 x.rlim_cur = 0x7FFFFFFF;
1576 if (x.rlim_max > 0x7FFFFFFF)
1577 x.rlim_max = 0x7FFFFFFF;
1578 return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0;
1579 }
1580
1581 #endif
1582
1583 static inline bool rlim64_is_infinity(__u64 rlim64)
1584 {
1585 #if BITS_PER_LONG < 64
1586 return rlim64 >= ULONG_MAX;
1587 #else
1588 return rlim64 == RLIM64_INFINITY;
1589 #endif
1590 }
1591
1592 static void rlim_to_rlim64(const struct rlimit *rlim, struct rlimit64 *rlim64)
1593 {
1594 if (rlim->rlim_cur == RLIM_INFINITY)
1595 rlim64->rlim_cur = RLIM64_INFINITY;
1596 else
1597 rlim64->rlim_cur = rlim->rlim_cur;
1598 if (rlim->rlim_max == RLIM_INFINITY)
1599 rlim64->rlim_max = RLIM64_INFINITY;
1600 else
1601 rlim64->rlim_max = rlim->rlim_max;
1602 }
1603
1604 static void rlim64_to_rlim(const struct rlimit64 *rlim64, struct rlimit *rlim)
1605 {
1606 if (rlim64_is_infinity(rlim64->rlim_cur))
1607 rlim->rlim_cur = RLIM_INFINITY;
1608 else
1609 rlim->rlim_cur = (unsigned long)rlim64->rlim_cur;
1610 if (rlim64_is_infinity(rlim64->rlim_max))
1611 rlim->rlim_max = RLIM_INFINITY;
1612 else
1613 rlim->rlim_max = (unsigned long)rlim64->rlim_max;
1614 }
1615
1616 /* make sure you are allowed to change @tsk limits before calling this */
1617 int do_prlimit(struct task_struct *tsk, unsigned int resource,
1618 struct rlimit *new_rlim, struct rlimit *old_rlim)
1619 {
1620 struct rlimit *rlim;
1621 int retval = 0;
1622
1623 if (resource >= RLIM_NLIMITS)
1624 return -EINVAL;
1625 if (new_rlim) {
1626 if (new_rlim->rlim_cur > new_rlim->rlim_max)
1627 return -EINVAL;
1628 if (resource == RLIMIT_NOFILE &&
1629 new_rlim->rlim_max > sysctl_nr_open)
1630 return -EPERM;
1631 }
1632
1633 /* protect tsk->signal and tsk->sighand from disappearing */
1634 read_lock(&tasklist_lock);
1635 if (!tsk->sighand) {
1636 retval = -ESRCH;
1637 goto out;
1638 }
1639
1640 rlim = tsk->signal->rlim + resource;
1641 task_lock(tsk->group_leader);
1642 if (new_rlim) {
1643 /* Keep the capable check against init_user_ns until
1644 cgroups can contain all limits */
1645 if (new_rlim->rlim_max > rlim->rlim_max &&
1646 !capable(CAP_SYS_RESOURCE))
1647 retval = -EPERM;
1648 if (!retval)
1649 retval = security_task_setrlimit(tsk->group_leader,
1650 resource, new_rlim);
1651 if (resource == RLIMIT_CPU && new_rlim->rlim_cur == 0) {
1652 /*
1653 * The caller is asking for an immediate RLIMIT_CPU
1654 * expiry. But we use the zero value to mean "it was
1655 * never set". So let's cheat and make it one second
1656 * instead
1657 */
1658 new_rlim->rlim_cur = 1;
1659 }
1660 }
1661 if (!retval) {
1662 if (old_rlim)
1663 *old_rlim = *rlim;
1664 if (new_rlim)
1665 *rlim = *new_rlim;
1666 }
1667 task_unlock(tsk->group_leader);
1668
1669 /*
1670 * RLIMIT_CPU handling. Note that the kernel fails to return an error
1671 * code if it rejected the user's attempt to set RLIMIT_CPU. This is a
1672 * very long-standing error, and fixing it now risks breakage of
1673 * applications, so we live with it
1674 */
1675 if (!retval && new_rlim && resource == RLIMIT_CPU &&
1676 new_rlim->rlim_cur != RLIM_INFINITY)
1677 update_rlimit_cpu(tsk, new_rlim->rlim_cur);
1678 out:
1679 read_unlock(&tasklist_lock);
1680 return retval;
1681 }
1682
1683 /* rcu lock must be held */
1684 static int check_prlimit_permission(struct task_struct *task)
1685 {
1686 const struct cred *cred = current_cred(), *tcred;
1687
1688 if (current == task)
1689 return 0;
1690
1691 tcred = __task_cred(task);
1692 if (uid_eq(cred->uid, tcred->euid) &&
1693 uid_eq(cred->uid, tcred->suid) &&
1694 uid_eq(cred->uid, tcred->uid) &&
1695 gid_eq(cred->gid, tcred->egid) &&
1696 gid_eq(cred->gid, tcred->sgid) &&
1697 gid_eq(cred->gid, tcred->gid))
1698 return 0;
1699 if (ns_capable(tcred->user_ns, CAP_SYS_RESOURCE))
1700 return 0;
1701
1702 return -EPERM;
1703 }
1704
1705 SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource,
1706 const struct rlimit64 __user *, new_rlim,
1707 struct rlimit64 __user *, old_rlim)
1708 {
1709 struct rlimit64 old64, new64;
1710 struct rlimit old, new;
1711 struct task_struct *tsk;
1712 int ret;
1713
1714 if (new_rlim) {
1715 if (copy_from_user(&new64, new_rlim, sizeof(new64)))
1716 return -EFAULT;
1717 rlim64_to_rlim(&new64, &new);
1718 }
1719
1720 rcu_read_lock();
1721 tsk = pid ? find_task_by_vpid(pid) : current;
1722 if (!tsk) {
1723 rcu_read_unlock();
1724 return -ESRCH;
1725 }
1726 ret = check_prlimit_permission(tsk);
1727 if (ret) {
1728 rcu_read_unlock();
1729 return ret;
1730 }
1731 get_task_struct(tsk);
1732 rcu_read_unlock();
1733
1734 ret = do_prlimit(tsk, resource, new_rlim ? &new : NULL,
1735 old_rlim ? &old : NULL);
1736
1737 if (!ret && old_rlim) {
1738 rlim_to_rlim64(&old, &old64);
1739 if (copy_to_user(old_rlim, &old64, sizeof(old64)))
1740 ret = -EFAULT;
1741 }
1742
1743 put_task_struct(tsk);
1744 return ret;
1745 }
1746
1747 SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
1748 {
1749 struct rlimit new_rlim;
1750
1751 if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
1752 return -EFAULT;
1753 return do_prlimit(current, resource, &new_rlim, NULL);
1754 }
1755
1756 /*
1757 * It would make sense to put struct rusage in the task_struct,
1758 * except that would make the task_struct be *really big*. After
1759 * task_struct gets moved into malloc'ed memory, it would
1760 * make sense to do this. It will make moving the rest of the information
1761 * a lot simpler! (Which we're not doing right now because we're not
1762 * measuring them yet).
1763 *
1764 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1765 * races with threads incrementing their own counters. But since word
1766 * reads are atomic, we either get new values or old values and we don't
1767 * care which for the sums. We always take the siglock to protect reading
1768 * the c* fields from p->signal from races with exit.c updating those
1769 * fields when reaping, so a sample either gets all the additions of a
1770 * given child after it's reaped, or none so this sample is before reaping.
1771 *
1772 * Locking:
1773 * We need to take the siglock for CHILDEREN, SELF and BOTH
1774 * for the cases current multithreaded, non-current single threaded
1775 * non-current multithreaded. Thread traversal is now safe with
1776 * the siglock held.
1777 * Strictly speaking, we donot need to take the siglock if we are current and
1778 * single threaded, as no one else can take our signal_struct away, no one
1779 * else can reap the children to update signal->c* counters, and no one else
1780 * can race with the signal-> fields. If we do not take any lock, the
1781 * signal-> fields could be read out of order while another thread was just
1782 * exiting. So we should place a read memory barrier when we avoid the lock.
1783 * On the writer side, write memory barrier is implied in __exit_signal
1784 * as __exit_signal releases the siglock spinlock after updating the signal->
1785 * fields. But we don't do this yet to keep things simple.
1786 *
1787 */
1788
1789 static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r)
1790 {
1791 r->ru_nvcsw += t->nvcsw;
1792 r->ru_nivcsw += t->nivcsw;
1793 r->ru_minflt += t->min_flt;
1794 r->ru_majflt += t->maj_flt;
1795 r->ru_inblock += task_io_get_inblock(t);
1796 r->ru_oublock += task_io_get_oublock(t);
1797 }
1798
1799 static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
1800 {
1801 struct task_struct *t;
1802 unsigned long flags;
1803 cputime_t tgutime, tgstime, utime, stime;
1804 unsigned long maxrss = 0;
1805
1806 memset((char *) r, 0, sizeof *r);
1807 utime = stime = 0;
1808
1809 if (who == RUSAGE_THREAD) {
1810 task_cputime_adjusted(current, &utime, &stime);
1811 accumulate_thread_rusage(p, r);
1812 maxrss = p->signal->maxrss;
1813 goto out;
1814 }
1815
1816 if (!lock_task_sighand(p, &flags))
1817 return;
1818
1819 switch (who) {
1820 case RUSAGE_BOTH:
1821 case RUSAGE_CHILDREN:
1822 utime = p->signal->cutime;
1823 stime = p->signal->cstime;
1824 r->ru_nvcsw = p->signal->cnvcsw;
1825 r->ru_nivcsw = p->signal->cnivcsw;
1826 r->ru_minflt = p->signal->cmin_flt;
1827 r->ru_majflt = p->signal->cmaj_flt;
1828 r->ru_inblock = p->signal->cinblock;
1829 r->ru_oublock = p->signal->coublock;
1830 maxrss = p->signal->cmaxrss;
1831
1832 if (who == RUSAGE_CHILDREN)
1833 break;
1834
1835 case RUSAGE_SELF:
1836 thread_group_cputime_adjusted(p, &tgutime, &tgstime);
1837 utime += tgutime;
1838 stime += tgstime;
1839 r->ru_nvcsw += p->signal->nvcsw;
1840 r->ru_nivcsw += p->signal->nivcsw;
1841 r->ru_minflt += p->signal->min_flt;
1842 r->ru_majflt += p->signal->maj_flt;
1843 r->ru_inblock += p->signal->inblock;
1844 r->ru_oublock += p->signal->oublock;
1845 if (maxrss < p->signal->maxrss)
1846 maxrss = p->signal->maxrss;
1847 t = p;
1848 do {
1849 accumulate_thread_rusage(t, r);
1850 t = next_thread(t);
1851 } while (t != p);
1852 break;
1853
1854 default:
1855 BUG();
1856 }
1857 unlock_task_sighand(p, &flags);
1858
1859 out:
1860 cputime_to_timeval(utime, &r->ru_utime);
1861 cputime_to_timeval(stime, &r->ru_stime);
1862
1863 if (who != RUSAGE_CHILDREN) {
1864 struct mm_struct *mm = get_task_mm(p);
1865 if (mm) {
1866 setmax_mm_hiwater_rss(&maxrss, mm);
1867 mmput(mm);
1868 }
1869 }
1870 r->ru_maxrss = maxrss * (PAGE_SIZE / 1024); /* convert pages to KBs */
1871 }
1872
1873 int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
1874 {
1875 struct rusage r;
1876 k_getrusage(p, who, &r);
1877 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1878 }
1879
1880 SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
1881 {
1882 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
1883 who != RUSAGE_THREAD)
1884 return -EINVAL;
1885 return getrusage(current, who, ru);
1886 }
1887
1888 #ifdef CONFIG_COMPAT
1889 COMPAT_SYSCALL_DEFINE2(getrusage, int, who, struct compat_rusage __user *, ru)
1890 {
1891 struct rusage r;
1892
1893 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
1894 who != RUSAGE_THREAD)
1895 return -EINVAL;
1896
1897 k_getrusage(current, who, &r);
1898 return put_compat_rusage(&r, ru);
1899 }
1900 #endif
1901
1902 SYSCALL_DEFINE1(umask, int, mask)
1903 {
1904 mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
1905 return mask;
1906 }
1907
1908 static int prctl_set_mm_exe_file(struct mm_struct *mm, unsigned int fd)
1909 {
1910 struct fd exe;
1911 struct inode *inode;
1912 int err;
1913
1914 exe = fdget(fd);
1915 if (!exe.file)
1916 return -EBADF;
1917
1918 inode = file_inode(exe.file);
1919
1920 /*
1921 * Because the original mm->exe_file points to executable file, make
1922 * sure that this one is executable as well, to avoid breaking an
1923 * overall picture.
1924 */
1925 err = -EACCES;
1926 if (!S_ISREG(inode->i_mode) ||
1927 exe.file->f_path.mnt->mnt_flags & MNT_NOEXEC)
1928 goto exit;
1929
1930 err = inode_permission(inode, MAY_EXEC);
1931 if (err)
1932 goto exit;
1933
1934 down_write(&mm->mmap_sem);
1935
1936 /*
1937 * Forbid mm->exe_file change if old file still mapped.
1938 */
1939 err = -EBUSY;
1940 if (mm->exe_file) {
1941 struct vm_area_struct *vma;
1942
1943 for (vma = mm->mmap; vma; vma = vma->vm_next)
1944 if (vma->vm_file &&
1945 path_equal(&vma->vm_file->f_path,
1946 &mm->exe_file->f_path))
1947 goto exit_unlock;
1948 }
1949
1950 /*
1951 * The symlink can be changed only once, just to disallow arbitrary
1952 * transitions malicious software might bring in. This means one
1953 * could make a snapshot over all processes running and monitor
1954 * /proc/pid/exe changes to notice unusual activity if needed.
1955 */
1956 err = -EPERM;
1957 if (test_and_set_bit(MMF_EXE_FILE_CHANGED, &mm->flags))
1958 goto exit_unlock;
1959
1960 err = 0;
1961 set_mm_exe_file(mm, exe.file); /* this grabs a reference to exe.file */
1962 exit_unlock:
1963 up_write(&mm->mmap_sem);
1964
1965 exit:
1966 fdput(exe);
1967 return err;
1968 }
1969
1970 static int prctl_set_mm(int opt, unsigned long addr,
1971 unsigned long arg4, unsigned long arg5)
1972 {
1973 unsigned long rlim = rlimit(RLIMIT_DATA);
1974 struct mm_struct *mm = current->mm;
1975 struct vm_area_struct *vma;
1976 int error;
1977
1978 if (arg5 || (arg4 && opt != PR_SET_MM_AUXV))
1979 return -EINVAL;
1980
1981 if (!capable(CAP_SYS_RESOURCE))
1982 return -EPERM;
1983
1984 if (opt == PR_SET_MM_EXE_FILE)
1985 return prctl_set_mm_exe_file(mm, (unsigned int)addr);
1986
1987 if (addr >= TASK_SIZE || addr < mmap_min_addr)
1988 return -EINVAL;
1989
1990 error = -EINVAL;
1991
1992 down_read(&mm->mmap_sem);
1993 vma = find_vma(mm, addr);
1994
1995 switch (opt) {
1996 case PR_SET_MM_START_CODE:
1997 mm->start_code = addr;
1998 break;
1999 case PR_SET_MM_END_CODE:
2000 mm->end_code = addr;
2001 break;
2002 case PR_SET_MM_START_DATA:
2003 mm->start_data = addr;
2004 break;
2005 case PR_SET_MM_END_DATA:
2006 mm->end_data = addr;
2007 break;
2008
2009 case PR_SET_MM_START_BRK:
2010 if (addr <= mm->end_data)
2011 goto out;
2012
2013 if (rlim < RLIM_INFINITY &&
2014 (mm->brk - addr) +
2015 (mm->end_data - mm->start_data) > rlim)
2016 goto out;
2017
2018 mm->start_brk = addr;
2019 break;
2020
2021 case PR_SET_MM_BRK:
2022 if (addr <= mm->end_data)
2023 goto out;
2024
2025 if (rlim < RLIM_INFINITY &&
2026 (addr - mm->start_brk) +
2027 (mm->end_data - mm->start_data) > rlim)
2028 goto out;
2029
2030 mm->brk = addr;
2031 break;
2032
2033 /*
2034 * If command line arguments and environment
2035 * are placed somewhere else on stack, we can
2036 * set them up here, ARG_START/END to setup
2037 * command line argumets and ENV_START/END
2038 * for environment.
2039 */
2040 case PR_SET_MM_START_STACK:
2041 case PR_SET_MM_ARG_START:
2042 case PR_SET_MM_ARG_END:
2043 case PR_SET_MM_ENV_START:
2044 case PR_SET_MM_ENV_END:
2045 if (!vma) {
2046 error = -EFAULT;
2047 goto out;
2048 }
2049 if (opt == PR_SET_MM_START_STACK)
2050 mm->start_stack = addr;
2051 else if (opt == PR_SET_MM_ARG_START)
2052 mm->arg_start = addr;
2053 else if (opt == PR_SET_MM_ARG_END)
2054 mm->arg_end = addr;
2055 else if (opt == PR_SET_MM_ENV_START)
2056 mm->env_start = addr;
2057 else if (opt == PR_SET_MM_ENV_END)
2058 mm->env_end = addr;
2059 break;
2060
2061 /*
2062 * This doesn't move auxiliary vector itself
2063 * since it's pinned to mm_struct, but allow
2064 * to fill vector with new values. It's up
2065 * to a caller to provide sane values here
2066 * otherwise user space tools which use this
2067 * vector might be unhappy.
2068 */
2069 case PR_SET_MM_AUXV: {
2070 unsigned long user_auxv[AT_VECTOR_SIZE];
2071
2072 if (arg4 > sizeof(user_auxv))
2073 goto out;
2074 up_read(&mm->mmap_sem);
2075
2076 if (copy_from_user(user_auxv, (const void __user *)addr, arg4))
2077 return -EFAULT;
2078
2079 /* Make sure the last entry is always AT_NULL */
2080 user_auxv[AT_VECTOR_SIZE - 2] = 0;
2081 user_auxv[AT_VECTOR_SIZE - 1] = 0;
2082
2083 BUILD_BUG_ON(sizeof(user_auxv) != sizeof(mm->saved_auxv));
2084
2085 task_lock(current);
2086 memcpy(mm->saved_auxv, user_auxv, arg4);
2087 task_unlock(current);
2088
2089 return 0;
2090 }
2091 default:
2092 goto out;
2093 }
2094
2095 error = 0;
2096 out:
2097 up_read(&mm->mmap_sem);
2098 return error;
2099 }
2100
2101 #ifdef CONFIG_CHECKPOINT_RESTORE
2102 static int prctl_get_tid_address(struct task_struct *me, int __user **tid_addr)
2103 {
2104 return put_user(me->clear_child_tid, tid_addr);
2105 }
2106 #else
2107 static int prctl_get_tid_address(struct task_struct *me, int __user **tid_addr)
2108 {
2109 return -EINVAL;
2110 }
2111 #endif
2112
2113 #ifdef CONFIG_MMU
2114 static int prctl_update_vma_anon_name(struct vm_area_struct *vma,
2115 struct vm_area_struct **prev,
2116 unsigned long start, unsigned long end,
2117 const char __user *name_addr)
2118 {
2119 struct mm_struct * mm = vma->vm_mm;
2120 int error = 0;
2121 pgoff_t pgoff;
2122
2123 if (name_addr == vma_get_anon_name(vma)) {
2124 *prev = vma;
2125 goto out;
2126 }
2127
2128 pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
2129 *prev = vma_merge(mm, *prev, start, end, vma->vm_flags, vma->anon_vma,
2130 vma->vm_file, pgoff, vma_policy(vma),
2131 name_addr);
2132 if (*prev) {
2133 vma = *prev;
2134 goto success;
2135 }
2136
2137 *prev = vma;
2138
2139 if (start != vma->vm_start) {
2140 error = split_vma(mm, vma, start, 1);
2141 if (error)
2142 goto out;
2143 }
2144
2145 if (end != vma->vm_end) {
2146 error = split_vma(mm, vma, end, 0);
2147 if (error)
2148 goto out;
2149 }
2150
2151 success:
2152 if (!vma->vm_file)
2153 vma->shared.anon_name = name_addr;
2154
2155 out:
2156 if (error == -ENOMEM)
2157 error = -EAGAIN;
2158 return error;
2159 }
2160
2161 static int prctl_set_vma_anon_name(unsigned long start, unsigned long end,
2162 unsigned long arg)
2163 {
2164 unsigned long tmp;
2165 struct vm_area_struct * vma, *prev;
2166 int unmapped_error = 0;
2167 int error = -EINVAL;
2168
2169 /*
2170 * If the interval [start,end) covers some unmapped address
2171 * ranges, just ignore them, but return -ENOMEM at the end.
2172 * - this matches the handling in madvise.
2173 */
2174 vma = find_vma_prev(current->mm, start, &prev);
2175 if (vma && start > vma->vm_start)
2176 prev = vma;
2177
2178 for (;;) {
2179 /* Still start < end. */
2180 error = -ENOMEM;
2181 if (!vma)
2182 return error;
2183
2184 /* Here start < (end|vma->vm_end). */
2185 if (start < vma->vm_start) {
2186 unmapped_error = -ENOMEM;
2187 start = vma->vm_start;
2188 if (start >= end)
2189 return error;
2190 }
2191
2192 /* Here vma->vm_start <= start < (end|vma->vm_end) */
2193 tmp = vma->vm_end;
2194 if (end < tmp)
2195 tmp = end;
2196
2197 /* Here vma->vm_start <= start < tmp <= (end|vma->vm_end). */
2198 error = prctl_update_vma_anon_name(vma, &prev, start, tmp,
2199 (const char __user *)arg);
2200 if (error)
2201 return error;
2202 start = tmp;
2203 if (prev && start < prev->vm_end)
2204 start = prev->vm_end;
2205 error = unmapped_error;
2206 if (start >= end)
2207 return error;
2208 if (prev)
2209 vma = prev->vm_next;
2210 else /* madvise_remove dropped mmap_sem */
2211 vma = find_vma(current->mm, start);
2212 }
2213 }
2214
2215 static int prctl_set_vma(unsigned long opt, unsigned long start,
2216 unsigned long len_in, unsigned long arg)
2217 {
2218 struct mm_struct *mm = current->mm;
2219 int error;
2220 unsigned long len;
2221 unsigned long end;
2222
2223 #ifndef CONFIG_MT_ENG_BUILD
2224 /* Do not do prctl_set_vma in !eng load */
2225 return 0;
2226 #endif
2227
2228 if (start & ~PAGE_MASK)
2229 return -EINVAL;
2230 len = (len_in + ~PAGE_MASK) & PAGE_MASK;
2231
2232 /* Check to see whether len was rounded up from small -ve to zero */
2233 if (len_in && !len)
2234 return -EINVAL;
2235
2236 end = start + len;
2237 if (end < start)
2238 return -EINVAL;
2239
2240 if (end == start)
2241 return 0;
2242
2243 down_write(&mm->mmap_sem);
2244
2245 switch (opt) {
2246 case PR_SET_VMA_ANON_NAME:
2247 error = prctl_set_vma_anon_name(start, end, arg);
2248 break;
2249 default:
2250 error = -EINVAL;
2251 }
2252
2253 up_write(&mm->mmap_sem);
2254
2255 return error;
2256 }
2257 #else /* CONFIG_MMU */
2258 static int prctl_set_vma(unsigned long opt, unsigned long start,
2259 unsigned long len_in, unsigned long arg)
2260 {
2261 return -EINVAL;
2262 }
2263 #endif
2264
2265 SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
2266 unsigned long, arg4, unsigned long, arg5)
2267 {
2268 struct task_struct *me = current;
2269 struct task_struct *tsk;
2270 unsigned char comm[sizeof(me->comm)];
2271 long error;
2272
2273 error = security_task_prctl(option, arg2, arg3, arg4, arg5);
2274 if (error != -ENOSYS)
2275 return error;
2276
2277 error = 0;
2278 switch (option) {
2279 case PR_SET_PDEATHSIG:
2280 if (!valid_signal(arg2)) {
2281 error = -EINVAL;
2282 break;
2283 }
2284 me->pdeath_signal = arg2;
2285 break;
2286 case PR_GET_PDEATHSIG:
2287 error = put_user(me->pdeath_signal, (int __user *)arg2);
2288 break;
2289 case PR_GET_DUMPABLE:
2290 error = get_dumpable(me->mm);
2291 break;
2292 case PR_SET_DUMPABLE:
2293 if (arg2 != SUID_DUMP_DISABLE && arg2 != SUID_DUMP_USER) {
2294 error = -EINVAL;
2295 break;
2296 }
2297 set_dumpable(me->mm, arg2);
2298 break;
2299
2300 case PR_SET_UNALIGN:
2301 error = SET_UNALIGN_CTL(me, arg2);
2302 break;
2303 case PR_GET_UNALIGN:
2304 error = GET_UNALIGN_CTL(me, arg2);
2305 break;
2306 case PR_SET_FPEMU:
2307 error = SET_FPEMU_CTL(me, arg2);
2308 break;
2309 case PR_GET_FPEMU:
2310 error = GET_FPEMU_CTL(me, arg2);
2311 break;
2312 case PR_SET_FPEXC:
2313 error = SET_FPEXC_CTL(me, arg2);
2314 break;
2315 case PR_GET_FPEXC:
2316 error = GET_FPEXC_CTL(me, arg2);
2317 break;
2318 case PR_GET_TIMING:
2319 error = PR_TIMING_STATISTICAL;
2320 break;
2321 case PR_SET_TIMING:
2322 if (arg2 != PR_TIMING_STATISTICAL)
2323 error = -EINVAL;
2324 break;
2325 case PR_SET_NAME:
2326 comm[sizeof(me->comm) - 1] = 0;
2327 if (strncpy_from_user(comm, (char __user *)arg2,
2328 sizeof(me->comm) - 1) < 0)
2329 return -EFAULT;
2330 set_task_comm(me, comm);
2331 proc_comm_connector(me);
2332 break;
2333 case PR_GET_NAME:
2334 get_task_comm(comm, me);
2335 if (copy_to_user((char __user *)arg2, comm, sizeof(comm)))
2336 return -EFAULT;
2337 break;
2338 case PR_GET_ENDIAN:
2339 error = GET_ENDIAN(me, arg2);
2340 break;
2341 case PR_SET_ENDIAN:
2342 error = SET_ENDIAN(me, arg2);
2343 break;
2344 case PR_GET_SECCOMP:
2345 error = prctl_get_seccomp();
2346 break;
2347 case PR_SET_SECCOMP:
2348 error = prctl_set_seccomp(arg2, (char __user *)arg3);
2349 break;
2350 case PR_GET_TSC:
2351 error = GET_TSC_CTL(arg2);
2352 break;
2353 case PR_SET_TSC:
2354 error = SET_TSC_CTL(arg2);
2355 break;
2356 case PR_TASK_PERF_EVENTS_DISABLE:
2357 error = perf_event_task_disable();
2358 break;
2359 case PR_TASK_PERF_EVENTS_ENABLE:
2360 error = perf_event_task_enable();
2361 break;
2362 case PR_GET_TIMERSLACK:
2363 error = current->timer_slack_ns;
2364 break;
2365 case PR_SET_TIMERSLACK:
2366 if (arg2 <= 0)
2367 current->timer_slack_ns =
2368 current->default_timer_slack_ns;
2369 else
2370 current->timer_slack_ns = arg2;
2371 break;
2372 case PR_MCE_KILL:
2373 if (arg4 | arg5)
2374 return -EINVAL;
2375 switch (arg2) {
2376 case PR_MCE_KILL_CLEAR:
2377 if (arg3 != 0)
2378 return -EINVAL;
2379 current->flags &= ~PF_MCE_PROCESS;
2380 break;
2381 case PR_MCE_KILL_SET:
2382 current->flags |= PF_MCE_PROCESS;
2383 if (arg3 == PR_MCE_KILL_EARLY)
2384 current->flags |= PF_MCE_EARLY;
2385 else if (arg3 == PR_MCE_KILL_LATE)
2386 current->flags &= ~PF_MCE_EARLY;
2387 else if (arg3 == PR_MCE_KILL_DEFAULT)
2388 current->flags &=
2389 ~(PF_MCE_EARLY|PF_MCE_PROCESS);
2390 else
2391 return -EINVAL;
2392 break;
2393 case PR_SET_TIMERSLACK_PID:
2394 if (current->pid != (pid_t)arg3 &&
2395 !capable(CAP_SYS_NICE))
2396 return -EPERM;
2397 rcu_read_lock();
2398 tsk = find_task_by_pid_ns((pid_t)arg3, &init_pid_ns);
2399 if (tsk == NULL) {
2400 rcu_read_unlock();
2401 return -EINVAL;
2402 }
2403 get_task_struct(tsk);
2404 rcu_read_unlock();
2405 if (arg2 <= 0)
2406 tsk->timer_slack_ns =
2407 tsk->default_timer_slack_ns;
2408 else
2409 tsk->timer_slack_ns = arg2;
2410 put_task_struct(tsk);
2411 error = 0;
2412 break;
2413 default:
2414 return -EINVAL;
2415 }
2416 break;
2417 case PR_MCE_KILL_GET:
2418 if (arg2 | arg3 | arg4 | arg5)
2419 return -EINVAL;
2420 if (current->flags & PF_MCE_PROCESS)
2421 error = (current->flags & PF_MCE_EARLY) ?
2422 PR_MCE_KILL_EARLY : PR_MCE_KILL_LATE;
2423 else
2424 error = PR_MCE_KILL_DEFAULT;
2425 break;
2426 case PR_SET_MM:
2427 error = prctl_set_mm(arg2, arg3, arg4, arg5);
2428 break;
2429 case PR_GET_TID_ADDRESS:
2430 error = prctl_get_tid_address(me, (int __user **)arg2);
2431 break;
2432 case PR_SET_CHILD_SUBREAPER:
2433 me->signal->is_child_subreaper = !!arg2;
2434 break;
2435 case PR_GET_CHILD_SUBREAPER:
2436 error = put_user(me->signal->is_child_subreaper,
2437 (int __user *)arg2);
2438 break;
2439 case PR_SET_NO_NEW_PRIVS:
2440 if (arg2 != 1 || arg3 || arg4 || arg5)
2441 return -EINVAL;
2442
2443 task_set_no_new_privs(current);
2444 break;
2445 case PR_GET_NO_NEW_PRIVS:
2446 if (arg2 || arg3 || arg4 || arg5)
2447 return -EINVAL;
2448 return task_no_new_privs(current) ? 1 : 0;
2449 case PR_SET_VMA:
2450 error = prctl_set_vma(arg2, arg3, arg4, arg5);
2451 break;
2452 default:
2453 error = -EINVAL;
2454 break;
2455 }
2456 return error;
2457 }
2458
2459 SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep,
2460 struct getcpu_cache __user *, unused)
2461 {
2462 int err = 0;
2463 int cpu = raw_smp_processor_id();
2464 if (cpup)
2465 err |= put_user(cpu, cpup);
2466 if (nodep)
2467 err |= put_user(cpu_to_node(cpu), nodep);
2468 return err ? -EFAULT : 0;
2469 }
2470
2471 char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
2472
2473 static int __orderly_poweroff(bool force)
2474 {
2475 char **argv;
2476 static char *envp[] = {
2477 "HOME=/",
2478 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
2479 NULL
2480 };
2481 int ret;
2482
2483 argv = argv_split(GFP_KERNEL, poweroff_cmd, NULL);
2484 if (argv) {
2485 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
2486 argv_free(argv);
2487 } else {
2488 printk(KERN_WARNING "%s failed to allocate memory for \"%s\"\n",
2489 __func__, poweroff_cmd);
2490 ret = -ENOMEM;
2491 }
2492
2493 if (ret && force) {
2494 printk(KERN_WARNING "Failed to start orderly shutdown: "
2495 "forcing the issue\n");
2496 /*
2497 * I guess this should try to kick off some daemon to sync and
2498 * poweroff asap. Or not even bother syncing if we're doing an
2499 * emergency shutdown?
2500 */
2501 emergency_sync();
2502 kernel_power_off();
2503 }
2504
2505 return ret;
2506 }
2507
2508 static bool poweroff_force;
2509
2510 static void poweroff_work_func(struct work_struct *work)
2511 {
2512 __orderly_poweroff(poweroff_force);
2513 }
2514
2515 static DECLARE_WORK(poweroff_work, poweroff_work_func);
2516
2517 /**
2518 * orderly_poweroff - Trigger an orderly system poweroff
2519 * @force: force poweroff if command execution fails
2520 *
2521 * This may be called from any context to trigger a system shutdown.
2522 * If the orderly shutdown fails, it will force an immediate shutdown.
2523 */
2524 int orderly_poweroff(bool force)
2525 {
2526 if (force) /* do not override the pending "true" */
2527 poweroff_force = true;
2528 schedule_work(&poweroff_work);
2529 return 0;
2530 }
2531 EXPORT_SYMBOL_GPL(orderly_poweroff);
2532
2533 /**
2534 * do_sysinfo - fill in sysinfo struct
2535 * @info: pointer to buffer to fill
2536 */
2537 static int do_sysinfo(struct sysinfo *info)
2538 {
2539 unsigned long mem_total, sav_total;
2540 unsigned int mem_unit, bitcount;
2541 struct timespec tp;
2542
2543 memset(info, 0, sizeof(struct sysinfo));
2544
2545 ktime_get_ts(&tp);
2546 monotonic_to_bootbased(&tp);
2547 info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
2548
2549 get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);
2550
2551 info->procs = nr_threads;
2552
2553 si_meminfo(info);
2554 si_swapinfo(info);
2555
2556 /*
2557 * If the sum of all the available memory (i.e. ram + swap)
2558 * is less than can be stored in a 32 bit unsigned long then
2559 * we can be binary compatible with 2.2.x kernels. If not,
2560 * well, in that case 2.2.x was broken anyways...
2561 *
2562 * -Erik Andersen <andersee@debian.org>
2563 */
2564
2565 mem_total = info->totalram + info->totalswap;
2566 if (mem_total < info->totalram || mem_total < info->totalswap)
2567 goto out;
2568 bitcount = 0;
2569 mem_unit = info->mem_unit;
2570 while (mem_unit > 1) {
2571 bitcount++;
2572 mem_unit >>= 1;
2573 sav_total = mem_total;
2574 mem_total <<= 1;
2575 if (mem_total < sav_total)
2576 goto out;
2577 }
2578
2579 /*
2580 * If mem_total did not overflow, multiply all memory values by
2581 * info->mem_unit and set it to 1. This leaves things compatible
2582 * with 2.2.x, and also retains compatibility with earlier 2.4.x
2583 * kernels...
2584 */
2585
2586 info->mem_unit = 1;
2587 info->totalram <<= bitcount;
2588 info->freeram <<= bitcount;
2589 info->sharedram <<= bitcount;
2590 info->bufferram <<= bitcount;
2591 info->totalswap <<= bitcount;
2592 info->freeswap <<= bitcount;
2593 info->totalhigh <<= bitcount;
2594 info->freehigh <<= bitcount;
2595
2596 out:
2597 return 0;
2598 }
2599
2600 SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info)
2601 {
2602 struct sysinfo val;
2603
2604 do_sysinfo(&val);
2605
2606 if (copy_to_user(info, &val, sizeof(struct sysinfo)))
2607 return -EFAULT;
2608
2609 return 0;
2610 }
2611
2612 #ifdef CONFIG_COMPAT
2613 struct compat_sysinfo {
2614 s32 uptime;
2615 u32 loads[3];
2616 u32 totalram;
2617 u32 freeram;
2618 u32 sharedram;
2619 u32 bufferram;
2620 u32 totalswap;
2621 u32 freeswap;
2622 u16 procs;
2623 u16 pad;
2624 u32 totalhigh;
2625 u32 freehigh;
2626 u32 mem_unit;
2627 char _f[20-2*sizeof(u32)-sizeof(int)];
2628 };
2629
2630 COMPAT_SYSCALL_DEFINE1(sysinfo, struct compat_sysinfo __user *, info)
2631 {
2632 struct sysinfo s;
2633
2634 do_sysinfo(&s);
2635
2636 /* Check to see if any memory value is too large for 32-bit and scale
2637 * down if needed
2638 */
2639 if ((s.totalram >> 32) || (s.totalswap >> 32)) {
2640 int bitcount = 0;
2641
2642 while (s.mem_unit < PAGE_SIZE) {
2643 s.mem_unit <<= 1;
2644 bitcount++;
2645 }
2646
2647 s.totalram >>= bitcount;
2648 s.freeram >>= bitcount;
2649 s.sharedram >>= bitcount;
2650 s.bufferram >>= bitcount;
2651 s.totalswap >>= bitcount;
2652 s.freeswap >>= bitcount;
2653 s.totalhigh >>= bitcount;
2654 s.freehigh >>= bitcount;
2655 }
2656
2657 if (!access_ok(VERIFY_WRITE, info, sizeof(struct compat_sysinfo)) ||
2658 __put_user(s.uptime, &info->uptime) ||
2659 __put_user(s.loads[0], &info->loads[0]) ||
2660 __put_user(s.loads[1], &info->loads[1]) ||
2661 __put_user(s.loads[2], &info->loads[2]) ||
2662 __put_user(s.totalram, &info->totalram) ||
2663 __put_user(s.freeram, &info->freeram) ||
2664 __put_user(s.sharedram, &info->sharedram) ||
2665 __put_user(s.bufferram, &info->bufferram) ||
2666 __put_user(s.totalswap, &info->totalswap) ||
2667 __put_user(s.freeswap, &info->freeswap) ||
2668 __put_user(s.procs, &info->procs) ||
2669 __put_user(s.totalhigh, &info->totalhigh) ||
2670 __put_user(s.freehigh, &info->freehigh) ||
2671 __put_user(s.mem_unit, &info->mem_unit))
2672 return -EFAULT;
2673
2674 return 0;
2675 }
2676 #endif /* CONFIG_COMPAT */
kernel source for telekom puls (alcatel/mediatek)