sys_sunos32.c

ARM8008光盘linux-kernel

		/* sys_semctl(): */
		arg4.__pad=(void *)A(ptr); /* value to modify semaphore to */
		ret = sys_semctl((int)arg1, (int)arg2, (int)arg3, arg4);
		break;
	case 1:
		/* sys_semget(): */
		ret = sys_semget((key_t)arg1, (int)arg2, (int)arg3);
		break;
	case 2:
		/* sys_semop(): */
		ret = sys_semop((int)arg1, (struct sembuf *)A(arg2), (unsigned)arg3);
		break;
	default:
		ret = -EINVAL;
		break;
	};
	return ret;
}

struct msgbuf32 {
	s32 mtype;
	char mtext[1];
};

struct ipc_perm32
{
	key_t    	  key;
        __kernel_uid_t32  uid;
        __kernel_gid_t32  gid;
        __kernel_uid_t32  cuid;
        __kernel_gid_t32  cgid;
        __kernel_mode_t32 mode;
        unsigned short  seq;
};

struct msqid_ds32
{
        struct ipc_perm32 msg_perm;
        u32 msg_first;
        u32 msg_last;
        __kernel_time_t32 msg_stime;
        __kernel_time_t32 msg_rtime;
        __kernel_time_t32 msg_ctime;
        u32 wwait;
        u32 rwait;
        unsigned short msg_cbytes;
        unsigned short msg_qnum;  
        unsigned short msg_qbytes;
        __kernel_ipc_pid_t32 msg_lspid;
        __kernel_ipc_pid_t32 msg_lrpid;
};

static inline int sunos_msqid_get(struct msqid_ds32 *user,
				  struct msqid_ds *kern)
{
	if(get_user(kern->msg_perm.key, &user->msg_perm.key)		||
	   __get_user(kern->msg_perm.uid, &user->msg_perm.uid)		||
	   __get_user(kern->msg_perm.gid, &user->msg_perm.gid)		||
	   __get_user(kern->msg_perm.cuid, &user->msg_perm.cuid)	||
	   __get_user(kern->msg_perm.cgid, &user->msg_perm.cgid)	||
	   __get_user(kern->msg_stime, &user->msg_stime)		||
	   __get_user(kern->msg_rtime, &user->msg_rtime)		||
	   __get_user(kern->msg_ctime, &user->msg_ctime)		||
	   __get_user(kern->msg_ctime, &user->msg_cbytes)		||
	   __get_user(kern->msg_ctime, &user->msg_qnum)			||
	   __get_user(kern->msg_ctime, &user->msg_qbytes)		||
	   __get_user(kern->msg_ctime, &user->msg_lspid)		||
	   __get_user(kern->msg_ctime, &user->msg_lrpid))
		return -EFAULT;
	return 0;
}

static inline int sunos_msqid_put(struct msqid_ds32 *user,
				  struct msqid_ds *kern)
{
	if(put_user(kern->msg_perm.key, &user->msg_perm.key)		||
	   __put_user(kern->msg_perm.uid, &user->msg_perm.uid)		||
	   __put_user(kern->msg_perm.gid, &user->msg_perm.gid)		||
	   __put_user(kern->msg_perm.cuid, &user->msg_perm.cuid)	||
	   __put_user(kern->msg_perm.cgid, &user->msg_perm.cgid)	||
	   __put_user(kern->msg_stime, &user->msg_stime)		||
	   __put_user(kern->msg_rtime, &user->msg_rtime)		||
	   __put_user(kern->msg_ctime, &user->msg_ctime)		||
	   __put_user(kern->msg_ctime, &user->msg_cbytes)		||
	   __put_user(kern->msg_ctime, &user->msg_qnum)			||
	   __put_user(kern->msg_ctime, &user->msg_qbytes)		||
	   __put_user(kern->msg_ctime, &user->msg_lspid)		||
	   __put_user(kern->msg_ctime, &user->msg_lrpid))
		return -EFAULT;
	return 0;
}

static inline int sunos_msgbuf_get(struct msgbuf32 *user, struct msgbuf *kern, int len)
{
	if(get_user(kern->mtype, &user->mtype)	||
	   __copy_from_user(kern->mtext, &user->mtext, len))
		return -EFAULT;
	return 0;
}

