2 * sysirix.c: IRIX system call emulation.
4 * Copyright (C) 1996 David S. Miller
5 * Copyright (C) 1997 Miguel de Icaza
6 * Copyright (C) 1997, 1998, 1999, 2000 Ralf Baechle
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>
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>
34 #include <asm/ptrace.h>
36 #include <asm/uaccess.h>
37 #include <asm/inventory.h>
39 /* 2,191 lines of complete and utter shit coming up... */
41 extern int max_threads
;
43 /* The sysmp commands supported thus far. */
44 #define MP_NPROCS 1 /* # processor in complex */
45 #define MP_NAPROCS 2 /* # active processors in complex */
46 #define MP_PGSIZE 14 /* Return system page size in v1. */
48 asmlinkage
int irix_sysmp(struct pt_regs
*regs
)
54 if(regs
->regs
[2] == 1000)
56 cmd
= regs
->regs
[base
+ 4];
63 error
= num_online_cpus();
66 printk("SYSMP[%s:%d]: Unsupported opcode %d\n",
67 current
->comm
, current
->pid
, (int)cmd
);
75 /* The prctl commands. */
76 #define PR_MAXPROCS 1 /* Tasks/user. */
77 #define PR_ISBLOCKED 2 /* If blocked, return 1. */
78 #define PR_SETSTACKSIZE 3 /* Set largest task stack size. */
79 #define PR_GETSTACKSIZE 4 /* Get largest task stack size. */
80 #define PR_MAXPPROCS 5 /* Num parallel tasks. */
81 #define PR_UNBLKONEXEC 6 /* When task exec/exit's, unblock. */
82 #define PR_SETEXITSIG 8 /* When task exit's, set signal. */
83 #define PR_RESIDENT 9 /* Make task unswappable. */
84 #define PR_ATTACHADDR 10 /* (Re-)Connect a vma to a task. */
85 #define PR_DETACHADDR 11 /* Disconnect a vma from a task. */
86 #define PR_TERMCHILD 12 /* Kill child if the parent dies. */
87 #define PR_GETSHMASK 13 /* Get the sproc() share mask. */
88 #define PR_GETNSHARE 14 /* Number of share group members. */
89 #define PR_COREPID 15 /* Add task pid to name when it core. */
90 #define PR_ATTACHADDRPERM 16 /* (Re-)Connect vma, with specified prot. */
91 #define PR_PTHREADEXIT 17 /* Kill a pthread, only for IRIX 6.[234] */
93 asmlinkage
int irix_prctl(unsigned option
, ...)
98 va_start(args
, option
);
101 printk("irix_prctl[%s:%d]: Wants PR_MAXPROCS\n",
102 current
->comm
, current
->pid
);
107 struct task_struct
*task
;
109 printk("irix_prctl[%s:%d]: Wants PR_ISBLOCKED\n",
110 current
->comm
, current
->pid
);
111 read_lock(&tasklist_lock
);
112 task
= find_task_by_pid(va_arg(args
, pid_t
));
115 error
= (task
->run_list
.next
!= NULL
);
116 read_unlock(&tasklist_lock
);
117 /* Can _your_ OS find this out that fast? */
121 case PR_SETSTACKSIZE
: {
122 long value
= va_arg(args
, long);
124 printk("irix_prctl[%s:%d]: Wants PR_SETSTACKSIZE<%08lx>\n",
125 current
->comm
, current
->pid
, (unsigned long) value
);
126 if (value
> RLIM_INFINITY
)
127 value
= RLIM_INFINITY
;
128 if (capable(CAP_SYS_ADMIN
)) {
129 task_lock(current
->group_leader
);
130 current
->signal
->rlim
[RLIMIT_STACK
].rlim_max
=
131 current
->signal
->rlim
[RLIMIT_STACK
].rlim_cur
= value
;
132 task_unlock(current
->group_leader
);
136 task_lock(current
->group_leader
);
137 if (value
> current
->signal
->rlim
[RLIMIT_STACK
].rlim_max
) {
139 task_unlock(current
->group_leader
);
142 current
->signal
->rlim
[RLIMIT_STACK
].rlim_cur
= value
;
143 task_unlock(current
->group_leader
);
148 case PR_GETSTACKSIZE
:
149 printk("irix_prctl[%s:%d]: Wants PR_GETSTACKSIZE\n",
150 current
->comm
, current
->pid
);
151 error
= current
->signal
->rlim
[RLIMIT_STACK
].rlim_cur
;
155 printk("irix_prctl[%s:%d]: Wants PR_MAXPROCS\n",
156 current
->comm
, current
->pid
);
161 printk("irix_prctl[%s:%d]: Wants PR_UNBLKONEXEC\n",
162 current
->comm
, current
->pid
);
167 printk("irix_prctl[%s:%d]: Wants PR_SETEXITSIG\n",
168 current
->comm
, current
->pid
);
170 /* We can probably play some game where we set the task
171 * exit_code to some non-zero value when this is requested,
172 * and check whether exit_code is already set in do_exit().
178 printk("irix_prctl[%s:%d]: Wants PR_RESIDENT\n",
179 current
->comm
, current
->pid
);
180 error
= 0; /* Compatibility indeed. */
184 printk("irix_prctl[%s:%d]: Wants PR_ATTACHADDR\n",
185 current
->comm
, current
->pid
);
190 printk("irix_prctl[%s:%d]: Wants PR_DETACHADDR\n",
191 current
->comm
, current
->pid
);
196 printk("irix_prctl[%s:%d]: Wants PR_TERMCHILD\n",
197 current
->comm
, current
->pid
);
202 printk("irix_prctl[%s:%d]: Wants PR_GETSHMASK\n",
203 current
->comm
, current
->pid
);
204 error
= -EINVAL
; /* Until I have the sproc() stuff in. */
208 error
= 0; /* Until I have the sproc() stuff in. */
212 printk("irix_prctl[%s:%d]: Wants PR_COREPID\n",
213 current
->comm
, current
->pid
);
217 case PR_ATTACHADDRPERM
:
218 printk("irix_prctl[%s:%d]: Wants PR_ATTACHADDRPERM\n",
219 current
->comm
, current
->pid
);
224 printk("irix_prctl[%s:%d]: Non-existant opcode %d\n",
225 current
->comm
, current
->pid
, option
);
234 #undef DEBUG_PROCGRPS
236 extern unsigned long irix_mapelf(int fd
, struct elf_phdr __user
*user_phdrp
, int cnt
);
237 extern int getrusage(struct task_struct
*p
, int who
, struct rusage __user
*ru
);
238 extern char *prom_getenv(char *name
);
239 extern long prom_setenv(char *name
, char *value
);
241 /* The syssgi commands supported thus far. */
242 #define SGI_SYSID 1 /* Return unique per-machine identifier. */
243 #define SGI_INVENT 5 /* Fetch inventory */
244 # define SGI_INV_SIZEOF 1
245 # define SGI_INV_READ 2
246 #define SGI_RDNAME 6 /* Return string name of a process. */
247 #define SGI_SETNVRAM 8 /* Set PROM variable. */
248 #define SGI_GETNVRAM 9 /* Get PROM variable. */
249 #define SGI_SETPGID 21 /* Set process group id. */
250 #define SGI_SYSCONF 22 /* POSIX sysconf garbage. */
251 #define SGI_PATHCONF 24 /* POSIX sysconf garbage. */
252 #define SGI_SETGROUPS 40 /* POSIX sysconf garbage. */
253 #define SGI_GETGROUPS 41 /* POSIX sysconf garbage. */
254 #define SGI_RUSAGE 56 /* BSD style rusage(). */
255 #define SGI_SSYNC 62 /* Synchronous fs sync. */
256 #define SGI_GETSID 65 /* SysVr4 get session id. */
257 #define SGI_ELFMAP 68 /* Map an elf image. */
258 #define SGI_TOSSTSAVE 108 /* Toss saved vma's. */
259 #define SGI_FP_BCOPY 129 /* Should FPU bcopy be used on this machine? */
260 #define SGI_PHYSP 1011 /* Translate virtual into physical page. */
262 asmlinkage
int irix_syssgi(struct pt_regs
*regs
)
265 int retval
, base
= 0;
267 if (regs
->regs
[2] == 1000)
270 cmd
= regs
->regs
[base
+ 4];
273 char __user
*buf
= (char __user
*) regs
->regs
[base
+ 5];
275 /* XXX Use ethernet addr.... */
276 retval
= clear_user(buf
, 64) ? -EFAULT
: 0;
281 int pid
= (int) regs
->regs
[base
+ 5];
282 char __user
*buf
= (char __user
*) regs
->regs
[base
+ 6];
283 struct task_struct
*p
;
284 char tcomm
[sizeof(current
->comm
)];
286 read_lock(&tasklist_lock
);
287 p
= find_task_by_pid(pid
);
289 read_unlock(&tasklist_lock
);
293 get_task_comm(tcomm
, p
);
294 read_unlock(&tasklist_lock
);
296 /* XXX Need to check sizes. */
297 retval
= copy_to_user(buf
, tcomm
, sizeof(tcomm
)) ? -EFAULT
: 0;
302 char __user
*name
= (char __user
*) regs
->regs
[base
+5];
303 char __user
*buf
= (char __user
*) regs
->regs
[base
+6];
305 return -EINVAL
; /* til I fix it */
306 value
= prom_getenv(name
); /* PROM lock? */
311 /* Do I strlen() for the length? */
312 retval
= copy_to_user(buf
, value
, 128) ? -EFAULT
: 0;
317 char __user
*name
= (char __user
*) regs
->regs
[base
+5];
318 char __user
*value
= (char __user
*) regs
->regs
[base
+6];
319 return -EINVAL
; /* til I fix it */
320 retval
= prom_setenv(name
, value
);
321 /* XXX make sure retval conforms to syssgi(2) */
322 printk("[%s:%d] setnvram(\"%s\", \"%s\"): retval %d",
323 current
->comm
, current
->pid
, name
, value
, retval
);
324 /* if (retval == PROM_ENOENT)
331 #ifdef DEBUG_PROCGRPS
332 printk("[%s:%d] setpgid(%d, %d) ",
333 current
->comm
, current
->pid
,
334 (int) regs
->regs
[base
+ 5], (int)regs
->regs
[base
+ 6]);
336 retval
= sys_setpgid(regs
->regs
[base
+ 5], regs
->regs
[base
+ 6]);
338 #ifdef DEBUG_PROCGRPS
339 printk("retval=%d\n", retval
);
344 switch(regs
->regs
[base
+ 5]) {
346 retval
= (MAX_ARG_PAGES
>> 4); /* XXX estimate... */
349 retval
= max_threads
;
355 retval
= NGROUPS_MAX
;
393 retval
= sys_setgroups((int) regs
->regs
[base
+ 5],
394 (gid_t __user
*) regs
->regs
[base
+ 6]);
398 retval
= sys_getgroups((int) regs
->regs
[base
+ 5],
399 (gid_t __user
*) regs
->regs
[base
+ 6]);
403 struct rusage __user
*ru
= (struct rusage __user
*) regs
->regs
[base
+ 6];
405 switch((int) regs
->regs
[base
+ 5]) {
408 retval
= getrusage(current
, RUSAGE_SELF
, ru
);
412 /* rusage children */
413 retval
= getrusage(current
, RUSAGE_CHILDREN
, ru
);
428 #ifdef DEBUG_PROCGRPS
429 printk("[%s:%d] getsid(%d) ", current
->comm
, current
->pid
,
430 (int) regs
->regs
[base
+ 5]);
432 retval
= sys_getsid(regs
->regs
[base
+ 5]);
433 #ifdef DEBUG_PROCGRPS
434 printk("retval=%d\n", retval
);
439 retval
= irix_mapelf((int) regs
->regs
[base
+ 5],
440 (struct elf_phdr __user
*) regs
->regs
[base
+ 6],
441 (int) regs
->regs
[base
+ 7]);
445 /* XXX We don't need to do anything? */
454 unsigned long addr
= regs
->regs
[base
+ 5];
455 int __user
*pageno
= (int __user
*) (regs
->regs
[base
+ 6]);
456 struct mm_struct
*mm
= current
->mm
;
462 down_read(&mm
->mmap_sem
);
463 pgdp
= pgd_offset(mm
, addr
);
464 pudp
= pud_offset(pgdp
, addr
);
465 pmdp
= pmd_offset(pudp
, addr
);
466 ptep
= pte_offset(pmdp
, addr
);
471 if (pte_val(pte
) & (_PAGE_VALID
| _PAGE_PRESENT
)) {
472 /* b0rked on 64-bit */
473 retval
= put_user((pte_val(pte
) & PAGE_MASK
) >>
477 up_read(&mm
->mmap_sem
);
482 int arg1
= (int) regs
->regs
[base
+ 5];
483 void __user
*buffer
= (void __user
*) regs
->regs
[base
+ 6];
484 int count
= (int) regs
->regs
[base
+ 7];
488 retval
= sizeof (inventory_t
);
491 retval
= dump_inventory_to_user (buffer
, count
);
500 printk("irix_syssgi: Unsupported command %d\n", (int)cmd
);
509 asmlinkage
int irix_gtime(struct pt_regs
*regs
)
511 return get_seconds();
515 * IRIX is completely broken... it returns 0 on success, otherwise
518 asmlinkage
int irix_brk(unsigned long brk
)
521 unsigned long newbrk
, oldbrk
;
522 struct mm_struct
*mm
= current
->mm
;
525 down_write(&mm
->mmap_sem
);
526 if (brk
< mm
->end_code
) {
531 newbrk
= PAGE_ALIGN(brk
);
532 oldbrk
= PAGE_ALIGN(mm
->brk
);
533 if (oldbrk
== newbrk
) {
540 * Always allow shrinking brk
542 if (brk
<= mm
->brk
) {
544 do_munmap(mm
, newbrk
, oldbrk
-newbrk
);
549 * Check against rlimit and stack..
551 rlim
= current
->signal
->rlim
[RLIMIT_DATA
].rlim_cur
;
552 if (rlim
>= RLIM_INFINITY
)
554 if (brk
- mm
->end_code
> rlim
) {
560 * Check against existing mmap mappings.
562 if (find_vma_intersection(mm
, oldbrk
, newbrk
+PAGE_SIZE
)) {
568 * Ok, looks good - let it rip.
570 if (do_brk(oldbrk
, newbrk
-oldbrk
) != oldbrk
) {
578 up_write(&mm
->mmap_sem
);
582 asmlinkage
int irix_getpid(struct pt_regs
*regs
)
584 regs
->regs
[3] = current
->real_parent
->pid
;
588 asmlinkage
int irix_getuid(struct pt_regs
*regs
)
590 regs
->regs
[3] = current
->euid
;
594 asmlinkage
int irix_getgid(struct pt_regs
*regs
)
596 regs
->regs
[3] = current
->egid
;
600 asmlinkage
int irix_stime(int value
)
607 err
= security_settime(&tv
, NULL
);
611 write_seqlock_irq(&xtime_lock
);
612 xtime
.tv_sec
= value
;
615 write_sequnlock_irq(&xtime_lock
);
620 static inline void jiffiestotv(unsigned long jiffies
, struct timeval
*value
)
622 value
->tv_usec
= (jiffies
% HZ
) * (1000000 / HZ
);
623 value
->tv_sec
= jiffies
/ HZ
;
626 static inline void getitimer_real(struct itimerval
*value
)
628 register unsigned long val
, interval
;
630 interval
= current
->it_real_incr
;
632 if (del_timer(¤t
->real_timer
)) {
633 unsigned long now
= jiffies
;
634 val
= current
->real_timer
.expires
;
635 add_timer(¤t
->real_timer
);
636 /* look out for negative/zero itimer.. */
641 jiffiestotv(val
, &value
->it_value
);
642 jiffiestotv(interval
, &value
->it_interval
);
645 asmlinkage
unsigned int irix_alarm(unsigned int seconds
)
647 struct itimerval it_new
, it_old
;
648 unsigned int oldalarm
;
651 getitimer_real(&it_old
);
652 del_timer(¤t
->real_timer
);
654 it_new
.it_interval
.tv_sec
= it_new
.it_interval
.tv_usec
= 0;
655 it_new
.it_value
.tv_sec
= seconds
;
656 it_new
.it_value
.tv_usec
= 0;
657 do_setitimer(ITIMER_REAL
, &it_new
, &it_old
);
659 oldalarm
= it_old
.it_value
.tv_sec
;
661 * ehhh.. We can't return 0 if we have an alarm pending ...
662 * And we'd better return too much than too little anyway
664 if (it_old
.it_value
.tv_usec
)
670 asmlinkage
int irix_pause(void)
672 current
->state
= TASK_INTERRUPTIBLE
;
678 /* XXX need more than this... */
679 asmlinkage
int irix_mount(char __user
*dev_name
, char __user
*dir_name
,
680 unsigned long flags
, char __user
*type
, void __user
*data
, int datalen
)
682 printk("[%s:%d] irix_mount(%p,%p,%08lx,%p,%p,%d)\n",
683 current
->comm
, current
->pid
,
684 dev_name
, dir_name
, flags
, type
, data
, datalen
);
686 return sys_mount(dev_name
, dir_name
, type
, flags
, data
);
691 long f_bsize
, f_frsize
, f_blocks
, f_bfree
, f_files
, f_ffree
;
692 char f_fname
[6], f_fpack
[6];
695 asmlinkage
int irix_statfs(const char __user
*path
,
696 struct irix_statfs __user
*buf
, int len
, int fs_type
)
702 /* We don't support this feature yet. */
707 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statfs
))) {
712 error
= user_path_walk(path
, &nd
);
716 error
= vfs_statfs(nd
.dentry
->d_inode
->i_sb
, &kbuf
);
720 error
= __put_user(kbuf
.f_type
, &buf
->f_type
);
721 error
|= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
722 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
723 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
724 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
725 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
726 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
727 for (i
= 0; i
< 6; i
++) {
728 error
|= __put_user(0, &buf
->f_fname
[i
]);
729 error
|= __put_user(0, &buf
->f_fpack
[i
]);
738 asmlinkage
int irix_fstatfs(unsigned int fd
, struct irix_statfs __user
*buf
)
744 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statfs
))) {
749 if (!(file
= fget(fd
))) {
754 error
= vfs_statfs(file
->f_dentry
->d_inode
->i_sb
, &kbuf
);
758 error
= __put_user(kbuf
.f_type
, &buf
->f_type
);
759 error
|= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
760 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
761 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
762 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
763 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
764 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
766 for (i
= 0; i
< 6; i
++) {
767 error
|= __put_user(0, &buf
->f_fname
[i
]);
768 error
|= __put_user(0, &buf
->f_fpack
[i
]);
777 asmlinkage
int irix_setpgrp(int flags
)
781 #ifdef DEBUG_PROCGRPS
782 printk("[%s:%d] setpgrp(%d) ", current
->comm
, current
->pid
, flags
);
785 error
= process_group(current
);
787 error
= sys_setsid();
788 #ifdef DEBUG_PROCGRPS
789 printk("returning %d\n", process_group(current
));
795 asmlinkage
int irix_times(struct tms __user
*tbuf
)
800 if (!access_ok(VERIFY_WRITE
,tbuf
,sizeof *tbuf
))
803 err
= __put_user(current
->utime
, &tbuf
->tms_utime
);
804 err
|= __put_user(current
->stime
, &tbuf
->tms_stime
);
805 err
|= __put_user(current
->signal
->cutime
, &tbuf
->tms_cutime
);
806 err
|= __put_user(current
->signal
->cstime
, &tbuf
->tms_cstime
);
812 asmlinkage
int irix_exec(struct pt_regs
*regs
)
817 if(regs
->regs
[2] == 1000)
819 filename
= getname((char __user
*) (long)regs
->regs
[base
+ 4]);
820 error
= PTR_ERR(filename
);
821 if (IS_ERR(filename
))
824 error
= do_execve(filename
, (char __user
* __user
*) (long)regs
->regs
[base
+ 5],
831 asmlinkage
int irix_exece(struct pt_regs
*regs
)
836 if (regs
->regs
[2] == 1000)
838 filename
= getname((char __user
*) (long)regs
->regs
[base
+ 4]);
839 error
= PTR_ERR(filename
);
840 if (IS_ERR(filename
))
842 error
= do_execve(filename
, (char __user
* __user
*) (long)regs
->regs
[base
+ 5],
843 (char __user
* __user
*) (long)regs
->regs
[base
+ 6], regs
);
849 asmlinkage
unsigned long irix_gethostid(void)
851 printk("[%s:%d]: irix_gethostid() called...\n",
852 current
->comm
, current
->pid
);
857 asmlinkage
unsigned long irix_sethostid(unsigned long val
)
859 printk("[%s:%d]: irix_sethostid(%08lx) called...\n",
860 current
->comm
, current
->pid
, val
);
865 asmlinkage
int irix_socket(int family
, int type
, int protocol
)
877 type
= 9; /* Invalid... */
889 type
= SOCK_SEQPACKET
;
896 return sys_socket(family
, type
, protocol
);
899 asmlinkage
int irix_getdomainname(char __user
*name
, int len
)
904 if (len
> __NEW_UTS_LEN
)
906 err
= copy_to_user(name
, system_utsname
.domainname
, len
) ? -EFAULT
: 0;
912 asmlinkage
unsigned long irix_getpagesize(void)
917 asmlinkage
int irix_msgsys(int opcode
, unsigned long arg0
, unsigned long arg1
,
918 unsigned long arg2
, unsigned long arg3
,
923 return sys_msgget((key_t
) arg0
, (int) arg1
);
925 return sys_msgctl((int) arg0
, (int) arg1
,
926 (struct msqid_ds __user
*)arg2
);
928 return sys_msgrcv((int) arg0
, (struct msgbuf __user
*) arg1
,
929 (size_t) arg2
, (long) arg3
, (int) arg4
);
931 return sys_msgsnd((int) arg0
, (struct msgbuf __user
*) arg1
,
932 (size_t) arg2
, (int) arg3
);
938 asmlinkage
int irix_shmsys(int opcode
, unsigned long arg0
, unsigned long arg1
,
939 unsigned long arg2
, unsigned long arg3
)
943 return do_shmat((int) arg0
, (char __user
*) arg1
, (int) arg2
,
944 (unsigned long *) arg3
);
946 return sys_shmctl((int)arg0
, (int)arg1
,
947 (struct shmid_ds __user
*)arg2
);
949 return sys_shmdt((char __user
*)arg0
);
951 return sys_shmget((key_t
) arg0
, (int) arg1
, (int) arg2
);
957 asmlinkage
int irix_semsys(int opcode
, unsigned long arg0
, unsigned long arg1
,
958 unsigned long arg2
, int arg3
)
962 return sys_semctl((int) arg0
, (int) arg1
, (int) arg2
,
965 return sys_semget((key_t
) arg0
, (int) arg1
, (int) arg2
);
967 return sys_semop((int) arg0
, (struct sembuf __user
*)arg1
,
968 (unsigned int) arg2
);
974 static inline loff_t
llseek(struct file
*file
, loff_t offset
, int origin
)
976 loff_t (*fn
)(struct file
*, loff_t
, int);
980 if (file
->f_op
&& file
->f_op
->llseek
)
981 fn
= file
->f_op
->llseek
;
983 retval
= fn(file
, offset
, origin
);
989 asmlinkage
int irix_lseek64(int fd
, int _unused
, int offhi
, int offlow
,
1004 offset
= llseek(file
, ((loff_t
) offhi
<< 32) | offlow
, origin
);
1005 retval
= (int) offset
;
1013 asmlinkage
int irix_sginap(int ticks
)
1015 schedule_timeout_interruptible(ticks
);
1019 asmlinkage
int irix_sgikopt(char __user
*istring
, char __user
*ostring
, int len
)
1024 asmlinkage
int irix_gettimeofday(struct timeval __user
*tv
)
1030 if (!access_ok(VERIFY_WRITE
, tv
, sizeof(struct timeval
)))
1034 seq
= read_seqbegin(&xtime_lock
);
1036 nsec
= xtime
.tv_nsec
;
1037 } while (read_seqretry(&xtime_lock
, seq
));
1039 err
= __put_user(sec
, &tv
->tv_sec
);
1040 err
|= __put_user((nsec
/ 1000), &tv
->tv_usec
);
1045 #define IRIX_MAP_AUTOGROW 0x40
1047 asmlinkage
unsigned long irix_mmap32(unsigned long addr
, size_t len
, int prot
,
1048 int flags
, int fd
, off_t offset
)
1050 struct file
*file
= NULL
;
1051 unsigned long retval
;
1053 if (!(flags
& MAP_ANONYMOUS
)) {
1054 if (!(file
= fget(fd
)))
1057 /* Ok, bad taste hack follows, try to think in something else
1058 * when reading this. */
1059 if (flags
& IRIX_MAP_AUTOGROW
) {
1060 unsigned long old_pos
;
1061 long max_size
= offset
+ len
;
1063 if (max_size
> file
->f_dentry
->d_inode
->i_size
) {
1064 old_pos
= sys_lseek (fd
, max_size
- 1, 0);
1065 sys_write (fd
, (void __user
*) "", 1);
1066 sys_lseek (fd
, old_pos
, 0);
1071 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
1073 down_write(¤t
->mm
->mmap_sem
);
1074 retval
= do_mmap(file
, addr
, len
, prot
, flags
, offset
);
1075 up_write(¤t
->mm
->mmap_sem
);
1082 asmlinkage
int irix_madvise(unsigned long addr
, int len
, int behavior
)
1084 printk("[%s:%d] Wheee.. irix_madvise(%08lx,%d,%d)\n",
1085 current
->comm
, current
->pid
, addr
, len
, behavior
);
1090 asmlinkage
int irix_pagelock(char __user
*addr
, int len
, int op
)
1092 printk("[%s:%d] Wheee.. irix_pagelock(%p,%d,%d)\n",
1093 current
->comm
, current
->pid
, addr
, len
, op
);
1098 asmlinkage
int irix_quotactl(struct pt_regs
*regs
)
1100 printk("[%s:%d] Wheee.. irix_quotactl()\n",
1101 current
->comm
, current
->pid
);
1106 asmlinkage
int irix_BSDsetpgrp(int pid
, int pgrp
)
1110 #ifdef DEBUG_PROCGRPS
1111 printk("[%s:%d] BSDsetpgrp(%d, %d) ", current
->comm
, current
->pid
,
1117 /* Wheee, weird sysv thing... */
1118 if ((pgrp
== 0) && (pid
== current
->pid
))
1119 error
= sys_setsid();
1121 error
= sys_setpgid(pid
, pgrp
);
1123 #ifdef DEBUG_PROCGRPS
1124 printk("error = %d\n", error
);
1130 asmlinkage
int irix_systeminfo(int cmd
, char __user
*buf
, int cnt
)
1132 printk("[%s:%d] Wheee.. irix_systeminfo(%d,%p,%d)\n",
1133 current
->comm
, current
->pid
, cmd
, buf
, cnt
);
1139 char sysname
[257], nodename
[257], release
[257];
1140 char version
[257], machine
[257];
1141 char m_type
[257], base_rel
[257];
1142 char _unused0
[257], _unused1
[257], _unused2
[257];
1143 char _unused3
[257], _unused4
[257], _unused5
[257];
1146 asmlinkage
int irix_uname(struct iuname __user
*buf
)
1148 down_read(&uts_sem
);
1149 if (copy_from_user(system_utsname
.sysname
, buf
->sysname
, 65)
1150 || copy_from_user(system_utsname
.nodename
, buf
->nodename
, 65)
1151 || copy_from_user(system_utsname
.release
, buf
->release
, 65)
1152 || copy_from_user(system_utsname
.version
, buf
->version
, 65)
1153 || copy_from_user(system_utsname
.machine
, buf
->machine
, 65)) {
1163 static int irix_xstat32_xlate(struct kstat
*stat
, void __user
*ubuf
)
1166 u32 st_dev
, st_pad1
[3], st_ino
, st_mode
, st_nlink
, st_uid
, st_gid
;
1167 u32 st_rdev
, st_pad2
[2], st_size
, st_pad3
;
1168 u32 st_atime0
, st_atime1
;
1169 u32 st_mtime0
, st_mtime1
;
1170 u32 st_ctime0
, st_ctime1
;
1171 u32 st_blksize
, st_blocks
;
1176 if (!sysv_valid_dev(stat
->dev
) || !sysv_valid_dev(stat
->rdev
))
1178 ub
.st_dev
= sysv_encode_dev(stat
->dev
);
1179 ub
.st_ino
= stat
->ino
;
1180 ub
.st_mode
= stat
->mode
;
1181 ub
.st_nlink
= stat
->nlink
;
1182 SET_UID(ub
.st_uid
, stat
->uid
);
1183 SET_GID(ub
.st_gid
, stat
->gid
);
1184 ub
.st_rdev
= sysv_encode_dev(stat
->rdev
);
1185 #if BITS_PER_LONG == 32
1186 if (stat
->size
> MAX_NON_LFS
)
1189 ub
.st_size
= stat
->size
;
1190 ub
.st_atime0
= stat
->atime
.tv_sec
;
1191 ub
.st_atime1
= stat
->atime
.tv_nsec
;
1192 ub
.st_mtime0
= stat
->mtime
.tv_sec
;
1193 ub
.st_mtime1
= stat
->atime
.tv_nsec
;
1194 ub
.st_ctime0
= stat
->ctime
.tv_sec
;
1195 ub
.st_ctime1
= stat
->atime
.tv_nsec
;
1196 ub
.st_blksize
= stat
->blksize
;
1197 ub
.st_blocks
= stat
->blocks
;
1198 strcpy (ub
.st_fstype
, "efs");
1200 return copy_to_user(ubuf
, &ub
, sizeof(ub
)) ? -EFAULT
: 0;
1203 static int irix_xstat64_xlate(struct kstat
*stat
, void __user
*ubuf
)
1206 u32 st_dev
; s32 st_pad1
[3];
1207 unsigned long long st_ino
;
1209 u32 st_nlink
; s32 st_uid
; s32 st_gid
; u32 st_rdev
;
1213 struct { s32 tv_sec
, tv_nsec
; } st_atime
, st_mtime
, st_ctime
;
1215 long long st_blocks
;
1220 if (!sysv_valid_dev(stat
->dev
) || !sysv_valid_dev(stat
->rdev
))
1223 ks
.st_dev
= sysv_encode_dev(stat
->dev
);
1224 ks
.st_pad1
[0] = ks
.st_pad1
[1] = ks
.st_pad1
[2] = 0;
1225 ks
.st_ino
= (unsigned long long) stat
->ino
;
1226 ks
.st_mode
= (u32
) stat
->mode
;
1227 ks
.st_nlink
= (u32
) stat
->nlink
;
1228 ks
.st_uid
= (s32
) stat
->uid
;
1229 ks
.st_gid
= (s32
) stat
->gid
;
1230 ks
.st_rdev
= sysv_encode_dev (stat
->rdev
);
1231 ks
.st_pad2
[0] = ks
.st_pad2
[1] = 0;
1232 ks
.st_size
= (long long) stat
->size
;
1235 /* XXX hackety hack... */
1236 ks
.st_atime
.tv_sec
= (s32
) stat
->atime
.tv_sec
;
1237 ks
.st_atime
.tv_nsec
= stat
->atime
.tv_nsec
;
1238 ks
.st_mtime
.tv_sec
= (s32
) stat
->mtime
.tv_sec
;
1239 ks
.st_mtime
.tv_nsec
= stat
->mtime
.tv_nsec
;
1240 ks
.st_ctime
.tv_sec
= (s32
) stat
->ctime
.tv_sec
;
1241 ks
.st_ctime
.tv_nsec
= stat
->ctime
.tv_nsec
;
1243 ks
.st_blksize
= (s32
) stat
->blksize
;
1244 ks
.st_blocks
= (long long) stat
->blocks
;
1245 memset(ks
.st_fstype
, 0, 16);
1246 ks
.st_pad4
[0] = ks
.st_pad4
[1] = ks
.st_pad4
[2] = ks
.st_pad4
[3] = 0;
1247 ks
.st_pad4
[4] = ks
.st_pad4
[5] = ks
.st_pad4
[6] = ks
.st_pad4
[7] = 0;
1249 /* Now write it all back. */
1250 return copy_to_user(ubuf
, &ks
, sizeof(ks
)) ? -EFAULT
: 0;
1253 asmlinkage
int irix_xstat(int version
, char __user
*filename
, struct stat __user
*statbuf
)
1259 printk("[%s:%d] Wheee.. irix_xstat(%d,%s,%p) ",
1260 current
->comm
, current
->pid
, version
, filename
, statbuf
);
1263 retval
= vfs_stat(filename
, &stat
);
1267 retval
= irix_xstat32_xlate(&stat
, statbuf
);
1270 retval
= irix_xstat64_xlate(&stat
, statbuf
);
1279 asmlinkage
int irix_lxstat(int version
, char __user
*filename
, struct stat __user
*statbuf
)
1285 printk("[%s:%d] Wheee.. irix_lxstat(%d,%s,%p) ",
1286 current
->comm
, current
->pid
, version
, filename
, statbuf
);
1289 error
= vfs_lstat(filename
, &stat
);
1294 error
= irix_xstat32_xlate(&stat
, statbuf
);
1297 error
= irix_xstat64_xlate(&stat
, statbuf
);
1306 asmlinkage
int irix_fxstat(int version
, int fd
, struct stat __user
*statbuf
)
1312 printk("[%s:%d] Wheee.. irix_fxstat(%d,%d,%p) ",
1313 current
->comm
, current
->pid
, version
, fd
, statbuf
);
1316 error
= vfs_fstat(fd
, &stat
);
1320 error
= irix_xstat32_xlate(&stat
, statbuf
);
1323 error
= irix_xstat64_xlate(&stat
, statbuf
);
1332 asmlinkage
int irix_xmknod(int ver
, char __user
*filename
, int mode
, unsigned dev
)
1335 printk("[%s:%d] Wheee.. irix_xmknod(%d,%s,%x,%x)\n",
1336 current
->comm
, current
->pid
, ver
, filename
, mode
, dev
);
1340 /* shouldn't we convert here as well as on stat()? */
1341 retval
= sys_mknod(filename
, mode
, dev
);
1352 asmlinkage
int irix_swapctl(int cmd
, char __user
*arg
)
1354 printk("[%s:%d] Wheee.. irix_swapctl(%d,%p)\n",
1355 current
->comm
, current
->pid
, cmd
, arg
);
1360 struct irix_statvfs
{
1361 u32 f_bsize
; u32 f_frsize
; u32 f_blocks
;
1362 u32 f_bfree
; u32 f_bavail
; u32 f_files
; u32 f_ffree
; u32 f_favail
;
1363 u32 f_fsid
; char f_basetype
[16];
1364 u32 f_flag
; u32 f_namemax
;
1365 char f_fstr
[32]; u32 f_filler
[16];
1368 asmlinkage
int irix_statvfs(char __user
*fname
, struct irix_statvfs __user
*buf
)
1370 struct nameidata nd
;
1371 struct kstatfs kbuf
;
1374 printk("[%s:%d] Wheee.. irix_statvfs(%s,%p)\n",
1375 current
->comm
, current
->pid
, fname
, buf
);
1376 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs
)))
1379 error
= user_path_walk(fname
, &nd
);
1382 error
= vfs_statfs(nd
.dentry
->d_inode
->i_sb
, &kbuf
);
1386 error
|= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1387 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1388 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1389 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1390 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1391 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1392 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1393 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1395 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1397 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1399 for (i
= 0; i
< 16; i
++)
1400 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1401 error
|= __put_user(0, &buf
->f_flag
);
1402 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1403 for (i
= 0; i
< 32; i
++)
1404 error
|= __put_user(0, &buf
->f_fstr
[i
]);
1412 asmlinkage
int irix_fstatvfs(int fd
, struct irix_statvfs __user
*buf
)
1414 struct kstatfs kbuf
;
1418 printk("[%s:%d] Wheee.. irix_fstatvfs(%d,%p)\n",
1419 current
->comm
, current
->pid
, fd
, buf
);
1421 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs
)))
1424 if (!(file
= fget(fd
))) {
1428 error
= vfs_statfs(file
->f_dentry
->d_inode
->i_sb
, &kbuf
);
1432 error
= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1433 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1434 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1435 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1436 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1437 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1438 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1439 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1441 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1443 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1445 for(i
= 0; i
< 16; i
++)
1446 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1447 error
|= __put_user(0, &buf
->f_flag
);
1448 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1449 error
|= __clear_user(&buf
->f_fstr
, sizeof(buf
->f_fstr
)) ? -EFAULT
: 0;
1457 asmlinkage
int irix_priocntl(struct pt_regs
*regs
)
1459 printk("[%s:%d] Wheee.. irix_priocntl()\n",
1460 current
->comm
, current
->pid
);
1465 asmlinkage
int irix_sigqueue(int pid
, int sig
, int code
, int val
)
1467 printk("[%s:%d] Wheee.. irix_sigqueue(%d,%d,%d,%d)\n",
1468 current
->comm
, current
->pid
, pid
, sig
, code
, val
);
1473 asmlinkage
int irix_truncate64(char __user
*name
, int pad
, int size1
, int size2
)
1481 retval
= sys_truncate(name
, size2
);
1487 asmlinkage
int irix_ftruncate64(int fd
, int pad
, int size1
, int size2
)
1495 retval
= sys_ftruncate(fd
, size2
);
1501 asmlinkage
int irix_mmap64(struct pt_regs
*regs
)
1503 int len
, prot
, flags
, fd
, off1
, off2
, error
, base
= 0;
1504 unsigned long addr
, pgoff
, *sp
;
1505 struct file
*file
= NULL
;
1508 if (regs
->regs
[2] == 1000)
1510 sp
= (unsigned long *) (regs
->regs
[29] + 16);
1511 addr
= regs
->regs
[base
+ 4];
1512 len
= regs
->regs
[base
+ 5];
1513 prot
= regs
->regs
[base
+ 6];
1515 flags
= regs
->regs
[base
+ 7];
1516 if (!access_ok(VERIFY_READ
, sp
, (4 * sizeof(unsigned long))))
1519 err
= __get_user(off1
, &sp
[1]);
1520 err
|= __get_user(off2
, &sp
[2]);
1522 if (!access_ok(VERIFY_READ
, sp
, (5 * sizeof(unsigned long))))
1524 err
= __get_user(flags
, &sp
[0]);
1525 err
|= __get_user(fd
, &sp
[1]);
1526 err
|= __get_user(off1
, &sp
[2]);
1527 err
|= __get_user(off2
, &sp
[3]);
1533 if (off1
& PAGE_MASK
)
1536 pgoff
= (off1
<< (32 - PAGE_SHIFT
)) | (off2
>> PAGE_SHIFT
);
1538 if (!(flags
& MAP_ANONYMOUS
)) {
1539 if (!(file
= fget(fd
)))
1542 /* Ok, bad taste hack follows, try to think in something else
1543 when reading this */
1544 if (flags
& IRIX_MAP_AUTOGROW
) {
1545 unsigned long old_pos
;
1546 long max_size
= off2
+ len
;
1548 if (max_size
> file
->f_dentry
->d_inode
->i_size
) {
1549 old_pos
= sys_lseek (fd
, max_size
- 1, 0);
1550 sys_write (fd
, (void __user
*) "", 1);
1551 sys_lseek (fd
, old_pos
, 0);
1556 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
1558 down_write(¤t
->mm
->mmap_sem
);
1559 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
1560 up_write(¤t
->mm
->mmap_sem
);
1568 asmlinkage
int irix_dmi(struct pt_regs
*regs
)
1570 printk("[%s:%d] Wheee.. irix_dmi()\n",
1571 current
->comm
, current
->pid
);
1576 asmlinkage
int irix_pread(int fd
, char __user
*buf
, int cnt
, int off64
,
1579 printk("[%s:%d] Wheee.. irix_pread(%d,%p,%d,%d,%d,%d)\n",
1580 current
->comm
, current
->pid
, fd
, buf
, cnt
, off64
, off1
, off2
);
1585 asmlinkage
int irix_pwrite(int fd
, char __user
*buf
, int cnt
, int off64
,
1588 printk("[%s:%d] Wheee.. irix_pwrite(%d,%p,%d,%d,%d,%d)\n",
1589 current
->comm
, current
->pid
, fd
, buf
, cnt
, off64
, off1
, off2
);
1594 asmlinkage
int irix_sgifastpath(int cmd
, unsigned long arg0
, unsigned long arg1
,
1595 unsigned long arg2
, unsigned long arg3
,
1596 unsigned long arg4
, unsigned long arg5
)
1598 printk("[%s:%d] Wheee.. irix_fastpath(%d,%08lx,%08lx,%08lx,%08lx,"
1600 current
->comm
, current
->pid
, cmd
, arg0
, arg1
, arg2
,
1606 struct irix_statvfs64
{
1607 u32 f_bsize
; u32 f_frsize
;
1608 u64 f_blocks
; u64 f_bfree
; u64 f_bavail
;
1609 u64 f_files
; u64 f_ffree
; u64 f_favail
;
1611 char f_basetype
[16];
1612 u32 f_flag
; u32 f_namemax
;
1617 asmlinkage
int irix_statvfs64(char __user
*fname
, struct irix_statvfs64 __user
*buf
)
1619 struct nameidata nd
;
1620 struct kstatfs kbuf
;
1623 printk("[%s:%d] Wheee.. irix_statvfs64(%s,%p)\n",
1624 current
->comm
, current
->pid
, fname
, buf
);
1625 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs64
))) {
1630 error
= user_path_walk(fname
, &nd
);
1633 error
= vfs_statfs(nd
.dentry
->d_inode
->i_sb
, &kbuf
);
1637 error
= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1638 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1639 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1640 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1641 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1642 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1643 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1644 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1646 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1648 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1650 for(i
= 0; i
< 16; i
++)
1651 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1652 error
|= __put_user(0, &buf
->f_flag
);
1653 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1654 for(i
= 0; i
< 32; i
++)
1655 error
|= __put_user(0, &buf
->f_fstr
[i
]);
1663 asmlinkage
int irix_fstatvfs64(int fd
, struct irix_statvfs __user
*buf
)
1665 struct kstatfs kbuf
;
1669 printk("[%s:%d] Wheee.. irix_fstatvfs64(%d,%p)\n",
1670 current
->comm
, current
->pid
, fd
, buf
);
1672 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs
))) {
1676 if (!(file
= fget(fd
))) {
1680 error
= vfs_statfs(file
->f_dentry
->d_inode
->i_sb
, &kbuf
);
1684 error
= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1685 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1686 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1687 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1688 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1689 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1690 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1691 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1693 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1695 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1697 for(i
= 0; i
< 16; i
++)
1698 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1699 error
|= __put_user(0, &buf
->f_flag
);
1700 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1701 error
|= __clear_user(buf
->f_fstr
, sizeof(buf
->f_fstr
[i
])) ? -EFAULT
: 0;
1709 asmlinkage
int irix_getmountid(char __user
*fname
, unsigned long __user
*midbuf
)
1713 printk("[%s:%d] irix_getmountid(%s, %p)\n",
1714 current
->comm
, current
->pid
, fname
, midbuf
);
1715 if (!access_ok(VERIFY_WRITE
, midbuf
, (sizeof(unsigned long) * 4)))
1719 * The idea with this system call is that when trying to determine
1720 * 'pwd' and it's a toss-up for some reason, userland can use the
1721 * fsid of the filesystem to try and make the right decision, but
1722 * we don't have this so for now. XXX
1724 err
= __put_user(0, &midbuf
[0]);
1725 err
|= __put_user(0, &midbuf
[1]);
1726 err
|= __put_user(0, &midbuf
[2]);
1727 err
|= __put_user(0, &midbuf
[3]);
1732 asmlinkage
int irix_nsproc(unsigned long entry
, unsigned long mask
,
1733 unsigned long arg
, unsigned long sp
, int slen
)
1735 printk("[%s:%d] Wheee.. irix_nsproc(%08lx,%08lx,%08lx,%08lx,%d)\n",
1736 current
->comm
, current
->pid
, entry
, mask
, arg
, sp
, slen
);
1741 #undef DEBUG_GETDENTS
1743 struct irix_dirent32
{
1746 unsigned short d_reclen
;
1750 struct irix_dirent32_callback
{
1751 struct irix_dirent32 __user
*current_dir
;
1752 struct irix_dirent32 __user
*previous
;
1757 #define NAME_OFFSET32(de) ((int) ((de)->d_name - (char *) (de)))
1758 #define ROUND_UP32(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
1760 static int irix_filldir32(void *__buf
, const char *name
,
1761 int namlen
, loff_t offset
, ino_t ino
, unsigned int d_type
)
1763 struct irix_dirent32 __user
*dirent
;
1764 struct irix_dirent32_callback
*buf
= __buf
;
1765 unsigned short reclen
= ROUND_UP32(NAME_OFFSET32(dirent
) + namlen
+ 1);
1768 #ifdef DEBUG_GETDENTS
1769 printk("\nirix_filldir32[reclen<%d>namlen<%d>count<%d>]",
1770 reclen
, namlen
, buf
->count
);
1772 buf
->error
= -EINVAL
; /* only used if we fail.. */
1773 if (reclen
> buf
->count
)
1775 dirent
= buf
->previous
;
1777 err
= __put_user(offset
, &dirent
->d_off
);
1778 dirent
= buf
->current_dir
;
1779 err
|= __put_user(dirent
, &buf
->previous
);
1780 err
|= __put_user(ino
, &dirent
->d_ino
);
1781 err
|= __put_user(reclen
, &dirent
->d_reclen
);
1782 err
|= copy_to_user((char __user
*)dirent
->d_name
, name
, namlen
) ? -EFAULT
: 0;
1783 err
|= __put_user(0, &dirent
->d_name
[namlen
]);
1784 dirent
= (struct irix_dirent32 __user
*) ((char __user
*) dirent
+ reclen
);
1786 buf
->current_dir
= dirent
;
1787 buf
->count
-= reclen
;
1792 asmlinkage
int irix_ngetdents(unsigned int fd
, void __user
* dirent
,
1793 unsigned int count
, int __user
*eob
)
1796 struct irix_dirent32 __user
*lastdirent
;
1797 struct irix_dirent32_callback buf
;
1800 #ifdef DEBUG_GETDENTS
1801 printk("[%s:%d] ngetdents(%d, %p, %d, %p) ", current
->comm
,
1802 current
->pid
, fd
, dirent
, count
, eob
);
1809 buf
.current_dir
= (struct irix_dirent32 __user
*) dirent
;
1810 buf
.previous
= NULL
;
1814 error
= vfs_readdir(file
, irix_filldir32
, &buf
);
1819 lastdirent
= buf
.previous
;
1821 put_user(file
->f_pos
, &lastdirent
->d_off
);
1822 error
= count
- buf
.count
;
1825 if (put_user(0, eob
) < 0) {
1830 #ifdef DEBUG_GETDENTS
1831 printk("eob=%d returning %d\n", *eob
, count
- buf
.count
);
1833 error
= count
- buf
.count
;
1841 struct irix_dirent64
{
1844 unsigned short d_reclen
;
1848 struct irix_dirent64_callback
{
1849 struct irix_dirent64 __user
*curr
;
1850 struct irix_dirent64 __user
*previous
;
1855 #define NAME_OFFSET64(de) ((int) ((de)->d_name - (char *) (de)))
1856 #define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
1858 static int irix_filldir64(void *__buf
, const char *name
,
1859 int namlen
, loff_t offset
, ino_t ino
, unsigned int d_type
)
1861 struct irix_dirent64 __user
*dirent
;
1862 struct irix_dirent64_callback
* buf
= __buf
;
1863 unsigned short reclen
= ROUND_UP64(NAME_OFFSET64(dirent
) + namlen
+ 1);
1866 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(*buf
)))
1869 if (__put_user(-EINVAL
, &buf
->error
)) /* only used if we fail.. */
1871 if (reclen
> buf
->count
)
1873 dirent
= buf
->previous
;
1875 err
= __put_user(offset
, &dirent
->d_off
);
1877 buf
->previous
= dirent
;
1878 err
|= __put_user(ino
, &dirent
->d_ino
);
1879 err
|= __put_user(reclen
, &dirent
->d_reclen
);
1880 err
|= __copy_to_user((char __user
*)dirent
->d_name
, name
, namlen
)
1882 err
|= __put_user(0, &dirent
->d_name
[namlen
]);
1884 dirent
= (struct irix_dirent64 __user
*) ((char __user
*) dirent
+ reclen
);
1887 buf
->count
-= reclen
;
1892 asmlinkage
int irix_getdents64(int fd
, void __user
*dirent
, int cnt
)
1895 struct irix_dirent64 __user
*lastdirent
;
1896 struct irix_dirent64_callback buf
;
1899 #ifdef DEBUG_GETDENTS
1900 printk("[%s:%d] getdents64(%d, %p, %d) ", current
->comm
,
1901 current
->pid
, fd
, dirent
, cnt
);
1904 if (!(file
= fget(fd
)))
1908 if (!access_ok(VERIFY_WRITE
, dirent
, cnt
))
1912 if (cnt
< (sizeof(struct irix_dirent64
) + 255))
1915 buf
.curr
= (struct irix_dirent64 __user
*) dirent
;
1916 buf
.previous
= NULL
;
1919 error
= vfs_readdir(file
, irix_filldir64
, &buf
);
1922 lastdirent
= buf
.previous
;
1927 if (put_user(file
->f_pos
, &lastdirent
->d_off
))
1929 #ifdef DEBUG_GETDENTS
1930 printk("returning %d\n", cnt
- buf
.count
);
1932 error
= cnt
- buf
.count
;
1940 asmlinkage
int irix_ngetdents64(int fd
, void __user
*dirent
, int cnt
, int *eob
)
1943 struct irix_dirent64 __user
*lastdirent
;
1944 struct irix_dirent64_callback buf
;
1947 #ifdef DEBUG_GETDENTS
1948 printk("[%s:%d] ngetdents64(%d, %p, %d) ", current
->comm
,
1949 current
->pid
, fd
, dirent
, cnt
);
1952 if (!(file
= fget(fd
)))
1956 if (!access_ok(VERIFY_WRITE
, dirent
, cnt
) ||
1957 !access_ok(VERIFY_WRITE
, eob
, sizeof(*eob
)))
1961 if (cnt
< (sizeof(struct irix_dirent64
) + 255))
1965 buf
.curr
= (struct irix_dirent64 __user
*) dirent
;
1966 buf
.previous
= NULL
;
1969 error
= vfs_readdir(file
, irix_filldir64
, &buf
);
1972 lastdirent
= buf
.previous
;
1977 if (put_user(file
->f_pos
, &lastdirent
->d_off
))
1979 #ifdef DEBUG_GETDENTS
1980 printk("eob=%d returning %d\n", *eob
, cnt
- buf
.count
);
1982 error
= cnt
- buf
.count
;
1990 asmlinkage
int irix_uadmin(unsigned long op
, unsigned long func
, unsigned long arg
)
1997 printk("[%s:%d] irix_uadmin: Wants to reboot...\n",
1998 current
->comm
, current
->pid
);
2004 printk("[%s:%d] irix_uadmin: Wants to shutdown...\n",
2005 current
->comm
, current
->pid
);
2011 printk("[%s:%d] irix_uadmin: Wants to remount root...\n",
2012 current
->comm
, current
->pid
);
2017 /* Kill all tasks. */
2018 printk("[%s:%d] irix_uadmin: Wants to kill all tasks...\n",
2019 current
->comm
, current
->pid
);
2024 /* Set magic mushrooms... */
2025 printk("[%s:%d] irix_uadmin: Wants to set magic mushroom[%d]...\n",
2026 current
->comm
, current
->pid
, (int) func
);
2031 printk("[%s:%d] irix_uadmin: Unknown operation [%d]...\n",
2032 current
->comm
, current
->pid
, (int) op
);
2041 asmlinkage
int irix_utssys(char __user
*inbuf
, int arg
, int type
, char __user
*outbuf
)
2048 retval
= irix_uname((struct iuname __user
*)inbuf
);
2053 printk("[%s:%d] irix_utssys: Wants to do ustat()\n",
2054 current
->comm
, current
->pid
);
2060 printk("[%s:%d] irix_utssys: Wants to do fusers()\n",
2061 current
->comm
, current
->pid
);
2066 printk("[%s:%d] irix_utssys: Wants to do unknown type[%d]\n",
2067 current
->comm
, current
->pid
, (int) type
);
2078 #define IRIX_F_ALLOCSP 10
2080 asmlinkage
int irix_fcntl(int fd
, int cmd
, int arg
)
2085 printk("[%s:%d] irix_fcntl(%d, %d, %d) ", current
->comm
,
2086 current
->pid
, fd
, cmd
, arg
);
2088 if (cmd
== IRIX_F_ALLOCSP
){
2091 retval
= sys_fcntl(fd
, cmd
, arg
);
2093 printk("%d\n", retval
);
2098 asmlinkage
int irix_ulimit(int cmd
, int arg
)
2104 printk("[%s:%d] irix_ulimit: Wants to get file size limit.\n",
2105 current
->comm
, current
->pid
);
2110 printk("[%s:%d] irix_ulimit: Wants to set file size limit.\n",
2111 current
->comm
, current
->pid
);
2116 printk("[%s:%d] irix_ulimit: Wants to get brk limit.\n",
2117 current
->comm
, current
->pid
);
2123 printk("[%s:%d] irix_ulimit: Wants to get fd limit.\n",
2124 current
->comm
, current
->pid
);
2128 retval
= current
->signal
->rlim
[RLIMIT_NOFILE
].rlim_cur
;
2132 printk("[%s:%d] irix_ulimit: Wants to get txt offset.\n",
2133 current
->comm
, current
->pid
);
2138 printk("[%s:%d] irix_ulimit: Unknown command [%d].\n",
2139 current
->comm
, current
->pid
, cmd
);
2147 asmlinkage
int irix_unimp(struct pt_regs
*regs
)
2149 printk("irix_unimp [%s:%d] v0=%d v1=%d a0=%08lx a1=%08lx a2=%08lx "
2150 "a3=%08lx\n", current
->comm
, current
->pid
,
2151 (int) regs
->regs
[2], (int) regs
->regs
[3],
2152 regs
->regs
[4], regs
->regs
[5], regs
->regs
[6], regs
->regs
[7]);