1 /* $Id: sys_sunos32.c,v 1.51 2000/07/06 01:41:29 davem Exp $
2 * sys_sunos32.c: SunOS binary compatability layer on sparc64.
4 * Copyright (C) 1995, 1996, 1997 David S. Miller (davem@caip.rutgers.edu)
5 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
7 * Based upon preliminary work which is:
9 * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu)
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/types.h>
15 #include <linux/mman.h>
17 #include <linux/swap.h>
19 #include <linux/file.h>
20 #include <linux/resource.h>
21 #include <linux/ipc.h>
22 #include <linux/shm.h>
23 #include <linux/msg.h>
24 #include <linux/sem.h>
25 #include <linux/signal.h>
26 #include <linux/uio.h>
27 #include <linux/utsname.h>
28 #include <linux/major.h>
29 #include <linux/stat.h>
30 #include <linux/malloc.h>
31 #include <linux/pagemap.h>
32 #include <linux/errno.h>
33 #include <linux/smp.h>
34 #include <linux/smp_lock.h>
36 #include <asm/uaccess.h>
38 #include <asm/pgtable.h>
39 #include <asm/pconf.h>
40 #include <asm/idprom.h> /* for gethostid() */
41 #include <asm/unistd.h>
42 #include <asm/system.h>
44 /* For the nfs mount emulation */
45 #include <linux/socket.h>
47 #include <linux/nfs.h>
48 #include <linux/nfs2.h>
49 #include <linux/nfs_mount.h>
51 /* for sunos_select */
52 #include <linux/time.h>
53 #include <linux/personality.h>
55 /* Use this to get at 32-bit user passed pointers. */
57 ({ unsigned long __ret; \
58 __asm__ ("srl %0, 0, %0" \
64 #define SUNOS_NR_OPEN 256
66 asmlinkage u32
sunos_mmap(u32 addr
, u32 len
, u32 prot
, u32 flags
, u32 fd
, u32 off
)
68 struct file
*file
= NULL
;
69 unsigned long retval
, ret_type
;
71 if(flags
& MAP_NORESERVE
) {
74 printk("%s: unimplemented SunOS MAP_NORESERVE mmap() flag\n",
76 flags
&= ~MAP_NORESERVE
;
79 if(!(flags
& MAP_ANONYMOUS
)) {
81 if(fd
>= SUNOS_NR_OPEN
)
86 inode
= file
->f_dentry
->d_inode
;
87 if(MAJOR(inode
->i_rdev
)==MEM_MAJOR
&& MINOR(inode
->i_rdev
)==5) {
88 flags
|= MAP_ANONYMOUS
;
95 if(!(flags
& MAP_FIXED
))
97 else if (len
> 0xf0000000 || addr
> 0xf0000000 - len
)
99 ret_type
= flags
& _MAP_NEW
;
102 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
103 down(¤t
->mm
->mmap_sem
);
104 retval
= do_mmap(file
,
105 (unsigned long) addr
, (unsigned long) len
,
106 (unsigned long) prot
, (unsigned long) flags
,
107 (unsigned long) off
);
108 up(¤t
->mm
->mmap_sem
);
110 retval
= ((retval
< 0xf0000000) ? 0 : retval
);
118 asmlinkage
int sunos_mctl(u32 addr
, u32 len
, int function
, u32 arg
)
123 asmlinkage
int sunos_brk(u32 baddr
)
125 int freepages
, retval
= -ENOMEM
;
127 unsigned long newbrk
, oldbrk
, brk
= (unsigned long) baddr
;
129 down(¤t
->mm
->mmap_sem
);
130 if (brk
< current
->mm
->end_code
)
132 newbrk
= PAGE_ALIGN(brk
);
133 oldbrk
= PAGE_ALIGN(current
->mm
->brk
);
135 if (oldbrk
== newbrk
) {
136 current
->mm
->brk
= brk
;
139 /* Always allow shrinking brk. */
140 if (brk
<= current
->mm
->brk
) {
141 current
->mm
->brk
= brk
;
142 do_munmap(current
->mm
, newbrk
, oldbrk
-newbrk
);
145 /* Check against rlimit and stack.. */
147 rlim
= current
->rlim
[RLIMIT_DATA
].rlim_cur
;
148 if (rlim
>= RLIM_INFINITY
)
150 if (brk
- current
->mm
->end_code
> rlim
)
152 /* Check against existing mmap mappings. */
153 if (find_vma_intersection(current
->mm
, oldbrk
, newbrk
+PAGE_SIZE
))
155 /* stupid algorithm to decide if we have enough memory: while
156 * simple, it hopefully works in most obvious cases.. Easy to
157 * fool it, but this should catch most mistakes.
159 freepages
= atomic_read(&buffermem_pages
) >> PAGE_SHIFT
;
160 freepages
+= atomic_read(&page_cache_size
);
162 freepages
+= nr_free_pages();
163 freepages
+= nr_swap_pages
;
164 freepages
-= num_physpages
>> 4;
165 freepages
-= (newbrk
-oldbrk
) >> PAGE_SHIFT
;
168 /* Ok, we have probably got enough memory - let it rip. */
169 current
->mm
->brk
= brk
;
170 do_brk(oldbrk
, newbrk
-oldbrk
);
173 up(¤t
->mm
->mmap_sem
);
177 asmlinkage u32
sunos_sbrk(int increment
)
181 /* This should do it hopefully... */
183 oldbrk
= (int)current
->mm
->brk
;
184 error
= sunos_brk(((int) current
->mm
->brk
) + increment
);
191 asmlinkage u32
sunos_sstk(int increment
)
194 printk("%s: Call to sunos_sstk(increment<%d>) is unsupported\n",
195 current
->comm
, increment
);
200 /* Give hints to the kernel as to what paging strategy to use...
201 * Completely bogus, don't remind me.
203 #define VA_NORMAL 0 /* Normal vm usage expected */
204 #define VA_ABNORMAL 1 /* Abnormal/random vm usage probable */
205 #define VA_SEQUENTIAL 2 /* Accesses will be of a sequential nature */
206 #define VA_INVALIDATE 3 /* Page table entries should be flushed ??? */
207 static char *vstrings
[] = {
214 asmlinkage
void sunos_vadvise(u32 strategy
)
216 /* I wanna see who uses this... */
218 printk("%s: Advises us to use %s paging strategy\n",
220 strategy
<= 3 ? vstrings
[strategy
] : "BOGUS");
224 /* This just wants the soft limit (ie. rlim_cur element) of the RLIMIT_NOFILE
225 * resource limit and is for backwards compatibility with older sunos
228 asmlinkage
int sunos_getdtablesize(void)
230 return SUNOS_NR_OPEN
;
234 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
236 asmlinkage u32
sunos_sigblock(u32 blk_mask
)
240 spin_lock_irq(¤t
->sigmask_lock
);
241 old
= (u32
) current
->blocked
.sig
[0];
242 current
->blocked
.sig
[0] |= (blk_mask
& _BLOCKABLE
);
243 recalc_sigpending(current
);
244 spin_unlock_irq(¤t
->sigmask_lock
);
248 asmlinkage u32
sunos_sigsetmask(u32 newmask
)
252 spin_lock_irq(¤t
->sigmask_lock
);
253 retval
= (u32
) current
->blocked
.sig
[0];
254 current
->blocked
.sig
[0] = (newmask
& _BLOCKABLE
);
255 recalc_sigpending(current
);
256 spin_unlock_irq(¤t
->sigmask_lock
);
260 /* SunOS getdents is very similar to the newer Linux (iBCS2 compliant) */
261 /* getdents system call, the format of the structure just has a different */
262 /* layout (d_off+d_ino instead of d_ino+d_off) */
263 struct sunos_dirent
{
271 struct sunos_dirent_callback
{
272 struct sunos_dirent
*curr
;
273 struct sunos_dirent
*previous
;
278 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
279 #define ROUND_UP(x) (((x)+sizeof(s32)-1) & ~(sizeof(s32)-1))
281 static int sunos_filldir(void * __buf
, const char * name
, int namlen
,
282 off_t offset
, ino_t ino
)
284 struct sunos_dirent
* dirent
;
285 struct sunos_dirent_callback
* buf
= (struct sunos_dirent_callback
*) __buf
;
286 int reclen
= ROUND_UP(NAME_OFFSET(dirent
) + namlen
+ 1);
288 buf
->error
= -EINVAL
; /* only used if we fail.. */
289 if (reclen
> buf
->count
)
291 dirent
= buf
->previous
;
293 put_user(offset
, &dirent
->d_off
);
295 buf
->previous
= dirent
;
296 put_user(ino
, &dirent
->d_ino
);
297 put_user(namlen
, &dirent
->d_namlen
);
298 put_user(reclen
, &dirent
->d_reclen
);
299 copy_to_user(dirent
->d_name
, name
, namlen
);
300 put_user(0, dirent
->d_name
+ namlen
);
301 ((char *) dirent
) += reclen
;
303 buf
->count
-= reclen
;
307 asmlinkage
int sunos_getdents(unsigned int fd
, u32 u_dirent
, int cnt
)
310 struct sunos_dirent
* lastdirent
;
311 struct sunos_dirent_callback buf
;
313 void *dirent
= (void *)A(u_dirent
);
315 if(fd
>= SUNOS_NR_OPEN
)
323 if(cnt
< (sizeof(struct sunos_dirent
) + 255))
326 buf
.curr
= (struct sunos_dirent
*) dirent
;
331 error
= vfs_readdir(file
, sunos_filldir
, &buf
);
335 lastdirent
= buf
.previous
;
338 put_user(file
->f_pos
, &lastdirent
->d_off
);
339 error
= cnt
- buf
.count
;
348 /* Old sunos getdirentries, severely broken compatibility stuff here. */
349 struct sunos_direntry
{
356 struct sunos_direntry_callback
{
357 struct sunos_direntry
*curr
;
358 struct sunos_direntry
*previous
;
363 static int sunos_filldirentry(void * __buf
, const char * name
, int namlen
,
364 off_t offset
, ino_t ino
)
366 struct sunos_direntry
* dirent
;
367 struct sunos_direntry_callback
* buf
= (struct sunos_direntry_callback
*) __buf
;
368 int reclen
= ROUND_UP(NAME_OFFSET(dirent
) + namlen
+ 1);
370 buf
->error
= -EINVAL
; /* only used if we fail.. */
371 if (reclen
> buf
->count
)
373 dirent
= buf
->previous
;
375 buf
->previous
= dirent
;
376 put_user(ino
, &dirent
->d_ino
);
377 put_user(namlen
, &dirent
->d_namlen
);
378 put_user(reclen
, &dirent
->d_reclen
);
379 copy_to_user(dirent
->d_name
, name
, namlen
);
380 put_user(0, dirent
->d_name
+ namlen
);
381 ((char *) dirent
) += reclen
;
383 buf
->count
-= reclen
;
387 asmlinkage
int sunos_getdirentries(unsigned int fd
, u32 u_dirent
,
388 int cnt
, u32 u_basep
)
390 void *dirent
= (void *) A(u_dirent
);
391 unsigned int *basep
= (unsigned int *)A(u_basep
);
393 struct sunos_direntry
* lastdirent
;
395 struct sunos_direntry_callback buf
;
397 if(fd
>= SUNOS_NR_OPEN
)
405 if(cnt
< (sizeof(struct sunos_direntry
) + 255))
408 buf
.curr
= (struct sunos_direntry
*) dirent
;
413 error
= vfs_readdir(file
, sunos_filldirentry
, &buf
);
417 lastdirent
= buf
.previous
;
420 put_user(file
->f_pos
, basep
);
421 error
= cnt
- buf
.count
;
430 struct sunos_utsname
{
439 asmlinkage
int sunos_uname(struct sunos_utsname
*name
)
444 ret
= copy_to_user(&name
->sname
[0], &system_utsname
.sysname
[0], sizeof(name
->sname
) - 1);
445 ret
|= copy_to_user(&name
->nname
[0], &system_utsname
.nodename
[0], sizeof(name
->nname
) - 1);
446 ret
|= put_user('\0', &name
->nname
[8]);
447 ret
|= copy_to_user(&name
->rel
[0], &system_utsname
.release
[0], sizeof(name
->rel
) - 1);
448 ret
|= copy_to_user(&name
->ver
[0], &system_utsname
.version
[0], sizeof(name
->ver
) - 1);
449 ret
|= copy_to_user(&name
->mach
[0], &system_utsname
.machine
[0], sizeof(name
->mach
) - 1);
454 asmlinkage
int sunos_nosys(void)
456 struct pt_regs
*regs
;
461 regs
= current
->thread
.kregs
;
462 info
.si_signo
= SIGSYS
;
464 info
.si_code
= __SI_FAULT
|0x100;
465 info
.si_addr
= (void *)regs
->tpc
;
466 info
.si_trapno
= regs
->u_regs
[UREG_G1
];
467 send_sig_info(SIGSYS
, &info
, current
);
469 printk("Process makes ni_syscall number %d, register dump:\n",
470 (int) regs
->u_regs
[UREG_G1
]);
477 /* This is not a real and complete implementation yet, just to keep
478 * the easy SunOS binaries happy.
480 asmlinkage
int sunos_fpathconf(int fd
, int name
)
504 case _PCONF_CHRESTRICT
: /* XXX Investigate XXX */
507 case _PCONF_NOTRUNC
: /* XXX Investigate XXX */
508 case _PCONF_VDISABLE
:
519 asmlinkage
int sunos_pathconf(u32 u_path
, int name
)
524 ret
= sunos_fpathconf(0, name
); /* XXX cheese XXX */
529 /* SunOS mount system call emulation */
530 extern asmlinkage
int
531 sys32_select(int n
, u32 inp
, u32 outp
, u32 exp
, u32 tvp
);
538 asmlinkage
int sunos_select(int width
, u32 inp
, u32 outp
, u32 exp
, u32 tvp_x
)
542 /* SunOS binaries expect that select won't change the tvp contents */
544 ret
= sys32_select (width
, inp
, outp
, exp
, tvp_x
);
545 if (ret
== -EINTR
&& tvp_x
) {
546 struct timeval32
*tvp
= (struct timeval32
*)A(tvp_x
);
549 __get_user(sec
, &tvp
->tv_sec
);
550 __get_user(usec
, &tvp
->tv_usec
);
551 if (sec
== 0 && usec
== 0)
558 asmlinkage
void sunos_nop(void)
563 /* XXXXXXXXXX SunOS mount/umount. XXXXXXXXXXX */
564 #define SMNT_RDONLY 1
565 #define SMNT_NOSUID 2
566 #define SMNT_NEWTYPE 4
568 #define SMNT_REMOUNT 16
569 #define SMNT_NOSUB 32
570 #define SMNT_MULTI 64
571 #define SMNT_SYS5 128
574 char fh_data
[NFS_FHSIZE
];
577 struct sunos_nfs_mount_args
{
578 struct sockaddr_in
*addr
; /* file server address */
579 struct nfs_fh
*fh
; /* File handle to be mounted */
580 int flags
; /* flags */
581 int wsize
; /* write size in bytes */
582 int rsize
; /* read size in bytes */
583 int timeo
; /* initial timeout in .1 secs */
584 int retrans
; /* times to retry send */
585 char *hostname
; /* server's hostname */
586 int acregmin
; /* attr cache file min secs */
587 int acregmax
; /* attr cache file max secs */
588 int acdirmin
; /* attr cache dir min secs */
589 int acdirmax
; /* attr cache dir max secs */
590 char *netname
; /* server's netname */
593 extern dev_t
get_unnamed_dev(void);
594 extern void put_unnamed_dev(dev_t
);
595 extern asmlinkage
int sys_mount(char *, char *, char *, unsigned long, void *);
596 extern asmlinkage
int sys_connect(int fd
, struct sockaddr
*uservaddr
, int addrlen
);
597 extern asmlinkage
int sys_socket(int family
, int type
, int protocol
);
598 extern asmlinkage
int sys_bind(int fd
, struct sockaddr
*umyaddr
, int addrlen
);
601 /* Bind the socket on a local reserved port and connect it to the
602 * remote server. This on Linux/i386 is done by the mount program,
605 /* XXXXXXXXXXXXXXXXXXXX */
607 sunos_nfs_get_server_fd (int fd
, struct sockaddr_in
*addr
)
609 struct sockaddr_in local
;
610 struct sockaddr_in server
;
613 struct socket
*socket
;
614 struct dentry
*dentry
;
622 dentry
= file
->f_dentry
;
623 inode
= dentry
->d_inode
;
625 socket
= &inode
->u
.socket_i
;
626 local
.sin_family
= AF_INET
;
627 local
.sin_addr
.s_addr
= INADDR_ANY
;
629 /* IPPORT_RESERVED = 1024, can't find the definition in the kernel */
632 local
.sin_port
= htons (--try_port
);
633 ret
= socket
->ops
->bind(socket
, (struct sockaddr
*)&local
,
635 } while (ret
&& try_port
> (1024 / 2));
642 server
.sin_family
= AF_INET
;
643 server
.sin_addr
= addr
->sin_addr
;
644 server
.sin_port
= NFS_PORT
;
646 /* Call sys_connect */
647 ret
= socket
->ops
->connect (socket
, (struct sockaddr
*) &server
,
648 sizeof (server
), file
->f_flags
);
655 /* XXXXXXXXXXXXXXXXXXXX */
656 static int get_default (int value
, int def_value
)
664 /* XXXXXXXXXXXXXXXXXXXX */
665 static int sunos_nfs_mount(char *dir_name
, int linux_flags
, void *data
)
669 struct nfs_mount_data linux_nfs_mount
;
670 struct sunos_nfs_mount_args sunos_mount
;
672 /* Ok, here comes the fun part: Linux's nfs mount needs a
673 * socket connection to the server, but SunOS mount does not
674 * require this, so we use the information on the destination
675 * address to create a socket and bind it to a reserved
676 * port on this system
678 if (copy_from_user(&sunos_mount
, data
, sizeof(sunos_mount
)))
681 server_fd
= sys_socket (AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
685 if (copy_from_user(&linux_nfs_mount
.addr
,sunos_mount
.addr
,
686 sizeof(*sunos_mount
.addr
)) ||
687 copy_from_user(&linux_nfs_mount
.root
,sunos_mount
.fh
,
688 sizeof(*sunos_mount
.fh
))) {
689 sys_close (server_fd
);
693 if (!sunos_nfs_get_server_fd (server_fd
, &linux_nfs_mount
.addr
)){
694 sys_close (server_fd
);
698 /* Now, bind it to a locally reserved port */
699 linux_nfs_mount
.version
= NFS_MOUNT_VERSION
;
700 linux_nfs_mount
.flags
= sunos_mount
.flags
;
701 linux_nfs_mount
.fd
= server_fd
;
703 linux_nfs_mount
.rsize
= get_default (sunos_mount
.rsize
, 8192);
704 linux_nfs_mount
.wsize
= get_default (sunos_mount
.wsize
, 8192);
705 linux_nfs_mount
.timeo
= get_default (sunos_mount
.timeo
, 10);
706 linux_nfs_mount
.retrans
= sunos_mount
.retrans
;
708 linux_nfs_mount
.acregmin
= sunos_mount
.acregmin
;
709 linux_nfs_mount
.acregmax
= sunos_mount
.acregmax
;
710 linux_nfs_mount
.acdirmin
= sunos_mount
.acdirmin
;
711 linux_nfs_mount
.acdirmax
= sunos_mount
.acdirmax
;
713 the_name
= getname(sunos_mount
.hostname
);
715 return PTR_ERR(the_name
);
717 strncpy (linux_nfs_mount
.hostname
, the_name
, 254);
718 linux_nfs_mount
.hostname
[255] = 0;
721 return do_mount ("", dir_name
, "nfs", linux_flags
, &linux_nfs_mount
);
724 /* XXXXXXXXXXXXXXXXXXXX */
726 sunos_mount(char *type
, char *dir
, int flags
, void *data
)
728 int linux_flags
= MS_MGC_MSK
; /* new semantics */
731 char *dir_page
, *type_page
;
733 if (!capable (CAP_SYS_ADMIN
))
736 /* We don't handle the integer fs type */
737 if ((flags
& SMNT_NEWTYPE
) == 0)
740 /* Do not allow for those flags we don't support */
741 if (flags
& (SMNT_GRPID
|SMNT_NOSUB
|SMNT_MULTI
|SMNT_SYS5
))
744 if(flags
& SMNT_REMOUNT
)
745 linux_flags
|= MS_REMOUNT
;
746 if(flags
& SMNT_RDONLY
)
747 linux_flags
|= MS_RDONLY
;
748 if(flags
& SMNT_NOSUID
)
749 linux_flags
|= MS_NOSUID
;
751 dir_page
= getname(dir
);
752 ret
= PTR_ERR(dir_page
);
753 if (IS_ERR(dir_page
))
756 type_page
= getname(type
);
757 ret
= PTR_ERR(type_page
);
758 if (IS_ERR(type_page
))
761 if(strcmp(type_page
, "ext2") == 0) {
762 dev_fname
= getname(data
);
763 } else if(strcmp(type_page
, "iso9660") == 0) {
764 dev_fname
= getname(data
);
765 } else if(strcmp(type_page
, "minix") == 0) {
766 dev_fname
= getname(data
);
767 } else if(strcmp(type_page
, "nfs") == 0) {
768 ret
= sunos_nfs_mount (dir_page
, flags
, data
);
770 } else if(strcmp(type_page
, "ufs") == 0) {
771 printk("Warning: UFS filesystem mounts unsupported.\n");
774 } else if(strcmp(type_page
, "proc")) {
778 ret
= PTR_ERR(dev_fname
);
779 if (IS_ERR(dev_fname
))
781 ret
= do_mount(dev_fname
, dir_page
, type_page
, linux_flags
, NULL
);
793 extern asmlinkage
int sys_setsid(void);
794 extern asmlinkage
int sys_setpgid(pid_t
, pid_t
);
796 asmlinkage
int sunos_setpgrp(pid_t pid
, pid_t pgid
)
802 if((!pid
|| pid
== current
->pid
) &&
807 ret
= sys_setpgid(pid
, pgid
);
814 extern asmlinkage
int sys32_wait4(__kernel_pid_t32 pid
,
815 u32 stat_addr
, int options
, u32 ru
);
817 asmlinkage
int sunos_wait4(__kernel_pid_t32 pid
, u32 stat_addr
, int options
, u32 ru
)
822 ret
= sys32_wait4((pid
? pid
: ((__kernel_pid_t32
)-1)),
823 stat_addr
, options
, ru
);
828 extern int kill_pg(int, int, int);
829 asmlinkage
int sunos_killpg(int pgrp
, int sig
)
834 ret
= kill_pg(pgrp
, sig
, 0);
839 asmlinkage
int sunos_audit(void)
842 printk ("sys_audit\n");
847 extern asmlinkage u32
sunos_gethostid(void)
852 ret
= (((u32
)idprom
->id_machtype
<< 24) | ((u32
)idprom
->id_sernum
));
857 /* sysconf options, for SunOS compatibility */
858 #define _SC_ARG_MAX 1
859 #define _SC_CHILD_MAX 2
860 #define _SC_CLK_TCK 3
861 #define _SC_NGROUPS_MAX 4
862 #define _SC_OPEN_MAX 5
863 #define _SC_JOB_CONTROL 6
864 #define _SC_SAVED_IDS 7
865 #define _SC_VERSION 8
867 extern asmlinkage s32
sunos_sysconf (int name
)
882 case _SC_NGROUPS_MAX
:
888 case _SC_JOB_CONTROL
:
889 ret
= 1; /* yes, we do support job control */
892 ret
= 1; /* yes, we do support saved uids */
895 /* mhm, POSIX_VERSION is in /usr/include/unistd.h
896 * should it go on /usr/include/linux?
908 asmlinkage
int sunos_semsys(int op
, u32 arg1
, u32 arg2
, u32 arg3
, u32 ptr
)
916 /* Most arguments match on a 1:1 basis but cmd doesn't */
934 arg4
.__pad
=(void *)A(ptr
); /* value to modify semaphore to */
935 ret
= sys_semctl((int)arg1
, (int)arg2
, (int)arg3
, arg4
);
939 ret
= sys_semget((key_t
)arg1
, (int)arg2
, (int)arg3
);
943 ret
= sys_semop((int)arg1
, (struct sembuf
*)A(arg2
), (unsigned)arg3
);
961 __kernel_uid_t32 uid
;
962 __kernel_gid_t32 gid
;
963 __kernel_uid_t32 cuid
;
964 __kernel_gid_t32 cgid
;
965 __kernel_mode_t32 mode
;
971 struct ipc_perm32 msg_perm
;
974 __kernel_time_t32 msg_stime
;
975 __kernel_time_t32 msg_rtime
;
976 __kernel_time_t32 msg_ctime
;
979 unsigned short msg_cbytes
;
980 unsigned short msg_qnum
;
981 unsigned short msg_qbytes
;
982 __kernel_ipc_pid_t32 msg_lspid
;
983 __kernel_ipc_pid_t32 msg_lrpid
;
986 static inline int sunos_msqid_get(struct msqid_ds32
*user
,
987 struct msqid_ds
*kern
)
989 if(get_user(kern
->msg_perm
.key
, &user
->msg_perm
.key
) ||
990 __get_user(kern
->msg_perm
.uid
, &user
->msg_perm
.uid
) ||
991 __get_user(kern
->msg_perm
.gid
, &user
->msg_perm
.gid
) ||
992 __get_user(kern
->msg_perm
.cuid
, &user
->msg_perm
.cuid
) ||
993 __get_user(kern
->msg_perm
.cgid
, &user
->msg_perm
.cgid
) ||
994 __get_user(kern
->msg_stime
, &user
->msg_stime
) ||
995 __get_user(kern
->msg_rtime
, &user
->msg_rtime
) ||
996 __get_user(kern
->msg_ctime
, &user
->msg_ctime
) ||
997 __get_user(kern
->msg_ctime
, &user
->msg_cbytes
) ||
998 __get_user(kern
->msg_ctime
, &user
->msg_qnum
) ||
999 __get_user(kern
->msg_ctime
, &user
->msg_qbytes
) ||
1000 __get_user(kern
->msg_ctime
, &user
->msg_lspid
) ||
1001 __get_user(kern
->msg_ctime
, &user
->msg_lrpid
))
1006 static inline int sunos_msqid_put(struct msqid_ds32
*user
,
1007 struct msqid_ds
*kern
)
1009 if(put_user(kern
->msg_perm
.key
, &user
->msg_perm
.key
) ||
1010 __put_user(kern
->msg_perm
.uid
, &user
->msg_perm
.uid
) ||
1011 __put_user(kern
->msg_perm
.gid
, &user
->msg_perm
.gid
) ||
1012 __put_user(kern
->msg_perm
.cuid
, &user
->msg_perm
.cuid
) ||
1013 __put_user(kern
->msg_perm
.cgid
, &user
->msg_perm
.cgid
) ||
1014 __put_user(kern
->msg_stime
, &user
->msg_stime
) ||
1015 __put_user(kern
->msg_rtime
, &user
->msg_rtime
) ||
1016 __put_user(kern
->msg_ctime
, &user
->msg_ctime
) ||
1017 __put_user(kern
->msg_ctime
, &user
->msg_cbytes
) ||
1018 __put_user(kern
->msg_ctime
, &user
->msg_qnum
) ||
1019 __put_user(kern
->msg_ctime
, &user
->msg_qbytes
) ||
1020 __put_user(kern
->msg_ctime
, &user
->msg_lspid
) ||
1021 __put_user(kern
->msg_ctime
, &user
->msg_lrpid
))
1026 static inline int sunos_msgbuf_get(struct msgbuf32
*user
, struct msgbuf
*kern
, int len
)
1028 if(get_user(kern
->mtype
, &user
->mtype
) ||
1029 __copy_from_user(kern
->mtext
, &user
->mtext
, len
))
1034 static inline int sunos_msgbuf_put(struct msgbuf32
*user
, struct msgbuf
*kern
, int len
)
1036 if(put_user(kern
->mtype
, &user
->mtype
) ||
1037 __copy_to_user(user
->mtext
, kern
->mtext
, len
))
1042 asmlinkage
int sunos_msgsys(int op
, u32 arg1
, u32 arg2
, u32 arg3
, u32 arg4
)
1044 struct sparc_stackf32
*sp
;
1045 struct msqid_ds kds
;
1046 struct msgbuf
*kmbuf
;
1047 mm_segment_t old_fs
= get_fs();
1054 rval
= sys_msgget((key_t
)arg1
, (int)arg2
);
1057 if(!sunos_msqid_get((struct msqid_ds32
*)A(arg3
), &kds
)) {
1059 rval
= sys_msgctl((int)arg1
, (int)arg2
,
1060 (struct msqid_ds
*)A(arg3
));
1063 rval
= sunos_msqid_put((struct msqid_ds32
*)A(arg3
),
1070 kmbuf
= (struct msgbuf
*)kmalloc(sizeof(struct msgbuf
) + arg3
,
1074 sp
= (struct sparc_stackf32
*)
1075 (current
->thread
.kregs
->u_regs
[UREG_FP
] & 0xffffffffUL
);
1076 if(get_user(arg5
, &sp
->xxargs
[0])) {
1081 rval
= sys_msgrcv((int)arg1
, kmbuf
, (size_t)arg3
,
1082 (long)arg4
, (int)arg5
);
1085 rval
= sunos_msgbuf_put((struct msgbuf32
*)A(arg2
),
1091 kmbuf
= (struct msgbuf
*)kmalloc(sizeof(struct msgbuf
) + arg3
,
1093 if(!kmbuf
|| sunos_msgbuf_get((struct msgbuf32
*)A(arg2
),
1097 rval
= sys_msgsnd((int)arg1
, kmbuf
, (size_t)arg3
, (int)arg4
);
1110 struct ipc_perm32 shm_perm
;
1112 __kernel_time_t32 shm_atime
;
1113 __kernel_time_t32 shm_dtime
;
1114 __kernel_time_t32 shm_ctime
;
1115 __kernel_ipc_pid_t32 shm_cpid
;
1116 __kernel_ipc_pid_t32 shm_lpid
;
1117 unsigned short shm_nattch
;
1120 static inline int sunos_shmid_get(struct shmid_ds32
*user
,
1121 struct shmid_ds
*kern
)
1123 if(get_user(kern
->shm_perm
.key
, &user
->shm_perm
.key
) ||
1124 __get_user(kern
->shm_perm
.uid
, &user
->shm_perm
.uid
) ||
1125 __get_user(kern
->shm_perm
.gid
, &user
->shm_perm
.gid
) ||
1126 __get_user(kern
->shm_perm
.cuid
, &user
->shm_perm
.cuid
) ||
1127 __get_user(kern
->shm_perm
.cgid
, &user
->shm_perm
.cgid
) ||
1128 __get_user(kern
->shm_segsz
, &user
->shm_segsz
) ||
1129 __get_user(kern
->shm_atime
, &user
->shm_atime
) ||
1130 __get_user(kern
->shm_dtime
, &user
->shm_dtime
) ||
1131 __get_user(kern
->shm_ctime
, &user
->shm_ctime
) ||
1132 __get_user(kern
->shm_cpid
, &user
->shm_cpid
) ||
1133 __get_user(kern
->shm_lpid
, &user
->shm_lpid
) ||
1134 __get_user(kern
->shm_nattch
, &user
->shm_nattch
))
1139 static inline int sunos_shmid_put(struct shmid_ds32
*user
,
1140 struct shmid_ds
*kern
)
1142 if(put_user(kern
->shm_perm
.key
, &user
->shm_perm
.key
) ||
1143 __put_user(kern
->shm_perm
.uid
, &user
->shm_perm
.uid
) ||
1144 __put_user(kern
->shm_perm
.gid
, &user
->shm_perm
.gid
) ||
1145 __put_user(kern
->shm_perm
.cuid
, &user
->shm_perm
.cuid
) ||
1146 __put_user(kern
->shm_perm
.cgid
, &user
->shm_perm
.cgid
) ||
1147 __put_user(kern
->shm_segsz
, &user
->shm_segsz
) ||
1148 __put_user(kern
->shm_atime
, &user
->shm_atime
) ||
1149 __put_user(kern
->shm_dtime
, &user
->shm_dtime
) ||
1150 __put_user(kern
->shm_ctime
, &user
->shm_ctime
) ||
1151 __put_user(kern
->shm_cpid
, &user
->shm_cpid
) ||
1152 __put_user(kern
->shm_lpid
, &user
->shm_lpid
) ||
1153 __put_user(kern
->shm_nattch
, &user
->shm_nattch
))
1158 asmlinkage
int sunos_shmsys(int op
, u32 arg1
, u32 arg2
, u32 arg3
)
1160 struct shmid_ds ksds
;
1161 unsigned long raddr
;
1162 mm_segment_t old_fs
= get_fs();
1168 /* sys_shmat(): attach a shared memory area */
1169 rval
= sys_shmat((int)arg1
,(char *)A(arg2
),(int)arg3
,&raddr
);
1174 /* sys_shmctl(): modify shared memory area attr. */
1175 if(!sunos_shmid_get((struct shmid_ds32
*)A(arg3
), &ksds
)) {
1177 rval
= sys_shmctl((int)arg1
,(int)arg2
, &ksds
);
1180 rval
= sunos_shmid_put((struct shmid_ds32
*)A(arg3
),
1186 /* sys_shmdt(): detach a shared memory area */
1187 rval
= sys_shmdt((char *)A(arg1
));
1190 /* sys_shmget(): get a shared memory area */
1191 rval
= sys_shmget((key_t
)arg1
,(int)arg2
,(int)arg3
);
1201 extern asmlinkage
long sparc32_open(const char * filename
, int flags
, int mode
);
1203 asmlinkage
int sunos_open(u32 fname
, int flags
, int mode
)
1205 const char *filename
= (const char *)(long)fname
;
1207 return sparc32_open(filename
, flags
, mode
);
1210 #define SUNOS_EWOULDBLOCK 35
1212 /* see the sunos man page read(2v) for an explanation
1213 of this garbage. We use O_NDELAY to mark
1214 file descriptors that have been set non-blocking
1215 using 4.2BSD style calls. (tridge) */
1217 static inline int check_nonblock(int ret
, int fd
)
1219 if (ret
== -EAGAIN
) {
1220 struct file
* file
= fcheck(fd
);
1221 if (file
&& (file
->f_flags
& O_NDELAY
))
1222 ret
= -SUNOS_EWOULDBLOCK
;
1227 extern asmlinkage
int sys_read(unsigned int fd
, char *buf
, unsigned long count
);
1228 extern asmlinkage
int sys_write(unsigned int fd
, char *buf
, unsigned long count
);
1229 extern asmlinkage
int sys_recv(int fd
, void *ubuf
, size_t size
, unsigned flags
);
1230 extern asmlinkage
int sys_send(int fd
, void *buff
, size_t len
, unsigned flags
);
1231 extern asmlinkage
int sys_accept(int fd
, struct sockaddr
*sa
, int *addrlen
);
1232 extern asmlinkage
int sys32_readv(u32 fd
, u32 vector
, s32 count
);
1233 extern asmlinkage
int sys32_writev(u32 fd
, u32 vector
, s32 count
);
1235 asmlinkage
int sunos_read(unsigned int fd
, u32 buf
, u32 count
)
1240 ret
= check_nonblock(sys_read(fd
, (char *)A(buf
), count
), fd
);
1245 asmlinkage
int sunos_readv(u32 fd
, u32 vector
, s32 count
)
1250 ret
= check_nonblock(sys32_readv(fd
, vector
, count
), fd
);
1255 asmlinkage
int sunos_write(unsigned int fd
, u32 buf
, u32 count
)
1260 ret
= check_nonblock(sys_write(fd
, (char *)A(buf
), count
), fd
);
1265 asmlinkage
int sunos_writev(u32 fd
, u32 vector
, s32 count
)
1270 ret
= check_nonblock(sys32_writev(fd
, vector
, count
), fd
);
1275 asmlinkage
int sunos_recv(int fd
, u32 ubuf
, int size
, unsigned flags
)
1280 ret
= check_nonblock(sys_recv(fd
, (void *)A(ubuf
), size
, flags
), fd
);
1285 asmlinkage
int sunos_send(int fd
, u32 buff
, int len
, unsigned flags
)
1290 ret
= check_nonblock(sys_send(fd
, (void *)A(buff
), len
, flags
), fd
);
1295 extern asmlinkage
int sys_setsockopt(int fd
, int level
, int optname
,
1296 char *optval
, int optlen
);
1298 asmlinkage
int sunos_socket(int family
, int type
, int protocol
)
1303 ret
= sys_socket(family
, type
, protocol
);
1307 sys_setsockopt(ret
, SOL_SOCKET
, SO_BSDCOMPAT
,
1308 (char *)&one
, sizeof(one
));
1314 asmlinkage
int sunos_accept(int fd
, u32 sa
, u32 addrlen
)
1320 ret
= check_nonblock(sys_accept(fd
, (struct sockaddr
*)A(sa
),
1321 (int *)A(addrlen
)), fd
);
1322 if (ret
!= -ENETUNREACH
&& ret
!= -EHOSTUNREACH
)
1328 sys_setsockopt(ret
, SOL_SOCKET
, SO_BSDCOMPAT
,
1329 (char *)&one
, sizeof(one
));
1335 #define SUNOS_SV_INTERRUPT 2
1337 asmlinkage
int sunos_sigaction (int sig
, u32 act
, u32 oact
)
1339 struct k_sigaction new_ka
, old_ka
;
1343 old_sigset_t32 mask
;
1345 if (get_user((long)new_ka
.sa
.sa_handler
, &((struct old_sigaction32
*)A(act
))->sa_handler
) ||
1346 __get_user(new_ka
.sa
.sa_flags
, &((struct old_sigaction32
*)A(act
))->sa_flags
))
1348 __get_user(mask
, &((struct old_sigaction32
*)A(act
))->sa_mask
);
1349 new_ka
.sa
.sa_restorer
= NULL
;
1350 new_ka
.ka_restorer
= NULL
;
1351 siginitset(&new_ka
.sa
.sa_mask
, mask
);
1352 new_ka
.sa
.sa_flags
^= SUNOS_SV_INTERRUPT
;
1355 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
1358 old_ka
.sa
.sa_flags
^= SUNOS_SV_INTERRUPT
;
1359 if (put_user((long)old_ka
.sa
.sa_handler
, &((struct old_sigaction32
*)A(oact
))->sa_handler
) ||
1360 __put_user(old_ka
.sa
.sa_flags
, &((struct old_sigaction32
*)A(oact
))->sa_flags
))
1362 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &((struct old_sigaction32
*)A(oact
))->sa_mask
);
1368 extern asmlinkage
int sys_setsockopt(int fd
, int level
, int optname
,
1369 char *optval
, int optlen
);
1370 extern asmlinkage
int sys32_getsockopt(int fd
, int level
, int optname
,
1371 u32 optval
, u32 optlen
);
1373 asmlinkage
int sunos_setsockopt(int fd
, int level
, int optname
, u32 optval
,
1376 int tr_opt
= optname
;
1380 if (level
== SOL_IP
) {
1381 /* Multicast socketopts (ttl, membership) */
1382 if (tr_opt
>=2 && tr_opt
<= 6)
1385 ret
= sys_setsockopt(fd
, level
, tr_opt
, (char *)A(optval
), optlen
);
1390 asmlinkage
int sunos_getsockopt(int fd
, int level
, int optname
,
1391 u32 optval
, u32 optlen
)
1393 int tr_opt
= optname
;
1397 if (level
== SOL_IP
) {
1398 /* Multicast socketopts (ttl, membership) */
1399 if (tr_opt
>=2 && tr_opt
<= 6)
1402 ret
= sys32_getsockopt(fd
, level
, tr_opt
, optval
, optlen
);