998 lines
27 KiB
C
998 lines
27 KiB
C
/*
|
|
* Implements HPUX syscalls.
|
|
*
|
|
* Copyright (C) 1999 Matthew Wilcox <willy with parisc-linux.org>
|
|
* Copyright (C) 2000 Philipp Rumpf
|
|
* Copyright (C) 2000 John Marvin <jsm with parisc-linux.org>
|
|
* Copyright (C) 2000 Michael Ang <mang with subcarrier.org>
|
|
* Copyright (C) 2001 Nathan Neulinger <nneul at umr.edu>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <linux/capability.h>
|
|
#include <linux/file.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/namei.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/syscalls.h>
|
|
#include <linux/utsname.h>
|
|
#include <linux/vfs.h>
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <asm/errno.h>
|
|
#include <asm/pgalloc.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
unsigned long hpux_brk(unsigned long addr)
|
|
{
|
|
/* Sigh. Looks like HP/UX libc relies on kernel bugs. */
|
|
return sys_brk(addr + PAGE_SIZE);
|
|
}
|
|
|
|
int hpux_sbrk(void)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
/* Random other syscalls */
|
|
|
|
int hpux_nice(int priority_change)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
int hpux_ptrace(void)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
int hpux_wait(int __user *stat_loc)
|
|
{
|
|
return sys_waitpid(-1, stat_loc, 0);
|
|
}
|
|
|
|
int hpux_setpgrp(void)
|
|
{
|
|
return sys_setpgid(0,0);
|
|
}
|
|
|
|
int hpux_setpgrp3(void)
|
|
{
|
|
return hpux_setpgrp();
|
|
}
|
|
|
|
#define _SC_CPU_VERSION 10001
|
|
#define _SC_OPEN_MAX 4
|
|
#define CPU_PA_RISC1_1 0x210
|
|
|
|
int hpux_sysconf(int which)
|
|
{
|
|
switch (which) {
|
|
case _SC_CPU_VERSION:
|
|
return CPU_PA_RISC1_1;
|
|
case _SC_OPEN_MAX:
|
|
return INT_MAX;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define HPUX_UTSLEN 9
|
|
#define HPUX_SNLEN 15
|
|
|
|
struct hpux_utsname {
|
|
char sysname[HPUX_UTSLEN];
|
|
char nodename[HPUX_UTSLEN];
|
|
char release[HPUX_UTSLEN];
|
|
char version[HPUX_UTSLEN];
|
|
char machine[HPUX_UTSLEN];
|
|
char idnumber[HPUX_SNLEN];
|
|
} ;
|
|
|
|
struct hpux_ustat {
|
|
int32_t f_tfree; /* total free (daddr_t) */
|
|
u_int32_t f_tinode; /* total inodes free (ino_t) */
|
|
char f_fname[6]; /* filsys name */
|
|
char f_fpack[6]; /* filsys pack name */
|
|
u_int32_t f_blksize; /* filsys block size (int) */
|
|
};
|
|
|
|
/*
|
|
* HPUX's utssys() call. It's a collection of miscellaneous functions,
|
|
* alas, so there's no nice way of splitting them up.
|
|
*/
|
|
|
|
/* This function is called from hpux_utssys(); HP-UX implements
|
|
* ustat() as an option to utssys().
|
|
*
|
|
* Now, struct ustat on HP-UX is exactly the same as on Linux, except
|
|
* that it contains one addition field on the end, int32_t f_blksize.
|
|
* So, we could have written this function to just call the Linux
|
|
* sys_ustat(), (defined in linux/fs/super.c), and then just
|
|
* added this additional field to the user's structure. But I figure
|
|
* if we're gonna be digging through filesystem structures to get
|
|
* this, we might as well just do the whole enchilada all in one go.
|
|
*
|
|
* So, most of this function is almost identical to sys_ustat().
|
|
* I have placed comments at the few lines changed or added, to
|
|
* aid in porting forward if and when sys_ustat() is changed from
|
|
* its form in kernel 2.2.5.
|
|
*/
|
|
static int hpux_ustat(dev_t dev, struct hpux_ustat __user *ubuf)
|
|
{
|
|
struct super_block *s;
|
|
struct hpux_ustat tmp; /* Changed to hpux_ustat */
|
|
struct kstatfs sbuf;
|
|
int err = -EINVAL;
|
|
|
|
s = user_get_super(dev);
|
|
if (s == NULL)
|
|
goto out;
|
|
err = vfs_statfs(s->s_root, &sbuf);
|
|
drop_super(s);
|
|
if (err)
|
|
goto out;
|
|
|
|
memset(&tmp,0,sizeof(tmp));
|
|
|
|
tmp.f_tfree = (int32_t)sbuf.f_bfree;
|
|
tmp.f_tinode = (u_int32_t)sbuf.f_ffree;
|
|
tmp.f_blksize = (u_int32_t)sbuf.f_bsize; /* Added this line */
|
|
|
|
err = copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Wrapper for hpux statfs call. At the moment, just calls the linux native one
|
|
* and ignores the extra fields at the end of the hpux statfs struct.
|
|
*
|
|
*/
|
|
|
|
typedef int32_t hpux_fsid_t[2]; /* file system ID type */
|
|
typedef uint16_t hpux_site_t;
|
|
|
|
struct hpux_statfs {
|
|
int32_t f_type; /* type of info, zero for now */
|
|
int32_t f_bsize; /* fundamental file system block size */
|
|
int32_t f_blocks; /* total blocks in file system */
|
|
int32_t f_bfree; /* free block in fs */
|
|
int32_t f_bavail; /* free blocks avail to non-superuser */
|
|
int32_t f_files; /* total file nodes in file system */
|
|
int32_t f_ffree; /* free file nodes in fs */
|
|
hpux_fsid_t f_fsid; /* file system ID */
|
|
int32_t f_magic; /* file system magic number */
|
|
int32_t f_featurebits; /* file system features */
|
|
int32_t f_spare[4]; /* spare for later */
|
|
hpux_site_t f_cnode; /* cluster node where mounted */
|
|
int16_t f_pad;
|
|
};
|
|
|
|
static int vfs_statfs_hpux(struct dentry *dentry, struct hpux_statfs *buf)
|
|
{
|
|
struct kstatfs st;
|
|
int retval;
|
|
|
|
retval = vfs_statfs(dentry, &st);
|
|
if (retval)
|
|
return retval;
|
|
|
|
memset(buf, 0, sizeof(*buf));
|
|
buf->f_type = st.f_type;
|
|
buf->f_bsize = st.f_bsize;
|
|
buf->f_blocks = st.f_blocks;
|
|
buf->f_bfree = st.f_bfree;
|
|
buf->f_bavail = st.f_bavail;
|
|
buf->f_files = st.f_files;
|
|
buf->f_ffree = st.f_ffree;
|
|
buf->f_fsid[0] = st.f_fsid.val[0];
|
|
buf->f_fsid[1] = st.f_fsid.val[1];
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* hpux statfs */
|
|
asmlinkage long hpux_statfs(const char __user *pathname,
|
|
struct hpux_statfs __user *buf)
|
|
{
|
|
struct path path;
|
|
int error;
|
|
|
|
error = user_path(pathname, &path);
|
|
if (!error) {
|
|
struct hpux_statfs tmp;
|
|
error = vfs_statfs_hpux(path.dentry, &tmp);
|
|
if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
|
|
error = -EFAULT;
|
|
path_put(&path);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
asmlinkage long hpux_fstatfs(unsigned int fd, struct hpux_statfs __user * buf)
|
|
{
|
|
struct file *file;
|
|
struct hpux_statfs tmp;
|
|
int error;
|
|
|
|
error = -EBADF;
|
|
file = fget(fd);
|
|
if (!file)
|
|
goto out;
|
|
error = vfs_statfs_hpux(file->f_path.dentry, &tmp);
|
|
if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
|
|
error = -EFAULT;
|
|
fput(file);
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
|
|
/* This function is called from hpux_utssys(); HP-UX implements
|
|
* uname() as an option to utssys().
|
|
*
|
|
* The form of this function is pretty much copied from sys_olduname(),
|
|
* defined in linux/arch/i386/kernel/sys_i386.c.
|
|
*/
|
|
/* TODO: Are these put_user calls OK? Should they pass an int?
|
|
* (I copied it from sys_i386.c like this.)
|
|
*/
|
|
static int hpux_uname(struct hpux_utsname __user *name)
|
|
{
|
|
int error;
|
|
|
|
if (!name)
|
|
return -EFAULT;
|
|
if (!access_ok(VERIFY_WRITE,name,sizeof(struct hpux_utsname)))
|
|
return -EFAULT;
|
|
|
|
down_read(&uts_sem);
|
|
|
|
error = __copy_to_user(&name->sysname, &utsname()->sysname,
|
|
HPUX_UTSLEN - 1);
|
|
error |= __put_user(0, name->sysname + HPUX_UTSLEN - 1);
|
|
error |= __copy_to_user(&name->nodename, &utsname()->nodename,
|
|
HPUX_UTSLEN - 1);
|
|
error |= __put_user(0, name->nodename + HPUX_UTSLEN - 1);
|
|
error |= __copy_to_user(&name->release, &utsname()->release,
|
|
HPUX_UTSLEN - 1);
|
|
error |= __put_user(0, name->release + HPUX_UTSLEN - 1);
|
|
error |= __copy_to_user(&name->version, &utsname()->version,
|
|
HPUX_UTSLEN - 1);
|
|
error |= __put_user(0, name->version + HPUX_UTSLEN - 1);
|
|
error |= __copy_to_user(&name->machine, &utsname()->machine,
|
|
HPUX_UTSLEN - 1);
|
|
error |= __put_user(0, name->machine + HPUX_UTSLEN - 1);
|
|
|
|
up_read(&uts_sem);
|
|
|
|
/* HP-UX utsname has no domainname field. */
|
|
|
|
/* TODO: Implement idnumber!!! */
|
|
#if 0
|
|
error |= __put_user(0,name->idnumber);
|
|
error |= __put_user(0,name->idnumber+HPUX_SNLEN-1);
|
|
#endif
|
|
|
|
error = error ? -EFAULT : 0;
|
|
|
|
return error;
|
|
}
|
|
|
|
/* Note: HP-UX just uses the old suser() function to check perms
|
|
* in this system call. We'll use capable(CAP_SYS_ADMIN).
|
|
*/
|
|
int hpux_utssys(char __user *ubuf, int n, int type)
|
|
{
|
|
int len;
|
|
int error;
|
|
switch( type ) {
|
|
case 0:
|
|
/* uname(): */
|
|
return hpux_uname((struct hpux_utsname __user *)ubuf);
|
|
break ;
|
|
case 1:
|
|
/* Obsolete (used to be umask().) */
|
|
return -EFAULT ;
|
|
break ;
|
|
case 2:
|
|
/* ustat(): */
|
|
return hpux_ustat(new_decode_dev(n),
|
|
(struct hpux_ustat __user *)ubuf);
|
|
break;
|
|
case 3:
|
|
/* setuname():
|
|
*
|
|
* On linux (unlike HP-UX), utsname.nodename
|
|
* is the same as the hostname.
|
|
*
|
|
* sys_sethostname() is defined in linux/kernel/sys.c.
|
|
*/
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
/* Unlike Linux, HP-UX returns an error if n==0: */
|
|
if ( n <= 0 )
|
|
return -EINVAL ;
|
|
/* Unlike Linux, HP-UX truncates it if n is too big: */
|
|
len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
|
|
return sys_sethostname(ubuf, len);
|
|
break ;
|
|
case 4:
|
|
/* sethostname():
|
|
*
|
|
* sys_sethostname() is defined in linux/kernel/sys.c.
|
|
*/
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
/* Unlike Linux, HP-UX returns an error if n==0: */
|
|
if ( n <= 0 )
|
|
return -EINVAL ;
|
|
/* Unlike Linux, HP-UX truncates it if n is too big: */
|
|
len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
|
|
return sys_sethostname(ubuf, len);
|
|
break ;
|
|
case 5:
|
|
/* gethostname():
|
|
*
|
|
* sys_gethostname() is defined in linux/kernel/sys.c.
|
|
*/
|
|
/* Unlike Linux, HP-UX returns an error if n==0: */
|
|
if ( n <= 0 )
|
|
return -EINVAL ;
|
|
return sys_gethostname(ubuf, n);
|
|
break ;
|
|
case 6:
|
|
/* Supposedly called from setuname() in libc.
|
|
* TODO: When and why is this called?
|
|
* Is it ever even called?
|
|
*
|
|
* This code should look a lot like sys_sethostname(),
|
|
* defined in linux/kernel/sys.c. If that gets updated,
|
|
* update this code similarly.
|
|
*/
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
/* Unlike Linux, HP-UX returns an error if n==0: */
|
|
if ( n <= 0 )
|
|
return -EINVAL ;
|
|
/* Unlike Linux, HP-UX truncates it if n is too big: */
|
|
len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
|
|
/**/
|
|
/* TODO: print a warning about using this? */
|
|
down_write(&uts_sem);
|
|
error = -EFAULT;
|
|
if (!copy_from_user(utsname()->sysname, ubuf, len)) {
|
|
utsname()->sysname[len] = 0;
|
|
error = 0;
|
|
}
|
|
up_write(&uts_sem);
|
|
return error;
|
|
break ;
|
|
case 7:
|
|
/* Sets utsname.release, if you're allowed.
|
|
* Undocumented. Used by swinstall to change the
|
|
* OS version, during OS updates. Yuck!!!
|
|
*
|
|
* This code should look a lot like sys_sethostname()
|
|
* in linux/kernel/sys.c. If that gets updated, update
|
|
* this code similarly.
|
|
*/
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EPERM;
|
|
/* Unlike Linux, HP-UX returns an error if n==0: */
|
|
if ( n <= 0 )
|
|
return -EINVAL ;
|
|
/* Unlike Linux, HP-UX truncates it if n is too big: */
|
|
len = (n <= __NEW_UTS_LEN) ? n : __NEW_UTS_LEN ;
|
|
/**/
|
|
/* TODO: print a warning about this? */
|
|
down_write(&uts_sem);
|
|
error = -EFAULT;
|
|
if (!copy_from_user(utsname()->release, ubuf, len)) {
|
|
utsname()->release[len] = 0;
|
|
error = 0;
|
|
}
|
|
up_write(&uts_sem);
|
|
return error;
|
|
break ;
|
|
default:
|
|
/* This system call returns -EFAULT if given an unknown type.
|
|
* Why not -EINVAL? I don't know, it's just not what they did.
|
|
*/
|
|
return -EFAULT ;
|
|
}
|
|
}
|
|
|
|
int hpux_getdomainname(char __user *name, int len)
|
|
{
|
|
int nlen;
|
|
int err = -EFAULT;
|
|
|
|
down_read(&uts_sem);
|
|
|
|
nlen = strlen(utsname()->domainname) + 1;
|
|
|
|
if (nlen < len)
|
|
len = nlen;
|
|
if(len > __NEW_UTS_LEN)
|
|
goto done;
|
|
if(copy_to_user(name, utsname()->domainname, len))
|
|
goto done;
|
|
err = 0;
|
|
done:
|
|
up_read(&uts_sem);
|
|
return err;
|
|
|
|
}
|
|
|
|
int hpux_pipe(int *kstack_fildes)
|
|
{
|
|
int error;
|
|
|
|
lock_kernel();
|
|
error = do_pipe_flags(kstack_fildes, 0);
|
|
unlock_kernel();
|
|
return error;
|
|
}
|
|
|
|
/* lies - says it works, but it really didn't lock anything */
|
|
int hpux_lockf(int fildes, int function, off_t size)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int hpux_sysfs(int opcode, unsigned long arg1, unsigned long arg2)
|
|
{
|
|
char *fsname = NULL;
|
|
int len = 0;
|
|
int fstype;
|
|
|
|
/*Unimplemented HP-UX syscall emulation. Syscall #334 (sysfs)
|
|
Args: 1 80057bf4 0 400179f0 0 0 0 */
|
|
printk(KERN_DEBUG "in hpux_sysfs\n");
|
|
printk(KERN_DEBUG "hpux_sysfs called with opcode = %d\n", opcode);
|
|
printk(KERN_DEBUG "hpux_sysfs called with arg1='%lx'\n", arg1);
|
|
|
|
if ( opcode == 1 ) { /* GETFSIND */
|
|
char __user *user_fsname = (char __user *)arg1;
|
|
len = strlen_user(user_fsname);
|
|
printk(KERN_DEBUG "len of arg1 = %d\n", len);
|
|
if (len == 0)
|
|
return 0;
|
|
fsname = kmalloc(len, GFP_KERNEL);
|
|
if (!fsname) {
|
|
printk(KERN_DEBUG "failed to kmalloc fsname\n");
|
|
return 0;
|
|
}
|
|
|
|
if (copy_from_user(fsname, user_fsname, len)) {
|
|
printk(KERN_DEBUG "failed to copy_from_user fsname\n");
|
|
kfree(fsname);
|
|
return 0;
|
|
}
|
|
|
|
/* String could be altered by userspace after strlen_user() */
|
|
fsname[len] = '\0';
|
|
|
|
printk(KERN_DEBUG "that is '%s' as (char *)\n", fsname);
|
|
if ( !strcmp(fsname, "hfs") ) {
|
|
fstype = 0;
|
|
} else {
|
|
fstype = 0;
|
|
}
|
|
|
|
kfree(fsname);
|
|
|
|
printk(KERN_DEBUG "returning fstype=%d\n", fstype);
|
|
return fstype; /* something other than default */
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Table of syscall names and handle for unimplemented routines */
|
|
static const char * const syscall_names[] = {
|
|
"nosys", /* 0 */
|
|
"exit",
|
|
"fork",
|
|
"read",
|
|
"write",
|
|
"open", /* 5 */
|
|
"close",
|
|
"wait",
|
|
"creat",
|
|
"link",
|
|
"unlink", /* 10 */
|
|
"execv",
|
|
"chdir",
|
|
"time",
|
|
"mknod",
|
|
"chmod", /* 15 */
|
|
"chown",
|
|
"brk",
|
|
"lchmod",
|
|
"lseek",
|
|
"getpid", /* 20 */
|
|
"mount",
|
|
"umount",
|
|
"setuid",
|
|
"getuid",
|
|
"stime", /* 25 */
|
|
"ptrace",
|
|
"alarm",
|
|
NULL,
|
|
"pause",
|
|
"utime", /* 30 */
|
|
"stty",
|
|
"gtty",
|
|
"access",
|
|
"nice",
|
|
"ftime", /* 35 */
|
|
"sync",
|
|
"kill",
|
|
"stat",
|
|
"setpgrp3",
|
|
"lstat", /* 40 */
|
|
"dup",
|
|
"pipe",
|
|
"times",
|
|
"profil",
|
|
"ki_call", /* 45 */
|
|
"setgid",
|
|
"getgid",
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 50 */
|
|
"acct",
|
|
"set_userthreadid",
|
|
NULL,
|
|
"ioctl",
|
|
"reboot", /* 55 */
|
|
"symlink",
|
|
"utssys",
|
|
"readlink",
|
|
"execve",
|
|
"umask", /* 60 */
|
|
"chroot",
|
|
"fcntl",
|
|
"ulimit",
|
|
NULL,
|
|
NULL, /* 65 */
|
|
"vfork",
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 70 */
|
|
"mmap",
|
|
NULL,
|
|
"munmap",
|
|
"mprotect",
|
|
"madvise", /* 75 */
|
|
"vhangup",
|
|
"swapoff",
|
|
NULL,
|
|
"getgroups",
|
|
"setgroups", /* 80 */
|
|
"getpgrp2",
|
|
"setpgid/setpgrp2",
|
|
"setitimer",
|
|
"wait3",
|
|
"swapon", /* 85 */
|
|
"getitimer",
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
"dup2", /* 90 */
|
|
NULL,
|
|
"fstat",
|
|
"select",
|
|
NULL,
|
|
"fsync", /* 95 */
|
|
"setpriority",
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
"getpriority", /* 100 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 105 */
|
|
NULL,
|
|
NULL,
|
|
"sigvector",
|
|
"sigblock",
|
|
"sigsetmask", /* 110 */
|
|
"sigpause",
|
|
"sigstack",
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 115 */
|
|
"gettimeofday",
|
|
"getrusage",
|
|
NULL,
|
|
NULL,
|
|
"readv", /* 120 */
|
|
"writev",
|
|
"settimeofday",
|
|
"fchown",
|
|
"fchmod",
|
|
NULL, /* 125 */
|
|
"setresuid",
|
|
"setresgid",
|
|
"rename",
|
|
"truncate",
|
|
"ftruncate", /* 130 */
|
|
NULL,
|
|
"sysconf",
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 135 */
|
|
"mkdir",
|
|
"rmdir",
|
|
NULL,
|
|
"sigcleanup",
|
|
"setcore", /* 140 */
|
|
NULL,
|
|
"gethostid",
|
|
"sethostid",
|
|
"getrlimit",
|
|
"setrlimit", /* 145 */
|
|
NULL,
|
|
NULL,
|
|
"quotactl",
|
|
"get_sysinfo",
|
|
NULL, /* 150 */
|
|
"privgrp",
|
|
"rtprio",
|
|
"plock",
|
|
NULL,
|
|
"lockf", /* 155 */
|
|
"semget",
|
|
NULL,
|
|
"semop",
|
|
"msgget",
|
|
NULL, /* 160 */
|
|
"msgsnd",
|
|
"msgrcv",
|
|
"shmget",
|
|
NULL,
|
|
"shmat", /* 165 */
|
|
"shmdt",
|
|
NULL,
|
|
"csp/nsp_init",
|
|
"cluster",
|
|
"mkrnod", /* 170 */
|
|
"test",
|
|
"unsp_open",
|
|
NULL,
|
|
"getcontext",
|
|
"osetcontext", /* 175 */
|
|
"bigio",
|
|
"pipenode",
|
|
"lsync",
|
|
"getmachineid",
|
|
"cnodeid/mysite", /* 180 */
|
|
"cnodes/sitels",
|
|
"swapclients",
|
|
"rmtprocess",
|
|
"dskless_stats",
|
|
"sigprocmask", /* 185 */
|
|
"sigpending",
|
|
"sigsuspend",
|
|
"sigaction",
|
|
NULL,
|
|
"nfssvc", /* 190 */
|
|
"getfh",
|
|
"getdomainname",
|
|
"setdomainname",
|
|
"async_daemon",
|
|
"getdirentries", /* 195 */
|
|
NULL,
|
|
NULL,
|
|
"vfsmount",
|
|
NULL,
|
|
"waitpid", /* 200 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 205 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 210 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 215 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 220 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
"sigsetreturn",
|
|
"sigsetstatemask", /* 225 */
|
|
"bfactl",
|
|
"cs",
|
|
"cds",
|
|
NULL,
|
|
"pathconf", /* 230 */
|
|
"fpathconf",
|
|
NULL,
|
|
NULL,
|
|
"nfs_fcntl",
|
|
"ogetacl", /* 235 */
|
|
"ofgetacl",
|
|
"osetacl",
|
|
"ofsetacl",
|
|
"pstat",
|
|
"getaudid", /* 240 */
|
|
"setaudid",
|
|
"getaudproc",
|
|
"setaudproc",
|
|
"getevent",
|
|
"setevent", /* 245 */
|
|
"audwrite",
|
|
"audswitch",
|
|
"audctl",
|
|
"ogetaccess",
|
|
"fsctl", /* 250 */
|
|
"ulconnect",
|
|
"ulcontrol",
|
|
"ulcreate",
|
|
"uldest",
|
|
"ulrecv", /* 255 */
|
|
"ulrecvcn",
|
|
"ulsend",
|
|
"ulshutdown",
|
|
"swapfs",
|
|
"fss", /* 260 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 265 */
|
|
NULL,
|
|
"tsync",
|
|
"getnumfds",
|
|
"poll",
|
|
"getmsg", /* 270 */
|
|
"putmsg",
|
|
"fchdir",
|
|
"getmount_cnt",
|
|
"getmount_entry",
|
|
"accept", /* 275 */
|
|
"bind",
|
|
"connect",
|
|
"getpeername",
|
|
"getsockname",
|
|
"getsockopt", /* 280 */
|
|
"listen",
|
|
"recv",
|
|
"recvfrom",
|
|
"recvmsg",
|
|
"send", /* 285 */
|
|
"sendmsg",
|
|
"sendto",
|
|
"setsockopt",
|
|
"shutdown",
|
|
"socket", /* 290 */
|
|
"socketpair",
|
|
"proc_open",
|
|
"proc_close",
|
|
"proc_send",
|
|
"proc_recv", /* 295 */
|
|
"proc_sendrecv",
|
|
"proc_syscall",
|
|
"ipccreate",
|
|
"ipcname",
|
|
"ipcnamerase", /* 300 */
|
|
"ipclookup",
|
|
"ipcselect",
|
|
"ipcconnect",
|
|
"ipcrecvcn",
|
|
"ipcsend", /* 305 */
|
|
"ipcrecv",
|
|
"ipcgetnodename",
|
|
"ipcsetnodename",
|
|
"ipccontrol",
|
|
"ipcshutdown", /* 310 */
|
|
"ipcdest",
|
|
"semctl",
|
|
"msgctl",
|
|
"shmctl",
|
|
"mpctl", /* 315 */
|
|
"exportfs",
|
|
"getpmsg",
|
|
"putpmsg",
|
|
"strioctl",
|
|
"msync", /* 320 */
|
|
"msleep",
|
|
"mwakeup",
|
|
"msem_init",
|
|
"msem_remove",
|
|
"adjtime", /* 325 */
|
|
"kload",
|
|
"fattach",
|
|
"fdetach",
|
|
"serialize",
|
|
"statvfs", /* 330 */
|
|
"fstatvfs",
|
|
"lchown",
|
|
"getsid",
|
|
"sysfs",
|
|
NULL, /* 335 */
|
|
NULL,
|
|
"sched_setparam",
|
|
"sched_getparam",
|
|
"sched_setscheduler",
|
|
"sched_getscheduler", /* 340 */
|
|
"sched_yield",
|
|
"sched_get_priority_max",
|
|
"sched_get_priority_min",
|
|
"sched_rr_get_interval",
|
|
"clock_settime", /* 345 */
|
|
"clock_gettime",
|
|
"clock_getres",
|
|
"timer_create",
|
|
"timer_delete",
|
|
"timer_settime", /* 350 */
|
|
"timer_gettime",
|
|
"timer_getoverrun",
|
|
"nanosleep",
|
|
"toolbox",
|
|
NULL, /* 355 */
|
|
"getdents",
|
|
"getcontext",
|
|
"sysinfo",
|
|
"fcntl64",
|
|
"ftruncate64", /* 360 */
|
|
"fstat64",
|
|
"getdirentries64",
|
|
"getrlimit64",
|
|
"lockf64",
|
|
"lseek64", /* 365 */
|
|
"lstat64",
|
|
"mmap64",
|
|
"setrlimit64",
|
|
"stat64",
|
|
"truncate64", /* 370 */
|
|
"ulimit64",
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL, /* 375 */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
"setcontext", /* 380 */
|
|
"sigaltstack",
|
|
"waitid",
|
|
"setpgrp",
|
|
"recvmsg2",
|
|
"sendmsg2", /* 385 */
|
|
"socket2",
|
|
"socketpair2",
|
|
"setregid",
|
|
"lwp_create",
|
|
"lwp_terminate", /* 390 */
|
|
"lwp_wait",
|
|
"lwp_suspend",
|
|
"lwp_resume",
|
|
"lwp_self",
|
|
"lwp_abort_syscall", /* 395 */
|
|
"lwp_info",
|
|
"lwp_kill",
|
|
"ksleep",
|
|
"kwakeup",
|
|
"ksleep_abort", /* 400 */
|
|
"lwp_proc_info",
|
|
"lwp_exit",
|
|
"lwp_continue",
|
|
"getacl",
|
|
"fgetacl", /* 405 */
|
|
"setacl",
|
|
"fsetacl",
|
|
"getaccess",
|
|
"lwp_mutex_init",
|
|
"lwp_mutex_lock_sys", /* 410 */
|
|
"lwp_mutex_unlock",
|
|
"lwp_cond_init",
|
|
"lwp_cond_signal",
|
|
"lwp_cond_broadcast",
|
|
"lwp_cond_wait_sys", /* 415 */
|
|
"lwp_getscheduler",
|
|
"lwp_setscheduler",
|
|
"lwp_getprivate",
|
|
"lwp_setprivate",
|
|
"lwp_detach", /* 420 */
|
|
"mlock",
|
|
"munlock",
|
|
"mlockall",
|
|
"munlockall",
|
|
"shm_open", /* 425 */
|
|
"shm_unlink",
|
|
"sigqueue",
|
|
"sigwaitinfo",
|
|
"sigtimedwait",
|
|
"sigwait", /* 430 */
|
|
"aio_read",
|
|
"aio_write",
|
|
"lio_listio",
|
|
"aio_error",
|
|
"aio_return", /* 435 */
|
|
"aio_cancel",
|
|
"aio_suspend",
|
|
"aio_fsync",
|
|
"mq_open",
|
|
"mq_unlink", /* 440 */
|
|
"mq_send",
|
|
"mq_receive",
|
|
"mq_notify",
|
|
"mq_setattr",
|
|
"mq_getattr", /* 445 */
|
|
"ksem_open",
|
|
"ksem_unlink",
|
|
"ksem_close",
|
|
"ksem_destroy",
|
|
"lw_sem_incr", /* 450 */
|
|
"lw_sem_decr",
|
|
"lw_sem_read",
|
|
"mq_close",
|
|
};
|
|
static const int syscall_names_max = 453;
|
|
|
|
int
|
|
hpux_unimplemented(unsigned long arg1,unsigned long arg2,unsigned long arg3,
|
|
unsigned long arg4,unsigned long arg5,unsigned long arg6,
|
|
unsigned long arg7,unsigned long sc_num)
|
|
{
|
|
/* NOTE: sc_num trashes arg8 for the few syscalls that actually
|
|
* have a valid 8th argument.
|
|
*/
|
|
const char *name = NULL;
|
|
if ( sc_num <= syscall_names_max && sc_num >= 0 ) {
|
|
name = syscall_names[sc_num];
|
|
}
|
|
|
|
if ( name ) {
|
|
printk(KERN_DEBUG "Unimplemented HP-UX syscall emulation. Syscall #%lu (%s)\n",
|
|
sc_num, name);
|
|
} else {
|
|
printk(KERN_DEBUG "Unimplemented unknown HP-UX syscall emulation. Syscall #%lu\n",
|
|
sc_num);
|
|
}
|
|
|
|
printk(KERN_DEBUG " Args: %lx %lx %lx %lx %lx %lx %lx\n",
|
|
arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
|
|
return -ENOSYS;
|
|
}
|