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