v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / arch / sparc / kernel / sys_sunos.c
1 /* $Id: sys_sunos.c,v 1.134 2001/04/27 07:02:42 davem Exp $
2  * sys_sunos.c: SunOS specific syscall compatibility support.
3  *
4  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5  * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
6  *
7  * Based upon preliminary work which is:
8  *
9  * Copyright (C) 1995 Adrian M. Rodriguez (adrian@remus.rutgers.edu)
10  *
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/types.h>
16 #include <linux/mman.h>
17 #include <linux/mm.h>
18 #include <linux/swap.h>
19 #include <linux/fs.h>
20 #include <linux/file.h>
21 #include <linux/resource.h>
22 #include <linux/ipc.h>
23 #include <linux/shm.h>
24 #include <linux/msg.h>
25 #include <linux/sem.h>
26 #include <linux/signal.h>
27 #include <linux/uio.h>
28 #include <linux/utsname.h>
29 #include <linux/major.h>
30 #include <linux/stat.h>
31 #include <linux/slab.h>
32 #include <linux/pagemap.h>
33 #include <linux/errno.h>
34 #include <linux/smp.h>
35 #include <linux/smp_lock.h>
36
37 #include <asm/uaccess.h>
38 #ifndef KERNEL_DS
39 #include <linux/segment.h>
40 #endif
41
42 #include <asm/page.h>
43 #include <asm/pgtable.h>
44 #include <asm/pconf.h>
45 #include <asm/idprom.h> /* for gethostid() */
46 #include <asm/unistd.h>
47 #include <asm/system.h>
48
49 /* For the nfs mount emulation */
50 #include <linux/socket.h>
51 #include <linux/in.h>
52 #include <linux/nfs.h>
53 #include <linux/nfs2.h>
54 #include <linux/nfs_mount.h>
55
56 /* for sunos_select */
57 #include <linux/time.h>
58 #include <linux/personality.h>
59
60 /* NR_OPEN is now larger and dynamic in recent kernels. */
61 #define SUNOS_NR_OPEN   256
62
63 /* We use the SunOS mmap() semantics. */
64 asmlinkage unsigned long sunos_mmap(unsigned long addr, unsigned long len,
65                                     unsigned long prot, unsigned long flags,
66                                     unsigned long fd, unsigned long off)
67 {
68         struct file * file = NULL;
69         unsigned long retval, ret_type;
70
71         if(flags & MAP_NORESERVE) {
72                 static int cnt;
73                 if (cnt++ < 10)
74                         printk("%s: unimplemented SunOS MAP_NORESERVE mmap() flag\n",
75                                current->comm);
76                 flags &= ~MAP_NORESERVE;
77         }
78         retval = -EBADF;
79         if(!(flags & MAP_ANONYMOUS)) {
80                 if (fd >= SUNOS_NR_OPEN)
81                         goto out;
82                 file = fget(fd);
83                 if (!file)
84                         goto out;
85         }
86
87         retval = -EINVAL;
88         /* If this is ld.so or a shared library doing an mmap
89          * of /dev/zero, transform it into an anonymous mapping.
90          * SunOS is so stupid some times... hmph!
91          */
92         if (file) {
93                 if(MAJOR(file->f_dentry->d_inode->i_rdev) == MEM_MAJOR &&
94                    MINOR(file->f_dentry->d_inode->i_rdev) == 5) {
95                         flags |= MAP_ANONYMOUS;
96                         fput(file);
97                         file = 0;
98                 }
99         }
100         ret_type = flags & _MAP_NEW;
101         flags &= ~_MAP_NEW;
102
103         if(!(flags & MAP_FIXED))
104                 addr = 0;
105         else {
106                 if (ARCH_SUN4C_SUN4 &&
107                     (len > 0x20000000 ||
108                      ((flags & MAP_FIXED) &&
109                       addr < 0xe0000000 && addr + len > 0x20000000)))
110                         goto out_putf;
111
112                 /* See asm-sparc/uaccess.h */
113                 if (len > TASK_SIZE - PAGE_SIZE ||
114                     addr + len > TASK_SIZE - PAGE_SIZE)
115                         goto out_putf;
116         }
117
118         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
119         down_write(&current->mm->mmap_sem);
120         retval = do_mmap(file, addr, len, prot, flags, off);
121         up_write(&current->mm->mmap_sem);
122         if(!ret_type)
123                 retval = ((retval < PAGE_OFFSET) ? 0 : retval);
124
125 out_putf:
126         if (file)
127                 fput(file);
128 out:
129         return retval;
130 }
131
132 /* lmbench calls this, just say "yeah, ok" */
133 asmlinkage int sunos_mctl(unsigned long addr, unsigned long len, int function, char *arg)
134 {
135         return 0;
136 }
137
138 /* SunOS is completely broken... it returns 0 on success, otherwise
139  * ENOMEM.  For sys_sbrk() it wants the old brk value as a return
140  * on success and ENOMEM as before on failure.
141  */
142 asmlinkage int sunos_brk(unsigned long brk)
143 {
144         int freepages, retval = -ENOMEM;
145         unsigned long rlim;
146         unsigned long newbrk, oldbrk;
147
148         down_write(&current->mm->mmap_sem);
149         if(ARCH_SUN4C_SUN4) {
150                 if(brk >= 0x20000000 && brk < 0xe0000000) {
151                         goto out;
152                 }
153         }
154
155         if (brk < current->mm->end_code)
156                 goto out;
157
158         newbrk = PAGE_ALIGN(brk);
159         oldbrk = PAGE_ALIGN(current->mm->brk);
160         retval = 0;
161         if (oldbrk == newbrk) {
162                 current->mm->brk = brk;
163                 goto out;
164         }
165
166         /*
167          * Always allow shrinking brk
168          */
169         if (brk <= current->mm->brk) {
170                 current->mm->brk = brk;
171                 do_munmap(current->mm, newbrk, oldbrk-newbrk);
172                 goto out;
173         }
174         /*
175          * Check against rlimit and stack..
176          */
177         retval = -ENOMEM;
178         rlim = current->rlim[RLIMIT_DATA].rlim_cur;
179         if (rlim >= RLIM_INFINITY)
180                 rlim = ~0;
181         if (brk - current->mm->end_code > rlim)
182                 goto out;
183
184         /*
185          * Check against existing mmap mappings.
186          */
187         if (find_vma_intersection(current->mm, oldbrk, newbrk+PAGE_SIZE))
188                 goto out;
189
190         /*
191          * stupid algorithm to decide if we have enough memory: while
192          * simple, it hopefully works in most obvious cases.. Easy to
193          * fool it, but this should catch most mistakes.
194          */
195         freepages = atomic_read(&buffermem_pages) >> PAGE_SHIFT;
196         freepages += atomic_read(&page_cache_size);
197         freepages >>= 1;
198         freepages += nr_free_pages();
199         freepages += nr_swap_pages;
200         freepages -= num_physpages >> 4;
201         freepages -= (newbrk-oldbrk) >> PAGE_SHIFT;
202         if (freepages < 0)
203                 goto out;
204         /*
205          * Ok, we have probably got enough memory - let it rip.
206          */
207         current->mm->brk = brk;
208         do_brk(oldbrk, newbrk-oldbrk);
209         retval = 0;
210 out:
211         up_write(&current->mm->mmap_sem);
212         return retval;
213 }
214
215 asmlinkage unsigned long sunos_sbrk(int increment)
216 {
217         int error;
218         unsigned long oldbrk;
219
220         /* This should do it hopefully... */
221         lock_kernel();
222         oldbrk = current->mm->brk;
223         error = sunos_brk(((int) current->mm->brk) + increment);
224         if(!error)
225                 error = oldbrk;
226         unlock_kernel();
227         return error;
228 }
229
230 /* XXX Completely undocumented, and completely magic...
231  * XXX I believe it is to increase the size of the stack by
232  * XXX argument 'increment' and return the new end of stack
233  * XXX area.  Wheee...
234  */
235 asmlinkage unsigned long sunos_sstk(int increment)
236 {
237         lock_kernel();
238         printk("%s: Call to sunos_sstk(increment<%d>) is unsupported\n",
239                current->comm, increment);
240         unlock_kernel();
241         return -1;
242 }
243
244 /* Give hints to the kernel as to what paging strategy to use...
245  * Completely bogus, don't remind me.
246  */
247 #define VA_NORMAL     0 /* Normal vm usage expected */
248 #define VA_ABNORMAL   1 /* Abnormal/random vm usage probable */
249 #define VA_SEQUENTIAL 2 /* Accesses will be of a sequential nature */
250 #define VA_INVALIDATE 3 /* Page table entries should be flushed ??? */
251 static char *vstrings[] = {
252         "VA_NORMAL",
253         "VA_ABNORMAL",
254         "VA_SEQUENTIAL",
255         "VA_INVALIDATE",
256 };
257
258 asmlinkage void sunos_vadvise(unsigned long strategy)
259 {
260         /* I wanna see who uses this... */
261         lock_kernel();
262         printk("%s: Advises us to use %s paging strategy\n",
263                current->comm,
264                strategy <= 3 ? vstrings[strategy] : "BOGUS");
265         unlock_kernel();
266 }
267
268 /* This just wants the soft limit (ie. rlim_cur element) of the RLIMIT_NOFILE
269  * resource limit and is for backwards compatibility with older sunos
270  * revs.
271  */
272 asmlinkage long sunos_getdtablesize(void)
273 {
274         return SUNOS_NR_OPEN;
275 }
276
277 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
278
279 asmlinkage unsigned long sunos_sigblock(unsigned long blk_mask)
280 {
281         unsigned long old;
282
283         spin_lock_irq(&current->sigmask_lock);
284         old = current->blocked.sig[0];
285         current->blocked.sig[0] |= (blk_mask & _BLOCKABLE);
286         recalc_sigpending(current);
287         spin_unlock_irq(&current->sigmask_lock);
288         return old;
289 }
290
291 asmlinkage unsigned long sunos_sigsetmask(unsigned long newmask)
292 {
293         unsigned long retval;
294
295         spin_lock_irq(&current->sigmask_lock);
296         retval = current->blocked.sig[0];
297         current->blocked.sig[0] = (newmask & _BLOCKABLE);
298         recalc_sigpending(current);
299         spin_unlock_irq(&current->sigmask_lock);
300         return retval;
301 }
302
303 /* SunOS getdents is very similar to the newer Linux (iBCS2 compliant)    */
304 /* getdents system call, the format of the structure just has a different */
305 /* layout (d_off+d_ino instead of d_ino+d_off) */
306 struct sunos_dirent {
307     long           d_off;
308     unsigned long  d_ino;
309     unsigned short d_reclen;
310     unsigned short d_namlen;
311     char           d_name[1];
312 };
313
314 struct sunos_dirent_callback {
315     struct sunos_dirent *curr;
316     struct sunos_dirent *previous;
317     int count;
318     int error;
319 };
320
321 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
322 #define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
323
324 static int sunos_filldir(void * __buf, const char * name, int namlen,
325                          loff_t offset, ino_t ino, unsigned int d_type)
326 {
327         struct sunos_dirent * dirent;
328         struct sunos_dirent_callback * buf = (struct sunos_dirent_callback *) __buf;
329         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
330
331         buf->error = -EINVAL;   /* only used if we fail.. */
332         if (reclen > buf->count)
333                 return -EINVAL;
334         dirent = buf->previous;
335         if (dirent)
336                 put_user(offset, &dirent->d_off);
337         dirent = buf->curr;
338         buf->previous = dirent;
339         put_user(ino, &dirent->d_ino);
340         put_user(namlen, &dirent->d_namlen);
341         put_user(reclen, &dirent->d_reclen);
342         copy_to_user(dirent->d_name, name, namlen);
343         put_user(0, dirent->d_name + namlen);
344         ((char *) dirent) += reclen;
345         buf->curr = dirent;
346         buf->count -= reclen;
347         return 0;
348 }
349
350 asmlinkage int sunos_getdents(unsigned int fd, void * dirent, int cnt)
351 {
352         struct file * file;
353         struct sunos_dirent * lastdirent;
354         struct sunos_dirent_callback buf;
355         int error = -EBADF;
356
357         if (fd >= SUNOS_NR_OPEN)
358                 goto out;
359
360         file = fget(fd);
361         if (!file)
362                 goto out;
363
364         error = -EINVAL;
365         if (cnt < (sizeof(struct sunos_dirent) + 255))
366                 goto out_putf;
367
368         buf.curr = (struct sunos_dirent *) dirent;
369         buf.previous = NULL;
370         buf.count = cnt;
371         buf.error = 0;
372
373         error = vfs_readdir(file, sunos_filldir, &buf);
374         if (error < 0)
375                 goto out_putf;
376
377         lastdirent = buf.previous;
378         error = buf.error;
379         if (lastdirent) {
380                 put_user(file->f_pos, &lastdirent->d_off);
381                 error = cnt - buf.count;
382         }
383
384 out_putf:
385         fput(file);
386 out:
387         return error;
388 }
389
390 /* Old sunos getdirentries, severely broken compatibility stuff here. */
391 struct sunos_direntry {
392     unsigned long  d_ino;
393     unsigned short d_reclen;
394     unsigned short d_namlen;
395     char           d_name[1];
396 };
397
398 struct sunos_direntry_callback {
399     struct sunos_direntry *curr;
400     struct sunos_direntry *previous;
401     int count;
402     int error;
403 };
404
405 static int sunos_filldirentry(void * __buf, const char * name, int namlen,
406                               loff_t offset, ino_t ino, unsigned int d_type)
407 {
408         struct sunos_direntry * dirent;
409         struct sunos_direntry_callback * buf = (struct sunos_direntry_callback *) __buf;
410         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
411
412         buf->error = -EINVAL;   /* only used if we fail.. */
413         if (reclen > buf->count)
414                 return -EINVAL;
415         dirent = buf->previous;
416         dirent = buf->curr;
417         buf->previous = dirent;
418         put_user(ino, &dirent->d_ino);
419         put_user(namlen, &dirent->d_namlen);
420         put_user(reclen, &dirent->d_reclen);
421         copy_to_user(dirent->d_name, name, namlen);
422         put_user(0, dirent->d_name + namlen);
423         ((char *) dirent) += reclen;
424         buf->curr = dirent;
425         buf->count -= reclen;
426         return 0;
427 }
428
429 asmlinkage int sunos_getdirentries(unsigned int fd, void * dirent, int cnt, unsigned int *basep)
430 {
431         struct file * file;
432         struct sunos_direntry * lastdirent;
433         struct sunos_direntry_callback buf;
434         int error = -EBADF;
435
436         if (fd >= SUNOS_NR_OPEN)
437                 goto out;
438
439         file = fget(fd);
440         if (!file)
441                 goto out;
442
443         error = -EINVAL;
444         if(cnt < (sizeof(struct sunos_direntry) + 255))
445                 goto out_putf;
446
447         buf.curr = (struct sunos_direntry *) dirent;
448         buf.previous = NULL;
449         buf.count = cnt;
450         buf.error = 0;
451
452         error = vfs_readdir(file, sunos_filldirentry, &buf);
453         if (error < 0)
454                 goto out_putf;
455
456         lastdirent = buf.previous;
457         error = buf.error;
458         if (lastdirent) {
459                 put_user(file->f_pos, basep);
460                 error = cnt - buf.count;
461         }
462
463 out_putf:
464         fput(file);
465 out:
466         return error;
467 }
468
469 struct sunos_utsname {
470         char sname[9];
471         char nname[9];
472         char nnext[56];
473         char rel[9];
474         char ver[9];
475         char mach[9];
476 };
477
478 asmlinkage int sunos_uname(struct sunos_utsname *name)
479 {
480         int ret;
481         down_read(&uts_sem);
482         ret = copy_to_user(&name->sname[0], &system_utsname.sysname[0], sizeof(name->sname) - 1);
483         if (!ret) {
484                 ret |= __copy_to_user(&name->nname[0], &system_utsname.nodename[0], sizeof(name->nname) - 1);
485                 ret |= __put_user('\0', &name->nname[8]);
486                 ret |= __copy_to_user(&name->rel[0], &system_utsname.release[0], sizeof(name->rel) - 1);
487                 ret |= __copy_to_user(&name->ver[0], &system_utsname.version[0], sizeof(name->ver) - 1);
488                 ret |= __copy_to_user(&name->mach[0], &system_utsname.machine[0], sizeof(name->mach) - 1);
489         }
490         up_read(&uts_sem);
491         return ret;
492 }
493
494 asmlinkage int sunos_nosys(void)
495 {
496         struct pt_regs *regs;
497         siginfo_t info;
498         static int cnt;
499
500         lock_kernel();
501         regs = current->thread.kregs;
502         info.si_signo = SIGSYS;
503         info.si_errno = 0;
504         info.si_code = __SI_FAULT|0x100;
505         info.si_addr = (void *)regs->pc;
506         info.si_trapno = regs->u_regs[UREG_G1];
507         send_sig_info(SIGSYS, &info, current);
508         if (cnt++ < 4) {
509                 printk("Process makes ni_syscall number %d, register dump:\n",
510                        (int) regs->u_regs[UREG_G1]);
511                 show_regs(regs);
512         }
513         unlock_kernel();
514         return -ENOSYS;
515 }
516
517 /* This is not a real and complete implementation yet, just to keep
518  * the easy SunOS binaries happy.
519  */
520 asmlinkage int sunos_fpathconf(int fd, int name)
521 {
522         int ret;
523
524         switch(name) {
525         case _PCONF_LINK:
526                 ret = LINK_MAX;
527                 break;
528         case _PCONF_CANON:
529                 ret = MAX_CANON;
530                 break;
531         case _PCONF_INPUT:
532                 ret = MAX_INPUT;
533                 break;
534         case _PCONF_NAME:
535                 ret = NAME_MAX;
536                 break;
537         case _PCONF_PATH:
538                 ret = PATH_MAX;
539                 break;
540         case _PCONF_PIPE:
541                 ret = PIPE_BUF;
542                 break;
543         case _PCONF_CHRESTRICT:         /* XXX Investigate XXX */
544                 ret = 1;
545                 break;
546         case _PCONF_NOTRUNC:            /* XXX Investigate XXX */
547         case _PCONF_VDISABLE:
548                 ret = 0;
549                 break;
550         default:
551                 ret = -EINVAL;
552                 break;
553         }
554         return ret;
555 }
556
557 asmlinkage int sunos_pathconf(char *path, int name)
558 {
559         int ret;
560
561         ret = sunos_fpathconf(0, name); /* XXX cheese XXX */
562         return ret;
563 }
564
565 /* SunOS mount system call emulation */
566 extern asmlinkage int
567 sys_select(int n, fd_set *inp, fd_set *outp, fd_set *exp, struct timeval *tvp);
568
569 asmlinkage int sunos_select(int width, fd_set *inp, fd_set *outp, fd_set *exp, struct timeval *tvp)
570 {
571         int ret;
572
573         /* SunOS binaries expect that select won't change the tvp contents */
574         ret = sys_select (width, inp, outp, exp, tvp);
575         if (ret == -EINTR && tvp) {
576                 time_t sec, usec;
577
578                 __get_user(sec, &tvp->tv_sec);
579                 __get_user(usec, &tvp->tv_usec);
580
581                 if (sec == 0 && usec == 0)
582                         ret = 0;
583         }
584         return ret;
585 }
586
587 asmlinkage void sunos_nop(void)
588 {
589         return;
590 }
591
592 /* SunOS mount/umount. */
593 #define SMNT_RDONLY       1
594 #define SMNT_NOSUID       2
595 #define SMNT_NEWTYPE      4
596 #define SMNT_GRPID        8
597 #define SMNT_REMOUNT      16
598 #define SMNT_NOSUB        32
599 #define SMNT_MULTI        64
600 #define SMNT_SYS5         128
601
602 struct sunos_fh_t {
603         char fh_data [NFS_FHSIZE];
604 };
605
606 struct sunos_nfs_mount_args {
607         struct sockaddr_in  *addr; /* file server address */
608         struct nfs_fh *fh;     /* File handle to be mounted */
609         int        flags;      /* flags */
610         int        wsize;      /* write size in bytes */
611         int        rsize;      /* read size in bytes */
612         int        timeo;      /* initial timeout in .1 secs */
613         int        retrans;    /* times to retry send */
614         char       *hostname;  /* server's hostname */
615         int        acregmin;   /* attr cache file min secs */
616         int        acregmax;   /* attr cache file max secs */
617         int        acdirmin;   /* attr cache dir min secs */
618         int        acdirmax;   /* attr cache dir max secs */
619         char       *netname;   /* server's netname */
620 };
621
622
623 extern asmlinkage int sys_connect(int fd, struct sockaddr *uservaddr, int addrlen);
624 extern asmlinkage int sys_socket(int family, int type, int protocol);
625 extern asmlinkage int sys_bind(int fd, struct sockaddr *umyaddr, int addrlen);
626
627
628 /* Bind the socket on a local reserved port and connect it to the
629  * remote server.  This on Linux/i386 is done by the mount program,
630  * not by the kernel.
631  */
632 static int
633 sunos_nfs_get_server_fd (int fd, struct sockaddr_in *addr)
634 {
635         struct sockaddr_in local;
636         struct sockaddr_in server;
637         int    try_port;
638         struct socket *socket;
639         struct inode  *inode;
640         struct file   *file;
641         int    ret, result = 0;
642
643         file = fget(fd);
644         if (!file)
645                 goto out;
646
647         inode = file->f_dentry->d_inode;
648
649         socket = &inode->u.socket_i;
650         local.sin_family = AF_INET;
651         local.sin_addr.s_addr = INADDR_ANY;
652
653         /* IPPORT_RESERVED = 1024, can't find the definition in the kernel */
654         try_port = 1024;
655         do {
656                 local.sin_port = htons (--try_port);
657                 ret = socket->ops->bind(socket, (struct sockaddr*)&local,
658                                         sizeof(local));
659         } while (ret && try_port > (1024 / 2));
660
661         if (ret)
662                 goto out_putf;
663
664         server.sin_family = AF_INET;
665         server.sin_addr = addr->sin_addr;
666         server.sin_port = NFS_PORT;
667
668         /* Call sys_connect */
669         ret = socket->ops->connect (socket, (struct sockaddr *) &server,
670                                     sizeof (server), file->f_flags);
671         if (ret >= 0)
672                 result = 1;
673
674 out_putf:
675         fput(file);
676 out:
677         return result;
678 }
679
680 static int get_default (int value, int def_value)
681 {
682     if (value)
683         return value;
684     else
685         return def_value;
686 }
687
688 static int sunos_nfs_mount(char *dir_name, int linux_flags, void *data)
689 {
690         int  server_fd;
691         char *the_name;
692         struct nfs_mount_data linux_nfs_mount;
693         struct sunos_nfs_mount_args sunos_mount;
694
695         /* Ok, here comes the fun part: Linux's nfs mount needs a
696          * socket connection to the server, but SunOS mount does not
697          * require this, so we use the information on the destination
698          * address to create a socket and bind it to a reserved
699          * port on this system
700          */
701         if (copy_from_user(&sunos_mount, data, sizeof(sunos_mount)))
702                 return -EFAULT;
703
704         server_fd = sys_socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
705         if (server_fd < 0)
706                 return -ENXIO;
707
708         if (copy_from_user(&linux_nfs_mount.addr,sunos_mount.addr,
709                                 sizeof(*sunos_mount.addr)) ||
710             copy_from_user(&linux_nfs_mount.root,sunos_mount.fh,
711                                 sizeof(*sunos_mount.fh))) {
712                 sys_close (server_fd);
713                 return -EFAULT;
714         }
715
716         if (!sunos_nfs_get_server_fd (server_fd, &linux_nfs_mount.addr)){
717                 sys_close (server_fd);
718                 return -ENXIO;
719         }
720
721         /* Now, bind it to a locally reserved port */
722         linux_nfs_mount.version  = NFS_MOUNT_VERSION;
723         linux_nfs_mount.flags    = sunos_mount.flags;
724         linux_nfs_mount.fd       = server_fd;
725         
726         linux_nfs_mount.rsize    = get_default (sunos_mount.rsize, 8192);
727         linux_nfs_mount.wsize    = get_default (sunos_mount.wsize, 8192);
728         linux_nfs_mount.timeo    = get_default (sunos_mount.timeo, 10);
729         linux_nfs_mount.retrans  = sunos_mount.retrans;
730         
731         linux_nfs_mount.acregmin = sunos_mount.acregmin;
732         linux_nfs_mount.acregmax = sunos_mount.acregmax;
733         linux_nfs_mount.acdirmin = sunos_mount.acdirmin;
734         linux_nfs_mount.acdirmax = sunos_mount.acdirmax;
735
736         the_name = getname(sunos_mount.hostname);
737         if(IS_ERR(the_name))
738                 return PTR_ERR(the_name);
739
740         strncpy (linux_nfs_mount.hostname, the_name, 254);
741         linux_nfs_mount.hostname [255] = 0;
742         putname (the_name);
743         
744         return do_mount ("", dir_name, "nfs", linux_flags, &linux_nfs_mount);
745 }
746
747 asmlinkage int
748 sunos_mount(char *type, char *dir, int flags, void *data)
749 {
750         int linux_flags = 0;
751         int ret = -EINVAL;
752         char *dev_fname = 0;
753         char *dir_page, *type_page;
754
755         if (!capable (CAP_SYS_ADMIN))
756                 return -EPERM;
757                 
758         lock_kernel();
759         /* We don't handle the integer fs type */
760         if ((flags & SMNT_NEWTYPE) == 0)
761                 goto out;
762
763         /* Do not allow for those flags we don't support */
764         if (flags & (SMNT_GRPID|SMNT_NOSUB|SMNT_MULTI|SMNT_SYS5))
765                 goto out;
766
767         if(flags & SMNT_REMOUNT)
768                 linux_flags |= MS_REMOUNT;
769         if(flags & SMNT_RDONLY)
770                 linux_flags |= MS_RDONLY;
771         if(flags & SMNT_NOSUID)
772                 linux_flags |= MS_NOSUID;
773
774         dir_page = getname(dir);
775         ret = PTR_ERR(dir_page);
776         if (IS_ERR(dir_page))
777                 goto out;
778
779         type_page = getname(type);
780         ret = PTR_ERR(type_page);
781         if (IS_ERR(type_page))
782                 goto out1;
783
784         if(strcmp(type_page, "ext2") == 0) {
785                 dev_fname = getname(data);
786         } else if(strcmp(type_page, "iso9660") == 0) {
787                 dev_fname = getname(data);
788         } else if(strcmp(type_page, "minix") == 0) {
789                 dev_fname = getname(data);
790         } else if(strcmp(type_page, "nfs") == 0) {
791                 ret = sunos_nfs_mount (dir_page, flags, data);
792                 goto out2;
793         } else if(strcmp(type_page, "ufs") == 0) {
794                 printk("Warning: UFS filesystem mounts unsupported.\n");
795                 ret = -ENODEV;
796                 goto out2;
797         } else if(strcmp(type_page, "proc")) {
798                 ret = -ENODEV;
799                 goto out2;
800         }
801         ret = PTR_ERR(dev_fname);
802         if (IS_ERR(dev_fname))
803                 goto out2;
804         ret = do_mount(dev_fname, dir_page, type_page, linux_flags, NULL);
805         if (dev_fname)
806                 putname(dev_fname);
807 out2:
808         putname(type_page);
809 out1:
810         putname(dir_page);
811 out:
812         unlock_kernel();
813         return ret;
814 }
815
816 extern asmlinkage int sys_setsid(void);
817 extern asmlinkage int sys_setpgid(pid_t, pid_t);
818
819 asmlinkage int sunos_setpgrp(pid_t pid, pid_t pgid)
820 {
821         int ret;
822
823         /* So stupid... */
824         if((!pid || pid == current->pid) &&
825            !pgid) {
826                 sys_setsid();
827                 ret = 0;
828         } else {
829                 ret = sys_setpgid(pid, pgid);
830         }
831         return ret;
832 }
833
834 /* So stupid... */
835 asmlinkage int sunos_wait4(pid_t pid, unsigned int *stat_addr, int options, struct rusage *ru)
836 {
837         int ret;
838
839         ret = sys_wait4((pid ? pid : -1), stat_addr, options, ru);
840         return ret;
841 }
842
843 extern int kill_pg(int, int, int);
844 asmlinkage int sunos_killpg(int pgrp, int sig)
845 {
846         int ret;
847
848         lock_kernel();
849         ret = kill_pg(pgrp, sig, 0);
850         unlock_kernel();
851         return ret;
852 }
853
854 asmlinkage int sunos_audit(void)
855 {
856         lock_kernel();
857         printk ("sys_audit\n");
858         unlock_kernel();
859         return -1;
860 }
861
862 extern asmlinkage unsigned long sunos_gethostid(void)
863 {
864         unsigned long ret;
865
866         lock_kernel();
867         ret = ((unsigned long)idprom->id_machtype << 24) |
868                 (unsigned long)idprom->id_sernum;
869         unlock_kernel();
870         return ret;
871 }
872
873 /* sysconf options, for SunOS compatibility */
874 #define   _SC_ARG_MAX             1
875 #define   _SC_CHILD_MAX           2
876 #define   _SC_CLK_TCK             3
877 #define   _SC_NGROUPS_MAX         4
878 #define   _SC_OPEN_MAX            5
879 #define   _SC_JOB_CONTROL         6
880 #define   _SC_SAVED_IDS           7
881 #define   _SC_VERSION             8
882
883 extern asmlinkage long sunos_sysconf (int name)
884 {
885         long ret;
886
887         switch (name){
888         case _SC_ARG_MAX:
889                 ret = ARG_MAX;
890                 break;
891         case _SC_CHILD_MAX:
892                 ret = CHILD_MAX;
893                 break;
894         case _SC_CLK_TCK:
895                 ret = HZ;
896                 break;
897         case _SC_NGROUPS_MAX:
898                 ret = NGROUPS_MAX;
899                 break;
900         case _SC_OPEN_MAX:
901                 ret = OPEN_MAX;
902                 break;
903         case _SC_JOB_CONTROL:
904                 ret = 1;        /* yes, we do support job control */
905                 break;
906         case _SC_SAVED_IDS:
907                 ret = 1;        /* yes, we do support saved uids  */
908                 break;
909         case _SC_VERSION:
910                 /* mhm, POSIX_VERSION is in /usr/include/unistd.h
911                  * should it go on /usr/include/linux?
912                  */
913                 ret = 199009L; 
914                 break;
915         default:
916                 ret = -1;
917                 break;
918         };
919         return ret;
920 }
921
922 asmlinkage int sunos_semsys(int op, unsigned long arg1, unsigned long arg2,
923                             unsigned long arg3, void *ptr)
924 {
925         union semun arg4;
926         int ret;
927
928         switch (op) {
929         case 0:
930                 /* Most arguments match on a 1:1 basis but cmd doesn't */
931                 switch(arg3) {
932                 case 4:
933                         arg3=GETPID; break;
934                 case 5:
935                         arg3=GETVAL; break;
936                 case 6:
937                         arg3=GETALL; break;
938                 case 3:
939                         arg3=GETNCNT; break;
940                 case 7:
941                         arg3=GETZCNT; break;
942                 case 8:
943                         arg3=SETVAL; break;
944                 case 9:
945                         arg3=SETALL; break;
946                 }
947                 /* sys_semctl(): */
948                 arg4.__pad=ptr; /* value to modify semaphore to */
949                 ret = sys_semctl((int)arg1, (int)arg2, (int)arg3, arg4 );
950                 break;
951         case 1:
952                 /* sys_semget(): */
953                 ret = sys_semget((key_t)arg1, (int)arg2, (int)arg3);
954                 break;
955         case 2:
956                 /* sys_semop(): */
957                 ret = sys_semop((int)arg1, (struct sembuf *)arg2, (unsigned)arg3);
958                 break;
959         default:
960                 ret = -EINVAL;
961                 break;
962         };
963         return ret;
964 }
965
966 asmlinkage int sunos_msgsys(int op, unsigned long arg1, unsigned long arg2,
967                             unsigned long arg3, unsigned long arg4)
968 {
969         struct sparc_stackf *sp;
970         unsigned long arg5;
971         int rval;
972
973         switch(op) {
974         case 0:
975                 rval = sys_msgget((key_t)arg1, (int)arg2);
976                 break;
977         case 1:
978                 rval = sys_msgctl((int)arg1, (int)arg2,
979                                   (struct msqid_ds *)arg3);
980                 break;
981         case 2:
982                 lock_kernel();
983                 sp = (struct sparc_stackf *)current->thread.kregs->u_regs[UREG_FP];
984                 arg5 = sp->xxargs[0];
985                 unlock_kernel();
986                 rval = sys_msgrcv((int)arg1, (struct msgbuf *)arg2,
987                                   (size_t)arg3, (long)arg4, (int)arg5);
988                 break;
989         case 3:
990                 rval = sys_msgsnd((int)arg1, (struct msgbuf *)arg2,
991                                   (size_t)arg3, (int)arg4);
992                 break;
993         default:
994                 rval = -EINVAL;
995                 break;
996         }
997         return rval;
998 }
999
1000 asmlinkage int sunos_shmsys(int op, unsigned long arg1, unsigned long arg2,
1001                             unsigned long arg3)
1002 {
1003         unsigned long raddr;
1004         int rval;
1005
1006         switch(op) {
1007         case 0:
1008                 /* sys_shmat(): attach a shared memory area */
1009                 rval = sys_shmat((int)arg1,(char *)arg2,(int)arg3,&raddr);
1010                 if(!rval)
1011                         rval = (int) raddr;
1012                 break;
1013         case 1:
1014                 /* sys_shmctl(): modify shared memory area attr. */
1015                 rval = sys_shmctl((int)arg1,(int)arg2,(struct shmid_ds *)arg3);
1016                 break;
1017         case 2:
1018                 /* sys_shmdt(): detach a shared memory area */
1019                 rval = sys_shmdt((char *)arg1);
1020                 break;
1021         case 3:
1022                 /* sys_shmget(): get a shared memory area */
1023                 rval = sys_shmget((key_t)arg1,(int)arg2,(int)arg3);
1024                 break;
1025         default:
1026                 rval = -EINVAL;
1027                 break;
1028         };
1029         return rval;
1030 }
1031
1032 #define SUNOS_EWOULDBLOCK 35
1033
1034 /* see the sunos man page read(2v) for an explanation
1035    of this garbage. We use O_NDELAY to mark
1036    file descriptors that have been set non-blocking 
1037    using 4.2BSD style calls. (tridge) */
1038
1039 static inline int check_nonblock(int ret, int fd)
1040 {
1041         if (ret == -EAGAIN) {
1042                 struct file * file = fget(fd);
1043                 if (file) {
1044                         if (file->f_flags & O_NDELAY)
1045                                 ret = -SUNOS_EWOULDBLOCK;
1046                         fput(file);
1047                 }
1048         }
1049         return ret;
1050 }
1051
1052 extern asmlinkage int sys_read(unsigned int fd,char *buf,int count);
1053 extern asmlinkage int sys_write(unsigned int fd,char *buf,int count);
1054 extern asmlinkage int sys_recv(int fd, void * ubuf, int size, unsigned flags);
1055 extern asmlinkage int sys_send(int fd, void * buff, int len, unsigned flags);
1056 extern asmlinkage int sys_accept(int fd, struct sockaddr *sa, int *addrlen);
1057 extern asmlinkage int sys_readv(unsigned long fd, const struct iovec * vector, long count);
1058 extern asmlinkage int sys_writev(unsigned long fd, const struct iovec * vector, long count);
1059
1060
1061 asmlinkage int sunos_read(unsigned int fd,char *buf,int count)
1062 {
1063         int ret;
1064
1065         ret = check_nonblock(sys_read(fd,buf,count),fd);
1066         return ret;
1067 }
1068
1069 asmlinkage int sunos_readv(unsigned long fd, const struct iovec * vector, long count)
1070 {
1071         int ret;
1072
1073         ret = check_nonblock(sys_readv(fd,vector,count),fd);
1074         return ret;
1075 }
1076
1077 asmlinkage int sunos_write(unsigned int fd,char *buf,int count)
1078 {
1079         int ret;
1080
1081         ret = check_nonblock(sys_write(fd,buf,count),fd);
1082         return ret;
1083 }
1084
1085 asmlinkage int sunos_writev(unsigned long fd, const struct iovec * vector, long count)
1086 {
1087         int ret;
1088
1089         ret = check_nonblock(sys_writev(fd,vector,count),fd);
1090         return ret;
1091 }
1092
1093 asmlinkage int sunos_recv(int fd, void * ubuf, int size, unsigned flags)
1094 {
1095         int ret;
1096
1097         ret = check_nonblock(sys_recv(fd,ubuf,size,flags),fd);
1098         return ret;
1099 }
1100
1101 asmlinkage int sunos_send(int fd, void * buff, int len, unsigned flags)
1102 {
1103         int ret;
1104
1105         ret = check_nonblock(sys_send(fd,buff,len,flags),fd);
1106         return ret;
1107 }
1108
1109 extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
1110                                      char *optval, int optlen);
1111
1112 asmlinkage int sunos_socket(int family, int type, int protocol)
1113 {
1114         int ret, one = 1;
1115
1116         ret = sys_socket(family, type, protocol);
1117         if (ret < 0)
1118                 goto out;
1119
1120         sys_setsockopt(ret, SOL_SOCKET, SO_BSDCOMPAT,
1121                        (char *)&one, sizeof(one));
1122 out:
1123         return ret;
1124 }
1125
1126 asmlinkage int sunos_accept(int fd, struct sockaddr *sa, int *addrlen)
1127 {
1128         int ret, one = 1;
1129
1130         while (1) {
1131                 ret = check_nonblock(sys_accept(fd,sa,addrlen),fd);     
1132                 if (ret != -ENETUNREACH && ret != -EHOSTUNREACH)
1133                         break;
1134         }
1135         if (ret < 0)
1136                 goto out;
1137
1138         sys_setsockopt(ret, SOL_SOCKET, SO_BSDCOMPAT,
1139                        (char *)&one, sizeof(one));
1140 out:
1141         return ret;
1142 }
1143
1144 #define SUNOS_SV_INTERRUPT 2
1145
1146 asmlinkage int
1147 sunos_sigaction(int sig, const struct old_sigaction *act,
1148                 struct old_sigaction *oact)
1149 {
1150         struct k_sigaction new_ka, old_ka;
1151         int ret;
1152
1153         if(act) {
1154                 old_sigset_t mask;
1155
1156                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
1157                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
1158                     __get_user(new_ka.sa.sa_flags, &act->sa_flags))
1159                         return -EFAULT;
1160                 __get_user(mask, &act->sa_mask);
1161                 new_ka.sa.sa_restorer = NULL;
1162                 new_ka.ka_restorer = NULL;
1163                 siginitset(&new_ka.sa.sa_mask, mask);
1164                 new_ka.sa.sa_flags ^= SUNOS_SV_INTERRUPT;
1165         }
1166
1167         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
1168
1169         if (!ret && oact) {
1170                 /* In the clone() case we could copy half consistant
1171                  * state to the user, however this could sleep and
1172                  * deadlock us if we held the signal lock on SMP.  So for
1173                  * now I take the easy way out and do no locking.
1174                  * But then again we don't support SunOS lwp's anyways ;-)
1175                  */
1176                 old_ka.sa.sa_flags ^= SUNOS_SV_INTERRUPT;
1177                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
1178                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
1179                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags))
1180                          return -EFAULT;
1181                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
1182         }
1183
1184         return ret;
1185 }
1186
1187
1188 extern asmlinkage int sys_setsockopt(int fd, int level, int optname, char *optval, int optlen);
1189 extern asmlinkage int sys_getsockopt(int fd, int level, int optname, char *optval, int *optlen);
1190
1191 asmlinkage int sunos_setsockopt(int fd, int level, int optname, char *optval,
1192                                 int optlen)
1193 {
1194         int tr_opt = optname;
1195         int ret;
1196
1197         if (level == SOL_IP) {
1198                 /* Multicast socketopts (ttl, membership) */
1199                 if (tr_opt >=2 && tr_opt <= 6)
1200                         tr_opt += 30;
1201         }
1202         ret = sys_setsockopt(fd, level, tr_opt, optval, optlen);
1203         return ret;
1204 }
1205
1206 asmlinkage int sunos_getsockopt(int fd, int level, int optname, char *optval,
1207                                 int *optlen)
1208 {
1209         int tr_opt = optname;
1210         int ret;
1211
1212         if (level == SOL_IP) {
1213                 /* Multicast socketopts (ttl, membership) */
1214                 if (tr_opt >=2 && tr_opt <= 6)
1215                         tr_opt += 30;
1216         }
1217         ret = sys_getsockopt(fd, level, tr_opt, optval, optlen);
1218         return ret;
1219 }