tdb mutex check: Fix CID 1358473 Uninitialized scalar variable
[samba.git] / lib / tdb / common / mutex.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    trivial database library
5
6    Copyright (C) Volker Lendecke 2012,2013
7    Copyright (C) Stefan Metzmacher 2013,2014
8    Copyright (C) Michael Adam 2014
9
10      ** NOTE! The following LGPL license applies to the tdb
11      ** library. This does NOT imply that all of Samba is released
12      ** under the LGPL
13
14    This library is free software; you can redistribute it and/or
15    modify it under the terms of the GNU Lesser General Public
16    License as published by the Free Software Foundation; either
17    version 3 of the License, or (at your option) any later version.
18
19    This library is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22    Lesser General Public License for more details.
23
24    You should have received a copy of the GNU Lesser General Public
25    License along with this library; if not, see <http://www.gnu.org/licenses/>.
26 */
27 #include "tdb_private.h"
28 #include "system/threads.h"
29
30 #ifdef USE_TDB_MUTEX_LOCKING
31
32 /*
33  * If we run with mutexes, we store the "struct tdb_mutexes" at the
34  * beginning of the file. We store an additional tdb_header right
35  * beyond the mutex area, page aligned. All the offsets within the tdb
36  * are relative to the area behind the mutex area. tdb->map_ptr points
37  * behind the mmap area as well, so the read and write path in the
38  * mutex case can remain unchanged.
39  *
40  * Early in the mutex development the mutexes were placed between the hash
41  * chain pointers and the real tdb data. This had two drawbacks: First, it
42  * made pointer calculations more complex. Second, we had to mmap the mutex
43  * area twice. One was the normal map_ptr in the tdb. This frequently changed
44  * from within tdb_oob. At least the Linux glibc robust mutex code assumes
45  * constant pointers in memory, so a constantly changing mmap area destroys
46  * the mutex list. So we had to mmap the first bytes of the file with a second
47  * mmap call. With that scheme, very weird errors happened that could be
48  * easily fixed by doing the mutex mmap in a second file. It seemed that
49  * mapping the same memory area twice does not end up in accessing the same
50  * physical page, looking at the mutexes in gdb it seemed that old data showed
51  * up after some re-mapping. To avoid a separate mutex file, the code now puts
52  * the real content of the tdb file after the mutex area. This way we do not
53  * have overlapping mmap areas, the mutex area is mmapped once and not
54  * changed, the tdb data area's mmap is constantly changed but does not
55  * overlap.
56  */
57
58 struct tdb_mutexes {
59         struct tdb_header hdr;
60
61         /* protect allrecord_lock */
62         pthread_mutex_t allrecord_mutex;
63
64         /*
65          * F_UNLCK: free,
66          * F_RDLCK: shared,
67          * F_WRLCK: exclusive
68          */
69         short int allrecord_lock;
70
71         /*
72          * Index 0 is the freelist mutex, followed by
73          * one mutex per hashchain.
74          */
75         pthread_mutex_t hashchains[1];
76 };
77
78 bool tdb_have_mutexes(struct tdb_context *tdb)
79 {
80         return ((tdb->feature_flags & TDB_FEATURE_FLAG_MUTEX) != 0);
81 }
82
83 size_t tdb_mutex_size(struct tdb_context *tdb)
84 {
85         size_t mutex_size;
86
87         if (!tdb_have_mutexes(tdb)) {
88                 return 0;
89         }
90
91         mutex_size = sizeof(struct tdb_mutexes);
92         mutex_size += tdb->hash_size * sizeof(pthread_mutex_t);
93
94         return TDB_ALIGN(mutex_size, tdb->page_size);
95 }
96
97 /*
98  * Get the index for a chain mutex
99  */
100 static bool tdb_mutex_index(struct tdb_context *tdb, off_t off, off_t len,
101                             unsigned *idx)
102 {
103         /*
104          * Weird but true: We fcntl lock 1 byte at an offset 4 bytes before
105          * the 4 bytes of the freelist start and the hash chain that is about
106          * to be locked. See lock_offset() where the freelist is -1 vs the
107          * "+1" in TDB_HASH_TOP(). Because the mutex array is represented in
108          * the tdb file itself as data, we need to adjust the offset here.
109          */
110         const off_t freelist_lock_ofs = FREELIST_TOP - sizeof(tdb_off_t);
111
112         if (!tdb_have_mutexes(tdb)) {
113                 return false;
114         }
115         if (len != 1) {
116                 /* Possibly the allrecord lock */
117                 return false;
118         }
119         if (off < freelist_lock_ofs) {
120                 /* One of the special locks */
121                 return false;
122         }
123         if (tdb->hash_size == 0) {
124                 /* tdb not initialized yet, called from tdb_open_ex() */
125                 return false;
126         }
127         if (off >= TDB_DATA_START(tdb->hash_size)) {
128                 /* Single record lock from traverses */
129                 return false;
130         }
131
132         /*
133          * Now we know it's a freelist or hash chain lock. Those are always 4
134          * byte aligned. Paranoia check.
135          */
136         if ((off % sizeof(tdb_off_t)) != 0) {
137                 abort();
138         }
139
140         /*
141          * Re-index the fcntl offset into an offset into the mutex array
142          */
143         off -= freelist_lock_ofs; /* rebase to index 0 */
144         off /= sizeof(tdb_off_t); /* 0 for freelist 1-n for hashchain */
145
146         *idx = off;
147         return true;
148 }
149
150 static bool tdb_have_mutex_chainlocks(struct tdb_context *tdb)
151 {
152         size_t i;
153
154         for (i=0; i < tdb->num_lockrecs; i++) {
155                 bool ret;
156                 unsigned idx;
157
158                 ret = tdb_mutex_index(tdb,
159                                       tdb->lockrecs[i].off,
160                                       tdb->lockrecs[i].count,
161                                       &idx);
162                 if (!ret) {
163                         continue;
164                 }
165
166                 if (idx == 0) {
167                         /* this is the freelist mutex */
168                         continue;
169                 }
170
171                 return true;
172         }
173
174         return false;
175 }
176
177 static int chain_mutex_lock(pthread_mutex_t *m, bool waitflag)
178 {
179         int ret;
180
181         if (waitflag) {
182                 ret = pthread_mutex_lock(m);
183         } else {
184                 ret = pthread_mutex_trylock(m);
185         }
186         if (ret != EOWNERDEAD) {
187                 return ret;
188         }
189
190         /*
191          * For chainlocks, we don't do any cleanup (yet?)
192          */
193         return pthread_mutex_consistent(m);
194 }
195
196 static int allrecord_mutex_lock(struct tdb_mutexes *m, bool waitflag)
197 {
198         int ret;
199
200         if (waitflag) {
201                 ret = pthread_mutex_lock(&m->allrecord_mutex);
202         } else {
203                 ret = pthread_mutex_trylock(&m->allrecord_mutex);
204         }
205         if (ret != EOWNERDEAD) {
206                 return ret;
207         }
208
209         /*
210          * The allrecord lock holder died. We need to reset the allrecord_lock
211          * to F_UNLCK. This should also be the indication for
212          * tdb_needs_recovery.
213          */
214         m->allrecord_lock = F_UNLCK;
215
216         return pthread_mutex_consistent(&m->allrecord_mutex);
217 }
218
219 bool tdb_mutex_lock(struct tdb_context *tdb, int rw, off_t off, off_t len,
220                     bool waitflag, int *pret)
221 {
222         struct tdb_mutexes *m = tdb->mutexes;
223         pthread_mutex_t *chain;
224         int ret;
225         unsigned idx;
226         bool allrecord_ok;
227
228         if (!tdb_mutex_index(tdb, off, len, &idx)) {
229                 return false;
230         }
231         chain = &m->hashchains[idx];
232
233 again:
234         ret = chain_mutex_lock(chain, waitflag);
235         if (ret == EBUSY) {
236                 ret = EAGAIN;
237         }
238         if (ret != 0) {
239                 errno = ret;
240                 goto fail;
241         }
242
243         if (idx == 0) {
244                 /*
245                  * This is a freelist lock, which is independent to
246                  * the allrecord lock. So we're done once we got the
247                  * freelist mutex.
248                  */
249                 *pret = 0;
250                 return true;
251         }
252
253         if (tdb_have_mutex_chainlocks(tdb)) {
254                 /*
255                  * We can only check the allrecord lock once. If we do it with
256                  * one chain mutex locked, we will deadlock with the allrecord
257                  * locker process in the following way: We lock the first hash
258                  * chain, we check for the allrecord lock. We keep the hash
259                  * chain locked. Then the allrecord locker locks the
260                  * allrecord_mutex. It walks the list of chain mutexes,
261                  * locking them all in sequence. Meanwhile, we have the chain
262                  * mutex locked, so the allrecord locker blocks trying to lock
263                  * our chain mutex. Then we come in and try to lock the second
264                  * chain lock, which in most cases will be the freelist. We
265                  * see that the allrecord lock is locked and put ourselves on
266                  * the allrecord_mutex. This will never be signalled though
267                  * because the allrecord locker waits for us to give up the
268                  * chain lock.
269                  */
270
271                 *pret = 0;
272                 return true;
273         }
274
275         /*
276          * Check if someone is has the allrecord lock: queue if so.
277          */
278
279         allrecord_ok = false;
280
281         if (m->allrecord_lock == F_UNLCK) {
282                 /*
283                  * allrecord lock not taken
284                  */
285                 allrecord_ok = true;
286         }
287
288         if ((m->allrecord_lock == F_RDLCK) && (rw == F_RDLCK)) {
289                 /*
290                  * allrecord shared lock taken, but we only want to read
291                  */
292                 allrecord_ok = true;
293         }
294
295         if (allrecord_ok) {
296                 *pret = 0;
297                 return true;
298         }
299
300         ret = pthread_mutex_unlock(chain);
301         if (ret != 0) {
302                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_unlock"
303                          "(chain_mutex) failed: %s\n", strerror(ret)));
304                 errno = ret;
305                 goto fail;
306         }
307         ret = allrecord_mutex_lock(m, waitflag);
308         if (ret == EBUSY) {
309                 ret = EAGAIN;
310         }
311         if (ret != 0) {
312                 if (waitflag || (ret != EAGAIN)) {
313                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_%slock"
314                                  "(allrecord_mutex) failed: %s\n",
315                                  waitflag ? "" : "try_",  strerror(ret)));
316                 }
317                 errno = ret;
318                 goto fail;
319         }
320         ret = pthread_mutex_unlock(&m->allrecord_mutex);
321         if (ret != 0) {
322                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_unlock"
323                          "(allrecord_mutex) failed: %s\n", strerror(ret)));
324                 errno = ret;
325                 goto fail;
326         }
327         goto again;
328
329 fail:
330         *pret = -1;
331         return true;
332 }
333
334 bool tdb_mutex_unlock(struct tdb_context *tdb, int rw, off_t off, off_t len,
335                       int *pret)
336 {
337         struct tdb_mutexes *m = tdb->mutexes;
338         pthread_mutex_t *chain;
339         int ret;
340         unsigned idx;
341
342         if (!tdb_mutex_index(tdb, off, len, &idx)) {
343                 return false;
344         }
345         chain = &m->hashchains[idx];
346
347         ret = pthread_mutex_unlock(chain);
348         if (ret == 0) {
349                 *pret = 0;
350                 return true;
351         }
352         errno = ret;
353         *pret = -1;
354         return true;
355 }
356
357 int tdb_mutex_allrecord_lock(struct tdb_context *tdb, int ltype,
358                              enum tdb_lock_flags flags)
359 {
360         struct tdb_mutexes *m = tdb->mutexes;
361         int ret;
362         uint32_t i;
363         bool waitflag = (flags & TDB_LOCK_WAIT);
364         int saved_errno;
365
366         if (tdb->flags & TDB_NOLOCK) {
367                 return 0;
368         }
369
370         if (flags & TDB_LOCK_MARK_ONLY) {
371                 return 0;
372         }
373
374         ret = allrecord_mutex_lock(m, waitflag);
375         if (!waitflag && (ret == EBUSY)) {
376                 errno = EAGAIN;
377                 tdb->ecode = TDB_ERR_LOCK;
378                 return -1;
379         }
380         if (ret != 0) {
381                 if (!(flags & TDB_LOCK_PROBE)) {
382                         TDB_LOG((tdb, TDB_DEBUG_TRACE,
383                                  "allrecord_mutex_lock() failed: %s\n",
384                                  strerror(ret)));
385                 }
386                 tdb->ecode = TDB_ERR_LOCK;
387                 return -1;
388         }
389
390         if (m->allrecord_lock != F_UNLCK) {
391                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "allrecord_lock == %d\n",
392                          (int)m->allrecord_lock));
393                 goto fail_unlock_allrecord_mutex;
394         }
395         m->allrecord_lock = (ltype == F_RDLCK) ? F_RDLCK : F_WRLCK;
396
397         for (i=0; i<tdb->hash_size; i++) {
398
399                 /* ignore hashchains[0], the freelist */
400                 pthread_mutex_t *chain = &m->hashchains[i+1];
401
402                 ret = chain_mutex_lock(chain, waitflag);
403                 if (!waitflag && (ret == EBUSY)) {
404                         errno = EAGAIN;
405                         goto fail_unroll_allrecord_lock;
406                 }
407                 if (ret != 0) {
408                         if (!(flags & TDB_LOCK_PROBE)) {
409                                 TDB_LOG((tdb, TDB_DEBUG_TRACE,
410                                          "chain_mutex_lock() failed: %s\n",
411                                          strerror(ret)));
412                         }
413                         errno = ret;
414                         goto fail_unroll_allrecord_lock;
415                 }
416
417                 ret = pthread_mutex_unlock(chain);
418                 if (ret != 0) {
419                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_unlock"
420                                  "(chainlock) failed: %s\n", strerror(ret)));
421                         errno = ret;
422                         goto fail_unroll_allrecord_lock;
423                 }
424         }
425         /*
426          * We leave this routine with m->allrecord_mutex locked
427          */
428         return 0;
429
430 fail_unroll_allrecord_lock:
431         m->allrecord_lock = F_UNLCK;
432
433 fail_unlock_allrecord_mutex:
434         saved_errno = errno;
435         ret = pthread_mutex_unlock(&m->allrecord_mutex);
436         if (ret != 0) {
437                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_unlock"
438                          "(allrecord_mutex) failed: %s\n", strerror(ret)));
439         }
440         errno = saved_errno;
441         tdb->ecode = TDB_ERR_LOCK;
442         return -1;
443 }
444
445 int tdb_mutex_allrecord_upgrade(struct tdb_context *tdb)
446 {
447         struct tdb_mutexes *m = tdb->mutexes;
448         int ret;
449         uint32_t i;
450
451         if (tdb->flags & TDB_NOLOCK) {
452                 return 0;
453         }
454
455         /*
456          * Our only caller tdb_allrecord_upgrade()
457          * garantees that we already own the allrecord lock.
458          *
459          * Which means m->allrecord_mutex is still locked by us.
460          */
461
462         if (m->allrecord_lock != F_RDLCK) {
463                 tdb->ecode = TDB_ERR_LOCK;
464                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "allrecord_lock == %d\n",
465                          (int)m->allrecord_lock));
466                 return -1;
467         }
468
469         m->allrecord_lock = F_WRLCK;
470
471         for (i=0; i<tdb->hash_size; i++) {
472
473                 /* ignore hashchains[0], the freelist */
474                 pthread_mutex_t *chain = &m->hashchains[i+1];
475
476                 ret = chain_mutex_lock(chain, true);
477                 if (ret != 0) {
478                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_lock"
479                                  "(chainlock) failed: %s\n", strerror(ret)));
480                         goto fail_unroll_allrecord_lock;
481                 }
482
483                 ret = pthread_mutex_unlock(chain);
484                 if (ret != 0) {
485                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_unlock"
486                                  "(chainlock) failed: %s\n", strerror(ret)));
487                         goto fail_unroll_allrecord_lock;
488                 }
489         }
490
491         return 0;
492
493 fail_unroll_allrecord_lock:
494         m->allrecord_lock = F_RDLCK;
495         tdb->ecode = TDB_ERR_LOCK;
496         return -1;
497 }
498
499 void tdb_mutex_allrecord_downgrade(struct tdb_context *tdb)
500 {
501         struct tdb_mutexes *m = tdb->mutexes;
502
503         /*
504          * Our only caller tdb_allrecord_upgrade() (in the error case)
505          * garantees that we already own the allrecord lock.
506          *
507          * Which means m->allrecord_mutex is still locked by us.
508          */
509
510         if (m->allrecord_lock != F_WRLCK) {
511                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "allrecord_lock == %d\n",
512                          (int)m->allrecord_lock));
513                 return;
514         }
515
516         m->allrecord_lock = F_RDLCK;
517         return;
518 }
519
520
521 int tdb_mutex_allrecord_unlock(struct tdb_context *tdb)
522 {
523         struct tdb_mutexes *m = tdb->mutexes;
524         short old;
525         int ret;
526
527         if (tdb->flags & TDB_NOLOCK) {
528                 return 0;
529         }
530
531         /*
532          * Our only callers tdb_allrecord_unlock() and
533          * tdb_allrecord_lock() (in the error path)
534          * garantee that we already own the allrecord lock.
535          *
536          * Which means m->allrecord_mutex is still locked by us.
537          */
538
539         if ((m->allrecord_lock != F_RDLCK) && (m->allrecord_lock != F_WRLCK)) {
540                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "allrecord_lock == %d\n",
541                          (int)m->allrecord_lock));
542                 return -1;
543         }
544
545         old = m->allrecord_lock;
546         m->allrecord_lock = F_UNLCK;
547
548         ret = pthread_mutex_unlock(&m->allrecord_mutex);
549         if (ret != 0) {
550                 m->allrecord_lock = old;
551                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "pthread_mutex_unlock"
552                          "(allrecord_mutex) failed: %s\n", strerror(ret)));
553                 return -1;
554         }
555         return 0;
556 }
557
558 int tdb_mutex_init(struct tdb_context *tdb)
559 {
560         struct tdb_mutexes *m;
561         pthread_mutexattr_t ma;
562         int i, ret;
563
564         ret = tdb_mutex_mmap(tdb);
565         if (ret == -1) {
566                 return -1;
567         }
568         m = tdb->mutexes;
569
570         ret = pthread_mutexattr_init(&ma);
571         if (ret != 0) {
572                 goto fail_munmap;
573         }
574         ret = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK);
575         if (ret != 0) {
576                 goto fail;
577         }
578         ret = pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
579         if (ret != 0) {
580                 goto fail;
581         }
582         ret = pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
583         if (ret != 0) {
584                 goto fail;
585         }
586
587         for (i=0; i<tdb->hash_size+1; i++) {
588                 pthread_mutex_t *chain = &m->hashchains[i];
589
590                 ret = pthread_mutex_init(chain, &ma);
591                 if (ret != 0) {
592                         goto fail;
593                 }
594         }
595
596         m->allrecord_lock = F_UNLCK;
597
598         ret = pthread_mutex_init(&m->allrecord_mutex, &ma);
599         if (ret != 0) {
600                 goto fail;
601         }
602         ret = 0;
603 fail:
604         pthread_mutexattr_destroy(&ma);
605 fail_munmap:
606         tdb_mutex_munmap(tdb);
607
608         if (ret == 0) {
609                 return 0;
610         }
611
612         errno = ret;
613         return -1;
614 }
615
616 int tdb_mutex_mmap(struct tdb_context *tdb)
617 {
618         size_t len;
619         void *ptr;
620
621         len = tdb_mutex_size(tdb);
622         if (len == 0) {
623                 return 0;
624         }
625
626         ptr = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FILE,
627                    tdb->fd, 0);
628         if (ptr == MAP_FAILED) {
629                 return -1;
630         }
631         tdb->mutexes = (struct tdb_mutexes *)ptr;
632
633         return 0;
634 }
635
636 int tdb_mutex_munmap(struct tdb_context *tdb)
637 {
638         size_t len;
639
640         len = tdb_mutex_size(tdb);
641         if (len == 0) {
642                 return 0;
643         }
644
645         return munmap(tdb->mutexes, len);
646 }
647
648 static bool tdb_mutex_locking_cached;
649
650 static bool tdb_mutex_locking_supported(void)
651 {
652         pthread_mutexattr_t ma;
653         pthread_mutex_t m;
654         int ret;
655         static bool initialized;
656
657         if (initialized) {
658                 return tdb_mutex_locking_cached;
659         }
660
661         initialized = true;
662
663         ret = pthread_mutexattr_init(&ma);
664         if (ret != 0) {
665                 return false;
666         }
667         ret = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK);
668         if (ret != 0) {
669                 goto cleanup_ma;
670         }
671         ret = pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
672         if (ret != 0) {
673                 goto cleanup_ma;
674         }
675         ret = pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
676         if (ret != 0) {
677                 goto cleanup_ma;
678         }
679         ret = pthread_mutex_init(&m, &ma);
680         if (ret != 0) {
681                 goto cleanup_ma;
682         }
683         ret = pthread_mutex_lock(&m);
684         if (ret != 0) {
685                 goto cleanup_m;
686         }
687         /*
688          * This makes sure we have real mutexes
689          * from a threading library instead of just
690          * stubs from libc.
691          */
692         ret = pthread_mutex_lock(&m);
693         if (ret != EDEADLK) {
694                 goto cleanup_lock;
695         }
696         ret = pthread_mutex_unlock(&m);
697         if (ret != 0) {
698                 goto cleanup_m;
699         }
700
701         tdb_mutex_locking_cached = true;
702         goto cleanup_m;
703
704 cleanup_lock:
705         pthread_mutex_unlock(&m);
706 cleanup_m:
707         pthread_mutex_destroy(&m);
708 cleanup_ma:
709         pthread_mutexattr_destroy(&ma);
710         return tdb_mutex_locking_cached;
711 }
712
713 static void (*tdb_robust_mutext_old_handler)(int) = SIG_ERR;
714 static pid_t tdb_robust_mutex_pid = -1;
715
716 static bool tdb_robust_mutex_setup_sigchild(void (*handler)(int),
717                         void (**p_old_handler)(int))
718 {
719 #ifdef HAVE_SIGACTION
720         struct sigaction act;
721         struct sigaction oldact;
722
723         memset(&act, '\0', sizeof(act));
724
725         act.sa_handler = handler;
726 #ifdef SA_RESTART
727         act.sa_flags = SA_RESTART;
728 #endif
729         sigemptyset(&act.sa_mask);
730         sigaddset(&act.sa_mask, SIGCHLD);
731         sigaction(SIGCHLD, &act, &oldact);
732         if (p_old_handler) {
733                 *p_old_handler = oldact.sa_handler;
734         }
735         return true;
736 #else /* !HAVE_SIGACTION */
737         return false;
738 #endif
739 }
740
741 static void tdb_robust_mutex_handler(int sig)
742 {
743         if (tdb_robust_mutex_pid != -1) {
744                 pid_t pid;
745                 int status;
746
747                 pid = waitpid(tdb_robust_mutex_pid, &status, WNOHANG);
748                 if (pid == tdb_robust_mutex_pid) {
749                         tdb_robust_mutex_pid = -1;
750                         return;
751                 }
752         }
753
754         if (tdb_robust_mutext_old_handler == SIG_DFL) {
755                 return;
756         }
757         if (tdb_robust_mutext_old_handler == SIG_IGN) {
758                 return;
759         }
760         if (tdb_robust_mutext_old_handler == SIG_ERR) {
761                 return;
762         }
763
764         tdb_robust_mutext_old_handler(sig);
765 }
766
767 _PUBLIC_ bool tdb_runtime_check_for_robust_mutexes(void)
768 {
769         void *ptr = NULL;
770         pthread_mutex_t *m = NULL;
771         pthread_mutexattr_t ma;
772         int ret = 1;
773         int pipe_down[2] = { -1, -1 };
774         int pipe_up[2] = { -1, -1 };
775         ssize_t nread;
776         char c = 0;
777         bool ok;
778         static bool initialized;
779         sigset_t mask, old_mask, suspend_mask;
780         bool cleanup_ma = false;
781         bool cleanup_sigmask = false;
782
783         if (initialized) {
784                 return tdb_mutex_locking_cached;
785         }
786
787         initialized = true;
788
789         sigemptyset(&suspend_mask);
790
791         ok = tdb_mutex_locking_supported();
792         if (!ok) {
793                 return false;
794         }
795
796         tdb_mutex_locking_cached = false;
797
798         ptr = mmap(NULL, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE,
799                    MAP_SHARED|MAP_ANON, -1 /* fd */, 0);
800         if (ptr == MAP_FAILED) {
801                 return false;
802         }
803
804         ret = pipe(pipe_down);
805         if (ret != 0) {
806                 goto cleanup;
807         }
808         ret = pipe(pipe_up);
809         if (ret != 0) {
810                 goto cleanup;
811         }
812
813         ret = pthread_mutexattr_init(&ma);
814         if (ret != 0) {
815                 goto cleanup;
816         }
817         cleanup_ma = true;
818         ret = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK);
819         if (ret != 0) {
820                 goto cleanup;
821         }
822         ret = pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
823         if (ret != 0) {
824                 goto cleanup;
825         }
826         ret = pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
827         if (ret != 0) {
828                 goto cleanup;
829         }
830         ret = pthread_mutex_init(ptr, &ma);
831         if (ret != 0) {
832                 goto cleanup;
833         }
834         m = (pthread_mutex_t *)ptr;
835
836         /*
837          * Block SIGCHLD so we can atomically wait for it later with
838          * sigsuspend()
839          */
840         sigemptyset(&mask);
841         sigaddset(&mask, SIGCHLD);
842         ret = pthread_sigmask(SIG_BLOCK, &mask, &old_mask);
843         if (ret != 0) {
844                 goto cleanup;
845         }
846         cleanup_sigmask = true;
847         suspend_mask = old_mask;
848         sigdelset(&suspend_mask, SIGCHLD);
849
850         if (tdb_robust_mutex_setup_sigchild(tdb_robust_mutex_handler,
851                         &tdb_robust_mutext_old_handler) == false) {
852                 goto cleanup;
853         }
854
855         tdb_robust_mutex_pid = fork();
856         if (tdb_robust_mutex_pid == 0) {
857                 size_t nwritten;
858                 close(pipe_down[1]);
859                 close(pipe_up[0]);
860                 ret = pthread_mutex_lock(m);
861                 nwritten = write(pipe_up[1], &ret, sizeof(ret));
862                 if (nwritten != sizeof(ret)) {
863                         _exit(1);
864                 }
865                 if (ret != 0) {
866                         _exit(1);
867                 }
868                 nread = read(pipe_down[0], &c, 1);
869                 if (nread != 1) {
870                         _exit(1);
871                 }
872                 /* leave locked */
873                 _exit(0);
874         }
875         if (tdb_robust_mutex_pid == -1) {
876                 goto cleanup;
877         }
878         close(pipe_down[0]);
879         pipe_down[0] = -1;
880         close(pipe_up[1]);
881         pipe_up[1] = -1;
882
883         nread = read(pipe_up[0], &ret, sizeof(ret));
884         if (nread != sizeof(ret)) {
885                 goto cleanup;
886         }
887
888         ret = pthread_mutex_trylock(m);
889         if (ret != EBUSY) {
890                 if (ret == 0) {
891                         pthread_mutex_unlock(m);
892                 }
893                 goto cleanup;
894         }
895
896         if (write(pipe_down[1], &c, 1) != 1) {
897                 goto cleanup;
898         }
899
900         nread = read(pipe_up[0], &c, 1);
901         if (nread != 0) {
902                 goto cleanup;
903         }
904
905         while (tdb_robust_mutex_pid > 0) {
906                 ret = sigsuspend(&suspend_mask);
907                 if (ret != -1 || errno != EINTR) {
908                         abort();
909                 }
910         }
911         tdb_robust_mutex_setup_sigchild(tdb_robust_mutext_old_handler, NULL);
912         tdb_robust_mutext_old_handler = SIG_ERR;
913
914         ret = pthread_mutex_trylock(m);
915         if (ret != EOWNERDEAD) {
916                 if (ret == 0) {
917                         pthread_mutex_unlock(m);
918                 }
919                 goto cleanup;
920         }
921
922         ret = pthread_mutex_consistent(m);
923         if (ret != 0) {
924                 goto cleanup;
925         }
926
927         ret = pthread_mutex_trylock(m);
928         if (ret != EDEADLK) {
929                 pthread_mutex_unlock(m);
930                 goto cleanup;
931         }
932
933         ret = pthread_mutex_unlock(m);
934         if (ret != 0) {
935                 goto cleanup;
936         }
937
938         tdb_mutex_locking_cached = true;
939
940 cleanup:
941         while (tdb_robust_mutex_pid > 0) {
942                 kill(tdb_robust_mutex_pid, SIGKILL);
943                 ret = sigsuspend(&suspend_mask);
944                 if (ret != -1 || errno != EINTR) {
945                         abort();
946                 }
947         }
948
949         if (tdb_robust_mutext_old_handler != SIG_ERR) {
950                 tdb_robust_mutex_setup_sigchild(tdb_robust_mutext_old_handler, NULL);
951         }
952         if (cleanup_sigmask) {
953                 ret = pthread_sigmask(SIG_SETMASK, &old_mask, NULL);
954                 if (ret != 0) {
955                         abort();
956                 }
957         }
958         if (m != NULL) {
959                 pthread_mutex_destroy(m);
960         }
961         if (cleanup_ma) {
962                 pthread_mutexattr_destroy(&ma);
963         }
964         if (pipe_down[0] != -1) {
965                 close(pipe_down[0]);
966         }
967         if (pipe_down[1] != -1) {
968                 close(pipe_down[1]);
969         }
970         if (pipe_up[0] != -1) {
971                 close(pipe_up[0]);
972         }
973         if (pipe_up[1] != -1) {
974                 close(pipe_up[1]);
975         }
976         if (ptr != NULL) {
977                 munmap(ptr, sizeof(pthread_mutex_t));
978         }
979
980         return tdb_mutex_locking_cached;
981 }
982
983 #else
984
985 size_t tdb_mutex_size(struct tdb_context *tdb)
986 {
987         return 0;
988 }
989
990 bool tdb_have_mutexes(struct tdb_context *tdb)
991 {
992         return false;
993 }
994
995 int tdb_mutex_allrecord_lock(struct tdb_context *tdb, int ltype,
996                              enum tdb_lock_flags flags)
997 {
998         tdb->ecode = TDB_ERR_LOCK;
999         return -1;
1000 }
1001
1002 int tdb_mutex_allrecord_unlock(struct tdb_context *tdb)
1003 {
1004         return -1;
1005 }
1006
1007 int tdb_mutex_allrecord_upgrade(struct tdb_context *tdb)
1008 {
1009         tdb->ecode = TDB_ERR_LOCK;
1010         return -1;
1011 }
1012
1013 void tdb_mutex_allrecord_downgrade(struct tdb_context *tdb)
1014 {
1015         return;
1016 }
1017
1018 int tdb_mutex_mmap(struct tdb_context *tdb)
1019 {
1020         errno = ENOSYS;
1021         return -1;
1022 }
1023
1024 int tdb_mutex_munmap(struct tdb_context *tdb)
1025 {
1026         errno = ENOSYS;
1027         return -1;
1028 }
1029
1030 int tdb_mutex_init(struct tdb_context *tdb)
1031 {
1032         errno = ENOSYS;
1033         return -1;
1034 }
1035
1036 _PUBLIC_ bool tdb_runtime_check_for_robust_mutexes(void)
1037 {
1038         return false;
1039 }
1040
1041 #endif