git.oblomov.eu Git - linux-2.6/blob - arch/parisc/hpux/sys_hpux.c

   1 /*
   2  *    Implements HPUX syscalls.
   3  *
   4  *    Copyright (C) 1999 Matthew Wilcox <willy with parisc-linux.org>
   5  *    Copyright (C) 2000 Philipp Rumpf
   6  *    Copyright (C) 2000 John Marvin <jsm with parisc-linux.org>
   7  *    Copyright (C) 2000 Michael Ang <mang with subcarrier.org>
   8  *    Copyright (C) 2001 Nathan Neulinger <nneul at umr.edu>
   9  *
  10  *    This program is free software; you can redistribute it and/or modify
  11  *    it under the terms of the GNU General Public License as published by
  12  *    the Free Software Foundation; either version 2 of the License, or
  13  *    (at your option) any later version.
  14  *
  15  *    This program is distributed in the hope that it will be useful,
  16  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *    GNU General Public License for more details.
  19  *
  20  *    You should have received a copy of the GNU General Public License
  21  *    along with this program; if not, write to the Free Software
  22  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <linux/capability.h>
  26 #include <linux/file.h>
  27 #include <linux/fs.h>
  28 #include <linux/namei.h>
  29 #include <linux/sched.h>
  30 #include <linux/slab.h>
  31 #include <linux/smp_lock.h>
  32 #include <linux/syscalls.h>
  33 #include <linux/utsname.h>
  34 #include <linux/vfs.h>
  35 #include <linux/vmalloc.h>
  36
  37 #include <asm/errno.h>
  38 #include <asm/pgalloc.h>
  39 #include <asm/uaccess.h>
  40
  41 unsigned long hpux_brk(unsigned long addr)
  42 {
  43         /* Sigh.  Looks like HP/UX libc relies on kernel bugs. */
  44         return sys_brk(addr + PAGE_SIZE);
  45 }
  46
  47 int hpux_sbrk(void)
  48 {
  49         return -ENOSYS;
  50 }
  51
  52 /* Random other syscalls */
  53
  54 int hpux_nice(int priority_change)
  55 {
  56         return -ENOSYS;
  57 }
  58
  59 int hpux_ptrace(void)
  60 {
  61         return -ENOSYS;
  62 }
  63
  64 int hpux_wait(int __user *stat_loc)
  65 {
  66         return sys_waitpid(-1, stat_loc, 0);
  67 }
  68
  69 int hpux_setpgrp(void)
  70 {
  71         return sys_setpgid(0,0);
  72 }
  73
  74 int hpux_setpgrp3(void)
  75 {
  76         return hpux_setpgrp();
  77 }
  78
  79 #define _SC_CPU_VERSION 10001
  80 #define _SC_OPEN_MAX    4
  81 #define CPU_PA_RISC1_1  0x210
  82
  83 int hpux_sysconf(int which)
  84 {
  85         switch (which) {
  86         case _SC_CPU_VERSION:
  87                 return CPU_PA_RISC1_1;
  88         case _SC_OPEN_MAX:
  89                 return INT_MAX;
  90         default:
  91                 return -EINVAL;
  92         }
  93 }
  94
  95 /*****************************************************************************/
  96
  97 #define HPUX_UTSLEN 9
  98 #define HPUX_SNLEN 15
  99
 100 struct hpux_utsname {
 101         char sysname[HPUX_UTSLEN];
 102         char nodename[HPUX_UTSLEN];
 103         char release[HPUX_UTSLEN];
 104         char version[HPUX_UTSLEN];
 105         char machine[HPUX_UTSLEN];
 106         char idnumber[HPUX_SNLEN];
 107 } ;
 108
 109 struct hpux_ustat {
 110         int32_t         f_tfree;        /* total free (daddr_t)  */
 111         u_int32_t       f_tinode;       /* total inodes free (ino_t)  */
 112         char            f_fname[6];     /* filsys name */
 113         char            f_fpack[6];     /* filsys pack name */
 114         u_int32_t       f_blksize;      /* filsys block size (int) */
 115 };
 116
 117 /*
 118  * HPUX's utssys() call.  It's a collection of miscellaneous functions,
 119  * alas, so there's no nice way of splitting them up.
 120  */
 121
 122 /*  This function is called from hpux_utssys(); HP-UX implements
 123  *  ustat() as an option to utssys().
 124  *
 125  *  Now, struct ustat on HP-UX is exactly the same as on Linux, except
 126  *  that it contains one addition field on the end, int32_t f_blksize.
 127  *  So, we could have written this function to just call the Linux
 128  *  sys_ustat(), (defined in linux/fs/super.c), and then just
 129  *  added this additional field to the user's structure.  But I figure
 130  *  if we're gonna be digging through filesystem structures to get
 131  *  this, we might as well just do the whole enchilada all in one go.
 132  *
 133  *  So, most of this function is almost identical to sys_ustat().
 134  *  I have placed comments at the few lines changed or added, to
 135  *  aid in porting forward if and when sys_ustat() is changed from
 136  *  its form in kernel 2.2.5.
 137  */
 138 static int hpux_ustat(dev_t dev, struct hpux_ustat __user *ubuf)
 139 {
 140         struct super_block *s;
 141         struct hpux_ustat tmp;  /* Changed to hpux_ustat */
 142         struct kstatfs sbuf;
 143         int err = -EINVAL;
 144
 145         s = user_get_super(dev);
 146         if (s == NULL)
 147                 goto out;
 148         err = vfs_statfs(s->s_root, &sbuf);
 149         drop_super(s);
 150         if (err)
 151                 goto out;
 152
 153         memset(&tmp,0,sizeof(tmp));
 154
 155         tmp.f_tfree = (int32_t)sbuf.f_bfree;
 156         tmp.f_tinode = (u_int32_t)sbuf.f_ffree;
 157         tmp.f_blksize = (u_int32_t)sbuf.f_bsize;  /*  Added this line  */
 158
 159         err = copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
 160 out:
 161         return err;
 162 }
 163
 164 /*
 165  * Wrapper for hpux statfs call. At the moment, just calls the linux native one
 166  * and ignores the extra fields at the end of the hpux statfs struct.
 167  *
 168  */
 169
 170 typedef int32_t hpux_fsid_t[2];              /* file system ID type */
 171 typedef uint16_t hpux_site_t;
 172
 173 struct hpux_statfs {
 174      int32_t f_type;                    /* type of info, zero for now */
 175      int32_t f_bsize;                   /* fundamental file system block size */
 176      int32_t f_blocks;                  /* total blocks in file system */
 177      int32_t f_bfree;                   /* free block in fs */
 178      int32_t f_bavail;                  /* free blocks avail to non-superuser */
 179      int32_t f_files;                   /* total file nodes in file system */
 180      int32_t f_ffree;                   /* free file nodes in fs */
 181      hpux_fsid_t  f_fsid;                    /* file system ID */
 182      int32_t f_magic;                   /* file system magic number */
 183      int32_t f_featurebits;             /* file system features */
 184      int32_t f_spare[4];                /* spare for later */
 185      hpux_site_t  f_cnode;                   /* cluster node where mounted */
 186      int16_t f_pad;
 187 };
 188
 189 static int vfs_statfs_hpux(struct dentry *dentry, struct hpux_statfs *buf)
 190 {
 191         struct kstatfs st;
 192         int retval;
 193
 194         retval = vfs_statfs(dentry, &st);
 195         if (retval)
 196                 return retval;
 197
 198         memset(buf, 0, sizeof(*buf));
 199         buf->f_type = st.f_type;
 200         buf->f_bsize = st.f_bsize;
 201         buf->f_blocks = st.f_blocks;
 202         buf->f_bfree = st.f_bfree;
 203         buf->f_bavail = st.f_bavail;
 204         buf->f_files = st.f_files;
 205         buf->f_ffree = st.f_ffree;
 206         buf->f_fsid[0] = st.f_fsid.val[0];
 207         buf->f_fsid[1] = st.f_fsid.val[1];
 208
 209         return 0;
 210 }
 211
 212 /* hpux statfs */
 213 asmlinkage long hpux_statfs(const char __user *pathname,
 214                                                 struct hpux_statfs __user *buf)
 215 {
 216         struct path path;
 217         int error;
 218
 219         error = user_path(pathname, &path);
 220         if (!error) {
 221                 struct hpux_statfs tmp;
 222                 error = vfs_statfs_hpux(path.dentry, &tmp);
 223                 if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
 224                         error = -EFAULT;
 225                 path_put(&path);
 226         }
 227         return error;
 228 }
 229
 230 asmlinkage long hpux_fstatfs(unsigned int fd, struct hpux_statfs __user * buf)
 231 {
 232         struct file *file;
 233         struct hpux_statfs tmp;
 234         int error;
 235
 236         error = -EBADF;
 237         file = fget(fd);
 238         if (!file)
 239                 goto out;
 240         error = vfs_statfs_hpux(file->f_path.dentry, &tmp);
 241         if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
 242                 error = -EFAULT;
 243         fput(file);
 244  out:
 245         return error;
 246 }
 247
 248
 249 /*  This function is called from hpux_utssys(); HP-UX implements
 250  *  uname() as an option to utssys().
 251  *
 252  *  The form of this function is pretty much copied from sys_olduname(),
 253  *  defined in linux/arch/i386/kernel/sys_i386.c.
 254  */
 255 /*  TODO: Are these put_user calls OK?  Should they pass an int?
 256  *        (I copied it from sys_i386.c like this.)
 257  */
 258 static int hpux_uname(struct hpux_utsname __user *name)
 259 {
 260         int error;
 261
 262         if (!name)
 263                 return -EFAULT;
 264         if (!access_ok(VERIFY_WRITE,name,sizeof(struct hpux_utsname)))
 265                 return -EFAULT;
 266
 267         down_read(&uts_sem);
 268
 269         error = __copy_to_user(&name->sysname, &utsname()->sysname,
 270                                HPUX_UTSLEN - 1);
 271         error |= __put_user(0, name->sysname + HPUX_UTSLEN - 1);
 272         error |= __copy_to_user(&name->nodename, &utsname()->nodename,
 273                                 HPUX_UTSLEN - 1);
 274         error |= __put_user(0, name->nodename + HPUX_UTSLEN - 1);
 275         error |= __copy_to_user(&name->release, &utsname()->release,
 276                                 HPUX_UTSLEN - 1);
 277         error |= __put_user(0, name->release + HPUX_UTSLEN - 1);
 278         error |= __copy_to_user(&name->version, &utsname()->version,
 279                                 HPUX_UTSLEN - 1);
 280         error |= __put_user(0, name->version + HPUX_UTSLEN - 1);
 281         error |= __copy_to_user(&name->machine, &utsname()->machine,
 282                                 HPUX_UTSLEN - 1);
 283         error |= __put_user(0, name->machine + HPUX_UTSLEN - 1);
 284
 285         up_read(&uts_sem);
 286
 287         /*  HP-UX  utsname has no domainname field.  */
 288
 289         /*  TODO:  Implement idnumber!!!  */
 290 #if 0
 291         error |= __put_user(0,name->idnumber);
 292         error |= __put_user(0,name->idnumber+HPUX_SNLEN-1);
 293 #endif
 294
 295         error = error ? -EFAULT : 0;
 296
 297         return error;
 298 }
 299
 300 /*  Note: HP-UX just uses the old suser() function to check perms
 301  *  in this system call.  We'll use capable(CAP_SYS_ADMIN).
 302  */
 303 int hpux_utssys(char __user *ubuf, int n, int type)
 304 {
 305         int len;
 306         int error;
 307         switch( type ) {
 308         case 0:
 309                 /*  uname():  */
 310                 return hpux_uname((struct hpux_utsname __user *)ubuf);
 311                 break ;
 312         case 1:
 313                 /*  Obsolete (used to be umask().)  */
 314                 return -EFAULT ;
 315                 break ;
 316         case 2:
 317                 /*  ustat():  */
 318                 return hpux_ustat(new_decode_dev(n),
 319                                   (struct hpux_ustat __user *)ubuf);
 320                 break;
 321         case 3:
 322                 /*  setuname():
 323                  *
 324                  *  On linux (unlike HP-UX), utsname.nodename
 325                  *  is the same as the hostname.
 326                  *
 327                  *  sys_sethostname() is defined in linux/kernel/sys.c.
 328                  */
 329                 if (!capable(CAP_SYS_ADMIN))
 330                         return -EPERM;
 331                 /*  Unlike Linux, HP-UX returns an error if n==0:  */
 332                 if ( n <= 0 )
 333                         return -EINVAL ;
 334                 /*  Unlike Linux, HP-UX truncates it if n is too big:  */
 335                 len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
 336                 return sys_sethostname(ubuf, len);
 337                 break ;
 338         case 4:
 339                 /*  sethostname():
 340                  *
 341                  *  sys_sethostname() is defined in linux/kernel/sys.c.
 342                  */
 343                 if (!capable(CAP_SYS_ADMIN))
 344                         return -EPERM;
 345                 /*  Unlike Linux, HP-UX returns an error if n==0:  */
 346                 if ( n <= 0 )
 347                         return -EINVAL ;
 348                 /*  Unlike Linux, HP-UX truncates it if n is too big:  */
 349                 len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
 350                 return sys_sethostname(ubuf, len);
 351                 break ;
 352         case 5:
 353                 /*  gethostname():
 354                  *
 355                  *  sys_gethostname() is defined in linux/kernel/sys.c.
 356                  */
 357                 /*  Unlike Linux, HP-UX returns an error if n==0:  */
 358                 if ( n <= 0 )
 359                         return -EINVAL ;
 360                 return sys_gethostname(ubuf, n);
 361                 break ;
 362         case 6:
 363                 /*  Supposedly called from setuname() in libc.
 364                  *  TODO: When and why is this called?
 365                  *        Is it ever even called?
 366                  *
 367                  *  This code should look a lot like sys_sethostname(),
 368                  *  defined in linux/kernel/sys.c.  If that gets updated,
 369                  *  update this code similarly.
 370                  */
 371                 if (!capable(CAP_SYS_ADMIN))
 372                         return -EPERM;
 373                 /*  Unlike Linux, HP-UX returns an error if n==0:  */
 374                 if ( n <= 0 )
 375                         return -EINVAL ;
 376                 /*  Unlike Linux, HP-UX truncates it if n is too big:  */
 377                 len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
 378                 /**/
 379                 /*  TODO:  print a warning about using this?  */
 380                 down_write(&uts_sem);
 381                 error = -EFAULT;
 382                 if (!copy_from_user(utsname()->sysname, ubuf, len)) {
 383                         utsname()->sysname[len] = 0;
 384                         error = 0;
 385                 }
 386                 up_write(&uts_sem);
 387                 return error;
 388                 break ;
 389         case 7:
 390                 /*  Sets utsname.release, if you're allowed.
 391                  *  Undocumented.  Used by swinstall to change the
 392                  *  OS version, during OS updates.  Yuck!!!
 393                  *
 394                  *  This code should look a lot like sys_sethostname()
 395                  *  in linux/kernel/sys.c.  If that gets updated, update
 396                  *  this code similarly.
 397                  */
 398                 if (!capable(CAP_SYS_ADMIN))
 399                         return -EPERM;
 400                 /*  Unlike Linux, HP-UX returns an error if n==0:  */
 401                 if ( n <= 0 )
 402                         return -EINVAL ;
 403                 /*  Unlike Linux, HP-UX truncates it if n is too big:  */
 404                 len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
 405                 /**/
 406                 /*  TODO:  print a warning about this?  */
 407                 down_write(&uts_sem);
 408                 error = -EFAULT;
 409                 if (!copy_from_user(utsname()->release, ubuf, len)) {
 410                         utsname()->release[len] = 0;
 411                         error = 0;
 412                 }
 413                 up_write(&uts_sem);
 414                 return error;
 415                 break ;
 416         default:
 417                 /*  This system call returns -EFAULT if given an unknown type.
 418                  *  Why not -EINVAL?  I don't know, it's just not what they did.
 419                  */
 420                 return -EFAULT ;
 421         }
 422 }
 423
 424 int hpux_getdomainname(char __user *name, int len)
 425 {
 426         int nlen;
 427         int err = -EFAULT;
 428
 429         down_read(&uts_sem);
 430
 431         nlen = strlen(utsname()->domainname) + 1;
 432
 433         if (nlen < len)
 434                 len = nlen;
 435         if(len > __NEW_UTS_LEN)
 436                 goto done;
 437         if(copy_to_user(name, utsname()->domainname, len))
 438                 goto done;
 439         err = 0;
 440 done:
 441         up_read(&uts_sem);
 442         return err;
 443
 444 }
 445
 446 int hpux_pipe(int *kstack_fildes)
 447 {
 448         int error;
 449
 450         lock_kernel();
 451         error = do_pipe_flags(kstack_fildes, 0);
 452         unlock_kernel();
 453         return error;
 454 }
 455
 456 /* lies - says it works, but it really didn't lock anything */
 457 int hpux_lockf(int fildes, int function, off_t size)
 458 {
 459         return 0;
 460 }
 461
 462 int hpux_sysfs(int opcode, unsigned long arg1, unsigned long arg2)
 463 {
 464         char *fsname = NULL;
 465         int len = 0;
 466         int fstype;
 467
 468 /*Unimplemented HP-UX syscall emulation. Syscall #334 (sysfs)
 469   Args: 1 80057bf4 0 400179f0 0 0 0 */
 470         printk(KERN_DEBUG "in hpux_sysfs\n");
 471         printk(KERN_DEBUG "hpux_sysfs called with opcode = %d\n", opcode);
 472         printk(KERN_DEBUG "hpux_sysfs called with arg1='%lx'\n", arg1);
 473
 474         if ( opcode == 1 ) { /* GETFSIND */
 475                 char __user *user_fsname = (char __user *)arg1;
 476                 len = strlen_user(user_fsname);
 477                 printk(KERN_DEBUG "len of arg1 = %d\n", len);
 478                 if (len == 0)
 479                         return 0;
 480                 fsname = kmalloc(len, GFP_KERNEL);
 481                 if (!fsname) {
 482                         printk(KERN_DEBUG "failed to kmalloc fsname\n");
 483                         return 0;
 484                 }
 485
 486                 if (copy_from_user(fsname, user_fsname, len)) {
 487                         printk(KERN_DEBUG "failed to copy_from_user fsname\n");
 488                         kfree(fsname);
 489                         return 0;
 490                 }
 491
 492                 /* String could be altered by userspace after strlen_user() */
 493                 fsname[len] = '\0';
 494
 495                 printk(KERN_DEBUG "that is '%s' as (char *)\n", fsname);
 496                 if ( !strcmp(fsname, "hfs") ) {
 497                         fstype = 0;
 498                 } else {
 499                         fstype = 0;
 500                 }
 501
 502                 kfree(fsname);
 503
 504                 printk(KERN_DEBUG "returning fstype=%d\n", fstype);
 505                 return fstype; /* something other than default */
 506         }
 507
 508
 509         return 0;
 510 }
 511
 512
 513 /* Table of syscall names and handle for unimplemented routines */
 514 static const char * const syscall_names[] = {
 515         "nosys",                  /* 0 */
 516         "exit",
 517         "fork",
 518         "read",
 519         "write",
 520         "open",                   /* 5 */
 521         "close",
 522         "wait",
 523         "creat",
 524         "link",
 525         "unlink",                 /* 10 */
 526         "execv",
 527         "chdir",
 528         "time",
 529         "mknod",
 530         "chmod",                  /* 15 */
 531         "chown",
 532         "brk",
 533         "lchmod",
 534         "lseek",
 535         "getpid",                 /* 20 */
 536         "mount",
 537         "umount",
 538         "setuid",
 539         "getuid",
 540         "stime",                  /* 25 */
 541         "ptrace",
 542         "alarm",
 543         NULL,
 544         "pause",
 545         "utime",                  /* 30 */
 546         "stty",
 547         "gtty",
 548         "access",
 549         "nice",
 550         "ftime",                  /* 35 */
 551         "sync",
 552         "kill",
 553         "stat",
 554         "setpgrp3",
 555         "lstat",                  /* 40 */
 556         "dup",
 557         "pipe",
 558         "times",
 559         "profil",
 560         "ki_call",                /* 45 */
 561         "setgid",
 562         "getgid",
 563         NULL,
 564         NULL,
 565         NULL,                     /* 50 */
 566         "acct",
 567         "set_userthreadid",
 568         NULL,
 569         "ioctl",
 570         "reboot",                 /* 55 */
 571         "symlink",
 572         "utssys",
 573         "readlink",
 574         "execve",
 575         "umask",                  /* 60 */
 576         "chroot",
 577         "fcntl",
 578         "ulimit",
 579         NULL,
 580         NULL,                     /* 65 */
 581         "vfork",
 582         NULL,
 583         NULL,
 584         NULL,
 585         NULL,                     /* 70 */
 586         "mmap",
 587         NULL,
 588         "munmap",
 589         "mprotect",
 590         "madvise",                /* 75 */
 591         "vhangup",
 592         "swapoff",
 593         NULL,
 594         "getgroups",
 595         "setgroups",              /* 80 */
 596         "getpgrp2",
 597         "setpgid/setpgrp2",
 598         "setitimer",
 599         "wait3",
 600         "swapon",                 /* 85 */
 601         "getitimer",
 602         NULL,
 603         NULL,
 604         NULL,
 605         "dup2",                   /* 90 */
 606         NULL,
 607         "fstat",
 608         "select",
 609         NULL,
 610         "fsync",                  /* 95 */
 611         "setpriority",
 612         NULL,
 613         NULL,
 614         NULL,
 615         "getpriority",            /* 100 */
 616         NULL,
 617         NULL,
 618         NULL,
 619         NULL,
 620         NULL,                     /* 105 */
 621         NULL,
 622         NULL,
 623         "sigvector",
 624         "sigblock",
 625         "sigsetmask",             /* 110 */
 626         "sigpause",
 627         "sigstack",
 628         NULL,
 629         NULL,
 630         NULL,                     /* 115 */
 631         "gettimeofday",
 632         "getrusage",
 633         NULL,
 634         NULL,
 635         "readv",                  /* 120 */
 636         "writev",
 637         "settimeofday",
 638         "fchown",
 639         "fchmod",
 640         NULL,                     /* 125 */
 641         "setresuid",
 642         "setresgid",
 643         "rename",
 644         "truncate",
 645         "ftruncate",              /* 130 */
 646         NULL,
 647         "sysconf",
 648         NULL,
 649         NULL,
 650         NULL,                     /* 135 */
 651         "mkdir",
 652         "rmdir",
 653         NULL,
 654         "sigcleanup",
 655         "setcore",                /* 140 */
 656         NULL,
 657         "gethostid",
 658         "sethostid",
 659         "getrlimit",
 660         "setrlimit",              /* 145 */
 661         NULL,
 662         NULL,
 663         "quotactl",
 664         "get_sysinfo",
 665         NULL,                     /* 150 */
 666         "privgrp",
 667         "rtprio",
 668         "plock",
 669         NULL,
 670         "lockf",                  /* 155 */
 671         "semget",
 672         NULL,
 673         "semop",
 674         "msgget",
 675         NULL,                     /* 160 */
 676         "msgsnd",
 677         "msgrcv",
 678         "shmget",
 679         NULL,
 680         "shmat",                  /* 165 */
 681         "shmdt",
 682         NULL,
 683         "csp/nsp_init",
 684         "cluster",
 685         "mkrnod",                 /* 170 */
 686         "test",
 687         "unsp_open",
 688         NULL,
 689         "getcontext",
 690         "osetcontext",            /* 175 */
 691         "bigio",
 692         "pipenode",
 693         "lsync",
 694         "getmachineid",
 695         "cnodeid/mysite",         /* 180 */
 696         "cnodes/sitels",
 697         "swapclients",
 698         "rmtprocess",
 699         "dskless_stats",
 700         "sigprocmask",            /* 185 */
 701         "sigpending",
 702         "sigsuspend",
 703         "sigaction",
 704         NULL,
 705         "nfssvc",                 /* 190 */
 706         "getfh",
 707         "getdomainname",
 708         "setdomainname",
 709         "async_daemon",
 710         "getdirentries",          /* 195 */
 711         NULL,
 712         NULL,
 713         "vfsmount",
 714         NULL,
 715         "waitpid",                /* 200 */
 716         NULL,
 717         NULL,
 718         NULL,
 719         NULL,
 720         NULL,                     /* 205 */
 721         NULL,
 722         NULL,
 723         NULL,
 724         NULL,
 725         NULL,                     /* 210 */
 726         NULL,
 727         NULL,
 728         NULL,
 729         NULL,
 730         NULL,                     /* 215 */
 731         NULL,
 732         NULL,
 733         NULL,
 734         NULL,
 735         NULL,                     /* 220 */
 736         NULL,
 737         NULL,
 738         NULL,
 739         "sigsetreturn",
 740         "sigsetstatemask",        /* 225 */
 741         "bfactl",
 742         "cs",
 743         "cds",
 744         NULL,
 745         "pathconf",               /* 230 */
 746         "fpathconf",
 747         NULL,
 748         NULL,
 749         "nfs_fcntl",
 750         "ogetacl",                /* 235 */
 751         "ofgetacl",
 752         "osetacl",
 753         "ofsetacl",
 754         "pstat",
 755         "getaudid",               /* 240 */
 756         "setaudid",
 757         "getaudproc",
 758         "setaudproc",
 759         "getevent",
 760         "setevent",               /* 245 */
 761         "audwrite",
 762         "audswitch",
 763         "audctl",
 764         "ogetaccess",
 765         "fsctl",                  /* 250 */
 766         "ulconnect",
 767         "ulcontrol",
 768         "ulcreate",
 769         "uldest",
 770         "ulrecv",                 /* 255 */
 771         "ulrecvcn",
 772         "ulsend",
 773         "ulshutdown",
 774         "swapfs",
 775         "fss",                    /* 260 */
 776         NULL,
 777         NULL,
 778         NULL,
 779         NULL,
 780         NULL,                     /* 265 */
 781         NULL,
 782         "tsync",
 783         "getnumfds",
 784         "poll",
 785         "getmsg",                 /* 270 */
 786         "putmsg",
 787         "fchdir",
 788         "getmount_cnt",
 789         "getmount_entry",
 790         "accept",                 /* 275 */
 791         "bind",
 792         "connect",
 793         "getpeername",
 794         "getsockname",
 795         "getsockopt",             /* 280 */
 796         "listen",
 797         "recv",
 798         "recvfrom",
 799         "recvmsg",
 800         "send",                   /* 285 */
 801         "sendmsg",
 802         "sendto",
 803         "setsockopt",
 804         "shutdown",
 805         "socket",                 /* 290 */
 806         "socketpair",
 807         "proc_open",
 808         "proc_close",
 809         "proc_send",
 810         "proc_recv",              /* 295 */
 811         "proc_sendrecv",
 812         "proc_syscall",
 813         "ipccreate",
 814         "ipcname",
 815         "ipcnamerase",            /* 300 */
 816         "ipclookup",
 817         "ipcselect",
 818         "ipcconnect",
 819         "ipcrecvcn",
 820         "ipcsend",                /* 305 */
 821         "ipcrecv",
 822         "ipcgetnodename",
 823         "ipcsetnodename",
 824         "ipccontrol",
 825         "ipcshutdown",            /* 310 */
 826         "ipcdest",
 827         "semctl",
 828         "msgctl",
 829         "shmctl",
 830         "mpctl",                  /* 315 */
 831         "exportfs",
 832         "getpmsg",
 833         "putpmsg",
 834         "strioctl",
 835         "msync",                  /* 320 */
 836         "msleep",
 837         "mwakeup",
 838         "msem_init",
 839         "msem_remove",
 840         "adjtime",                /* 325 */
 841         "kload",
 842         "fattach",
 843         "fdetach",
 844         "serialize",
 845         "statvfs",                /* 330 */
 846         "fstatvfs",
 847         "lchown",
 848         "getsid",
 849         "sysfs",
 850         NULL,                     /* 335 */
 851         NULL,
 852         "sched_setparam",
 853         "sched_getparam",
 854         "sched_setscheduler",
 855         "sched_getscheduler",     /* 340 */
 856         "sched_yield",
 857         "sched_get_priority_max",
 858         "sched_get_priority_min",
 859         "sched_rr_get_interval",
 860         "clock_settime",          /* 345 */
 861         "clock_gettime",
 862         "clock_getres",
 863         "timer_create",
 864         "timer_delete",
 865         "timer_settime",          /* 350 */
 866         "timer_gettime",
 867         "timer_getoverrun",
 868         "nanosleep",
 869         "toolbox",
 870         NULL,                     /* 355 */
 871         "getdents",
 872         "getcontext",
 873         "sysinfo",
 874         "fcntl64",
 875         "ftruncate64",            /* 360 */
 876         "fstat64",
 877         "getdirentries64",
 878         "getrlimit64",
 879         "lockf64",
 880         "lseek64",                /* 365 */
 881         "lstat64",
 882         "mmap64",
 883         "setrlimit64",
 884         "stat64",
 885         "truncate64",             /* 370 */
 886         "ulimit64",
 887         NULL,
 888         NULL,
 889         NULL,
 890         NULL,                     /* 375 */
 891         NULL,
 892         NULL,
 893         NULL,
 894         NULL,
 895         "setcontext",             /* 380 */
 896         "sigaltstack",
 897         "waitid",
 898         "setpgrp",
 899         "recvmsg2",
 900         "sendmsg2",               /* 385 */
 901         "socket2",
 902         "socketpair2",
 903         "setregid",
 904         "lwp_create",
 905         "lwp_terminate",          /* 390 */
 906         "lwp_wait",
 907         "lwp_suspend",
 908         "lwp_resume",
 909         "lwp_self",
 910         "lwp_abort_syscall",      /* 395 */
 911         "lwp_info",
 912         "lwp_kill",
 913         "ksleep",
 914         "kwakeup",
 915         "ksleep_abort",           /* 400 */
 916         "lwp_proc_info",
 917         "lwp_exit",
 918         "lwp_continue",
 919         "getacl",
 920         "fgetacl",                /* 405 */
 921         "setacl",
 922         "fsetacl",
 923         "getaccess",
 924         "lwp_mutex_init",
 925         "lwp_mutex_lock_sys",     /* 410 */
 926         "lwp_mutex_unlock",
 927         "lwp_cond_init",
 928         "lwp_cond_signal",
 929         "lwp_cond_broadcast",
 930         "lwp_cond_wait_sys",      /* 415 */
 931         "lwp_getscheduler",
 932         "lwp_setscheduler",
 933         "lwp_getprivate",
 934         "lwp_setprivate",
 935         "lwp_detach",             /* 420 */
 936         "mlock",
 937         "munlock",
 938         "mlockall",
 939         "munlockall",
 940         "shm_open",               /* 425 */
 941         "shm_unlink",
 942         "sigqueue",
 943         "sigwaitinfo",
 944         "sigtimedwait",
 945         "sigwait",                /* 430 */
 946         "aio_read",
 947         "aio_write",
 948         "lio_listio",
 949         "aio_error",
 950         "aio_return",             /* 435 */
 951         "aio_cancel",
 952         "aio_suspend",
 953         "aio_fsync",
 954         "mq_open",
 955         "mq_unlink",              /* 440 */
 956         "mq_send",
 957         "mq_receive",
 958         "mq_notify",
 959         "mq_setattr",
 960         "mq_getattr",             /* 445 */
 961         "ksem_open",
 962         "ksem_unlink",
 963         "ksem_close",
 964         "ksem_destroy",
 965         "lw_sem_incr",            /* 450 */
 966         "lw_sem_decr",
 967         "lw_sem_read",
 968         "mq_close",
 969 };
 970 static const int syscall_names_max = 453;
 971
 972 int
 973 hpux_unimplemented(unsigned long arg1,unsigned long arg2,unsigned long arg3,
 974                    unsigned long arg4,unsigned long arg5,unsigned long arg6,
 975                    unsigned long arg7,unsigned long sc_num)
 976 {
 977         /* NOTE: sc_num trashes arg8 for the few syscalls that actually
 978          * have a valid 8th argument.
 979          */
 980         const char *name = NULL;
 981         if ( sc_num <= syscall_names_max && sc_num >= 0 ) {
 982                 name = syscall_names[sc_num];
 983         }
 984
 985         if ( name ) {
 986                 printk(KERN_DEBUG "Unimplemented HP-UX syscall emulation. Syscall #%lu (%s)\n",
 987                 sc_num, name);
 988         } else {
 989                 printk(KERN_DEBUG "Unimplemented unknown HP-UX syscall emulation. Syscall #%lu\n",
 990                 sc_num);
 991         }
 992
 993         printk(KERN_DEBUG "  Args: %lx %lx %lx %lx %lx %lx %lx\n",
 994                 arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 995
 996         return -ENOSYS;
 997 }