[Glibc-bsd-commits] r4770 - trunk/kfreebsd-9/debian/patches
Petr Salinger
ps-guest at alioth.debian.org
Fri Jul 19 19:46:47 UTC 2013
Author: ps-guest
Date: 2013-07-19 19:46:47 +0000 (Fri, 19 Jul 2013)
New Revision: 4770
Added:
trunk/kfreebsd-9/debian/patches/000_cpuclockid2_compat32.diff
trunk/kfreebsd-9/debian/patches/000_cpuclockid2_syscall.diff
trunk/kfreebsd-9/debian/patches/000_cpuclockid2_zombie.diff
Log:
compat32 bits
Added: trunk/kfreebsd-9/debian/patches/000_cpuclockid2_compat32.diff
===================================================================
--- trunk/kfreebsd-9/debian/patches/000_cpuclockid2_compat32.diff (rev 0)
+++ trunk/kfreebsd-9/debian/patches/000_cpuclockid2_compat32.diff 2013-07-19 19:46:47 UTC (rev 4770)
@@ -0,0 +1,221 @@
+--- a/sys/compat/freebsd32/freebsd32_misc.c
++++ b/sys/compat/freebsd32/freebsd32_misc.c
+@@ -2332,6 +2332,20 @@ freebsd32_clock_getres(struct thread *td,
+ }
+
+ int
++freebsd32_clock_getcpuclockid2(struct thread *td,
++ struct freebsd32_clock_getcpuclockid2_args *uap)
++{
++ clockid_t clk_id;
++ int error;
++
++ error = kern_clock_getcpuclockid2(td, PAIR32TO64(id_t, uap->id),
++ uap->which, &clk_id);
++ if (error == 0)
++ error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t));
++ return (error);
++}
++
++int
+ freebsd32_thr_new(struct thread *td,
+ struct freebsd32_thr_new_args *uap)
+ {
+--- a/sys/compat/freebsd32/syscalls.master
++++ b/sys/compat/freebsd32/syscalls.master
+@@ -457,8 +457,9 @@
+ 244 AUE_NULL UNIMPL nosys
+ 245 AUE_NULL UNIMPL nosys
+ 246 AUE_NULL UNIMPL nosys
+-247 AUE_NULL NOPROTO { int clock_getcpuclockid2(id_t id,\
+- int which, clockid_t *clock_id); }
++247 AUE_NULL STD { int freebsd32_clock_getcpuclockid2(\
++ uint32_t id1, uint32_t id2,\
++ int which, clockid_t *clock_id); }
+ 248 AUE_NULL UNIMPL ntp_gettime
+ 249 AUE_NULL UNIMPL nosys
+ ; syscall numbers initially used in OpenBSD
+--- a/sys/kern/kern_time.c
++++ b/sys/kern/kern_time.c
+@@ -183,38 +183,46 @@ int
+ sys_clock_getcpuclockid2(struct thread *td, struct clock_getcpuclockid2_args *uap)
+ {
+ clockid_t clk_id;
++ int error;
++
++ error = kern_clock_getcpuclockid2(td, uap->id, uap->which, &clk_id);
++ if (error == 0)
++ error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t));
++ return (error);
++}
++
++int
++kern_clock_getcpuclockid2(struct thread *td, id_t id, int which,
++ clockid_t *clk_id)
++{
+ struct proc *p;
+ pid_t pid;
+ lwpid_t tid;
+ int error;
+
+- switch(uap->which) {
++ switch (which) {
+ case CPUCLOCK_WHICH_PID:
+- if (uap->id != 0) {
+- p = pfind(uap->id);
++ if (id != 0) {
++ p = pfind(id);
+ if (p == NULL)
+ return (ESRCH);
+ error = p_cansee(td, p);
+ PROC_UNLOCK(p);
+- if (error)
++ if (error != 0)
+ return (error);
+- pid = uap->id;
++ pid = id;
+ } else {
+ pid = td->td_proc->p_pid;
+ }
+- clk_id = MAKE_PROCESS_CPUCLOCK(pid);
+- break;
++ *clk_id = MAKE_PROCESS_CPUCLOCK(pid);
++ return (0);
+ case CPUCLOCK_WHICH_TID:
+- if (uap->id == 0)
+- tid = td->td_tid;
+- else
+- tid = uap->id;
+- clk_id = MAKE_THREAD_CPUCLOCK(tid);
+- break;
++ tid = id == 0 ? td->td_tid : id;
++ *clk_id = MAKE_THREAD_CPUCLOCK(tid);
++ return (0);
+ default:
+ return (EINVAL);
+ }
+- return (copyout(&clk_id, uap->clock_id, sizeof(clockid_t)));
+ }
+
+ #ifndef _SYS_SYSPROTO_H_
+--- a/sys/sys/syscallsubr.h
++++ b/sys/sys/syscallsubr.h
+@@ -76,6 +76,8 @@ int kern_chmod(struct thread *td, char *path, enum uio_seg pathseg,
+ int mode);
+ int kern_chown(struct thread *td, char *path, enum uio_seg pathseg, int uid,
+ int gid);
++int kern_clock_getcpuclockid2(struct thread *td, id_t id, int which,
++ clockid_t *clk_id);
+ int kern_clock_getres(struct thread *td, clockid_t clock_id,
+ struct timespec *ts);
+ int kern_clock_gettime(struct thread *td, clockid_t clock_id,
+--- a/sys/compat/freebsd32/freebsd32_proto.h
++++ b/sys/compat/freebsd32/freebsd32_proto.h
+@@ -211,6 +211,12 @@
+ char rqtp_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * rqtp; char rqtp_r_[PADR_(const struct timespec32 *)];
+ char rmtp_l_[PADL_(struct timespec32 *)]; struct timespec32 * rmtp; char rmtp_r_[PADR_(struct timespec32 *)];
+ };
++struct freebsd32_clock_getcpuclockid2_args {
++ char id1_l_[PADL_(uint32_t)]; uint32_t id1; char id1_r_[PADR_(uint32_t)];
++ char id2_l_[PADL_(uint32_t)]; uint32_t id2; char id2_r_[PADR_(uint32_t)];
++ char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)];
++ char clock_id_l_[PADL_(clockid_t *)]; clockid_t * clock_id; char clock_id_r_[PADR_(clockid_t *)];
++};
+ struct freebsd32_aio_read_args {
+ char aiocbp_l_[PADL_(struct aiocb32 *)]; struct aiocb32 * aiocbp; char aiocbp_r_[PADR_(struct aiocb32 *)];
+ };
+@@ -625,6 +631,7 @@
+ int freebsd32_clock_settime(struct thread *, struct freebsd32_clock_settime_args *);
+ int freebsd32_clock_getres(struct thread *, struct freebsd32_clock_getres_args *);
+ int freebsd32_nanosleep(struct thread *, struct freebsd32_nanosleep_args *);
++int freebsd32_clock_getcpuclockid2(struct thread *, struct freebsd32_clock_getcpuclockid2_args *);
+ int freebsd32_aio_read(struct thread *, struct freebsd32_aio_read_args *);
+ int freebsd32_aio_write(struct thread *, struct freebsd32_aio_write_args *);
+ int freebsd32_lio_listio(struct thread *, struct freebsd32_lio_listio_args *);
+@@ -1003,6 +1010,7 @@
+ #define FREEBSD32_SYS_AUE_freebsd32_clock_settime AUE_CLOCK_SETTIME
+ #define FREEBSD32_SYS_AUE_freebsd32_clock_getres AUE_NULL
+ #define FREEBSD32_SYS_AUE_freebsd32_nanosleep AUE_NULL
++#define FREEBSD32_SYS_AUE_freebsd32_clock_getcpuclockid2 AUE_NULL
+ #define FREEBSD32_SYS_AUE_freebsd32_aio_read AUE_NULL
+ #define FREEBSD32_SYS_AUE_freebsd32_aio_write AUE_NULL
+ #define FREEBSD32_SYS_AUE_freebsd32_lio_listio AUE_NULL
+--- a/sys/compat/freebsd32/freebsd32_syscall.h 2013-07-19 20:16:58.000000000 +0200
++++ b/sys/compat/freebsd32/freebsd32_syscall.h 2013-07-19 20:18:38.000000000 +0200
+@@ -207,7 +207,7 @@
+ #define FREEBSD32_SYS_freebsd32_clock_settime 233
+ #define FREEBSD32_SYS_freebsd32_clock_getres 234
+ #define FREEBSD32_SYS_freebsd32_nanosleep 240
+-#define FREEBSD32_SYS_clock_getcpuclockid2 247
++#define FREEBSD32_SYS_freebsd32_clock_getcpuclockid2 247
+ #define FREEBSD32_SYS_minherit 250
+ #define FREEBSD32_SYS_rfork 251
+ #define FREEBSD32_SYS_openbsd_poll 252
+--- a/sys/compat/freebsd32/freebsd32_syscalls.c
++++ b/sys/compat/freebsd32/freebsd32_syscalls.c
+@@ -257,7 +257,7 @@
+ "#244", /* 244 = nosys */
+ "#245", /* 245 = nosys */
+ "#246", /* 246 = nosys */
+- "clock_getcpuclockid2", /* 247 = clock_getcpuclockid2 */
++ "freebsd32_clock_getcpuclockid2", /* 247 = freebsd32_clock_getcpuclockid2 */
+ "#248", /* 248 = ntp_gettime */
+ "#249", /* 249 = nosys */
+ "minherit", /* 250 = minherit */
+--- a/sys/compat/freebsd32/freebsd32_sysent.c
++++ b/sys/compat/freebsd32/freebsd32_sysent.c
+@@ -294,7 +294,7 @@
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 244 = nosys */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 245 = nosys */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 246 = nosys */
+- { AS(clock_getcpuclockid2_args), (sy_call_t *)sys_clock_getcpuclockid2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 247 = clock_getcpuclockid2 */
++ { AS(freebsd32_clock_getcpuclockid2_args), (sy_call_t *)freebsd32_clock_getcpuclockid2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 247 = freebsd32_clock_getcpuclockid2 */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 248 = ntp_gettime */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 249 = nosys */
+ { AS(minherit_args), (sy_call_t *)sys_minherit, AUE_MINHERIT, NULL, 0, 0, 0, SY_THR_STATIC }, /* 250 = minherit */
+--- a/sys/compat/freebsd32/freebsd32_systrace_args.c
++++ b/sys/compat/freebsd32/freebsd32_systrace_args.c
+@@ -1203,13 +1203,14 @@
+ *n_args = 2;
+ break;
+ }
+- /* clock_getcpuclockid2 */
++ /* freebsd32_clock_getcpuclockid2 */
+ case 247: {
+- struct clock_getcpuclockid2_args *p = params;
+- iarg[0] = p->id; /* id_t */
+- iarg[1] = p->which; /* int */
+- uarg[2] = (intptr_t) p->clock_id; /* clockid_t * */
+- *n_args = 3;
++ struct freebsd32_clock_getcpuclockid2_args *p = params;
++ uarg[0] = p->id1; /* uint32_t */
++ uarg[1] = p->id2; /* uint32_t */
++ iarg[2] = p->which; /* int */
++ uarg[3] = (intptr_t) p->clock_id; /* clockid_t * */
++ *n_args = 4;
+ break;
+ }
+ /* minherit */
+@@ -4949,16 +4950,19 @@
+ break;
+ };
+ break;
+- /* clock_getcpuclockid2 */
++ /* freebsd32_clock_getcpuclockid2 */
+ case 247:
+ switch(ndx) {
+ case 0:
+- p = "id_t";
++ p = "uint32_t";
+ break;
+ case 1:
+- p = "int";
++ p = "uint32_t";
+ break;
+ case 2:
++ p = "int";
++ break;
++ case 3:
+ p = "clockid_t *";
+ break;
+ default:
Copied: trunk/kfreebsd-9/debian/patches/000_cpuclockid2_syscall.diff (from rev 4768, trunk/kfreebsd-9/debian/patches/000_clock_getcpuclockid2.diff)
===================================================================
--- trunk/kfreebsd-9/debian/patches/000_cpuclockid2_syscall.diff (rev 0)
+++ trunk/kfreebsd-9/debian/patches/000_cpuclockid2_syscall.diff 2013-07-19 19:46:47 UTC (rev 4770)
@@ -0,0 +1,460 @@
+backport clock_getcpuclockid2 syscall into kfreebsd-9
+#716746
+
+To properly provide CLOCK_THREAD_CPUTIME_ID, CLOCK_PROCESS_CPUTIME_ID
+and clock_id's created by clock_getcpuclockid() and
+pthread_getcpuclockid(), we need this kernel support.
+
+MFC r239347 - http://www.freebsd.org/cgi/query-pr.cgi?pr=168417
+MFC r253325 - http://www.freebsd.org/cgi/query-pr.cgi?pr=180496
+and regenerate files from syscalls.master's
+
+It still remains to solve compat32 problem by upstream,
+see http://www.freebsd.org/cgi/query-pr.cgi?pr=180652
+
+
+--- a/sys/compat/freebsd32/syscalls.master
++++ b/sys/compat/freebsd32/syscalls.master
+@@ -453,7 +453,8 @@
+ 244 AUE_NULL UNIMPL nosys
+ 245 AUE_NULL UNIMPL nosys
+ 246 AUE_NULL UNIMPL nosys
+-247 AUE_NULL UNIMPL nosys
++247 AUE_NULL NOPROTO { int clock_getcpuclockid2(id_t id,\
++ int which, clockid_t *clock_id); }
+ 248 AUE_NULL UNIMPL ntp_gettime
+ 249 AUE_NULL UNIMPL nosys
+ ; syscall numbers initially used in OpenBSD
+--- a/sys/compat/freebsd32/freebsd32_systrace_args.c
++++ b/sys/compat/freebsd32/freebsd32_systrace_args.c
+@@ -1203,6 +1203,15 @@
+ *n_args = 2;
+ break;
+ }
++ /* clock_getcpuclockid2 */
++ case 247: {
++ struct clock_getcpuclockid2_args *p = params;
++ iarg[0] = p->id; /* id_t */
++ iarg[1] = p->which; /* int */
++ uarg[2] = (intptr_t) p->clock_id; /* clockid_t * */
++ *n_args = 3;
++ break;
++ }
+ /* minherit */
+ case 250: {
+ struct minherit_args *p = params;
+@@ -4938,6 +4947,22 @@
+ break;
+ default:
+ break;
++ };
++ break;
++ /* clock_getcpuclockid2 */
++ case 247:
++ switch(ndx) {
++ case 0:
++ p = "id_t";
++ break;
++ case 1:
++ p = "int";
++ break;
++ case 2:
++ p = "clockid_t *";
++ break;
++ default:
++ break;
+ };
+ break;
+ /* minherit */
+--- a/sys/compat/freebsd32/freebsd32_syscalls.c
++++ b/sys/compat/freebsd32/freebsd32_syscalls.c
+@@ -257,7 +257,7 @@
+ "#244", /* 244 = nosys */
+ "#245", /* 245 = nosys */
+ "#246", /* 246 = nosys */
+- "#247", /* 247 = nosys */
++ "clock_getcpuclockid2", /* 247 = clock_getcpuclockid2 */
+ "#248", /* 248 = ntp_gettime */
+ "#249", /* 249 = nosys */
+ "minherit", /* 250 = minherit */
+--- a/sys/compat/freebsd32/freebsd32_syscall.h
++++ b/sys/compat/freebsd32/freebsd32_syscall.h
+@@ -207,6 +207,7 @@
+ #define FREEBSD32_SYS_freebsd32_clock_settime 233
+ #define FREEBSD32_SYS_freebsd32_clock_getres 234
+ #define FREEBSD32_SYS_freebsd32_nanosleep 240
++#define FREEBSD32_SYS_clock_getcpuclockid2 247
+ #define FREEBSD32_SYS_minherit 250
+ #define FREEBSD32_SYS_rfork 251
+ #define FREEBSD32_SYS_openbsd_poll 252
+--- a/sys/compat/freebsd32/freebsd32_sysent.c
++++ b/sys/compat/freebsd32/freebsd32_sysent.c
+@@ -294,7 +294,7 @@
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 244 = nosys */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 245 = nosys */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 246 = nosys */
+- { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 247 = nosys */
++ { AS(clock_getcpuclockid2_args), (sy_call_t *)sys_clock_getcpuclockid2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 247 = clock_getcpuclockid2 */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 248 = ntp_gettime */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 249 = nosys */
+ { AS(minherit_args), (sy_call_t *)sys_minherit, AUE_MINHERIT, NULL, 0, 0, 0, SY_THR_STATIC }, /* 250 = minherit */
+--- a/sys/sys/syscall.mk
++++ b/sys/sys/syscall.mk
+@@ -168,6 +168,7 @@
+ ktimer_gettime.o \
+ ktimer_getoverrun.o \
+ nanosleep.o \
++ clock_getcpuclockid2.o \
+ ntp_gettime.o \
+ minherit.o \
+ rfork.o \
+--- a/sys/sys/syscall.h
++++ b/sys/sys/syscall.h
+@@ -216,6 +216,7 @@
+ #define SYS_ktimer_gettime 238
+ #define SYS_ktimer_getoverrun 239
+ #define SYS_nanosleep 240
++#define SYS_clock_getcpuclockid2 247
+ #define SYS_ntp_gettime 248
+ #define SYS_minherit 250
+ #define SYS_rfork 251
+--- a/sys/sys/time.h
++++ b/sys/sys/time.h
+@@ -266,6 +266,7 @@
+ #define CLOCK_MONOTONIC_FAST 12 /* FreeBSD-specific. */
+ #define CLOCK_SECOND 13 /* FreeBSD-specific. */
+ #define CLOCK_THREAD_CPUTIME_ID 14
++#define CLOCK_PROCESS_CPUTIME_ID 15
+ #endif
+
+ #ifndef TIMER_ABSTIME
+@@ -273,6 +274,11 @@
+ #define TIMER_ABSTIME 0x1 /* absolute timer */
+ #endif
+
++#if __BSD_VISIBLE
++#define CPUCLOCK_WHICH_PID 0
++#define CPUCLOCK_WHICH_TID 1
++#endif
++
+ #ifdef _KERNEL
+
+ /*
+@@ -344,6 +350,7 @@
+
+ #if __BSD_VISIBLE
+ int adjtime(const struct timeval *, struct timeval *);
++int clock_getcpuclockid2(id_t, int, clockid_t *);
+ int futimes(int, const struct timeval *);
+ int futimesat(int, const char *, const struct timeval [2]);
+ int lutimes(const char *, const struct timeval *);
+--- a/sys/sys/sysproto.h
++++ b/sys/sys/sysproto.h
+@@ -726,6 +726,11 @@
+ char rqtp_l_[PADL_(const struct timespec *)]; const struct timespec * rqtp; char rqtp_r_[PADR_(const struct timespec *)];
+ char rmtp_l_[PADL_(struct timespec *)]; struct timespec * rmtp; char rmtp_r_[PADR_(struct timespec *)];
+ };
++struct clock_getcpuclockid2_args {
++ char id_l_[PADL_(id_t)]; id_t id; char id_r_[PADR_(id_t)];
++ char which_l_[PADL_(int)]; int which; char which_r_[PADR_(int)];
++ char clock_id_l_[PADL_(clockid_t *)]; clockid_t * clock_id; char clock_id_r_[PADR_(clockid_t *)];
++};
+ struct ntp_gettime_args {
+ char ntvp_l_[PADL_(struct ntptimeval *)]; struct ntptimeval * ntvp; char ntvp_r_[PADR_(struct ntptimeval *)];
+ };
+@@ -1894,6 +1899,7 @@
+ int sys_ktimer_gettime(struct thread *, struct ktimer_gettime_args *);
+ int sys_ktimer_getoverrun(struct thread *, struct ktimer_getoverrun_args *);
+ int sys_nanosleep(struct thread *, struct nanosleep_args *);
++int sys_clock_getcpuclockid2(struct thread *, struct clock_getcpuclockid2_args *);
+ int sys_ntp_gettime(struct thread *, struct ntp_gettime_args *);
+ int sys_minherit(struct thread *, struct minherit_args *);
+ int sys_rfork(struct thread *, struct rfork_args *);
+@@ -2581,6 +2587,7 @@
+ #define SYS_AUE_ktimer_gettime AUE_NULL
+ #define SYS_AUE_ktimer_getoverrun AUE_NULL
+ #define SYS_AUE_nanosleep AUE_NULL
++#define SYS_AUE_clock_getcpuclockid2 AUE_NULL
+ #define SYS_AUE_ntp_gettime AUE_NULL
+ #define SYS_AUE_minherit AUE_MINHERIT
+ #define SYS_AUE_rfork AUE_RFORK
+--- a/sys/sys/unistd.h
++++ b/sys/sys/unistd.h
+@@ -53,7 +53,7 @@
+ #define _POSIX_ASYNCHRONOUS_IO 0
+ #define _POSIX_CHOWN_RESTRICTED 1
+ #define _POSIX_CLOCK_SELECTION (-1)
+-#define _POSIX_CPUTIME (-1)
++#define _POSIX_CPUTIME 200112L
+ #define _POSIX_FSYNC 200112L
+ #define _POSIX_IPV6 0
+ #define _POSIX_JOB_CONTROL 1
+--- a/sys/kern/syscalls.c
++++ b/sys/kern/syscalls.c
+@@ -254,7 +254,7 @@
+ "#244", /* 244 = nosys */
+ "#245", /* 245 = nosys */
+ "#246", /* 246 = nosys */
+- "#247", /* 247 = nosys */
++ "clock_getcpuclockid2", /* 247 = clock_getcpuclockid2 */
+ "ntp_gettime", /* 248 = ntp_gettime */
+ "#249", /* 249 = nosys */
+ "minherit", /* 250 = minherit */
+--- a/sys/kern/kern_time.c
++++ b/sys/kern/kern_time.c
+@@ -58,6 +58,12 @@
+ #include <vm/vm_extern.h>
+
+ #define MAX_CLOCKS (CLOCK_MONOTONIC+1)
++#define CPUCLOCK_BIT 0x80000000
++#define CPUCLOCK_PROCESS_BIT 0x40000000
++#define CPUCLOCK_ID_MASK (~(CPUCLOCK_BIT|CPUCLOCK_PROCESS_BIT))
++#define MAKE_THREAD_CPUCLOCK(tid) (CPUCLOCK_BIT|(tid))
++#define MAKE_PROCESS_CPUCLOCK(pid) \
++ (CPUCLOCK_BIT|CPUCLOCK_PROCESS_BIT|(pid))
+
+ static struct kclock posix_clocks[MAX_CLOCKS];
+ static uma_zone_t itimer_zone = NULL;
+@@ -165,6 +171,52 @@
+ }
+
+ #ifndef _SYS_SYSPROTO_H_
++struct clock_getcpuclockid2_args {
++ id_t id;
++ int which,
++ clockid_t *clock_id;
++};
++#endif
++/* ARGSUSED */
++int
++sys_clock_getcpuclockid2(struct thread *td, struct clock_getcpuclockid2_args *uap)
++{
++ clockid_t clk_id;
++ struct proc *p;
++ pid_t pid;
++ lwpid_t tid;
++ int error;
++
++ switch(uap->which) {
++ case CPUCLOCK_WHICH_PID:
++ if (uap->id != 0) {
++ p = pfind(uap->id);
++ if (p == NULL)
++ return (ESRCH);
++ error = p_cansee(td, p);
++ PROC_UNLOCK(p);
++ if (error)
++ return (error);
++ pid = uap->id;
++ } else {
++ pid = td->td_proc->p_pid;
++ }
++ clk_id = MAKE_PROCESS_CPUCLOCK(pid);
++ break;
++ case CPUCLOCK_WHICH_TID:
++ if (uap->id == 0)
++ tid = td->td_tid;
++ else
++ tid = uap->id;
++ clk_id = MAKE_THREAD_CPUCLOCK(tid);
++ break;
++ default:
++ return (EINVAL);
++ }
++ return (copyout(&clk_id, uap->clock_id, sizeof(clockid_t)));
++}
++
++#ifndef _SYS_SYSPROTO_H_
+ struct clock_gettime_args {
+ clockid_t clock_id;
+ struct timespec *tp;
+@@ -184,12 +236,80 @@
+ return (error);
+ }
+
++static inline void
++cputick2timespec(uint64_t runtime, struct timespec *ats)
++{
++ runtime = cputick2usec(runtime);
++ ats->tv_sec = runtime / 1000000;
++ ats->tv_nsec = runtime % 1000000 * 1000;
++}
++
++static void
++get_thread_cputime(struct thread *targettd, struct timespec *ats)
++{
++ uint64_t runtime, curtime, switchtime;
++
++ if (targettd == NULL) { /* current thread */
++ critical_enter();
++ switchtime = PCPU_GET(switchtime);
++ curtime = cpu_ticks();
++ runtime = curthread->td_runtime;
++ critical_exit();
++ runtime += curtime - switchtime;
++ } else {
++ thread_lock(targettd);
++ runtime = targettd->td_runtime;
++ thread_unlock(targettd);
++ }
++ cputick2timespec(runtime, ats);
++}
++
++static void
++get_process_cputime(struct proc *targetp, struct timespec *ats)
++{
++ uint64_t runtime;
++ struct rusage ru;
++
++ PROC_SLOCK(targetp);
++ rufetch(targetp, &ru);
++ runtime = targetp->p_rux.rux_runtime;
++ PROC_SUNLOCK(targetp);
++ cputick2timespec(runtime, ats);
++}
++
++static int
++get_cputime(struct thread *td, clockid_t clock_id, struct timespec *ats)
++{
++ struct proc *p, *p2;
++ struct thread *td2;
++ lwpid_t tid;
++ pid_t pid;
++ int error;
++
++ p = td->td_proc;
++ if ((clock_id & CPUCLOCK_PROCESS_BIT) == 0) {
++ tid = clock_id & CPUCLOCK_ID_MASK;
++ td2 = tdfind(tid, p->p_pid);
++ if (td2 == NULL)
++ return (EINVAL);
++ get_thread_cputime(td2, ats);
++ PROC_UNLOCK(td2->td_proc);
++ } else {
++ pid = clock_id & CPUCLOCK_ID_MASK;
++ error = pget(pid, PGET_CANSEE, &p2);
++ if (error != 0)
++ return (EINVAL);
++ get_process_cputime(p2, ats);
++ PROC_UNLOCK(p2);
++ }
++ return (0);
++}
++
+ int
+ kern_clock_gettime(struct thread *td, clockid_t clock_id, struct timespec *ats)
+ {
+ struct timeval sys, user;
+ struct proc *p;
+- uint64_t runtime, curtime, switchtime;
+
+ p = td->td_proc;
+ switch (clock_id) {
+@@ -232,17 +352,17 @@
+ ats->tv_nsec = 0;
+ break;
+ case CLOCK_THREAD_CPUTIME_ID:
+- critical_enter();
+- switchtime = PCPU_GET(switchtime);
+- curtime = cpu_ticks();
+- runtime = td->td_runtime;
+- critical_exit();
+- runtime = cputick2usec(runtime + curtime - switchtime);
+- ats->tv_sec = runtime / 1000000;
+- ats->tv_nsec = runtime % 1000000 * 1000;
++ get_thread_cputime(NULL, ats);
++ break;
++ case CLOCK_PROCESS_CPUTIME_ID:
++ PROC_LOCK(p);
++ get_process_cputime(p, ats);
++ PROC_UNLOCK(p);
+ break;
+ default:
+- return (EINVAL);
++ if ((int)clock_id >= 0)
++ return (EINVAL);
++ return (get_cputime(td, clock_id, ats));
+ }
+ return (0);
+ }
+@@ -336,12 +456,16 @@
+ ts->tv_nsec = 0;
+ break;
+ case CLOCK_THREAD_CPUTIME_ID:
++ case CLOCK_PROCESS_CPUTIME_ID:
++ cputime:
+ /* sync with cputick2usec */
+ ts->tv_nsec = 1000000 / cpu_tickrate();
+ if (ts->tv_nsec == 0)
+ ts->tv_nsec = 1000;
+ break;
+ default:
++ if ((int)clock_id < 0)
++ goto cputime;
+ return (EINVAL);
+ }
+ return (0);
+--- a/sys/kern/init_sysent.c
++++ b/sys/kern/init_sysent.c
+@@ -281,7 +281,7 @@
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 244 = nosys */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 245 = nosys */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 246 = nosys */
+- { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 247 = nosys */
++ { AS(clock_getcpuclockid2_args), (sy_call_t *)sys_clock_getcpuclockid2, AUE_NULL, NULL, 0, 0, 0, SY_THR_STATIC }, /* 247 = clock_getcpuclockid2 */
+ { AS(ntp_gettime_args), (sy_call_t *)sys_ntp_gettime, AUE_NULL, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC }, /* 248 = ntp_gettime */
+ { 0, (sy_call_t *)nosys, AUE_NULL, NULL, 0, 0, 0, SY_THR_ABSENT }, /* 249 = nosys */
+ { AS(minherit_args), (sy_call_t *)sys_minherit, AUE_MINHERIT, NULL, 0, 0, SYF_CAPENABLED, SY_THR_STATIC }, /* 250 = minherit */
+--- a/sys/kern/syscalls.master
++++ b/sys/kern/syscalls.master
+@@ -462,7 +462,8 @@
+ 244 AUE_NULL UNIMPL nosys
+ 245 AUE_NULL UNIMPL nosys
+ 246 AUE_NULL UNIMPL nosys
+-247 AUE_NULL UNIMPL nosys
++247 AUE_NULL STD { int clock_getcpuclockid2(id_t id,\
++ int which, clockid_t *clock_id); }
+ 248 AUE_NULL STD { int ntp_gettime(struct ntptimeval *ntvp); }
+ 249 AUE_NULL UNIMPL nosys
+ ; syscall numbers initially used in OpenBSD
+--- a/sys/kern/systrace_args.c
++++ b/sys/kern/systrace_args.c
+@@ -1337,6 +1337,15 @@
+ *n_args = 2;
+ break;
+ }
++ /* clock_getcpuclockid2 */
++ case 247: {
++ struct clock_getcpuclockid2_args *p = params;
++ iarg[0] = p->id; /* id_t */
++ iarg[1] = p->which; /* int */
++ uarg[2] = (intptr_t) p->clock_id; /* clockid_t * */
++ *n_args = 3;
++ break;
++ }
+ /* ntp_gettime */
+ case 248: {
+ struct ntp_gettime_args *p = params;
+@@ -5379,6 +5388,22 @@
+ break;
+ default:
+ break;
++ };
++ break;
++ /* clock_getcpuclockid2 */
++ case 247:
++ switch(ndx) {
++ case 0:
++ p = "id_t";
++ break;
++ case 1:
++ p = "int";
++ break;
++ case 2:
++ p = "clockid_t *";
++ break;
++ default:
++ break;
+ };
+ break;
+ /* ntp_gettime */
Copied: trunk/kfreebsd-9/debian/patches/000_cpuclockid2_zombie.diff (from rev 4768, trunk/kfreebsd-9/debian/patches/000_zombie.diff)
===================================================================
--- trunk/kfreebsd-9/debian/patches/000_cpuclockid2_zombie.diff (rev 0)
+++ trunk/kfreebsd-9/debian/patches/000_cpuclockid2_zombie.diff 2013-07-19 19:46:47 UTC (rev 4770)
@@ -0,0 +1,200 @@
+apply patch from STABLE-9 branch
+enhances clock_getcpuclockid2 patch
+
+------------------------------------------------------------------------
+r243962 | kib | 2012-12-07 02:13:07 +0100 (Fri, 07 Dec 2012) | 11 lines
+
+MFC r243142:
+In pget(9), if PGET_NOTWEXIT flag is not specified, also search the
+zombie list for the pid. This allows several kern.proc sysctls to
+report useful information for zombies.
+
+Hold the allproc_lock around all searches instead of relocking it.
+Remove private pfind_locked() from the new nfs client code.
+
+MFC r243528 (by pjd):
+Look for zombie process only if we were given process id.
+
+--- a/sys/fs/nfsclient/nfs_clport.c (revision 243961)
++++ b/sys/fs/nfsclient/nfs_clport.c (revision 243962)
+@@ -1150,31 +1150,6 @@
+ }
+
+ /*
+- * Locate a process by number; return only "live" processes -- i.e., neither
+- * zombies nor newly born but incompletely initialized processes. By not
+- * returning processes in the PRS_NEW state, we allow callers to avoid
+- * testing for that condition to avoid dereferencing p_ucred, et al.
+- * Identical to pfind() in kern_proc.c, except it assume the list is
+- * already locked.
+- */
+-static struct proc *
+-pfind_locked(pid_t pid)
+-{
+- struct proc *p;
+-
+- LIST_FOREACH(p, PIDHASH(pid), p_hash)
+- if (p->p_pid == pid) {
+- PROC_LOCK(p);
+- if (p->p_state == PRS_NEW) {
+- PROC_UNLOCK(p);
+- p = NULL;
+- }
+- break;
+- }
+- return (p);
+-}
+-
+-/*
+ * Check to see if the process for this owner exists. Return 1 if it doesn't
+ * and 0 otherwise.
+ */
+
+--- a/sys/sys/proc.h (revision 243961)
++++ b/sys/sys/proc.h (revision 243962)
+@@ -835,6 +835,7 @@
+ extern struct uma_zone *proc_zone;
+
+ struct proc *pfind(pid_t); /* Find process by id. */
++struct proc *pfind_locked(pid_t pid);
+ struct pgrp *pgfind(pid_t); /* Find process group by id. */
+ struct proc *zpfind(pid_t); /* Find zombie process by id. */
+
+--- a/sys/kern/kern_proc.c (revision 243961)
++++ b/sys/kern/kern_proc.c (revision 243962)
+@@ -137,6 +137,7 @@
+ static int proc_init(void *mem, int size, int flags);
+ static void proc_fini(void *mem, int size);
+ static void pargs_free(struct pargs *pa);
++static struct proc *zpfind_locked(pid_t pid);
+
+ /*
+ * Other process lists
+@@ -284,20 +285,13 @@
+ return (1);
+ }
+
+-/*
+- * Locate a process by number; return only "live" processes -- i.e., neither
+- * zombies nor newly born but incompletely initialized processes. By not
+- * returning processes in the PRS_NEW state, we allow callers to avoid
+- * testing for that condition to avoid dereferencing p_ucred, et al.
+- */
+ struct proc *
+-pfind(pid)
+- register pid_t pid;
++pfind_locked(pid_t pid)
+ {
+- register struct proc *p;
++ struct proc *p;
+
+- sx_slock(&allproc_lock);
+- LIST_FOREACH(p, PIDHASH(pid), p_hash)
++ sx_assert(&allproc_lock, SX_LOCKED);
++ LIST_FOREACH(p, PIDHASH(pid), p_hash) {
+ if (p->p_pid == pid) {
+ PROC_LOCK(p);
+ if (p->p_state == PRS_NEW) {
+@@ -306,17 +300,34 @@
+ }
+ break;
+ }
++ }
++ return (p);
++}
++
++/*
++ * Locate a process by number; return only "live" processes -- i.e., neither
++ * zombies nor newly born but incompletely initialized processes. By not
++ * returning processes in the PRS_NEW state, we allow callers to avoid
++ * testing for that condition to avoid dereferencing p_ucred, et al.
++ */
++struct proc *
++pfind(pid_t pid)
++{
++ struct proc *p;
++
++ sx_slock(&allproc_lock);
++ p = pfind_locked(pid);
+ sx_sunlock(&allproc_lock);
+ return (p);
+ }
+
+ static struct proc *
+-pfind_tid(pid_t tid)
++pfind_tid_locked(pid_t tid)
+ {
+ struct proc *p;
+ struct thread *td;
+
+- sx_slock(&allproc_lock);
++ sx_assert(&allproc_lock, SX_LOCKED);
+ FOREACH_PROC_IN_SYSTEM(p) {
+ PROC_LOCK(p);
+ if (p->p_state == PRS_NEW) {
+@@ -330,7 +341,6 @@
+ PROC_UNLOCK(p);
+ }
+ found:
+- sx_sunlock(&allproc_lock);
+ return (p);
+ }
+
+@@ -364,12 +374,17 @@
+ struct proc *p;
+ int error;
+
+- if (pid <= PID_MAX)
+- p = pfind(pid);
+- else if ((flags & PGET_NOTID) == 0)
+- p = pfind_tid(pid);
+- else
++ sx_slock(&allproc_lock);
++ if (pid <= PID_MAX) {
++ p = pfind_locked(pid);
++ if (p == NULL && (flags & PGET_NOTWEXIT) == 0)
++ p = zpfind_locked(pid);
++ } else if ((flags & PGET_NOTID) == 0) {
++ p = pfind_tid_locked(pid);
++ } else {
+ p = NULL;
++ }
++ sx_sunlock(&allproc_lock);
+ if (p == NULL)
+ return (ESRCH);
+ if ((flags & PGET_CANSEE) != 0) {
+@@ -1046,6 +1061,21 @@
+ free(ps, M_SUBPROC);
+ }
+
++static struct proc *
++zpfind_locked(pid_t pid)
++{
++ struct proc *p;
++
++ sx_assert(&allproc_lock, SX_LOCKED);
++ LIST_FOREACH(p, &zombproc, p_list) {
++ if (p->p_pid == pid) {
++ PROC_LOCK(p);
++ break;
++ }
++ }
++ return (p);
++}
++
+ /*
+ * Locate a zombie process by number
+ */
+@@ -1055,11 +1085,7 @@
+ struct proc *p;
+
+ sx_slock(&allproc_lock);
+- LIST_FOREACH(p, &zombproc, p_list)
+- if (p->p_pid == pid) {
+- PROC_LOCK(p);
+- break;
+- }
++ p = zpfind_locked(pid);
+ sx_sunlock(&allproc_lock);
+ return (p);
+ }
More information about the Glibc-bsd-commits
mailing list