Changeset 8397 for branches/cu-security-branch/src/io/bmi/bmi.c

Timestamp:

06/18/10 20:02:50 (3 years ago)

Author:

nlmills

Message:

initial merge with Orange-Branch. much will be broken

Location:

branches/cu-security-branch

Files:

• . (modified) (1 prop)
• src/io/bmi (modified) (1 prop)
• src/io/bmi/bmi.c (modified) (17 diffs)

branches/cu-security-branch

@@ -3 +3 @@
 aclocal.m4
 autom4te.cache
-config.status
-Makefile
-pvfs2-config.h
-module.mk

@@ -3 +3 @@
 aclocal.m4
 autom4te.cache
-config.status
-Makefile
-pvfs2-config.h
-module.mk

branches/cu-security-branch/src/io/bmi/bmi.c

@@ -50 +50 @@
     struct qlist_head link;
     BMI_addr_t addr;
+};
+
+/*
+ * BMI trigger to reap all method resources for inactive addresses.
+ */
+static QLIST_HEAD(bmi_addr_force_drop_list);
+static gen_mutex_t bmi_addr_force_drop_list_mutex = GEN_MUTEX_INITIALIZER;
+struct drop_item
+{
+    struct qlist_head link;
+    char  *method_name;
 };
 
@@ -70 +81 @@
 #ifdef __STATIC_METHOD_BMI_PORTALS__
 extern struct bmi_method_ops bmi_portals_ops;
+#endif
+#ifdef __STATIC_METHOD_BMI_ZOID__
+extern struct bmi_method_ops bmi_zoid_ops;
 #endif
 
@@ -88 +102 @@
     &bmi_portals_ops,
 #endif
+#ifdef __STATIC_METHOD_BMI_ZOID__
+    &bmi_zoid_ops,
+#endif
     NULL
 };
@@ -110 +127 @@
 
 static struct bmi_method_ops **active_method_table = NULL;
-static struct {
+
+struct method_usage_t {
     int iters_polled;  /* how many iterations since this method was polled */
     int iters_active;  /* how many iterations since this method had action */
     int plan;
-} *method_usage = NULL;
+    int flags;
+};
+
+static struct method_usage_t * expected_method_usage = NULL;
+static struct method_usage_t * unexpected_method_usage = NULL;
+
 static const int usage_iters_starvation = 100000;
 static const int usage_iters_active = 10000;
@@ -122 +145 @@
     int flags);
 static void bmi_addr_drop(ref_st_p tmp_ref);
+static void bmi_addr_force_drop(ref_st_p ref, ref_list_p ref_list);
 static void bmi_check_forget_list(void);
+static void bmi_check_addr_force_drop (void);
 
 /** Initializes the BMI layer.  Must be called before any other BMI
@@ -518 +543 @@
     known_method_count = 0;
 
-    if (method_usage)
-        free(method_usage);
+    if (expected_method_usage)
+        free(expected_method_usage);
+
+    if (unexpected_method_usage)
+       free(unexpected_method_usage);
 
     /* destroy the reference list */
@@ -901 +929 @@
  */
 static void
