2 * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
30 * Copyright (c) 1982, 1986, 1989, 1993
31 * The Regents of the University of California. All rights reserved.
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions
36 * 1. Redistributions of source code must retain the above copyright
37 * notice, this list of conditions and the following disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in the
40 * documentation and/or other materials provided with the distribution.
41 * 3. All advertising materials mentioning features or use of this software
42 * must display the following acknowledgement:
43 * This product includes software developed by the University of
44 * California, Berkeley and its contributors.
45 * 4. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61 * @(#)kern_time.c 8.4 (Berkeley) 5/26/95
64 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
65 * support for mandatory and extensible security protections. This notice
66 * is included in support of clause 2.2 (b) of the Apple Public License,
70 #include <sys/param.h>
71 #include <sys/resourcevar.h>
72 #include <sys/kernel.h>
73 #include <sys/systm.h>
74 #include <sys/proc_internal.h>
75 #include <sys/kauth.h>
76 #include <sys/vnode.h>
80 #include <sys/mount_internal.h>
81 #include <sys/sysproto.h>
82 #include <sys/signalvar.h>
83 #include <sys/protosw.h> /* for net_uptime2timeval() */
85 #include <kern/clock.h>
86 #include <kern/task.h>
87 #include <kern/thread_call.h>
89 #include <security/mac_framework.h>
91 #include <IOKit/IOBSD.h>
94 #define HZ 100 /* XXX */
96 /* simple lock used to access timezone, tz structure */
97 lck_spin_t
* tz_slock
;
98 lck_grp_t
* tz_slock_grp
;
99 lck_attr_t
* tz_slock_attr
;
100 lck_grp_attr_t
*tz_slock_grp_attr
;
102 static void setthetime(
105 void time_zone_slock_init(void);
106 static boolean_t
timeval_fixusec(struct timeval
*t1
);
109 * Time of day and interval timer support.
111 * These routines provide the kernel entry points to get and set
112 * the time-of-day and per-process interval timers. Subroutines
113 * here provide support for adding and subtracting timeval structures
114 * and decrementing interval timers, optionally reloading the interval
115 * timers when they expire.
121 struct gettimeofday_args
*uap
,
122 __unused
int32_t *retval
)
125 struct timezone ltz
; /* local copy */
130 if (uap
->tp
|| uap
->mach_absolute_time
) {
131 clock_gettimeofday_and_absolute_time(&secs
, &usecs
, &mach_time
);
135 /* Casting secs through a uint32_t to match arm64 commpage */
136 if (IS_64BIT_PROCESS(p
)) {
137 struct user64_timeval user_atv
= {};
138 user_atv
.tv_sec
= (uint32_t)secs
;
139 user_atv
.tv_usec
= usecs
;
140 error
= copyout(&user_atv
, uap
->tp
, sizeof(user_atv
));
142 struct user32_timeval user_atv
= {};
143 user_atv
.tv_sec
= (uint32_t)secs
;
144 user_atv
.tv_usec
= usecs
;
145 error
= copyout(&user_atv
, uap
->tp
, sizeof(user_atv
));
153 lck_spin_lock(tz_slock
);
155 lck_spin_unlock(tz_slock
);
157 error
= copyout((caddr_t
)<z
, CAST_USER_ADDR_T(uap
->tzp
), sizeof(tz
));
160 if (error
== 0 && uap
->mach_absolute_time
) {
161 error
= copyout(&mach_time
, uap
->mach_absolute_time
, sizeof(mach_time
));
168 * XXX Y2038 bug because of setthetime() argument
172 settimeofday(__unused
struct proc
*p
, struct settimeofday_args
*uap
, __unused
int32_t *retval
)
178 bzero(&atv
, sizeof(atv
));
180 /* Check that this task is entitled to set the time or it is root */
181 if (!IOTaskHasEntitlement(current_task(), SETTIME_ENTITLEMENT
)) {
184 error
= mac_system_check_settime(kauth_cred_get());
188 #ifndef CONFIG_EMBEDDED
189 if ((error
= suser(kauth_cred_get(), &p
->p_acflag
)))
194 /* Verify all parameters before changing time */
196 if (IS_64BIT_PROCESS(p
)) {
197 struct user64_timeval user_atv
;
198 error
= copyin(uap
->tv
, &user_atv
, sizeof(user_atv
));
199 atv
.tv_sec
= user_atv
.tv_sec
;
200 atv
.tv_usec
= user_atv
.tv_usec
;
202 struct user32_timeval user_atv
;
203 error
= copyin(uap
->tv
, &user_atv
, sizeof(user_atv
));
204 atv
.tv_sec
= user_atv
.tv_sec
;
205 atv
.tv_usec
= user_atv
.tv_usec
;
210 if (uap
->tzp
&& (error
= copyin(uap
->tzp
, (caddr_t
)&atz
, sizeof(atz
))))
213 /* only positive values of sec/usec are accepted */
214 if (atv
.tv_sec
< 0 || atv
.tv_usec
< 0)
216 if (!timeval_fixusec(&atv
))
221 lck_spin_lock(tz_slock
);
223 lck_spin_unlock(tz_slock
);
232 clock_set_calendar_microtime(tv
->tv_sec
, tv
->tv_usec
);
236 * Verify the calendar value. If negative,
237 * reset to zero (the epoch).
241 __unused
time_t base
)
247 * The calendar has already been
248 * set up from the platform clock.
250 * The value returned by microtime()
251 * is gotten from the calendar.
255 if (tv
.tv_sec
< 0 || tv
.tv_usec
< 0) {
256 printf ("WARNING: preposterous time in Real Time Clock");
257 tv
.tv_sec
= 0; /* the UNIX epoch */
260 printf(" -- CHECK AND RESET THE DATE!\n");
268 clock_nsec_t nanosecs
;
270 clock_get_boottime_nanotime(&secs
, &nanosecs
);
275 boottime_timeval(struct timeval
*tv
)
278 clock_usec_t microsecs
;
280 clock_get_boottime_microtime(&secs
, µsecs
);
283 tv
->tv_usec
= microsecs
;
287 * Get value of an interval timer. The process virtual and
288 * profiling virtual time timers are kept internally in the
289 * way they are specified externally: in time until they expire.
291 * The real time interval timer expiration time (p_rtime)
292 * is kept as an absolute time rather than as a delta, so that
293 * it is easy to keep periodic real-time signals from drifting.
295 * The real time timer is processed by a callout routine.
296 * Since a callout may be delayed in real time due to
297 * other processing in the system, it is possible for the real
298 * time callout routine (realitexpire, given below), to be delayed
299 * in real time past when it is supposed to occur. It does not
300 * suffice, therefore, to reload the real time .it_value from the
301 * real time .it_interval. Rather, we compute the next time in
302 * absolute time when the timer should go off.
305 * EINVAL Invalid argument
306 * copyout:EFAULT Bad address
310 getitimer(struct proc
*p
, struct getitimer_args
*uap
, __unused
int32_t *retval
)
312 struct itimerval aitv
;
314 if (uap
->which
> ITIMER_PROF
)
317 bzero(&aitv
, sizeof(aitv
));
320 switch (uap
->which
) {
324 * If time for real time timer has passed return 0,
325 * else return difference between current time and
326 * time for the timer to go off.
328 aitv
= p
->p_realtimer
;
329 if (timerisset(&p
->p_rtime
)) {
333 if (timercmp(&p
->p_rtime
, &now
, <))
334 timerclear(&aitv
.it_value
);
336 aitv
.it_value
= p
->p_rtime
;
337 timevalsub(&aitv
.it_value
, &now
);
341 timerclear(&aitv
.it_value
);
345 aitv
= p
->p_vtimer_user
;
349 aitv
= p
->p_vtimer_prof
;
355 if (IS_64BIT_PROCESS(p
)) {
356 struct user64_itimerval user_itv
;
357 bzero(&user_itv
, sizeof (user_itv
));
358 user_itv
.it_interval
.tv_sec
= aitv
.it_interval
.tv_sec
;
359 user_itv
.it_interval
.tv_usec
= aitv
.it_interval
.tv_usec
;
360 user_itv
.it_value
.tv_sec
= aitv
.it_value
.tv_sec
;
361 user_itv
.it_value
.tv_usec
= aitv
.it_value
.tv_usec
;
362 return (copyout((caddr_t
)&user_itv
, uap
->itv
, sizeof (user_itv
)));
364 struct user32_itimerval user_itv
;
365 bzero(&user_itv
, sizeof (user_itv
));
366 user_itv
.it_interval
.tv_sec
= aitv
.it_interval
.tv_sec
;
367 user_itv
.it_interval
.tv_usec
= aitv
.it_interval
.tv_usec
;
368 user_itv
.it_value
.tv_sec
= aitv
.it_value
.tv_sec
;
369 user_itv
.it_value
.tv_usec
= aitv
.it_value
.tv_usec
;
370 return (copyout((caddr_t
)&user_itv
, uap
->itv
, sizeof (user_itv
)));
376 * EINVAL Invalid argument
377 * copyin:EFAULT Bad address
378 * getitimer:EINVAL Invalid argument
379 * getitimer:EFAULT Bad address
383 setitimer(struct proc
*p
, struct setitimer_args
*uap
, int32_t *retval
)
385 struct itimerval aitv
;
389 bzero(&aitv
, sizeof(aitv
));
391 if (uap
->which
> ITIMER_PROF
)
393 if ((itvp
= uap
->itv
)) {
394 if (IS_64BIT_PROCESS(p
)) {
395 struct user64_itimerval user_itv
;
396 if ((error
= copyin(itvp
, (caddr_t
)&user_itv
, sizeof (user_itv
))))
398 aitv
.it_interval
.tv_sec
= user_itv
.it_interval
.tv_sec
;
399 aitv
.it_interval
.tv_usec
= user_itv
.it_interval
.tv_usec
;
400 aitv
.it_value
.tv_sec
= user_itv
.it_value
.tv_sec
;
401 aitv
.it_value
.tv_usec
= user_itv
.it_value
.tv_usec
;
403 struct user32_itimerval user_itv
;
404 if ((error
= copyin(itvp
, (caddr_t
)&user_itv
, sizeof (user_itv
))))
406 aitv
.it_interval
.tv_sec
= user_itv
.it_interval
.tv_sec
;
407 aitv
.it_interval
.tv_usec
= user_itv
.it_interval
.tv_usec
;
408 aitv
.it_value
.tv_sec
= user_itv
.it_value
.tv_sec
;
409 aitv
.it_value
.tv_usec
= user_itv
.it_value
.tv_usec
;
412 if ((uap
->itv
= uap
->oitv
) && (error
= getitimer(p
, (struct getitimer_args
*)uap
, retval
)))
416 if (itimerfix(&aitv
.it_value
) || itimerfix(&aitv
.it_interval
))
419 switch (uap
->which
) {
423 if (timerisset(&aitv
.it_value
)) {
424 microuptime(&p
->p_rtime
);
425 timevaladd(&p
->p_rtime
, &aitv
.it_value
);
426 p
->p_realtimer
= aitv
;
427 if (!thread_call_enter_delayed_with_leeway(p
->p_rcall
, NULL
,
428 tvtoabstime(&p
->p_rtime
), 0, THREAD_CALL_DELAY_USER_NORMAL
))
431 timerclear(&p
->p_rtime
);
432 p
->p_realtimer
= aitv
;
433 if (thread_call_cancel(p
->p_rcall
))
442 if (timerisset(&aitv
.it_value
))
443 task_vtimer_set(p
->task
, TASK_VTIMER_USER
);
445 task_vtimer_clear(p
->task
, TASK_VTIMER_USER
);
448 p
->p_vtimer_user
= aitv
;
453 if (timerisset(&aitv
.it_value
))
454 task_vtimer_set(p
->task
, TASK_VTIMER_PROF
);
456 task_vtimer_clear(p
->task
, TASK_VTIMER_PROF
);
459 p
->p_vtimer_prof
= aitv
;
468 * Real interval timer expired:
469 * send process whose timer expired an alarm signal.
470 * If time is not set up to reload, then just return.
471 * Else compute next time timer should go off which is > current time.
472 * This is where delay in processing this timeout causes multiple
473 * SIGALRM calls to be compressed into one.
482 r
= proc_find(p
->p_pid
);
486 assert(p
->p_ractive
> 0);
488 if (--p
->p_ractive
> 0 || r
!= p
) {
490 * bail, because either proc is exiting
491 * or there's another active thread call
500 if (!timerisset(&p
->p_realtimer
.it_interval
)) {
502 * p_realtimer was cleared while this call was pending,
503 * send one last SIGALRM, but don't re-arm
505 timerclear(&p
->p_rtime
);
516 * Send the signal before re-arming the next thread call,
517 * so in case psignal blocks, we won't create yet another thread call.
524 /* Should we still re-arm the next thread call? */
525 if (!timerisset(&p
->p_realtimer
.it_interval
)) {
526 timerclear(&p
->p_rtime
);
534 timevaladd(&p
->p_rtime
, &p
->p_realtimer
.it_interval
);
536 if (timercmp(&p
->p_rtime
, &t
, <=)) {
537 if ((p
->p_rtime
.tv_sec
+ 2) >= t
.tv_sec
) {
539 timevaladd(&p
->p_rtime
, &p
->p_realtimer
.it_interval
);
540 if (timercmp(&p
->p_rtime
, &t
, >))
544 p
->p_rtime
= p
->p_realtimer
.it_interval
;
545 timevaladd(&p
->p_rtime
, &t
);
549 assert(p
->p_rcall
!= NULL
);
551 if (!thread_call_enter_delayed_with_leeway(p
->p_rcall
, NULL
, tvtoabstime(&p
->p_rtime
), 0,
552 THREAD_CALL_DELAY_USER_NORMAL
)) {
562 * Called once in proc_exit to clean up after an armed or pending realitexpire
564 * This will only be called after the proc refcount is drained,
565 * so realitexpire cannot be currently holding a proc ref.
566 * i.e. it will/has gotten PROC_NULL from proc_find.
569 proc_free_realitimer(proc_t p
)
573 assert(p
->p_rcall
!= NULL
);
574 assert(p
->p_refcount
== 0);
576 timerclear(&p
->p_realtimer
.it_interval
);
578 if (thread_call_cancel(p
->p_rcall
)) {
579 assert(p
->p_ractive
> 0);
583 while (p
->p_ractive
> 0) {
591 thread_call_t call
= p
->p_rcall
;
596 thread_call_free(call
);
600 * Check that a proposed value to load into the .it_value or
601 * .it_interval part of an interval timer is acceptable.
608 if (tv
->tv_sec
< 0 || tv
->tv_sec
> 100000000 ||
609 tv
->tv_usec
< 0 || tv
->tv_usec
>= 1000000)
615 timespec_is_valid(const struct timespec
*ts
)
617 /* The INT32_MAX limit ensures the timespec is safe for clock_*() functions
618 * which accept 32-bit ints. */
619 if (ts
->tv_sec
< 0 || ts
->tv_sec
> INT32_MAX
||
620 ts
->tv_nsec
< 0 || (unsigned long long)ts
->tv_nsec
> NSEC_PER_SEC
) {
627 * Decrement an interval timer by a specified number
628 * of microseconds, which must be less than a second,
629 * i.e. < 1000000. If the timer expires, then reload
630 * it. In this case, carry over (usec - old value) to
631 * reduce the value reloaded into the timer so that
632 * the timer does not drift. This routine assumes
633 * that it is called in a context where the timers
634 * on which it is operating cannot change in value.
638 struct itimerval
*itp
, int usec
)
643 if (itp
->it_value
.tv_usec
< usec
) {
644 if (itp
->it_value
.tv_sec
== 0) {
645 /* expired, and already in next interval */
646 usec
-= itp
->it_value
.tv_usec
;
649 itp
->it_value
.tv_usec
+= 1000000;
650 itp
->it_value
.tv_sec
--;
652 itp
->it_value
.tv_usec
-= usec
;
654 if (timerisset(&itp
->it_value
)) {
658 /* expired, exactly at end of interval */
660 if (timerisset(&itp
->it_interval
)) {
661 itp
->it_value
= itp
->it_interval
;
662 if (itp
->it_value
.tv_sec
> 0) {
663 itp
->it_value
.tv_usec
-= usec
;
664 if (itp
->it_value
.tv_usec
< 0) {
665 itp
->it_value
.tv_usec
+= 1000000;
666 itp
->it_value
.tv_sec
--;
670 itp
->it_value
.tv_usec
= 0; /* sec is already 0 */
676 * Add and subtract routines for timevals.
677 * N.B.: subtract routine doesn't deal with
678 * results which are before the beginning,
679 * it just gets very confused in this case.
688 t1
->tv_sec
+= t2
->tv_sec
;
689 t1
->tv_usec
+= t2
->tv_usec
;
698 t1
->tv_sec
-= t2
->tv_sec
;
699 t1
->tv_usec
-= t2
->tv_usec
;
707 if (t1
->tv_usec
< 0) {
709 t1
->tv_usec
+= 1000000;
711 if (t1
->tv_usec
>= 1000000) {
713 t1
->tv_usec
-= 1000000;
721 assert(t1
->tv_usec
>= 0);
722 assert(t1
->tv_sec
>= 0);
724 if (t1
->tv_usec
>= 1000000) {
725 if (os_add_overflow(t1
->tv_sec
, t1
->tv_usec
/ 1000000, &t1
->tv_sec
))
727 t1
->tv_usec
= t1
->tv_usec
% 1000000;
734 * Return the best possible estimate of the time in the timeval
735 * to which tvp points.
742 clock_usec_t tv_usec
;
744 clock_get_calendar_microtime(&tv_sec
, &tv_usec
);
746 tvp
->tv_sec
= tv_sec
;
747 tvp
->tv_usec
= tv_usec
;
751 microtime_with_abstime(
752 struct timeval
*tvp
, uint64_t *abstime
)
755 clock_usec_t tv_usec
;
757 clock_get_calendar_absolute_and_microtime(&tv_sec
, &tv_usec
, abstime
);
759 tvp
->tv_sec
= tv_sec
;
760 tvp
->tv_usec
= tv_usec
;
768 clock_usec_t tv_usec
;
770 clock_get_system_microtime(&tv_sec
, &tv_usec
);
772 tvp
->tv_sec
= tv_sec
;
773 tvp
->tv_usec
= tv_usec
;
777 * Ditto for timespec.
781 struct timespec
*tsp
)
784 clock_nsec_t tv_nsec
;
786 clock_get_calendar_nanotime(&tv_sec
, &tv_nsec
);
788 tsp
->tv_sec
= tv_sec
;
789 tsp
->tv_nsec
= tv_nsec
;
794 struct timespec
*tsp
)
797 clock_nsec_t tv_nsec
;
799 clock_get_system_nanotime(&tv_sec
, &tv_nsec
);
801 tsp
->tv_sec
= tv_sec
;
802 tsp
->tv_nsec
= tv_nsec
;
809 uint64_t result
, usresult
;
811 clock_interval_to_absolutetime_interval(
812 tvp
->tv_sec
, NSEC_PER_SEC
, &result
);
813 clock_interval_to_absolutetime_interval(
814 tvp
->tv_usec
, NSEC_PER_USEC
, &usresult
);
816 return (result
+ usresult
);
820 tstoabstime(struct timespec
*ts
)
822 uint64_t abstime_s
, abstime_ns
;
823 clock_interval_to_absolutetime_interval(ts
->tv_sec
, NSEC_PER_SEC
, &abstime_s
);
824 clock_interval_to_absolutetime_interval(ts
->tv_nsec
, 1, &abstime_ns
);
825 return abstime_s
+ abstime_ns
;
830 * ratecheck(): simple time-based rate-limit checking.
833 ratecheck(struct timeval
*lasttime
, const struct timeval
*mininterval
)
835 struct timeval tv
, delta
;
838 net_uptime2timeval(&tv
);
840 timevalsub(&delta
, lasttime
);
843 * check for 0,0 is so that the message will be seen at least once,
844 * even if interval is huge.
846 if (timevalcmp(&delta
, mininterval
, >=) ||
847 (lasttime
->tv_sec
== 0 && lasttime
->tv_usec
== 0)) {
856 * ppsratecheck(): packets (or events) per second limitation.
859 ppsratecheck(struct timeval
*lasttime
, int *curpps
, int maxpps
)
861 struct timeval tv
, delta
;
864 net_uptime2timeval(&tv
);
866 timersub(&tv
, lasttime
, &delta
);
869 * Check for 0,0 so that the message will be seen at least once.
870 * If more than one second has passed since the last update of
871 * lasttime, reset the counter.
873 * we do increment *curpps even in *curpps < maxpps case, as some may
874 * try to use *curpps for stat purposes as well.
876 if ((lasttime
->tv_sec
== 0 && lasttime
->tv_usec
== 0) ||
881 } else if (maxpps
< 0)
883 else if (*curpps
< maxpps
)
888 #if 1 /* DIAGNOSTIC? */
889 /* be careful about wrap-around */
891 *curpps
= *curpps
+ 1;
894 * assume that there's not too many calls to this function.
895 * not sure if the assumption holds, as it depends on *caller's*
896 * behavior, not the behavior of this function.
897 * IMHO it is wrong to make assumption on the caller's behavior,
898 * so the above #if is #if 1, not #ifdef DIAGNOSTIC.
900 *curpps
= *curpps
+ 1;
905 #endif /* NETWORKING */
908 time_zone_slock_init(void)
910 /* allocate lock group attribute and group */
911 tz_slock_grp_attr
= lck_grp_attr_alloc_init();
913 tz_slock_grp
= lck_grp_alloc_init("tzlock", tz_slock_grp_attr
);
915 /* Allocate lock attribute */
916 tz_slock_attr
= lck_attr_alloc_init();
918 /* Allocate the spin lock */
919 tz_slock
= lck_spin_alloc_init(tz_slock_grp
, tz_slock_attr
);