linux-vybrid_public/arch/parisc/hpux/sys_hpux.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/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 *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, &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 super_block *sb, struct hpux_statfs *buf)
{
	struct kstatfs st;
	int retval;
	
	retval = vfs_statfs(sb, &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 *path,
						struct hpux_statfs __user *buf)
{
	struct nameidata nd;
	int error;

	error = user_path_walk(path, &nd);
	if (!error) {
		struct hpux_statfs tmp;
		error = vfs_statfs_hpux(nd.dentry->d_inode->i_sb, &tmp);
		if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
			error = -EFAULT;
		path_release(&nd);
	}
	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_dentry->d_inode->i_sb, &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 *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,&system_utsname.sysname,HPUX_UTSLEN-1);
	error |= __put_user(0,name->sysname+HPUX_UTSLEN-1);
	error |= __copy_to_user(&name->nodename,&system_utsname.nodename,HPUX_UTSLEN-1);
	error |= __put_user(0,name->nodename+HPUX_UTSLEN-1);
	error |= __copy_to_user(&name->release,&system_utsname.release,HPUX_UTSLEN-1);
	error |= __put_user(0,name->release+HPUX_UTSLEN-1);
	error |= __copy_to_user(&name->version,&system_utsname.version,HPUX_UTSLEN-1);
	error |= __put_user(0,name->version+HPUX_UTSLEN-1);
	error |= __copy_to_user(&name->machine,&system_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 *ubuf, int n, int type)
{
	int len;
	int error;
	switch( type ) {
	case 0:
		/*  uname():  */
		return( hpux_uname( (struct hpux_utsname *)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 *)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(system_utsname.sysname, ubuf, len)) {
			system_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(system_utsname.release, ubuf, len)) {
			system_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 *name, int len)
{
 	int nlen;
 	int err = -EFAULT;
 	
 	down_read(&uts_sem);
 	
	nlen = strlen(system_utsname.domainname) + 1;

	if (nlen < len)
		len = nlen;
	if(len > __NEW_UTS_LEN)
		goto done;
	if(copy_to_user(name, system_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(kstack_fildes);
	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 */	
		len = strlen_user((char *)arg1);
		printk(KERN_DEBUG "len of arg1 = %d\n", len);

		fsname = (char *) kmalloc(len+1, GFP_KERNEL);
		if ( !fsname ) {
			printk(KERN_DEBUG "failed to kmalloc fsname\n");
			return 0;
		}

		if ( copy_from_user(fsname, (char *)arg1, len+1) ) {
			printk(KERN_DEBUG "failed to copy_from_user fsname\n");
			kfree(fsname);
			return 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 *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;
}