Tweak mutex order for SD

[bacula/bacula] / bacula / src / lib / lockmgr.c

diff --git a/bacula/src/lib/lockmgr.c b/bacula/src/lib/lockmgr.c
index d882da271ef7fa1b3dbd54139bd49a93494a741e..c2f7b875cb908df4d2b9987cd6db6555cafcc26a 100644 (file)
--- a/bacula/src/lib/lockmgr.c
+++ b/bacula/src/lib/lockmgr.c
@@ -26,6 +26,33 @@
    Switzerland, email:ftf@fsfeurope.org.
 */
 
+/*
+  How to use mutex with bad order usage detection
+ ------------------------------------------------
+
+ Instead of using:
+    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+    P(mutex);
+    ..
+    V(mutex);
+
+ use:
+    bthread_mutex_t mutex = BTHREAD_MUTEX_PRIORITY(1);
+    P(mutex);
+    ...
+    V(mutex);
+
+ Mutex that doesn't need this extra check can be declared as pthread_mutex_t.
+ You can use this object on pthread_mutex_lock/unlock/cond_wait/cond_timewait.
+ 
+ With dynamic creation, you can use:
+    bthread_mutex_t mutex;
+    pthread_mutex_init(&mutex);
+    bthread_mutex_set_priority(&mutex, 10);
+    pthread_mutex_destroy(&mutex);
+ 
+ */
+
 #define _LOCKMGR_COMPLIANT
 #include "bacula.h"
 
@@ -256,9 +283,10 @@ public:
       fprintf(fp, "threadid=%p max=%i current=%i\n", 
               (void *)thread_id, max, current);
       for(int i=0; i<=current; i++) {
-         fprintf(fp, "   lock=%p state=%s %s:%i\n", 
+         fprintf(fp, "   lock=%p state=%s priority=%i %s:%i\n", 
                  lock_list[i].lock, 
                  (lock_list[i].state=='W')?"Wanted ":"Granted",
+                 lock_list[i].priority,
                  lock_list[i].file, lock_list[i].line);
       } 
    }
@@ -275,10 +303,11 @@ public:
     * Call before a lock operation (mark mutex as WANTED)
     */
    virtual void pre_P(void *m, int priority, 
-                      const char *f="*unknown*", int l=0) {
+                      const char *f="*unknown*", int l=0) 
+   {
+      int max_prio = max_priority;
       ASSERT_p(current < LMGR_MAX_LOCK, f, l);
       ASSERT_p(current >= -1, f, l);
-      ASSERT_p(!priority || priority >= max_priority, f, l);
       lmgr_p(&mutex);
       {
          current++;
@@ -292,6 +321,7 @@ public:
          max_priority = MAX(priority, max_priority);
       }
       lmgr_v(&mutex);
+      ASSERT_p(!priority || priority >= max_prio, f, l);
    }
 
    /*
@@ -661,7 +691,7 @@ void bthread_mutex_set_priority(bthread_mutex_t *m, int prio)
 /*
  * Replacement for pthread_mutex_init()
  */
-int bthread_mutex_init(bthread_mutex_t *m, const pthread_mutexattr_t *attr)
+int pthread_mutex_init(bthread_mutex_t *m, const pthread_mutexattr_t *attr)
 {
    m->priority = 0;
    return pthread_mutex_init(&m->mutex, attr);
@@ -670,7 +700,7 @@ int bthread_mutex_init(bthread_mutex_t *m, const pthread_mutexattr_t *attr)
 /*
  * Replacement for pthread_mutex_destroy()
  */
-int bthread_mutex_destroy(bthread_mutex_t *m)
+int pthread_mutex_destroy(bthread_mutex_t *m)
 {
    return pthread_mutex_destroy(&m->mutex);
 }
@@ -883,10 +913,7 @@ void dbg_print_lock(FILE *fp)
 
 #include "lockmgr.h"
 #define BTHREAD_MUTEX_NO_PRIORITY      {PTHREAD_MUTEX_INITIALIZER, 0}
-#define BTHREAD_MUTEX_PRIORITY_1       {PTHREAD_MUTEX_INITIALIZER, 1}
-#define BTHREAD_MUTEX_PRIORITY_2       {PTHREAD_MUTEX_INITIALIZER, 2}
-#define BTHREAD_MUTEX_PRIORITY_3       {PTHREAD_MUTEX_INITIALIZER, 3}
-#define BTHREAD_MUTEX_PRIORITY_4       {PTHREAD_MUTEX_INITIALIZER, 4}
+#define BTHREAD_MUTEX_PRIORITY(p)      {PTHREAD_MUTEX_INITIALIZER, p}
 #undef P
 #undef V
 #define P(x) bthread_mutex_lock_p(&(x), __FILE__, __LINE__)
@@ -899,9 +926,9 @@ bthread_mutex_t mutex3 = BTHREAD_MUTEX_NO_PRIORITY;
 bthread_mutex_t mutex4 = BTHREAD_MUTEX_NO_PRIORITY;
 bthread_mutex_t mutex5 = BTHREAD_MUTEX_NO_PRIORITY;
 bthread_mutex_t mutex6 = BTHREAD_MUTEX_NO_PRIORITY;
-bthread_mutex_t mutex_p1 = BTHREAD_MUTEX_PRIORITY_1;
-bthread_mutex_t mutex_p2 = BTHREAD_MUTEX_PRIORITY_2;
-bthread_mutex_t mutex_p3 = BTHREAD_MUTEX_PRIORITY_3;
+bthread_mutex_t mutex_p1 = BTHREAD_MUTEX_PRIORITY(1);
+bthread_mutex_t mutex_p2 = BTHREAD_MUTEX_PRIORITY(2);
+bthread_mutex_t mutex_p3 = BTHREAD_MUTEX_PRIORITY(3);
 static const char *my_prog;
 
 void *self_lock(void *temp)
@@ -1062,10 +1089,13 @@ int main(int argc, char **argv)
    void *ret=NULL;
    lmgr_thread_t *self;
    pthread_t id1, id2, id3, tab[200];
+   bthread_mutex_t bmutex1;
+   pthread_mutex_t pmutex2;
    my_prog = argv[0];
 
    use_undertaker = false;
    lmgr_init_thread();
+   self = lmgr_get_thread_info();
 
    if (argc == 2) {             /* do priority check */
       P(mutex_p2);                /* not permited */
@@ -1075,6 +1105,18 @@ int main(int argc, char **argv)
       return 0;
    }
 
+   pthread_mutex_init(&bmutex1, NULL);
+   bthread_mutex_set_priority(&bmutex1, 10);
+
+   pthread_mutex_init(&pmutex2, NULL);
+   P(bmutex1);
+   ok(self->max_priority == 10, "Check self max_priority");
+   P(pmutex2);
+   ok(bmutex1.priority == 10, "Check bmutex_set_priority()");
+   V(pmutex2);
+   V(bmutex1);
+   ok(self->max_priority == 0, "Check self max_priority");
+
    pthread_create(&id1, NULL, self_lock, NULL);
    sleep(2);
    ok(lmgr_detect_deadlock(), "Check self deadlock");
@@ -1159,7 +1201,6 @@ int main(int argc, char **argv)
    pthread_join(id3, &ret);
    ok(ret != 0, "Check for priority segfault");
 
-   self = lmgr_get_thread_info();
    P(mutex_p1);
    ok(self->max_priority == 1, "Check max_priority 1/4");
    P(mutex_p2);