static inline int sunos_msgbuf_put(struct msgbuf32 *user, struct msgbuf *kern, int len)
{
	if(put_user(kern->mtype, &user->mtype)	||
	   __copy_to_user(user->mtext, kern->mtext, len))
		return -EFAULT;
	return 0;
}

asmlinkage int sunos_msgsys(int op, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
{
	struct sparc_stackf32 *sp;
	struct msqid_ds kds;
	struct msgbuf *kmbuf;
	mm_segment_t old_fs = get_fs();
	u32 arg5;
	int rval;

	switch(op) {
	case 0:
		rval = sys_msgget((key_t)arg1, (int)arg2);
		break;
	case 1:
		if(!sunos_msqid_get((struct msqid_ds32 *)A(arg3), &kds)) {
			set_fs(KERNEL_DS);
			rval = sys_msgctl((int)arg1, (int)arg2,
					  (struct msqid_ds *)A(arg3));
			set_fs(old_fs);
			if(!rval)
				rval = sunos_msqid_put((struct msqid_ds32 *)A(arg3),
						       &kds);
		} else
			rval = -EFAULT;
		break;
	case 2:
		rval = -EFAULT;
		kmbuf = (struct msgbuf *)kmalloc(sizeof(struct msgbuf) + arg3,
						 GFP_KERNEL);
		if(!kmbuf)
			break;
		sp = (struct sparc_stackf32 *)
			(current->thread.kregs->u_regs[UREG_FP] & 0xffffffffUL);
		if(get_user(arg5, &sp->xxargs[0])) {
			rval = -EFAULT;
			kfree(kmbuf);
			break;
		}
		set_fs(KERNEL_DS);
		rval = sys_msgrcv((int)arg1, kmbuf, (size_t)arg3,
				  (long)arg4, (int)arg5);
		set_fs(old_fs);
		if(!rval)
			rval = sunos_msgbuf_put((struct msgbuf32 *)A(arg2),
						kmbuf, arg3);
		kfree(kmbuf);
		break;
	case 3:
		rval = -EFAULT;
		kmbuf = (struct msgbuf *)kmalloc(sizeof(struct msgbuf) + arg3,
						 GFP_KERNEL);
		if(!kmbuf || sunos_msgbuf_get((struct msgbuf32 *)A(arg2),
					      kmbuf, arg3))
			break;
		set_fs(KERNEL_DS);
		rval = sys_msgsnd((int)arg1, kmbuf, (size_t)arg3, (int)arg4);
		set_fs(old_fs);
		kfree(kmbuf);
		break;
	default:
		rval = -EINVAL;
		break;
	}
	return rval;
}

struct shmid_ds32 {
        struct ipc_perm32       shm_perm;
        int                     shm_segsz;
        __kernel_time_t32       shm_atime;
        __kernel_time_t32       shm_dtime;
        __kernel_time_t32       shm_ctime;
        __kernel_ipc_pid_t32    shm_cpid; 
        __kernel_ipc_pid_t32    shm_lpid; 
        unsigned short          shm_nattch;
};
                                                        
static inline int sunos_shmid_get(struct shmid_ds32 *user,
				  struct shmid_ds *kern)
{
	if(get_user(kern->shm_perm.key, &user->shm_perm.key)		||
	   __get_user(kern->shm_perm.uid, &user->shm_perm.uid)		||
	   __get_user(kern->shm_perm.gid, &user->shm_perm.gid)		||
	   __get_user(kern->shm_perm.cuid, &user->shm_perm.cuid)	||
	   __get_user(kern->shm_perm.cgid, &user->shm_perm.cgid)	||
	   __get_user(kern->shm_segsz, &user->shm_segsz)		||
	   __get_user(kern->shm_atime, &user->shm_atime)		||
	   __get_user(kern->shm_dtime, &user->shm_dtime)		||
	   __get_user(kern->shm_ctime, &user->shm_ctime)		||
	   __get_user(kern->shm_cpid, &user->shm_cpid)			||
	   __get_user(kern->shm_lpid, &user->shm_lpid)			||
	   __get_user(kern->shm_nattch, &user->shm_nattch))
		return -EFAULT;
	return 0;
}

static inline int sunos_shmid_put(struct shmid_ds32 *user,
				  struct shmid_ds *kern)
{
	if(put_user(kern->shm_perm.key, &user->shm_perm.key)		||
	   __put_user(kern->shm_perm.uid, &user->shm_perm.uid)		||
	   __put_user(kern->shm_perm.gid, &user->shm_perm.gid)		||
	   __put_user(kern->shm_perm.cuid, &user->shm_perm.cuid)	||
	   __put_user(kern->shm_perm.cgid, &user->shm_perm.cgid)	||
	   __put_user(kern->shm_segsz, &user->shm_segsz)		||
	   __put_user(kern->shm_atime, &user->shm_atime)		||
	   __put_user(kern->shm_dtime, &user->shm_dtime)		||
	   __put_user(kern->shm_ctime, &user->shm_ctime)		||
	   __put_user(kern->shm_cpid, &user->shm_cpid)			||
	   __put_user(kern->shm_lpid, &user->shm_lpid)			||
	   __put_user(kern->shm_nattch, &user->shm_nattch))
		return -EFAULT;
	return 0;
}

asmlinkage int sunos_shmsys(int op, u32 arg1, u32 arg2, u32 arg3)
{
	struct shmid_ds ksds;
	unsigned long raddr;
	mm_segment_t old_fs = get_fs();
	int rval;

	switch(op) {
	case 0:
		/* sys_shmat(): attach a shared memory area */
		rval = sys_shmat((int)arg1,(char *)A(arg2),(int)arg3,&raddr);
		if(!rval)
			rval = (int) raddr;
		break;
	case 1:
		/* sys_shmctl(): modify shared memory area attr. */
		if(!sunos_shmid_get((struct shmid_ds32 *)A(arg3), &ksds)) {
			set_fs(KERNEL_DS);
			rval = sys_shmctl((int)arg1,(int)arg2, &ksds);
			set_fs(old_fs);
			if(!rval)
				rval = sunos_shmid_put((struct shmid_ds32 *)A(arg3),
						       &ksds);
		} else
			rval = -EFAULT;
		break;
	case 2:
		/* sys_shmdt(): detach a shared memory area */
		rval = sys_shmdt((char *)A(arg1));
		break;
	case 3:
		/* sys_shmget(): get a shared memory area */
		rval = sys_shmget((key_t)arg1,(int)arg2,(int)arg3);
		break;
	default:
		rval = -EINVAL;
		break;
	};
	return rval;
}

extern asmlinkage long sparc32_open(const char * filename, int flags, int mode);

asmlinkage int sunos_open(u32 fname, int flags, int mode)
{
	const char *filename = (const char *)(long)fname;

	return sparc32_open(filename, flags, mode);
}

#define SUNOS_EWOULDBLOCK 35

/* see the sunos man page read(2v) for an explanation
   of this garbage. We use O_NDELAY to mark
   file descriptors that have been set non-blocking 
   using 4.2BSD style calls. (tridge) */

static inline int check_nonblock(int ret, int fd)
{
	if (ret == -EAGAIN) {
		struct file * file = fget(fd);
		if (file) {
			if (file->f_flags & O_NDELAY)
				ret = -SUNOS_EWOULDBLOCK;
			fput(file);
		}
	}
	return ret;
}

extern asmlinkage int sys_read(unsigned int fd, char *buf, unsigned long count);
extern asmlinkage int sys_write(unsigned int fd, char *buf, unsigned long count);
extern asmlinkage int sys_recv(int fd, void *ubuf, size_t size, unsigned flags);
extern asmlinkage int sys_send(int fd, void *buff, size_t len, unsigned flags);
extern asmlinkage int sys_accept(int fd, struct sockaddr *sa, int *addrlen);
extern asmlinkage int sys32_readv(u32 fd, u32 vector, s32 count);
extern asmlinkage int sys32_writev(u32 fd, u32 vector, s32 count);

asmlinkage int sunos_read(unsigned int fd, u32 buf, u32 count)
{
	int ret;

	ret = check_nonblock(sys_read(fd, (char *)A(buf), count), fd);
	return ret;
}

asmlinkage int sunos_readv(u32 fd, u32 vector, s32 count)
{
	int ret;

	ret = check_nonblock(sys32_readv(fd, vector, count), fd);
	return ret;
}

asmlinkage int sunos_write(unsigned int fd, u32 buf, u32 count)
{
	int ret;

	ret = check_nonblock(sys_write(fd, (char *)A(buf), count), fd);
	return ret;
}

asmlinkage int sunos_writev(u32 fd, u32 vector, s32 count)
{
	int ret;

	ret = check_nonblock(sys32_writev(fd, vector, count), fd);
	return ret;
}

asmlinkage int sunos_recv(int fd, u32 ubuf, int size, unsigned flags)
{
	int ret;

	ret = check_nonblock(sys_recv(fd, (void *)A(ubuf), size, flags), fd);
	return ret;
}

asmlinkage int sunos_send(int fd, u32 buff, int len, unsigned flags)
{
	int ret;

	ret = check_nonblock(sys_send(fd, (void *)A(buff), len, flags), fd);
	return ret;
}

extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
				     char *optval, int optlen);

