arch/parisc/kernel/sys_parisc32.c

   1 /*
   2  * sys_parisc32.c: Conversion between 32bit and 64bit native syscalls.
   3  *
   4  * Copyright (C) 2000-2001 Hewlett Packard Company
   5  * Copyright (C) 2000 John Marvin
   6  * Copyright (C) 2001 Matthew Wilcox
   7  *
   8  * These routines maintain argument size conversion between 32bit and 64bit
   9  * environment. Based heavily on sys_ia32.c and sys_sparc32.c.
  10  */
  11
  12 #include <linux/compat.h>
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/fs.h>
  16 #include <linux/mm.h>
  17 #include <linux/file.h>
  18 #include <linux/signal.h>
  19 #include <linux/resource.h>
  20 #include <linux/times.h>
  21 #include <linux/utsname.h>
  22 #include <linux/time.h>
  23 #include <linux/smp.h>
  24 #include <linux/smp_lock.h>
  25 #include <linux/sem.h>
  26 #include <linux/msg.h>
  27 #include <linux/shm.h>
  28 #include <linux/slab.h>
  29 #include <linux/uio.h>
  30 #include <linux/nfs_fs.h>
  31 #include <linux/ncp_fs.h>
  32 #include <linux/sunrpc/svc.h>
  33 #include <linux/nfsd/nfsd.h>
  34 #include <linux/nfsd/cache.h>
  35 #include <linux/nfsd/xdr.h>
  36 #include <linux/nfsd/syscall.h>
  37 #include <linux/poll.h>
  38 #include <linux/personality.h>
  39 #include <linux/stat.h>
  40 #include <linux/highmem.h>
  41 #include <linux/highuid.h>
  42 #include <linux/mman.h>
  43 #include <linux/binfmts.h>
  44 #include <linux/namei.h>
  45 #include <linux/vfs.h>
  46 #include <linux/ptrace.h>
  47 #include <linux/swap.h>
  48 #include <linux/syscalls.h>
  49
  50 #include <asm/types.h>
  51 #include <asm/uaccess.h>
  52 #include <asm/semaphore.h>
  53 #include <asm/mmu_context.h>
  54
  55 #include "sys32.h"
  56
  57 #undef DEBUG
  58
  59 #ifdef DEBUG
  60 #define DBG(x)  printk x
  61 #else
  62 #define DBG(x)
  63 #endif
  64
  65 /*
  66  * sys32_execve() executes a new program.
  67  */
  68
  69 asmlinkage int sys32_execve(struct pt_regs *regs)
  70 {
  71         int error;
  72         char *filename;
  73
  74         DBG(("sys32_execve(%p) r26 = 0x%lx\n", regs, regs->gr[26]));
  75         filename = getname((const char __user *) regs->gr[26]);
  76         error = PTR_ERR(filename);
  77         if (IS_ERR(filename))
  78                 goto out;
  79         error = compat_do_execve(filename, compat_ptr(regs->gr[25]),
  80                                  compat_ptr(regs->gr[24]), regs);
  81         if (error == 0) {
  82                 task_lock(current);
  83                 current->ptrace &= ~PT_DTRACE;
  84                 task_unlock(current);
  85         }
  86         putname(filename);
  87 out:
  88
  89         return error;
  90 }
  91
  92 asmlinkage long sys32_unimplemented(int r26, int r25, int r24, int r23,
  93         int r22, int r21, int r20)
  94 {
  95     printk(KERN_ERR "%s(%d): Unimplemented 32 on 64 syscall #%d!\n",
  96         current->comm, current->pid, r20);
  97     return -ENOSYS;
  98 }
  99
 100 #ifdef CONFIG_SYSCTL
 101
 102 struct __sysctl_args32 {
 103         u32 name;
 104         int nlen;
 105         u32 oldval;
 106         u32 oldlenp;
 107         u32 newval;
 108         u32 newlen;
 109         u32 __unused[4];
 110 };
 111
 112 asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
 113 {
 114         struct __sysctl_args32 tmp;
 115         int error;
 116         unsigned int oldlen32;
 117         size_t oldlen, *oldlenp = NULL;
 118         unsigned long addr = (((long __force)&args->__unused[0]) + 7) & ~7;
 119         extern int do_sysctl(int *name, int nlen, void *oldval, size_t *oldlenp,
 120                void *newval, size_t newlen);
 121
 122         DBG(("sysctl32(%p)\n", args));
 123
 124         if (copy_from_user(&tmp, args, sizeof(tmp)))
 125                 return -EFAULT;
 126
 127         if (tmp.oldval && tmp.oldlenp) {
 128                 /* Duh, this is ugly and might not work if sysctl_args
 129                    is in read-only memory, but do_sysctl does indirectly
 130                    a lot of uaccess in both directions and we'd have to
 131                    basically copy the whole sysctl.c here, and
 132                    glibc's __sysctl uses rw memory for the structure
 133                    anyway.  */
 134                 /* a possibly better hack than this, which will avoid the
 135                  * problem if the struct is read only, is to push the
 136                  * 'oldlen' value out to the user's stack instead. -PB
 137                  */
 138                 if (get_user(oldlen32, (u32 *)(u64)tmp.oldlenp))
 139                         return -EFAULT;
 140                 oldlen = oldlen32;
 141                 if (put_user(oldlen, (size_t *)addr))
 142                         return -EFAULT;
 143                 oldlenp = (size_t *)addr;
 144         }
 145
 146         lock_kernel();
 147         error = do_sysctl((int *)(u64)tmp.name, tmp.nlen, (void *)(u64)tmp.oldval,
 148                           oldlenp, (void *)(u64)tmp.newval, tmp.newlen);
 149         unlock_kernel();
 150         if (oldlenp) {
 151                 if (!error) {
 152                         if (get_user(oldlen, (size_t *)addr)) {
 153                                 error = -EFAULT;
 154                         } else {
 155                                 oldlen32 = oldlen;
 156                                 if (put_user(oldlen32, (u32 *)(u64)tmp.oldlenp))
 157                                         error = -EFAULT;
 158                         }
 159                 }
 160                 if (copy_to_user(&args->__unused[0], tmp.__unused, sizeof(tmp.__unused)))
 161                         error = -EFAULT;
 162         }
 163         return error;
 164 }
 165
 166 #endif /* CONFIG_SYSCTL */
 167
 168 asmlinkage long sys32_sched_rr_get_interval(pid_t pid,
 169         struct compat_timespec __user *interval)
 170 {
 171         struct timespec t;
 172         int ret;
 173
 174         KERNEL_SYSCALL(ret, sys_sched_rr_get_interval, pid, (struct timespec __user *)&t);
 175         if (put_compat_timespec(&t, interval))
 176                 return -EFAULT;
 177         return ret;
 178 }
 179
 180 static int
 181 put_compat_timeval(struct compat_timeval __user *u, struct timeval *t)
 182 {
 183         struct compat_timeval t32;
 184         t32.tv_sec = t->tv_sec;
 185         t32.tv_usec = t->tv_usec;
 186         return copy_to_user(u, &t32, sizeof t32);
 187 }
 188
 189 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
 190 {
 191         long usec;
 192
 193         if (__get_user(o->tv_sec, &i->tv_sec))
 194                 return -EFAULT;
 195         if (__get_user(usec, &i->tv_usec))
 196                 return -EFAULT;
 197         o->tv_nsec = usec * 1000;
 198         return 0;
 199 }
 200
 201 asmlinkage int
 202 sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
 203 {
 204     extern void do_gettimeofday(struct timeval *tv);
 205
 206     if (tv) {
 207             struct timeval ktv;
 208             do_gettimeofday(&ktv);
 209             if (put_compat_timeval(tv, &ktv))
 210                     return -EFAULT;
 211     }
 212     if (tz) {
 213             extern struct timezone sys_tz;
 214             if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
 215                     return -EFAULT;
 216     }
 217     return 0;
 218 }
 219
 220 asmlinkage
 221 int sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
 222 {
 223         struct timespec kts;
 224         struct timezone ktz;
 225
 226         if (tv) {
 227                 if (get_ts32(&kts, tv))
 228                         return -EFAULT;
 229         }
 230         if (tz) {
 231                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
 232                         return -EFAULT;
 233         }
 234
 235         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
 236 }
 237
 238 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 239 {
 240         int err;
 241
 242         if (stat->size > MAX_NON_LFS || !new_valid_dev(stat->dev) ||
 243             !new_valid_dev(stat->rdev))
 244                 return -EOVERFLOW;
 245
 246         err  = put_user(new_encode_dev(stat->dev), &statbuf->st_dev);
 247         err |= put_user(stat->ino, &statbuf->st_ino);
 248         err |= put_user(stat->mode, &statbuf->st_mode);
 249         err |= put_user(stat->nlink, &statbuf->st_nlink);
 250         err |= put_user(0, &statbuf->st_reserved1);
 251         err |= put_user(0, &statbuf->st_reserved2);
 252         err |= put_user(new_encode_dev(stat->rdev), &statbuf->st_rdev);
 253         err |= put_user(stat->size, &statbuf->st_size);
 254         err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
 255         err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
 256         err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
 257         err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
 258         err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
 259         err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
 260         err |= put_user(stat->blksize, &statbuf->st_blksize);
 261         err |= put_user(stat->blocks, &statbuf->st_blocks);
 262         err |= put_user(0, &statbuf->__unused1);
 263         err |= put_user(0, &statbuf->__unused2);
 264         err |= put_user(0, &statbuf->__unused3);
 265         err |= put_user(0, &statbuf->__unused4);
 266         err |= put_user(0, &statbuf->__unused5);
 267         err |= put_user(0, &statbuf->st_fstype); /* not avail */
 268         err |= put_user(0, &statbuf->st_realdev); /* not avail */
 269         err |= put_user(0, &statbuf->st_basemode); /* not avail */
 270         err |= put_user(0, &statbuf->st_spareshort);
 271         err |= put_user(stat->uid, &statbuf->st_uid);
 272         err |= put_user(stat->gid, &statbuf->st_gid);
 273         err |= put_user(0, &statbuf->st_spare4[0]);
 274         err |= put_user(0, &statbuf->st_spare4[1]);
 275         err |= put_user(0, &statbuf->st_spare4[2]);
 276
 277         return err;
 278 }
 279
 280 struct linux32_dirent {
 281         u32             d_ino;
 282         compat_off_t    d_off;
 283         u16             d_reclen;
 284         char            d_name[1];
 285 };
 286
 287 struct old_linux32_dirent {
 288         u32     d_ino;
 289         u32     d_offset;
 290         u16     d_namlen;
 291         char    d_name[1];
 292 };
 293
 294 struct getdents32_callback {
 295         struct linux32_dirent __user * current_dir;
 296         struct linux32_dirent __user * previous;
 297         int count;
 298         int error;
 299 };
 300
 301 struct readdir32_callback {
 302         struct old_linux32_dirent __user * dirent;
 303         int count;
 304 };
 305
 306 #define ROUND_UP(x,a)   ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
 307 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
 308 static int
 309 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
 310            unsigned int d_type)
 311 {
 312         struct linux32_dirent __user * dirent;
 313         struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
 314         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
 315
 316         buf->error = -EINVAL;   /* only used if we fail.. */
 317         if (reclen > buf->count)
 318                 return -EINVAL;
 319         dirent = buf->previous;
 320         if (dirent)
 321                 put_user(offset, &dirent->d_off);
 322         dirent = buf->current_dir;
 323         buf->previous = dirent;
 324         put_user(ino, &dirent->d_ino);
 325         put_user(reclen, &dirent->d_reclen);
 326         copy_to_user(dirent->d_name, name, namlen);
 327         put_user(0, dirent->d_name + namlen);
 328         dirent = ((void __user *)dirent) + reclen;
 329         buf->current_dir = dirent;
 330         buf->count -= reclen;
 331         return 0;
 332 }
 333
 334 asmlinkage long
 335 sys32_getdents (unsigned int fd, void __user * dirent, unsigned int count)
 336 {
 337         struct file * file;
 338         struct linux32_dirent __user * lastdirent;
 339         struct getdents32_callback buf;
 340         int error;
 341
 342         error = -EBADF;
 343         file = fget(fd);
 344         if (!file)
 345                 goto out;
 346
 347         buf.current_dir = (struct linux32_dirent __user *) dirent;
 348         buf.previous = NULL;
 349         buf.count = count;
 350         buf.error = 0;
 351
 352         error = vfs_readdir(file, filldir32, &buf);
 353         if (error < 0)
 354                 goto out_putf;
 355         error = buf.error;
 356         lastdirent = buf.previous;
 357         if (lastdirent) {
 358                 put_user(file->f_pos, &lastdirent->d_off);
 359                 error = count - buf.count;
 360         }
 361
 362 out_putf:
 363         fput(file);
 364 out:
 365         return error;
 366 }
 367
 368 static int
 369 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
 370               unsigned int d_type)
 371 {
 372         struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
 373         struct old_linux32_dirent __user * dirent;
 374
 375         if (buf->count)
 376                 return -EINVAL;
 377         buf->count++;
 378         dirent = buf->dirent;
 379         put_user(ino, &dirent->d_ino);
 380         put_user(offset, &dirent->d_offset);
 381         put_user(namlen, &dirent->d_namlen);
 382         copy_to_user(dirent->d_name, name, namlen);
 383         put_user(0, dirent->d_name + namlen);
 384         return 0;
 385 }
 386
 387 asmlinkage long
 388 sys32_readdir (unsigned int fd, void __user * dirent, unsigned int count)
 389 {
 390         int error;
 391         struct file * file;
 392         struct readdir32_callback buf;
 393
 394         error = -EBADF;
 395         file = fget(fd);
 396         if (!file)
 397                 goto out;
 398
 399         buf.count = 0;
 400         buf.dirent = dirent;
 401
 402         error = vfs_readdir(file, fillonedir32, &buf);
 403         if (error >= 0)
 404                 error = buf.count;
 405         fput(file);
 406 out:
 407         return error;
 408 }
 409
 410 /*** copied from mips64 ***/
 411 /*
 412  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
 413  * 64-bit unsigned longs.
 414  */
 415
 416 static inline int
 417 get_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
 418 {
 419         n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
 420         if (ufdset) {
 421                 unsigned long odd;
 422
 423                 if (!access_ok(VERIFY_WRITE, ufdset, n*sizeof(u32)))
 424                         return -EFAULT;
 425
 426                 odd = n & 1UL;
 427                 n &= ~1UL;
 428                 while (n) {
 429                         unsigned long h, l;
 430                         __get_user(l, ufdset);
 431                         __get_user(h, ufdset+1);
 432                         ufdset += 2;
 433                         *fdset++ = h << 32 | l;
 434                         n -= 2;
 435                 }
 436                 if (odd)
 437                         __get_user(*fdset, ufdset);
 438         } else {
 439                 /* Tricky, must clear full unsigned long in the
 440                  * kernel fdset at the end, this makes sure that
 441                  * actually happens.
 442                  */
 443                 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
 444         }
 445         return 0;
 446 }
 447
 448 static inline void
 449 set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
 450 {
 451         unsigned long odd;
 452         n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
 453
 454         if (!ufdset)
 455                 return;
 456
 457         odd = n & 1UL;
 458         n &= ~1UL;
 459         while (n) {
 460                 unsigned long h, l;
 461                 l = *fdset++;
 462                 h = l >> 32;
 463                 __put_user(l, ufdset);
 464                 __put_user(h, ufdset+1);
 465                 ufdset += 2;
 466                 n -= 2;
 467         }
 468         if (odd)
 469                 __put_user(*fdset, ufdset);
 470 }
 471
 472 struct msgbuf32 {
 473     int mtype;
 474     char mtext[1];
 475 };
 476
 477 asmlinkage long sys32_msgsnd(int msqid,
 478                                 struct msgbuf32 __user *umsgp32,
 479                                 size_t msgsz, int msgflg)
 480 {
 481         struct msgbuf *mb;
 482         struct msgbuf32 mb32;
 483         int err;
 484
 485         if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL)
 486                 return -ENOMEM;
 487
 488         err = get_user(mb32.mtype, &umsgp32->mtype);
 489         mb->mtype = mb32.mtype;
 490         err |= copy_from_user(mb->mtext, &umsgp32->mtext, msgsz);
 491
 492         if (err)
 493                 err = -EFAULT;
 494         else
 495                 KERNEL_SYSCALL(err, sys_msgsnd, msqid, (struct msgbuf __user *)mb, msgsz, msgflg);
 496
 497         kfree(mb);
 498         return err;
 499 }
 500
 501 asmlinkage long sys32_msgrcv(int msqid,
 502                                 struct msgbuf32 __user *umsgp32,
 503                                 size_t msgsz, long msgtyp, int msgflg)
 504 {
 505         struct msgbuf *mb;
 506         struct msgbuf32 mb32;
 507         int err, len;
 508
 509         if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL)
 510                 return -ENOMEM;
 511
 512         KERNEL_SYSCALL(err, sys_msgrcv, msqid, (struct msgbuf __user *)mb, msgsz, msgtyp, msgflg);
 513
 514         if (err >= 0) {
 515                 len = err;
 516                 mb32.mtype = mb->mtype;
 517                 err = put_user(mb32.mtype, &umsgp32->mtype);
 518                 err |= copy_to_user(&umsgp32->mtext, mb->mtext, len);
 519                 if (err)
 520                         err = -EFAULT;
 521                 else
 522                         err = len;
 523         }
 524
 525         kfree(mb);
 526         return err;
 527 }
 528
 529 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, s32 count)
 530 {
 531         mm_segment_t old_fs = get_fs();
 532         int ret;
 533         off_t of;
 534
 535         if (offset && get_user(of, offset))
 536                 return -EFAULT;
 537
 538         set_fs(KERNEL_DS);
 539         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count);
 540         set_fs(old_fs);
 541
 542         if (offset && put_user(of, offset))
 543                 return -EFAULT;
 544
 545         return ret;
 546 }
 547
 548 asmlinkage int sys32_sendfile64(int out_fd, int in_fd, compat_loff_t __user *offset, s32 count)
 549 {
 550         mm_segment_t old_fs = get_fs();
 551         int ret;
 552         loff_t lof;
 553
 554         if (offset && get_user(lof, offset))
 555                 return -EFAULT;
 556
 557         set_fs(KERNEL_DS);
 558         ret = sys_sendfile64(out_fd, in_fd, offset ? (loff_t __user *)&lof : NULL, count);
 559         set_fs(old_fs);
 560
 561         if (offset && put_user(lof, offset))
 562                 return -EFAULT;
 563
 564         return ret;
 565 }
 566
 567
 568 struct sysinfo32 {
 569         s32 uptime;
 570         u32 loads[3];
 571         u32 totalram;
 572         u32 freeram;
 573         u32 sharedram;
 574         u32 bufferram;
 575         u32 totalswap;
 576         u32 freeswap;
 577         unsigned short procs;
 578         u32 totalhigh;
 579         u32 freehigh;
 580         u32 mem_unit;
 581         char _f[12];
 582 };
 583
 584 /* We used to call sys_sysinfo and translate the result.  But sys_sysinfo
 585  * undoes the good work done elsewhere, and rather than undoing the
 586  * damage, I decided to just duplicate the code from sys_sysinfo here.
 587  */
 588
 589 asmlinkage int sys32_sysinfo(struct sysinfo32 __user *info)
 590 {
 591         struct sysinfo val;
 592         int err;
 593         unsigned long seq;
 594
 595         /* We don't need a memset here because we copy the
 596          * struct to userspace once element at a time.
 597          */
 598
 599         do {
 600                 seq = read_seqbegin(&xtime_lock);
 601                 val.uptime = jiffies / HZ;
 602
 603                 val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
 604                 val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
 605                 val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
 606
 607                 val.procs = nr_threads;
 608         } while (read_seqretry(&xtime_lock, seq));
 609
 610
 611         si_meminfo(&val);
 612         si_swapinfo(&val);
 613
 614         err = put_user (val.uptime, &info->uptime);
 615         err |= __put_user (val.loads[0], &info->loads[0]);
 616         err |= __put_user (val.loads[1], &info->loads[1]);
 617         err |= __put_user (val.loads[2], &info->loads[2]);
 618         err |= __put_user (val.totalram, &info->totalram);
 619         err |= __put_user (val.freeram, &info->freeram);
 620         err |= __put_user (val.sharedram, &info->sharedram);
 621         err |= __put_user (val.bufferram, &info->bufferram);
 622         err |= __put_user (val.totalswap, &info->totalswap);
 623         err |= __put_user (val.freeswap, &info->freeswap);
 624         err |= __put_user (val.procs, &info->procs);
 625         err |= __put_user (val.totalhigh, &info->totalhigh);
 626         err |= __put_user (val.freehigh, &info->freehigh);
 627         err |= __put_user (val.mem_unit, &info->mem_unit);
 628         return err ? -EFAULT : 0;
 629 }
 630
 631
 632 /* lseek() needs a wrapper because 'offset' can be negative, but the top
 633  * half of the argument has been zeroed by syscall.S.
 634  */
 635
 636 asmlinkage int sys32_lseek(unsigned int fd, int offset, unsigned int origin)
 637 {
 638         return sys_lseek(fd, offset, origin);
 639 }
 640
 641 asmlinkage long sys32_semctl(int semid, int semnum, int cmd, union semun arg)
 642 {
 643         union semun u;
 644
 645         if (cmd == SETVAL) {
 646                 /* Ugh.  arg is a union of int,ptr,ptr,ptr, so is 8 bytes.
 647                  * The int should be in the first 4, but our argument
 648                  * frobbing has left it in the last 4.
 649                  */
 650                 u.val = *((int *)&arg + 1);
 651                 return sys_semctl (semid, semnum, cmd, u);
 652         }
 653         return sys_semctl (semid, semnum, cmd, arg);
 654 }
 655
 656 long sys32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char __user *buf,
 657                           size_t len)
 658 {
 659         return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
 660                                   buf, len);
 661 }