1 /*
2 * Copyright (c) 2014 The FreeBSD Foundation.
3 * Copyright (C) 2005 David Xu <[email protected]>.
4 * Copyright (c) 2003 Daniel Eischen <[email protected]>.
5 * Copyright (C) 2000 Jason Evans <[email protected]>.
6 * All rights reserved.
7 *
8 * Portions of this software were developed by Konstantin Belousov
9 * under sponsorship from the FreeBSD Foundation.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice(s), this list of conditions and the following disclaimer as
16 * the first lines of this file unmodified other than the possible
17 * addition of one or more copyright notices.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice(s), this list of conditions and the following disclaimer in
20 * the documentation and/or other materials provided with the
21 * distribution.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
24 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
31 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
32 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
33 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 */
35
36 /*-
37 * SPDX-License-Identifier: BSD-3-Clause
38 *
39 * Copyright (c) 1995-1998 John Birrell <[email protected]>
40 * All rights reserved.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in the
49 * documentation and/or other materials provided with the distribution.
50 * 3. Neither the name of the author nor the names of any co-contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 */
67
68 #include <sys/cdefs.h>
69 __FBSDID("$FreeBSD$");
70
71 #include "namespace.h"
72 #include <sys/types.h>
73 #include <sys/mman.h>
74 #include <sys/param.h>
75 #include <sys/select.h>
76 #include <sys/signalvar.h>
77 #include <sys/socket.h>
78 #include <sys/stat.h>
79 #include <sys/time.h>
80 #include <sys/uio.h>
81 #include <sys/wait.h>
82 #include <aio.h>
83 #include <dirent.h>
84 #include <errno.h>
85 #include <fcntl.h>
86 #include <poll.h>
87 #include <signal.h>
88 #include <stdarg.h>
89 #include <stdio.h>
90 #include <stdlib.h>
91 #include <string.h>
92 #include <termios.h>
93 #include <unistd.h>
94 #include <pthread.h>
95 #include "un-namespace.h"
96
97 #include "libc_private.h"
98 #include "thr_private.h"
99
100 static int
__thr_accept(int s,struct sockaddr * addr,socklen_t * addrlen)101 __thr_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
102 {
103 struct pthread *curthread;
104 int ret;
105
106 curthread = _get_curthread();
107 _thr_cancel_enter(curthread);
108 ret = __sys_accept(s, addr, addrlen);
109 _thr_cancel_leave(curthread, ret == -1);
110
111 return (ret);
112 }
113
114 /*
115 * Cancellation behavior:
116 * If thread is canceled, no socket is created.
117 */
118 static int
__thr_accept4(int s,struct sockaddr * addr,socklen_t * addrlen,int flags)119 __thr_accept4(int s, struct sockaddr *addr, socklen_t *addrlen, int flags)
120 {
121 struct pthread *curthread;
122 int ret;
123
124 curthread = _get_curthread();
125 _thr_cancel_enter(curthread);
126 ret = __sys_accept4(s, addr, addrlen, flags);
127 _thr_cancel_leave(curthread, ret == -1);
128
129 return (ret);
130 }
131
132 static int
__thr_aio_suspend(const struct aiocb * const iocbs[],int niocb,const struct timespec * timeout)133 __thr_aio_suspend(const struct aiocb * const iocbs[], int niocb, const struct
134 timespec *timeout)
135 {
136 struct pthread *curthread;
137 int ret;
138
139 curthread = _get_curthread();
140 _thr_cancel_enter(curthread);
141 ret = __sys_aio_suspend(iocbs, niocb, timeout);
142 _thr_cancel_leave(curthread, 1);
143
144 return (ret);
145 }
146
147 /*
148 * Cancellation behavior:
149 * According to manual of close(), the file descriptor is always deleted.
150 * Here, thread is only canceled after the system call, so the file
151 * descriptor is always deleted despite whether the thread is canceled
152 * or not.
153 */
154 static int
__thr_close(int fd)155 __thr_close(int fd)
156 {
157 struct pthread *curthread;
158 int ret;
159
160 curthread = _get_curthread();
161 _thr_cancel_enter2(curthread, 0);
162 ret = __sys_close(fd);
163 _thr_cancel_leave(curthread, 1);
164
165 return (ret);
166 }
167
168 /*
169 * Cancellation behavior:
170 * If the thread is canceled, connection is not made.
171 */
172 static int
__thr_connect(int fd,const struct sockaddr * name,socklen_t namelen)173 __thr_connect(int fd, const struct sockaddr *name, socklen_t namelen)
174 {
175 struct pthread *curthread;
176 int ret;
177
178 curthread = _get_curthread();
179 _thr_cancel_enter(curthread);
180 ret = __sys_connect(fd, name, namelen);
181 _thr_cancel_leave(curthread, ret == -1);
182
183 return (ret);
184 }
185
186 /*
187 * Cancellation behavior:
188 * According to specification, only F_SETLKW is a cancellation point.
189 * Thread is only canceled at start, or canceled if the system call
190 * is failure, this means the function does not generate side effect
191 * if it is canceled.
192 */
193 static int
__thr_fcntl(int fd,int cmd,...)194 __thr_fcntl(int fd, int cmd, ...)
195 {
196 struct pthread *curthread;
197 int ret;
198 va_list ap;
199
200 curthread = _get_curthread();
201 va_start(ap, cmd);
202 if (cmd == F_OSETLKW || cmd == F_SETLKW) {
203 _thr_cancel_enter(curthread);
204 ret = __sys_fcntl(fd, cmd, va_arg(ap, void *));
205 _thr_cancel_leave(curthread, ret == -1);
206 } else {
207 ret = __sys_fcntl(fd, cmd, va_arg(ap, void *));
208 }
209 va_end(ap);
210
211 return (ret);
212 }
213
214 /*
215 * Cancellation behavior:
216 * Thread may be canceled after system call.
217 */
218 static int
__thr_fsync(int fd)219 __thr_fsync(int fd)
220 {
221 struct pthread *curthread;
222 int ret;
223
224 curthread = _get_curthread();
225 _thr_cancel_enter2(curthread, 0);
226 ret = __sys_fsync(fd);
227 _thr_cancel_leave(curthread, 1);
228
229 return (ret);
230 }
231
232 static int
__thr_fdatasync(int fd)233 __thr_fdatasync(int fd)
234 {
235 struct pthread *curthread;
236 int ret;
237
238 curthread = _get_curthread();
239 _thr_cancel_enter2(curthread, 0);
240 ret = __sys_fdatasync(fd);
241 _thr_cancel_leave(curthread, 1);
242
243 return (ret);
244 }
245
246 /*
247 * Cancellation behavior:
248 * Thread may be canceled after system call.
249 */
250 static int
__thr_msync(void * addr,size_t len,int flags)251 __thr_msync(void *addr, size_t len, int flags)
252 {
253 struct pthread *curthread;
254 int ret;
255
256 curthread = _get_curthread();
257 _thr_cancel_enter2(curthread, 0);
258 ret = __sys_msync(addr, len, flags);
259 _thr_cancel_leave(curthread, 1);
260
261 return (ret);
262 }
263
264 static int
__thr_clock_nanosleep(clockid_t clock_id,int flags,const struct timespec * time_to_sleep,struct timespec * time_remaining)265 __thr_clock_nanosleep(clockid_t clock_id, int flags,
266 const struct timespec *time_to_sleep, struct timespec *time_remaining)
267 {
268 struct pthread *curthread;
269 int ret;
270
271 curthread = _get_curthread();
272 _thr_cancel_enter(curthread);
273 ret = __sys_clock_nanosleep(clock_id, flags, time_to_sleep,
274 time_remaining);
275 _thr_cancel_leave(curthread, 1);
276
277 return (ret);
278 }
279
280 static int
__thr_nanosleep(const struct timespec * time_to_sleep,struct timespec * time_remaining)281 __thr_nanosleep(const struct timespec *time_to_sleep,
282 struct timespec *time_remaining)
283 {
284 struct pthread *curthread;
285 int ret;
286
287 curthread = _get_curthread();
288 _thr_cancel_enter(curthread);
289 ret = __sys_nanosleep(time_to_sleep, time_remaining);
290 _thr_cancel_leave(curthread, 1);
291
292 return (ret);
293 }
294
295 /*
296 * Cancellation behavior:
297 * If the thread is canceled, file is not opened.
298 */
299 static int
__thr_openat(int fd,const char * path,int flags,...)300 __thr_openat(int fd, const char *path, int flags, ...)
301 {
302 struct pthread *curthread;
303 int mode, ret;
304 va_list ap;
305
306
307 /* Check if the file is being created: */
308 if ((flags & O_CREAT) != 0) {
309 /* Get the creation mode: */
310 va_start(ap, flags);
311 mode = va_arg(ap, int);
312 va_end(ap);
313 } else {
314 mode = 0;
315 }
316
317 curthread = _get_curthread();
318 _thr_cancel_enter(curthread);
319 ret = __sys_openat(fd, path, flags, mode);
320 _thr_cancel_leave(curthread, ret == -1);
321
322 return (ret);
323 }
324
325 /*
326 * Cancellation behavior:
327 * Thread may be canceled at start, but if the system call returns something,
328 * the thread is not canceled.
329 */
330 static int
__thr_poll(struct pollfd * fds,unsigned int nfds,int timeout)331 __thr_poll(struct pollfd *fds, unsigned int nfds, int timeout)
332 {
333 struct pthread *curthread;
334 int ret;
335
336 curthread = _get_curthread();
337 _thr_cancel_enter(curthread);
338 ret = __sys_poll(fds, nfds, timeout);
339 _thr_cancel_leave(curthread, ret == -1);
340
341 return (ret);
342 }
343
344 /*
345 * Cancellation behavior:
346 * Thread may be canceled at start, but if the system call returns something,
347 * the thread is not canceled.
348 */
349 static int
__thr_ppoll(struct pollfd pfd[],nfds_t nfds,const struct timespec * timeout,const sigset_t * newsigmask)350 __thr_ppoll(struct pollfd pfd[], nfds_t nfds, const struct timespec *
351 timeout, const sigset_t *newsigmask)
352 {
353 struct pthread *curthread;
354 int ret;
355
356 curthread = _get_curthread();
357 _thr_cancel_enter(curthread);
358 ret = __sys_ppoll(pfd, nfds, timeout, newsigmask);
359 _thr_cancel_leave(curthread, ret == -1);
360
361 return (ret);
362 }
363
364 /*
365 * Cancellation behavior:
366 * Thread may be canceled at start, but if the system call returns something,
367 * the thread is not canceled.
368 */
369 static int
__thr_pselect(int count,fd_set * rfds,fd_set * wfds,fd_set * efds,const struct timespec * timo,const sigset_t * mask)370 __thr_pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,
371 const struct timespec *timo, const sigset_t *mask)
372 {
373 struct pthread *curthread;
374 int ret;
375
376 curthread = _get_curthread();
377 _thr_cancel_enter(curthread);
378 ret = __sys_pselect(count, rfds, wfds, efds, timo, mask);
379 _thr_cancel_leave(curthread, ret == -1);
380
381 return (ret);
382 }
383
384 static int
__thr_kevent(int kq,const struct kevent * changelist,int nchanges,struct kevent * eventlist,int nevents,const struct timespec * timeout)385 __thr_kevent(int kq, const struct kevent *changelist, int nchanges,
386 struct kevent *eventlist, int nevents, const struct timespec *timeout)
387 {
388 struct pthread *curthread;
389 int ret;
390
391 if (nevents == 0) {
392 /*
393 * No blocking, do not make the call cancellable.
394 */
395 return (__sys_kevent(kq, changelist, nchanges, eventlist,
396 nevents, timeout));
397 }
398 curthread = _get_curthread();
399 _thr_cancel_enter(curthread);
400 ret = __sys_kevent(kq, changelist, nchanges, eventlist, nevents,
401 timeout);
402 _thr_cancel_leave(curthread, ret == -1 && nchanges == 0);
403
404 return (ret);
405 }
406
407 /*
408 * Cancellation behavior:
409 * Thread may be canceled at start, but if the system call got some data,
410 * the thread is not canceled.
411 */
412 static ssize_t
__thr_read(int fd,void * buf,size_t nbytes)413 __thr_read(int fd, void *buf, size_t nbytes)
414 {
415 struct pthread *curthread;
416 ssize_t ret;
417
418 curthread = _get_curthread();
419 _thr_cancel_enter(curthread);
420 ret = __sys_read(fd, buf, nbytes);
421 _thr_cancel_leave(curthread, ret == -1);
422
423 return (ret);
424 }
425
426 /*
427 * Cancellation behavior:
428 * Thread may be canceled at start, but if the system call got some data,
429 * the thread is not canceled.
430 */
431 static ssize_t
__thr_readv(int fd,const struct iovec * iov,int iovcnt)432 __thr_readv(int fd, const struct iovec *iov, int iovcnt)
433 {
434 struct pthread *curthread;
435 ssize_t ret;
436
437 curthread = _get_curthread();
438 _thr_cancel_enter(curthread);
439 ret = __sys_readv(fd, iov, iovcnt);
440 _thr_cancel_leave(curthread, ret == -1);
441 return (ret);
442 }
443
444 /*
445 * Cancellation behavior:
446 * Thread may be canceled at start, but if the system call got some data,
447 * the thread is not canceled.
448 */
449 static ssize_t
__thr_recvfrom(int s,void * b,size_t l,int f,struct sockaddr * from,socklen_t * fl)450 __thr_recvfrom(int s, void *b, size_t l, int f, struct sockaddr *from,
451 socklen_t *fl)
452 {
453 struct pthread *curthread;
454 ssize_t ret;
455
456 curthread = _get_curthread();
457 _thr_cancel_enter(curthread);
458 ret = __sys_recvfrom(s, b, l, f, from, fl);
459 _thr_cancel_leave(curthread, ret == -1);
460 return (ret);
461 }
462
463 /*
464 * Cancellation behavior:
465 * Thread may be canceled at start, but if the system call got some data,
466 * the thread is not canceled.
467 */
468 static ssize_t
__thr_recvmsg(int s,struct msghdr * m,int f)469 __thr_recvmsg(int s, struct msghdr *m, int f)
470 {
471 struct pthread *curthread;
472 ssize_t ret;
473
474 curthread = _get_curthread();
475 _thr_cancel_enter(curthread);
476 ret = __sys_recvmsg(s, m, f);
477 _thr_cancel_leave(curthread, ret == -1);
478 return (ret);
479 }
480
481 /*
482 * Cancellation behavior:
483 * Thread may be canceled at start, but if the system call returns something,
484 * the thread is not canceled.
485 */
486 static int
__thr_select(int numfds,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout)487 __thr_select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
488 struct timeval *timeout)
489 {
490 struct pthread *curthread;
491 int ret;
492
493 curthread = _get_curthread();
494 _thr_cancel_enter(curthread);
495 ret = __sys_select(numfds, readfds, writefds, exceptfds, timeout);
496 _thr_cancel_leave(curthread, ret == -1);
497 return (ret);
498 }
499
500 /*
501 * Cancellation behavior:
502 * Thread may be canceled at start, but if the system call sent
503 * data, the thread is not canceled.
504 */
505 static ssize_t
__thr_sendmsg(int s,const struct msghdr * m,int f)506 __thr_sendmsg(int s, const struct msghdr *m, int f)
507 {
508 struct pthread *curthread;
509 ssize_t ret;
510
511 curthread = _get_curthread();
512 _thr_cancel_enter(curthread);
513 ret = __sys_sendmsg(s, m, f);
514 _thr_cancel_leave(curthread, ret <= 0);
515 return (ret);
516 }
517
518 /*
519 * Cancellation behavior:
520 * Thread may be canceled at start, but if the system call sent some
521 * data, the thread is not canceled.
522 */
523 static ssize_t
__thr_sendto(int s,const void * m,size_t l,int f,const struct sockaddr * t,socklen_t tl)524 __thr_sendto(int s, const void *m, size_t l, int f, const struct sockaddr *t,
525 socklen_t tl)
526 {
527 struct pthread *curthread;
528 ssize_t ret;
529
530 curthread = _get_curthread();
531 _thr_cancel_enter(curthread);
532 ret = __sys_sendto(s, m, l, f, t, tl);
533 _thr_cancel_leave(curthread, ret <= 0);
534 return (ret);
535 }
536
537 static int
__thr_system(const char * string)538 __thr_system(const char *string)
539 {
540 struct pthread *curthread;
541 int ret;
542
543 curthread = _get_curthread();
544 _thr_cancel_enter(curthread);
545 ret = __libc_system(string);
546 _thr_cancel_leave(curthread, 1);
547 return (ret);
548 }
549
550 /*
551 * Cancellation behavior:
552 * If thread is canceled, the system call is not completed,
553 * this means not all bytes were drained.
554 */
555 static int
__thr_tcdrain(int fd)556 __thr_tcdrain(int fd)
557 {
558 struct pthread *curthread;
559 int ret;
560
561 curthread = _get_curthread();
562 _thr_cancel_enter(curthread);
563 ret = __libc_tcdrain(fd);
564 _thr_cancel_leave(curthread, ret == -1);
565 return (ret);
566 }
567
568 /*
569 * Cancellation behavior:
570 * Thread may be canceled at start, but if the system call returns
571 * a child pid, the thread is not canceled.
572 */
573 static pid_t
__thr_wait4(pid_t pid,int * status,int options,struct rusage * rusage)574 __thr_wait4(pid_t pid, int *status, int options, struct rusage *rusage)
575 {
576 struct pthread *curthread;
577 pid_t ret;
578
579 curthread = _get_curthread();
580 _thr_cancel_enter(curthread);
581 ret = __sys_wait4(pid, status, options, rusage);
582 _thr_cancel_leave(curthread, ret <= 0);
583 return (ret);
584 }
585
586 /*
587 * Cancellation behavior:
588 * Thread may be canceled at start, but if the system call returns
589 * a child pid, the thread is not canceled.
590 */
591 static pid_t
__thr_wait6(idtype_t idtype,id_t id,int * status,int options,struct __wrusage * ru,siginfo_t * infop)592 __thr_wait6(idtype_t idtype, id_t id, int *status, int options,
593 struct __wrusage *ru, siginfo_t *infop)
594 {
595 struct pthread *curthread;
596 pid_t ret;
597
598 curthread = _get_curthread();
599 _thr_cancel_enter(curthread);
600 ret = __sys_wait6(idtype, id, status, options, ru, infop);
601 _thr_cancel_leave(curthread, ret <= 0);
602 return (ret);
603 }
604
605 /*
606 * Cancellation behavior:
607 * Thread may be canceled at start, but if the thread wrote some data,
608 * it is not canceled.
609 */
610 static ssize_t
__thr_write(int fd,const void * buf,size_t nbytes)611 __thr_write(int fd, const void *buf, size_t nbytes)
612 {
613 struct pthread *curthread;
614 ssize_t ret;
615
616 curthread = _get_curthread();
617 _thr_cancel_enter(curthread);
618 ret = __sys_write(fd, buf, nbytes);
619 _thr_cancel_leave(curthread, (ret <= 0));
620 return (ret);
621 }
622
623 /*
624 * Cancellation behavior:
625 * Thread may be canceled at start, but if the thread wrote some data,
626 * it is not canceled.
627 */
628 static ssize_t
__thr_writev(int fd,const struct iovec * iov,int iovcnt)629 __thr_writev(int fd, const struct iovec *iov, int iovcnt)
630 {
631 struct pthread *curthread;
632 ssize_t ret;
633
634 curthread = _get_curthread();
635 _thr_cancel_enter(curthread);
636 ret = __sys_writev(fd, iov, iovcnt);
637 _thr_cancel_leave(curthread, (ret <= 0));
638 return (ret);
639 }
640
641 void
__thr_interpose_libc(void)642 __thr_interpose_libc(void)
643 {
644
645 __set_error_selector(__error_threaded);
646 #define SLOT(name) \
647 *(__libc_interposing_slot(INTERPOS_##name)) = \
648 (interpos_func_t)__thr_##name;
649 SLOT(accept);
650 SLOT(accept4);
651 SLOT(aio_suspend);
652 SLOT(close);
653 SLOT(connect);
654 SLOT(fcntl);
655 SLOT(fsync);
656 SLOT(fork);
657 SLOT(msync);
658 SLOT(nanosleep);
659 SLOT(openat);
660 SLOT(poll);
661 SLOT(pselect);
662 SLOT(read);
663 SLOT(readv);
664 SLOT(recvfrom);
665 SLOT(recvmsg);
666 SLOT(select);
667 SLOT(sendmsg);
668 SLOT(sendto);
669 SLOT(setcontext);
670 SLOT(sigaction);
671 SLOT(sigprocmask);
672 SLOT(sigsuspend);
673 SLOT(sigwait);
674 SLOT(sigtimedwait);
675 SLOT(sigwaitinfo);
676 SLOT(swapcontext);
677 SLOT(system);
678 SLOT(tcdrain);
679 SLOT(wait4);
680 SLOT(write);
681 SLOT(writev);
682 SLOT(spinlock);
683 SLOT(spinunlock);
684 SLOT(kevent);
685 SLOT(wait6);
686 SLOT(ppoll);
687 SLOT(map_stacks_exec);
688 SLOT(fdatasync);
689 SLOT(clock_nanosleep);
690 #undef SLOT
691 *(__libc_interposing_slot(
692 INTERPOS__pthread_mutex_init_calloc_cb)) =
693 (interpos_func_t)_pthread_mutex_init_calloc_cb;
694 }
695