Version:
~ [ 0.6-2.3.46 ] ~
Architecture:
~ [ um ] ~
** Warning: Cannot open xref database.
1 #include "linux/types.h"
2 #include "linux/utsname.h"
3 #include "linux/utime.h"
4 #include "linux/mm.h"
5 #include "linux/unistd.h"
6 #include "linux/smp_lock.h"
7 #include "linux/file.h"
8 #include "linux/poll.h"
9 #include "linux/module.h"
10 #include "linux/msg.h"
11 #include "linux/shm.h"
12 #include "linux/spinlock.h"
13 #include "asm/segment.h"
14 #include "asm/mman.h"
15 #include "asm/uaccess.h"
16 #include "asm/ipc.h"
17 #include "kern.h"
18 #include "user_util.h"
19 #include "kern_util.h"
20
21 extern int sys_getpid(void);
22 extern int sys_getppid(void);
23 extern long sys_open(const char * filename,int flags,int mode);
24 extern int sys_getuid(void);
25 extern int sys_geteuid(void);
26 extern int sys_getgid(void);
27 extern int sys_getegid(void);
28 extern int sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
29 extern int sys_reboot(int magic, int magic_too, int flag);
30 extern int do_sigaction(int sig, const struct k_sigaction *act,
31 struct k_sigaction *oact);
32 extern unsigned long sys_brk(unsigned long brk);
33 extern int sys_time(int * tloc);
34 extern int sys_socketcall(int call, unsigned long *args);
35 extern long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
36 extern int sys_setsid(void);
37 extern int sys_sigprocmask(int how, sigset_t *set, sigset_t *oset);
38 extern int sys_newlstat(char * filename, struct stat * statbuf);
39 extern int sys_newfstat(unsigned int fd, struct stat * statbuf);
40 extern int sys_unlink(const char * pathname);
41 extern int sys_write(unsigned int fd,char * buf,unsigned int count);
42 extern int sys_gettimeofday(struct timeval *tv, struct timezone *tz);
43 extern int sys_read(unsigned int fd, char * buf, int count);
44 extern int sys_access(const char * filename, int mode);
45 extern int sys_munmap(unsigned long addr, size_t len);
46 extern int do_fork(unsigned long clone_flags, unsigned long usp,
47 struct pt_regs *regs);
48 extern int sys_wait4(pid_t pid,unsigned int * stat_addr, int options,
49 struct rusage * ru);
50 extern int sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp);
51 extern int sys_dup(unsigned int fildes);
52 extern int sys_exit(int error_code);
53 extern int sys_execve(char *file, char **argv, char **env);
54 extern long sys_lseek(unsigned int fd, off_t offset, unsigned int origin);
55 extern int sys_dup2(unsigned int oldfd, unsigned int newfd);
56 extern int sys_select(int n, fd_set *inp, fd_set *outp, fd_set *exp,
57 struct timeval *tvp);
58 extern int sys_mprotect(unsigned long start, size_t len, unsigned long prot);
59 extern int sys_newuname(struct new_utsname * name);
60 extern int sys_getppid(void);
61 extern int sys_newstat(char * filename, struct stat * statbuf);
62 extern int sys_getpgrp(void);
63 extern int sys_sethostname(char *name, int len);
64 extern int sys_getrusage(int who, struct rusage *ru);
65 extern int sys_setdomainname(char *name, int len);
66 extern int sys_sync(void);
67 extern int sys_llseek(unsigned int fd, unsigned long offset_high,
68 unsigned long offset_low, loff_t * result,
69 unsigned int origin);
70 extern int sys_readlink(const char * path, char * buf, int bufsiz);
71 extern int sys_mount(char * dev_name, char * dir_name, char * type,
72 unsigned long new_flags, void * data);
73 extern int sys_utime(char * filename, struct utimbuf * times);
74 extern int sys_getdents(unsigned int fd, void * dirent, unsigned int count);
75 extern int sys_ftruncate(unsigned int fd, unsigned long length);
76 extern int sys_syslog(int type, char * buf, int len);
77 extern int sys_chdir(const char * filename);
78 extern int sys_getrlimit(unsigned int resource, struct rlimit *rlim);
79 extern int sys_setrlimit(unsigned int resource, struct rlimit *rlim);
80 extern int sys_getpriority(int which, int who);
81 extern int sys_setpriority(int which, int who, int niceval);
82 extern int sys_getgroups(int gidsetsize, gid_t *grouplist);
83 extern int sys_setgroups(int gidsetsize, gid_t *grouplist);
84 extern int sys_umask(int mask);
85 extern int sys_chmod(const char * filename, mode_t mode);
86 extern int sys_chown(const char * filename, uid_t user, gid_t group);
87 extern unsigned int sys_alarm(unsigned int seconds);
88 extern int sys_flock(unsigned int fd, unsigned int cmd);
89 extern int sys_vhangup(void);
90 extern int sys_bdflush(int func, long data);
91 extern int sys_setpgid(pid_t pid, pid_t pgid);
92 extern int sys_setuid(uid_t uid);
93 extern int sys_setreuid(uid_t ruid, uid_t euid);
94 extern int sys_setregid(gid_t rgid, gid_t egid);
95 extern int sys_setgid(gid_t gid);
96 extern int sys_statfs(const char * path, struct statfs * buf);
97 extern int sys_lchown(const char * filename, uid_t user, gid_t group);
98 extern int sys_kill(int pid, int sig);
99 extern int sys_rt_sigaction(int sig, const struct sigaction *act,
100 struct sigaction *oact, size_t sigsetsize);
101 extern int sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset,
102 size_t sigsetsize);
103 extern int sys_getcwd(char *buf, unsigned long size);
104 extern int sys_poll(struct pollfd * ufds, unsigned int nfds, long timeout);
105 extern int sys_link(const char * oldname, const char * newname);
106 extern ssize_t sys_writev(unsigned long fd, const struct iovec * vector,
107 unsigned long count);
108 extern int sys_fsync(unsigned int fd);
109 extern int sys_get_kernel_syms(struct kernel_sym *table);
110 extern int sys_setresuid(uid_t ruid, uid_t euid, uid_t suid);
111 extern int sys_fstatfs(unsigned int fd, struct statfs * buf);
112 extern int sys_delete_module(const char *name_user);
113 extern int sys_fchdir(unsigned int fd);
114 extern int sys_mkdir(const char * pathname, int mode);
115 extern int sys_rmdir(const char * pathname);
116 extern int sys_rename(const char * oldname, const char * newname);
117 extern int sys_mknod(const char * filename, int mode, dev_t dev);
118 extern int sys_umount(char * name, int flags);
119 extern int sys_fchmod(unsigned int fd, mode_t mode);
120 extern long sys_quotactl(int cmd, const char *special, int id, caddr_t addr);
121 extern int sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize);
122 extern long sys_setfsuid(uid_t uid);
123 extern long sys_setfsgid(gid_t gid);
124 extern long sys_swapon(const char * specialfile, int swap_flags);
125 extern long sys_swapoff(const char * specialfile);
126 extern long sys_symlink(const char *oldname, const char *newname);
127 extern long sys_oldumount(char * name);
128 extern long sys_fchown(unsigned int fd, uid_t user, gid_t group);
129
130 static int sys_fork(void)
131 {
132 return do_fork(SIGCHLD, 0, NULL);
133 }
134
135 int sys_vfork(void)
136 {
137 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, NULL);
138 }
139
140 struct mmap_arg_struct {
141 unsigned long addr;
142 unsigned long len;
143 unsigned long prot;
144 unsigned long flags;
145 unsigned long fd;
146 unsigned long offset;
147 };
148
149 static int old_mmap(struct mmap_arg_struct *arg)
150 {
151 int error = -EFAULT;
152 struct file * file = NULL;
153 struct mmap_arg_struct a;
154
155 if (copy_from_user(&a, arg, sizeof(a)))
156 return -EFAULT;
157
158 down(¤t->mm->mmap_sem);
159 lock_kernel();
160 if (!(a.flags & MAP_ANONYMOUS)) {
161 error = -EBADF;
162 file = fget(a.fd);
163 if (!file)
164 goto out;
165 }
166 a.flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
167
168 error = do_mmap(file, a.addr, a.len, a.prot, a.flags, a.offset);
169 if (file)
170 fput(file);
171 out:
172 unlock_kernel();
173 up(¤t->mm->mmap_sem);
174 return error;
175 }
176
177 /*
178 * sys_pipe() is the normal C calling standard for creating
179 * a pipe. It's not the way unix traditionally does this, though.
180 */
181 static int sys_pipe(unsigned long * fildes)
182 {
183 int fd[2];
184 int error;
185
186 lock_kernel();
187 error = do_pipe(fd);
188 unlock_kernel();
189 if (!error) {
190 if (copy_to_user(fildes, fd, 2*sizeof(int)))
191 error = -EFAULT;
192 }
193 return error;
194 }
195
196 static int sys_pause(void)
197 {
198 current->state = TASK_INTERRUPTIBLE;
199 schedule();
200 return -ERESTARTNOHAND;
201 }
202
203 static int sys_sigaction(int sig, const struct old_sigaction *act,
204 struct old_sigaction *oact)
205 {
206 struct k_sigaction new_ka, old_ka;
207 int ret;
208
209 if (act) {
210 old_sigset_t mask;
211 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
212 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
213 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
214 return -EFAULT;
215 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
216 __get_user(mask, &act->sa_mask);
217 siginitset(&new_ka.sa.sa_mask, mask);
218 }
219
220 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
221
222 if (!ret && oact) {
223 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
224 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
225 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
226 return -EFAULT;
227 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
228 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
229 }
230
231 return ret;
232 }
233
234
235 /*
236 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
237 *
238 * This is really horribly ugly.
239 */
240 int sys_ipc (uint call, int first, int second,
241 int third, void *ptr, long fifth)
242 {
243 int version, ret;
244
245 version = call >> 16; /* hack for backward compatibility */
246 call &= 0xffff;
247
248 switch (call) {
249 case SEMOP:
250 return sys_semop (first, (struct sembuf *)ptr, second);
251 case SEMGET:
252 return sys_semget (first, second, third);
253 case SEMCTL: {
254 union semun fourth;
255 if (!ptr)
256 return -EINVAL;
257 if (get_user(fourth.__pad, (void **) ptr))
258 return -EFAULT;
259 return sys_semctl (first, second, third, fourth);
260 }
261
262 case MSGSND:
263 return sys_msgsnd (first, (struct msgbuf *) ptr,
264 second, third);
265 case MSGRCV:
266 switch (version) {
267 case 0: {
268 struct ipc_kludge tmp;
269 if (!ptr)
270 return -EINVAL;
271
272 if (copy_from_user(&tmp,
273 (struct ipc_kludge *) ptr,
274 sizeof (tmp)))
275 return -EFAULT;
276 return sys_msgrcv (first, tmp.msgp, second,
277 tmp.msgtyp, third);
278 }
279 default:
280 panic("msgrcv with version != 0");
281 return sys_msgrcv (first,
282 (struct msgbuf *) ptr,
283 second, fifth, third);
284 }
285 case MSGGET:
286 return sys_msgget ((key_t) first, second);
287 case MSGCTL:
288 return sys_msgctl (first, second, (struct msqid_ds *) ptr);
289
290 case SHMAT:
291 switch (version) {
292 default: {
293 ulong raddr;
294 ret = sys_shmat (first, (char *) ptr, second, &raddr);
295 if (ret)
296 return ret;
297 return put_user (raddr, (ulong *) third);
298 }
299 case 1: /* iBCS2 emulator entry point */
300 if (!segment_eq(get_fs(), get_ds()))
301 return -EINVAL;
302 return sys_shmat (first, (char *) ptr, second, (ulong *) third);
303 }
304 case SHMDT:
305 return sys_shmdt ((char *)ptr);
306 case SHMGET:
307 return sys_shmget (first, second, third);
308 case SHMCTL:
309 return sys_shmctl (first, second,
310 (struct shmid_ds *) ptr);
311 default:
312 return -EINVAL;
313 }
314 }
315
316 int nsyscalls = 0;
317
318 int execute_syscall(int syscall, unsigned long *args)
319 {
320 unsigned long arg1, arg2, arg3, arg4, arg5;
321 int res;
322
323 current->thread.nsyscalls++;
324 nsyscalls++;
325 if(syscall == -1)
326 panic("syscall thread activated without a system call");
327 arg1 = args[0];
328 arg2 = args[1];
329 arg3 = args[2];
330 arg4 = args[3];
331 arg5 = args[4];
332 switch(syscall){
333 case __NR_exit: /* 1 */
334 res = sys_exit(arg1);
335 break;
336 case __NR_fork: /* 2 */
337 current->thread.forking = 1;
338 res = sys_fork();
339 current->thread.forking = 0;
340 break;
341 case __NR_read: /* 3 */
342 res = sys_read(arg1, (char *) arg2, arg3);
343 break;
344 case __NR_write: /* 4 */
345 res = sys_write(arg1, (char *) arg2, arg3);
346 break;
347 case __NR_open: /* 5 */
348 res = sys_open((char *) arg1, arg2, arg3);
349 break;
350 case __NR_close: /* 6 */
351 res = sys_close(arg1);
352 break;
353 case __NR_link: /* 9 */
354 res = sys_link((const char *) arg1, (const char *) arg2);
355 break;
356 case __NR_unlink: /* 10 */
357 res = sys_unlink((char *)arg1);
358 break;
359 case __NR_execve: /* 11 */
360 res = sys_execve((char *) arg1, (char **) arg2, (char **) arg3);
361 printk("exec of \"%s\" returned %d\n", (char *) arg1, res);
362 break;
363 case __NR_chdir: /* 12 */
364 res = sys_chdir((char *) arg1);
365 break;
366 case __NR_time: /* 13 */
367 res = sys_time((int *) arg1);
368 break;
369 case __NR_mknod:
370 res = sys_mknod((const char *) arg1, arg2, arg3);
371 break;
372 case __NR_chmod: /* 15 */
373 res = sys_chmod((const char *) arg1, arg2);
374 break;
375 case __NR_lchown: /* 16 */
376 res = sys_lchown((const char *) arg1, arg2, arg3);
377 break;
378 case __NR_lseek: /* 19 */
379 res = sys_lseek(arg1, arg2, arg3);
380 break;
381 case __NR_getpid: /* 20 */
382 res = sys_getpid();
383 break;
384 case __NR_mount: /* 21 */
385 res = sys_mount((char *) arg1, (char *) arg2, (char *) arg3, arg4,
386 (void *) arg5);
387 break;
388 case __NR_umount: /* 22 */
389 res = sys_oldumount((char *) arg1);
390 break;
391 case __NR_setuid: /* 23 */
392 res = sys_setuid(arg1);
393 break;
394 case __NR_getuid: /* 24 */
395 res = sys_getuid();
396 break;
397 case __NR_alarm: /* 27 */
398 res = sys_alarm(arg1);
399 break;
400 case __NR_pause: /* 29 */
401 res = sys_pause();
402 break;
403 case __NR_utime: /* 30 */
404 res = sys_utime((char *) arg1, (struct utimbuf *) arg2);
405 break;
406 case __NR_access: /* 33 */
407 res = sys_access((char *) arg1, arg2);
408 break;
409 case __NR_sync: /* 36 */
410 res = sys_sync();
411 break;
412 case __NR_kill: /* 37 */
413 res = sys_kill(arg1, arg2);
414 break;
415 case __NR_rename: /* 38 */
416 res = sys_rename((const char *) arg1, (const char *) arg2);
417 break;
418 case __NR_mkdir: /* 39 */
419 res = sys_mkdir((const char *) arg1, arg2);
420 break;
421 case __NR_rmdir: /* 40 */
422 res = sys_rmdir((const char *) arg1);
423 break;
424 case __NR_dup: /* 41 */
425 res = sys_dup(arg1);
426 break;
427 case __NR_pipe: /* 42 */
428 res = sys_pipe((unsigned long *) arg1);
429 break;
430 case __NR_brk: /* 45 */
431 res = sys_brk(arg1);
432 break;
433 case __NR_setgid: /* 46 */
434 res = sys_setgid(arg1);
435 break;
436 case __NR_getgid: /* 47 */
437 res = sys_getgid();
438 break;
439 case __NR_geteuid: /* 49 */
440 res = sys_geteuid();
441 break;
442 case __NR_getegid: /* 50 */
443 res = sys_getegid();
444 break;
445 case __NR_umount2: /* 52 */
446 res = sys_umount((char *) arg1, arg2);
447 break;
448 case __NR_ioctl: /* 54 */
449 res = sys_ioctl(arg1, arg2, arg3);
450 break;
451 case __NR_fcntl: /* 55 */
452 res = sys_fcntl(arg1, arg2, arg3);
453 break;
454 case __NR_setpgid: /* 57 */
455 res = sys_setpgid(arg1, arg2);
456 break;
457 case __NR_umask: /* 60 */
458 res = sys_umask(arg1);
459 break;
460 case __NR_dup2: /* 63 */
461 res = sys_dup2(arg1, arg2);
462 break;
463 case __NR_getppid: /* 64 */
464 res = sys_getppid();
465 break;
466 case __NR_getpgrp: /* 65 */
467 res = sys_getpgrp();
468 break;
469 case __NR_setsid: /* 66 */
470 res = sys_setsid();
471 break;
472 case __NR_sigaction: /* 67 */
473 res = sys_sigaction(arg1, (struct old_sigaction *) arg2,
474 (struct old_sigaction *) arg3);
475 break;
476 case __NR_setreuid: /* 70 */
477 res = sys_setreuid(arg1, arg2);
478 break;
479 case __NR_setregid: /* 71 */
480 res = sys_setregid(arg1, arg2);
481 break;
482 case __NR_sethostname: /* 74 */
483 res = sys_sethostname((char *) arg1, arg2);
484 break;
485 case __NR_getrlimit: /* 75 */
486 res = sys_getrlimit(arg1, (struct rlimit *) arg2);
487 break;
488 case __NR_setrlimit: /* 76 */
489 res = sys_setrlimit(arg1, (struct rlimit *) arg2);
490 break;
491 case __NR_getrusage: /* 77 */
492 res = sys_getrusage(arg1, (struct rusage *) arg2);
493 break;
494 case __NR_gettimeofday: /* 78 */
495 res = sys_gettimeofday((struct timeval *) arg1, (struct timezone *) arg2);
496 break;
497 case __NR_getgroups: /* 80 */
498 res = sys_getgroups(arg1, (gid_t *) arg2);
499 break;
500 case __NR_setgroups: /* 81 */
501 res = sys_setgroups(arg1, (gid_t *) arg2);
502 break;
503 case __NR_symlink: /* 83 */
504 res = sys_symlink((const char *) arg1, (const char *) arg2);
505 break;
506 case __NR_readlink: /* 85 */
507 res = sys_readlink((const char *) arg1, (char *) arg2, arg3);
508 break;
509 case __NR_swapon: /* 87 */
510 res = sys_swapon((const char *) arg1, arg2);
511 break;
512 case __NR_reboot: /* 88 */
513 res = sys_reboot(arg1, arg2, arg3);
514 break;
515 case __NR_mmap: /* 90 */
516 res = old_mmap((struct mmap_arg_struct *) arg1);
517 break;
518 case __NR_munmap: /* 91 */
519 res = sys_munmap(arg1, arg2);
520 break;
521 case __NR_ftruncate: /* 93 */
522 res = sys_ftruncate(arg1, arg2);
523 break;
524 case __NR_fchmod: /* 94 */
525 res = sys_fchmod(arg1, arg2);
526 break;
527 case __NR_fchown:
528 res = sys_fchown(arg1, arg2, arg3);
529 break;
530 case __NR_getpriority: /* 96 */
531 res = sys_getpriority(arg1, arg2);
532 break;
533 case __NR_setpriority: /* 97 */
534 res = sys_setpriority(arg1, arg2, arg3);
535 break;
536 case __NR_statfs: /* 99 */
537 res = sys_statfs((const char *) arg1, (struct statfs *) arg2);
538 break;
539 case __NR_fstatfs: /* 100 */
540 res = sys_fstatfs(arg1, (struct statfs *) arg2);
541 break;
542 case __NR_ioperm: /* 101 */
543 /* User-mode has no io ports */
544 res = 0;
545 break;
546 case __NR_socketcall: /* 102 */
547 res = sys_socketcall(arg1, (unsigned long *) arg2);
548 break;
549 case __NR_syslog: /* 103 */
550 res = sys_syslog(arg1, (char *) arg2, arg3);
551 break;
552 case __NR_stat: /* 106 */
553 res = sys_newstat((char *) arg1, (struct stat *) arg2);
554 break;
555 case __NR_lstat: /* 107 */
556 res = sys_newlstat((char *) arg1, (struct stat *) arg2);
557 break;
558 case __NR_fstat: /* 108 */
559 res = sys_newfstat(arg1, (struct stat *) arg2);
560 break;
561 case __NR_vhangup: /* 111 */
562 res = sys_vhangup();
563 break;
564 case __NR_wait4: /* 114 */
565 res = sys_wait4(arg1, (unsigned int *) arg2, arg3, (struct rusage *) arg4);
566 break;
567 case __NR_swapoff: /* 115 */
568 res = sys_swapoff((char *) arg1);
569 break;
570 case __NR_ipc: /* 117 */
571 res = sys_ipc(arg1, arg2, arg3, arg4, (void *) arg5, 0);
572 break;
573 case __NR_fsync: /* 118 */
574 res = sys_fsync(arg1);
575 break;
576 case __NR_setdomainname: /* 121 */
577 res = sys_setdomainname((char *)arg1, arg2);
578 break;
579 case __NR_uname: /* 122 */
580 res = sys_newuname((struct new_utsname *) arg1);
581 break;
582 case __NR_mprotect: /* 125 */
583 res = sys_mprotect(arg1, arg2, arg3);
584 break;
585 case __NR_sigprocmask: /* 126 */
586 res = sys_sigprocmask(arg1, (sigset_t *) arg2, (sigset_t *) arg3);
587 break;
588 case __NR_delete_module: /* 129 */
589 res = sys_delete_module((const char *) arg1);
590 break;
591 case __NR_get_kernel_syms: /* 130 */
592 res = sys_get_kernel_syms((struct kernel_sym *) arg1);
593 break;
594 case __NR_quotactl: /* 131 */
595 res = sys_quotactl(arg1, (const char *) arg2, arg3, (caddr_t) arg4);
596 break;
597 case __NR_fchdir: /* 133 */
598 res = sys_fchdir(arg1);
599 break;
600 case __NR_bdflush: /* 134 */
601 res = sys_bdflush(arg1, arg2);
602 break;
603 case __NR_personality: /* 136 */
604 res = sys_personality(arg1);
605 break;
606 case __NR_setfsuid: /* 138 */
607 res = sys_setfsuid(arg1);
608 break;
609 case __NR_setfsgid: /* 139 */
610 res = sys_setfsgid(arg1);
611 break;
612 case __NR__llseek: /* 140 */
613 res = sys_llseek(arg1, arg2, arg3, (loff_t *) arg4, arg5);
614 break;
615 case __NR_getdents: /* 141 */
616 res = sys_getdents(arg1, (void *) arg2, arg3);
617 break;
618 case __NR__newselect: /* 142 */
619 res = sys_select(arg1, (fd_set *) arg2, (fd_set *) arg3, (fd_set *) arg4,
620 (struct timeval *) arg5);
621 break;
622 case __NR_flock: /* 143 */
623 res = sys_flock(arg1, arg2);
624 break;
625 case __NR_writev: /* 146 */
626 res = sys_writev(arg1, (const struct iovec *) arg2, arg3);
627 break;
628 case __NR_nanosleep: /* 162 */
629 res = sys_nanosleep((struct timespec *) arg1, (struct timespec *) arg2);
630 break;
631 case __NR_setresuid: /* 164 */
632 res = sys_setresuid(arg1, arg2, arg3);
633 break;
634 case __NR_poll: /* 168 */
635 res = sys_poll((struct pollfd *) arg1, arg2, arg3);
636 break;
637 case __NR_rt_sigaction: /* 174 */
638 res = sys_rt_sigaction(arg1, (const struct sigaction *) arg2,
639 (struct sigaction *) arg3, arg4);
640 break;
641 case __NR_rt_sigprocmask: /* 175 */
642 res = sys_rt_sigprocmask(arg1, (sigset_t *) arg2, (sigset_t *) arg3,
643 arg4);
644 break;
645 case __NR_rt_sigsuspend: /* 179 */
646 res = sys_rt_sigsuspend((sigset_t *) arg1, arg2);
647 break;
648 case __NR_chown: /* 182 */
649 res = sys_chown((const char *) arg1, arg2, arg3);
650 break;
651 case __NR_getcwd: /* 183 */
652 res = sys_getcwd((char *) arg1, arg2);
653 break;
654 case __NR_vfork: /* 190 */
655 current->thread.forking = 1;
656 res = sys_vfork();
657 current->thread.forking = 0;
658 break;
659 default:
660 printk("Unimplemented syscall : %d\n", syscall);
661 res = -ENOSYS;
662 KERN_UNTESTED();
663 break;
664 }
665 return(res);
666 }
667
668 void store_syscall(void *t, int syscall, unsigned long arg1,
669 unsigned long arg2, unsigned long arg3, unsigned long arg4,
670 unsigned long arg5)
671 {
672 struct task_struct *task;
673
674 task = t;
675 task->thread.syscall.id = syscall;
676 task->thread.syscall.args[0] = arg1;
677 task->thread.syscall.args[1] = arg2;
678 task->thread.syscall.args[2] = arg3;
679 task->thread.syscall.args[3] = arg4;
680 task->thread.syscall.args[4] = arg5;
681 }
682
683 void set_syscall_result(void *t, int result, int again, int for_real)
684 {
685 struct task_struct *task;
686
687 if(t == NULL) task = current;
688 else task = t;
689 if(task->thread.syscall.have_result)
690 panic("Already have result in set_syscall_result");
691 task->thread.syscall.result = result;
692 task->thread.syscall.again = again;
693 task->thread.syscall.have_result = for_real;
694 }
695
696 int have_syscall_result(void *t, int *result_out)
697 {
698 struct task_struct *task;
699
700 task = t;
701 if(task->thread.syscall.have_result){
702 task->thread.syscall.have_result = 0;
703 *result_out = task->thread.syscall.result;
704 return(1);
705 }
706 else return(0);
707 }
708
709 int temp_syscall_result(void *t, int *again_out)
710 {
711 struct task_struct *task;
712
713 task = t;
714 if(again_out != NULL) *again_out = task->thread.syscall.again;
715 return(task->thread.syscall.result);
716 }
717
718 int current_syscall(void *t, unsigned long *args_out)
719 {
720 struct task_struct *task;
721
722 if(t == NULL) task = current;
723 else task = t;
724 args_out[0] = task->thread.syscall.args[0];
725 args_out[1] = task->thread.syscall.args[1];
726 args_out[2] = task->thread.syscall.args[2];
727 args_out[3] = task->thread.syscall.args[3];
728 args_out[4] = task->thread.syscall.args[4];
729 return(task->thread.syscall.id);
730 }
731
732 spinlock_t syscall_lock = SPIN_LOCK_UNLOCKED;
733
734 void lock_syscall(void)
735 {
736 spin_lock(&syscall_lock);
737 }
738
739 void unlock_syscall(void)
740 {
741 spin_unlock(&syscall_lock);
742 }
743
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.