* Landed b_cray_portals_merge.

[fs/lustre-release.git] / lnet / ulnds / proclib.c

diff --git a/lnet/ulnds/proclib.c b/lnet/ulnds/proclib.c
index 2a5ba0d..af0745b 100644 (file)
--- a/lnet/ulnds/proclib.c
+++ b/lnet/ulnds/proclib.c
@@ -95,7 +95,7 @@ static void nal_cli(nal_cb_t *nal,
     bridge b = (bridge) nal->nal_data;
     procbridge p = (procbridge) b->local;
 
-    pthread_mutex_lock(&p->nal_cb_lock);
+    pthread_mutex_lock(&p->mutex);
 }
 
 
@@ -105,9 +105,21 @@ static void nal_sti(nal_cb_t *nal,
     bridge b = (bridge)nal->nal_data;
     procbridge p = (procbridge) b->local;
 
-    pthread_mutex_unlock(&p->nal_cb_lock);
+    pthread_mutex_unlock(&p->mutex);
 }
 
+static void nal_callback(nal_cb_t *nal, void *private,
+                         lib_eq_t *eq, ptl_event_t *ev)
+{
+        bridge b = (bridge)nal->nal_data;
+        procbridge p = (procbridge) b->local;
+
+        /* holding p->mutex */
+        if (eq->event_callback != NULL)
+                eq->event_callback(ev);
+        
+        pthread_cond_broadcast(&p->cond);
+}
 
 static int nal_dist(nal_cb_t *nal,
                     ptl_nid_t nid,
@@ -116,21 +128,20 @@ static int nal_dist(nal_cb_t *nal,
     return 0;
 }
 
-static void wakeup_topside(void *z)
+static void check_stopping(void *z)
 {
     bridge b = z;
     procbridge p = b->local;
-    int stop;
 
+    if ((p->nal_flags & NAL_FLAG_STOPPING) == 0)
+            return;
+    
     pthread_mutex_lock(&p->mutex);
-    stop = p->nal_flags & NAL_FLAG_STOPPING;
-    if (stop)
-        p->nal_flags |= NAL_FLAG_STOPPED;
+    p->nal_flags |= NAL_FLAG_STOPPED;
     pthread_cond_broadcast(&p->cond);
     pthread_mutex_unlock(&p->mutex);
 
-    if (stop)
-        pthread_exit(0);
+    pthread_exit(0);
 }
 
 
@@ -146,9 +157,6 @@ static void wakeup_topside(void *z)
  *  We define a limit macro to place a ceiling on limits
  *   for syntactic convenience
  */
-#define LIMIT(x,y,max)\
-     if ((unsigned int)x > max) y = max;
-
 extern int tcpnal_init(bridge);
 
 nal_initialize nal_table[PTL_IFACE_MAX]={0,tcpnal_init,0};
@@ -159,10 +167,8 @@ void *nal_thread(void *z)
     bridge b = args->nia_bridge;
     procbridge p=b->local;
     int rc;
-    ptl_pid_t pid_request;
+    ptl_process_id_t process_id;
     int nal_type;
-    ptl_ni_limits_t desired;
-    ptl_ni_limits_t actual;
     
     b->nal_cb=(nal_cb_t *)malloc(sizeof(nal_cb_t));
     b->nal_cb->nal_data=b;
@@ -175,30 +181,24 @@ void *nal_thread(void *z)
     b->nal_cb->cb_printf=nal_printf;
     b->nal_cb->cb_cli=nal_cli;
     b->nal_cb->cb_sti=nal_sti;
+    b->nal_cb->cb_callback=nal_callback;
     b->nal_cb->cb_dist=nal_dist;
 
-    pid_request = args->nia_requested_pid;
-    desired = *args->nia_limits;
     nal_type = args->nia_nal_type;
 
-    actual = desired;
-    LIMIT(desired.max_match_entries,actual.max_match_entries,MAX_MES);
-    LIMIT(desired.max_mem_descriptors,actual.max_mem_descriptors,MAX_MDS);
-    LIMIT(desired.max_event_queues,actual.max_event_queues,MAX_EQS);
-    LIMIT(desired.max_atable_index,actual.max_atable_index,MAX_ACLS);
-    LIMIT(desired.max_ptable_index,actual.max_ptable_index,MAX_PTLS);
-
-    set_address(b,pid_request);
+    /* Wierd, but this sets b->nal_cb->ni.{nid,pid}, which lib_init() is
+     * about to do from the process_id passed to it...*/
+    set_address(b,args->nia_requested_pid);
 
+    process_id.pid = b->nal_cb->ni.pid;
+    process_id.nid = b->nal_cb->ni.nid;
+    
     if (nal_table[nal_type]) rc=(*nal_table[nal_type])(b);
     /* initialize the generic 'library' level code */
 
-    rc = lib_init(b->nal_cb, 
-                  b->nal_cb->ni.nid,
-                  b->nal_cb->ni.pid,
-                 10,
-                 actual.max_ptable_index,
-                 actual.max_atable_index);
+    rc = lib_init(b->nal_cb, process_id, 
+                  args->nia_requested_limits, 
+                  args->nia_actual_limits);
 
     /*
      * Whatever the initialization returned is passed back to the
@@ -207,18 +207,17 @@ void *nal_thread(void *z)
      */
     /* this should perform error checking */
     pthread_mutex_lock(&p->mutex);
-    p->nal_flags |= rc ? NAL_FLAG_STOPPED : NAL_FLAG_RUNNING;
+    p->nal_flags |= (rc != PTL_OK) ? NAL_FLAG_STOPPED : NAL_FLAG_RUNNING;
     pthread_cond_broadcast(&p->cond);
     pthread_mutex_unlock(&p->mutex);
 
-    if (!rc) {
+    if (rc == PTL_OK) {
         /* the thunk function is called each time the timer loop
            performs an operation and returns to blocking mode. we
            overload this function to inform the api side that
            it may be interested in looking at the event queue */
-        register_thunk(wakeup_topside,b);
+        register_thunk(check_stopping,b);
         timer_loop();
     }
     return(0);
 }
-#undef LIMIT