b950e0684c3c05fceac72b79532b0324a8feddfa
8 static int timernotefd
;
9 static void timerproc(void*);
14 return (pid
- 1) % MAXPROC
;
23 p
= &proctab
.proc
[pidhash(tid
)];
47 for(i
=0; i
<MAXPROC
; i
++){
48 tid
= proctab
.nextpid
++;
49 p
= &proctab
.proc
[pidhash(tid
)];
61 trace("allocproc(): out of processes");
70 while(w
= p
->freewait
){
71 p
->freewait
= w
->next
;
79 memset(p
, 0, sizeof(*p
));
93 snprint(buf
, sizeof(buf
), "/proc/%d/note", p
->kpid
);
94 p
->notefd
= open(buf
, OWRITE
);
95 snprint(buf
, sizeof(buf
), "/proc/%d/args", p
->kpid
);
96 p
->argsfd
= open(buf
, ORDWR
);
107 if((pid
= procfork(timerproc
, nil
, 0)) < 0)
108 panic("initproc: unable to fork timerproc: %r");
110 snprint(buf
, sizeof(buf
), "/proc/%d/note", pid
);
111 timernotefd
= open(buf
, OWRITE
);
114 current
->cwd
= kstrdup(getwd(buf
, sizeof(buf
)));
115 current
->kcwd
= kstrdup(current
->cwd
);
116 current
->linkloop
= 0;
117 current
->starttime
= nsec();
129 snprint(buf
, sizeof(buf
), "/proc/%d/args", getpid());
130 if((fd
= open(buf
, OWRITE
)) >= 0){
131 write(fd
, s
, strlen(s
));
135 write(current
->argsfd
, s
, strlen(s
));
140 intrnote(void *, char *msg
)
142 if(strncmp(msg
, "interrupt", 9) == 0)
150 void (*func
)(void *aux
);
157 struct kprocforkargs args
;
160 memmove(&args
, arg
, sizeof(args
));
162 if((pid
= rfork(RFPROC
|RFMEM
|args
.flags
)) != 0)
177 * procfork starts a kernel process running on kstack.
178 * that process will have linux memory segments (stack, private,
179 * shared) unmapped but plan9 segments (text, bss, stack) shared.
180 * here is no Uproc associated with it! current will be set to nil so
181 * you cant call sys_????() functions in here.
182 * procfork returns the plan9 pid. (usefull for posting notes)
184 int procfork(void (*func
)(void *aux
), void *aux
, int flags
)
186 struct kprocforkargs args
;
192 return onstack(kstack
, kprocfork
, &args
);
195 static void *Intr
= (void*)~0;
197 static char Notifyme
[] = "notifyme";
198 static char Wakeme
[] = "wakeme";
199 static char Xchange
[] = "xchange";
201 static char Wakeup
[] = "wakeup";
202 static char Abort
[] = "abort";
211 if(p
->notified
|| signalspending(p
)){
239 int sleepproc(QLock
*l
, int flags
)
248 if(x
== nil
|| x
== Wakeme
){
254 if(flags
&& signalspending(p
)){
257 ret
= rendezvous(p
, Xchange
);
261 if(p
->state
!= Xchange
){
262 while((ret
= rendezvous(p
, Xchange
)) == Intr
)
276 return (ret
== Wakeup
) ? 0 : -ERESTART
;
280 wakeup(Uproc
*proc
, char *m
, int force
)
294 proc
->state
= proc
->xstate
;
297 while(rendezvous(proc
, m
) == Intr
)
301 if((m
!= Wakeup
) && (proc
->notified
== 0)){
304 if(x
== Notifyme
|| force
){
307 write(proc
->notefd
, "interrupt", 9);
316 Uwait
* addwaitq(Uwaitq
*q
)
323 p
->freewait
= w
->next
;
325 w
= kmalloc(sizeof(*w
));
342 void delwaitq(Uwait
*w
)
349 for(x
= &q
->w
; *x
; x
=&((*x
)->nextq
)){
364 w
->next
= current
->freewait
;
365 current
->freewait
= w
;
368 int requeue(Uwaitq
*q1
, Uwaitq
*q2
, int nrequeue
)
384 while((w
= q1
->w
) && (n
< nrequeue
)){
396 int wakeq(Uwaitq
*q
, int nwake
)
404 for(w
= q
->w
; w
&& n
< nwake
; w
=w
->nextq
)
405 n
+= wakeup(w
->proc
, Wakeup
, 0);
411 int sleepq(Uwaitq
*q
, QLock
*l
, int flags
)
417 ret
= sleepproc(l
, flags
);
423 static Uproc
*alarmq
;
426 procsetalarm(Uproc
*proc
, vlong t
)
431 if(proc
->alarm
&& t
>= proc
->alarm
)
433 ret
= (alarmq
== nil
) || (t
< alarmq
->alarm
);
434 for(pp
= &alarmq
; *pp
; pp
= &((*pp
)->alarmq
)){
440 for(pp
= &alarmq
; *pp
; pp
= &((*pp
)->alarmq
))
453 if(procsetalarm(current
, t
))
454 write(timernotefd
, "interrupt", 9);
459 extern void alarmtimer(Uproc
*proc
, vlong now
);
468 setprocname("timerproc()");
470 while(proctab
.alloc
> 0){
476 m
= (h
->alarm
- now
) / 1000000;
483 if(now
>= h
->timeout
){
485 wakeup(h
, Wakeup
, 0);
487 procsetalarm(h
, h
->timeout
);
492 sleep((m
+ (1000/HZ
-1))/(1000/HZ
));
501 vlong expire, now, wake, dead;
505 setprocname("timerproc()");
510 wake = now + 60000000000LL;
512 for(i=0; i<MAXPROC; i++){
513 if((p = getprocn(i)) == nil)
515 if(p->wstate & WEXITED)
521 if(read(p->argsfd, &c, 1) < 0){
523 if(err != -EINTR && err != -ERESTART){
526 exitproc(p, SIGKILL, 1);
537 wakeup(p, Wakeup, 0);
543 expire = alarmtimer(p, now, wake);
550 dead = now + 5000000000LL;
557 sleep(wake/1000000LL);
562 int sys_waitpid(int pid
, int *pexit
, int opt
)
567 trace("sys_waitpid(%d, %p, %d)", pid
, pexit
, opt
);
578 for(i
=0; i
<MAXPROC
; i
++){
579 if((p
= getprocn(i
)) == nil
)
583 if((p
->exitsignal
!= SIGCHLD
) && (opt
& (WALL
|WCLONE
))==0)
585 if(p
->ppid
!= current
->pid
)
591 if(p
->pgid
!= current
->pgid
)
598 trace("sys_waitpid(): child %d wstate %x", p
->pid
, p
->wstate
);
604 trace("sys_waitpid(): no children we can wait for");
609 trace("sys_waitpid(): no exited/stoped/cont children");
612 if((i
= sleepproc(&proctab
, 1)) < 0){
620 status
= p
->exitcode
;
621 p
->wevent
&= ~(p
->wevent
& m
);
622 if(p
->wstate
& WEXITED
){
623 trace("sys_waitpid(): found zombie %d exitcode %d", pid
, status
);
632 struct linux_rusage
{
633 struct linux_timeval ru_utime
; /* user time used */
634 struct linux_timeval ru_stime
; /* system time used */
635 long ru_maxrss
; /* maximum resident set size */
636 long ru_ixrss
; /* integral shared memory size */
637 long ru_idrss
; /* integral unshared data size */
638 long ru_isrss
; /* integral unshared stack size */
639 long ru_minflt
; /* page reclaims */
640 long ru_majflt
; /* page faults */
641 long ru_nswap
; /* swaps */
642 long ru_inblock
; /* block input operations */
643 long ru_oublock
; /* block output operations */
644 long ru_msgsnd
; /* messages sent */
645 long ru_msgrcv
; /* messages received */
646 long ru_nsignals
; /* signals received */
647 long ru_nvcsw
; /* voluntary context switches */
648 long ru_nivcsw
; /* involuntary context switches */
651 int sys_wait4(int pid
, int *pexit
, int opt
, void *prusage
)
654 struct linux_rusage
*ru
= prusage
;
656 trace("sys_wait4(%d, %p, %d, %p)", pid
, pexit
, opt
, prusage
);
658 ret
= sys_waitpid(pid
, pexit
, opt
);
660 memset(ru
, 0, sizeof(*ru
));
672 for(i
= 0; i
<MAXPROC
; i
++){
674 if(p
!= nil
&& p
->pid
== pid
)
681 killproc(Uproc
*p
, Usiginfo
*info
, int group
)
687 if((err
= sendsignal(p
, info
, group
)) <= 0)
691 if(group
&& !wantssignal(w
, sig
)){
692 for(i
=1, n
= p
->tid
+ 1; i
<MAXPROC
; i
++, n
++){
693 if((p
= getprocn(pidhash(n
))) == nil
)
697 if(!wantssignal(p
, info
->signo
))
703 wakeup(w
, Abort
, (sig
== SIGKILL
|| sig
== SIGSTOP
|| sig
== SIGALRM
));
718 * queue the exit signal into the parent process. this
719 * doesnt do the wakeup like killproc().
722 sendexitsignal(Uproc
*parent
, Uproc
*proc
, int sig
, int code
)
726 memset(&si
, 0, sizeof(si
));
727 switch(si
.signo
= sig
){
731 si
.code
= CLD_EXITED
;
734 si
.code
= CLD_STOPPED
;
737 si
.code
= CLD_CONTINUED
;
740 si
.code
= CLD_KILLED
;
743 si
.code
= CLD_DUMPED
;
746 si
.chld
.pid
= proc
->pid
;
747 si
.chld
.uid
= proc
->uid
;
748 si
.chld
.status
= code
;
750 return sendsignal(parent
, &si
, 1);
754 * wakeup all threads who are in the same thread group
755 * as p including p. must be called with proctab locked.
758 wakeupall(Uproc
*p
, char *m
, int force
)
763 for(i
=0, n
= p
->tid
; i
<MAXPROC
; i
++, n
++)
764 if(p
= getprocn(pidhash(n
)))
772 exitproc(current
, 0, 0);
783 for(i
=1, n
= current
->tid
+1; i
<MAXPROC
; i
++, n
++){
784 if((p
= getprocn(pidhash(n
))) == nil
)
786 if(p
->pid
!= current
->pid
|| p
== current
)
791 trace("zapthreads() zapping thread %p", p
);
792 p
->tracearg
= current
;
799 sleepproc(&proctab
, 0);
815 struct kexitprocargs
*args
;
818 Uproc
*parent
, *child
, **pp
;
827 trace("kexitproc: cleartidptr = %p", proc
->cleartidptr
);
828 if(okaddr(proc
->cleartidptr
, sizeof(*proc
->cleartidptr
), 1))
829 *proc
->cleartidptr
= 0;
830 sys_futex((ulong
*)proc
->cleartidptr
, 1, MAXPROC
, nil
, nil
, 0);
841 close(proc
->notefd
); proc
->notefd
= -1;
842 close(proc
->argsfd
); proc
->argsfd
= -1;
846 for(pp
= &alarmq
; *pp
; pp
= &((*pp
)->alarmq
)){
854 /* reparent children, and reap when zombies */
855 for(i
=0; i
<MAXPROC
; i
++){
856 if((child
= getprocn(i
)) == nil
)
858 if(child
->ppid
!= proc
->pid
)
861 if(child
->wstate
& WEXITED
)
865 /* if we got zapped, just free the proc and wakeup zapper */
866 if((proc
== current
) && (proc
->traceproc
== zap
) && (parent
= proc
->tracearg
)){
868 wakeup(parent
, Wakeup
, 0);
872 if(group
&& proc
== current
)
875 parent
= getproc(proc
->ppid
);
876 if((threadcount(proc
->pid
)==1) && parent
&&
877 (proc
->exitsignal
== SIGCHLD
) && !ignoressignal(parent
, SIGCHLD
)){
880 proc
->exitcode
= code
;
881 proc
->wstate
= WEXITED
;
882 proc
->wevent
= proc
->wstate
;
885 sendexitsignal(parent
, proc
, proc
->exitsignal
, code
);
886 wakeupall(parent
, Abort
, 0);
890 sendexitsignal(parent
, proc
, proc
->exitsignal
, code
);
894 if(parent
&& proc
->exitsignal
> 0)
895 sendexitsignal(parent
, proc
, proc
->exitsignal
, code
);
899 wakeupall(parent
, Abort
, 0);
910 void exitproc(Uproc
*proc
, int code
, int group
)
912 struct kexitprocargs args
;
914 trace("exitproc(%p, %d, %d)", proc
, code
, group
);
921 onstack(kstack
, kexitproc
, &args
);
936 struct kstoparg
*arg
= aux
;
938 stopproc(current
, arg
->code
, 0);
941 void stopproc(Uproc
*proc
, int code
, int group
)
943 struct kstoparg
*arg
;
947 trace("stopproc(%p, %d, %d)", proc
, code
, group
);
950 proc
->exitcode
= code
;
951 proc
->wstate
= WSTOPPED
;
952 proc
->wevent
= proc
->wstate
;
954 if((proc
== current
) && (proc
->traceproc
== stop
) && (arg
= proc
->tracearg
)){
955 proc
->traceproc
= nil
;
956 proc
->tracearg
= nil
;
957 wakeup(arg
->stopper
, Wakeup
, 0);
962 /* put all threads in the stopped state */
966 arg
= kmalloc(sizeof(*arg
));
967 arg
->stopper
= current
;
971 for(i
=1, n
= proc
->tid
+1; i
<MAXPROC
; i
++, n
++){
972 if((p
= getprocn(pidhash(n
))) == nil
)
974 if(p
->pid
!= proc
->pid
|| p
== proc
)
978 if(p
->wstate
& (WSTOPPED
| WEXITED
))
981 trace("stopproc() stopping thread %p", p
);
989 sleepproc(&proctab
, 0);
993 if(parent
= getproc(proc
->ppid
)){
994 if(group
&& !ignoressignal(parent
, SIGCHLD
))
995 sendexitsignal(parent
, proc
, SIGCHLD
, code
);
996 wakeupall(parent
, Abort
, 0);
1001 void contproc(Uproc
*proc
, int code
, int group
)
1006 trace("contproc(%p, %d, %d)", proc
, code
, group
);
1009 proc
->exitcode
= code
;
1010 proc
->wstate
= WCONTINUED
;
1011 proc
->wevent
= proc
->wstate
;
1013 for(i
=1, n
= proc
->tid
+1; i
<MAXPROC
; i
++, n
++){
1014 if((p
= getprocn(pidhash(n
))) == nil
)
1016 if(p
->pid
!= proc
->pid
|| p
== proc
)
1020 if((p
->wstate
& WSTOPPED
) == 0)
1022 if(p
->wstate
& (WCONTINUED
| WEXITED
))
1025 trace("contproc() waking thread %p", p
);
1027 p
->wstate
= WCONTINUED
;
1028 p
->wevent
= p
->wstate
;
1029 wakeup(p
, Wakeup
, 0);
1032 if(parent
= getproc(proc
->ppid
)){
1033 if(group
&& !ignoressignal(parent
, SIGCHLD
))
1034 sendexitsignal(parent
, proc
, SIGCHLD
, code
);
1035 wakeupall(parent
, Abort
, 0);
1040 int sys_exit(int code
)
1042 trace("sys_exit(%d)", code
);
1044 exitproc(current
, (code
& 0xFF)<<8, 0);
1048 int sys_exit_group(int code
)
1050 trace("sys_exit_group(%d)", code
);
1052 exitproc(current
, (code
& 0xFF)<<8, 1);
1056 struct kcloneprocargs
1066 kcloneproc(void *arg
)
1068 struct kcloneprocargs args
;
1069 struct linux_user_desc tls
;
1071 int rflags
, pid
, tid
;
1075 memmove(&args
, arg
, sizeof(args
));
1076 memmove(&ureg
, current
->ureg
, sizeof(ureg
));
1077 if(args
.flags
& CLONE_SETTLS
){
1078 if(!okaddr(args
.tlsdescr
, sizeof(tls
), 0))
1080 memmove(&tls
, args
.tlsdescr
, sizeof(tls
));
1084 if((new = allocproc()) == nil
){
1090 if(args
.flags
& CLONE_PARENT_SETTID
){
1091 if(!okaddr(args
.parenttidptr
, sizeof(*args
.parenttidptr
), 1)){
1096 *args
.parenttidptr
= tid
;
1100 if(args
.flags
& CLONE_VM
)
1104 if((pid
= rfork(rflags
)) < 0){
1109 trace("kcloneproc(): rfork failed: %r");
1116 new->exitsignal
= args
.flags
& 0xFF;
1119 new->syscall
= current
->syscall
;
1120 new->sysret
= current
->sysret
;
1124 new->root
= current
->root
? kstrdup(current
->root
) : nil
;
1125 new->cwd
= kstrdup(current
->cwd
);
1126 new->kcwd
= kstrdup(current
->kcwd
);
1127 new->starttime
= nsec();
1129 snprint(buf
, sizeof(buf
), "/proc/%d/note", pid
);
1130 new->notefd
= open(buf
, OWRITE
);
1131 snprint(buf
, sizeof(buf
), "/proc/%d/args", pid
);
1132 new->argsfd
= open(buf
, ORDWR
);
1134 if(args
.flags
& (CLONE_THREAD
| CLONE_PARENT
)){
1135 new->ppid
= current
->ppid
;
1137 new->ppid
= current
->pid
;
1140 if(args
.flags
& CLONE_THREAD
)
1141 new->pid
= current
->pid
;
1143 new->cleartidptr
= nil
;
1144 if(args
.flags
& CLONE_CHILD_CLEARTID
)
1145 new->cleartidptr
= args
.childtidptr
;
1147 new->pgid
= current
->pgid
;
1148 new->psid
= current
->psid
;
1149 new->uid
= current
->uid
;
1150 new->gid
= current
->gid
;
1152 clonetrace(new, !(args
.flags
& CLONE_THREAD
));
1153 clonesignal(new, !(args
.flags
& CLONE_SIGHAND
), !(args
.flags
& CLONE_THREAD
));
1154 clonemem(new, !(args
.flags
& CLONE_VM
));
1155 clonefile(new, !(args
.flags
& CLONE_FILES
));
1159 while(rendezvous(new, 0) == (void*)~0)
1171 /* wait for parent to copy our resources */
1172 while(rendezvous(new, 0) == (void*)~0)
1175 trace("kcloneproc(): hello world");
1177 if(args
.flags
& CLONE_SETTLS
)
1178 sys_set_thread_area(&tls
);
1180 if(args
.flags
& CLONE_CHILD_SETTID
)
1181 if(okaddr(args
.childtidptr
, sizeof(*args
.childtidptr
), 1))
1182 *args
.childtidptr
= tid
;
1184 if(args
.newstack
!= nil
)
1185 current
->ureg
->sp
= (ulong
)args
.newstack
;
1194 int sys_linux_clone(int flags
, void *newstack
, int *parenttidptr
, int *tlsdescr
, void *childtidptr
)
1196 struct kcloneprocargs a
;
1198 trace("sys_linux_clone(%x, %p, %p, %p, %p)", flags
, newstack
, parenttidptr
, childtidptr
, tlsdescr
);
1201 a
.newstack
= newstack
;
1202 a
.parenttidptr
= parenttidptr
;
1203 a
.childtidptr
= childtidptr
;
1204 a
.tlsdescr
= tlsdescr
;
1206 return onstack(kstack
, kcloneproc
, &a
);
1211 trace("sys_fork()");
1213 return sys_linux_clone(SIGCHLD
, nil
, nil
, nil
, nil
);
1218 trace("sys_vfork()");
1223 int sys_getpid(void)
1225 trace("sys_getpid()");
1227 return current
->pid
;
1230 int sys_getppid(void)
1232 trace("sys_getppid()");
1234 return current
->ppid
;
1237 int sys_gettid(void)
1239 trace("sys_gettid()");
1241 return current
->tid
;
1244 int sys_setpgid(int pid
, int pgid
)
1248 trace("sys_setpgid(%d, %d)", pid
, pgid
);
1251 pgid
= current
->pgid
;
1257 for(i
=0; i
<MAXPROC
; i
++){
1260 if((p
= getprocn(i
)) == nil
)
1270 return n
? 0 : -ESRCH
;
1273 int sys_getpgid(int pid
)
1278 trace("sys_getpgid(%d)", pid
);
1282 return current
->pgid
;
1284 for(i
=0; i
<MAXPROC
; i
++){
1287 if((p
= getprocn(i
)) == nil
)
1300 int sys_getpgrp(void)
1302 trace("sys_getpgrp()");
1304 return sys_getpgid(0);
1307 int sys_getuid(void)
1309 trace("sys_getuid()");
1311 return current
->uid
;
1314 int sys_getgid(void)
1316 trace("sys_getgid()");
1318 return current
->gid
;
1321 int sys_setuid(int uid
)
1323 trace("sys_setuid(%d)", uid
);
1329 int sys_setgid(int gid
)
1331 trace("sys_setgid(%d)", gid
);
1337 int sys_setresuid(int ruid
, int euid
, int suid
)
1339 trace("sys_setresuid(%d, %d, %d)", ruid
, euid
, suid
);
1344 int sys_setresgid(int rgid
, int egid
, int sgid
)
1346 trace("sys_setresgid(%d, %d, %d)", rgid
, egid
, sgid
);
1350 int sys_setreuid(int ruid
, int euid
)
1352 trace("sys_setreuid(%d, %d)", ruid
, euid
);
1357 int sys_setregid(int rgid
, int egid
)
1359 trace("sys_setregid(%d, %d)", rgid
, egid
);
1364 int sys_getresuid(int *ruid
, int *euid
, int *suid
)
1366 trace("sys_getresuid(%p, %p, %p)", ruid
, euid
, suid
);
1375 *ruid
= current
->uid
;
1376 *euid
= current
->uid
;
1377 *suid
= current
->uid
;
1382 int sys_getresgid(int *rgid
, int *egid
, int *sgid
)
1384 trace("sys_getresgid(%p, %p, %p)", rgid
, egid
, sgid
);
1393 *rgid
= current
->gid
;
1394 *egid
= current
->gid
;
1395 *sgid
= current
->gid
;
1400 int sys_setsid(void)
1404 trace("sys_setsid()");
1406 if(current
->pid
== current
->pgid
)
1410 for(i
=0; i
<MAXPROC
; i
++){
1413 if((p
= getprocn(i
)) == nil
)
1415 if(p
->pid
!= current
->pid
)
1417 p
->pgid
= current
->pid
;
1418 p
->psid
= current
->pid
;
1424 return current
->pgid
;
1427 int sys_getsid(int pid
)
1431 trace("sys_getsid(%d)", pid
);
1437 for(i
=0; i
<MAXPROC
; i
++){
1440 if((p
= getprocn(i
)) == nil
)
1444 if(p
->pid
!= p
->psid
)
1454 int sys_getgroups(int size
, int *groups
)
1456 trace("sys_getgroups(%d, %p)", size
, groups
);
1462 int sys_setgroups(int size
, int *groups
)
1464 trace("sys_setgroups(%d, %p)", size
, groups
);
1468 struct linux_utsname
1475 char domainname
[65];
1478 int sys_uname(void *a
)
1480 struct linux_utsname
*p
= a
;
1482 trace("sys_uname(%p)", a
);
1484 strncpy(p
->sysname
, "Linux", 65);
1485 strncpy(p
->nodename
, sysname(), 65);
1486 strncpy(p
->release
, "3.2.1", 65);
1487 strncpy(p
->version
, "linuxemu", 65);
1488 strncpy(p
->machine
, "i386", 65);
1489 strncpy(p
->domainname
, sysname(), 65);
1494 int sys_personality(ulong p
)
1496 trace("sys_personality(%lux)", p
);
1498 if(p
!= 0 && p
!= 0xffffffff)
1503 int sys_tkill(int tid
, int sig
)
1507 trace("sys_tkill(%d, %S)", tid
, sig
);
1515 if(p
= getproc(tid
)){
1518 memset(&si
, 0, sizeof(si
));
1521 si
.kill
.pid
= current
->tid
;
1522 si
.kill
.uid
= current
->uid
;
1523 err
= killproc(p
, &si
, 0);
1530 int sys_tgkill(int pid
, int tid
, int sig
)
1534 trace("sys_tgkill(%d, %d, %S)", pid
, tid
, sig
);
1542 if((p
= getproc(tid
)) && (p
->pid
== pid
)){
1545 memset(&si
, 0, sizeof(si
));
1548 si
.kill
.pid
= current
->tid
;
1549 si
.kill
.uid
= current
->uid
;
1550 err
= killproc(p
, &si
, 0);
1557 int sys_rt_sigqueueinfo(int pid
, int sig
, void *info
)
1563 trace("sys_rt_sigqueueinfo(%d, %S, %p)", pid
, sig
, info
);
1567 if(p
= getproc(pid
)){
1568 memset(&si
, 0, sizeof(si
));
1569 linux2siginfo(info
, &si
);
1572 err
= killproc(p
, &si
, 1);
1579 PIDMAPBITS1
= 8*sizeof(ulong
),
1582 int sys_kill(int pid
, int sig
)
1587 ulong pidmap
[(MAXPROC
+ PIDMAPBITS1
-1) / PIDMAPBITS1
];
1590 trace("sys_kill(%d, %S)", pid
, sig
);
1593 memset(pidmap
, 0, sizeof(pidmap
));
1595 for(i
=0; i
<MAXPROC
; i
++){
1596 if((p
= getprocn(i
)) == nil
)
1598 if(p
->wstate
& WEXITED
)
1604 if(p
->pgid
!= current
->pgid
)
1606 } else if(pid
== -1){
1609 if(p
->tid
== current
->tid
)
1611 } else if(pid
< -1) {
1619 /* make sure we send only one signal per pid */
1620 j
= pidhash(p
->pid
);
1621 m
= 1 << (j
% PIDMAPBITS1
);
1628 memset(&si
, 0, sizeof(si
));
1631 si
.kill
.pid
= current
->tid
;
1632 si
.kill
.uid
= current
->uid
;
1633 killproc(p
, &si
, 1);
1643 int sys_set_tid_address(int *tidptr
)
1645 trace("sys_set_tid_address(%p)", tidptr
);
1647 current
->cleartidptr
= tidptr
;
1648 return current
->pid
;
1651 struct linux_sched_param
1656 int sys_sched_setscheduler(int pid
, int policy
, void *param
)
1658 trace("sys_sched_setscheduler(%d, %d, %p)", pid
, policy
, param
);
1660 if(getproc(pid
) == nil
)
1665 int sys_sched_getscheduler(int pid
)
1667 trace("sys_sched_getscheduler(%d)", pid
);
1669 if(getproc(pid
) == nil
)
1674 int sys_sched_setparam(int pid
, void *param
)
1676 trace("sys_sched_setparam(%d, %p)", pid
, param
);
1678 if(getproc(pid
) == nil
)
1683 int sys_sched_getparam(int pid
, void *param
)
1685 struct linux_sched_param
*p
= param
;
1687 trace("sys_sched_getparam(%d, %p)", pid
, param
);
1689 if(getproc(pid
) == nil
)
1693 p
->sched_priority
= 0;
1698 int sys_sched_yield(void)
1700 trace("sys_sched_yield()");
1723 RLIM_INFINITY
= ~0UL,
1732 int sys_getrlimit(long resource
, void *rlim
)
1734 struct linux_rlimit
*r
= rlim
;
1736 trace("sys_getrlimit(%ld, %p)", resource
, rlim
);
1738 if(resource
>= RLIM_NLIMITS
)
1743 r
->rlim_cur
= RLIM_INFINITY
;
1744 r
->rlim_max
= RLIM_INFINITY
;
1748 r
->rlim_cur
= USTACK
;
1749 r
->rlim_max
= USTACK
;
1755 r
->rlim_cur
= MAXPROC
;
1756 r
->rlim_max
= MAXPROC
;
1759 r
->rlim_cur
= MAXFD
;
1760 r
->rlim_max
= MAXFD
;
1766 int sys_setrlimit(long resource
, void *rlim
)
1768 trace("sys_setrlimit(%ld, %p)", resource
, rlim
);
1770 if(resource
>= RLIM_NLIMITS
)