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/capability.h>
12 #include <linux/highuid.h>
13 #include <linux/pagemap.h>
15 #include <linux/mman.h>
16 #include <linux/slab.h>
17 #include <linux/swap.h>
18 #include <linux/errno.h>
19 #include <linux/time.h>
20 #include <linux/timex.h>
21 #include <linux/times.h>
22 #include <linux/elf.h>
23 #include <linux/msg.h>
24 #include <linux/shm.h>
25 #include <linux/smp.h>
26 #include <linux/smp_lock.h>
27 #include <linux/utsname.h>
28 #include <linux/file.h>
29 #include <linux/vfs.h>
30 #include <linux/namei.h>
31 #include <linux/socket.h>
32 #include <linux/security.h>
33 #include <linux/syscalls.h>
35 #include <asm/ptrace.h>
37 #include <asm/uaccess.h>
38 #include <asm/inventory.h>
40 /* 2,191 lines of complete and utter shit coming up... */
42 extern int max_threads
;
44 /* The sysmp commands supported thus far. */
45 #define MP_NPROCS 1 /* # processor in complex */
46 #define MP_NAPROCS 2 /* # active processors in complex */
47 #define MP_PGSIZE 14 /* Return system page size in v1. */
49 asmlinkage
int irix_sysmp(struct pt_regs
*regs
)
55 if(regs
->regs
[2] == 1000)
57 cmd
= regs
->regs
[base
+ 4];
64 error
= num_online_cpus();
67 printk("SYSMP[%s:%d]: Unsupported opcode %d\n",
68 current
->comm
, current
->pid
, (int)cmd
);
76 /* The prctl commands. */
77 #define PR_MAXPROCS 1 /* Tasks/user. */
78 #define PR_ISBLOCKED 2 /* If blocked, return 1. */
79 #define PR_SETSTACKSIZE 3 /* Set largest task stack size. */
80 #define PR_GETSTACKSIZE 4 /* Get largest task stack size. */
81 #define PR_MAXPPROCS 5 /* Num parallel tasks. */
82 #define PR_UNBLKONEXEC 6 /* When task exec/exit's, unblock. */
83 #define PR_SETEXITSIG 8 /* When task exit's, set signal. */
84 #define PR_RESIDENT 9 /* Make task unswappable. */
85 #define PR_ATTACHADDR 10 /* (Re-)Connect a vma to a task. */
86 #define PR_DETACHADDR 11 /* Disconnect a vma from a task. */
87 #define PR_TERMCHILD 12 /* Kill child if the parent dies. */
88 #define PR_GETSHMASK 13 /* Get the sproc() share mask. */
89 #define PR_GETNSHARE 14 /* Number of share group members. */
90 #define PR_COREPID 15 /* Add task pid to name when it core. */
91 #define PR_ATTACHADDRPERM 16 /* (Re-)Connect vma, with specified prot. */
92 #define PR_PTHREADEXIT 17 /* Kill a pthread, only for IRIX 6.[234] */
94 asmlinkage
int irix_prctl(unsigned option
, ...)
99 va_start(args
, option
);
102 printk("irix_prctl[%s:%d]: Wants PR_MAXPROCS\n",
103 current
->comm
, current
->pid
);
108 struct task_struct
*task
;
110 printk("irix_prctl[%s:%d]: Wants PR_ISBLOCKED\n",
111 current
->comm
, current
->pid
);
112 read_lock(&tasklist_lock
);
113 task
= find_task_by_pid(va_arg(args
, pid_t
));
116 error
= (task
->run_list
.next
!= NULL
);
117 read_unlock(&tasklist_lock
);
118 /* Can _your_ OS find this out that fast? */
122 case PR_SETSTACKSIZE
: {
123 long value
= va_arg(args
, long);
125 printk("irix_prctl[%s:%d]: Wants PR_SETSTACKSIZE<%08lx>\n",
126 current
->comm
, current
->pid
, (unsigned long) value
);
127 if (value
> RLIM_INFINITY
)
128 value
= RLIM_INFINITY
;
129 if (capable(CAP_SYS_ADMIN
)) {
130 task_lock(current
->group_leader
);
131 current
->signal
->rlim
[RLIMIT_STACK
].rlim_max
=
132 current
->signal
->rlim
[RLIMIT_STACK
].rlim_cur
= value
;
133 task_unlock(current
->group_leader
);
137 task_lock(current
->group_leader
);
138 if (value
> current
->signal
->rlim
[RLIMIT_STACK
].rlim_max
) {
140 task_unlock(current
->group_leader
);
143 current
->signal
->rlim
[RLIMIT_STACK
].rlim_cur
= value
;
144 task_unlock(current
->group_leader
);
149 case PR_GETSTACKSIZE
:
150 printk("irix_prctl[%s:%d]: Wants PR_GETSTACKSIZE\n",
151 current
->comm
, current
->pid
);
152 error
= current
->signal
->rlim
[RLIMIT_STACK
].rlim_cur
;
156 printk("irix_prctl[%s:%d]: Wants PR_MAXPROCS\n",
157 current
->comm
, current
->pid
);
162 printk("irix_prctl[%s:%d]: Wants PR_UNBLKONEXEC\n",
163 current
->comm
, current
->pid
);
168 printk("irix_prctl[%s:%d]: Wants PR_SETEXITSIG\n",
169 current
->comm
, current
->pid
);
171 /* We can probably play some game where we set the task
172 * exit_code to some non-zero value when this is requested,
173 * and check whether exit_code is already set in do_exit().
179 printk("irix_prctl[%s:%d]: Wants PR_RESIDENT\n",
180 current
->comm
, current
->pid
);
181 error
= 0; /* Compatibility indeed. */
185 printk("irix_prctl[%s:%d]: Wants PR_ATTACHADDR\n",
186 current
->comm
, current
->pid
);
191 printk("irix_prctl[%s:%d]: Wants PR_DETACHADDR\n",
192 current
->comm
, current
->pid
);
197 printk("irix_prctl[%s:%d]: Wants PR_TERMCHILD\n",
198 current
->comm
, current
->pid
);
203 printk("irix_prctl[%s:%d]: Wants PR_GETSHMASK\n",
204 current
->comm
, current
->pid
);
205 error
= -EINVAL
; /* Until I have the sproc() stuff in. */
209 error
= 0; /* Until I have the sproc() stuff in. */
213 printk("irix_prctl[%s:%d]: Wants PR_COREPID\n",
214 current
->comm
, current
->pid
);
218 case PR_ATTACHADDRPERM
:
219 printk("irix_prctl[%s:%d]: Wants PR_ATTACHADDRPERM\n",
220 current
->comm
, current
->pid
);
225 printk("irix_prctl[%s:%d]: Non-existant opcode %d\n",
226 current
->comm
, current
->pid
, option
);
235 #undef DEBUG_PROCGRPS
237 extern unsigned long irix_mapelf(int fd
, struct elf_phdr __user
*user_phdrp
, int cnt
);
238 extern int getrusage(struct task_struct
*p
, int who
, struct rusage __user
*ru
);
239 extern char *prom_getenv(char *name
);
240 extern long prom_setenv(char *name
, char *value
);
242 /* The syssgi commands supported thus far. */
243 #define SGI_SYSID 1 /* Return unique per-machine identifier. */
244 #define SGI_INVENT 5 /* Fetch inventory */
245 # define SGI_INV_SIZEOF 1
246 # define SGI_INV_READ 2
247 #define SGI_RDNAME 6 /* Return string name of a process. */
248 #define SGI_SETNVRAM 8 /* Set PROM variable. */
249 #define SGI_GETNVRAM 9 /* Get PROM variable. */
250 #define SGI_SETPGID 21 /* Set process group id. */
251 #define SGI_SYSCONF 22 /* POSIX sysconf garbage. */
252 #define SGI_PATHCONF 24 /* POSIX sysconf garbage. */
253 #define SGI_SETGROUPS 40 /* POSIX sysconf garbage. */
254 #define SGI_GETGROUPS 41 /* POSIX sysconf garbage. */
255 #define SGI_RUSAGE 56 /* BSD style rusage(). */
256 #define SGI_SSYNC 62 /* Synchronous fs sync. */
257 #define SGI_GETSID 65 /* SysVr4 get session id. */
258 #define SGI_ELFMAP 68 /* Map an elf image. */
259 #define SGI_TOSSTSAVE 108 /* Toss saved vma's. */
260 #define SGI_FP_BCOPY 129 /* Should FPU bcopy be used on this machine? */
261 #define SGI_PHYSP 1011 /* Translate virtual into physical page. */
263 asmlinkage
int irix_syssgi(struct pt_regs
*regs
)
266 int retval
, base
= 0;
268 if (regs
->regs
[2] == 1000)
271 cmd
= regs
->regs
[base
+ 4];
274 char __user
*buf
= (char __user
*) regs
->regs
[base
+ 5];
276 /* XXX Use ethernet addr.... */
277 retval
= clear_user(buf
, 64) ? -EFAULT
: 0;
282 int pid
= (int) regs
->regs
[base
+ 5];
283 char __user
*buf
= (char __user
*) regs
->regs
[base
+ 6];
284 struct task_struct
*p
;
285 char tcomm
[sizeof(current
->comm
)];
287 read_lock(&tasklist_lock
);
288 p
= find_task_by_pid(pid
);
290 read_unlock(&tasklist_lock
);
294 get_task_comm(tcomm
, p
);
295 read_unlock(&tasklist_lock
);
297 /* XXX Need to check sizes. */
298 retval
= copy_to_user(buf
, tcomm
, sizeof(tcomm
)) ? -EFAULT
: 0;
303 char __user
*name
= (char __user
*) regs
->regs
[base
+5];
304 char __user
*buf
= (char __user
*) regs
->regs
[base
+6];
306 return -EINVAL
; /* til I fix it */
307 value
= prom_getenv(name
); /* PROM lock? */
312 /* Do I strlen() for the length? */
313 retval
= copy_to_user(buf
, value
, 128) ? -EFAULT
: 0;
318 char __user
*name
= (char __user
*) regs
->regs
[base
+5];
319 char __user
*value
= (char __user
*) regs
->regs
[base
+6];
320 return -EINVAL
; /* til I fix it */
321 retval
= prom_setenv(name
, value
);
322 /* XXX make sure retval conforms to syssgi(2) */
323 printk("[%s:%d] setnvram(\"%s\", \"%s\"): retval %d",
324 current
->comm
, current
->pid
, name
, value
, retval
);
325 /* if (retval == PROM_ENOENT)
332 #ifdef DEBUG_PROCGRPS
333 printk("[%s:%d] setpgid(%d, %d) ",
334 current
->comm
, current
->pid
,
335 (int) regs
->regs
[base
+ 5], (int)regs
->regs
[base
+ 6]);
337 retval
= sys_setpgid(regs
->regs
[base
+ 5], regs
->regs
[base
+ 6]);
339 #ifdef DEBUG_PROCGRPS
340 printk("retval=%d\n", retval
);
345 switch(regs
->regs
[base
+ 5]) {
347 retval
= (MAX_ARG_PAGES
>> 4); /* XXX estimate... */
350 retval
= max_threads
;
356 retval
= NGROUPS_MAX
;
394 retval
= sys_setgroups((int) regs
->regs
[base
+ 5],
395 (gid_t __user
*) regs
->regs
[base
+ 6]);
399 retval
= sys_getgroups((int) regs
->regs
[base
+ 5],
400 (gid_t __user
*) regs
->regs
[base
+ 6]);
404 struct rusage __user
*ru
= (struct rusage __user
*) regs
->regs
[base
+ 6];
406 switch((int) regs
->regs
[base
+ 5]) {
409 retval
= getrusage(current
, RUSAGE_SELF
, ru
);
413 /* rusage children */
414 retval
= getrusage(current
, RUSAGE_CHILDREN
, ru
);
429 #ifdef DEBUG_PROCGRPS
430 printk("[%s:%d] getsid(%d) ", current
->comm
, current
->pid
,
431 (int) regs
->regs
[base
+ 5]);
433 retval
= sys_getsid(regs
->regs
[base
+ 5]);
434 #ifdef DEBUG_PROCGRPS
435 printk("retval=%d\n", retval
);
440 retval
= irix_mapelf((int) regs
->regs
[base
+ 5],
441 (struct elf_phdr __user
*) regs
->regs
[base
+ 6],
442 (int) regs
->regs
[base
+ 7]);
446 /* XXX We don't need to do anything? */
455 unsigned long addr
= regs
->regs
[base
+ 5];
456 int __user
*pageno
= (int __user
*) (regs
->regs
[base
+ 6]);
457 struct mm_struct
*mm
= current
->mm
;
463 down_read(&mm
->mmap_sem
);
464 pgdp
= pgd_offset(mm
, addr
);
465 pudp
= pud_offset(pgdp
, addr
);
466 pmdp
= pmd_offset(pudp
, addr
);
467 ptep
= pte_offset(pmdp
, addr
);
472 if (pte_val(pte
) & (_PAGE_VALID
| _PAGE_PRESENT
)) {
473 /* b0rked on 64-bit */
474 retval
= put_user((pte_val(pte
) & PAGE_MASK
) >>
478 up_read(&mm
->mmap_sem
);
483 int arg1
= (int) regs
->regs
[base
+ 5];
484 void __user
*buffer
= (void __user
*) regs
->regs
[base
+ 6];
485 int count
= (int) regs
->regs
[base
+ 7];
489 retval
= sizeof (inventory_t
);
492 retval
= dump_inventory_to_user (buffer
, count
);
501 printk("irix_syssgi: Unsupported command %d\n", (int)cmd
);
510 asmlinkage
int irix_gtime(struct pt_regs
*regs
)
512 return get_seconds();
516 * IRIX is completely broken... it returns 0 on success, otherwise
519 asmlinkage
int irix_brk(unsigned long brk
)
522 unsigned long newbrk
, oldbrk
;
523 struct mm_struct
*mm
= current
->mm
;
526 down_write(&mm
->mmap_sem
);
527 if (brk
< mm
->end_code
) {
532 newbrk
= PAGE_ALIGN(brk
);
533 oldbrk
= PAGE_ALIGN(mm
->brk
);
534 if (oldbrk
== newbrk
) {
541 * Always allow shrinking brk
543 if (brk
<= mm
->brk
) {
545 do_munmap(mm
, newbrk
, oldbrk
-newbrk
);
550 * Check against rlimit and stack..
552 rlim
= current
->signal
->rlim
[RLIMIT_DATA
].rlim_cur
;
553 if (rlim
>= RLIM_INFINITY
)
555 if (brk
- mm
->end_code
> rlim
) {
561 * Check against existing mmap mappings.
563 if (find_vma_intersection(mm
, oldbrk
, newbrk
+PAGE_SIZE
)) {
569 * Ok, looks good - let it rip.
571 if (do_brk(oldbrk
, newbrk
-oldbrk
) != oldbrk
) {
579 up_write(&mm
->mmap_sem
);
583 asmlinkage
int irix_getpid(struct pt_regs
*regs
)
585 regs
->regs
[3] = current
->real_parent
->pid
;
589 asmlinkage
int irix_getuid(struct pt_regs
*regs
)
591 regs
->regs
[3] = current
->euid
;
595 asmlinkage
int irix_getgid(struct pt_regs
*regs
)
597 regs
->regs
[3] = current
->egid
;
601 asmlinkage
int irix_stime(int value
)
608 err
= security_settime(&tv
, NULL
);
612 write_seqlock_irq(&xtime_lock
);
613 xtime
.tv_sec
= value
;
616 write_sequnlock_irq(&xtime_lock
);
621 static inline void jiffiestotv(unsigned long jiffies
, struct timeval
*value
)
623 value
->tv_usec
= (jiffies
% HZ
) * (1000000 / HZ
);
624 value
->tv_sec
= jiffies
/ HZ
;
627 static inline void getitimer_real(struct itimerval
*value
)
629 register unsigned long val
, interval
;
631 interval
= current
->it_real_incr
;
633 if (del_timer(¤t
->real_timer
)) {
634 unsigned long now
= jiffies
;
635 val
= current
->real_timer
.expires
;
636 add_timer(¤t
->real_timer
);
637 /* look out for negative/zero itimer.. */
642 jiffiestotv(val
, &value
->it_value
);
643 jiffiestotv(interval
, &value
->it_interval
);
646 asmlinkage
unsigned int irix_alarm(unsigned int seconds
)
648 struct itimerval it_new
, it_old
;
649 unsigned int oldalarm
;
652 getitimer_real(&it_old
);
653 del_timer(¤t
->real_timer
);
655 it_new
.it_interval
.tv_sec
= it_new
.it_interval
.tv_usec
= 0;
656 it_new
.it_value
.tv_sec
= seconds
;
657 it_new
.it_value
.tv_usec
= 0;
658 do_setitimer(ITIMER_REAL
, &it_new
, &it_old
);
660 oldalarm
= it_old
.it_value
.tv_sec
;
662 * ehhh.. We can't return 0 if we have an alarm pending ...
663 * And we'd better return too much than too little anyway
665 if (it_old
.it_value
.tv_usec
)
671 asmlinkage
int irix_pause(void)
673 current
->state
= TASK_INTERRUPTIBLE
;
679 /* XXX need more than this... */
680 asmlinkage
int irix_mount(char __user
*dev_name
, char __user
*dir_name
,
681 unsigned long flags
, char __user
*type
, void __user
*data
, int datalen
)
683 printk("[%s:%d] irix_mount(%p,%p,%08lx,%p,%p,%d)\n",
684 current
->comm
, current
->pid
,
685 dev_name
, dir_name
, flags
, type
, data
, datalen
);
687 return sys_mount(dev_name
, dir_name
, type
, flags
, data
);
692 long f_bsize
, f_frsize
, f_blocks
, f_bfree
, f_files
, f_ffree
;
693 char f_fname
[6], f_fpack
[6];
696 asmlinkage
int irix_statfs(const char __user
*path
,
697 struct irix_statfs __user
*buf
, int len
, int fs_type
)
703 /* We don't support this feature yet. */
708 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statfs
))) {
713 error
= user_path_walk(path
, &nd
);
717 error
= vfs_statfs(nd
.dentry
->d_inode
->i_sb
, &kbuf
);
721 error
= __put_user(kbuf
.f_type
, &buf
->f_type
);
722 error
|= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
723 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
724 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
725 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
726 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
727 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
728 for (i
= 0; i
< 6; i
++) {
729 error
|= __put_user(0, &buf
->f_fname
[i
]);
730 error
|= __put_user(0, &buf
->f_fpack
[i
]);
739 asmlinkage
int irix_fstatfs(unsigned int fd
, struct irix_statfs __user
*buf
)
745 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statfs
))) {
750 if (!(file
= fget(fd
))) {
755 error
= vfs_statfs(file
->f_dentry
->d_inode
->i_sb
, &kbuf
);
759 error
= __put_user(kbuf
.f_type
, &buf
->f_type
);
760 error
|= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
761 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
762 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
763 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
764 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
765 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
767 for (i
= 0; i
< 6; i
++) {
768 error
|= __put_user(0, &buf
->f_fname
[i
]);
769 error
|= __put_user(0, &buf
->f_fpack
[i
]);
778 asmlinkage
int irix_setpgrp(int flags
)
782 #ifdef DEBUG_PROCGRPS
783 printk("[%s:%d] setpgrp(%d) ", current
->comm
, current
->pid
, flags
);
786 error
= process_group(current
);
788 error
= sys_setsid();
789 #ifdef DEBUG_PROCGRPS
790 printk("returning %d\n", process_group(current
));
796 asmlinkage
int irix_times(struct tms __user
*tbuf
)
801 if (!access_ok(VERIFY_WRITE
,tbuf
,sizeof *tbuf
))
804 err
= __put_user(current
->utime
, &tbuf
->tms_utime
);
805 err
|= __put_user(current
->stime
, &tbuf
->tms_stime
);
806 err
|= __put_user(current
->signal
->cutime
, &tbuf
->tms_cutime
);
807 err
|= __put_user(current
->signal
->cstime
, &tbuf
->tms_cstime
);
813 asmlinkage
int irix_exec(struct pt_regs
*regs
)
818 if(regs
->regs
[2] == 1000)
820 filename
= getname((char __user
*) (long)regs
->regs
[base
+ 4]);
821 error
= PTR_ERR(filename
);
822 if (IS_ERR(filename
))
825 error
= do_execve(filename
, (char __user
* __user
*) (long)regs
->regs
[base
+ 5],
832 asmlinkage
int irix_exece(struct pt_regs
*regs
)
837 if (regs
->regs
[2] == 1000)
839 filename
= getname((char __user
*) (long)regs
->regs
[base
+ 4]);
840 error
= PTR_ERR(filename
);
841 if (IS_ERR(filename
))
843 error
= do_execve(filename
, (char __user
* __user
*) (long)regs
->regs
[base
+ 5],
844 (char __user
* __user
*) (long)regs
->regs
[base
+ 6], regs
);
850 asmlinkage
unsigned long irix_gethostid(void)
852 printk("[%s:%d]: irix_gethostid() called...\n",
853 current
->comm
, current
->pid
);
858 asmlinkage
unsigned long irix_sethostid(unsigned long val
)
860 printk("[%s:%d]: irix_sethostid(%08lx) called...\n",
861 current
->comm
, current
->pid
, val
);
866 asmlinkage
int irix_socket(int family
, int type
, int protocol
)
878 type
= 9; /* Invalid... */
890 type
= SOCK_SEQPACKET
;
897 return sys_socket(family
, type
, protocol
);
900 asmlinkage
int irix_getdomainname(char __user
*name
, int len
)
905 if (len
> __NEW_UTS_LEN
)
907 err
= copy_to_user(name
, system_utsname
.domainname
, len
) ? -EFAULT
: 0;
913 asmlinkage
unsigned long irix_getpagesize(void)
918 asmlinkage
int irix_msgsys(int opcode
, unsigned long arg0
, unsigned long arg1
,
919 unsigned long arg2
, unsigned long arg3
,
924 return sys_msgget((key_t
) arg0
, (int) arg1
);
926 return sys_msgctl((int) arg0
, (int) arg1
,
927 (struct msqid_ds __user
*)arg2
);
929 return sys_msgrcv((int) arg0
, (struct msgbuf __user
*) arg1
,
930 (size_t) arg2
, (long) arg3
, (int) arg4
);
932 return sys_msgsnd((int) arg0
, (struct msgbuf __user
*) arg1
,
933 (size_t) arg2
, (int) arg3
);
939 asmlinkage
int irix_shmsys(int opcode
, unsigned long arg0
, unsigned long arg1
,
940 unsigned long arg2
, unsigned long arg3
)
944 return do_shmat((int) arg0
, (char __user
*) arg1
, (int) arg2
,
945 (unsigned long *) arg3
);
947 return sys_shmctl((int)arg0
, (int)arg1
,
948 (struct shmid_ds __user
*)arg2
);
950 return sys_shmdt((char __user
*)arg0
);
952 return sys_shmget((key_t
) arg0
, (int) arg1
, (int) arg2
);
958 asmlinkage
int irix_semsys(int opcode
, unsigned long arg0
, unsigned long arg1
,
959 unsigned long arg2
, int arg3
)
963 return sys_semctl((int) arg0
, (int) arg1
, (int) arg2
,
966 return sys_semget((key_t
) arg0
, (int) arg1
, (int) arg2
);
968 return sys_semop((int) arg0
, (struct sembuf __user
*)arg1
,
969 (unsigned int) arg2
);
975 static inline loff_t
llseek(struct file
*file
, loff_t offset
, int origin
)
977 loff_t (*fn
)(struct file
*, loff_t
, int);
981 if (file
->f_op
&& file
->f_op
->llseek
)
982 fn
= file
->f_op
->llseek
;
984 retval
= fn(file
, offset
, origin
);
990 asmlinkage
int irix_lseek64(int fd
, int _unused
, int offhi
, int offlow
,
1005 offset
= llseek(file
, ((loff_t
) offhi
<< 32) | offlow
, origin
);
1006 retval
= (int) offset
;
1014 asmlinkage
int irix_sginap(int ticks
)
1016 schedule_timeout_interruptible(ticks
);
1020 asmlinkage
int irix_sgikopt(char __user
*istring
, char __user
*ostring
, int len
)
1025 asmlinkage
int irix_gettimeofday(struct timeval __user
*tv
)
1031 if (!access_ok(VERIFY_WRITE
, tv
, sizeof(struct timeval
)))
1035 seq
= read_seqbegin(&xtime_lock
);
1037 nsec
= xtime
.tv_nsec
;
1038 } while (read_seqretry(&xtime_lock
, seq
));
1040 err
= __put_user(sec
, &tv
->tv_sec
);
1041 err
|= __put_user((nsec
/ 1000), &tv
->tv_usec
);
1046 #define IRIX_MAP_AUTOGROW 0x40
1048 asmlinkage
unsigned long irix_mmap32(unsigned long addr
, size_t len
, int prot
,
1049 int flags
, int fd
, off_t offset
)
1051 struct file
*file
= NULL
;
1052 unsigned long retval
;
1054 if (!(flags
& MAP_ANONYMOUS
)) {
1055 if (!(file
= fget(fd
)))
1058 /* Ok, bad taste hack follows, try to think in something else
1059 * when reading this. */
1060 if (flags
& IRIX_MAP_AUTOGROW
) {
1061 unsigned long old_pos
;
1062 long max_size
= offset
+ len
;
1064 if (max_size
> file
->f_dentry
->d_inode
->i_size
) {
1065 old_pos
= sys_lseek (fd
, max_size
- 1, 0);
1066 sys_write (fd
, (void __user
*) "", 1);
1067 sys_lseek (fd
, old_pos
, 0);
1072 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
1074 down_write(¤t
->mm
->mmap_sem
);
1075 retval
= do_mmap(file
, addr
, len
, prot
, flags
, offset
);
1076 up_write(¤t
->mm
->mmap_sem
);
1083 asmlinkage
int irix_madvise(unsigned long addr
, int len
, int behavior
)
1085 printk("[%s:%d] Wheee.. irix_madvise(%08lx,%d,%d)\n",
1086 current
->comm
, current
->pid
, addr
, len
, behavior
);
1091 asmlinkage
int irix_pagelock(char __user
*addr
, int len
, int op
)
1093 printk("[%s:%d] Wheee.. irix_pagelock(%p,%d,%d)\n",
1094 current
->comm
, current
->pid
, addr
, len
, op
);
1099 asmlinkage
int irix_quotactl(struct pt_regs
*regs
)
1101 printk("[%s:%d] Wheee.. irix_quotactl()\n",
1102 current
->comm
, current
->pid
);
1107 asmlinkage
int irix_BSDsetpgrp(int pid
, int pgrp
)
1111 #ifdef DEBUG_PROCGRPS
1112 printk("[%s:%d] BSDsetpgrp(%d, %d) ", current
->comm
, current
->pid
,
1118 /* Wheee, weird sysv thing... */
1119 if ((pgrp
== 0) && (pid
== current
->pid
))
1120 error
= sys_setsid();
1122 error
= sys_setpgid(pid
, pgrp
);
1124 #ifdef DEBUG_PROCGRPS
1125 printk("error = %d\n", error
);
1131 asmlinkage
int irix_systeminfo(int cmd
, char __user
*buf
, int cnt
)
1133 printk("[%s:%d] Wheee.. irix_systeminfo(%d,%p,%d)\n",
1134 current
->comm
, current
->pid
, cmd
, buf
, cnt
);
1140 char sysname
[257], nodename
[257], release
[257];
1141 char version
[257], machine
[257];
1142 char m_type
[257], base_rel
[257];
1143 char _unused0
[257], _unused1
[257], _unused2
[257];
1144 char _unused3
[257], _unused4
[257], _unused5
[257];
1147 asmlinkage
int irix_uname(struct iuname __user
*buf
)
1149 down_read(&uts_sem
);
1150 if (copy_from_user(system_utsname
.sysname
, buf
->sysname
, 65)
1151 || copy_from_user(system_utsname
.nodename
, buf
->nodename
, 65)
1152 || copy_from_user(system_utsname
.release
, buf
->release
, 65)
1153 || copy_from_user(system_utsname
.version
, buf
->version
, 65)
1154 || copy_from_user(system_utsname
.machine
, buf
->machine
, 65)) {
1164 static int irix_xstat32_xlate(struct kstat
*stat
, void __user
*ubuf
)
1167 u32 st_dev
, st_pad1
[3], st_ino
, st_mode
, st_nlink
, st_uid
, st_gid
;
1168 u32 st_rdev
, st_pad2
[2], st_size
, st_pad3
;
1169 u32 st_atime0
, st_atime1
;
1170 u32 st_mtime0
, st_mtime1
;
1171 u32 st_ctime0
, st_ctime1
;
1172 u32 st_blksize
, st_blocks
;
1177 if (!sysv_valid_dev(stat
->dev
) || !sysv_valid_dev(stat
->rdev
))
1179 ub
.st_dev
= sysv_encode_dev(stat
->dev
);
1180 ub
.st_ino
= stat
->ino
;
1181 ub
.st_mode
= stat
->mode
;
1182 ub
.st_nlink
= stat
->nlink
;
1183 SET_UID(ub
.st_uid
, stat
->uid
);
1184 SET_GID(ub
.st_gid
, stat
->gid
);
1185 ub
.st_rdev
= sysv_encode_dev(stat
->rdev
);
1186 #if BITS_PER_LONG == 32
1187 if (stat
->size
> MAX_NON_LFS
)
1190 ub
.st_size
= stat
->size
;
1191 ub
.st_atime0
= stat
->atime
.tv_sec
;
1192 ub
.st_atime1
= stat
->atime
.tv_nsec
;
1193 ub
.st_mtime0
= stat
->mtime
.tv_sec
;
1194 ub
.st_mtime1
= stat
->atime
.tv_nsec
;
1195 ub
.st_ctime0
= stat
->ctime
.tv_sec
;
1196 ub
.st_ctime1
= stat
->atime
.tv_nsec
;
1197 ub
.st_blksize
= stat
->blksize
;
1198 ub
.st_blocks
= stat
->blocks
;
1199 strcpy (ub
.st_fstype
, "efs");
1201 return copy_to_user(ubuf
, &ub
, sizeof(ub
)) ? -EFAULT
: 0;
1204 static int irix_xstat64_xlate(struct kstat
*stat
, void __user
*ubuf
)
1207 u32 st_dev
; s32 st_pad1
[3];
1208 unsigned long long st_ino
;
1210 u32 st_nlink
; s32 st_uid
; s32 st_gid
; u32 st_rdev
;
1214 struct { s32 tv_sec
, tv_nsec
; } st_atime
, st_mtime
, st_ctime
;
1216 long long st_blocks
;
1221 if (!sysv_valid_dev(stat
->dev
) || !sysv_valid_dev(stat
->rdev
))
1224 ks
.st_dev
= sysv_encode_dev(stat
->dev
);
1225 ks
.st_pad1
[0] = ks
.st_pad1
[1] = ks
.st_pad1
[2] = 0;
1226 ks
.st_ino
= (unsigned long long) stat
->ino
;
1227 ks
.st_mode
= (u32
) stat
->mode
;
1228 ks
.st_nlink
= (u32
) stat
->nlink
;
1229 ks
.st_uid
= (s32
) stat
->uid
;
1230 ks
.st_gid
= (s32
) stat
->gid
;
1231 ks
.st_rdev
= sysv_encode_dev (stat
->rdev
);
1232 ks
.st_pad2
[0] = ks
.st_pad2
[1] = 0;
1233 ks
.st_size
= (long long) stat
->size
;
1236 /* XXX hackety hack... */
1237 ks
.st_atime
.tv_sec
= (s32
) stat
->atime
.tv_sec
;
1238 ks
.st_atime
.tv_nsec
= stat
->atime
.tv_nsec
;
1239 ks
.st_mtime
.tv_sec
= (s32
) stat
->mtime
.tv_sec
;
1240 ks
.st_mtime
.tv_nsec
= stat
->mtime
.tv_nsec
;
1241 ks
.st_ctime
.tv_sec
= (s32
) stat
->ctime
.tv_sec
;
1242 ks
.st_ctime
.tv_nsec
= stat
->ctime
.tv_nsec
;
1244 ks
.st_blksize
= (s32
) stat
->blksize
;
1245 ks
.st_blocks
= (long long) stat
->blocks
;
1246 memset(ks
.st_fstype
, 0, 16);
1247 ks
.st_pad4
[0] = ks
.st_pad4
[1] = ks
.st_pad4
[2] = ks
.st_pad4
[3] = 0;
1248 ks
.st_pad4
[4] = ks
.st_pad4
[5] = ks
.st_pad4
[6] = ks
.st_pad4
[7] = 0;
1250 /* Now write it all back. */
1251 return copy_to_user(ubuf
, &ks
, sizeof(ks
)) ? -EFAULT
: 0;
1254 asmlinkage
int irix_xstat(int version
, char __user
*filename
, struct stat __user
*statbuf
)
1260 printk("[%s:%d] Wheee.. irix_xstat(%d,%s,%p) ",
1261 current
->comm
, current
->pid
, version
, filename
, statbuf
);
1264 retval
= vfs_stat(filename
, &stat
);
1268 retval
= irix_xstat32_xlate(&stat
, statbuf
);
1271 retval
= irix_xstat64_xlate(&stat
, statbuf
);
1280 asmlinkage
int irix_lxstat(int version
, char __user
*filename
, struct stat __user
*statbuf
)
1286 printk("[%s:%d] Wheee.. irix_lxstat(%d,%s,%p) ",
1287 current
->comm
, current
->pid
, version
, filename
, statbuf
);
1290 error
= vfs_lstat(filename
, &stat
);
1295 error
= irix_xstat32_xlate(&stat
, statbuf
);
1298 error
= irix_xstat64_xlate(&stat
, statbuf
);
1307 asmlinkage
int irix_fxstat(int version
, int fd
, struct stat __user
*statbuf
)
1313 printk("[%s:%d] Wheee.. irix_fxstat(%d,%d,%p) ",
1314 current
->comm
, current
->pid
, version
, fd
, statbuf
);
1317 error
= vfs_fstat(fd
, &stat
);
1321 error
= irix_xstat32_xlate(&stat
, statbuf
);
1324 error
= irix_xstat64_xlate(&stat
, statbuf
);
1333 asmlinkage
int irix_xmknod(int ver
, char __user
*filename
, int mode
, unsigned dev
)
1336 printk("[%s:%d] Wheee.. irix_xmknod(%d,%s,%x,%x)\n",
1337 current
->comm
, current
->pid
, ver
, filename
, mode
, dev
);
1341 /* shouldn't we convert here as well as on stat()? */
1342 retval
= sys_mknod(filename
, mode
, dev
);
1353 asmlinkage
int irix_swapctl(int cmd
, char __user
*arg
)
1355 printk("[%s:%d] Wheee.. irix_swapctl(%d,%p)\n",
1356 current
->comm
, current
->pid
, cmd
, arg
);
1361 struct irix_statvfs
{
1362 u32 f_bsize
; u32 f_frsize
; u32 f_blocks
;
1363 u32 f_bfree
; u32 f_bavail
; u32 f_files
; u32 f_ffree
; u32 f_favail
;
1364 u32 f_fsid
; char f_basetype
[16];
1365 u32 f_flag
; u32 f_namemax
;
1366 char f_fstr
[32]; u32 f_filler
[16];
1369 asmlinkage
int irix_statvfs(char __user
*fname
, struct irix_statvfs __user
*buf
)
1371 struct nameidata nd
;
1372 struct kstatfs kbuf
;
1375 printk("[%s:%d] Wheee.. irix_statvfs(%s,%p)\n",
1376 current
->comm
, current
->pid
, fname
, buf
);
1377 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs
)))
1380 error
= user_path_walk(fname
, &nd
);
1383 error
= vfs_statfs(nd
.dentry
->d_inode
->i_sb
, &kbuf
);
1387 error
|= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1388 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1389 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1390 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1391 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1392 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1393 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1394 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1396 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1398 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1400 for (i
= 0; i
< 16; i
++)
1401 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1402 error
|= __put_user(0, &buf
->f_flag
);
1403 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1404 for (i
= 0; i
< 32; i
++)
1405 error
|= __put_user(0, &buf
->f_fstr
[i
]);
1413 asmlinkage
int irix_fstatvfs(int fd
, struct irix_statvfs __user
*buf
)
1415 struct kstatfs kbuf
;
1419 printk("[%s:%d] Wheee.. irix_fstatvfs(%d,%p)\n",
1420 current
->comm
, current
->pid
, fd
, buf
);
1422 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs
)))
1425 if (!(file
= fget(fd
))) {
1429 error
= vfs_statfs(file
->f_dentry
->d_inode
->i_sb
, &kbuf
);
1433 error
= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1434 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1435 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1436 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1437 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1438 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1439 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1440 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1442 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1444 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1446 for(i
= 0; i
< 16; i
++)
1447 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1448 error
|= __put_user(0, &buf
->f_flag
);
1449 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1450 error
|= __clear_user(&buf
->f_fstr
, sizeof(buf
->f_fstr
)) ? -EFAULT
: 0;
1458 asmlinkage
int irix_priocntl(struct pt_regs
*regs
)
1460 printk("[%s:%d] Wheee.. irix_priocntl()\n",
1461 current
->comm
, current
->pid
);
1466 asmlinkage
int irix_sigqueue(int pid
, int sig
, int code
, int val
)
1468 printk("[%s:%d] Wheee.. irix_sigqueue(%d,%d,%d,%d)\n",
1469 current
->comm
, current
->pid
, pid
, sig
, code
, val
);
1474 asmlinkage
int irix_truncate64(char __user
*name
, int pad
, int size1
, int size2
)
1482 retval
= sys_truncate(name
, size2
);
1488 asmlinkage
int irix_ftruncate64(int fd
, int pad
, int size1
, int size2
)
1496 retval
= sys_ftruncate(fd
, size2
);
1502 asmlinkage
int irix_mmap64(struct pt_regs
*regs
)
1504 int len
, prot
, flags
, fd
, off1
, off2
, error
, base
= 0;
1505 unsigned long addr
, pgoff
, *sp
;
1506 struct file
*file
= NULL
;
1509 if (regs
->regs
[2] == 1000)
1511 sp
= (unsigned long *) (regs
->regs
[29] + 16);
1512 addr
= regs
->regs
[base
+ 4];
1513 len
= regs
->regs
[base
+ 5];
1514 prot
= regs
->regs
[base
+ 6];
1516 flags
= regs
->regs
[base
+ 7];
1517 if (!access_ok(VERIFY_READ
, sp
, (4 * sizeof(unsigned long))))
1520 err
= __get_user(off1
, &sp
[1]);
1521 err
|= __get_user(off2
, &sp
[2]);
1523 if (!access_ok(VERIFY_READ
, sp
, (5 * sizeof(unsigned long))))
1525 err
= __get_user(flags
, &sp
[0]);
1526 err
|= __get_user(fd
, &sp
[1]);
1527 err
|= __get_user(off1
, &sp
[2]);
1528 err
|= __get_user(off2
, &sp
[3]);
1534 if (off1
& PAGE_MASK
)
1537 pgoff
= (off1
<< (32 - PAGE_SHIFT
)) | (off2
>> PAGE_SHIFT
);
1539 if (!(flags
& MAP_ANONYMOUS
)) {
1540 if (!(file
= fget(fd
)))
1543 /* Ok, bad taste hack follows, try to think in something else
1544 when reading this */
1545 if (flags
& IRIX_MAP_AUTOGROW
) {
1546 unsigned long old_pos
;
1547 long max_size
= off2
+ len
;
1549 if (max_size
> file
->f_dentry
->d_inode
->i_size
) {
1550 old_pos
= sys_lseek (fd
, max_size
- 1, 0);
1551 sys_write (fd
, (void __user
*) "", 1);
1552 sys_lseek (fd
, old_pos
, 0);
1557 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
1559 down_write(¤t
->mm
->mmap_sem
);
1560 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
1561 up_write(¤t
->mm
->mmap_sem
);
1569 asmlinkage
int irix_dmi(struct pt_regs
*regs
)
1571 printk("[%s:%d] Wheee.. irix_dmi()\n",
1572 current
->comm
, current
->pid
);
1577 asmlinkage
int irix_pread(int fd
, char __user
*buf
, int cnt
, int off64
,
1580 printk("[%s:%d] Wheee.. irix_pread(%d,%p,%d,%d,%d,%d)\n",
1581 current
->comm
, current
->pid
, fd
, buf
, cnt
, off64
, off1
, off2
);
1586 asmlinkage
int irix_pwrite(int fd
, char __user
*buf
, int cnt
, int off64
,
1589 printk("[%s:%d] Wheee.. irix_pwrite(%d,%p,%d,%d,%d,%d)\n",
1590 current
->comm
, current
->pid
, fd
, buf
, cnt
, off64
, off1
, off2
);
1595 asmlinkage
int irix_sgifastpath(int cmd
, unsigned long arg0
, unsigned long arg1
,
1596 unsigned long arg2
, unsigned long arg3
,
1597 unsigned long arg4
, unsigned long arg5
)
1599 printk("[%s:%d] Wheee.. irix_fastpath(%d,%08lx,%08lx,%08lx,%08lx,"
1601 current
->comm
, current
->pid
, cmd
, arg0
, arg1
, arg2
,
1607 struct irix_statvfs64
{
1608 u32 f_bsize
; u32 f_frsize
;
1609 u64 f_blocks
; u64 f_bfree
; u64 f_bavail
;
1610 u64 f_files
; u64 f_ffree
; u64 f_favail
;
1612 char f_basetype
[16];
1613 u32 f_flag
; u32 f_namemax
;
1618 asmlinkage
int irix_statvfs64(char __user
*fname
, struct irix_statvfs64 __user
*buf
)
1620 struct nameidata nd
;
1621 struct kstatfs kbuf
;
1624 printk("[%s:%d] Wheee.. irix_statvfs64(%s,%p)\n",
1625 current
->comm
, current
->pid
, fname
, buf
);
1626 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs64
))) {
1631 error
= user_path_walk(fname
, &nd
);
1634 error
= vfs_statfs(nd
.dentry
->d_inode
->i_sb
, &kbuf
);
1638 error
= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1639 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1640 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1641 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1642 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1643 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1644 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1645 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1647 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1649 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1651 for(i
= 0; i
< 16; i
++)
1652 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1653 error
|= __put_user(0, &buf
->f_flag
);
1654 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1655 for(i
= 0; i
< 32; i
++)
1656 error
|= __put_user(0, &buf
->f_fstr
[i
]);
1664 asmlinkage
int irix_fstatvfs64(int fd
, struct irix_statvfs __user
*buf
)
1666 struct kstatfs kbuf
;
1670 printk("[%s:%d] Wheee.. irix_fstatvfs64(%d,%p)\n",
1671 current
->comm
, current
->pid
, fd
, buf
);
1673 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(struct irix_statvfs
))) {
1677 if (!(file
= fget(fd
))) {
1681 error
= vfs_statfs(file
->f_dentry
->d_inode
->i_sb
, &kbuf
);
1685 error
= __put_user(kbuf
.f_bsize
, &buf
->f_bsize
);
1686 error
|= __put_user(kbuf
.f_frsize
, &buf
->f_frsize
);
1687 error
|= __put_user(kbuf
.f_blocks
, &buf
->f_blocks
);
1688 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bfree
);
1689 error
|= __put_user(kbuf
.f_bfree
, &buf
->f_bavail
); /* XXX hackety hack... */
1690 error
|= __put_user(kbuf
.f_files
, &buf
->f_files
);
1691 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_ffree
);
1692 error
|= __put_user(kbuf
.f_ffree
, &buf
->f_favail
); /* XXX hackety hack... */
1694 error
|= __put_user(kbuf
.f_fsid
.val
[1], &buf
->f_fsid
);
1696 error
|= __put_user(kbuf
.f_fsid
.val
[0], &buf
->f_fsid
);
1698 for(i
= 0; i
< 16; i
++)
1699 error
|= __put_user(0, &buf
->f_basetype
[i
]);
1700 error
|= __put_user(0, &buf
->f_flag
);
1701 error
|= __put_user(kbuf
.f_namelen
, &buf
->f_namemax
);
1702 error
|= __clear_user(buf
->f_fstr
, sizeof(buf
->f_fstr
[i
])) ? -EFAULT
: 0;
1710 asmlinkage
int irix_getmountid(char __user
*fname
, unsigned long __user
*midbuf
)
1714 printk("[%s:%d] irix_getmountid(%s, %p)\n",
1715 current
->comm
, current
->pid
, fname
, midbuf
);
1716 if (!access_ok(VERIFY_WRITE
, midbuf
, (sizeof(unsigned long) * 4)))
1720 * The idea with this system call is that when trying to determine
1721 * 'pwd' and it's a toss-up for some reason, userland can use the
1722 * fsid of the filesystem to try and make the right decision, but
1723 * we don't have this so for now. XXX
1725 err
= __put_user(0, &midbuf
[0]);
1726 err
|= __put_user(0, &midbuf
[1]);
1727 err
|= __put_user(0, &midbuf
[2]);
1728 err
|= __put_user(0, &midbuf
[3]);
1733 asmlinkage
int irix_nsproc(unsigned long entry
, unsigned long mask
,
1734 unsigned long arg
, unsigned long sp
, int slen
)
1736 printk("[%s:%d] Wheee.. irix_nsproc(%08lx,%08lx,%08lx,%08lx,%d)\n",
1737 current
->comm
, current
->pid
, entry
, mask
, arg
, sp
, slen
);
1742 #undef DEBUG_GETDENTS
1744 struct irix_dirent32
{
1747 unsigned short d_reclen
;
1751 struct irix_dirent32_callback
{
1752 struct irix_dirent32 __user
*current_dir
;
1753 struct irix_dirent32 __user
*previous
;
1758 #define NAME_OFFSET32(de) ((int) ((de)->d_name - (char *) (de)))
1759 #define ROUND_UP32(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
1761 static int irix_filldir32(void *__buf
, const char *name
,
1762 int namlen
, loff_t offset
, ino_t ino
, unsigned int d_type
)
1764 struct irix_dirent32 __user
*dirent
;
1765 struct irix_dirent32_callback
*buf
= __buf
;
1766 unsigned short reclen
= ROUND_UP32(NAME_OFFSET32(dirent
) + namlen
+ 1);
1769 #ifdef DEBUG_GETDENTS
1770 printk("\nirix_filldir32[reclen<%d>namlen<%d>count<%d>]",
1771 reclen
, namlen
, buf
->count
);
1773 buf
->error
= -EINVAL
; /* only used if we fail.. */
1774 if (reclen
> buf
->count
)
1776 dirent
= buf
->previous
;
1778 err
= __put_user(offset
, &dirent
->d_off
);
1779 dirent
= buf
->current_dir
;
1780 err
|= __put_user(dirent
, &buf
->previous
);
1781 err
|= __put_user(ino
, &dirent
->d_ino
);
1782 err
|= __put_user(reclen
, &dirent
->d_reclen
);
1783 err
|= copy_to_user((char __user
*)dirent
->d_name
, name
, namlen
) ? -EFAULT
: 0;
1784 err
|= __put_user(0, &dirent
->d_name
[namlen
]);
1785 dirent
= (struct irix_dirent32 __user
*) ((char __user
*) dirent
+ reclen
);
1787 buf
->current_dir
= dirent
;
1788 buf
->count
-= reclen
;
1793 asmlinkage
int irix_ngetdents(unsigned int fd
, void __user
* dirent
,
1794 unsigned int count
, int __user
*eob
)
1797 struct irix_dirent32 __user
*lastdirent
;
1798 struct irix_dirent32_callback buf
;
1801 #ifdef DEBUG_GETDENTS
1802 printk("[%s:%d] ngetdents(%d, %p, %d, %p) ", current
->comm
,
1803 current
->pid
, fd
, dirent
, count
, eob
);
1810 buf
.current_dir
= (struct irix_dirent32 __user
*) dirent
;
1811 buf
.previous
= NULL
;
1815 error
= vfs_readdir(file
, irix_filldir32
, &buf
);
1820 lastdirent
= buf
.previous
;
1822 put_user(file
->f_pos
, &lastdirent
->d_off
);
1823 error
= count
- buf
.count
;
1826 if (put_user(0, eob
) < 0) {
1831 #ifdef DEBUG_GETDENTS
1832 printk("eob=%d returning %d\n", *eob
, count
- buf
.count
);
1834 error
= count
- buf
.count
;
1842 struct irix_dirent64
{
1845 unsigned short d_reclen
;
1849 struct irix_dirent64_callback
{
1850 struct irix_dirent64 __user
*curr
;
1851 struct irix_dirent64 __user
*previous
;
1856 #define NAME_OFFSET64(de) ((int) ((de)->d_name - (char *) (de)))
1857 #define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
1859 static int irix_filldir64(void *__buf
, const char *name
,
1860 int namlen
, loff_t offset
, ino_t ino
, unsigned int d_type
)
1862 struct irix_dirent64 __user
*dirent
;
1863 struct irix_dirent64_callback
* buf
= __buf
;
1864 unsigned short reclen
= ROUND_UP64(NAME_OFFSET64(dirent
) + namlen
+ 1);
1867 if (!access_ok(VERIFY_WRITE
, buf
, sizeof(*buf
)))
1870 if (__put_user(-EINVAL
, &buf
->error
)) /* only used if we fail.. */
1872 if (reclen
> buf
->count
)
1874 dirent
= buf
->previous
;
1876 err
= __put_user(offset
, &dirent
->d_off
);
1878 buf
->previous
= dirent
;
1879 err
|= __put_user(ino
, &dirent
->d_ino
);
1880 err
|= __put_user(reclen
, &dirent
->d_reclen
);
1881 err
|= __copy_to_user((char __user
*)dirent
->d_name
, name
, namlen
)
1883 err
|= __put_user(0, &dirent
->d_name
[namlen
]);
1885 dirent
= (struct irix_dirent64 __user
*) ((char __user
*) dirent
+ reclen
);
1888 buf
->count
-= reclen
;
1893 asmlinkage
int irix_getdents64(int fd
, void __user
*dirent
, int cnt
)
1896 struct irix_dirent64 __user
*lastdirent
;
1897 struct irix_dirent64_callback buf
;
1900 #ifdef DEBUG_GETDENTS
1901 printk("[%s:%d] getdents64(%d, %p, %d) ", current
->comm
,
1902 current
->pid
, fd
, dirent
, cnt
);
1905 if (!(file
= fget(fd
)))
1909 if (!access_ok(VERIFY_WRITE
, dirent
, cnt
))
1913 if (cnt
< (sizeof(struct irix_dirent64
) + 255))
1916 buf
.curr
= (struct irix_dirent64 __user
*) dirent
;
1917 buf
.previous
= NULL
;
1920 error
= vfs_readdir(file
, irix_filldir64
, &buf
);
1923 lastdirent
= buf
.previous
;
1928 if (put_user(file
->f_pos
, &lastdirent
->d_off
))
1930 #ifdef DEBUG_GETDENTS
1931 printk("returning %d\n", cnt
- buf
.count
);
1933 error
= cnt
- buf
.count
;
1941 asmlinkage
int irix_ngetdents64(int fd
, void __user
*dirent
, int cnt
, int *eob
)
1944 struct irix_dirent64 __user
*lastdirent
;
1945 struct irix_dirent64_callback buf
;
1948 #ifdef DEBUG_GETDENTS
1949 printk("[%s:%d] ngetdents64(%d, %p, %d) ", current
->comm
,
1950 current
->pid
, fd
, dirent
, cnt
);
1953 if (!(file
= fget(fd
)))
1957 if (!access_ok(VERIFY_WRITE
, dirent
, cnt
) ||
1958 !access_ok(VERIFY_WRITE
, eob
, sizeof(*eob
)))
1962 if (cnt
< (sizeof(struct irix_dirent64
) + 255))
1966 buf
.curr
= (struct irix_dirent64 __user
*) dirent
;
1967 buf
.previous
= NULL
;
1970 error
= vfs_readdir(file
, irix_filldir64
, &buf
);
1973 lastdirent
= buf
.previous
;
1978 if (put_user(file
->f_pos
, &lastdirent
->d_off
))
1980 #ifdef DEBUG_GETDENTS
1981 printk("eob=%d returning %d\n", *eob
, cnt
- buf
.count
);
1983 error
= cnt
- buf
.count
;
1991 asmlinkage
int irix_uadmin(unsigned long op
, unsigned long func
, unsigned long arg
)
1998 printk("[%s:%d] irix_uadmin: Wants to reboot...\n",
1999 current
->comm
, current
->pid
);
2005 printk("[%s:%d] irix_uadmin: Wants to shutdown...\n",
2006 current
->comm
, current
->pid
);
2012 printk("[%s:%d] irix_uadmin: Wants to remount root...\n",
2013 current
->comm
, current
->pid
);
2018 /* Kill all tasks. */
2019 printk("[%s:%d] irix_uadmin: Wants to kill all tasks...\n",
2020 current
->comm
, current
->pid
);
2025 /* Set magic mushrooms... */
2026 printk("[%s:%d] irix_uadmin: Wants to set magic mushroom[%d]...\n",
2027 current
->comm
, current
->pid
, (int) func
);
2032 printk("[%s:%d] irix_uadmin: Unknown operation [%d]...\n",
2033 current
->comm
, current
->pid
, (int) op
);
2042 asmlinkage
int irix_utssys(char __user
*inbuf
, int arg
, int type
, char __user
*outbuf
)
2049 retval
= irix_uname((struct iuname __user
*)inbuf
);
2054 printk("[%s:%d] irix_utssys: Wants to do ustat()\n",
2055 current
->comm
, current
->pid
);
2061 printk("[%s:%d] irix_utssys: Wants to do fusers()\n",
2062 current
->comm
, current
->pid
);
2067 printk("[%s:%d] irix_utssys: Wants to do unknown type[%d]\n",
2068 current
->comm
, current
->pid
, (int) type
);
2079 #define IRIX_F_ALLOCSP 10
2081 asmlinkage
int irix_fcntl(int fd
, int cmd
, int arg
)
2086 printk("[%s:%d] irix_fcntl(%d, %d, %d) ", current
->comm
,
2087 current
->pid
, fd
, cmd
, arg
);
2089 if (cmd
== IRIX_F_ALLOCSP
){
2092 retval
= sys_fcntl(fd
, cmd
, arg
);
2094 printk("%d\n", retval
);
2099 asmlinkage
int irix_ulimit(int cmd
, int arg
)
2105 printk("[%s:%d] irix_ulimit: Wants to get file size limit.\n",
2106 current
->comm
, current
->pid
);
2111 printk("[%s:%d] irix_ulimit: Wants to set file size limit.\n",
2112 current
->comm
, current
->pid
);
2117 printk("[%s:%d] irix_ulimit: Wants to get brk limit.\n",
2118 current
->comm
, current
->pid
);
2124 printk("[%s:%d] irix_ulimit: Wants to get fd limit.\n",
2125 current
->comm
, current
->pid
);
2129 retval
= current
->signal
->rlim
[RLIMIT_NOFILE
].rlim_cur
;
2133 printk("[%s:%d] irix_ulimit: Wants to get txt offset.\n",
2134 current
->comm
, current
->pid
);
2139 printk("[%s:%d] irix_ulimit: Unknown command [%d].\n",
2140 current
->comm
, current
->pid
, cmd
);
2148 asmlinkage
int irix_unimp(struct pt_regs
*regs
)
2150 printk("irix_unimp [%s:%d] v0=%d v1=%d a0=%08lx a1=%08lx a2=%08lx "
2151 "a3=%08lx\n", current
->comm
, current
->pid
,
2152 (int) regs
->regs
[2], (int) regs
->regs
[3],
2153 regs
->regs
[4], regs
->regs
[5], regs
->regs
[6], regs
->regs
[7]);