kernel/sys.c

   1 /*
   2  *  linux/kernel/sys.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/module.h>
   9 #include <linux/mm.h>
  10 #include <linux/utsname.h>
  11 #include <linux/mman.h>
  12 #include <linux/smp_lock.h>
  13 #include <linux/notifier.h>
  14 #include <linux/kmod.h>
  15 #include <linux/reboot.h>
  16 #include <linux/prctl.h>
  17 #include <linux/init.h>
  18 #include <linux/highuid.h>
  19 #include <linux/fs.h>
  20 #include <linux/workqueue.h>
  21 #include <linux/device.h>
  22 #include <linux/key.h>
  23 #include <linux/times.h>
  24 #include <linux/security.h>
  25 #include <linux/dcookies.h>
  26 #include <linux/suspend.h>
  27 #include <linux/ckrm.h>
  28 #include <linux/vs_base.h>
  29 #include <linux/vs_cvirt.h>
  30 #include <linux/tty.h>
  31
  32 #include <linux/compat.h>
  33 #include <linux/syscalls.h>
  34
  35 #include <asm/uaccess.h>
  36 #include <asm/io.h>
  37 #include <asm/unistd.h>
  38
  39 #ifndef SET_UNALIGN_CTL
  40 # define SET_UNALIGN_CTL(a,b)   (-EINVAL)
  41 #endif
  42 #ifndef GET_UNALIGN_CTL
  43 # define GET_UNALIGN_CTL(a,b)   (-EINVAL)
  44 #endif
  45 #ifndef SET_FPEMU_CTL
  46 # define SET_FPEMU_CTL(a,b)     (-EINVAL)
  47 #endif
  48 #ifndef GET_FPEMU_CTL
  49 # define GET_FPEMU_CTL(a,b)     (-EINVAL)
  50 #endif
  51 #ifndef SET_FPEXC_CTL
  52 # define SET_FPEXC_CTL(a,b)     (-EINVAL)
  53 #endif
  54 #ifndef GET_FPEXC_CTL
  55 # define GET_FPEXC_CTL(a,b)     (-EINVAL)
  56 #endif
  57
  58 /*
  59  * this is where the system-wide overflow UID and GID are defined, for
  60  * architectures that now have 32-bit UID/GID but didn't in the past
  61  */
  62
  63 int overflowuid = DEFAULT_OVERFLOWUID;
  64 int overflowgid = DEFAULT_OVERFLOWGID;
  65
  66 #ifdef CONFIG_UID16
  67 EXPORT_SYMBOL(overflowuid);
  68 EXPORT_SYMBOL(overflowgid);
  69 #endif
  70
  71 /*
  72  * the same as above, but for filesystems which can only store a 16-bit
  73  * UID and GID. as such, this is needed on all architectures
  74  */
  75
  76 int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
  77 int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;
  78
  79 EXPORT_SYMBOL(fs_overflowuid);
  80 EXPORT_SYMBOL(fs_overflowgid);
  81
  82 /*
  83  * this indicates whether you can reboot with ctrl-alt-del: the default is yes
  84  */
  85
  86 int C_A_D = 1;
  87 int cad_pid = 1;
  88
  89 /*
  90  *      Notifier list for kernel code which wants to be called
  91  *      at shutdown. This is used to stop any idling DMA operations
  92  *      and the like.
  93  */
  94
  95 static struct notifier_block *reboot_notifier_list;
  96 rwlock_t notifier_lock = RW_LOCK_UNLOCKED;
  97
  98 /**
  99  *      notifier_chain_register - Add notifier to a notifier chain
 100  *      @list: Pointer to root list pointer
 101  *      @n: New entry in notifier chain
 102  *
 103  *      Adds a notifier to a notifier chain.
 104  *
 105  *      Currently always returns zero.
 106  */
 107
 108 int notifier_chain_register(struct notifier_block **list, struct notifier_block *n)
 109 {
 110         write_lock(&notifier_lock);
 111         while(*list)
 112         {
 113                 if(n->priority > (*list)->priority)
 114                         break;
 115                 list= &((*list)->next);
 116         }
 117         n->next = *list;
 118         *list=n;
 119         write_unlock(&notifier_lock);
 120         return 0;
 121 }
 122
 123 EXPORT_SYMBOL(notifier_chain_register);
 124
 125 /**
 126  *      notifier_chain_unregister - Remove notifier from a notifier chain
 127  *      @nl: Pointer to root list pointer
 128  *      @n: New entry in notifier chain
 129  *
 130  *      Removes a notifier from a notifier chain.
 131  *
 132  *      Returns zero on success, or %-ENOENT on failure.
 133  */
 134
 135 int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n)
 136 {
 137         write_lock(&notifier_lock);
 138         while((*nl)!=NULL)
 139         {
 140                 if((*nl)==n)
 141                 {
 142                         *nl=n->next;
 143                         write_unlock(&notifier_lock);
 144                         return 0;
 145                 }
 146                 nl=&((*nl)->next);
 147         }
 148         write_unlock(&notifier_lock);
 149         return -ENOENT;
 150 }
 151
 152 EXPORT_SYMBOL(notifier_chain_unregister);
 153
 154 /**
 155  *      notifier_call_chain - Call functions in a notifier chain
 156  *      @n: Pointer to root pointer of notifier chain
 157  *      @val: Value passed unmodified to notifier function
 158  *      @v: Pointer passed unmodified to notifier function
 159  *
 160  *      Calls each function in a notifier chain in turn.
 161  *
 162  *      If the return value of the notifier can be and'd
 163  *      with %NOTIFY_STOP_MASK, then notifier_call_chain
 164  *      will return immediately, with the return value of
 165  *      the notifier function which halted execution.
 166  *      Otherwise, the return value is the return value
 167  *      of the last notifier function called.
 168  */
 169
 170 int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v)
 171 {
 172         int ret=NOTIFY_DONE;
 173         struct notifier_block *nb = *n;
 174
 175         while(nb)
 176         {
 177                 ret=nb->notifier_call(nb,val,v);
 178                 if(ret&NOTIFY_STOP_MASK)
 179                 {
 180                         return ret;
 181                 }
 182                 nb=nb->next;
 183         }
 184         return ret;
 185 }
 186
 187 EXPORT_SYMBOL(notifier_call_chain);
 188
 189 /**
 190  *      register_reboot_notifier - Register function to be called at reboot time
 191  *      @nb: Info about notifier function to be called
 192  *
 193  *      Registers a function with the list of functions
 194  *      to be called at reboot time.
 195  *
 196  *      Currently always returns zero, as notifier_chain_register
 197  *      always returns zero.
 198  */
 199
 200 int register_reboot_notifier(struct notifier_block * nb)
 201 {
 202         return notifier_chain_register(&reboot_notifier_list, nb);
 203 }
 204
 205 EXPORT_SYMBOL(register_reboot_notifier);
 206
 207 /**
 208  *      unregister_reboot_notifier - Unregister previously registered reboot notifier
 209  *      @nb: Hook to be unregistered
 210  *
 211  *      Unregisters a previously registered reboot
 212  *      notifier function.
 213  *
 214  *      Returns zero on success, or %-ENOENT on failure.
 215  */
 216
 217 int unregister_reboot_notifier(struct notifier_block * nb)
 218 {
 219         return notifier_chain_unregister(&reboot_notifier_list, nb);
 220 }
 221
 222 EXPORT_SYMBOL(unregister_reboot_notifier);
 223 static int set_one_prio(struct task_struct *p, int niceval, int error)
 224 {
 225         int no_nice;
 226
 227         if (p->uid != current->euid &&
 228                 p->uid != current->uid && !capable(CAP_SYS_NICE)) {
 229                 error = -EPERM;
 230                 goto out;
 231         }
 232         if (niceval < task_nice(p) && !capable(CAP_SYS_NICE)) {
 233                 if (vx_flags(VXF_IGNEG_NICE, 0))
 234                         error = 0;
 235                 else
 236                         error = -EACCES;
 237                 goto out;
 238         }
 239         no_nice = security_task_setnice(p, niceval);
 240         if (no_nice) {
 241                 error = no_nice;
 242                 goto out;
 243         }
 244         if (error == -ESRCH)
 245                 error = 0;
 246         set_user_nice(p, niceval);
 247 out:
 248         return error;
 249 }
 250
 251 asmlinkage long sys_setpriority(int which, int who, int niceval)
 252 {
 253         struct task_struct *g, *p;
 254         struct user_struct *user;
 255         int error = -EINVAL;
 256
 257         if (which > 2 || which < 0)
 258                 goto out;
 259
 260         /* normalize: avoid signed division (rounding problems) */
 261         error = -ESRCH;
 262         if (niceval < -20)
 263                 niceval = -20;
 264         if (niceval > 19)
 265                 niceval = 19;
 266
 267         read_lock(&tasklist_lock);
 268         switch (which) {
 269                 case PRIO_PROCESS:
 270                         if (!who)
 271                                 who = current->pid;
 272                         p = find_task_by_pid(who);
 273                         if (p)
 274                                 error = set_one_prio(p, niceval, error);
 275                         break;
 276                 case PRIO_PGRP:
 277                         if (!who)
 278                                 who = process_group(current);
 279                         do_each_task_pid(who, PIDTYPE_PGID, p) {
 280                                 error = set_one_prio(p, niceval, error);
 281                         } while_each_task_pid(who, PIDTYPE_PGID, p);
 282                         break;
 283                 case PRIO_USER:
 284                         user = current->user;
 285                         if (!who)
 286                                 who = current->uid;
 287                         else
 288                                 if ((who != current->uid) &&
 289                                         !(user = find_user(vx_current_xid(), who)))
 290                                         goto out_unlock;        /* No processes for this user */
 291
 292                         do_each_thread(g, p)
 293                                 if (p->uid == who)
 294                                         error = set_one_prio(p, niceval, error);
 295                         while_each_thread(g, p);
 296                         if (who != current->uid)
 297                                 free_uid(user);         /* For find_user() */
 298                         break;
 299         }
 300 out_unlock:
 301         read_unlock(&tasklist_lock);
 302 out:
 303         return error;
 304 }
 305
 306 /*
 307  * Ugh. To avoid negative return values, "getpriority()" will
 308  * not return the normal nice-value, but a negated value that
 309  * has been offset by 20 (ie it returns 40..1 instead of -20..19)
 310  * to stay compatible.
 311  */
 312 asmlinkage long sys_getpriority(int which, int who)
 313 {
 314         struct task_struct *g, *p;
 315         struct user_struct *user;
 316         long niceval, retval = -ESRCH;
 317
 318         if (which > 2 || which < 0)
 319                 return -EINVAL;
 320
 321         read_lock(&tasklist_lock);
 322         switch (which) {
 323                 case PRIO_PROCESS:
 324                         if (!who)
 325                                 who = current->pid;
 326                         p = find_task_by_pid(who);
 327                         if (p) {
 328                                 niceval = 20 - task_nice(p);
 329                                 if (niceval > retval)
 330                                         retval = niceval;
 331                         }
 332                         break;
 333                 case PRIO_PGRP:
 334                         if (!who)
 335                                 who = process_group(current);
 336                         do_each_task_pid(who, PIDTYPE_PGID, p) {
 337                                 niceval = 20 - task_nice(p);
 338                                 if (niceval > retval)
 339                                         retval = niceval;
 340                         } while_each_task_pid(who, PIDTYPE_PGID, p);
 341                         break;
 342                 case PRIO_USER:
 343                         user = current->user;
 344                         if (!who)
 345                                 who = current->uid;
 346                         else
 347                                 if ((who != current->uid) &&
 348                                         !(user = find_user(vx_current_xid(), who)))
 349                                         goto out_unlock;        /* No processes for this user */
 350
 351                         do_each_thread(g, p)
 352                                 if (p->uid == who) {
 353                                         niceval = 20 - task_nice(p);
 354                                         if (niceval > retval)
 355                                                 retval = niceval;
 356                                 }
 357                         while_each_thread(g, p);
 358                         if (who != current->uid)
 359                                 free_uid(user);         /* for find_user() */
 360                         break;
 361         }
 362 out_unlock:
 363         read_unlock(&tasklist_lock);
 364
 365         return retval;
 366 }
 367
 368 long vs_reboot(unsigned int, void *);
 369
 370 /*
 371  * Reboot system call: for obvious reasons only root may call it,
 372  * and even root needs to set up some magic numbers in the registers
 373  * so that some mistake won't make this reboot the whole machine.
 374  * You can also set the meaning of the ctrl-alt-del-key here.
 375  *
 376  * reboot doesn't sync: do that yourself before calling this.
 377  */
 378 asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user * arg)
 379 {
 380         char buffer[256];
 381
 382         /* We only trust the superuser with rebooting the system. */
 383         if (!capable(CAP_SYS_BOOT))
 384                 return -EPERM;
 385
 386         /* For safety, we require "magic" arguments. */
 387         if (magic1 != LINUX_REBOOT_MAGIC1 ||
 388             (magic2 != LINUX_REBOOT_MAGIC2 &&
 389                         magic2 != LINUX_REBOOT_MAGIC2A &&
 390                         magic2 != LINUX_REBOOT_MAGIC2B &&
 391                         magic2 != LINUX_REBOOT_MAGIC2C))
 392                 return -EINVAL;
 393
 394         if (!vx_check(0, VX_ADMIN|VX_WATCH))
 395                 return vs_reboot(cmd, arg);
 396
 397         lock_kernel();
 398         switch (cmd) {
 399         case LINUX_REBOOT_CMD_RESTART:
 400                 notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
 401                 system_state = SYSTEM_RESTART;
 402                 device_shutdown();
 403                 printk(KERN_EMERG "Restarting system.\n");
 404                 machine_restart(NULL);
 405                 break;
 406
 407         case LINUX_REBOOT_CMD_CAD_ON:
 408                 C_A_D = 1;
 409                 break;
 410
 411         case LINUX_REBOOT_CMD_CAD_OFF:
 412                 C_A_D = 0;
 413                 break;
 414
 415         case LINUX_REBOOT_CMD_HALT:
 416                 notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);
 417                 system_state = SYSTEM_HALT;
 418                 device_shutdown();
 419                 printk(KERN_EMERG "System halted.\n");
 420                 machine_halt();
 421                 unlock_kernel();
 422                 do_exit(0);
 423                 break;
 424
 425         case LINUX_REBOOT_CMD_POWER_OFF:
 426                 notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);
 427                 system_state = SYSTEM_POWER_OFF;
 428                 device_shutdown();
 429                 printk(KERN_EMERG "Power down.\n");
 430                 machine_power_off();
 431                 unlock_kernel();
 432                 do_exit(0);
 433                 break;
 434
 435         case LINUX_REBOOT_CMD_RESTART2:
 436                 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
 437                         unlock_kernel();
 438                         return -EFAULT;
 439                 }
 440                 buffer[sizeof(buffer) - 1] = '\0';
 441
 442                 notifier_call_chain(&reboot_notifier_list, SYS_RESTART, buffer);
 443                 system_state = SYSTEM_RESTART;
 444                 device_shutdown();
 445                 printk(KERN_EMERG "Restarting system with command '%s'.\n", buffer);
 446                 machine_restart(buffer);
 447                 break;
 448
 449 #ifdef CONFIG_KEXEC
 450         case LINUX_REBOOT_CMD_KEXEC:
 451         {
 452                 struct kimage *image;
 453                 image = xchg(&kexec_image, 0);
 454                 if (!image) {
 455                         unlock_kernel();
 456                         return -EINVAL;
 457                 }
 458                 notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
 459                 system_state = SYSTEM_RESTART;
 460                 device_shutdown();
 461                 system_state = SYSTEM_BOOTING;
 462                 printk(KERN_EMERG "Starting new kernel\n");
 463                 machine_shutdown();
 464                 machine_kexec(image);
 465                 break;
 466         }
 467 #endif
 468
 469 #ifdef CONFIG_SOFTWARE_SUSPEND
 470         case LINUX_REBOOT_CMD_SW_SUSPEND:
 471                 {
 472                         int ret = software_suspend();
 473                         unlock_kernel();
 474                         return ret;
 475                 }
 476 #endif
 477
 478         default:
 479                 unlock_kernel();
 480                 return -EINVAL;
 481         }
 482         unlock_kernel();
 483         return 0;
 484 }
 485
 486 static void deferred_cad(void *dummy)
 487 {
 488         notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
 489         machine_restart(NULL);
 490 }
 491
 492 /*
 493  * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
 494  * As it's called within an interrupt, it may NOT sync: the only choice
 495  * is whether to reboot at once, or just ignore the ctrl-alt-del.
 496  */
 497 void ctrl_alt_del(void)
 498 {
 499         static DECLARE_WORK(cad_work, deferred_cad, NULL);
 500
 501         if (C_A_D)
 502                 schedule_work(&cad_work);
 503         else
 504                 kill_proc(cad_pid, SIGINT, 1);
 505 }
 506
 507
 508 /*
 509  * Unprivileged users may change the real gid to the effective gid
 510  * or vice versa.  (BSD-style)
 511  *
 512  * If you set the real gid at all, or set the effective gid to a value not
 513  * equal to the real gid, then the saved gid is set to the new effective gid.
 514  *
 515  * This makes it possible for a setgid program to completely drop its
 516  * privileges, which is often a useful assertion to make when you are doing
 517  * a security audit over a program.
 518  *
 519  * The general idea is that a program which uses just setregid() will be
 520  * 100% compatible with BSD.  A program which uses just setgid() will be
 521  * 100% compatible with POSIX with saved IDs.
 522  *
 523  * SMP: There are not races, the GIDs are checked only by filesystem
 524  *      operations (as far as semantic preservation is concerned).
 525  */
 526 asmlinkage long sys_setregid(gid_t rgid, gid_t egid)
 527 {
 528         int old_rgid = current->gid;
 529         int old_egid = current->egid;
 530         int new_rgid = old_rgid;
 531         int new_egid = old_egid;
 532         int retval;
 533
 534         retval = security_task_setgid(rgid, egid, (gid_t)-1, LSM_SETID_RE);
 535         if (retval)
 536                 return retval;
 537
 538         if (rgid != (gid_t) -1) {
 539                 if ((old_rgid == rgid) ||
 540                     (current->egid==rgid) ||
 541                     capable(CAP_SETGID))
 542                         new_rgid = rgid;
 543                 else
 544                         return -EPERM;
 545         }
 546         if (egid != (gid_t) -1) {
 547                 if ((old_rgid == egid) ||
 548                     (current->egid == egid) ||
 549                     (current->sgid == egid) ||
 550                     capable(CAP_SETGID))
 551                         new_egid = egid;
 552                 else {
 553                         return -EPERM;
 554                 }
 555         }
 556         if (new_egid != old_egid)
 557         {
 558                 current->mm->dumpable = suid_dumpable;
 559                 wmb();
 560         }
 561         if (rgid != (gid_t) -1 ||
 562             (egid != (gid_t) -1 && egid != old_rgid))
 563                 current->sgid = new_egid;
 564         current->fsgid = new_egid;
 565         current->egid = new_egid;
 566         current->gid = new_rgid;
 567
 568         ckrm_cb_gid();
 569
 570         key_fsgid_changed(current);
 571         return 0;
 572 }
 573
 574 /*
 575  * setgid() is implemented like SysV w/ SAVED_IDS
 576  *
 577  * SMP: Same implicit races as above.
 578  */
 579 asmlinkage long sys_setgid(gid_t gid)
 580 {
 581         int old_egid = current->egid;
 582         int retval;
 583
 584         retval = security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_ID);
 585         if (retval)
 586                 return retval;
 587
 588         if (capable(CAP_SETGID))
 589         {
 590                 if(old_egid != gid)
 591                 {
 592                         current->mm->dumpable = suid_dumpable;
 593                         wmb();
 594                 }
 595                 current->gid = current->egid = current->sgid = current->fsgid = gid;
 596         }
 597         else if ((gid == current->gid) || (gid == current->sgid))
 598         {
 599                 if(old_egid != gid)
 600                 {
 601                         current->mm->dumpable = suid_dumpable;
 602                         wmb();
 603                 }
 604                 current->egid = current->fsgid = gid;
 605         }
 606         else
 607                 return -EPERM;
 608
 609         ckrm_cb_gid();
 610
 611         key_fsgid_changed(current);
 612         return 0;
 613 }
 614
 615 static int set_user(uid_t new_ruid, int dumpclear)
 616 {
 617         struct user_struct *new_user;
 618
 619         new_user = alloc_uid(vx_current_xid(), new_ruid);
 620         if (!new_user)
 621                 return -EAGAIN;
 622
 623         if (atomic_read(&new_user->processes) >=
 624                                 current->signal->rlim[RLIMIT_NPROC].rlim_cur &&
 625                         new_user != &root_user) {
 626                 free_uid(new_user);
 627                 return -EAGAIN;
 628         }
 629
 630         switch_uid(new_user);
 631
 632         if(dumpclear)
 633         {
 634                 current->mm->dumpable = suid_dumpable;
 635                 wmb();
 636         }
 637         current->uid = new_ruid;
 638         return 0;
 639 }
 640
 641 /*
 642  * Unprivileged users may change the real uid to the effective uid
 643  * or vice versa.  (BSD-style)
 644  *
 645  * If you set the real uid at all, or set the effective uid to a value not
 646  * equal to the real uid, then the saved uid is set to the new effective uid.
 647  *
 648  * This makes it possible for a setuid program to completely drop its
 649  * privileges, which is often a useful assertion to make when you are doing
 650  * a security audit over a program.
 651  *
 652  * The general idea is that a program which uses just setreuid() will be
 653  * 100% compatible with BSD.  A program which uses just setuid() will be
 654  * 100% compatible with POSIX with saved IDs.
 655  */
 656 asmlinkage long sys_setreuid(uid_t ruid, uid_t euid)
 657 {
 658         int old_ruid, old_euid, old_suid, new_ruid, new_euid;
 659         int retval;
 660
 661         retval = security_task_setuid(ruid, euid, (uid_t)-1, LSM_SETID_RE);
 662         if (retval)
 663                 return retval;
 664
 665         new_ruid = old_ruid = current->uid;
 666         new_euid = old_euid = current->euid;
 667         old_suid = current->suid;
 668
 669         if (ruid != (uid_t) -1) {
 670                 new_ruid = ruid;
 671                 if ((old_ruid != ruid) &&
 672                     (current->euid != ruid) &&
 673                     !capable(CAP_SETUID))
 674                         return -EPERM;
 675         }
 676
 677         if (euid != (uid_t) -1) {
 678                 new_euid = euid;
 679                 if ((old_ruid != euid) &&
 680                     (current->euid != euid) &&
 681                     (current->suid != euid) &&
 682                     !capable(CAP_SETUID))
 683                         return -EPERM;
 684         }
 685
 686         if (new_ruid != old_ruid && set_user(new_ruid, new_euid != old_euid) < 0)
 687                 return -EAGAIN;
 688
 689         if (new_euid != old_euid)
 690         {
 691                 current->mm->dumpable = suid_dumpable;
 692                 wmb();
 693         }
 694         current->fsuid = current->euid = new_euid;
 695         if (ruid != (uid_t) -1 ||
 696             (euid != (uid_t) -1 && euid != old_ruid))
 697                 current->suid = current->euid;
 698         current->fsuid = current->euid;
 699
 700         ckrm_cb_uid();
 701
 702         key_fsuid_changed(current);
 703
 704         return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_RE);
 705 }
 706
 707
 708
 709 /*
 710  * setuid() is implemented like SysV with SAVED_IDS
 711  *
 712  * Note that SAVED_ID's is deficient in that a setuid root program
 713  * like sendmail, for example, cannot set its uid to be a normal
 714  * user and then switch back, because if you're root, setuid() sets
 715  * the saved uid too.  If you don't like this, blame the bright people
 716  * in the POSIX committee and/or USG.  Note that the BSD-style setreuid()
 717  * will allow a root program to temporarily drop privileges and be able to
 718  * regain them by swapping the real and effective uid.
 719  */
 720 asmlinkage long sys_setuid(uid_t uid)
 721 {
 722         int old_euid = current->euid;
 723         int old_ruid, old_suid, new_ruid, new_suid;
 724         int retval;
 725
 726         retval = security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_ID);
 727         if (retval)
 728                 return retval;
 729
 730         old_ruid = new_ruid = current->uid;
 731         old_suid = current->suid;
 732         new_suid = old_suid;
 733
 734         if (capable(CAP_SETUID)) {
 735                 if (uid != old_ruid && set_user(uid, old_euid != uid) < 0)
 736                         return -EAGAIN;
 737                 new_suid = uid;
 738         } else if ((uid != current->uid) && (uid != new_suid))
 739                 return -EPERM;
 740
 741         if (old_euid != uid)
 742         {
 743                 current->mm->dumpable = suid_dumpable;
 744                 wmb();
 745         }
 746         current->fsuid = current->euid = uid;
 747         current->suid = new_suid;
 748
 749         ckrm_cb_uid();
 750
 751         key_fsuid_changed(current);
 752
 753         return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_ID);
 754 }
 755
 756
 757 /*
 758  * This function implements a generic ability to update ruid, euid,
 759  * and suid.  This allows you to implement the 4.4 compatible seteuid().
 760  */
 761 asmlinkage long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
 762 {
 763         int old_ruid = current->uid;
 764         int old_euid = current->euid;
 765         int old_suid = current->suid;
 766         int retval;
 767
 768         retval = security_task_setuid(ruid, euid, suid, LSM_SETID_RES);
 769         if (retval)
 770                 return retval;
 771
 772         if (!capable(CAP_SETUID)) {
 773                 if ((ruid != (uid_t) -1) && (ruid != current->uid) &&
 774                     (ruid != current->euid) && (ruid != current->suid))
 775                         return -EPERM;
 776                 if ((euid != (uid_t) -1) && (euid != current->uid) &&
 777                     (euid != current->euid) && (euid != current->suid))
 778                         return -EPERM;
 779                 if ((suid != (uid_t) -1) && (suid != current->uid) &&
 780                     (suid != current->euid) && (suid != current->suid))
 781                         return -EPERM;
 782         }
 783         if (ruid != (uid_t) -1) {
 784                 if (ruid != current->uid && set_user(ruid, euid != current->euid) < 0)
 785                         return -EAGAIN;
 786         }
 787         if (euid != (uid_t) -1) {
 788                 if (euid != current->euid)
 789                 {
 790                         current->mm->dumpable = suid_dumpable;
 791                         wmb();
 792                 }
 793                 current->euid = euid;
 794         }
 795         current->fsuid = current->euid;
 796         if (suid != (uid_t) -1)
 797                 current->suid = suid;
 798
 799         ckrm_cb_uid();
 800
 801         key_fsuid_changed(current);
 802
 803         return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_RES);
 804 }
 805
 806 asmlinkage long sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __user *suid)
 807 {
 808         int retval;
 809
 810         if (!(retval = put_user(current->uid, ruid)) &&
 811             !(retval = put_user(current->euid, euid)))
 812                 retval = put_user(current->suid, suid);
 813
 814         return retval;
 815 }
 816
 817 /*
 818  * Same as above, but for rgid, egid, sgid.
 819  */
 820 asmlinkage long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
 821 {
 822         int retval;
 823
 824         retval = security_task_setgid(rgid, egid, sgid, LSM_SETID_RES);
 825         if (retval)
 826                 return retval;
 827
 828         if (!capable(CAP_SETGID)) {
 829                 if ((rgid != (gid_t) -1) && (rgid != current->gid) &&
 830                     (rgid != current->egid) && (rgid != current->sgid))
 831                         return -EPERM;
 832                 if ((egid != (gid_t) -1) && (egid != current->gid) &&
 833                     (egid != current->egid) && (egid != current->sgid))
 834                         return -EPERM;
 835                 if ((sgid != (gid_t) -1) && (sgid != current->gid) &&
 836                     (sgid != current->egid) && (sgid != current->sgid))
 837                         return -EPERM;
 838         }
 839         if (egid != (gid_t) -1) {
 840                 if (egid != current->egid)
 841                 {
 842                         current->mm->dumpable = suid_dumpable;
 843                         wmb();
 844                 }
 845                 current->egid = egid;
 846         }
 847         current->fsgid = current->egid;
 848         if (rgid != (gid_t) -1)
 849                 current->gid = rgid;
 850         if (sgid != (gid_t) -1)
 851                 current->sgid = sgid;
 852
 853         ckrm_cb_gid();
 854
 855
 856         key_fsgid_changed(current);
 857         return 0;
 858 }
 859
 860 asmlinkage long sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __user *sgid)
 861 {
 862         int retval;
 863
 864         if (!(retval = put_user(current->gid, rgid)) &&
 865             !(retval = put_user(current->egid, egid)))
 866                 retval = put_user(current->sgid, sgid);
 867
 868         return retval;
 869 }
 870
 871
 872 /*
 873  * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
 874  * is used for "access()" and for the NFS daemon (letting nfsd stay at
 875  * whatever uid it wants to). It normally shadows "euid", except when
 876  * explicitly set by setfsuid() or for access..
 877  */
 878 asmlinkage long sys_setfsuid(uid_t uid)
 879 {
 880         int old_fsuid;
 881
 882         old_fsuid = current->fsuid;
 883         if (security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS))
 884                 return old_fsuid;
 885
 886         if (uid == current->uid || uid == current->euid ||
 887             uid == current->suid || uid == current->fsuid ||
 888             capable(CAP_SETUID))
 889         {
 890                 if (uid != old_fsuid)
 891                 {
 892                         current->mm->dumpable = suid_dumpable;
 893                         wmb();
 894                 }
 895                 current->fsuid = uid;
 896         }
 897
 898         key_fsuid_changed(current);
 899
 900         security_task_post_setuid(old_fsuid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS);
 901
 902         return old_fsuid;
 903 }
 904
 905 /*
 906  * Samma på svenska..
 907  */
 908 asmlinkage long sys_setfsgid(gid_t gid)
 909 {
 910         int old_fsgid;
 911
 912         old_fsgid = current->fsgid;
 913         if (security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_FS))
 914                 return old_fsgid;
 915
 916         if (gid == current->gid || gid == current->egid ||
 917             gid == current->sgid || gid == current->fsgid ||
 918             capable(CAP_SETGID))
 919         {
 920                 if (gid != old_fsgid)
 921                 {
 922                         current->mm->dumpable = suid_dumpable;
 923                         wmb();
 924                 }
 925                 current->fsgid = gid;
 926                 key_fsgid_changed(current);
 927         }
 928         return old_fsgid;
 929 }
 930
 931 asmlinkage long sys_times(struct tms __user * tbuf)
 932 {
 933         /*
 934          *      In the SMP world we might just be unlucky and have one of
 935          *      the times increment as we use it. Since the value is an
 936          *      atomically safe type this is just fine. Conceptually its
 937          *      as if the syscall took an instant longer to occur.
 938          */
 939         if (tbuf) {
 940                 struct tms tmp;
 941                 struct task_struct *tsk = current;
 942                 struct task_struct *t;
 943                 unsigned long utime, stime, cutime, cstime;
 944
 945                 read_lock(&tasklist_lock);
 946                 utime = tsk->signal->utime;
 947                 stime = tsk->signal->stime;
 948                 t = tsk;
 949                 do {
 950                         utime += t->utime;
 951                         stime += t->stime;
 952                         t = next_thread(t);
 953                 } while (t != tsk);
 954
 955                 /*
 956                  * While we have tasklist_lock read-locked, no dying thread
 957                  * can be updating current->signal->[us]time.  Instead,
 958                  * we got their counts included in the live thread loop.
 959                  * However, another thread can come in right now and
 960                  * do a wait call that updates current->signal->c[us]time.
 961                  * To make sure we always see that pair updated atomically,
 962                  * we take the siglock around fetching them.
 963                  */
 964                 spin_lock_irq(&tsk->sighand->siglock);
 965                 cutime = tsk->signal->cutime;
 966                 cstime = tsk->signal->cstime;
 967                 spin_unlock_irq(&tsk->sighand->siglock);
 968                 read_unlock(&tasklist_lock);
 969
 970                 tmp.tms_utime = jiffies_to_clock_t(utime);
 971                 tmp.tms_stime = jiffies_to_clock_t(stime);
 972                 tmp.tms_cutime = jiffies_to_clock_t(cutime);
 973                 tmp.tms_cstime = jiffies_to_clock_t(cstime);
 974                 if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
 975                         return -EFAULT;
 976         }
 977         return (long) jiffies_64_to_clock_t(get_jiffies_64());
 978 }
 979
 980 /*
 981  * This needs some heavy checking ...
 982  * I just haven't the stomach for it. I also don't fully
 983  * understand sessions/pgrp etc. Let somebody who does explain it.
 984  *
 985  * OK, I think I have the protection semantics right.... this is really
 986  * only important on a multi-user system anyway, to make sure one user
 987  * can't send a signal to a process owned by another.  -TYT, 12/12/91
 988  *
 989  * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
 990  * LBT 04.03.94
 991  */
 992
 993 asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
 994 {
 995         struct task_struct *p;
 996         int err = -EINVAL;
 997         pid_t rpgid;
 998
 999         if (!pid)
1000                 pid = vx_map_pid(current->pid);
1001         if (!pgid)
1002                 pgid = pid;
1003         if (pgid < 0)
1004                 return -EINVAL;
1005
1006         rpgid = vx_rmap_pid(pgid);
1007
1008         /* From this point forward we keep holding onto the tasklist lock
1009          * so that our parent does not change from under us. -DaveM
1010          */
1011         write_lock_irq(&tasklist_lock);
1012
1013         err = -ESRCH;
1014         p = find_task_by_pid(pid);
1015         if (!p)
1016                 goto out;
1017
1018         err = -EINVAL;
1019         if (!thread_group_leader(p))
1020                 goto out;
1021
1022         if (p->parent == current || p->real_parent == current) {
1023                 err = -EPERM;
1024                 if (p->signal->session != current->signal->session)
1025                         goto out;
1026                 err = -EACCES;
1027                 if (p->did_exec)
1028                         goto out;
1029         } else {
1030                 err = -ESRCH;
1031                 if (p != current)
1032                         goto out;
1033         }
1034
1035         err = -EPERM;
1036         if (p->signal->leader)
1037                 goto out;
1038
1039         if (pgid != pid) {
1040                 struct task_struct *p;
1041
1042                 do_each_task_pid(rpgid, PIDTYPE_PGID, p) {
1043                         if (p->signal->session == current->signal->session)
1044                                 goto ok_pgid;
1045                 } while_each_task_pid(rpgid, PIDTYPE_PGID, p);
1046                 goto out;
1047         }
1048
1049 ok_pgid:
1050         err = security_task_setpgid(p, rpgid);
1051         if (err)
1052                 goto out;
1053
1054         if (process_group(p) != rpgid) {
1055                 detach_pid(p, PIDTYPE_PGID);
1056                 p->signal->pgrp = rpgid;
1057                 attach_pid(p, PIDTYPE_PGID, rpgid);
1058         }
1059
1060         err = 0;
1061 out:
1062         /* All paths lead to here, thus we are safe. -DaveM */
1063         write_unlock_irq(&tasklist_lock);
1064         return err;
1065 }
1066
1067 asmlinkage long sys_getpgid(pid_t pid)
1068 {
1069         if (!pid) {
1070                 return vx_rmap_pid(process_group(current));
1071         } else {
1072                 int retval;
1073                 struct task_struct *p;
1074
1075                 read_lock(&tasklist_lock);
1076                 p = find_task_by_pid(pid);
1077
1078                 retval = -ESRCH;
1079                 if (p) {
1080                         retval = security_task_getpgid(p);
1081                         if (!retval)
1082                                 retval = vx_rmap_pid(process_group(p));
1083                 }
1084                 read_unlock(&tasklist_lock);
1085                 return retval;
1086         }
1087 }
1088
1089 #ifdef __ARCH_WANT_SYS_GETPGRP
1090
1091 asmlinkage long sys_getpgrp(void)
1092 {
1093         /* SMP - assuming writes are word atomic this is fine */
1094         return process_group(current);
1095 }
1096
1097 #endif
1098
1099 asmlinkage long sys_getsid(pid_t pid)
1100 {
1101         if (!pid) {
1102                 return current->signal->session;
1103         } else {
1104                 int retval;
1105                 struct task_struct *p;
1106
1107                 read_lock(&tasklist_lock);
1108                 p = find_task_by_pid(pid);
1109
1110                 retval = -ESRCH;
1111                 if(p) {
1112                         retval = security_task_getsid(p);
1113                         if (!retval)
1114                                 retval = p->signal->session;
1115                 }
1116                 read_unlock(&tasklist_lock);
1117                 return retval;
1118         }
1119 }
1120
1121 asmlinkage long sys_setsid(void)
1122 {
1123         struct pid *pid;
1124         int err = -EPERM;
1125
1126         if (!thread_group_leader(current))
1127                 return -EINVAL;
1128
1129         down(&tty_sem);
1130         write_lock_irq(&tasklist_lock);
1131
1132         pid = find_pid(PIDTYPE_PGID, current->pid);
1133         if (pid)
1134                 goto out;
1135
1136         current->signal->leader = 1;
1137         __set_special_pids(current->pid, current->pid);
1138         current->signal->tty = NULL;
1139         current->signal->tty_old_pgrp = 0;
1140         err = process_group(current);
1141 out:
1142         write_unlock_irq(&tasklist_lock);
1143         up(&tty_sem);
1144         return err;
1145 }
1146
1147 /*
1148  * Supplementary group IDs
1149  */
1150
1151 /* init to 2 - one for init_task, one to ensure it is never freed */
1152 struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
1153
1154 struct group_info *groups_alloc(int gidsetsize)
1155 {
1156         struct group_info *group_info;
1157         int nblocks;
1158         int i;
1159
1160         nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;
1161         /* Make sure we always allocate at least one indirect block pointer */
1162         nblocks = nblocks ? : 1;
1163         group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);
1164         if (!group_info)
1165                 return NULL;
1166         group_info->ngroups = gidsetsize;
1167         group_info->nblocks = nblocks;
1168         atomic_set(&group_info->usage, 1);
1169
1170         if (gidsetsize <= NGROUPS_SMALL) {
1171                 group_info->blocks[0] = group_info->small_block;
1172         } else {
1173                 for (i = 0; i < nblocks; i++) {
1174                         gid_t *b;
1175                         b = (void *)__get_free_page(GFP_USER);
1176                         if (!b)
1177                                 goto out_undo_partial_alloc;
1178                         group_info->blocks[i] = b;
1179                 }
1180         }
1181         return group_info;
1182
1183 out_undo_partial_alloc:
1184         while (--i >= 0) {
1185                 free_page((unsigned long)group_info->blocks[i]);
1186         }
1187         kfree(group_info);
1188         return NULL;
1189 }
1190
1191 EXPORT_SYMBOL(groups_alloc);
1192
1193 void groups_free(struct group_info *group_info)
1194 {
1195         if (group_info->blocks[0] != group_info->small_block) {
1196                 int i;
1197                 for (i = 0; i < group_info->nblocks; i++)
1198                         free_page((unsigned long)group_info->blocks[i]);
1199         }
1200         kfree(group_info);
1201 }
1202
1203 EXPORT_SYMBOL(groups_free);
1204
1205 /* export the group_info to a user-space array */
1206 static int groups_to_user(gid_t __user *grouplist,
1207     struct group_info *group_info)
1208 {
1209         int i;
1210         int count = group_info->ngroups;
1211
1212         for (i = 0; i < group_info->nblocks; i++) {
1213                 int cp_count = min(NGROUPS_PER_BLOCK, count);
1214                 int off = i * NGROUPS_PER_BLOCK;
1215                 int len = cp_count * sizeof(*grouplist);
1216
1217                 if (copy_to_user(grouplist+off, group_info->blocks[i], len))
1218                         return -EFAULT;
1219
1220                 count -= cp_count;
1221         }
1222         return 0;
1223 }
1224
1225 /* fill a group_info from a user-space array - it must be allocated already */
1226 static int groups_from_user(struct group_info *group_info,
1227     gid_t __user *grouplist)
1228  {
1229         int i;
1230         int count = group_info->ngroups;
1231
1232         for (i = 0; i < group_info->nblocks; i++) {
1233                 int cp_count = min(NGROUPS_PER_BLOCK, count);
1234                 int off = i * NGROUPS_PER_BLOCK;
1235                 int len = cp_count * sizeof(*grouplist);
1236
1237                 if (copy_from_user(group_info->blocks[i], grouplist+off, len))
1238                         return -EFAULT;
1239
1240                 count -= cp_count;
1241         }
1242         return 0;
1243 }
1244
1245 /* a simple shell-metzner sort */
1246 static void groups_sort(struct group_info *group_info)
1247 {
1248         int base, max, stride;
1249         int gidsetsize = group_info->ngroups;
1250
1251         for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
1252                 ; /* nothing */
1253         stride /= 3;
1254
1255         while (stride) {
1256                 max = gidsetsize - stride;
1257                 for (base = 0; base < max; base++) {
1258                         int left = base;
1259                         int right = left + stride;
1260                         gid_t tmp = GROUP_AT(group_info, right);
1261
1262                         while (left >= 0 && GROUP_AT(group_info, left) > tmp) {
1263                                 GROUP_AT(group_info, right) =
1264                                     GROUP_AT(group_info, left);
1265                                 right = left;
1266                                 left -= stride;
1267                         }
1268                         GROUP_AT(group_info, right) = tmp;
1269                 }
1270                 stride /= 3;
1271         }
1272 }
1273
1274 /* a simple bsearch */
1275 static int groups_search(struct group_info *group_info, gid_t grp)
1276 {
1277         int left, right;
1278
1279         if (!group_info)
1280                 return 0;
1281
1282         left = 0;
1283         right = group_info->ngroups;
1284         while (left < right) {
1285                 int mid = (left+right)/2;
1286                 int cmp = grp - GROUP_AT(group_info, mid);
1287                 if (cmp > 0)
1288                         left = mid + 1;
1289                 else if (cmp < 0)
1290                         right = mid;
1291                 else
1292                         return 1;
1293         }
1294         return 0;
1295 }
1296
1297 /* validate and set current->group_info */
1298 int set_current_groups(struct group_info *group_info)
1299 {
1300         int retval;
1301         struct group_info *old_info;
1302
1303         retval = security_task_setgroups(group_info);
1304         if (retval)
1305                 return retval;
1306
1307         groups_sort(group_info);
1308         get_group_info(group_info);
1309
1310         task_lock(current);
1311         old_info = current->group_info;
1312         current->group_info = group_info;
1313         task_unlock(current);
1314
1315         put_group_info(old_info);
1316
1317         return 0;
1318 }
1319
1320 EXPORT_SYMBOL(set_current_groups);
1321
1322 asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist)
1323 {
1324         int i = 0;
1325
1326         /*
1327          *      SMP: Nobody else can change our grouplist. Thus we are
1328          *      safe.
1329          */
1330
1331         if (gidsetsize < 0)
1332                 return -EINVAL;
1333
1334         /* no need to grab task_lock here; it cannot change */
1335         get_group_info(current->group_info);
1336         i = current->group_info->ngroups;
1337         if (gidsetsize) {
1338                 if (i > gidsetsize) {
1339                         i = -EINVAL;
1340                         goto out;
1341                 }
1342                 if (groups_to_user(grouplist, current->group_info)) {
1343                         i = -EFAULT;
1344                         goto out;
1345                 }
1346         }
1347 out:
1348         put_group_info(current->group_info);
1349         return i;
1350 }
1351
1352 /*
1353  *      SMP: Our groups are copy-on-write. We can set them safely
1354  *      without another task interfering.
1355  */
1356
1357 asmlinkage long sys_setgroups(int gidsetsize, gid_t __user *grouplist)
1358 {
1359         struct group_info *group_info;
1360         int retval;
1361
1362         if (!capable(CAP_SETGID))
1363                 return -EPERM;
1364         if ((unsigned)gidsetsize > NGROUPS_MAX)
1365                 return -EINVAL;
1366
1367         group_info = groups_alloc(gidsetsize);
1368         if (!group_info)
1369                 return -ENOMEM;
1370         retval = groups_from_user(group_info, grouplist);
1371         if (retval) {
1372                 put_group_info(group_info);
1373                 return retval;
1374         }
1375
1376         retval = set_current_groups(group_info);
1377         put_group_info(group_info);
1378
1379         return retval;
1380 }
1381
1382 /*
1383  * Check whether we're fsgid/egid or in the supplemental group..
1384  */
1385 int in_group_p(gid_t grp)
1386 {
1387         int retval = 1;
1388         if (grp != current->fsgid) {
1389                 get_group_info(current->group_info);
1390                 retval = groups_search(current->group_info, grp);
1391                 put_group_info(current->group_info);
1392         }
1393         return retval;
1394 }
1395
1396 EXPORT_SYMBOL(in_group_p);
1397
1398 int in_egroup_p(gid_t grp)
1399 {
1400         int retval = 1;
1401         if (grp != current->egid) {
1402                 get_group_info(current->group_info);
1403                 retval = groups_search(current->group_info, grp);
1404                 put_group_info(current->group_info);
1405         }
1406         return retval;
1407 }
1408
1409 EXPORT_SYMBOL(in_egroup_p);
1410
1411 DECLARE_RWSEM(uts_sem);
1412
1413 EXPORT_SYMBOL(uts_sem);
1414
1415 asmlinkage long sys_newuname(struct new_utsname __user * name)
1416 {
1417         int errno = 0;
1418
1419         down_read(&uts_sem);
1420         if (copy_to_user(name, vx_new_utsname(), sizeof *name))
1421                 errno = -EFAULT;
1422         up_read(&uts_sem);
1423         return errno;
1424 }
1425
1426 asmlinkage long sys_sethostname(char __user *name, int len)
1427 {
1428         int errno;
1429         char tmp[__NEW_UTS_LEN];
1430
1431         if (!capable(CAP_SYS_ADMIN) && !vx_ccaps(VXC_SET_UTSNAME))
1432                 return -EPERM;
1433         if (len < 0 || len > __NEW_UTS_LEN)
1434                 return -EINVAL;
1435         down_write(&uts_sem);
1436         errno = -EFAULT;
1437         if (!copy_from_user(tmp, name, len)) {
1438                 char *ptr = vx_new_uts(nodename);
1439
1440                 memcpy(ptr, tmp, len);
1441                 ptr[len] = 0;
1442                 errno = 0;
1443         }
1444         up_write(&uts_sem);
1445         return errno;
1446 }
1447
1448 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
1449
1450 asmlinkage long sys_gethostname(char __user *name, int len)
1451 {
1452         int i, errno;
1453         char *ptr;
1454
1455         if (len < 0)
1456                 return -EINVAL;
1457         down_read(&uts_sem);
1458         ptr = vx_new_uts(nodename);
1459         i = 1 + strlen(ptr);
1460         if (i > len)
1461                 i = len;
1462         errno = 0;
1463         if (copy_to_user(name, ptr, i))
1464                 errno = -EFAULT;
1465         up_read(&uts_sem);
1466         return errno;
1467 }
1468
1469 #endif
1470
1471 /*
1472  * Only setdomainname; getdomainname can be implemented by calling
1473  * uname()
1474  */
1475 asmlinkage long sys_setdomainname(char __user *name, int len)
1476 {
1477         int errno;
1478         char tmp[__NEW_UTS_LEN];
1479
1480         if (!capable(CAP_SYS_ADMIN) && !vx_ccaps(VXC_SET_UTSNAME))
1481                 return -EPERM;
1482         if (len < 0 || len > __NEW_UTS_LEN)
1483                 return -EINVAL;
1484
1485         down_write(&uts_sem);
1486         errno = -EFAULT;
1487         if (!copy_from_user(tmp, name, len)) {
1488                 char *ptr = vx_new_uts(domainname);
1489
1490                 memcpy(ptr, tmp, len);
1491                 ptr[len] = 0;
1492                 errno = 0;
1493         }
1494         up_write(&uts_sem);
1495         return errno;
1496 }
1497
1498 asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit __user *rlim)
1499 {
1500         if (resource >= RLIM_NLIMITS)
1501                 return -EINVAL;
1502         else {
1503                 struct rlimit value;
1504                 task_lock(current->group_leader);
1505                 value = current->signal->rlim[resource];
1506                 task_unlock(current->group_leader);
1507                 return copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
1508         }
1509 }
1510
1511 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1512
1513 /*
1514  *      Back compatibility for getrlimit. Needed for some apps.
1515  */
1516
1517 asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim)
1518 {
1519         struct rlimit x;
1520         if (resource >= RLIM_NLIMITS)
1521                 return -EINVAL;
1522
1523         task_lock(current->group_leader);
1524         x = current->signal->rlim[resource];
1525         task_unlock(current->group_leader);
1526         if(x.rlim_cur > 0x7FFFFFFF)
1527                 x.rlim_cur = 0x7FFFFFFF;
1528         if(x.rlim_max > 0x7FFFFFFF)
1529                 x.rlim_max = 0x7FFFFFFF;
1530         return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0;
1531 }
1532
1533 #endif
1534
1535 asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit __user *rlim)
1536 {
1537         struct rlimit new_rlim, *old_rlim;
1538         int retval;
1539
1540         if (resource >= RLIM_NLIMITS)
1541                 return -EINVAL;
1542         if(copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
1543                 return -EFAULT;
1544        if (new_rlim.rlim_cur > new_rlim.rlim_max)
1545                return -EINVAL;
1546         old_rlim = current->signal->rlim + resource;
1547         if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
1548             !capable(CAP_SYS_RESOURCE) && !vx_ccaps(VXC_SET_RLIMIT))
1549                 return -EPERM;
1550         if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > NR_OPEN)
1551                         return -EPERM;
1552
1553         retval = security_task_setrlimit(resource, &new_rlim);
1554         if (retval)
1555                 return retval;
1556
1557         task_lock(current->group_leader);
1558         *old_rlim = new_rlim;
1559         task_unlock(current->group_leader);
1560         return 0;
1561 }
1562
1563 /*
1564  * It would make sense to put struct rusage in the task_struct,
1565  * except that would make the task_struct be *really big*.  After
1566  * task_struct gets moved into malloc'ed memory, it would
1567  * make sense to do this.  It will make moving the rest of the information
1568  * a lot simpler!  (Which we're not doing right now because we're not
1569  * measuring them yet).
1570  *
1571  * This expects to be called with tasklist_lock read-locked or better,
1572  * and the siglock not locked.  It may momentarily take the siglock.
1573  *
1574  * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1575  * races with threads incrementing their own counters.  But since word
1576  * reads are atomic, we either get new values or old values and we don't
1577  * care which for the sums.  We always take the siglock to protect reading
1578  * the c* fields from p->signal from races with exit.c updating those
1579  * fields when reaping, so a sample either gets all the additions of a
1580  * given child after it's reaped, or none so this sample is before reaping.
1581  */
1582
1583 void k_getrusage(struct task_struct *p, int who, struct rusage *r)
1584 {
1585         struct task_struct *t;
1586         unsigned long flags;
1587         unsigned long utime, stime;
1588
1589         memset((char *) r, 0, sizeof *r);
1590
1591         if (unlikely(!p->signal))
1592                 return;
1593
1594         switch (who) {
1595                 case RUSAGE_CHILDREN:
1596                         spin_lock_irqsave(&p->sighand->siglock, flags);
1597                         utime = p->signal->cutime;
1598                         stime = p->signal->cstime;
1599                         r->ru_nvcsw = p->signal->cnvcsw;
1600                         r->ru_nivcsw = p->signal->cnivcsw;
1601                         r->ru_minflt = p->signal->cmin_flt;
1602                         r->ru_majflt = p->signal->cmaj_flt;
1603                         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1604                         jiffies_to_timeval(utime, &r->ru_utime);
1605                         jiffies_to_timeval(stime, &r->ru_stime);
1606                         break;
1607                 case RUSAGE_SELF:
1608                         spin_lock_irqsave(&p->sighand->siglock, flags);
1609                         utime = stime = 0;
1610                         goto sum_group;
1611                 case RUSAGE_BOTH:
1612                         spin_lock_irqsave(&p->sighand->siglock, flags);
1613                         utime = p->signal->cutime;
1614                         stime = p->signal->cstime;
1615                         r->ru_nvcsw = p->signal->cnvcsw;
1616                         r->ru_nivcsw = p->signal->cnivcsw;
1617                         r->ru_minflt = p->signal->cmin_flt;
1618                         r->ru_majflt = p->signal->cmaj_flt;
1619                 sum_group:
1620                         utime += p->signal->utime;
1621                         stime += p->signal->stime;
1622                         r->ru_nvcsw += p->signal->nvcsw;
1623                         r->ru_nivcsw += p->signal->nivcsw;
1624                         r->ru_minflt += p->signal->min_flt;
1625                         r->ru_majflt += p->signal->maj_flt;
1626                         t = p;
1627                         do {
1628                                 utime += t->utime;
1629                                 stime += t->stime;
1630                                 r->ru_nvcsw += t->nvcsw;
1631                                 r->ru_nivcsw += t->nivcsw;
1632                                 r->ru_minflt += t->min_flt;
1633                                 r->ru_majflt += t->maj_flt;
1634                                 t = next_thread(t);
1635                         } while (t != p);
1636                         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1637                         jiffies_to_timeval(utime, &r->ru_utime);
1638                         jiffies_to_timeval(stime, &r->ru_stime);
1639                         break;
1640                 default:
1641                         BUG();
1642         }
1643 }
1644
1645 int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
1646 {
1647         struct rusage r;
1648         read_lock(&tasklist_lock);
1649         k_getrusage(p, who, &r);
1650         read_unlock(&tasklist_lock);
1651         return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1652 }
1653
1654 asmlinkage long sys_getrusage(int who, struct rusage __user *ru)
1655 {
1656         if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN)
1657                 return -EINVAL;
1658         return getrusage(current, who, ru);
1659 }
1660
1661 asmlinkage long sys_umask(int mask)
1662 {
1663         mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
1664         return mask;
1665 }
1666
1667 asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
1668                           unsigned long arg4, unsigned long arg5)
1669 {
1670         long error;
1671         int sig;
1672
1673         error = security_task_prctl(option, arg2, arg3, arg4, arg5);
1674         if (error)
1675                 return error;
1676
1677         switch (option) {
1678                 case PR_SET_PDEATHSIG:
1679                         sig = arg2;
1680                         if (sig < 0 || sig > _NSIG) {
1681                                 error = -EINVAL;
1682                                 break;
1683                         }
1684                         current->pdeath_signal = sig;
1685                         break;
1686                 case PR_GET_PDEATHSIG:
1687                         error = put_user(current->pdeath_signal, (int __user *)arg2);
1688                         break;
1689                 case PR_GET_DUMPABLE:
1690                         if (current->mm->dumpable)
1691                                 error = 1;
1692                         break;
1693                 case PR_SET_DUMPABLE:
1694                         if (arg2 < 0 && arg2 > 2) {
1695                                 error = -EINVAL;
1696                                 break;
1697                         }
1698                         current->mm->dumpable = arg2;
1699                         break;
1700
1701                 case PR_SET_UNALIGN:
1702                         error = SET_UNALIGN_CTL(current, arg2);
1703                         break;
1704                 case PR_GET_UNALIGN:
1705                         error = GET_UNALIGN_CTL(current, arg2);
1706                         break;
1707                 case PR_SET_FPEMU:
1708                         error = SET_FPEMU_CTL(current, arg2);
1709                         break;
1710                 case PR_GET_FPEMU:
1711                         error = GET_FPEMU_CTL(current, arg2);
1712                         break;
1713                 case PR_SET_FPEXC:
1714                         error = SET_FPEXC_CTL(current, arg2);
1715                         break;
1716                 case PR_GET_FPEXC:
1717                         error = GET_FPEXC_CTL(current, arg2);
1718                         break;
1719                 case PR_GET_TIMING:
1720                         error = PR_TIMING_STATISTICAL;
1721                         break;
1722                 case PR_SET_TIMING:
1723                         if (arg2 == PR_TIMING_STATISTICAL)
1724                                 error = 0;
1725                         else
1726                                 error = -EINVAL;
1727                         break;
1728
1729                 case PR_GET_KEEPCAPS:
1730                         if (current->keep_capabilities)
1731                                 error = 1;
1732                         break;
1733                 case PR_SET_KEEPCAPS:
1734                         if (arg2 != 0 && arg2 != 1) {
1735                                 error = -EINVAL;
1736                                 break;
1737                         }
1738                         current->keep_capabilities = arg2;
1739                         break;
1740                 case PR_SET_NAME: {
1741                         struct task_struct *me = current;
1742                         unsigned char ncomm[sizeof(me->comm)];
1743
1744                         ncomm[sizeof(me->comm)-1] = 0;
1745                         if (strncpy_from_user(ncomm, (char __user *)arg2,
1746                                                 sizeof(me->comm)-1) < 0)
1747                                 return -EFAULT;
1748                         set_task_comm(me, ncomm);
1749                         return 0;
1750                 }
1751                 default:
1752                         error = -EINVAL;
1753                         break;
1754         }
1755         return error;
1756 }