开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sys_sunos.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：29k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

sys_sunos.c：源码内容
  1. /* $Id: sys_sunos.c,v 1.135 2001/08/13 14:40:10 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.  */
  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>
  37. #include <asm/uaccess.h>
  38. #ifndef KERNEL_DS
  39. #include <linux/segment.h>
  40. #endif
  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>
  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>
  56. /* for sunos_select */
  57. #include <linux/time.h>
  58. #include <linux/personality.h>
  60. /* NR_OPEN is now larger and dynamic in recent kernels. */
  61. #define SUNOS_NR_OPEN 256
  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;
  71. if(flags & MAP_NORESERVE) {
  72. static int cnt;
  73. if (cnt++ < 10)
  74. printk("%s: unimplemented SunOS MAP_NORESERVE mmap() flagn",
  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. }
  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;
  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;
  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. }
  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);
  125. out_putf:
  126. if (file)
  127. fput(file);
  128. out:
  129. return retval;
  130. }
  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. }
  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;
  148. down_write(&current->mm->mmap_sem);
  149. if(ARCH_SUN4C_SUN4) {
  150. if(brk >= 0x20000000 && brk < 0xe0000000) {
  151. goto out;
  152. }
  153. }
  155. if (brk < current->mm->end_code)
  156. goto out;
  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. }
  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;
  184. /*
  185.  * Check against existing mmap mappings.
  186.  */
  187. if (find_vma_intersection(current->mm, oldbrk, newbrk+PAGE_SIZE))
  188. goto out;
  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. }
  215. asmlinkage unsigned long sunos_sbrk(int increment)
  216. {
  217. int error;
  218. unsigned long oldbrk;
  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. }
  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 unsupportedn",
  239.        current->comm, increment);
  240. unlock_kernel();
  241. return -1;
  242. }
  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. };
  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 strategyn",
  263.        current->comm,
  264.        strategy <= 3 ? vstrings[strategy] : "BOGUS");
  265. unlock_kernel();
  266. }
  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. }
  277. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  279. asmlinkage unsigned long sunos_sigblock(unsigned long blk_mask)
  280. {
  281. unsigned long old;
  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. }
  291. asmlinkage unsigned long sunos_sigsetmask(unsigned long newmask)
  292. {
  293. unsigned long retval;
  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. }
  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. };
  314. struct sunos_dirent_callback {
  315.     struct sunos_dirent *curr;
  316.     struct sunos_dirent *previous;
  317.     int count;
  318.     int error;
  319. };
  321. #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
  322. #define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
  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);
  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. }
  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;
  357. if (fd >= SUNOS_NR_OPEN)
  358. goto out;
  360. file = fget(fd);
  361. if (!file)
  362. goto out;
  364. error = -EINVAL;
  365. if (cnt < (sizeof(struct sunos_dirent) + 255))
  366. goto out_putf;
  368. buf.curr = (struct sunos_dirent *) dirent;
  369. buf.previous = NULL;
  370. buf.count = cnt;
  371. buf.error = 0;
  373. error = vfs_readdir(file, sunos_filldir, &buf);
  374. if (error < 0)
  375. goto out_putf;
  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. }
  384. out_putf:
  385. fput(file);
  386. out:
  387. return error;
  388. }
  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. };
  398. struct sunos_direntry_callback {
  399.     struct sunos_direntry *curr;
  400.     struct sunos_direntry *previous;
  401.     int count;
  402.     int error;
  403. };
  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);
  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. }
  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;
  436. if (fd >= SUNOS_NR_OPEN)
  437. goto out;
  439. file = fget(fd);
  440. if (!file)
  441. goto out;
  443. error = -EINVAL;
  444. if(cnt < (sizeof(struct sunos_direntry) + 255))
  445. goto out_putf;
  447. buf.curr = (struct sunos_direntry *) dirent;
  448. buf.previous = NULL;
  449. buf.count = cnt;
  450. buf.error = 0;
  452. error = vfs_readdir(file, sunos_filldirentry, &buf);
  453. if (error < 0)
  454. goto out_putf;
  456. lastdirent = buf.previous;
  457. error = buf.error;
  458. if (lastdirent) {
  459. put_user(file->f_pos, basep);
  460. error = cnt - buf.count;
  461. }
  463. out_putf:
  464. fput(file);
  465. out:
  466. return error;
  467. }
  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. };
  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('', &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. }
  494. asmlinkage int sunos_nosys(void)
  495. {
  496. struct pt_regs *regs;
  497. siginfo_t info;
  498. static int cnt;
  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. }
  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;
  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. }
  557. asmlinkage int sunos_pathconf(char *path, int name)
  558. {
  559. int ret;
  561. ret = sunos_fpathconf(0, name); /* XXX cheese XXX */
  562. return ret;
  563. }
  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);
  569. asmlinkage int sunos_select(int width, fd_set *inp, fd_set *outp, fd_set *exp, struct timeval *tvp)
  570. {
  571. int ret;
  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;
  578. __get_user(sec, &tvp->tv_sec);
  579. __get_user(usec, &tvp->tv_usec);
  581. if (sec == 0 && usec == 0)
  582. ret = 0;
  583. }
  584. return ret;
  585. }
  587. asmlinkage void sunos_nop(void)
  588. {
  589. return;
  590. }
  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
  602. struct sunos_fh_t {
  603. char fh_data [NFS_FHSIZE];
  604. };
  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. };
  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);
  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;
  643. file = fget(fd);
  644. if (!file)
  645. goto out;
  647. inode = file->f_dentry->d_inode;
  649. socket = &inode->u.socket_i;
  650. local.sin_family = AF_INET;
  651. local.sin_addr.s_addr = INADDR_ANY;
  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));
  661. if (ret)
  662. goto out_putf;
  664. server.sin_family = AF_INET;
  665. server.sin_addr = addr->sin_addr;
  666. server.sin_port = NFS_PORT;
  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;
  674. out_putf:
  675. fput(file);
  676. out:
  677. return result;
  678. }
  680. static int get_default (int value, int def_value)
  681. {
  682.     if (value)
  683. return value;
  684.     else
  685. return def_value;
  686. }
  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;
  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;
  704. server_fd = sys_socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  705. if (server_fd < 0)
  706. return -ENXIO;
  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. }
  716. if (!sunos_nfs_get_server_fd (server_fd, &linux_nfs_mount.addr)){
  717. sys_close (server_fd);
  718. return -ENXIO;
  719. }
  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;
  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;
  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;
  736. the_name = getname(sunos_mount.hostname);
  737. if(IS_ERR(the_name))
  738. return PTR_ERR(the_name);
  740. strncpy (linux_nfs_mount.hostname, the_name, 254);
  741. linux_nfs_mount.hostname [255] = 0;
  742. putname (the_name);
  744. return do_mount ("", dir_name, "nfs", linux_flags, &linux_nfs_mount);
  745. }
  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;
  755. if (!capable (CAP_SYS_ADMIN))
  756. return -EPERM;
  758. lock_kernel();
  759. /* We don't handle the integer fs type */
  760. if ((flags & SMNT_NEWTYPE) == 0)
  761. goto out;
  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;
  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;
  774. dir_page = getname(dir);
  775. ret = PTR_ERR(dir_page);
  776. if (IS_ERR(dir_page))
  777. goto out;
  779. type_page = getname(type);
  780. ret = PTR_ERR(type_page);
  781. if (IS_ERR(type_page))
  782. goto out1;
  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. }
  816. extern asmlinkage int sys_setsid(void);
  817. extern asmlinkage int sys_setpgid(pid_t, pid_t);
  819. asmlinkage int sunos_setpgrp(pid_t pid, pid_t pgid)
  820. {
  821. int ret;
  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. }
  834. /* So stupid... */
  835. asmlinkage int sunos_wait4(pid_t pid, unsigned int *stat_addr, int options, struct rusage *ru)
  836. {
  837. int ret;
  839. ret = sys_wait4((pid ? pid : -1), stat_addr, options, ru);
  840. return ret;
  841. }
  843. extern int kill_pg(int, int, int);
  844. asmlinkage int sunos_killpg(int pgrp, int sig)
  845. {
  846. int ret;
  848. lock_kernel();
  849. ret = kill_pg(pgrp, sig, 0);
  850. unlock_kernel();
  851. return ret;
  852. }
  854. asmlinkage int sunos_audit(void)
  855. {
  856. lock_kernel();
  857. printk ("sys_auditn");
  858. unlock_kernel();
  859. return -1;
  860. }
  862. extern asmlinkage unsigned long sunos_gethostid(void)
  863. {
  864. unsigned long ret;
  866. lock_kernel();
  867. ret = ((unsigned long)idprom->id_machtype << 24) |
  868. (unsigned long)idprom->id_sernum;
  869. unlock_kernel();
  870. return ret;
  871. }
  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
  883. extern asmlinkage long sunos_sysconf (int name)
  884. {
  885. long ret;
  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. }
  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;
  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. }
  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;
  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. }
  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;
  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. }
  1032. #define SUNOS_EWOULDBLOCK 35
  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) */
  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. }
  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);
  1061. asmlinkage int sunos_read(unsigned int fd,char *buf,int count)
  1062. {
  1063. int ret;
  1065. ret = check_nonblock(sys_read(fd,buf,count),fd);
  1066. return ret;
  1067. }
  1069. asmlinkage int sunos_readv(unsigned long fd, const struct iovec * vector, long count)
  1070. {
  1071. int ret;
  1073. ret = check_nonblock(sys_readv(fd,vector,count),fd);
  1074. return ret;
  1075. }
  1077. asmlinkage int sunos_write(unsigned int fd,char *buf,int count)
  1078. {
  1079. int ret;
  1081. ret = check_nonblock(sys_write(fd,buf,count),fd);
  1082. return ret;
  1083. }
  1085. asmlinkage int sunos_writev(unsigned long fd, const struct iovec * vector, long count)
  1086. {
  1087. int ret;
  1089. ret = check_nonblock(sys_writev(fd,vector,count),fd);
  1090. return ret;
  1091. }
  1093. asmlinkage int sunos_recv(int fd, void * ubuf, int size, unsigned flags)
  1094. {
  1095. int ret;
  1097. ret = check_nonblock(sys_recv(fd,ubuf,size,flags),fd);
  1098. return ret;
  1099. }
  1101. asmlinkage int sunos_send(int fd, void * buff, int len, unsigned flags)
  1102. {
  1103. int ret;
  1105. ret = check_nonblock(sys_send(fd,buff,len,flags),fd);
  1106. return ret;
  1107. }
  1109. extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
  1110.      char *optval, int optlen);
  1112. asmlinkage int sunos_socket(int family, int type, int protocol)
  1113. {
  1114. int ret, one = 1;
  1116. ret = sys_socket(family, type, protocol);
  1117. if (ret < 0)
  1118. goto out;
  1120. sys_setsockopt(ret, SOL_SOCKET, SO_BSDCOMPAT,
  1121.        (char *)&one, sizeof(one));
  1122. out:
  1123. return ret;
  1124. }
  1126. asmlinkage int sunos_accept(int fd, struct sockaddr *sa, int *addrlen)
  1127. {
  1128. int ret, one = 1;
  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;
  1138. sys_setsockopt(ret, SOL_SOCKET, SO_BSDCOMPAT,
  1139.        (char *)&one, sizeof(one));
  1140. out:
  1141. return ret;
  1142. }
  1144. #define SUNOS_SV_INTERRUPT 2
  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;
  1153. if(act) {
  1154. old_sigset_t mask;
  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. }
  1167. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  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. }
  1184. return ret;
  1185. }
  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);
  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;
  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. }
  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;
  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. }