PageRenderTime 29ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/mips/kernel/sysirix.c

https://bitbucket.org/evzijst/gittest
C | 2179 lines | 1793 code | 313 blank | 73 comment | 144 complexity | 1aed4eba76f6dc59e4700c26d443a59a MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0

Large files files are truncated, but you can click here to view the full file

  1. /*
  2. * sysirix.c: IRIX system call emulation.
  3. *
  4. * Copyright (C) 1996 David S. Miller
  5. * Copyright (C) 1997 Miguel de Icaza
  6. * Copyright (C) 1997, 1998, 1999, 2000 Ralf Baechle
  7. */
  8. #include <linux/kernel.h>
  9. #include <linux/sched.h>
  10. #include <linux/binfmts.h>
  11. #include <linux/highuid.h>
  12. #include <linux/pagemap.h>
  13. #include <linux/mm.h>
  14. #include <linux/mman.h>
  15. #include <linux/slab.h>
  16. #include <linux/swap.h>
  17. #include <linux/errno.h>
  18. #include <linux/time.h>
  19. #include <linux/timex.h>
  20. #include <linux/times.h>
  21. #include <linux/elf.h>
  22. #include <linux/msg.h>
  23. #include <linux/shm.h>
  24. #include <linux/smp.h>
  25. #include <linux/smp_lock.h>
  26. #include <linux/utsname.h>
  27. #include <linux/file.h>
  28. #include <linux/vfs.h>
  29. #include <linux/namei.h>
  30. #include <linux/socket.h>
  31. #include <linux/security.h>
  32. #include <linux/syscalls.h>
  33. #include <asm/ptrace.h>
  34. #include <asm/page.h>
  35. #include <asm/uaccess.h>
  36. #include <asm/inventory.h>
  37. /* 2,191 lines of complete and utter shit coming up... */
  38. extern int max_threads;
  39. /* The sysmp commands supported thus far. */
  40. #define MP_NPROCS 1 /* # processor in complex */
  41. #define MP_NAPROCS 2 /* # active processors in complex */
  42. #define MP_PGSIZE 14 /* Return system page size in v1. */
  43. asmlinkage int irix_sysmp(struct pt_regs *regs)
  44. {
  45. unsigned long cmd;
  46. int base = 0;
  47. int error = 0;
  48. if(regs->regs[2] == 1000)
  49. base = 1;
  50. cmd = regs->regs[base + 4];
  51. switch(cmd) {
  52. case MP_PGSIZE:
  53. error = PAGE_SIZE;
  54. break;
  55. case MP_NPROCS:
  56. case MP_NAPROCS:
  57. error = num_online_cpus();
  58. break;
  59. default:
  60. printk("SYSMP[%s:%d]: Unsupported opcode %d\n",
  61. current->comm, current->pid, (int)cmd);
  62. error = -EINVAL;
  63. break;
  64. }
  65. return error;
  66. }
  67. /* The prctl commands. */
  68. #define PR_MAXPROCS 1 /* Tasks/user. */
  69. #define PR_ISBLOCKED 2 /* If blocked, return 1. */
  70. #define PR_SETSTACKSIZE 3 /* Set largest task stack size. */
  71. #define PR_GETSTACKSIZE 4 /* Get largest task stack size. */
  72. #define PR_MAXPPROCS 5 /* Num parallel tasks. */
  73. #define PR_UNBLKONEXEC 6 /* When task exec/exit's, unblock. */
  74. #define PR_SETEXITSIG 8 /* When task exit's, set signal. */
  75. #define PR_RESIDENT 9 /* Make task unswappable. */
  76. #define PR_ATTACHADDR 10 /* (Re-)Connect a vma to a task. */
  77. #define PR_DETACHADDR 11 /* Disconnect a vma from a task. */
  78. #define PR_TERMCHILD 12 /* When parent sleeps with fishes, kill child. */
  79. #define PR_GETSHMASK 13 /* Get the sproc() share mask. */
  80. #define PR_GETNSHARE 14 /* Number of share group members. */
  81. #define PR_COREPID 15 /* Add task pid to name when it core. */
  82. #define PR_ATTACHADDRPERM 16 /* (Re-)Connect vma, with specified prot. */
  83. #define PR_PTHREADEXIT 17 /* Kill a pthread without prejudice. */
  84. asmlinkage int irix_prctl(struct pt_regs *regs)
  85. {
  86. unsigned long cmd;
  87. int error = 0, base = 0;
  88. if (regs->regs[2] == 1000)
  89. base = 1;
  90. cmd = regs->regs[base + 4];
  91. switch (cmd) {
  92. case PR_MAXPROCS:
  93. printk("irix_prctl[%s:%d]: Wants PR_MAXPROCS\n",
  94. current->comm, current->pid);
  95. error = max_threads;
  96. break;
  97. case PR_ISBLOCKED: {
  98. struct task_struct *task;
  99. printk("irix_prctl[%s:%d]: Wants PR_ISBLOCKED\n",
  100. current->comm, current->pid);
  101. read_lock(&tasklist_lock);
  102. task = find_task_by_pid(regs->regs[base + 5]);
  103. error = -ESRCH;
  104. if (error)
  105. error = (task->run_list.next != NULL);
  106. read_unlock(&tasklist_lock);
  107. /* Can _your_ OS find this out that fast? */
  108. break;
  109. }
  110. case PR_SETSTACKSIZE: {
  111. long value = regs->regs[base + 5];
  112. printk("irix_prctl[%s:%d]: Wants PR_SETSTACKSIZE<%08lx>\n",
  113. current->comm, current->pid, (unsigned long) value);
  114. if (value > RLIM_INFINITY)
  115. value = RLIM_INFINITY;
  116. if (capable(CAP_SYS_ADMIN)) {
  117. task_lock(current->group_leader);
  118. current->signal->rlim[RLIMIT_STACK].rlim_max =
  119. current->signal->rlim[RLIMIT_STACK].rlim_cur = value;
  120. task_unlock(current->group_leader);
  121. error = value;
  122. break;
  123. }
  124. task_lock(current->group_leader);
  125. if (value > current->signal->rlim[RLIMIT_STACK].rlim_max) {
  126. error = -EINVAL;
  127. task_unlock(current->group_leader);
  128. break;
  129. }
  130. current->signal->rlim[RLIMIT_STACK].rlim_cur = value;
  131. task_unlock(current->group_leader);
  132. error = value;
  133. break;
  134. }
  135. case PR_GETSTACKSIZE:
  136. printk("irix_prctl[%s:%d]: Wants PR_GETSTACKSIZE\n",
  137. current->comm, current->pid);
  138. error = current->signal->rlim[RLIMIT_STACK].rlim_cur;
  139. break;
  140. case PR_MAXPPROCS:
  141. printk("irix_prctl[%s:%d]: Wants PR_MAXPROCS\n",
  142. current->comm, current->pid);
  143. error = 1;
  144. break;
  145. case PR_UNBLKONEXEC:
  146. printk("irix_prctl[%s:%d]: Wants PR_UNBLKONEXEC\n",
  147. current->comm, current->pid);
  148. error = -EINVAL;
  149. break;
  150. case PR_SETEXITSIG:
  151. printk("irix_prctl[%s:%d]: Wants PR_SETEXITSIG\n",
  152. current->comm, current->pid);
  153. /* We can probably play some game where we set the task
  154. * exit_code to some non-zero value when this is requested,
  155. * and check whether exit_code is already set in do_exit().
  156. */
  157. error = -EINVAL;
  158. break;
  159. case PR_RESIDENT:
  160. printk("irix_prctl[%s:%d]: Wants PR_RESIDENT\n",
  161. current->comm, current->pid);
  162. error = 0; /* Compatibility indeed. */
  163. break;
  164. case PR_ATTACHADDR:
  165. printk("irix_prctl[%s:%d]: Wants PR_ATTACHADDR\n",
  166. current->comm, current->pid);
  167. error = -EINVAL;
  168. break;
  169. case PR_DETACHADDR:
  170. printk("irix_prctl[%s:%d]: Wants PR_DETACHADDR\n",
  171. current->comm, current->pid);
  172. error = -EINVAL;
  173. break;
  174. case PR_TERMCHILD:
  175. printk("irix_prctl[%s:%d]: Wants PR_TERMCHILD\n",
  176. current->comm, current->pid);
  177. error = -EINVAL;
  178. break;
  179. case PR_GETSHMASK:
  180. printk("irix_prctl[%s:%d]: Wants PR_GETSHMASK\n",
  181. current->comm, current->pid);
  182. error = -EINVAL; /* Until I have the sproc() stuff in. */
  183. break;
  184. case PR_GETNSHARE:
  185. error = 0; /* Until I have the sproc() stuff in. */
  186. break;
  187. case PR_COREPID:
  188. printk("irix_prctl[%s:%d]: Wants PR_COREPID\n",
  189. current->comm, current->pid);
  190. error = -EINVAL;
  191. break;
  192. case PR_ATTACHADDRPERM:
  193. printk("irix_prctl[%s:%d]: Wants PR_ATTACHADDRPERM\n",
  194. current->comm, current->pid);
  195. error = -EINVAL;
  196. break;
  197. case PR_PTHREADEXIT:
  198. printk("irix_prctl[%s:%d]: Wants PR_PTHREADEXIT\n",
  199. current->comm, current->pid);
  200. do_exit(regs->regs[base + 5]);
  201. default:
  202. printk("irix_prctl[%s:%d]: Non-existant opcode %d\n",
  203. current->comm, current->pid, (int)cmd);
  204. error = -EINVAL;
  205. break;
  206. }
  207. return error;
  208. }
  209. #undef DEBUG_PROCGRPS
  210. extern unsigned long irix_mapelf(int fd, struct elf_phdr *user_phdrp, int cnt);
  211. extern int getrusage(struct task_struct *p, int who, struct rusage __user *ru);
  212. extern char *prom_getenv(char *name);
  213. extern long prom_setenv(char *name, char *value);
  214. /* The syssgi commands supported thus far. */
  215. #define SGI_SYSID 1 /* Return unique per-machine identifier. */
  216. #define SGI_INVENT 5 /* Fetch inventory */
  217. # define SGI_INV_SIZEOF 1
  218. # define SGI_INV_READ 2
  219. #define SGI_RDNAME 6 /* Return string name of a process. */
  220. #define SGI_SETNVRAM 8 /* Set PROM variable. */
  221. #define SGI_GETNVRAM 9 /* Get PROM variable. */
  222. #define SGI_SETPGID 21 /* Set process group id. */
  223. #define SGI_SYSCONF 22 /* POSIX sysconf garbage. */
  224. #define SGI_PATHCONF 24 /* POSIX sysconf garbage. */
  225. #define SGI_SETGROUPS 40 /* POSIX sysconf garbage. */
  226. #define SGI_GETGROUPS 41 /* POSIX sysconf garbage. */
  227. #define SGI_RUSAGE 56 /* BSD style rusage(). */
  228. #define SGI_SSYNC 62 /* Synchronous fs sync. */
  229. #define SGI_GETSID 65 /* SysVr4 get session id. */
  230. #define SGI_ELFMAP 68 /* Map an elf image. */
  231. #define SGI_TOSSTSAVE 108 /* Toss saved vma's. */
  232. #define SGI_FP_BCOPY 129 /* Should FPU bcopy be used on this machine? */
  233. #define SGI_PHYSP 1011 /* Translate virtual into physical page. */
  234. asmlinkage int irix_syssgi(struct pt_regs *regs)
  235. {
  236. unsigned long cmd;
  237. int retval, base = 0;
  238. if (regs->regs[2] == 1000)
  239. base = 1;
  240. cmd = regs->regs[base + 4];
  241. switch(cmd) {
  242. case SGI_SYSID: {
  243. char *buf = (char *) regs->regs[base + 5];
  244. /* XXX Use ethernet addr.... */
  245. retval = clear_user(buf, 64);
  246. break;
  247. }
  248. #if 0
  249. case SGI_RDNAME: {
  250. int pid = (int) regs->regs[base + 5];
  251. char *buf = (char *) regs->regs[base + 6];
  252. struct task_struct *p;
  253. char tcomm[sizeof(current->comm)];
  254. if (!access_ok(VERIFY_WRITE, buf, sizeof(tcomm))) {
  255. retval = -EFAULT;
  256. break;
  257. }
  258. read_lock(&tasklist_lock);
  259. p = find_task_by_pid(pid);
  260. if (!p) {
  261. read_unlock(&tasklist_lock);
  262. retval = -ESRCH;
  263. break;
  264. }
  265. get_task_comm(tcomm, p);
  266. read_unlock(&tasklist_lock);
  267. /* XXX Need to check sizes. */
  268. copy_to_user(buf, tcomm, sizeof(tcomm));
  269. retval = 0;
  270. break;
  271. }
  272. case SGI_GETNVRAM: {
  273. char *name = (char *) regs->regs[base+5];
  274. char *buf = (char *) regs->regs[base+6];
  275. char *value;
  276. return -EINVAL; /* til I fix it */
  277. if (!access_ok(VERIFY_WRITE, buf, 128)) {
  278. retval = -EFAULT;
  279. break;
  280. }
  281. value = prom_getenv(name); /* PROM lock? */
  282. if (!value) {
  283. retval = -EINVAL;
  284. break;
  285. }
  286. /* Do I strlen() for the length? */
  287. copy_to_user(buf, value, 128);
  288. retval = 0;
  289. break;
  290. }
  291. case SGI_SETNVRAM: {
  292. char *name = (char *) regs->regs[base+5];
  293. char *value = (char *) regs->regs[base+6];
  294. return -EINVAL; /* til I fix it */
  295. retval = prom_setenv(name, value);
  296. /* XXX make sure retval conforms to syssgi(2) */
  297. printk("[%s:%d] setnvram(\"%s\", \"%s\"): retval %d",
  298. current->comm, current->pid, name, value, retval);
  299. /* if (retval == PROM_ENOENT)
  300. retval = -ENOENT; */
  301. break;
  302. }
  303. #endif
  304. case SGI_SETPGID: {
  305. #ifdef DEBUG_PROCGRPS
  306. printk("[%s:%d] setpgid(%d, %d) ",
  307. current->comm, current->pid,
  308. (int) regs->regs[base + 5], (int)regs->regs[base + 6]);
  309. #endif
  310. retval = sys_setpgid(regs->regs[base + 5], regs->regs[base + 6]);
  311. #ifdef DEBUG_PROCGRPS
  312. printk("retval=%d\n", retval);
  313. #endif
  314. }
  315. case SGI_SYSCONF: {
  316. switch(regs->regs[base + 5]) {
  317. case 1:
  318. retval = (MAX_ARG_PAGES >> 4); /* XXX estimate... */
  319. goto out;
  320. case 2:
  321. retval = max_threads;
  322. goto out;
  323. case 3:
  324. retval = HZ;
  325. goto out;
  326. case 4:
  327. retval = NGROUPS_MAX;
  328. goto out;
  329. case 5:
  330. retval = NR_OPEN;
  331. goto out;
  332. case 6:
  333. retval = 1;
  334. goto out;
  335. case 7:
  336. retval = 1;
  337. goto out;
  338. case 8:
  339. retval = 199009;
  340. goto out;
  341. case 11:
  342. retval = PAGE_SIZE;
  343. goto out;
  344. case 12:
  345. retval = 4;
  346. goto out;
  347. case 25:
  348. case 26:
  349. case 27:
  350. case 28:
  351. case 29:
  352. case 30:
  353. retval = 0;
  354. goto out;
  355. case 31:
  356. retval = 32;
  357. goto out;
  358. default:
  359. retval = -EINVAL;
  360. goto out;
  361. };
  362. }
  363. case SGI_SETGROUPS:
  364. retval = sys_setgroups((int) regs->regs[base + 5],
  365. (gid_t *) regs->regs[base + 6]);
  366. break;
  367. case SGI_GETGROUPS:
  368. retval = sys_getgroups((int) regs->regs[base + 5],
  369. (gid_t *) regs->regs[base + 6]);
  370. break;
  371. case SGI_RUSAGE: {
  372. struct rusage *ru = (struct rusage *) regs->regs[base + 6];
  373. switch((int) regs->regs[base + 5]) {
  374. case 0:
  375. /* rusage self */
  376. retval = getrusage(current, RUSAGE_SELF, ru);
  377. goto out;
  378. case -1:
  379. /* rusage children */
  380. retval = getrusage(current, RUSAGE_CHILDREN, ru);
  381. goto out;
  382. default:
  383. retval = -EINVAL;
  384. goto out;
  385. };
  386. }
  387. case SGI_SSYNC:
  388. sys_sync();
  389. retval = 0;
  390. break;
  391. case SGI_GETSID:
  392. #ifdef DEBUG_PROCGRPS
  393. printk("[%s:%d] getsid(%d) ", current->comm, current->pid,
  394. (int) regs->regs[base + 5]);
  395. #endif
  396. retval = sys_getsid(regs->regs[base + 5]);
  397. #ifdef DEBUG_PROCGRPS
  398. printk("retval=%d\n", retval);
  399. #endif
  400. break;
  401. case SGI_ELFMAP:
  402. retval = irix_mapelf((int) regs->regs[base + 5],
  403. (struct elf_phdr *) regs->regs[base + 6],
  404. (int) regs->regs[base + 7]);
  405. break;
  406. case SGI_TOSSTSAVE:
  407. /* XXX We don't need to do anything? */
  408. retval = 0;
  409. break;
  410. case SGI_FP_BCOPY:
  411. retval = 0;
  412. break;
  413. case SGI_PHYSP: {
  414. unsigned long addr = regs->regs[base + 5];
  415. int *pageno = (int *) (regs->regs[base + 6]);
  416. struct mm_struct *mm = current->mm;
  417. pgd_t *pgdp;
  418. pmd_t *pmdp;
  419. pte_t *ptep;
  420. if (!access_ok(VERIFY_WRITE, pageno, sizeof(int)))
  421. return -EFAULT;
  422. down_read(&mm->mmap_sem);
  423. pgdp = pgd_offset(mm, addr);
  424. pmdp = pmd_offset(pgdp, addr);
  425. ptep = pte_offset(pmdp, addr);
  426. retval = -EINVAL;
  427. if (ptep) {
  428. pte_t pte = *ptep;
  429. if (pte_val(pte) & (_PAGE_VALID | _PAGE_PRESENT)) {
  430. retval = put_user((pte_val(pte) & PAGE_MASK) >>
  431. PAGE_SHIFT, pageno);
  432. }
  433. }
  434. up_read(&mm->mmap_sem);
  435. break;
  436. }
  437. case SGI_INVENT: {
  438. int arg1 = (int) regs->regs [base + 5];
  439. void *buffer = (void *) regs->regs [base + 6];
  440. int count = (int) regs->regs [base + 7];
  441. switch (arg1) {
  442. case SGI_INV_SIZEOF:
  443. retval = sizeof (inventory_t);
  444. break;
  445. case SGI_INV_READ:
  446. retval = dump_inventory_to_user (buffer, count);
  447. break;
  448. default:
  449. retval = -EINVAL;
  450. }
  451. break;
  452. }
  453. default:
  454. printk("irix_syssgi: Unsupported command %d\n", (int)cmd);
  455. retval = -EINVAL;
  456. break;
  457. };
  458. out:
  459. return retval;
  460. }
  461. asmlinkage int irix_gtime(struct pt_regs *regs)
  462. {
  463. return get_seconds();
  464. }
  465. /*
  466. * IRIX is completely broken... it returns 0 on success, otherwise
  467. * ENOMEM.
  468. */
  469. asmlinkage int irix_brk(unsigned long brk)
  470. {
  471. unsigned long rlim;
  472. unsigned long newbrk, oldbrk;
  473. struct mm_struct *mm = current->mm;
  474. int ret;
  475. down_write(&mm->mmap_sem);
  476. if (brk < mm->end_code) {
  477. ret = -ENOMEM;
  478. goto out;
  479. }
  480. newbrk = PAGE_ALIGN(brk);
  481. oldbrk = PAGE_ALIGN(mm->brk);
  482. if (oldbrk == newbrk) {
  483. mm->brk = brk;
  484. ret = 0;
  485. goto out;
  486. }
  487. /*
  488. * Always allow shrinking brk
  489. */
  490. if (brk <= mm->brk) {
  491. mm->brk = brk;
  492. do_munmap(mm, newbrk, oldbrk-newbrk);
  493. ret = 0;
  494. goto out;
  495. }
  496. /*
  497. * Check against rlimit and stack..
  498. */
  499. rlim = current->signal->rlim[RLIMIT_DATA].rlim_cur;
  500. if (rlim >= RLIM_INFINITY)
  501. rlim = ~0;
  502. if (brk - mm->end_code > rlim) {
  503. ret = -ENOMEM;
  504. goto out;
  505. }
  506. /*
  507. * Check against existing mmap mappings.
  508. */
  509. if (find_vma_intersection(mm, oldbrk, newbrk+PAGE_SIZE)) {
  510. ret = -ENOMEM;
  511. goto out;
  512. }
  513. /*
  514. * Check if we have enough memory..
  515. */
  516. if (security_vm_enough_memory((newbrk-oldbrk) >> PAGE_SHIFT)) {
  517. ret = -ENOMEM;
  518. goto out;
  519. }
  520. /*
  521. * Ok, looks good - let it rip.
  522. */
  523. mm->brk = brk;
  524. do_brk(oldbrk, newbrk-oldbrk);
  525. ret = 0;
  526. out:
  527. up_write(&mm->mmap_sem);
  528. return ret;
  529. }
  530. asmlinkage int irix_getpid(struct pt_regs *regs)
  531. {
  532. regs->regs[3] = current->real_parent->pid;
  533. return current->pid;
  534. }
  535. asmlinkage int irix_getuid(struct pt_regs *regs)
  536. {
  537. regs->regs[3] = current->euid;
  538. return current->uid;
  539. }
  540. asmlinkage int irix_getgid(struct pt_regs *regs)
  541. {
  542. regs->regs[3] = current->egid;
  543. return current->gid;
  544. }
  545. asmlinkage int irix_stime(int value)
  546. {
  547. int err;
  548. struct timespec tv;
  549. tv.tv_sec = value;
  550. tv.tv_nsec = 0;
  551. err = security_settime(&tv, NULL);
  552. if (err)
  553. return err;
  554. write_seqlock_irq(&xtime_lock);
  555. xtime.tv_sec = value;
  556. xtime.tv_nsec = 0;
  557. time_adjust = 0; /* stop active adjtime() */
  558. time_status |= STA_UNSYNC;
  559. time_maxerror = NTP_PHASE_LIMIT;
  560. time_esterror = NTP_PHASE_LIMIT;
  561. write_sequnlock_irq(&xtime_lock);
  562. return 0;
  563. }
  564. static inline void jiffiestotv(unsigned long jiffies, struct timeval *value)
  565. {
  566. value->tv_usec = (jiffies % HZ) * (1000000 / HZ);
  567. value->tv_sec = jiffies / HZ;
  568. }
  569. static inline void getitimer_real(struct itimerval *value)
  570. {
  571. register unsigned long val, interval;
  572. interval = current->it_real_incr;
  573. val = 0;
  574. if (del_timer(&current->real_timer)) {
  575. unsigned long now = jiffies;
  576. val = current->real_timer.expires;
  577. add_timer(&current->real_timer);
  578. /* look out for negative/zero itimer.. */
  579. if (val <= now)
  580. val = now+1;
  581. val -= now;
  582. }
  583. jiffiestotv(val, &value->it_value);
  584. jiffiestotv(interval, &value->it_interval);
  585. }
  586. asmlinkage unsigned int irix_alarm(unsigned int seconds)
  587. {
  588. struct itimerval it_new, it_old;
  589. unsigned int oldalarm;
  590. if (!seconds) {
  591. getitimer_real(&it_old);
  592. del_timer(&current->real_timer);
  593. } else {
  594. it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
  595. it_new.it_value.tv_sec = seconds;
  596. it_new.it_value.tv_usec = 0;
  597. do_setitimer(ITIMER_REAL, &it_new, &it_old);
  598. }
  599. oldalarm = it_old.it_value.tv_sec;
  600. /*
  601. * ehhh.. We can't return 0 if we have an alarm pending ...
  602. * And we'd better return too much than too little anyway
  603. */
  604. if (it_old.it_value.tv_usec)
  605. oldalarm++;
  606. return oldalarm;
  607. }
  608. asmlinkage int irix_pause(void)
  609. {
  610. current->state = TASK_INTERRUPTIBLE;
  611. schedule();
  612. return -EINTR;
  613. }
  614. /* XXX need more than this... */
  615. asmlinkage int irix_mount(char *dev_name, char *dir_name, unsigned long flags,
  616. char *type, void *data, int datalen)
  617. {
  618. printk("[%s:%d] irix_mount(%p,%p,%08lx,%p,%p,%d)\n",
  619. current->comm, current->pid,
  620. dev_name, dir_name, flags, type, data, datalen);
  621. return sys_mount(dev_name, dir_name, type, flags, data);
  622. }
  623. struct irix_statfs {
  624. short f_type;
  625. long f_bsize, f_frsize, f_blocks, f_bfree, f_files, f_ffree;
  626. char f_fname[6], f_fpack[6];
  627. };
  628. asmlinkage int irix_statfs(const char *path, struct irix_statfs *buf,
  629. int len, int fs_type)
  630. {
  631. struct nameidata nd;
  632. struct kstatfs kbuf;
  633. int error, i;
  634. /* We don't support this feature yet. */
  635. if (fs_type) {
  636. error = -EINVAL;
  637. goto out;
  638. }
  639. if (!access_ok(VERIFY_WRITE, buf, sizeof(struct irix_statfs))) {
  640. error = -EFAULT;
  641. goto out;
  642. }
  643. error = user_path_walk(path, &nd);
  644. if (error)
  645. goto out;
  646. error = vfs_statfs(nd.dentry->d_inode->i_sb, &kbuf);
  647. if (error)
  648. goto dput_and_out;
  649. __put_user(kbuf.f_type, &buf->f_type);
  650. __put_user(kbuf.f_bsize, &buf->f_bsize);
  651. __put_user(kbuf.f_frsize, &buf->f_frsize);
  652. __put_user(kbuf.f_blocks, &buf->f_blocks);
  653. __put_user(kbuf.f_bfree, &buf->f_bfree);
  654. __put_user(kbuf.f_files, &buf->f_files);
  655. __put_user(kbuf.f_ffree, &buf->f_ffree);
  656. for (i = 0; i < 6; i++) {
  657. __put_user(0, &buf->f_fname[i]);
  658. __put_user(0, &buf->f_fpack[i]);
  659. }
  660. error = 0;
  661. dput_and_out:
  662. path_release(&nd);
  663. out:
  664. return error;
  665. }
  666. asmlinkage int irix_fstatfs(unsigned int fd, struct irix_statfs *buf)
  667. {
  668. struct kstatfs kbuf;
  669. struct file *file;
  670. int error, i;
  671. if (!access_ok(VERIFY_WRITE, buf, sizeof(struct irix_statfs))) {
  672. error = -EFAULT;
  673. goto out;
  674. }
  675. if (!(file = fget(fd))) {
  676. error = -EBADF;
  677. goto out;
  678. }
  679. error = vfs_statfs(file->f_dentry->d_inode->i_sb, &kbuf);
  680. if (error)
  681. goto out_f;
  682. __put_user(kbuf.f_type, &buf->f_type);
  683. __put_user(kbuf.f_bsize, &buf->f_bsize);
  684. __put_user(kbuf.f_frsize, &buf->f_frsize);
  685. __put_user(kbuf.f_blocks, &buf->f_blocks);
  686. __put_user(kbuf.f_bfree, &buf->f_bfree);
  687. __put_user(kbuf.f_files, &buf->f_files);
  688. __put_user(kbuf.f_ffree, &buf->f_ffree);
  689. for(i = 0; i < 6; i++) {
  690. __put_user(0, &buf->f_fname[i]);
  691. __put_user(0, &buf->f_fpack[i]);
  692. }
  693. out_f:
  694. fput(file);
  695. out:
  696. return error;
  697. }
  698. asmlinkage int irix_setpgrp(int flags)
  699. {
  700. int error;
  701. #ifdef DEBUG_PROCGRPS
  702. printk("[%s:%d] setpgrp(%d) ", current->comm, current->pid, flags);
  703. #endif
  704. if(!flags)
  705. error = process_group(current);
  706. else
  707. error = sys_setsid();
  708. #ifdef DEBUG_PROCGRPS
  709. printk("returning %d\n", process_group(current));
  710. #endif
  711. return error;
  712. }
  713. asmlinkage int irix_times(struct tms * tbuf)
  714. {
  715. int err = 0;
  716. if (tbuf) {
  717. if (!access_ok(VERIFY_WRITE,tbuf,sizeof *tbuf))
  718. return -EFAULT;
  719. err |= __put_user(current->utime, &tbuf->tms_utime);
  720. err |= __put_user(current->stime, &tbuf->tms_stime);
  721. err |= __put_user(current->signal->cutime, &tbuf->tms_cutime);
  722. err |= __put_user(current->signal->cstime, &tbuf->tms_cstime);
  723. }
  724. return err;
  725. }
  726. asmlinkage int irix_exec(struct pt_regs *regs)
  727. {
  728. int error, base = 0;
  729. char *filename;
  730. if(regs->regs[2] == 1000)
  731. base = 1;
  732. filename = getname((char *) (long)regs->regs[base + 4]);
  733. error = PTR_ERR(filename);
  734. if (IS_ERR(filename))
  735. return error;
  736. error = do_execve(filename, (char **) (long)regs->regs[base + 5],
  737. (char **) 0, regs);
  738. putname(filename);
  739. return error;
  740. }
  741. asmlinkage int irix_exece(struct pt_regs *regs)
  742. {
  743. int error, base = 0;
  744. char *filename;
  745. if (regs->regs[2] == 1000)
  746. base = 1;
  747. filename = getname((char *) (long)regs->regs[base + 4]);
  748. error = PTR_ERR(filename);
  749. if (IS_ERR(filename))
  750. return error;
  751. error = do_execve(filename, (char **) (long)regs->regs[base + 5],
  752. (char **) (long)regs->regs[base + 6], regs);
  753. putname(filename);
  754. return error;
  755. }
  756. asmlinkage unsigned long irix_gethostid(void)
  757. {
  758. printk("[%s:%d]: irix_gethostid() called...\n",
  759. current->comm, current->pid);
  760. return -EINVAL;
  761. }
  762. asmlinkage unsigned long irix_sethostid(unsigned long val)
  763. {
  764. printk("[%s:%d]: irix_sethostid(%08lx) called...\n",
  765. current->comm, current->pid, val);
  766. return -EINVAL;
  767. }
  768. asmlinkage int irix_socket(int family, int type, int protocol)
  769. {
  770. switch(type) {
  771. case 1:
  772. type = SOCK_DGRAM;
  773. break;
  774. case 2:
  775. type = SOCK_STREAM;
  776. break;
  777. case 3:
  778. type = 9; /* Invalid... */
  779. break;
  780. case 4:
  781. type = SOCK_RAW;
  782. break;
  783. case 5:
  784. type = SOCK_RDM;
  785. break;
  786. case 6:
  787. type = SOCK_SEQPACKET;
  788. break;
  789. default:
  790. break;
  791. }
  792. return sys_socket(family, type, protocol);
  793. }
  794. asmlinkage int irix_getdomainname(char *name, int len)
  795. {
  796. int error;
  797. if (!access_ok(VERIFY_WRITE, name, len))
  798. return -EFAULT;
  799. down_read(&uts_sem);
  800. if (len > __NEW_UTS_LEN)
  801. len = __NEW_UTS_LEN;
  802. error = 0;
  803. if (copy_to_user(name, system_utsname.domainname, len))
  804. error = -EFAULT;
  805. up_read(&uts_sem);
  806. return error;
  807. }
  808. asmlinkage unsigned long irix_getpagesize(void)
  809. {
  810. return PAGE_SIZE;
  811. }
  812. asmlinkage int irix_msgsys(int opcode, unsigned long arg0, unsigned long arg1,
  813. unsigned long arg2, unsigned long arg3,
  814. unsigned long arg4)
  815. {
  816. switch (opcode) {
  817. case 0:
  818. return sys_msgget((key_t) arg0, (int) arg1);
  819. case 1:
  820. return sys_msgctl((int) arg0, (int) arg1, (struct msqid_ds *)arg2);
  821. case 2:
  822. return sys_msgrcv((int) arg0, (struct msgbuf *) arg1,
  823. (size_t) arg2, (long) arg3, (int) arg4);
  824. case 3:
  825. return sys_msgsnd((int) arg0, (struct msgbuf *) arg1,
  826. (size_t) arg2, (int) arg3);
  827. default:
  828. return -EINVAL;
  829. }
  830. }
  831. asmlinkage int irix_shmsys(int opcode, unsigned long arg0, unsigned long arg1,
  832. unsigned long arg2, unsigned long arg3)
  833. {
  834. switch (opcode) {
  835. case 0:
  836. return do_shmat((int) arg0, (char *)arg1, (int) arg2,
  837. (unsigned long *) arg3);
  838. case 1:
  839. return sys_shmctl((int)arg0, (int)arg1, (struct shmid_ds *)arg2);
  840. case 2:
  841. return sys_shmdt((char *)arg0);
  842. case 3:
  843. return sys_shmget((key_t) arg0, (int) arg1, (int) arg2);
  844. default:
  845. return -EINVAL;
  846. }
  847. }
  848. asmlinkage int irix_semsys(int opcode, unsigned long arg0, unsigned long arg1,
  849. unsigned long arg2, int arg3)
  850. {
  851. switch (opcode) {
  852. case 0:
  853. return sys_semctl((int) arg0, (int) arg1, (int) arg2,
  854. (union semun) arg3);
  855. case 1:
  856. return sys_semget((key_t) arg0, (int) arg1, (int) arg2);
  857. case 2:
  858. return sys_semop((int) arg0, (struct sembuf *)arg1,
  859. (unsigned int) arg2);
  860. default:
  861. return -EINVAL;
  862. }
  863. }
  864. static inline loff_t llseek(struct file *file, loff_t offset, int origin)
  865. {
  866. loff_t (*fn)(struct file *, loff_t, int);
  867. loff_t retval;
  868. fn = default_llseek;
  869. if (file->f_op && file->f_op->llseek)
  870. fn = file->f_op->llseek;
  871. lock_kernel();
  872. retval = fn(file, offset, origin);
  873. unlock_kernel();
  874. return retval;
  875. }
  876. asmlinkage int irix_lseek64(int fd, int _unused, int offhi, int offlow,
  877. int origin)
  878. {
  879. int retval;
  880. struct file * file;
  881. loff_t offset;
  882. retval = -EBADF;
  883. file = fget(fd);
  884. if (!file)
  885. goto bad;
  886. retval = -EINVAL;
  887. if (origin > 2)
  888. goto out_putf;
  889. offset = llseek(file, ((loff_t) offhi << 32) | offlow, origin);
  890. retval = (int) offset;
  891. out_putf:
  892. fput(file);
  893. bad:
  894. return retval;
  895. }
  896. asmlinkage int irix_sginap(int ticks)
  897. {
  898. current->state = TASK_INTERRUPTIBLE;
  899. schedule_timeout(ticks);
  900. return 0;
  901. }
  902. asmlinkage int irix_sgikopt(char *istring, char *ostring, int len)
  903. {
  904. return -EINVAL;
  905. }
  906. asmlinkage int irix_gettimeofday(struct timeval *tv)
  907. {
  908. time_t sec;
  909. long nsec, seq;
  910. int err;
  911. if (!access_ok(VERIFY_WRITE, tv, sizeof(struct timeval)))
  912. return -EFAULT;
  913. do {
  914. seq = read_seqbegin(&xtime_lock);
  915. sec = xtime.tv_sec;
  916. nsec = xtime.tv_nsec;
  917. } while (read_seqretry(&xtime_lock, seq));
  918. err = __put_user(sec, &tv->tv_sec);
  919. err |= __put_user((nsec / 1000), &tv->tv_usec);
  920. return err;
  921. }
  922. #define IRIX_MAP_AUTOGROW 0x40
  923. asmlinkage unsigned long irix_mmap32(unsigned long addr, size_t len, int prot,
  924. int flags, int fd, off_t offset)
  925. {
  926. struct file *file = NULL;
  927. unsigned long retval;
  928. if (!(flags & MAP_ANONYMOUS)) {
  929. if (!(file = fget(fd)))
  930. return -EBADF;
  931. /* Ok, bad taste hack follows, try to think in something else
  932. * when reading this. */
  933. if (flags & IRIX_MAP_AUTOGROW) {
  934. unsigned long old_pos;
  935. long max_size = offset + len;
  936. if (max_size > file->f_dentry->d_inode->i_size) {
  937. old_pos = sys_lseek (fd, max_size - 1, 0);
  938. sys_write (fd, "", 1);
  939. sys_lseek (fd, old_pos, 0);
  940. }
  941. }
  942. }
  943. flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  944. down_write(&current->mm->mmap_sem);
  945. retval = do_mmap(file, addr, len, prot, flags, offset);
  946. up_write(&current->mm->mmap_sem);
  947. if (file)
  948. fput(file);
  949. return retval;
  950. }
  951. asmlinkage int irix_madvise(unsigned long addr, int len, int behavior)
  952. {
  953. printk("[%s:%d] Wheee.. irix_madvise(%08lx,%d,%d)\n",
  954. current->comm, current->pid, addr, len, behavior);
  955. return -EINVAL;
  956. }
  957. asmlinkage int irix_pagelock(char *addr, int len, int op)
  958. {
  959. printk("[%s:%d] Wheee.. irix_pagelock(%p,%d,%d)\n",
  960. current->comm, current->pid, addr, len, op);
  961. return -EINVAL;
  962. }
  963. asmlinkage int irix_quotactl(struct pt_regs *regs)
  964. {
  965. printk("[%s:%d] Wheee.. irix_quotactl()\n",
  966. current->comm, current->pid);
  967. return -EINVAL;
  968. }
  969. asmlinkage int irix_BSDsetpgrp(int pid, int pgrp)
  970. {
  971. int error;
  972. #ifdef DEBUG_PROCGRPS
  973. printk("[%s:%d] BSDsetpgrp(%d, %d) ", current->comm, current->pid,
  974. pid, pgrp);
  975. #endif
  976. if(!pid)
  977. pid = current->pid;
  978. /* Wheee, weird sysv thing... */
  979. if ((pgrp == 0) && (pid == current->pid))
  980. error = sys_setsid();
  981. else
  982. error = sys_setpgid(pid, pgrp);
  983. #ifdef DEBUG_PROCGRPS
  984. printk("error = %d\n", error);
  985. #endif
  986. return error;
  987. }
  988. asmlinkage int irix_systeminfo(int cmd, char *buf, int cnt)
  989. {
  990. printk("[%s:%d] Wheee.. irix_systeminfo(%d,%p,%d)\n",
  991. current->comm, current->pid, cmd, buf, cnt);
  992. return -EINVAL;
  993. }
  994. struct iuname {
  995. char sysname[257], nodename[257], release[257];
  996. char version[257], machine[257];
  997. char m_type[257], base_rel[257];
  998. char _unused0[257], _unused1[257], _unused2[257];
  999. char _unused3[257], _unused4[257], _unused5[257];
  1000. };
  1001. asmlinkage int irix_uname(struct iuname *buf)
  1002. {
  1003. down_read(&uts_sem);
  1004. if (copy_to_user(system_utsname.sysname, buf->sysname, 65)
  1005. || copy_to_user(system_utsname.nodename, buf->nodename, 65)
  1006. || copy_to_user(system_utsname.release, buf->release, 65)
  1007. || copy_to_user(system_utsname.version, buf->version, 65)
  1008. || copy_to_user(system_utsname.machine, buf->machine, 65)) {
  1009. return -EFAULT;
  1010. }
  1011. up_read(&uts_sem);
  1012. return 1;
  1013. }
  1014. #undef DEBUG_XSTAT
  1015. static int irix_xstat32_xlate(struct kstat *stat, void *ubuf)
  1016. {
  1017. struct xstat32 {
  1018. u32 st_dev, st_pad1[3], st_ino, st_mode, st_nlink, st_uid, st_gid;
  1019. u32 st_rdev, st_pad2[2], st_size, st_pad3;
  1020. u32 st_atime0, st_atime1;
  1021. u32 st_mtime0, st_mtime1;
  1022. u32 st_ctime0, st_ctime1;
  1023. u32 st_blksize, st_blocks;
  1024. char st_fstype[16];
  1025. u32 st_pad4[8];
  1026. } ub;
  1027. if (!sysv_valid_dev(stat->dev) || !sysv_valid_dev(stat->rdev))
  1028. return -EOVERFLOW;
  1029. ub.st_dev = sysv_encode_dev(stat->dev);
  1030. ub.st_ino = stat->ino;
  1031. ub.st_mode = stat->mode;
  1032. ub.st_nlink = stat->nlink;
  1033. SET_UID(ub.st_uid, stat->uid);
  1034. SET_GID(ub.st_gid, stat->gid);
  1035. ub.st_rdev = sysv_encode_dev(stat->rdev);
  1036. #if BITS_PER_LONG == 32
  1037. if (stat->size > MAX_NON_LFS)
  1038. return -EOVERFLOW;
  1039. #endif
  1040. ub.st_size = stat->size;
  1041. ub.st_atime0 = stat->atime.tv_sec;
  1042. ub.st_atime1 = stat->atime.tv_nsec;
  1043. ub.st_mtime0 = stat->mtime.tv_sec;
  1044. ub.st_mtime1 = stat->atime.tv_nsec;
  1045. ub.st_ctime0 = stat->ctime.tv_sec;
  1046. ub.st_ctime1 = stat->atime.tv_nsec;
  1047. ub.st_blksize = stat->blksize;
  1048. ub.st_blocks = stat->blocks;
  1049. strcpy (ub.st_fstype, "efs");
  1050. return copy_to_user(ubuf, &ub, sizeof(ub)) ? -EFAULT : 0;
  1051. }
  1052. static int irix_xstat64_xlate(struct kstat *stat, void *ubuf)
  1053. {
  1054. struct xstat64 {
  1055. u32 st_dev; s32 st_pad1[3];
  1056. unsigned long long st_ino;
  1057. u32 st_mode;
  1058. u32 st_nlink; s32 st_uid; s32 st_gid; u32 st_rdev;
  1059. s32 st_pad2[2];
  1060. long long st_size;
  1061. s32 st_pad3;
  1062. struct { s32 tv_sec, tv_nsec; } st_atime, st_mtime, st_ctime;
  1063. s32 st_blksize;
  1064. long long st_blocks;
  1065. char st_fstype[16];
  1066. s32 st_pad4[8];
  1067. } ks;
  1068. if (!sysv_valid_dev(stat->dev) || !sysv_valid_dev(stat->rdev))
  1069. return -EOVERFLOW;
  1070. ks.st_dev = sysv_encode_dev(stat->dev);
  1071. ks.st_pad1[0] = ks.st_pad1[1] = ks.st_pad1[2] = 0;
  1072. ks.st_ino = (unsigned long long) stat->ino;
  1073. ks.st_mode = (u32) stat->mode;
  1074. ks.st_nlink = (u32) stat->nlink;
  1075. ks.st_uid = (s32) stat->uid;
  1076. ks.st_gid = (s32) stat->gid;
  1077. ks.st_rdev = sysv_encode_dev (stat->rdev);
  1078. ks.st_pad2[0] = ks.st_pad2[1] = 0;
  1079. ks.st_size = (long long) stat->size;
  1080. ks.st_pad3 = 0;
  1081. /* XXX hackety hack... */
  1082. ks.st_atime.tv_sec = (s32) stat->atime.tv_sec;
  1083. ks.st_atime.tv_nsec = stat->atime.tv_nsec;
  1084. ks.st_mtime.tv_sec = (s32) stat->mtime.tv_sec;
  1085. ks.st_mtime.tv_nsec = stat->mtime.tv_nsec;
  1086. ks.st_ctime.tv_sec = (s32) stat->ctime.tv_sec;
  1087. ks.st_ctime.tv_nsec = stat->ctime.tv_nsec;
  1088. ks.st_blksize = (s32) stat->blksize;
  1089. ks.st_blocks = (long long) stat->blocks;
  1090. memset(ks.st_fstype, 0, 16);
  1091. ks.st_pad4[0] = ks.st_pad4[1] = ks.st_pad4[2] = ks.st_pad4[3] = 0;
  1092. ks.st_pad4[4] = ks.st_pad4[5] = ks.st_pad4[6] = ks.st_pad4[7] = 0;
  1093. /* Now write it all back. */
  1094. return copy_to_user(ubuf, &ks, sizeof(ks)) ? -EFAULT : 0;
  1095. }
  1096. asmlinkage int irix_xstat(int version, char *filename, struct stat *statbuf)
  1097. {
  1098. int retval;
  1099. struct kstat stat;
  1100. #ifdef DEBUG_XSTAT
  1101. printk("[%s:%d] Wheee.. irix_xstat(%d,%s,%p) ",
  1102. current->comm, current->pid, version, filename, statbuf);
  1103. #endif
  1104. retval = vfs_stat(filename, &stat);
  1105. if (!retval) {
  1106. switch(version) {
  1107. case 2:
  1108. retval = irix_xstat32_xlate(&stat, statbuf);
  1109. break;
  1110. case 3:
  1111. retval = irix_xstat64_xlate(&stat, statbuf);
  1112. break;
  1113. default:
  1114. retval = -EINVAL;
  1115. }
  1116. }
  1117. return retval;
  1118. }
  1119. asmlinkage int irix_lxstat(int version, char *filename, struct stat *statbuf)
  1120. {
  1121. int error;
  1122. struct kstat stat;
  1123. #ifdef DEBUG_XSTAT
  1124. printk("[%s:%d] Wheee.. irix_lxstat(%d,%s,%p) ",
  1125. current->comm, current->pid, version, filename, statbuf);
  1126. #endif
  1127. error = vfs_lstat(filename, &stat);
  1128. if (!error) {
  1129. switch (version) {
  1130. case 2:
  1131. error = irix_xstat32_xlate(&stat, statbuf);
  1132. break;
  1133. case 3:
  1134. error = irix_xstat64_xlate(&stat, statbuf);
  1135. break;
  1136. default:
  1137. error = -EINVAL;
  1138. }
  1139. }
  1140. return error;
  1141. }
  1142. asmlinkage int irix_fxstat(int version, int fd, struct stat *statbuf)
  1143. {
  1144. int error;
  1145. struct kstat stat;
  1146. #ifdef DEBUG_XSTAT
  1147. printk("[%s:%d] Wheee.. irix_fxstat(%d,%d,%p) ",
  1148. current->comm, current->pid, version, fd, statbuf);
  1149. #endif
  1150. error = vfs_fstat(fd, &stat);
  1151. if (!error) {
  1152. switch (version) {
  1153. case 2:
  1154. error = irix_xstat32_xlate(&stat, statbuf);
  1155. break;
  1156. case 3:
  1157. error = irix_xstat64_xlate(&stat, statbuf);
  1158. break;
  1159. default:
  1160. error = -EINVAL;
  1161. }
  1162. }
  1163. return error;
  1164. }
  1165. asmlinkage int irix_xmknod(int ver, char *filename, int mode, unsigned dev)
  1166. {
  1167. int retval;
  1168. printk("[%s:%d] Wheee.. irix_xmknod(%d,%s,%x,%x)\n",
  1169. current->comm, current->pid, ver, filename, mode, dev);
  1170. switch(ver) {
  1171. case 2:
  1172. /* shouldn't we convert here as well as on stat()? */
  1173. retval = sys_mknod(filename, mode, dev);
  1174. break;
  1175. default:
  1176. retval = -EINVAL;
  1177. break;
  1178. };
  1179. return retval;
  1180. }
  1181. asmlinkage int irix_swapctl(int cmd, char *arg)
  1182. {
  1183. printk("[%s:%d] Wheee.. irix_swapctl(%d,%p)\n",
  1184. current->comm, current->pid, cmd, arg);
  1185. return -EINVAL;
  1186. }
  1187. struct irix_statvfs {
  1188. u32 f_bsize; u32 f_frsize; u32 f_blocks;
  1189. u32 f_bfree; u32 f_bavail; u32 f_files; u32 f_ffree; u32 f_favail;
  1190. u32 f_fsid; char f_basetype[16];
  1191. u32 f_flag; u32 f_namemax;
  1192. char f_fstr[32]; u32 f_filler[16];
  1193. };
  1194. asmlinkage int irix_statvfs(char *fname, struct irix_statvfs *buf)
  1195. {
  1196. struct nameidata nd;
  1197. struct kstatfs kbuf;
  1198. int error, i;
  1199. printk("[%s:%d] Wheee.. irix_statvfs(%s,%p)\n",
  1200. current->comm, current->pid, fname, buf);
  1201. if (!access_ok(VERIFY_WRITE, buf, sizeof(struct irix_statvfs))) {
  1202. error = -EFAULT;
  1203. goto out;
  1204. }
  1205. error = user_path_walk(fname, &nd);
  1206. if (error)
  1207. goto out;
  1208. error = vfs_statfs(nd.dentry->d_inode->i_sb, &kbuf);
  1209. if (error)
  1210. goto dput_and_out;
  1211. __put_user(kbuf.f_bsize, &buf->f_bsize);
  1212. __put_user(kbuf.f_frsize, &buf->f_frsize);
  1213. __put_user(kbuf.f_blocks, &buf->f_blocks);
  1214. __put_user(kbuf.f_bfree, &buf->f_bfree);
  1215. __put_user(kbuf.f_bfree, &buf->f_bavail); /* XXX hackety hack... */
  1216. __put_user(kbuf.f_files, &buf->f_files);
  1217. __put_user(kbuf.f_ffree, &buf->f_ffree);
  1218. __put_user(kbuf.f_ffree, &buf->f_favail); /* XXX hackety hack... */
  1219. #ifdef __MIPSEB__
  1220. __put_user(kbuf.f_fsid.val[1], &buf->f_fsid);
  1221. #else
  1222. __put_user(kbuf.f_fsid.val[0], &buf->f_fsid);
  1223. #endif
  1224. for (i = 0; i < 16; i++)
  1225. __put_user(0, &buf->f_basetype[i]);
  1226. __put_user(0, &buf->f_flag);
  1227. __put_user(kbuf.f_namelen, &buf->f_namemax);
  1228. for (i = 0; i < 32; i++)
  1229. __put_user(0, &buf->f_fstr[i]);
  1230. error = 0;
  1231. dput_and_out:
  1232. path_release(&nd);
  1233. out:
  1234. return error;
  1235. }
  1236. asmlinkage int irix_fstatvfs(int fd, struct irix_statvfs *buf)
  1237. {
  1238. struct kstatfs kbuf;
  1239. struct file *file;
  1240. int error, i;
  1241. printk("[%s:%d] Wheee.. irix_fstatvfs(%d,%p)\n",
  1242. current->comm, current->pid, fd, buf);
  1243. if (!access_ok(VERIFY_WRITE, buf, sizeof(struct irix_statvfs))) {
  1244. error = -EFAULT;
  1245. goto out;
  1246. }
  1247. if (!(file = fget(fd))) {
  1248. error = -EBADF;
  1249. goto out;
  1250. }
  1251. error = vfs_statfs(file->f_dentry->d_inode->i_sb, &kbuf);
  1252. if (error)
  1253. goto out_f;
  1254. __put_user(kbuf.f_bsize, &buf->f_bsize);
  1255. __put_user(kbuf.f_frsize, &buf->f_frsize);
  1256. __put_user(kbuf.f_blocks, &buf->f_blocks);
  1257. __put_user(kbuf.f_bfree, &buf->f_bfree);
  1258. __put_user(kbuf.f_bfree, &buf->f_bavail); /* XXX hackety hack... */
  1259. __put_user(kbuf.f_files, &buf->f_files);
  1260. __put_user(kbuf.f_ffree, &buf->f_ffree);
  1261. __put_user(kbuf.f_ffree, &buf->f_favail); /* XXX hackety hack... */
  1262. #ifdef __MIPSEB__
  1263. __put_user(kbuf.f_fsid.val[1], &buf->f_fsid);
  1264. #else
  1265. __put_user(kbuf.f_fsid.val[0], &buf->f_fsid);
  1266. #endif
  1267. for(i = 0; i < 16; i++)
  1268. __put_user(0, &buf->f_basetype[i]);
  1269. __put_user(0, &buf->f_flag);
  1270. __put_user(kbuf.f_namelen, &buf->f_namemax);
  1271. __clear_user(&buf->f_fstr, sizeof(buf->f_fstr));
  1272. out_f:
  1273. fput(file);
  1274. out:
  1275. return error;
  1276. }
  1277. asmlinkage int irix_priocntl(struct pt_regs *regs)
  1278. {
  1279. printk("[%s:%d] Wheee.. irix_priocntl()\n",
  1280. current->comm, current->pid);
  1281. return -EINVAL;
  1282. }
  1283. asmlinkage int irix_sigqueue(int pid, int sig, int code, int val)
  1284. {
  1285. printk("[%s:%d] Wheee.. irix_sigqueue(%d,%d,%d,%d)\n",
  1286. current->comm, current->pid, pid, sig, code, val);
  1287. return -EINVAL;
  1288. }
  1289. asmlinkage int irix_truncate64(char *name, int pad, int size1, int size2)
  1290. {
  1291. int retval;
  1292. if (size1) {
  1293. retval = -EINVAL;
  1294. goto out;
  1295. }
  1296. retval = sys_truncate(name, size2);
  1297. out:
  1298. return retval;
  1299. }
  1300. asmlinkage int irix_ftruncate64(int fd, int pad, int size1, int size2)
  1301. {
  1302. int retval;
  1303. if (size1) {
  1304. retval = -EINVAL;
  1305. goto out;
  1306. }
  1307. retval = sys_ftruncate(fd, size2);
  1308. out:
  1309. return retval;
  1310. }
  1311. asmlinkage int irix_mmap64(struct pt_regs *regs)
  1312. {
  1313. int len, prot, flags, fd, off1, off2, error, base = 0;
  1314. unsigned long addr, pgoff, *sp;
  1315. struct file *file = NULL;
  1316. if (regs->regs[2] == 1000)
  1317. base = 1;
  1318. sp = (unsigned long *) (regs->regs[29] + 16);
  1319. addr = regs->regs[base + 4];
  1320. len = regs->regs[base + 5];
  1321. prot = regs->regs[base + 6];
  1322. if (!base) {
  1323. flags = regs->regs[base + 7];
  1324. if (!access_ok(VERIFY_READ, sp, (4 * sizeof(unsigned long)))) {
  1325. error = -EFAULT;
  1326. goto out;
  1327. }
  1328. fd = sp[0];
  1329. __get_user(off1, &sp[1]);
  1330. __get_user(off2, &sp[2]);
  1331. } else {
  1332. if (!access_ok(VERIFY_READ, sp, (5 * sizeof(unsigned long)))) {
  1333. error = -EFAULT;
  1334. goto out;
  1335. }
  1336. __get_user(flags, &sp[0]);
  1337. __get_user(fd, &sp[1]);
  1338. __get_user(off1, &sp[2]);
  1339. __get_user(off2, &sp[3]);
  1340. }
  1341. if (off1 & PAGE_MASK) {
  1342. error = -EOVERFLOW;
  1343. goto out;
  1344. }
  1345. pgoff = (off1 << (32 - PAGE_SHIFT)) | (off2 >> PAGE_SHIFT);
  1346. if (!(flags & MAP_ANONYMOUS)) {
  1347. if (!(file = fget(fd))) {
  1348. error = -EBADF;
  1349. goto out;
  1350. }
  1351. /* Ok, bad taste hack follows, try to think in something else
  1352. when reading this */
  1353. if (flags & IRIX_MAP_AUTOGROW) {
  1354. unsigned long old_pos;
  1355. long max_size = off2 + len;
  1356. if (max_size > file->f_dentry->d_inode->i_size) {
  1357. old_pos = sys_lseek (fd, max_size - 1, 0);
  1358. sys_write (fd, "", 1);
  1359. sys_lseek (fd, old_pos, 0);
  1360. }
  1361. }
  1362. }
  1363. flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  1364. down_write(&current->mm->mmap_sem);
  1365. error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  1366. up_write(&current->mm->mmap_sem);
  1367. if (file)
  1368. fput(file);
  1369. out:
  1370. return error;
  1371. }
  1372. asmlinkage int irix_dmi(struct pt_regs *regs)
  1373. {
  1374. printk("[%s:%d] Wheee.. irix_dmi()\n",
  1375. current->comm, current->pid);
  1376. return -EINVAL;
  1377. }
  1378. asmlinkage int irix_pread(int fd, char *buf, int cnt, int off64,
  1379. int off1, int off2)
  1380. {
  1381. printk("[%s:%d] Wheee.. irix_pread(%d,%p,%d,%d,%d,%d)\n",
  1382. current->comm, current->pid, fd, buf, cnt, off64, off1, off2);
  1383. return -EINVAL;
  1384. }
  1385. asmlinkage int irix_pwrite(int fd, char *buf, int cnt, int off64,
  1386. int off1, int off2)
  1387. {
  1388. printk("[%s:%d] Wheee.. irix_pwrite(%d,%p,%d,%d,%d,%d)\n",
  1389. current->comm, current->pid, fd, buf, cnt, off64, off1, off2);
  1390. return -EINVAL;
  1391. }
  1392. asmlinkage int irix_sgifastpath(int cmd, unsigned long arg0, unsigned long arg1,
  1393. unsigned long arg2, unsigned long arg3,
  1394. unsigned long arg4, unsigned long arg5)
  1395. {
  1396. printk("[%s:%d] Wheee.. irix_fastpath(%d,%08lx,%08lx,%08lx,%08lx,"
  1397. "%08lx,%08lx)\n",
  1398. current->comm, current->pid, cmd, arg0, arg1, arg2,
  1399. arg3, arg4, arg5);
  1400. return -EINVAL;
  1401. }
  1402. struct irix_statvfs64 {
  1403. u32 f_bsize; u32 f_frsize;
  1404. u64 f_blocks; u64 f_bfree; u64 f_bavail;
  1405. u64 f_files; u64 f_ffree; u64 f_favail;
  1406. u32 f_fsid;
  1407. char f_basetype[16];
  1408. u32 f_flag; u32 f_namemax;
  1409. char f_fstr[32];
  1410. u32 f_filler[16];
  1411. };
  1412. asmlinkage int irix_statvfs64(char *fname, struct irix_statvfs64 *buf)
  1413. {
  1414. struct nameidata nd;
  1415. struct kstatfs kbuf;
  1416. int error, i;
  1417. printk("[%s:%d] Wheee.. irix_statvfs64(%s,%p)\n",
  1418. current->comm, current->pid, fname, buf);
  1419. if (!access_ok(VERIFY_WRITE, buf, sizeof(struct irix_statvfs64))) {
  1420. error = -EFAULT;
  1421. goto out;
  1422. }
  1423. error = user_path_walk(fname, &nd);
  1424. if (error)
  1425. goto out;
  1426. error = vfs_statfs(nd.dentry->d_inode->i_sb, &kbuf);
  1427. if (error)
  1428. goto dput_and_out;
  1429. __put_user(kbuf.f_bsize, &buf->f_bsize);
  1430. __put_user(kbuf.f_frsize, &buf->f_frsize);
  1431. __put_user(kbuf.f_blocks, &buf->f_blocks);
  1432. __put_user(kbuf.f_bfree, &buf->f_bfree);
  1433. __put_user(kbuf.f_bfree, &buf->f_bavail); /* XXX hackety hack... */
  1434. __put_user(kbuf.f_files, &buf->f_files);
  1435. __put_user(kbuf.f_ffree, &buf->f_ffree);
  1436. __put_user(kbuf.f_ffree, &buf->f_favail); /* XXX hackety hack... */
  1437. #ifdef __MIPSEB__
  1438. __put_user(kbuf.f_fsid.val[1], &buf->f_fsid);
  1439. #else
  1440. __put_user(kbuf.f_fsid.val[0], &buf->f_fsid);
  1441. #endif
  1442. for(i = 0; i < 16; i++)
  1443. __put_user(0, &buf->f_basetype[i]);
  1444. __put_user(0, &buf->f_flag);
  1445. __put_user(kbuf.f_namelen, &buf->f_namemax);
  1446. for(i = 0; i < 32; i++)
  1447. __put_user(0, &buf->f_fstr[i]);
  1448. error = 0;
  1449. dput_and_out:
  1450. path_release(&nd);
  1451. out:
  1452. return error;
  1453. }
  1454. asmlinkage int irix_fstatvfs64(int fd, struct irix_statvfs *buf)
  1455. {
  1456. struct kstatfs kbuf;
  1457. struct file *file;
  1458. int error, i;
  1459. printk("[%s:%d] Wheee.. irix_fstatvfs64(%d,%p)\n",
  1460. current->comm, current->pid, fd, buf);
  1461. if (!access_ok(VERIFY_WRITE, buf, sizeof(struct irix_statvfs))) {
  1462. error = -EFAULT;
  1463. goto out;
  1464. }
  1465. if (!(file = fget(fd))) {
  1466. error = -EBADF;
  1467. goto out;
  1468. }
  1469. error = vfs_statfs(file->f_dentry->d_inode->i_sb, &kbuf);
  1470. if (error)
  1471. goto out_f;
  1472. __put_user(kbuf.f_bsize, &buf->f_bsize);
  1473. __put_user(kbuf.f_frsize, &buf->f_frsize);
  1474. __put_user(kbuf.f_blocks, &buf->f_blocks);
  1475. __put_user(kbuf.f_bfree, &buf->f_bfree);
  1476. __put_user(kbuf.f_bfree, &buf->f_bavail); /* XXX hackety hack... */
  1477. __put_user(kbuf.f_files, &buf->f_files);
  1478. __put_user(kbuf.f_ffree, &buf->f_ffree);
  1479. __put_user(kbuf.f_ffree, &buf->f_favail); /* XXX hackety hack... */
  1480. #ifdef __MIPSEB__
  1481. __put_user(kbuf.f_fsid.val[1], &buf->f_fsid);
  1482. #else
  1483. __put_user(kbuf.f_fsid.val[0], &buf->f_fsid);
  1484. #endif
  1485. for(i = 0; i < 16; i++)
  1486. __put_user(0, &buf->f_basetype[i]);
  1487. __put_user(0, &buf->f_flag);
  1488. __put_user(kbuf.f_namelen, &buf->f_namemax);
  1489. __clear_user(buf->f_fstr, sizeof(buf->f_fstr[i]));
  1490. out_f:
  1491. fput(file);
  1492. out:
  1493. return error;
  1494. }
  1495. asmlinkage int irix_getmountid(char *fname, unsigned long *midbuf)
  1496. {
  1497. int err = 0;
  1498. printk("[%s:%d] irix_getmountid(%s, %p)\n",
  1499. current->comm, current->pid, fname, midbuf);
  1500. if (!access_ok(VERIFY_WRITE, midbuf, (sizeof(unsigned long) * 4)))
  1501. return -EFAULT;
  1502. /*
  1503. * The idea with this system call is that when trying to determine
  1504. * 'pwd' and it's a toss-up for some reason, userland can use the
  1505. * fsid of the filesystem to try and make the right decision, but
  1506. * we don't have this so for now. XXX
  1507. */
  1508. err |= __put_user(0, &midbuf[0]);
  1509. err |= __put_user(0, &midbuf[1]);
  1510. err |= __put_user(0, &midbuf[2]);
  1511. err |= __put_user(0, &midbuf[3]);
  1512. return err;
  1513. }
  1514. asmlinkage int irix_nsproc(unsigned long entry, unsigned long mask,
  1515. unsigned long arg, unsigned long sp, int slen)
  1516. {
  1517. printk("[%s:%d] Wheee.. irix_nsproc(%08lx,%08lx,%08lx,%08lx,%d)\n",
  1518. current->comm, current->pid, entry, mask, arg, sp, slen);
  1519. return -EINVAL;
  1520. }
  1521. #undef DEBUG_GETDENTS
  1522. struct irix_dirent32 {
  1523. u32 d_ino;
  1524. u32 d_off;
  1525. unsigned short d_reclen;
  1526. char d_name[1];
  1527. };
  1528. struct irix_dirent32_callback {
  1529. struct irix_dirent32 *current_dir;
  1530. struct irix_dirent32 *previous;
  1531. int count;
  1532. int error;
  1533. };
  1534. #define NAME_OFFSET32(de) ((int) ((de)->d_name - (char *) (de)))
  1535. #define ROUND_UP32(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
  1536. static int irix_filldir32(void *__buf, const char *name, int namlen,
  1537. loff_t offset, ino_t ino, unsigned int d_type)
  1538. {
  1539. struct irix_dirent32 *dirent;
  1540. struct irix_dirent32_callback *buf =
  1541. (struct irix_dirent32_callback *)__buf;
  1542. unsigned short reclen = ROUND_UP32(NAME_OFFSET32(dirent) + namlen + 1);
  1543. #ifdef DEBUG_GETDENTS
  1544. printk("\nirix_filldir32[reclen<%d>namlen<%d>count<%d>]",
  1545. reclen, namlen, buf->count);
  1546. #endif
  1547. buf->error = -EINVAL; /* only used if we fail.. */
  1548. if (reclen > buf->count)
  1549. return -EINVAL;
  1550. dirent = buf->previous;
  1551. if (dirent)
  1552. __put_user(offset, &dirent->d_off);
  1553. dirent = buf->current_dir;
  1554. buf->previous = dirent;
  1555. __put_user(ino, &dirent->d_ino);
  1556. __put_user(reclen, &dirent->d_reclen);
  1557. copy_to_user(dirent->d_name, name, namlen);
  1558. __put_user(0, &dirent->d_name[namlen]);
  1559. ((char *) dirent) += reclen;
  1560. buf->current_dir = dirent;
  1561. buf->count -= reclen;
  1562. return 0;
  1563. }
  1564. asmlinkage int irix_ngetdents(unsigned int fd, void * dirent,
  1565. unsigned int count, int *eob)
  1566. {
  1567. struct file *file;
  1568. struct irix_dirent32 *lastdirent;
  1569. struct irix_dirent32_callback buf;
  1570. int error;
  1571. #ifdef DEBUG_GETDENTS
  1572. printk("[%s:%d] ngetdents(%d, %p, %d, %p) ", current->comm,
  1573. current->pid, fd, dirent, count, eob);
  1574. #endif
  1575. error = -EBADF;
  1576. file = fget(fd);
  1577. if (!file)
  1578. goto out;
  1579. buf.current_dir = (struct irix_dirent32 *) dirent;
  1580. buf.previous = NULL;
  1581. buf.count = count;
  1582. buf.error = 0;
  1583. error = vfs_readdir(file, irix_filldir32, &buf);
  1584. if (error < 0)
  1585. goto out_putf;
  1586. error = buf.error;
  1587. lastdirent = buf.previous;
  1588. if (lastdirent) {
  1589. put_user(file->f_pos, &lastdirent->d_off);
  1590. error = count - buf.count;
  1591. }
  1592. if (put_user(0, eob) < 0) {
  1593. error = -EFAULT;
  1594. goto out_putf;
  1595. }
  1596. #ifdef DEBUG_GETDENTS
  1597. printk("eob=%d returning %d\n", *eob, count - buf.count);
  1598. #endif
  1599. error = count - buf.count;
  1600. out_putf:
  1601. fput(file);
  1602. out:
  1603. return error;
  1604. }
  1605. struct irix_dirent64 {
  1606. u64 d_ino;
  1607. u64 d_off;
  1608. unsigned short d_reclen;
  1609. char d_name[1];
  1610. };
  1611. struct irix_dirent64_callback {
  1612. struct irix_dirent64 *curr;
  1613. struct irix_dirent64 *previous;
  1614. int count;
  1615. int error;
  1616. };
  1617. #define NAME_OFFSET64(de) ((int) ((de)->d_name - (char *) (de)))
  1618. #define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
  1619. static int irix_filldir64(void * __buf, const char * name, int namlen,
  1620. loff_t offset, ino_t ino, unsigned int d_type)
  1621. {
  1622. struct irix_dirent64 *dirent;
  1623. struct irix_dirent64_callback * buf =
  1624. (struct irix_dirent64_callback *) __buf;
  1625. unsigned short reclen = ROUND_UP64(NAME_OFFSET64(dirent) + namlen + 1);
  1626. buf->error = -EINVAL; /* only used if we fail.. */
  1627. if (reclen > buf->count)
  1628. return -EINVAL;
  1629. dirent = buf->previous;
  1630. if (dirent)
  1631. __put_user(offset, &dirent->d_off);
  1632. dirent = buf->curr;
  1633. buf->previous = dirent;
  1634. __put_user(ino, &dirent->d_ino);
  1635. __put_user(reclen, &dirent->d_reclen);
  1636. __copy_to_user(dirent->d_name, name, namlen);
  1637. __put_user(0, &dirent->d_name[namlen]);
  1638. ((char *) dirent) += reclen;
  1639. buf->curr = dirent;
  1640. buf->count -= reclen;
  1641. return 0;
  1642. }
  1643. asmlinkage int irix_getdents64(int fd, void *dirent, int cnt)
  1644. {
  1645. struct file *file;
  1646. struct irix_dirent64 *lastdirent;
  1647. struct irix_dirent64_callback buf;
  1648. int error;
  1649. #ifdef DEBUG_GETDENTS
  1650. printk("[%s:%d] getdents64(%d, %p, %d) ", current->comm,
  1651. current->pid, fd, dirent, cnt);
  1652. #endif
  1653. error = -EBADF;
  1654. if (!(file = fget(fd)))
  1655. goto out;
  1656. error = -EFAULT;
  1657. if (!access_ok(VERIFY_WRITE, dirent, cnt))
  1658. goto out_f;
  1659. error = -EINVAL;
  1660. if (cnt < (sizeof(struct irix_dirent64) + 255))
  1661. goto out_f;
  1662. buf.curr = (struct irix_dirent64 *) dirent;
  1663. buf.previous = NULL;
  1664. buf.count = cnt;
  1665. buf.error = 0;
  1666. error = vfs_readdir(file, irix_filldir64, &buf);
  1667. if (error < 0)
  1668. goto out_f;
  1669. lastdirent = buf.previous;
  1670. if (!lastdirent) {
  1671. error = buf.error;
  1672. goto out_f;
  1673. }
  1674. lastdirent->d_off = (u64) file->f_pos;
  1675. #ifdef DEBUG_GETDENTS
  1676. printk("returning %d\n", cnt - buf.count);
  1677. #endif
  1678. error = cnt - buf.count;
  1679. out_f:
  1680. fput(file);
  1681. out:
  1682. return error;
  1683. }
  1684. asmlinkage int irix_ngetdents64(int fd, void *dirent, int cnt, int *eob)
  1685. {
  1686. struct file *file;
  1687. struct irix_dirent64 *lastdirent;
  1688. struct irix_dirent64_callback buf;
  1689. int error;
  1690. #ifdef DEBUG_GETDENTS
  1691. printk("[%s:%d] ngetdents64(%d, %p, %d) ", current->comm,
  1692. current->pid, fd, dirent, cnt);
  1693. #endif
  1694. error = -EBADF;
  1695. if (!(file = fget(fd)))
  1696. goto out;
  1697. error = -EFAULT;
  1698. if (!access_ok(VERIFY_WRITE, dirent, cnt) ||
  1699. !access_ok(VERIFY_WRITE, eob, sizeof(*eob)))
  1700. goto out_f;
  1701. error = -EINVAL;
  1702. if (cnt < (sizeof(struct irix_dirent64) + 255))
  1703. goto out_f;
  1704. *eob = 0;
  1705. buf.curr = (struct irix_dirent64 *) dirent;
  1706. buf.previous = NULL;
  1707. buf.count = cnt;
  1708. buf.error = 0;
  1709. error = vfs_readdir(file, irix_filldir64, &buf);
  1710. if (error < 0)
  1711. goto out_f;
  1712. lastdirent = buf.previous;
  1713. if (!lastdirent) {
  1714. error = buf.error;
  1715. goto out_f;
  1716. }
  1717. lastdirent->d_off = (u64) file->f_pos;
  1718. #ifdef DEBUG_GETDENTS
  1719. printk("eob=%d returning %d\n", *eob, cnt - buf.count);
  1720. #endif
  1721. error = cnt - buf.count;
  1722. out_f:
  1723. fput(file);
  1724. out:
  1725. return error;
  1726. }
  1727. asmlinkage int irix_uadmin(unsigned long op, unsigned long func, unsigned long arg)
  1728. {
  1729. int retval;
  1730. switch (op) {
  1731. case 1:
  1732. /* Reboot */
  1733. printk("[%s:%d] irix_uadmin: Wants to reboot...\n",
  1734. current->comm, current->pid);
  1735. retval = -EINVAL;
  1736. goto out;
  1737. case 2:
  1738. /* Shutdown */
  1739. printk("[%s:%d] irix_uadmin: Wants to shutdown...\n",
  1740. current->comm, current->pid);
  1741. retval = -EINVAL;
  1742. goto out;
  1743. case 4:
  1744. /* Remount-root */
  1745. printk("[%s:%d] irix_uadmin: Wants to remount root...\n",
  1746. current->comm, current->pid);
  1747. retval = -EINVAL;
  1748. goto out;
  1749. case 8:
  1750. /* Kill all tasks. */
  1751. printk("[%s:%d] irix_uadmin: Wants to kill all tasks...\n",
  1752. current->comm, current->pid);
  1753. retval = -EINVAL;
  1754. goto out;
  1755. case 256:
  1756. /* Set magic mushrooms... */
  1757. printk("[%s:%d] irix_uadmin: Wants to set magic mushroom[%d]...\n",
  1758. current->comm, current->pid, (int) func);
  1759. retval = -EINVAL;
  1760. goto out;
  1761. default:
  1762. printk("[%s:%d] irix_uadmin: Unknown operation [%d]...\n",
  1763. current->comm, current->pid, (int) op);
  1764. retval = -EINVAL;
  1765. goto out;
  1766. };
  1767. out:
  1768. return retval;
  1769. }
  1770. asmlinkage int irix_utssys(char *inbuf, int arg, int type, char *outbuf)
  1771. {
  1772. int retval;
  1773. switch(type) {
  1774. case 0:
  1775. /* uname() */
  1776. retval = irix_uname((struct iuname *)inbuf);
  1777. goto out;
  1778. case 2:
  1779. /* ustat() */
  1780. printk("[%s:%d] irix_utssys: Wants to do ustat()\n",
  1781. current->comm, current->pid);
  1782. retval = -EINVAL;
  1783. goto out;
  1784. case 3:
  1785. /* fusers() */
  1786. printk("[%s:%d] irix_utssys: Wants to do fusers()\n",
  1787. current->comm, current->pid);
  1788. retval = -EINVAL;
  1789. goto out;
  1790. default:
  1791. printk("[%s:%d] irix_utssys: Wants to do unknown type[%d]\n",
  1792. current->comm, current->pid, (int) type);
  1793. retval = -EINVAL;
  1794. goto out;
  1795. }
  1796. out:
  1797. return retval;
  1798. }
  1799. #undef DEBUG_FCNTL
  1800. #define IRIX_F_ALLOCSP 10
  1801. asmlinkage int irix_fcntl(int fd, int cmd, int arg)
  1802. {
  1803. int retval;
  1804. #ifdef DEBUG_FCNTL
  1805. printk("[%s:%d] irix_fcntl(%d, %d, %d) ", current->comm,
  1806. current->pid, fd, cmd, arg);
  1807. #endif
  1808. if (cmd == IRIX_F_ALLOCSP){
  1809. return 0;
  1810. }
  1811. retval = sys_fcntl(fd, cmd, arg);
  1812. #ifdef DEBUG_FCNTL
  1813. printk("%d\n", retval);
  1814. #endif
  1815. return retval;
  1816. }
  1817. asmlinkage int irix_ulimit(int cmd, int arg)
  1818. {
  1819. int retval;
  1820. switch(cmd) {
  1821. case 1:
  1822. printk("[%s:%d] irix_ulimit: Wants to get file size limit.\n",
  1823. current->comm, current->pid);
  1824. retval = -EINVAL;
  1825. goto out;
  1826. case 2:
  1827. printk("[%s:%d] irix_ulimit: Wants to set file size limit.\n",
  1828. current->comm, current->pid);
  1829. retval = -EINVAL;
  1830. goto out;
  1831. case 3:
  1832. printk("[%s:%d] irix_ulimit: Wants to get brk limit.\n",
  1833. current->comm, current->pid);
  1834. retval = -EINVAL;
  1835. goto out;
  1836. case 4:
  1837. #if 0
  1838. printk("[%s:%d] irix_ulimit: Want…

Large files files are truncated, but you can click here to view the full file