-construct_poll_plan(int nmeth, int *idle_time_ms)
+construct_poll_plan(struct method_usage_t * method_usage,
+      int nmeth, int *idle_time_ms)
 {
     int i, numplan;
@@ -910 +939 @@
         ++method_usage[i].iters_active;
         method_usage[i].plan = 0;
-        if (method_usage[i].iters_active <= usage_iters_active) {
+        if ((method_usage[i].iters_active <= usage_iters_active) &&
+            (!(method_usage[i].flags & BMI_METHOD_FLAG_NO_POLLING))){
             /* recently busy, poll */
             if (0) gossip_debug(GOSSIP_BMI_DEBUG_CONTROL,
@@ -967 +997 @@
     /* figure out if we need to drop any stale addresses */
     bmi_check_forget_list();
+    bmi_check_addr_force_drop();
 
     gen_mutex_lock(&active_method_count_mutex);
@@ -977 +1008 @@
     *outcount = 0;
 
-    construct_poll_plan(tmp_active_method_count, &max_idle_time_ms);
+    construct_poll_plan(unexpected_method_usage,
+          tmp_active_method_count, &max_idle_time_ms);
 
     while (position < incount && i < tmp_active_method_count)
     {
-        if (method_usage[i].plan) {
+        if (unexpected_method_usage[i].plan) {
             ret = active_method_table[i]->testunexpected(
                 (incount - position), &tmp_outcount,
@@ -993 +1025 @@
             position += tmp_outcount;
             (*outcount) += tmp_outcount;
-            method_usage[i].iters_polled = 0;
+            unexpected_method_usage[i].iters_polled = 0;
             if (ret)
-                method_usage[i].iters_active = 0;
+                unexpected_method_usage[i].iters_active = 0;
         }
         i++;
@@ -1074 +1106 @@
     }
 
-    construct_poll_plan(tmp_active_method_count, &max_idle_time_ms);
+    construct_poll_plan(expected_method_usage,
+          tmp_active_method_count, &max_idle_time_ms);
 
     while (position < incount && i < tmp_active_method_count)
     {
-        if (method_usage[i].plan) {
+        if (expected_method_usage[i].plan) {
             ret = active_method_table[i]->testcontext(
                 incount - position, 
@@ -1096 +1129 @@
             position += tmp_outcount;
             (*outcount) += tmp_outcount;
-            method_usage[i].iters_polled = 0;
+            expected_method_usage[i].iters_polled = 0;
             if (ret)
-                method_usage[i].iters_active = 0;
+                expected_method_usage[i].iters_active = 0;
         }
         i++;
@@ -1202 +1235 @@
     new_buffer = tmp_ref->interface->memalloc(size, send_recv);
 
+    /* initialize buffer, if not NULL. */
+    if (new_buffer)
+    {
+       memset(new_buffer,0,size);
+    }
     return (new_buffer);
 }
@@ -1981 +2019 @@
 
 /*
+ * Signal BMI to drop inactive connections for this method.
+ */
+void bmi_method_addr_drop_callback (char* method_name)
+{
+    struct drop_item *item =
+        (struct drop_item *) malloc(sizeof(struct drop_item));
+
+    /*
+     * If we can't allocate, just return.
+     * Maybe this will succeed next time.
+     */
+    if (!item) return;
+
+    item->method_name = method_name;
+    
+    gen_mutex_lock(&bmi_addr_force_drop_list_mutex);
+    qlist_add(&item->link, &bmi_addr_force_drop_list);
+    gen_mutex_unlock(&bmi_addr_force_drop_list_mutex);
+
+    return;
+}
+
+
+/**
+ * Try to increase method_usage_t struct to include room for a new method.
+ */
+static int grow_method_usage (struct method_usage_t ** p, int newflags)
+{
+    struct method_usage_t * x = *p;
+    *p = malloc((active_method_count + 1) * sizeof(**p));
+    if (!*p) {
+        *p = x;
+        return 0;
+    }
+    if (active_method_count) {
+        memcpy(*p, x, active_method_count * sizeof(**p));
+        free(x);
+    }
+    memset(&((*p)[active_method_count]), 0, sizeof(**p));
+    (*p)[active_method_count].flags = newflags;
+
+    return 1;
+ }
+
+/*
  * Attempt to insert this name into the list of active methods,
  * and bring it up.
@@ -2030 +2113 @@
     active_method_table[active_method_count] = meth;
 
-    x = method_usage;
-    method_usage = malloc((active_method_count + 1) * sizeof(*method_usage));
-    if (!method_usage) {
-        method_usage = x;
-        return -ENOMEM;
-    }
-    if (active_method_count) {
-        memcpy(method_usage, x, active_method_count * sizeof(*method_usage));
-        free(x);
-    }
-    memset(&method_usage[active_method_count], 0, sizeof(*method_usage));
+    if (!grow_method_usage (&unexpected_method_usage, meth->flags))
+       return -ENOMEM;
+
+    /**
+     * If we run out of memory here, the unexpected_method_usage will be
+     * larger than strictly required but there is no memory leak.
+     */
+
+    if (!grow_method_usage (&expected_method_usage, meth->flags))
+       return -ENOMEM;
 
     ++active_method_count;
@@ -2220 +2302 @@
 }
 
+
+/* bmi_addr_force_drop
+ *
+ * Destroys a complete BMI address, including forcing the method to clean up 
+ * its portion.
+ *
+ * NOTE: must be called with ref list mutex held 
+ */
+static void bmi_addr_force_drop(ref_st_p ref, ref_list_p ref_list)
+{
+    gossip_debug(GOSSIP_BMI_DEBUG_CONTROL,
+                 "[BMI CONTROL]: %s: bmi discarding address: %llu\n",
+                 __func__, llu(ref->bmi_addr));
+
+    ref_list_rem(ref_list, ref->bmi_addr);
+    dealloc_ref_st(ref);
+
+    return;
+}
+
+/*
+ * bmi_check_addr_force_drop
+ *
+ * Checks to see if any method has requested freeing resources.
+ */
+static void bmi_check_addr_force_drop (void)
+{
+    struct drop_item *drop_item = NULL;
+    ref_st_p          ref_item = NULL;
+
+    gen_mutex_lock(&bmi_addr_force_drop_list_mutex);
+    while (!qlist_empty(&bmi_addr_force_drop_list))
+    {
+        drop_item = qlist_entry(qlist_pop(&bmi_addr_force_drop_list),
+                                struct drop_item,
+                                link);
+        gen_mutex_unlock(&bmi_addr_force_drop_list_mutex);
+        gen_mutex_lock(&ref_mutex);
+        qlist_for_each_entry(ref_item, cur_ref_list, list_link)
+        {
+             if ((ref_item->ref_count == 0) &&
+                 (ref_item->interface->method_name == drop_item->method_name))
+             {
+                 bmi_addr_force_drop(ref_item, cur_ref_list);
+             }
+        }
+        gen_mutex_unlock(&ref_mutex);
+        gen_mutex_lock(&bmi_addr_force_drop_list_mutex);
+    }
+    gen_mutex_unlock(&bmi_addr_force_drop_list_mutex);
+
+    return;
+}
+
 /*
  * Local variables:

@@ -3 +3 @@
 aclocal.m4
 autom4te.cache
-config.status
-Makefile
-pvfs2-config.h
-module.mk