arch/alpha/kernel/osf_sys.c

   1 /*
   2  *  linux/arch/alpha/kernel/osf_sys.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  */
   6
   7 /*
   8  * This file handles some of the stranger OSF/1 system call interfaces.
   9  * Some of the system calls expect a non-C calling standard, others have
  10  * special parameter blocks..
  11  */
  12
  13 #include <linux/errno.h>
  14 #include <linux/sched.h>
  15 #include <linux/kernel.h>
  16 #include <linux/mm.h>
  17 #include <linux/smp.h>
  18 #include <linux/smp_lock.h>
  19 #include <linux/stddef.h>
  20 #include <linux/syscalls.h>
  21 #include <linux/unistd.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/slab.h>
  24 #include <linux/user.h>
  25 #include <linux/a.out.h>
  26 #include <linux/utsname.h>
  27 #include <linux/time.h>
  28 #include <linux/timex.h>
  29 #include <linux/major.h>
  30 #include <linux/stat.h>
  31 #include <linux/mman.h>
  32 #include <linux/shm.h>
  33 #include <linux/poll.h>
  34 #include <linux/file.h>
  35 #include <linux/types.h>
  36 #include <linux/ipc.h>
  37 #include <linux/namei.h>
  38 #include <linux/uio.h>
  39 #include <linux/vfs.h>
  40 #include <linux/rcupdate.h>
  41 #include <linux/vs_cvirt.h>
  42
  43 #include <asm/fpu.h>
  44 #include <asm/io.h>
  45 #include <asm/uaccess.h>
  46 #include <asm/system.h>
  47 #include <asm/sysinfo.h>
  48 #include <asm/hwrpb.h>
  49 #include <asm/processor.h>
  50
  51 extern int do_pipe(int *);
  52
  53 /*
  54  * Brk needs to return an error.  Still support Linux's brk(0) query idiom,
  55  * which OSF programs just shouldn't be doing.  We're still not quite
  56  * identical to OSF as we don't return 0 on success, but doing otherwise
  57  * would require changes to libc.  Hopefully this is good enough.
  58  */
  59 asmlinkage unsigned long
  60 osf_brk(unsigned long brk)
  61 {
  62         unsigned long retval = sys_brk(brk);
  63         if (brk && brk != retval)
  64                 retval = -ENOMEM;
  65         return retval;
  66 }
  67
  68 /*
  69  * This is pure guess-work..
  70  */
  71 asmlinkage int
  72 osf_set_program_attributes(unsigned long text_start, unsigned long text_len,
  73                            unsigned long bss_start, unsigned long bss_len)
  74 {
  75         struct mm_struct *mm;
  76
  77         lock_kernel();
  78         mm = current->mm;
  79         mm->end_code = bss_start + bss_len;
  80         mm->brk = bss_start + bss_len;
  81 #if 0
  82         printk("set_program_attributes(%lx %lx %lx %lx)\n",
  83                 text_start, text_len, bss_start, bss_len);
  84 #endif
  85         unlock_kernel();
  86         return 0;
  87 }
  88
  89 /*
  90  * OSF/1 directory handling functions...
  91  *
  92  * The "getdents()" interface is much more sane: the "basep" stuff is
  93  * braindamage (it can't really handle filesystems where the directory
  94  * offset differences aren't the same as "d_reclen").
  95  */
  96 #define NAME_OFFSET     offsetof (struct osf_dirent, d_name)
  97 #define ROUND_UP(x)     (((x)+3) & ~3)
  98
  99 struct osf_dirent {
 100         unsigned int d_ino;
 101         unsigned short d_reclen;
 102         unsigned short d_namlen;
 103         char d_name[1];
 104 };
 105
 106 struct osf_dirent_callback {
 107         struct osf_dirent __user *dirent;
 108         long __user *basep;
 109         unsigned int count;
 110         int error;
 111 };
 112
 113 static int
 114 osf_filldir(void *__buf, const char *name, int namlen, loff_t offset,
 115             ino_t ino, unsigned int d_type)
 116 {
 117         struct osf_dirent __user *dirent;
 118         struct osf_dirent_callback *buf = (struct osf_dirent_callback *) __buf;
 119         unsigned int reclen = ROUND_UP(NAME_OFFSET + namlen + 1);
 120         unsigned int d_ino;
 121
 122         buf->error = -EINVAL;   /* only used if we fail */
 123         if (reclen > buf->count)
 124                 return -EINVAL;
 125         d_ino = ino;
 126         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
 127                 return -EOVERFLOW;
 128         if (buf->basep) {
 129                 if (put_user(offset, buf->basep))
 130                         return -EFAULT;
 131                 buf->basep = NULL;
 132         }
 133         dirent = buf->dirent;
 134         put_user(d_ino, &dirent->d_ino);
 135         put_user(namlen, &dirent->d_namlen);
 136         put_user(reclen, &dirent->d_reclen);
 137         if (copy_to_user(dirent->d_name, name, namlen) ||
 138             put_user(0, dirent->d_name + namlen))
 139                 return -EFAULT;
 140         dirent = (void __user *)dirent + reclen;
 141         buf->dirent = dirent;
 142         buf->count -= reclen;
 143         return 0;
 144 }
 145
 146 asmlinkage int
 147 osf_getdirentries(unsigned int fd, struct osf_dirent __user *dirent,
 148                   unsigned int count, long __user *basep)
 149 {
 150         int error;
 151         struct file *file;
 152         struct osf_dirent_callback buf;
 153
 154         error = -EBADF;
 155         file = fget(fd);
 156         if (!file)
 157                 goto out;
 158
 159         buf.dirent = dirent;
 160         buf.basep = basep;
 161         buf.count = count;
 162         buf.error = 0;
 163
 164         error = vfs_readdir(file, osf_filldir, &buf);
 165         if (error < 0)
 166                 goto out_putf;
 167
 168         error = buf.error;
 169         if (count != buf.count)
 170                 error = count - buf.count;
 171
 172  out_putf:
 173         fput(file);
 174  out:
 175         return error;
 176 }
 177
 178 #undef ROUND_UP
 179 #undef NAME_OFFSET
 180
 181 asmlinkage unsigned long
 182 osf_mmap(unsigned long addr, unsigned long len, unsigned long prot,
 183          unsigned long flags, unsigned long fd, unsigned long off)
 184 {
 185         struct file *file = NULL;
 186         unsigned long ret = -EBADF;
 187
 188 #if 0
 189         if (flags & (_MAP_HASSEMAPHORE | _MAP_INHERIT | _MAP_UNALIGNED))
 190                 printk("%s: unimplemented OSF mmap flags %04lx\n",
 191                         current->comm, flags);
 192 #endif
 193         if (!(flags & MAP_ANONYMOUS)) {
 194                 file = fget(fd);
 195                 if (!file)
 196                         goto out;
 197         }
 198         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 199         down_write(&current->mm->mmap_sem);
 200         ret = do_mmap(file, addr, len, prot, flags, off);
 201         up_write(&current->mm->mmap_sem);
 202         if (file)
 203                 fput(file);
 204  out:
 205         return ret;
 206 }
 207
 208
 209 /*
 210  * The OSF/1 statfs structure is much larger, but this should
 211  * match the beginning, at least.
 212  */
 213 struct osf_statfs {
 214         short f_type;
 215         short f_flags;
 216         int f_fsize;
 217         int f_bsize;
 218         int f_blocks;
 219         int f_bfree;
 220         int f_bavail;
 221         int f_files;
 222         int f_ffree;
 223         __kernel_fsid_t f_fsid;
 224 };
 225
 226 static int
 227 linux_to_osf_statfs(struct kstatfs *linux_stat, struct osf_statfs __user *osf_stat,
 228                     unsigned long bufsiz)
 229 {
 230         struct osf_statfs tmp_stat;
 231
 232         tmp_stat.f_type = linux_stat->f_type;
 233         tmp_stat.f_flags = 0;   /* mount flags */
 234         tmp_stat.f_fsize = linux_stat->f_frsize;
 235         tmp_stat.f_bsize = linux_stat->f_bsize;
 236         tmp_stat.f_blocks = linux_stat->f_blocks;
 237         tmp_stat.f_bfree = linux_stat->f_bfree;
 238         tmp_stat.f_bavail = linux_stat->f_bavail;
 239         tmp_stat.f_files = linux_stat->f_files;
 240         tmp_stat.f_ffree = linux_stat->f_ffree;
 241         tmp_stat.f_fsid = linux_stat->f_fsid;
 242         if (bufsiz > sizeof(tmp_stat))
 243                 bufsiz = sizeof(tmp_stat);
 244         return copy_to_user(osf_stat, &tmp_stat, bufsiz) ? -EFAULT : 0;
 245 }
 246
 247 static int
 248 do_osf_statfs(struct dentry * dentry, struct osf_statfs __user *buffer,
 249               unsigned long bufsiz)
 250 {
 251         struct kstatfs linux_stat;
 252         int error = vfs_statfs(dentry, &linux_stat);
 253         if (!error)
 254                 error = linux_to_osf_statfs(&linux_stat, buffer, bufsiz);
 255         return error;
 256 }
 257
 258 asmlinkage int
 259 osf_statfs(char __user *path, struct osf_statfs __user *buffer, unsigned long bufsiz)
 260 {
 261         struct nameidata nd;
 262         int retval;
 263
 264         retval = user_path_walk(path, &nd);
 265         if (!retval) {
 266                 retval = do_osf_statfs(nd.dentry, buffer, bufsiz);
 267                 path_release(&nd);
 268         }
 269         return retval;
 270 }
 271
 272 asmlinkage int
 273 osf_fstatfs(unsigned long fd, struct osf_statfs __user *buffer, unsigned long bufsiz)
 274 {
 275         struct file *file;
 276         int retval;
 277
 278         retval = -EBADF;
 279         file = fget(fd);
 280         if (file) {
 281                 retval = do_osf_statfs(file->f_dentry, buffer, bufsiz);
 282                 fput(file);
 283         }
 284         return retval;
 285 }
 286
 287 /*
 288  * Uhh.. OSF/1 mount parameters aren't exactly obvious..
 289  *
 290  * Although to be frank, neither are the native Linux/i386 ones..
 291  */
 292 struct ufs_args {
 293         char __user *devname;
 294         int flags;
 295         uid_t exroot;
 296 };
 297
 298 struct cdfs_args {
 299         char __user *devname;
 300         int flags;
 301         uid_t exroot;
 302
 303         /* This has lots more here, which Linux handles with the option block
 304            but I'm too lazy to do the translation into ASCII.  */
 305 };
 306
 307 struct procfs_args {
 308         char __user *devname;
 309         int flags;
 310         uid_t exroot;
 311 };
 312
 313 /*
 314  * We can't actually handle ufs yet, so we translate UFS mounts to
 315  * ext2fs mounts. I wouldn't mind a UFS filesystem, but the UFS
 316  * layout is so braindead it's a major headache doing it.
 317  *
 318  * Just how long ago was it written? OTOH our UFS driver may be still
 319  * unhappy with OSF UFS. [CHECKME]
 320  */
 321 static int
 322 osf_ufs_mount(char *dirname, struct ufs_args __user *args, int flags)
 323 {
 324         int retval;
 325         struct cdfs_args tmp;
 326         char *devname;
 327
 328         retval = -EFAULT;
 329         if (copy_from_user(&tmp, args, sizeof(tmp)))
 330                 goto out;
 331         devname = getname(tmp.devname);
 332         retval = PTR_ERR(devname);
 333         if (IS_ERR(devname))
 334                 goto out;
 335         retval = do_mount(devname, dirname, "ext2", flags, NULL);
 336         putname(devname);
 337  out:
 338         return retval;
 339 }
 340
 341 static int
 342 osf_cdfs_mount(char *dirname, struct cdfs_args __user *args, int flags)
 343 {
 344         int retval;
 345         struct cdfs_args tmp;
 346         char *devname;
 347
 348         retval = -EFAULT;
 349         if (copy_from_user(&tmp, args, sizeof(tmp)))
 350                 goto out;
 351         devname = getname(tmp.devname);
 352         retval = PTR_ERR(devname);
 353         if (IS_ERR(devname))
 354                 goto out;
 355         retval = do_mount(devname, dirname, "iso9660", flags, NULL);
 356         putname(devname);
 357  out:
 358         return retval;
 359 }
 360
 361 static int
 362 osf_procfs_mount(char *dirname, struct procfs_args __user *args, int flags)
 363 {
 364         struct procfs_args tmp;
 365
 366         if (copy_from_user(&tmp, args, sizeof(tmp)))
 367                 return -EFAULT;
 368
 369         return do_mount("", dirname, "proc", flags, NULL);
 370 }
 371
 372 asmlinkage int
 373 osf_mount(unsigned long typenr, char __user *path, int flag, void __user *data)
 374 {
 375         int retval = -EINVAL;
 376         char *name;
 377
 378         lock_kernel();
 379
 380         name = getname(path);
 381         retval = PTR_ERR(name);
 382         if (IS_ERR(name))
 383                 goto out;
 384         switch (typenr) {
 385         case 1:
 386                 retval = osf_ufs_mount(name, data, flag);
 387                 break;
 388         case 6:
 389                 retval = osf_cdfs_mount(name, data, flag);
 390                 break;
 391         case 9:
 392                 retval = osf_procfs_mount(name, data, flag);
 393                 break;
 394         default:
 395                 printk("osf_mount(%ld, %x)\n", typenr, flag);
 396         }
 397         putname(name);
 398  out:
 399         unlock_kernel();
 400         return retval;
 401 }
 402
 403 asmlinkage int
 404 osf_utsname(char __user *name)
 405 {
 406         int error;
 407         struct new_utsname *ptr;
 408
 409         down_read(&uts_sem);
 410         ptr = vx_new_utsname();
 411         error = -EFAULT;
 412         if (copy_to_user(name + 0, ptr->sysname, 32))
 413                 goto out;
 414         if (copy_to_user(name + 32, ptr->nodename, 32))
 415                 goto out;
 416         if (copy_to_user(name + 64, ptr->release, 32))
 417                 goto out;
 418         if (copy_to_user(name + 96, ptr->version, 32))
 419                 goto out;
 420         if (copy_to_user(name + 128, ptr->machine, 32))
 421                 goto out;
 422
 423         error = 0;
 424  out:
 425         up_read(&uts_sem);
 426         return error;
 427 }
 428
 429 asmlinkage unsigned long
 430 sys_getpagesize(void)
 431 {
 432         return PAGE_SIZE;
 433 }
 434
 435 asmlinkage unsigned long
 436 sys_getdtablesize(void)
 437 {
 438         return NR_OPEN;
 439 }
 440
 441 /*
 442  * For compatibility with OSF/1 only.  Use utsname(2) instead.
 443  */
 444 asmlinkage int
 445 osf_getdomainname(char __user *name, int namelen)
 446 {
 447         unsigned len;
 448         int i;
 449         char *domainname;
 450
 451         if (!access_ok(VERIFY_WRITE, name, namelen))
 452                 return -EFAULT;
 453
 454         len = namelen;
 455         if (namelen > 32)
 456                 len = 32;
 457
 458         down_read(&uts_sem);
 459         domainname = vx_new_uts(domainname);
 460         for (i = 0; i < len; ++i) {
 461                 __put_user(domainname[i], name + i);
 462                 if (domainname[i] == '\0')
 463                         break;
 464         }
 465         up_read(&uts_sem);
 466
 467         return 0;
 468 }
 469
 470 /*
 471  * The following stuff should move into a header file should it ever
 472  * be labeled "officially supported."  Right now, there is just enough
 473  * support to avoid applications (such as tar) printing error
 474  * messages.  The attributes are not really implemented.
 475  */
 476
 477 /*
 478  * Values for Property list entry flag
 479  */
 480 #define PLE_PROPAGATE_ON_COPY           0x1     /* cp(1) will copy entry
 481                                                    by default */
 482 #define PLE_FLAG_MASK                   0x1     /* Valid flag values */
 483 #define PLE_FLAG_ALL                    -1      /* All flag value */
 484
 485 struct proplistname_args {
 486         unsigned int pl_mask;
 487         unsigned int pl_numnames;
 488         char **pl_names;
 489 };
 490
 491 union pl_args {
 492         struct setargs {
 493                 char __user *path;
 494                 long follow;
 495                 long nbytes;
 496                 char __user *buf;
 497         } set;
 498         struct fsetargs {
 499                 long fd;
 500                 long nbytes;
 501                 char __user *buf;
 502         } fset;
 503         struct getargs {
 504                 char __user *path;
 505                 long follow;
 506                 struct proplistname_args __user *name_args;
 507                 long nbytes;
 508                 char __user *buf;
 509                 int __user *min_buf_size;
 510         } get;
 511         struct fgetargs {
 512                 long fd;
 513                 struct proplistname_args __user *name_args;
 514                 long nbytes;
 515                 char __user *buf;
 516                 int __user *min_buf_size;
 517         } fget;
 518         struct delargs {
 519                 char __user *path;
 520                 long follow;
 521                 struct proplistname_args __user *name_args;
 522         } del;
 523         struct fdelargs {
 524                 long fd;
 525                 struct proplistname_args __user *name_args;
 526         } fdel;
 527 };
 528
 529 enum pl_code {
 530         PL_SET = 1, PL_FSET = 2,
 531         PL_GET = 3, PL_FGET = 4,
 532         PL_DEL = 5, PL_FDEL = 6
 533 };
 534
 535 asmlinkage long
 536 osf_proplist_syscall(enum pl_code code, union pl_args __user *args)
 537 {
 538         long error;
 539         int __user *min_buf_size_ptr;
 540
 541         lock_kernel();
 542         switch (code) {
 543         case PL_SET:
 544                 if (get_user(error, &args->set.nbytes))
 545                         error = -EFAULT;
 546                 break;
 547         case PL_FSET:
 548                 if (get_user(error, &args->fset.nbytes))
 549                         error = -EFAULT;
 550                 break;
 551         case PL_GET:
 552                 error = get_user(min_buf_size_ptr, &args->get.min_buf_size);
 553                 if (error)
 554                         break;
 555                 error = put_user(0, min_buf_size_ptr);
 556                 break;
 557         case PL_FGET:
 558                 error = get_user(min_buf_size_ptr, &args->fget.min_buf_size);
 559                 if (error)
 560                         break;
 561                 error = put_user(0, min_buf_size_ptr);
 562                 break;
 563         case PL_DEL:
 564         case PL_FDEL:
 565                 error = 0;
 566                 break;
 567         default:
 568                 error = -EOPNOTSUPP;
 569                 break;
 570         };
 571         unlock_kernel();
 572         return error;
 573 }
 574
 575 asmlinkage int
 576 osf_sigstack(struct sigstack __user *uss, struct sigstack __user *uoss)
 577 {
 578         unsigned long usp = rdusp();
 579         unsigned long oss_sp = current->sas_ss_sp + current->sas_ss_size;
 580         unsigned long oss_os = on_sig_stack(usp);
 581         int error;
 582
 583         if (uss) {
 584                 void __user *ss_sp;
 585
 586                 error = -EFAULT;
 587                 if (get_user(ss_sp, &uss->ss_sp))
 588                         goto out;
 589
 590                 /* If the current stack was set with sigaltstack, don't
 591                    swap stacks while we are on it.  */
 592                 error = -EPERM;
 593                 if (current->sas_ss_sp && on_sig_stack(usp))
 594                         goto out;
 595
 596                 /* Since we don't know the extent of the stack, and we don't
 597                    track onstack-ness, but rather calculate it, we must
 598                    presume a size.  Ho hum this interface is lossy.  */
 599                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
 600                 current->sas_ss_size = SIGSTKSZ;
 601         }
 602
 603         if (uoss) {
 604                 error = -EFAULT;
 605                 if (! access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))
 606                     || __put_user(oss_sp, &uoss->ss_sp)
 607                     || __put_user(oss_os, &uoss->ss_onstack))
 608                         goto out;
 609         }
 610
 611         error = 0;
 612  out:
 613         return error;
 614 }
 615
 616 asmlinkage long
 617 osf_sysinfo(int command, char __user *buf, long count)
 618 {
 619         unsigned long offset;
 620         char *res;
 621         long len, err = -EINVAL;
 622
 623         offset = command-1;
 624         if (offset >= 9) {
 625                 /* Digital UNIX has a few unpublished interfaces here */
 626                 printk("sysinfo(%d)", command);
 627                 goto out;
 628         }
 629
 630         down_read(&uts_sem);
 631         switch (offset)
 632         {
 633         case 0: res = vx_new_uts(sysname);  break;
 634         case 1: res = vx_new_uts(nodename); break;
 635         case 2: res = vx_new_uts(release);  break;
 636         case 3: res = vx_new_uts(version);  break;
 637         case 4: res = vx_new_uts(machine);  break;
 638         case 5: res = "alpha";              break;
 639         default:
 640                 res = "dummy";
 641                 break;
 642         }
 643         len = strlen(res)+1;
 644         if (len > count)
 645                 len = count;
 646         if (copy_to_user(buf, res, len))
 647                 err = -EFAULT;
 648         else
 649                 err = 0;
 650         up_read(&uts_sem);
 651  out:
 652         return err;
 653 }
 654
 655 asmlinkage unsigned long
 656 osf_getsysinfo(unsigned long op, void __user *buffer, unsigned long nbytes,
 657                int __user *start, void __user *arg)
 658 {
 659         unsigned long w;
 660         struct percpu_struct *cpu;
 661
 662         switch (op) {
 663         case GSI_IEEE_FP_CONTROL:
 664                 /* Return current software fp control & status bits.  */
 665                 /* Note that DU doesn't verify available space here.  */
 666
 667                 w = current_thread_info()->ieee_state & IEEE_SW_MASK;
 668                 w = swcr_update_status(w, rdfpcr());
 669                 if (put_user(w, (unsigned long __user *) buffer))
 670                         return -EFAULT;
 671                 return 0;
 672
 673         case GSI_IEEE_STATE_AT_SIGNAL:
 674                 /*
 675                  * Not sure anybody will ever use this weird stuff.  These
 676                  * ops can be used (under OSF/1) to set the fpcr that should
 677                  * be used when a signal handler starts executing.
 678                  */
 679                 break;
 680
 681         case GSI_UACPROC:
 682                 if (nbytes < sizeof(unsigned int))
 683                         return -EINVAL;
 684                 w = (current_thread_info()->flags >> UAC_SHIFT) & UAC_BITMASK;
 685                 if (put_user(w, (unsigned int __user *)buffer))
 686                         return -EFAULT;
 687                 return 1;
 688
 689         case GSI_PROC_TYPE:
 690                 if (nbytes < sizeof(unsigned long))
 691                         return -EINVAL;
 692                 cpu = (struct percpu_struct*)
 693                   ((char*)hwrpb + hwrpb->processor_offset);
 694                 w = cpu->type;
 695                 if (put_user(w, (unsigned long  __user*)buffer))
 696                         return -EFAULT;
 697                 return 1;
 698
 699         case GSI_GET_HWRPB:
 700                 if (nbytes < sizeof(*hwrpb))
 701                         return -EINVAL;
 702                 if (copy_to_user(buffer, hwrpb, nbytes) != 0)
 703                         return -EFAULT;
 704                 return 1;
 705
 706         default:
 707                 break;
 708         }
 709
 710         return -EOPNOTSUPP;
 711 }
 712
 713 asmlinkage unsigned long
 714 osf_setsysinfo(unsigned long op, void __user *buffer, unsigned long nbytes,
 715                int __user *start, void __user *arg)
 716 {
 717         switch (op) {
 718         case SSI_IEEE_FP_CONTROL: {
 719                 unsigned long swcr, fpcr;
 720                 unsigned int *state;
 721
 722                 /*
 723                  * Alpha Architecture Handbook 4.7.7.3:
 724                  * To be fully IEEE compiant, we must track the current IEEE
 725                  * exception state in software, because spurrious bits can be
 726                  * set in the trap shadow of a software-complete insn.
 727                  */
 728
 729                 if (get_user(swcr, (unsigned long __user *)buffer))
 730                         return -EFAULT;
 731                 state = &current_thread_info()->ieee_state;
 732
 733                 /* Update softare trap enable bits.  */
 734                 *state = (*state & ~IEEE_SW_MASK) | (swcr & IEEE_SW_MASK);
 735
 736                 /* Update the real fpcr.  */
 737                 fpcr = rdfpcr() & FPCR_DYN_MASK;
 738                 fpcr |= ieee_swcr_to_fpcr(swcr);
 739                 wrfpcr(fpcr);
 740
 741                 return 0;
 742         }
 743
 744         case SSI_IEEE_RAISE_EXCEPTION: {
 745                 unsigned long exc, swcr, fpcr, fex;
 746                 unsigned int *state;
 747
 748                 if (get_user(exc, (unsigned long __user *)buffer))
 749                         return -EFAULT;
 750                 state = &current_thread_info()->ieee_state;
 751                 exc &= IEEE_STATUS_MASK;
 752
 753                 /* Update softare trap enable bits.  */
 754                 swcr = (*state & IEEE_SW_MASK) | exc;
 755                 *state |= exc;
 756
 757                 /* Update the real fpcr.  */
 758                 fpcr = rdfpcr();
 759                 fpcr |= ieee_swcr_to_fpcr(swcr);
 760                 wrfpcr(fpcr);
 761
 762                 /* If any exceptions set by this call, and are unmasked,
 763                    send a signal.  Old exceptions are not signaled.  */
 764                 fex = (exc >> IEEE_STATUS_TO_EXCSUM_SHIFT) & swcr;
 765                 if (fex) {
 766                         siginfo_t info;
 767                         int si_code = 0;
 768
 769                         if (fex & IEEE_TRAP_ENABLE_DNO) si_code = FPE_FLTUND;
 770                         if (fex & IEEE_TRAP_ENABLE_INE) si_code = FPE_FLTRES;
 771                         if (fex & IEEE_TRAP_ENABLE_UNF) si_code = FPE_FLTUND;
 772                         if (fex & IEEE_TRAP_ENABLE_OVF) si_code = FPE_FLTOVF;
 773                         if (fex & IEEE_TRAP_ENABLE_DZE) si_code = FPE_FLTDIV;
 774                         if (fex & IEEE_TRAP_ENABLE_INV) si_code = FPE_FLTINV;
 775
 776                         info.si_signo = SIGFPE;
 777                         info.si_errno = 0;
 778                         info.si_code = si_code;
 779                         info.si_addr = NULL;  /* FIXME */
 780                         send_sig_info(SIGFPE, &info, current);
 781                 }
 782                 return 0;
 783         }
 784
 785         case SSI_IEEE_STATE_AT_SIGNAL:
 786         case SSI_IEEE_IGNORE_STATE_AT_SIGNAL:
 787                 /*
 788                  * Not sure anybody will ever use this weird stuff.  These
 789                  * ops can be used (under OSF/1) to set the fpcr that should
 790                  * be used when a signal handler starts executing.
 791                  */
 792                 break;
 793
 794         case SSI_NVPAIRS: {
 795                 unsigned long v, w, i;
 796                 unsigned int old, new;
 797
 798                 for (i = 0; i < nbytes; ++i) {
 799
 800                         if (get_user(v, 2*i + (unsigned int __user *)buffer))
 801                                 return -EFAULT;
 802                         if (get_user(w, 2*i + 1 + (unsigned int __user *)buffer))
 803                                 return -EFAULT;
 804                         switch (v) {
 805                         case SSIN_UACPROC:
 806                         again:
 807                                 old = current_thread_info()->flags;
 808                                 new = old & ~(UAC_BITMASK << UAC_SHIFT);
 809                                 new = new | (w & UAC_BITMASK) << UAC_SHIFT;
 810                                 if (cmpxchg(&current_thread_info()->flags,
 811                                             old, new) != old)
 812                                         goto again;
 813                                 break;
 814
 815                         default:
 816                                 return -EOPNOTSUPP;
 817                         }
 818                 }
 819                 return 0;
 820         }
 821
 822         default:
 823                 break;
 824         }
 825
 826         return -EOPNOTSUPP;
 827 }
 828
 829 /* Translations due to the fact that OSF's time_t is an int.  Which
 830    affects all sorts of things, like timeval and itimerval.  */
 831
 832 extern struct timezone sys_tz;
 833
 834 struct timeval32
 835 {
 836     int tv_sec, tv_usec;
 837 };
 838
 839 struct itimerval32
 840 {
 841     struct timeval32 it_interval;
 842     struct timeval32 it_value;
 843 };
 844
 845 static inline long
 846 get_tv32(struct timeval *o, struct timeval32 __user *i)
 847 {
 848         return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
 849                 (__get_user(o->tv_sec, &i->tv_sec) |
 850                  __get_user(o->tv_usec, &i->tv_usec)));
 851 }
 852
 853 static inline long
 854 put_tv32(struct timeval32 __user *o, struct timeval *i)
 855 {
 856         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 857                 (__put_user(i->tv_sec, &o->tv_sec) |
 858                  __put_user(i->tv_usec, &o->tv_usec)));
 859 }
 860
 861 static inline long
 862 get_it32(struct itimerval *o, struct itimerval32 __user *i)
 863 {
 864         return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
 865                 (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
 866                  __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
 867                  __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
 868                  __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
 869 }
 870
 871 static inline long
 872 put_it32(struct itimerval32 __user *o, struct itimerval *i)
 873 {
 874         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
 875                 (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
 876                  __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
 877                  __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
 878                  __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
 879 }
 880
 881 static inline void
 882 jiffies_to_timeval32(unsigned long jiffies, struct timeval32 *value)
 883 {
 884         value->tv_usec = (jiffies % HZ) * (1000000L / HZ);
 885         value->tv_sec = jiffies / HZ;
 886 }
 887
 888 asmlinkage int
 889 osf_gettimeofday(struct timeval32 __user *tv, struct timezone __user *tz)
 890 {
 891         if (tv) {
 892                 struct timeval ktv;
 893                 do_gettimeofday(&ktv);
 894                 if (put_tv32(tv, &ktv))
 895                         return -EFAULT;
 896         }
 897         if (tz) {
 898                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 899                         return -EFAULT;
 900         }
 901         return 0;
 902 }
 903
 904 asmlinkage int
 905 osf_settimeofday(struct timeval32 __user *tv, struct timezone __user *tz)
 906 {
 907         struct timespec kts;
 908         struct timezone ktz;
 909
 910         if (tv) {
 911                 if (get_tv32((struct timeval *)&kts, tv))
 912                         return -EFAULT;
 913         }
 914         if (tz) {
 915                 if (copy_from_user(&ktz, tz, sizeof(*tz)))
 916                         return -EFAULT;
 917         }
 918
 919         kts.tv_nsec *= 1000;
 920
 921         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
 922 }
 923
 924 asmlinkage int
 925 osf_getitimer(int which, struct itimerval32 __user *it)
 926 {
 927         struct itimerval kit;
 928         int error;
 929
 930         error = do_getitimer(which, &kit);
 931         if (!error && put_it32(it, &kit))
 932                 error = -EFAULT;
 933
 934         return error;
 935 }
 936
 937 asmlinkage int
 938 osf_setitimer(int which, struct itimerval32 __user *in, struct itimerval32 __user *out)
 939 {
 940         struct itimerval kin, kout;
 941         int error;
 942
 943         if (in) {
 944                 if (get_it32(&kin, in))
 945                         return -EFAULT;
 946         } else
 947                 memset(&kin, 0, sizeof(kin));
 948
 949         error = do_setitimer(which, &kin, out ? &kout : NULL);
 950         if (error || !out)
 951                 return error;
 952
 953         if (put_it32(out, &kout))
 954                 return -EFAULT;
 955
 956         return 0;
 957
 958 }
 959
 960 asmlinkage int
 961 osf_utimes(char __user *filename, struct timeval32 __user *tvs)
 962 {
 963         struct timeval ktvs[2];
 964
 965         if (tvs) {
 966                 if (get_tv32(&ktvs[0], &tvs[0]) ||
 967                     get_tv32(&ktvs[1], &tvs[1]))
 968                         return -EFAULT;
 969         }
 970
 971         return do_utimes(AT_FDCWD, filename, tvs ? ktvs : NULL);
 972 }
 973
 974 #define MAX_SELECT_SECONDS \
 975         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
 976
 977 asmlinkage int
 978 osf_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp,
 979            struct timeval32 __user *tvp)
 980 {
 981         fd_set_bits fds;
 982         char *bits;
 983         size_t size;
 984         long timeout;
 985         int ret = -EINVAL;
 986         struct fdtable *fdt;
 987         int max_fdset;
 988
 989         timeout = MAX_SCHEDULE_TIMEOUT;
 990         if (tvp) {
 991                 time_t sec, usec;
 992
 993                 if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp))
 994                     || __get_user(sec, &tvp->tv_sec)
 995                     || __get_user(usec, &tvp->tv_usec)) {
 996                         ret = -EFAULT;
 997                         goto out_nofds;
 998                 }
 999