asmlinkage int sunos_socket(int family, int type, int protocol)
{
	int ret, one = 1;

	ret = sys_socket(family, type, protocol);
	if (ret < 0)
		goto out;

	sys_setsockopt(ret, SOL_SOCKET, SO_BSDCOMPAT,
		       (char *)&one, sizeof(one));
out:
	return ret;
}

asmlinkage int sunos_accept(int fd, u32 sa, u32 addrlen)
{
	int ret, one = 1;

	while (1) {
		ret = check_nonblock(sys_accept(fd, (struct sockaddr *)A(sa),
						(int *)A(addrlen)), fd);
		if (ret != -ENETUNREACH && ret != -EHOSTUNREACH)
			break;
	}
	if (ret < 0)
		goto out;

	sys_setsockopt(ret, SOL_SOCKET, SO_BSDCOMPAT,
		       (char *)&one, sizeof(one));
out:
	return ret;
}

#define SUNOS_SV_INTERRUPT 2

asmlinkage int sunos_sigaction (int sig, u32 act, u32 oact)
{
	struct k_sigaction new_ka, old_ka;
	int ret;

	if (act) {
		old_sigset_t32 mask;

		if (get_user((long)new_ka.sa.sa_handler, &((struct old_sigaction32 *)A(act))->sa_handler) ||
		    __get_user(new_ka.sa.sa_flags, &((struct old_sigaction32 *)A(act))->sa_flags))
			return -EFAULT;
		__get_user(mask, &((struct old_sigaction32 *)A(act))->sa_mask);
		new_ka.sa.sa_restorer = NULL;
		new_ka.ka_restorer = NULL;
		siginitset(&new_ka.sa.sa_mask, mask);
		new_ka.sa.sa_flags ^= SUNOS_SV_INTERRUPT;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		old_ka.sa.sa_flags ^= SUNOS_SV_INTERRUPT;
		if (put_user((long)old_ka.sa.sa_handler, &((struct old_sigaction32 *)A(oact))->sa_handler) ||
		    __put_user(old_ka.sa.sa_flags, &((struct old_sigaction32 *)A(oact))->sa_flags))
			return -EFAULT;
		__put_user(old_ka.sa.sa_mask.sig[0], &((struct old_sigaction32 *)A(oact))->sa_mask);
	}

	return ret;
}

extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
				     char *optval, int optlen);
extern asmlinkage int sys32_getsockopt(int fd, int level, int optname,
				     u32 optval, u32 optlen);

asmlinkage int sunos_setsockopt(int fd, int level, int optname, u32 optval,
				int optlen)
{
	int tr_opt = optname;
	int ret;

	if (level == SOL_IP) {
		/* Multicast socketopts (ttl, membership) */
		if (tr_opt >=2 && tr_opt <= 6)
			tr_opt += 30;
	}
	ret = sys_setsockopt(fd, level, tr_opt, (char *)A(optval), optlen);
	return ret;
}

asmlinkage int sunos_getsockopt(int fd, int level, int optname,
				u32 optval, u32 optlen)
{
	int tr_opt = optname;
	int ret;

	if (level == SOL_IP) {
		/* Multicast socketopts (ttl, membership) */
		if (tr_opt >=2 && tr_opt <= 6)
			tr_opt += 30;
	}
	ret = sys32_getsockopt(fd, level, tr_opt, optval, optlen);
	return ret;
}