1 /* $Id: sys_sunos32.c,v 1.55 2000/11/18 02:10:59 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... */
182 oldbrk
= (int)current
->mm
->brk
;
183 error
= sunos_brk(((int) current
->mm
->brk
) + increment
);
189 asmlinkage u32
sunos_sstk(int increment
)
191 printk("%s: Call to sunos_sstk(increment<%d>) is unsupported\n",
192 current
->comm
, increment
);
197 /* Give hints to the kernel as to what paging strategy to use...
198 * Completely bogus, don't remind me.
200 #define VA_NORMAL 0 /* Normal vm usage expected */
201 #define VA_ABNORMAL 1 /* Abnormal/random vm usage probable */
202 #define VA_SEQUENTIAL 2 /* Accesses will be of a sequential nature */
203 #define VA_INVALIDATE 3 /* Page table entries should be flushed ??? */
204 static char *vstrings
[] = {
211 asmlinkage
void sunos_vadvise(u32 strategy
)
213 static int count
= 0;
215 /* I wanna see who uses this... */
217 printk("%s: Advises us to use %s paging strategy\n",
219 strategy
<= 3 ? vstrings
[strategy
] : "BOGUS");
222 /* This just wants the soft limit (ie. rlim_cur element) of the RLIMIT_NOFILE
223 * resource limit and is for backwards compatibility with older sunos
226 asmlinkage
int sunos_getdtablesize(void)
228 return SUNOS_NR_OPEN
;
232 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
234 asmlinkage u32
sunos_sigblock(u32 blk_mask
)
238 spin_lock_irq(¤t
->sigmask_lock
);
239 old
= (u32
) current
->blocked
.sig
[0];
240 current
->blocked
.sig
[0] |= (blk_mask
& _BLOCKABLE
);
241 recalc_sigpending(current
);
242 spin_unlock_irq(¤t
->sigmask_lock
);
246 asmlinkage u32
sunos_sigsetmask(u32 newmask
)
250 spin_lock_irq(¤t
->sigmask_lock
);
251 retval
= (u32
) current
->blocked
.sig
[0];
252 current
->blocked
.sig
[0] = (newmask
& _BLOCKABLE
);
253 recalc_sigpending(current
);
254 spin_unlock_irq(¤t
->sigmask_lock
);
258 /* SunOS getdents is very similar to the newer Linux (iBCS2 compliant) */
259 /* getdents system call, the format of the structure just has a different */
260 /* layout (d_off+d_ino instead of d_ino+d_off) */
261 struct sunos_dirent
{
269 struct sunos_dirent_callback
{
270 struct sunos_dirent
*curr
;
271 struct sunos_dirent
*previous
;
276 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
277 #define ROUND_UP(x) (((x)+sizeof(s32)-1) & ~(sizeof(s32)-1))
279 static int sunos_filldir(void * __buf
, const char * name
, int namlen
,
280 off_t offset
, ino_t ino
, unsigned int d_type
)
282 struct sunos_dirent
* dirent
;
283 struct sunos_dirent_callback
* buf
= (struct sunos_dirent_callback
*) __buf
;
284 int reclen
= ROUND_UP(NAME_OFFSET(dirent
) + namlen
+ 1);
286 buf
->error
= -EINVAL
; /* only used if we fail.. */
287 if (reclen
> buf
->count
)
289 dirent
= buf
->previous
;
291 put_user(offset
, &dirent
->d_off
);
293 buf
->previous
= dirent
;
294 put_user(ino
, &dirent
->d_ino
);
295 put_user(namlen
, &dirent
->d_namlen
);
296 put_user(reclen
, &dirent
->d_reclen
);
297 copy_to_user(dirent
->d_name
, name
, namlen
);
298 put_user(0, dirent
->d_name
+ namlen
);
299 ((char *) dirent
) += reclen
;
301 buf
->count
-= reclen
;
305 asmlinkage
int sunos_getdents(unsigned int fd
, u32 u_dirent
, int cnt
)
308 struct sunos_dirent
* lastdirent
;
309 struct sunos_dirent_callback buf
;
311 void *dirent
= (void *)A(u_dirent
);
313 if(fd
>= SUNOS_NR_OPEN
)
321 if(cnt
< (sizeof(struct sunos_dirent
) + 255))
324 buf
.curr
= (struct sunos_dirent
*) dirent
;
329 error
= vfs_readdir(file
, sunos_filldir
, &buf
);
333 lastdirent
= buf
.previous
;
336 put_user(file
->f_pos
, &lastdirent
->d_off
);
337 error
= cnt
- buf
.count
;
346 /* Old sunos getdirentries, severely broken compatibility stuff here. */
347 struct sunos_direntry
{
354 struct sunos_direntry_callback
{
355 struct sunos_direntry
*curr
;
356 struct sunos_direntry
*previous
;
361 static int sunos_filldirentry(void * __buf
, const char * name
, int namlen
,
362 off_t offset
, ino_t ino
, unsigned int d_type
)
364 struct sunos_direntry
* dirent
;
365 struct sunos_direntry_callback
* buf
= (struct sunos_direntry_callback
*) __buf
;
366 int reclen
= ROUND_UP(NAME_OFFSET(dirent
) + namlen
+ 1);
368 buf
->error
= -EINVAL
; /* only used if we fail.. */
369 if (reclen
> buf
->count
)
371 dirent
= buf
->previous
;
373 buf
->previous
= dirent
;
374 put_user(ino
, &dirent
->d_ino
);
375 put_user(namlen
, &dirent
->d_namlen
);
376 put_user(reclen
, &dirent
->d_reclen
);
377 copy_to_user(dirent
->d_name
, name
, namlen
);
378 put_user(0, dirent
->d_name
+ namlen
);
379 ((char *) dirent
) += reclen
;
381 buf
->count
-= reclen
;
385 asmlinkage
int sunos_getdirentries(unsigned int fd
, u32 u_dirent
,
386 int cnt
, u32 u_basep
)
388 void *dirent
= (void *) A(u_dirent
);
389 unsigned int *basep
= (unsigned int *)A(u_basep
);
391 struct sunos_direntry
* lastdirent
;
393 struct sunos_direntry_callback buf
;
395 if(fd
>= SUNOS_NR_OPEN
)
403 if(cnt
< (sizeof(struct sunos_direntry
) + 255))
406 buf
.curr
= (struct sunos_direntry
*) dirent
;
411 error
= vfs_readdir(file
, sunos_filldirentry
, &buf
);
415 lastdirent
= buf
.previous
;
418 put_user(file
->f_pos
, basep
);
419 error
= cnt
- buf
.count
;
428 struct sunos_utsname
{
437 asmlinkage
int sunos_uname(struct sunos_utsname
*name
)
442 ret
= copy_to_user(&name
->sname
[0], &system_utsname
.sysname
[0], sizeof(name
->sname
) - 1);
443 ret
|= copy_to_user(&name
->nname
[0], &system_utsname
.nodename
[0], sizeof(name
->nname
) - 1);
444 ret
|= put_user('\0', &name
->nname
[8]);
445 ret
|= copy_to_user(&name
->rel
[0], &system_utsname
.release
[0], sizeof(name
->rel
) - 1);
446 ret
|= copy_to_user(&name
->ver
[0], &system_utsname
.version
[0], sizeof(name
->ver
) - 1);
447 ret
|= copy_to_user(&name
->mach
[0], &system_utsname
.machine
[0], sizeof(name
->mach
) - 1);
452 asmlinkage
int sunos_nosys(void)
454 struct pt_regs
*regs
;
458 regs
= current
->thread
.kregs
;
459 info
.si_signo
= SIGSYS
;
461 info
.si_code
= __SI_FAULT
|0x100;
462 info
.si_addr
= (void *)regs
->tpc
;
463 info
.si_trapno
= regs
->u_regs
[UREG_G1
];
464 send_sig_info(SIGSYS
, &info
, current
);
466 printk("Process makes ni_syscall number %d, register dump:\n",
467 (int) regs
->u_regs
[UREG_G1
]);
473 /* This is not a real and complete implementation yet, just to keep
474 * the easy SunOS binaries happy.
476 asmlinkage
int sunos_fpathconf(int fd
, int name
)
499 case _PCONF_CHRESTRICT
: /* XXX Investigate XXX */
502 case _PCONF_NOTRUNC
: /* XXX Investigate XXX */
503 case _PCONF_VDISABLE
:
513 asmlinkage
int sunos_pathconf(u32 u_path
, int name
)
517 ret
= sunos_fpathconf(0, name
); /* XXX cheese XXX */
521 /* SunOS mount system call emulation */
522 extern asmlinkage
int
523 sys32_select(int n
, u32 inp
, u32 outp
, u32 exp
, u32 tvp
);
530 asmlinkage
int sunos_select(int width
, u32 inp
, u32 outp
, u32 exp
, u32 tvp_x
)
534 /* SunOS binaries expect that select won't change the tvp contents */
535 ret
= sys32_select (width
, inp
, outp
, exp
, tvp_x
);
536 if (ret
== -EINTR
&& tvp_x
) {
537 struct timeval32
*tvp
= (struct timeval32
*)A(tvp_x
);
540 __get_user(sec
, &tvp
->tv_sec
);
541 __get_user(usec
, &tvp
->tv_usec
);
542 if (sec
== 0 && usec
== 0)
548 asmlinkage
void sunos_nop(void)
553 /* XXXXXXXXXX SunOS mount/umount. XXXXXXXXXXX */
554 #define SMNT_RDONLY 1
555 #define SMNT_NOSUID 2
556 #define SMNT_NEWTYPE 4
558 #define SMNT_REMOUNT 16
559 #define SMNT_NOSUB 32
560 #define SMNT_MULTI 64
561 #define SMNT_SYS5 128
564 char fh_data
[NFS_FHSIZE
];
567 struct sunos_nfs_mount_args
{
568 struct sockaddr_in
*addr
; /* file server address */
569 struct nfs_fh
*fh
; /* File handle to be mounted */
570 int flags
; /* flags */
571 int wsize
; /* write size in bytes */
572 int rsize
; /* read size in bytes */
573 int timeo
; /* initial timeout in .1 secs */
574 int retrans
; /* times to retry send */
575 char *hostname
; /* server's hostname */
576 int acregmin
; /* attr cache file min secs */
577 int acregmax
; /* attr cache file max secs */
578 int acdirmin
; /* attr cache dir min secs */
579 int acdirmax
; /* attr cache dir max secs */
580 char *netname
; /* server's netname */
583 extern dev_t
get_unnamed_dev(void);
584 extern void put_unnamed_dev(dev_t
);
585 extern asmlinkage
int sys_mount(char *, char *, char *, unsigned long, void *);
586 extern asmlinkage
int sys_connect(int fd
, struct sockaddr
*uservaddr
, int addrlen
);
587 extern asmlinkage
int sys_socket(int family
, int type
, int protocol
);
588 extern asmlinkage
int sys_bind(int fd
, struct sockaddr
*umyaddr
, int addrlen
);
591 /* Bind the socket on a local reserved port and connect it to the
592 * remote server. This on Linux/i386 is done by the mount program,
595 /* XXXXXXXXXXXXXXXXXXXX */
597 sunos_nfs_get_server_fd (int fd
, struct sockaddr_in
*addr
)
599 struct sockaddr_in local
;
600 struct sockaddr_in server
;
603 struct socket
*socket
;
611 inode
= file
->f_dentry
->d_inode
;
613 socket
= &inode
->u
.socket_i
;
614 local
.sin_family
= AF_INET
;
615 local
.sin_addr
.s_addr
= INADDR_ANY
;
617 /* IPPORT_RESERVED = 1024, can't find the definition in the kernel */
620 local
.sin_port
= htons (--try_port
);
621 ret
= socket
->ops
->bind(socket
, (struct sockaddr
*)&local
,
623 } while (ret
&& try_port
> (1024 / 2));
630 server
.sin_family
= AF_INET
;
631 server
.sin_addr
= addr
->sin_addr
;
632 server
.sin_port
= NFS_PORT
;
634 /* Call sys_connect */
635 ret
= socket
->ops
->connect (socket
, (struct sockaddr
*) &server
,
636 sizeof (server
), file
->f_flags
);
643 /* XXXXXXXXXXXXXXXXXXXX */
644 static int get_default (int value
, int def_value
)
652 /* XXXXXXXXXXXXXXXXXXXX */
653 static int sunos_nfs_mount(char *dir_name
, int linux_flags
, void *data
)
657 struct nfs_mount_data linux_nfs_mount
;
658 struct sunos_nfs_mount_args sunos_mount
;
660 /* Ok, here comes the fun part: Linux's nfs mount needs a
661 * socket connection to the server, but SunOS mount does not
662 * require this, so we use the information on the destination
663 * address to create a socket and bind it to a reserved
664 * port on this system
666 if (copy_from_user(&sunos_mount
, data
, sizeof(sunos_mount
)))
669 server_fd
= sys_socket (AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
673 if (copy_from_user(&linux_nfs_mount
.addr
,sunos_mount
.addr
,
674 sizeof(*sunos_mount
.addr
)) ||
675 copy_from_user(&linux_nfs_mount
.root
,sunos_mount
.fh
,
676 sizeof(*sunos_mount
.fh
))) {
677 sys_close (server_fd
);
681 if (!sunos_nfs_get_server_fd (server_fd
, &linux_nfs_mount
.addr
)){
682 sys_close (server_fd
);
686 /* Now, bind it to a locally reserved port */
687 linux_nfs_mount
.version
= NFS_MOUNT_VERSION
;
688 linux_nfs_mount
.flags
= sunos_mount
.flags
;
689 linux_nfs_mount
.fd
= server_fd
;
691 linux_nfs_mount
.rsize
= get_default (sunos_mount
.rsize
, 8192);
692 linux_nfs_mount
.wsize
= get_default (sunos_mount
.wsize
, 8192);
693 linux_nfs_mount
.timeo
= get_default (sunos_mount
.timeo
, 10);
694 linux_nfs_mount
.retrans
= sunos_mount
.retrans
;
696 linux_nfs_mount
.acregmin
= sunos_mount
.acregmin
;
697 linux_nfs_mount
.acregmax
= sunos_mount
.acregmax
;
698 linux_nfs_mount
.acdirmin
= sunos_mount
.acdirmin
;
699 linux_nfs_mount
.acdirmax
= sunos_mount
.acdirmax
;
701 the_name
= getname(sunos_mount
.hostname
);
703 return PTR_ERR(the_name
);
705 strncpy (linux_nfs_mount
.hostname
, the_name
, 254);
706 linux_nfs_mount
.hostname
[255] = 0;
709 return do_mount ("", dir_name
, "nfs", linux_flags
, &linux_nfs_mount
);
712 /* XXXXXXXXXXXXXXXXXXXX */
714 sunos_mount(char *type
, char *dir
, int flags
, void *data
)
716 int linux_flags
= MS_MGC_MSK
; /* new semantics */
719 char *dir_page
, *type_page
;
721 if (!capable (CAP_SYS_ADMIN
))
724 /* We don't handle the integer fs type */
725 if ((flags
& SMNT_NEWTYPE
) == 0)
728 /* Do not allow for those flags we don't support */
729 if (flags
& (SMNT_GRPID
|SMNT_NOSUB
|SMNT_MULTI
|SMNT_SYS5
))
732 if(flags
& SMNT_REMOUNT
)
733 linux_flags
|= MS_REMOUNT
;
734 if(flags
& SMNT_RDONLY
)
735 linux_flags
|= MS_RDONLY
;
736 if(flags
& SMNT_NOSUID
)
737 linux_flags
|= MS_NOSUID
;
739 dir_page
= getname(dir
);
740 ret
= PTR_ERR(dir_page
);
741 if (IS_ERR(dir_page
))
744 type_page
= getname(type
);
745 ret
= PTR_ERR(type_page
);
746 if (IS_ERR(type_page
))
749 if(strcmp(type_page
, "ext2") == 0) {
750 dev_fname
= getname(data
);
751 } else if(strcmp(type_page
, "iso9660") == 0) {
752 dev_fname
= getname(data
);
753 } else if(strcmp(type_page
, "minix") == 0) {
754 dev_fname
= getname(data
);
755 } else if(strcmp(type_page
, "nfs") == 0) {
756 ret
= sunos_nfs_mount (dir_page
, flags
, data
);
758 } else if(strcmp(type_page
, "ufs") == 0) {
759 printk("Warning: UFS filesystem mounts unsupported.\n");
762 } else if(strcmp(type_page
, "proc")) {
766 ret
= PTR_ERR(dev_fname
);
767 if (IS_ERR(dev_fname
))
770 ret
= do_mount(dev_fname
, dir_page
, type_page
, linux_flags
, NULL
);
782 extern asmlinkage
int sys_setsid(void);
783 extern asmlinkage
int sys_setpgid(pid_t
, pid_t
);
785 asmlinkage
int sunos_setpgrp(pid_t pid
, pid_t pgid
)
790 if((!pid
|| pid
== current
->pid
) &&
795 ret
= sys_setpgid(pid
, pgid
);
801 extern asmlinkage
int sys32_wait4(__kernel_pid_t32 pid
,
802 u32 stat_addr
, int options
, u32 ru
);
804 asmlinkage
int sunos_wait4(__kernel_pid_t32 pid
, u32 stat_addr
, int options
, u32 ru
)
808 ret
= sys32_wait4((pid
? pid
: ((__kernel_pid_t32
)-1)),
809 stat_addr
, options
, ru
);
813 extern int kill_pg(int, int, int);
814 asmlinkage
int sunos_killpg(int pgrp
, int sig
)
816 return kill_pg(pgrp
, sig
, 0);
819 asmlinkage
int sunos_audit(void)
821 printk ("sys_audit\n");
825 extern asmlinkage u32
sunos_gethostid(void)
829 ret
= (((u32
)idprom
->id_machtype
<< 24) | ((u32
)idprom
->id_sernum
));
834 /* sysconf options, for SunOS compatibility */
835 #define _SC_ARG_MAX 1
836 #define _SC_CHILD_MAX 2
837 #define _SC_CLK_TCK 3
838 #define _SC_NGROUPS_MAX 4
839 #define _SC_OPEN_MAX 5
840 #define _SC_JOB_CONTROL 6
841 #define _SC_SAVED_IDS 7
842 #define _SC_VERSION 8
844 extern asmlinkage s32
sunos_sysconf (int name
)
858 case _SC_NGROUPS_MAX
:
864 case _SC_JOB_CONTROL
:
865 ret
= 1; /* yes, we do support job control */
868 ret
= 1; /* yes, we do support saved uids */
871 /* mhm, POSIX_VERSION is in /usr/include/unistd.h
872 * should it go on /usr/include/linux?
883 asmlinkage
int sunos_semsys(int op
, u32 arg1
, u32 arg2
, u32 arg3
, u32 ptr
)
890 /* Most arguments match on a 1:1 basis but cmd doesn't */
908 arg4
.__pad
=(void *)A(ptr
); /* value to modify semaphore to */
909 ret
= sys_semctl((int)arg1
, (int)arg2
, (int)arg3
, arg4
);
913 ret
= sys_semget((key_t
)arg1
, (int)arg2
, (int)arg3
);
917 ret
= sys_semop((int)arg1
, (struct sembuf
*)A(arg2
), (unsigned)arg3
);
934 __kernel_uid_t32 uid
;
935 __kernel_gid_t32 gid
;
936 __kernel_uid_t32 cuid
;
937 __kernel_gid_t32 cgid
;
938 __kernel_mode_t32 mode
;
944 struct ipc_perm32 msg_perm
;
947 __kernel_time_t32 msg_stime
;
948 __kernel_time_t32 msg_rtime
;
949 __kernel_time_t32 msg_ctime
;
952 unsigned short msg_cbytes
;
953 unsigned short msg_qnum
;
954 unsigned short msg_qbytes
;
955 __kernel_ipc_pid_t32 msg_lspid
;
956 __kernel_ipc_pid_t32 msg_lrpid
;
959 static inline int sunos_msqid_get(struct msqid_ds32
*user
,
960 struct msqid_ds
*kern
)
962 if(get_user(kern
->msg_perm
.key
, &user
->msg_perm
.key
) ||
963 __get_user(kern
->msg_perm
.uid
, &user
->msg_perm
.uid
) ||
964 __get_user(kern
->msg_perm
.gid
, &user
->msg_perm
.gid
) ||
965 __get_user(kern
->msg_perm
.cuid
, &user
->msg_perm
.cuid
) ||
966 __get_user(kern
->msg_perm
.cgid
, &user
->msg_perm
.cgid
) ||
967 __get_user(kern
->msg_stime
, &user
->msg_stime
) ||
968 __get_user(kern
->msg_rtime
, &user
->msg_rtime
) ||
969 __get_user(kern
->msg_ctime
, &user
->msg_ctime
) ||
970 __get_user(kern
->msg_ctime
, &user
->msg_cbytes
) ||
971 __get_user(kern
->msg_ctime
, &user
->msg_qnum
) ||
972 __get_user(kern
->msg_ctime
, &user
->msg_qbytes
) ||
973 __get_user(kern
->msg_ctime
, &user
->msg_lspid
) ||
974 __get_user(kern
->msg_ctime
, &user
->msg_lrpid
))
979 static inline int sunos_msqid_put(struct msqid_ds32
*user
,
980 struct msqid_ds
*kern
)
982 if(put_user(kern
->msg_perm
.key
, &user
->msg_perm
.key
) ||
983 __put_user(kern
->msg_perm
.uid
, &user
->msg_perm
.uid
) ||
984 __put_user(kern
->msg_perm
.gid
, &user
->msg_perm
.gid
) ||
985 __put_user(kern
->msg_perm
.cuid
, &user
->msg_perm
.cuid
) ||
986 __put_user(kern
->msg_perm
.cgid
, &user
->msg_perm
.cgid
) ||
987 __put_user(kern
->msg_stime
, &user
->msg_stime
) ||
988 __put_user(kern
->msg_rtime
, &user
->msg_rtime
) ||
989 __put_user(kern
->msg_ctime
, &user
->msg_ctime
) ||
990 __put_user(kern
->msg_ctime
, &user
->msg_cbytes
) ||
991 __put_user(kern
->msg_ctime
, &user
->msg_qnum
) ||
992 __put_user(kern
->msg_ctime
, &user
->msg_qbytes
) ||
993 __put_user(kern
->msg_ctime
, &user
->msg_lspid
) ||
994 __put_user(kern
->msg_ctime
, &user
->msg_lrpid
))
999 static inline int sunos_msgbuf_get(struct msgbuf32
*user
, struct msgbuf
*kern
, int len
)
1001 if(get_user(kern
->mtype
, &user
->mtype
) ||
1002 __copy_from_user(kern
->mtext
, &user
->mtext
, len
))
1007 static inline int sunos_msgbuf_put(struct msgbuf32
*user
, struct msgbuf
*kern
, int len
)
1009 if(put_user(kern
->mtype
, &user
->mtype
) ||
1010 __copy_to_user(user
->mtext
, kern
->mtext
, len
))
1015 asmlinkage
int sunos_msgsys(int op
, u32 arg1
, u32 arg2
, u32 arg3
, u32 arg4
)
1017 struct sparc_stackf32
*sp
;
1018 struct msqid_ds kds
;
1019 struct msgbuf
*kmbuf
;
1020 mm_segment_t old_fs
= get_fs();
1026 rval
= sys_msgget((key_t
)arg1
, (int)arg2
);
1029 if(!sunos_msqid_get((struct msqid_ds32
*)A(arg3
), &kds
)) {
1031 rval
= sys_msgctl((int)arg1
, (int)arg2
,
1032 (struct msqid_ds
*)A(arg3
));
1035 rval
= sunos_msqid_put((struct msqid_ds32
*)A(arg3
),
1042 kmbuf
= (struct msgbuf
*)kmalloc(sizeof(struct msgbuf
) + arg3
,
1046 sp
= (struct sparc_stackf32
*)
1047 (current
->thread
.kregs
->u_regs
[UREG_FP
] & 0xffffffffUL
);
1048 if(get_user(arg5
, &sp
->xxargs
[0])) {
1053 rval
= sys_msgrcv((int)arg1
, kmbuf
, (size_t)arg3
,
1054 (long)arg4
, (int)arg5
);
1057 rval
= sunos_msgbuf_put((struct msgbuf32
*)A(arg2
),
1063 kmbuf
= (struct msgbuf
*)kmalloc(sizeof(struct msgbuf
) + arg3
,
1065 if(!kmbuf
|| sunos_msgbuf_get((struct msgbuf32
*)A(arg2
),
1069 rval
= sys_msgsnd((int)arg1
, kmbuf
, (size_t)arg3
, (int)arg4
);
1081 struct ipc_perm32 shm_perm
;
1083 __kernel_time_t32 shm_atime
;
1084 __kernel_time_t32 shm_dtime
;
1085 __kernel_time_t32 shm_ctime
;
1086 __kernel_ipc_pid_t32 shm_cpid
;
1087 __kernel_ipc_pid_t32 shm_lpid
;
1088 unsigned short shm_nattch
;
1091 static inline int sunos_shmid_get(struct shmid_ds32
*user
,
1092 struct shmid_ds
*kern
)
1094 if(get_user(kern
->shm_perm
.key
, &user
->shm_perm
.key
) ||
1095 __get_user(kern
->shm_perm
.uid
, &user
->shm_perm
.uid
) ||
1096 __get_user(kern
->shm_perm
.gid
, &user
->shm_perm
.gid
) ||
1097 __get_user(kern
->shm_perm
.cuid
, &user
->shm_perm
.cuid
) ||
1098 __get_user(kern
->shm_perm
.cgid
, &user
->shm_perm
.cgid
) ||
1099 __get_user(kern
->shm_segsz
, &user
->shm_segsz
) ||
1100 __get_user(kern
->shm_atime
, &user
->shm_atime
) ||
1101 __get_user(kern
->shm_dtime
, &user
->shm_dtime
) ||
1102 __get_user(kern
->shm_ctime
, &user
->shm_ctime
) ||
1103 __get_user(kern
->shm_cpid
, &user
->shm_cpid
) ||
1104 __get_user(kern
->shm_lpid
, &user
->shm_lpid
) ||
1105 __get_user(kern
->shm_nattch
, &user
->shm_nattch
))
1110 static inline int sunos_shmid_put(struct shmid_ds32
*user
,
1111 struct shmid_ds
*kern
)
1113 if(put_user(kern
->shm_perm
.key
, &user
->shm_perm
.key
) ||
1114 __put_user(kern
->shm_perm
.uid
, &user
->shm_perm
.uid
) ||
1115 __put_user(kern
->shm_perm
.gid
, &user
->shm_perm
.gid
) ||
1116 __put_user(kern
->shm_perm
.cuid
, &user
->shm_perm
.cuid
) ||
1117 __put_user(kern
->shm_perm
.cgid
, &user
->shm_perm
.cgid
) ||
1118 __put_user(kern
->shm_segsz
, &user
->shm_segsz
) ||
1119 __put_user(kern
->shm_atime
, &user
->shm_atime
) ||
1120 __put_user(kern
->shm_dtime
, &user
->shm_dtime
) ||
1121 __put_user(kern
->shm_ctime
, &user
->shm_ctime
) ||
1122 __put_user(kern
->shm_cpid
, &user
->shm_cpid
) ||
1123 __put_user(kern
->shm_lpid
, &user
->shm_lpid
) ||
1124 __put_user(kern
->shm_nattch
, &user
->shm_nattch
))
1129 asmlinkage
int sunos_shmsys(int op
, u32 arg1
, u32 arg2
, u32 arg3
)
1131 struct shmid_ds ksds
;
1132 unsigned long raddr
;
1133 mm_segment_t old_fs
= get_fs();
1138 /* sys_shmat(): attach a shared memory area */
1139 rval
= sys_shmat((int)arg1
,(char *)A(arg2
),(int)arg3
,&raddr
);
1144 /* sys_shmctl(): modify shared memory area attr. */
1145 if(!sunos_shmid_get((struct shmid_ds32
*)A(arg3
), &ksds
)) {
1147 rval
= sys_shmctl((int)arg1
,(int)arg2
, &ksds
);
1150 rval
= sunos_shmid_put((struct shmid_ds32
*)A(arg3
),
1156 /* sys_shmdt(): detach a shared memory area */
1157 rval
= sys_shmdt((char *)A(arg1
));
1160 /* sys_shmget(): get a shared memory area */
1161 rval
= sys_shmget((key_t
)arg1
,(int)arg2
,(int)arg3
);
1170 extern asmlinkage
long sparc32_open(const char * filename
, int flags
, int mode
);
1172 asmlinkage
int sunos_open(u32 fname
, int flags
, int mode
)
1174 const char *filename
= (const char *)(long)fname
;
1176 return sparc32_open(filename
, flags
, mode
);
1179 #define SUNOS_EWOULDBLOCK 35
1181 /* see the sunos man page read(2v) for an explanation
1182 of this garbage. We use O_NDELAY to mark
1183 file descriptors that have been set non-blocking
1184 using 4.2BSD style calls. (tridge) */
1186 static inline int check_nonblock(int ret
, int fd
)
1188 if (ret
== -EAGAIN
) {
1189 struct file
* file
= fget(fd
);
1191 if (file
->f_flags
& O_NDELAY
)
1192 ret
= -SUNOS_EWOULDBLOCK
;
1199 extern asmlinkage
int sys_read(unsigned int fd
, char *buf
, unsigned long count
);
1200 extern asmlinkage
int sys_write(unsigned int fd
, char *buf
, unsigned long count
);
1201 extern asmlinkage
int sys_recv(int fd
, void *ubuf
, size_t size
, unsigned flags
);
1202 extern asmlinkage
int sys_send(int fd
, void *buff
, size_t len
, unsigned flags
);
1203 extern asmlinkage
int sys_accept(int fd
, struct sockaddr
*sa
, int *addrlen
);
1204 extern asmlinkage
int sys32_readv(u32 fd
, u32 vector
, s32 count
);
1205 extern asmlinkage
int sys32_writev(u32 fd
, u32 vector
, s32 count
);
1207 asmlinkage
int sunos_read(unsigned int fd
, u32 buf
, u32 count
)
1211 ret
= check_nonblock(sys_read(fd
, (char *)A(buf
), count
), fd
);
1215 asmlinkage
int sunos_readv(u32 fd
, u32 vector
, s32 count
)
1219 ret
= check_nonblock(sys32_readv(fd
, vector
, count
), fd
);
1223 asmlinkage
int sunos_write(unsigned int fd
, u32 buf
, u32 count
)
1227 ret
= check_nonblock(sys_write(fd
, (char *)A(buf
), count
), fd
);
1231 asmlinkage
int sunos_writev(u32 fd
, u32 vector
, s32 count
)
1235 ret
= check_nonblock(sys32_writev(fd
, vector
, count
), fd
);
1239 asmlinkage
int sunos_recv(int fd
, u32 ubuf
, int size
, unsigned flags
)
1243 ret
= check_nonblock(sys_recv(fd
, (void *)A(ubuf
), size
, flags
), fd
);
1247 asmlinkage
int sunos_send(int fd
, u32 buff
, int len
, unsigned flags
)
1251 ret
= check_nonblock(sys_send(fd
, (void *)A(buff
), len
, flags
), fd
);
1255 extern asmlinkage
int sys_setsockopt(int fd
, int level
, int optname
,
1256 char *optval
, int optlen
);
1258 asmlinkage
int sunos_socket(int family
, int type
, int protocol
)
1262 ret
= sys_socket(family
, type
, protocol
);
1266 sys_setsockopt(ret
, SOL_SOCKET
, SO_BSDCOMPAT
,
1267 (char *)&one
, sizeof(one
));
1272 asmlinkage
int sunos_accept(int fd
, u32 sa
, u32 addrlen
)
1277 ret
= check_nonblock(sys_accept(fd
, (struct sockaddr
*)A(sa
),
1278 (int *)A(addrlen
)), fd
);
1279 if (ret
!= -ENETUNREACH
&& ret
!= -EHOSTUNREACH
)
1285 sys_setsockopt(ret
, SOL_SOCKET
, SO_BSDCOMPAT
,
1286 (char *)&one
, sizeof(one
));
1291 #define SUNOS_SV_INTERRUPT 2
1293 asmlinkage
int sunos_sigaction (int sig
, u32 act
, u32 oact
)
1295 struct k_sigaction new_ka
, old_ka
;
1299 old_sigset_t32 mask
;
1301 if (get_user((long)new_ka
.sa
.sa_handler
, &((struct old_sigaction32
*)A(act
))->sa_handler
) ||
1302 __get_user(new_ka
.sa
.sa_flags
, &((struct old_sigaction32
*)A(act
))->sa_flags
))
1304 __get_user(mask
, &((struct old_sigaction32
*)A(act
))->sa_mask
);
1305 new_ka
.sa
.sa_restorer
= NULL
;
1306 new_ka
.ka_restorer
= NULL
;
1307 siginitset(&new_ka
.sa
.sa_mask
, mask
);
1308 new_ka
.sa
.sa_flags
^= SUNOS_SV_INTERRUPT
;
1311 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
1314 old_ka
.sa
.sa_flags
^= SUNOS_SV_INTERRUPT
;
1315 if (put_user((long)old_ka
.sa
.sa_handler
, &((struct old_sigaction32
*)A(oact
))->sa_handler
) ||
1316 __put_user(old_ka
.sa
.sa_flags
, &((struct old_sigaction32
*)A(oact
))->sa_flags
))
1318 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &((struct old_sigaction32
*)A(oact
))->sa_mask
);
1324 extern asmlinkage
int sys_setsockopt(int fd
, int level
, int optname
,
1325 char *optval
, int optlen
);
1326 extern asmlinkage
int sys32_getsockopt(int fd
, int level
, int optname
,
1327 u32 optval
, u32 optlen
);
1329 asmlinkage
int sunos_setsockopt(int fd
, int level
, int optname
, u32 optval
,
1332 int tr_opt
= optname
;
1335 if (level
== SOL_IP
) {
1336 /* Multicast socketopts (ttl, membership) */
1337 if (tr_opt
>=2 && tr_opt
<= 6)
1340 ret
= sys_setsockopt(fd
, level
, tr_opt
, (char *)A(optval
), optlen
);
1344 asmlinkage
int sunos_getsockopt(int fd
, int level
, int optname
,
1345 u32 optval
, u32 optlen
)
1347 int tr_opt
= optname
;
1350 if (level
== SOL_IP
) {
1351 /* Multicast socketopts (ttl, membership) */
1352 if (tr_opt
>=2 && tr_opt
<= 6)
1355 ret
= sys32_getsockopt(fd
, level
, tr_opt
, optval
, optlen
);