1000                 if (sec < 0 || usec < 0)
1001                         goto out_nofds;
1002
1003                 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
1004                         timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
1005                         timeout += sec * (unsigned long) HZ;
1006                 }
1007         }
1008
1009         rcu_read_lock();
1010         fdt = files_fdtable(current->files);
1011         max_fdset = fdt->max_fdset;
1012         rcu_read_unlock();
1013         if (n < 0 || n > max_fdset)
1014                 goto out_nofds;
1015
1016         /*
1017          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1018          * since we used fdset we need to allocate memory in units of
1019          * long-words.
1020          */
1021         ret = -ENOMEM;
1022         size = FDS_BYTES(n);
1023         bits = kmalloc(6 * size, GFP_KERNEL);
1024         if (!bits)
1025                 goto out_nofds;
1026         fds.in      = (unsigned long *)  bits;
1027         fds.out     = (unsigned long *) (bits +   size);
1028         fds.ex      = (unsigned long *) (bits + 2*size);
1029         fds.res_in  = (unsigned long *) (bits + 3*size);
1030         fds.res_out = (unsigned long *) (bits + 4*size);
1031         fds.res_ex  = (unsigned long *) (bits + 5*size);
1032
1033         if ((ret = get_fd_set(n, inp->fds_bits, fds.in)) ||
1034             (ret = get_fd_set(n, outp->fds_bits, fds.out)) ||
1035             (ret = get_fd_set(n, exp->fds_bits, fds.ex)))
1036                 goto out;
1037         zero_fd_set(n, fds.res_in);
1038         zero_fd_set(n, fds.res_out);
1039         zero_fd_set(n, fds.res_ex);
1040
1041         ret = do_select(n, &fds, &timeout);
1042
1043         /* OSF does not copy back the remaining time.  */
1044
1045         if (ret < 0)
1046                 goto out;
1047         if (!ret) {
1048                 ret = -ERESTARTNOHAND;
1049                 if (signal_pending(current))
1050                         goto out;
1051                 ret = 0;
1052         }
1053
1054         if (set_fd_set(n, inp->fds_bits, fds.res_in) ||
1055             set_fd_set(n, outp->fds_bits, fds.res_out) ||
1056             set_fd_set(n, exp->fds_bits, fds.res_ex))
1057                 ret = -EFAULT;
1058
1059  out:
1060         kfree(bits);
1061  out_nofds:
1062         return ret;
1063 }
1064
1065 struct rusage32 {
1066         struct timeval32 ru_utime;      /* user time used */
1067         struct timeval32 ru_stime;      /* system time used */
1068         long    ru_maxrss;              /* maximum resident set size */
1069         long    ru_ixrss;               /* integral shared memory size */
1070         long    ru_idrss;               /* integral unshared data size */
1071         long    ru_isrss;               /* integral unshared stack size */
1072         long    ru_minflt;              /* page reclaims */
1073         long    ru_majflt;              /* page faults */
1074         long    ru_nswap;               /* swaps */
1075         long    ru_inblock;             /* block input operations */
1076         long    ru_oublock;             /* block output operations */
1077         long    ru_msgsnd;              /* messages sent */
1078         long    ru_msgrcv;              /* messages received */
1079         long    ru_nsignals;            /* signals received */
1080         long    ru_nvcsw;               /* voluntary context switches */
1081         long    ru_nivcsw;              /* involuntary " */
1082 };
1083
1084 asmlinkage int
1085 osf_getrusage(int who, struct rusage32 __user *ru)
1086 {
1087         struct rusage32 r;
1088
1089         if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN)
1090                 return -EINVAL;
1091
1092         memset(&r, 0, sizeof(r));
1093         switch (who) {
1094         case RUSAGE_SELF:
1095                 jiffies_to_timeval32(current->utime, &r.ru_utime);
1096                 jiffies_to_timeval32(current->stime, &r.ru_stime);
1097                 r.ru_minflt = current->min_flt;
1098                 r.ru_majflt = current->maj_flt;
1099                 break;
1100         case RUSAGE_CHILDREN:
1101                 jiffies_to_timeval32(current->signal->cutime, &r.ru_utime);
1102                 jiffies_to_timeval32(current->signal->cstime, &r.ru_stime);
1103                 r.ru_minflt = current->signal->cmin_flt;
1104                 r.ru_majflt = current->signal->cmaj_flt;
1105                 break;
1106         }
1107
1108         return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1109 }
1110
1111 asmlinkage long
1112 osf_wait4(pid_t pid, int __user *ustatus, int options,
1113           struct rusage32 __user *ur)
1114 {
1115         struct rusage r;
1116         long ret, err;
1117         mm_segment_t old_fs;
1118
1119         if (!ur)
1120                 return sys_wait4(pid, ustatus, options, NULL);
1121
1122         old_fs = get_fs();
1123
1124         set_fs (KERNEL_DS);
1125         ret = sys_wait4(pid, ustatus, options, (struct rusage __user *) &r);
1126         set_fs (old_fs);
1127
1128         if (!access_ok(VERIFY_WRITE, ur, sizeof(*ur)))
1129                 return -EFAULT;
1130
1131         err = 0;
1132         err |= __put_user(r.ru_utime.tv_sec, &ur->ru_utime.tv_sec);
1133         err |= __put_user(r.ru_utime.tv_usec, &ur->ru_utime.tv_usec);
1134         err |= __put_user(r.ru_stime.tv_sec, &ur->ru_stime.tv_sec);
1135         err |= __put_user(r.ru_stime.tv_usec, &ur->ru_stime.tv_usec);
1136         err |= __put_user(r.ru_maxrss, &ur->ru_maxrss);
1137         err |= __put_user(r.ru_ixrss, &ur->ru_ixrss);
1138         err |= __put_user(r.ru_idrss, &ur->ru_idrss);
1139         err |= __put_user(r.ru_isrss, &ur->ru_isrss);
1140         err |= __put_user(r.ru_minflt, &ur->ru_minflt);
1141         err |= __put_user(r.ru_majflt, &ur->ru_majflt);
1142         err |= __put_user(r.ru_nswap, &ur->ru_nswap);
1143         err |= __put_user(r.ru_inblock, &ur->ru_inblock);
1144         err |= __put_user(r.ru_oublock, &ur->ru_oublock);
1145         err |= __put_user(r.ru_msgsnd, &ur->ru_msgsnd);
1146         err |= __put_user(r.ru_msgrcv, &ur->ru_msgrcv);
1147         err |= __put_user(r.ru_nsignals, &ur->ru_nsignals);
1148         err |= __put_user(r.ru_nvcsw, &ur->ru_nvcsw);
1149         err |= __put_user(r.ru_nivcsw, &ur->ru_nivcsw);
1150
1151         return err ? err : ret;
1152 }
1153
1154 /*
1155  * I don't know what the parameters are: the first one
1156  * seems to be a timeval pointer, and I suspect the second
1157  * one is the time remaining.. Ho humm.. No documentation.
1158  */
1159 asmlinkage int
1160 osf_usleep_thread(struct timeval32 __user *sleep, struct timeval32 __user *remain)
1161 {
1162         struct timeval tmp;
1163         unsigned long ticks;
1164
1165         if (get_tv32(&tmp, sleep))
1166                 goto fault;
1167
1168         ticks = timeval_to_jiffies(&tmp);
1169
1170         ticks = schedule_timeout_interruptible(ticks);
1171
1172         if (remain) {
1173                 jiffies_to_timeval(ticks, &tmp);
1174                 if (put_tv32(remain, &tmp))
1175                         goto fault;
1176         }
1177
1178         return 0;
1179  fault:
1180         return -EFAULT;
1181 }
1182
1183
1184 struct timex32 {
1185         unsigned int modes;     /* mode selector */
1186         long offset;            /* time offset (usec) */
1187         long freq;              /* frequency offset (scaled ppm) */
1188         long maxerror;          /* maximum error (usec) */
1189         long esterror;          /* estimated error (usec) */
1190         int status;             /* clock command/status */
1191         long constant;          /* pll time constant */
1192         long precision;         /* clock precision (usec) (read only) */
1193         long tolerance;         /* clock frequency tolerance (ppm)
1194                                  * (read only)
1195                                  */
1196         struct timeval32 time;  /* (read only) */
1197         long tick;              /* (modified) usecs between clock ticks */
1198
1199         long ppsfreq;           /* pps frequency (scaled ppm) (ro) */
1200         long jitter;            /* pps jitter (us) (ro) */
1201         int shift;              /* interval duration (s) (shift) (ro) */
1202         long stabil;            /* pps stability (scaled ppm) (ro) */
1203         long jitcnt;            /* jitter limit exceeded (ro) */
1204         long calcnt;            /* calibration intervals (ro) */
1205         long errcnt;            /* calibration errors (ro) */
1206         long stbcnt;            /* stability limit exceeded (ro) */
1207
1208         int  :32; int  :32; int  :32; int  :32;
1209         int  :32; int  :32; int  :32; int  :32;
1210         int  :32; int  :32; int  :32; int  :32;
1211 };
1212
1213 asmlinkage int
1214 sys_old_adjtimex(struct timex32 __user *txc_p)
1215 {
1216         struct timex txc;
1217         int ret;
1218
1219         /* copy relevant bits of struct timex. */
1220         if (copy_from_user(&txc, txc_p, offsetof(struct timex32, time)) ||
1221             copy_from_user(&txc.tick, &txc_p->tick, sizeof(struct timex32) -
1222                            offsetof(struct timex32, time)))
1223           return -EFAULT;
1224
1225         ret = do_adjtimex(&txc);
1226         if (ret < 0)
1227           return ret;
1228
1229         /* copy back to timex32 */
1230         if (copy_to_user(txc_p, &txc, offsetof(struct timex32, time)) ||
1231             (copy_to_user(&txc_p->tick, &txc.tick, sizeof(struct timex32) -
1232                           offsetof(struct timex32, tick))) ||
1233             (put_tv32(&txc_p->time, &txc.time)))
1234           return -EFAULT;
1235
1236         return ret;
1237 }
1238
1239 /* Get an address range which is currently unmapped.  Similar to the
1240    generic version except that we know how to honor ADDR_LIMIT_32BIT.  */
1241
1242 static unsigned long
1243 arch_get_unmapped_area_1(unsigned long addr, unsigned long len,
1244                          unsigned long limit)
1245 {
1246         struct vm_area_struct *vma = find_vma(current->mm, addr);
1247
1248         while (1) {
1249                 /* At this point:  (!vma || addr < vma->vm_end). */
1250                 if (limit - len < addr)
1251                         return -ENOMEM;
1252                 if (!vma || addr + len <= vma->vm_start)
1253                         return addr;
1254                 addr = vma->vm_end;
1255                 vma = vma->vm_next;
1256         }
1257 }
1258
1259 unsigned long
1260 arch_get_unmapped_area(struct file *filp, unsigned long addr,
1261                        unsigned long len, unsigned long pgoff,
1262                        unsigned long flags)
1263 {
1264         unsigned long limit;
1265
1266         /* "32 bit" actually means 31 bit, since pointers sign extend.  */
1267         if (current->personality & ADDR_LIMIT_32BIT)
1268                 limit = 0x80000000;
1269         else
1270                 limit = TASK_SIZE;
1271
1272         if (len > limit)
1273                 return -ENOMEM;
1274
1275         /* First, see if the given suggestion fits.
1276
1277            The OSF/1 loader (/sbin/loader) relies on us returning an
1278            address larger than the requested if one exists, which is
1279            a terribly broken way to program.
1280
1281            That said, I can see the use in being able to suggest not
1282            merely specific addresses, but regions of memory -- perhaps
1283            this feature should be incorporated into all ports?  */
1284
1285         if (addr) {
1286                 addr = arch_get_unmapped_area_1 (PAGE_ALIGN(addr), len, limit);
1287                 if (addr != (unsigned long) -ENOMEM)
1288                         return addr;
1289         }
1290
1291         /* Next, try allocating at TASK_UNMAPPED_BASE.  */
1292         addr = arch_get_unmapped_area_1 (PAGE_ALIGN(TASK_UNMAPPED_BASE),
1293                                          len, limit);
1294         if (addr != (unsigned long) -ENOMEM)
1295                 return addr;
1296
1297         /* Finally, try allocating in low memory.  */
1298         addr = arch_get_unmapped_area_1 (PAGE_SIZE, len, limit);
1299
1300         return addr;
1301 }
1302
1303 #ifdef CONFIG_OSF4_COMPAT
1304
1305 /* Clear top 32 bits of iov_len in the user's buffer for
1306    compatibility with old versions of OSF/1 where iov_len
1307    was defined as int. */
1308 static int
1309 osf_fix_iov_len(const struct iovec __user *iov, unsigned long count)
1310 {
1311         unsigned long i;
1312
1313         for (i = 0 ; i < count ; i++) {
1314                 int __user *iov_len_high = (int __user *)&iov[i].iov_len + 1;
1315
1316                 if (put_user(0, iov_len_high))
1317                         return -EFAULT;
1318         }
1319         return 0;
1320 }
1321
1322 asmlinkage ssize_t
1323 osf_readv(unsigned long fd, const struct iovec __user * vector, unsigned long count)
1324 {
1325         if (unlikely(personality(current->personality) == PER_OSF4))
1326                 if (osf_fix_iov_len(vector, count))
1327                         return -EFAULT;
1328         return sys_readv(fd, vector, count);
1329 }
1330
1331 asmlinkage ssize_t
1332 osf_writev(unsigned long fd, const struct iovec __user * vector, unsigned long count)
1333 {
1334         if (unlikely(personality(current->personality) == PER_OSF4))
1335                 if (osf_fix_iov_len(vector, count))
1336                         return -EFAULT;
1337         return sys_writev(fd, vector, count);
1338 }
1339
1340 #endif