Changeset 8397 for branches/cu-security-branch/src/common/misc

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/common/misc (modified) (1 prop)
• src/common/misc/mkspace.c (modified) (9 diffs)
• src/common/misc/mkspace.h (modified) (2 diffs)
• src/common/misc/msgpairarray.h (modified) (1 diff)
• src/common/misc/msgpairarray.sm (modified) (10 diffs)
• src/common/misc/pint-cached-config.c (modified) (1 diff)
• src/common/misc/pint-cached-config.h (modified) (1 diff)
• src/common/misc/pint-event.c (modified) (4 diffs)
• src/common/misc/pint-event.h (modified) (2 diffs)
• src/common/misc/pint-hint.c (modified) (1 diff)
• src/common/misc/pint-mem.c (modified) (2 diffs)
• src/common/misc/pint-util.c (modified) (4 diffs)
• src/common/misc/pvfs2-debug.c (modified) (1 diff)
• src/common/misc/pvfs2-internal.h (modified) (1 diff)
• src/common/misc/pvfs2-util.c (modified) (5 diffs)
• src/common/misc/server-config.c (modified) (20 diffs)
• src/common/misc/server-config.h (modified) (3 diffs)
• src/common/misc/state-machine-fns.c (modified) (1 diff)
• src/common/misc/state-machine.h (modified) (2 diffs)
• src/common/misc/str-utils.c (modified) (6 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/common/misc/mkspace.c

@@ -112 +112 @@
 
 int pvfs2_mkspace(
-    char *storage_space,
+    char *data_path,
+    char *meta_path,
     char *collection,
     TROVE_coll_id coll_id,
@@ -135 +136 @@
     TROVE_handle lost_and_found_dirdata_handle = TROVE_HANDLE_NULL;
 
-    mkspace_print(verbose,"Storage space: %s\n",storage_space);
+    mkspace_print(verbose,"Data storage space     : %s\n",data_path);
+    mkspace_print(verbose,"Metadata storage space : %s\n", meta_path);
     mkspace_print(verbose,"Collection   : %s\n",collection);
     mkspace_print(verbose,"ID           : %d\n",coll_id);
@@ -160 +162 @@
         ret = trove_initialize(TROVE_METHOD_DBPF, 
                                NULL, 
-                               storage_space, 
+                               data_path,
+                               meta_path,
                                0);
         if (ret > -1)
         {
-            gossip_err("error: storage space %s already "
-                       "exists; aborting!\n",storage_space);
-            return -1;
-        }
-
-        ret = trove_storage_create(TROVE_METHOD_DBPF, storage_space, NULL, &op_id);
+            gossip_err("error: storage space %s or %s already "
+                       "exists; aborting!\n",data_path,meta_path);
+            return -1;
+        }
+
+        ret = trove_storage_create(TROVE_METHOD_DBPF, data_path, meta_path, NULL, &op_id);
         if (ret != 1)
         {
@@ -180 +183 @@
     ret = trove_initialize(
         TROVE_METHOD_DBPF, NULL, 
-        storage_space, 0);
+        data_path, meta_path, 0);
     if (ret < 0)
     {
@@ -187 +190 @@
     }
 
-    mkspace_print(verbose,"info: created storage space '%s'.\n",
-                  storage_space);
+    mkspace_print(verbose,"info: created data storage space '%s'.\n",
+                  data_path);
+    mkspace_print(verbose,"info: created metadata storage space '%s'.\n",
+                  meta_path);
 
     /* try to look up collection used to store file system */
@@ -637 +642 @@
 
 int pvfs2_rmspace(
-    char *storage_space,
+    char *data_path,
+    char *meta_path,
     char *collection,
     TROVE_coll_id coll_id,
@@ -652 +658 @@
         ret = trove_initialize(
             TROVE_METHOD_DBPF, NULL,
-            storage_space, 0);
+            data_path, meta_path, 0);
         if (ret == -1)
         {
-            gossip_err("error: storage space %s does not "
-                       "exist; aborting!\n", storage_space);
+            gossip_err("error: storage space %s or %s does not "
+                       "exist; aborting!\n", data_path, meta_path);
             return -1;
         }
@@ -674 +680 @@
     if (!remove_collection_only)
     {
-        ret = trove_storage_remove(
-            TROVE_METHOD_DBPF, storage_space, NULL, &op_id);
+        ret = trove_storage_remove(TROVE_METHOD_DBPF, data_path, meta_path, 
+                                   NULL, &op_id);
         /*
          * it is a bit weird to do a trove_finaliz() prior to blowing away
@@ -683 +689 @@
         trove_finalize(TROVE_METHOD_DBPF);
         mkspace_print(
-            verbose, "PVFS2 Storage Space %s removed %s\n",
-            storage_space, (((ret == 1) || (ret == -TROVE_ENOENT)) ?
+            verbose, "PVFS2 Storage Space %s and %s removed %s\n",
+            data_path, meta_path, (((ret == 1) || (ret == -TROVE_ENOENT)) ?
                             "successfully" : "with errors"));
 

branches/cu-security-branch/src/common/misc/mkspace.h

@@ -14 +14 @@
 
 int pvfs2_mkspace(
-    char *storage_space,
+    char *data_path,
+    char *meta_path,
     char *collection,
     TROVE_coll_id coll_id,
@@ -24 +25 @@
 
 int pvfs2_rmspace(
-    char *storage_space,
+    char *data_path,
+    char *meta_path,
     char *collection,
     TROVE_coll_id coll_id,

branches/cu-security-branch/src/common/misc/msgpairarray.h

@@ -49 +49 @@
     /* server address */
     PVFS_BMI_addr_t svr_addr;
+
+    /*session identifier between send and rcvs*/
+    /*note:  server-side i/o machine uses the session_tag as the flow */
+    /*descriptor tag.                                                 */
+    bmi_msg_tag_t session_tag;
 
     /* req and encoded_req are used to send a request */

branches/cu-security-branch/src/common/misc/msgpairarray.sm

@@ -95 +95 @@
     PINT_sm_msgpair_state *msg_p = NULL;
 
+    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing msgpairarray_init...\n");
+    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tbase frame:%d\tframe count:%d\n"
+                                    ,smcb->base_frame,smcb->frame_count);
+
     gossip_debug(GOSSIP_MSGPAIR_DEBUG, "(%p) msgpairarray state: init "
                  "(%d msgpair(s))\n", smcb, mop->count);
@@ -116 +120 @@
         msg_p->retry_count = 0;
         msg_p->complete = 0;
+
     }
     return SM_ACTION_COMPLETE;
@@ -233 +238 @@
                 PINT_ENCODE_RESP, msg_p->req.op, msg_p->enc_type);
 
+
             msg_p->encoded_resp_p = BMI_memalloc(
                 msg_p->svr_addr, msg_p->max_resp_sz, BMI_RECV);
@@ -245 +251 @@
 
         session_tag = PINT_util_get_next_tag();
+
+        /*store the session tag for this msgpair, so the msgpair completion */
+        /*function can pass it to the caller of msgpairarray.               */
+        msg_p->session_tag = session_tag;
 
         gossip_debug(GOSSIP_MSGPAIR_DEBUG, "%s: sm %p msgpair %d: "
@@ -301 +311 @@
             {
                 PINT_encode_release(&msg_p->encoded_req, PINT_ENCODE_REQ);
+                memset(&msg_p->encoded_req,0,sizeof(msg_p->encoded_req));
                 BMI_memfree(msg_p->svr_addr,msg_p->encoded_resp_p,
                             msg_p->max_resp_sz, BMI_RECV);
@@ -489 +500 @@
     gossip_debug(GOSSIP_MSGPAIR_DEBUG, "(%p) msgpairarray state: "
                  "completion_fn\n", smcb);
+    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing msgpairarray_completion_fn..\n");
 
     for (i = 0; i < mop->count; i++)
@@ -546 +558 @@
         if (msg_p->comp_fn != NULL)
         {
+            gossip_debug(GOSSIP_MIRROR_DEBUG,"\texecuting msg_p->comp_fn..\n");
             /* If we call the completion function, store the result on
              * a per message pair basis.  Also store some non-zero
@@ -590 +603 @@
         }
 
+        memset(&msg_p->encoded_req,0,sizeof(msg_p->encoded_req));
         msg_p->encoded_resp_p = NULL;
         msg_p->max_resp_sz = 0;
@@ -601 +615 @@
         gossip_debug(GOSSIP_MSGPAIR_DEBUG, "%s: sm %p msgpair %d "
                      "marked complete\n", __func__, smcb, i);
-    }
+    }/*end for*/
 
     if (need_retry) {
@@ -783 +797 @@
     {
         PINT_encode_release(encoded_req_p, PINT_ENCODE_REQ);
+        memset(encoded_req_p,0,sizeof(*encoded_req_p));
 
         PINT_decode_release(decoded_resp_p, PINT_DECODE_RESP);
+        memset(decoded_resp_p,0,sizeof(*decoded_resp_p));
 
         BMI_memfree(*svr_addr_p, encoded_resp_p, max_resp_sz, BMI_RECV);
+        encoded_resp_p = NULL;
 
         ret = 0;

branches/cu-security-branch/src/common/misc/pint-cached-config.c

@@ -1788 +1788 @@
 }
 
+/* PINT_cached_config_server_names()
+ *
+ * Returns a list of pointers to the IO server names currently running in this   
+ * file system.
+ *
+ * returns 0 on success, -PVFS_error on failure
+ */
+int PINT_cached_config_io_server_names( char ***list
+                                      , int *size
+                                      , PVFS_fs_id fsid)
+{
+    int i;
+    struct qlist_head *hash_link = NULL;
+    struct config_fs_cache_s *cur_config_cache = NULL;
+
+    assert(PINT_fsid_config_cache_table);
+
+    hash_link = qhash_search(PINT_fsid_config_cache_table,&(fsid));
+    if(!hash_link)
+    {
+        return(-PVFS_ENOENT);
+    }
+
+    cur_config_cache = qlist_entry(
+        hash_link, struct config_fs_cache_s, hash_link);
+
+    assert(cur_config_cache);
+
+    *size = cur_config_cache->io_server_count;
+
+    *list = malloc(sizeof(char *) * (*size));
+
+    if (! (*list) )
+       return(-PVFS_ENOMEM);
+
+    memset(*list,0,sizeof(char *) * (*size));
+
+    for (i=0; i<(*size); i++)
+    {
+        /*addr_string originates from the alias mapping->bmi_address*/
+        (*list)[i] = cur_config_cache->io_server_array[i].addr_string;
+    }
+
+   return(0);
+}
+
 /*
  * Local variables:

branches/cu-security-branch/src/common/misc/pint-cached-config.h

@@ -136 +136 @@
     struct server_configuration_s *config);
 
+int PINT_cached_config_io_server_names(
+    char ***list, 
+    int *size,
+    PVFS_fs_id fsid);
+
 #endif /* __PINT_CACHED_CONFIG_H */
 

branches/cu-security-branch/src/common/misc/pint-event.c

@@ -67 +67 @@
 static void PINT_event_tau_thread_init(char* gname);
 static void PINT_event_tau_thread_fini(void);
+static void PINT_event_free( struct PINT_event *p );
+static void PINT_group_free( strcut PINT_group *g );
 
 #endif /* HAVE_TAU */
+
+static void PINT_event_free( struct PINT_event *p )
+{
+    if( p != NULL )
+    {
+        if( p->name != NULL )
+        {
+            free( p->name );
+        }
+        free( p );
+    }
+    return;
+}
+
+static void PINT_group_free( struct PINT_group *g )
+{
+    if( g != NULL )
+    {
+        if( g->name != NULL )
+        {
+            free( g->name );
+        }
+        free( g );
+    }
+    return;
+}
+
 
 static int PINT_group_compare(void *key, struct qhash_head *link)
@@ -105 +134 @@
     if(!groups_table)
     {
-        qhash_finalize(events_table);
+        qhash_destroy_and_finalize( events_table, struct PINT_event, link, 
+            PINT_event_free);
         return -PVFS_ENOMEM;
     }
@@ -112 +142 @@
     if(ret < 0)
     {
-        qhash_finalize(events_table);
-        qhash_finalize(groups_table);
+        qhash_destroy_and_finalize( groups_table, struct PINT_group, link, 
+            PINT_group_free );
+        qhash_destroy_and_finalize( events_table, struct PINT_event, link, 
+            PINT_event_free);
+
         return ret;
     }
@@ -131 +164 @@
 }
 
+void PINT_event_free_bucket_resources(struct qhash_table *qht, unsigned long distance_from_link)
+{
+  char **name = NULL;
+  char *start_of_structure = NULL; 
+  struct qhash_head *bucket_entry = NULL;
+  struct qhash_head *bucket = NULL;
+  struct qhash_head *next = NULL;
+  int i;
+
+  for (i=0; i<qht->table_size; i++)
+  {
+     bucket = &(qht->array[i]);
+     if (bucket==bucket->next && bucket==bucket->prev)
+        continue;  //this bucket is empty
+     
+     /*for each entry, deallocate the name string and the entry structure*/
+     for (bucket_entry=bucket->next; bucket_entry != bucket; bucket_entry = next)
+     {
+         start_of_structure = (char *)((char *)bucket_entry - distance_from_link);
+         name = (char **)start_of_structure;
+         if (*name)
+         {
+            free(*name);
+            *name=NULL;
+         }
+         name=NULL;
+
+         next = bucket_entry->next;
+         free(start_of_structure);
+         start_of_structure=NULL;
+     }/*end for*/
+
+
+  } /*end for*/
+
+  return;
+}
+
+
 void PINT_event_finalize(void)
 {
-
 #if defined(HAVE_TAU)
     PINT_event_tau_fini();
 #endif
 
-    qhash_finalize(groups_table);
-    qhash_finalize(events_table);
+    /*free the buckets in the tables and the tables themselves*/
+    /* need to free contents as well */
+    qhash_destroy_and_finalize( groups_table, struct PINT_group, link, 
+        PINT_group_free );
+    qhash_destroy_and_finalize( events_table, struct PINT_event, link, 
+        PINT_event_free);
     return;
 }

branches/cu-security-branch/src/common/misc/pint-event.h

@@ -9 +9 @@
 
 #include "pvfs2-types.h"
+#include "quickhash.h"
 
 typedef PVFS_id_gen_t PINT_event_type;
@@ -31 +32 @@
 
 void PINT_event_finalize(void);
+void PINT_event_free_bucket_resources(struct qhash_table *qt
+                                     ,unsigned long distance_from_link);
 
 int PINT_event_enable(const char *events);

branches/cu-security-branch/src/common/misc/pint-hint.c

@@ -565 +565 @@
     while(h)
     {
-        if(!strcmp(hint->type_string, name))
+        if(!strcmp(h->type_string, name))
         {
             if(length)

branches/cu-security-branch/src/common/misc/pint-mem.c

@@ -8 +8 @@
 #include <errno.h>
 #include <stdlib.h>
+#include <string.h>
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif
 
-#include "pint-mem.h"
+/* prototype definitions */
+inline void* PINT_mem_aligned_alloc(size_t size, size_t alignment);
+inline void PINT_mem_aligned_free(void *ptr);
 
 /* PINT_mem_aligned_alloc()
@@ -33 +36 @@
         return NULL;
     }
+    memset(ptr, 0, size);
     return ptr;
 }

branches/cu-security-branch/src/common/misc/pint-util.c

@@ -154 +154 @@
             if (dest->u.dir.hint.dist_params_len > 0)
             {
-                dest->u.dir.hint.dist_params = strdup(src->u.dir.hint.dist_params);
+                dest->u.dir.hint.dist_params 
+                        = strdup(src->u.dir.hint.dist_params);
                 if (dest->u.dir.hint.dist_params == NULL)
                 {
@@ -219 +220 @@
             }
 
+          if(src->mask & PVFS_ATTR_META_MIRROR_DFILES)
+            {
+                PVFS_size df_array_size = src->u.meta.dfile_count         *
+                                          src->u.meta.mirror_copies_count *
+                                          sizeof(PVFS_handle);
+
+                if (df_array_size)
+                {
+                    if (   (dest->mask & PVFS_ATTR_META_MIRROR_DFILES) 
+                        && (dest->u.meta.dfile_count > 0)
+                        && (dest->u.meta.mirror_copies_count > 0) )
+                    {
+                        if (dest->u.meta.mirror_dfile_array)
+                        {
+                            free(dest->u.meta.mirror_dfile_array);
+                            dest->u.meta.mirror_dfile_array = NULL;
+                        }
+                    }
+                    dest->u.meta.mirror_dfile_array = malloc(df_array_size);
+                    if (!dest->u.meta.mirror_dfile_array)
+                    {
+                        return ret;
+                    }
+                    memcpy(dest->u.meta.mirror_dfile_array,
+                           src->u.meta.mirror_dfile_array, df_array_size);
+                }
+                else
+                {
+                    dest->u.meta.mirror_dfile_array = NULL;
+                }
+                dest->u.meta.mirror_copies_count 
+                   = src->u.meta.mirror_copies_count;
+            }
+
+
             if(src->mask & PVFS_ATTR_META_DIST)
             {
@@ -284 +320 @@
                 }
             }
+            if (attr->mask & PVFS_ATTR_META_MIRROR_DFILES)
+            {
+                if (attr->u.meta.mirror_dfile_array)
+                {
+                    free(attr->u.meta.mirror_dfile_array);
+                    attr->u.meta.mirror_dfile_array = NULL;
+                }
+            }
             if (attr->mask & PVFS_ATTR_META_DIST)
             {
@@ -307 +351 @@
         else if (attr->objtype == PVFS_TYPE_DIRECTORY)
         {
-            if ((attr->mask & PVFS_ATTR_DIR_HINT) || (attr->mask & PVFS_ATTR_DIR_DIRENT_COUNT))
+            if ((attr->mask & PVFS_ATTR_DIR_HINT) || 
+                (attr->mask & PVFS_ATTR_DIR_DIRENT_COUNT))
             {
                 if (attr->u.dir.hint.dist_name)

branches/cu-security-branch/src/common/misc/pvfs2-debug.c

@@ -11 +11 @@
 
 #include "pvfs2-debug.h"
-
-/* a private internal type */
-typedef struct 
-{
-    const char *keyword;
-    uint64_t mask_val;
-} __keyword_mask_t;
-
-#define __DEBUG_ALL ((uint64_t) -1)
-
-/* map all config keywords to pvfs2 debug masks here */
-static __keyword_mask_t s_keyword_mask_map[] =
-{
-    /* Log trove debugging info.  Same as 'trove'.*/
-    { "storage", GOSSIP_TROVE_DEBUG },
-    /* Log trove debugging info.  Same as 'storage'. */
-    { "trove", GOSSIP_TROVE_DEBUG },
-    /* Log trove operations. */
-    { "trove_op", GOSSIP_TROVE_OP_DEBUG },
-    /* Log network debug info. */
-    { "network", GOSSIP_BMI_DEBUG_ALL },
-    /* Log server info, including new operations. */
-    { "server", GOSSIP_SERVER_DEBUG },
-    /* Log client sysint info.  This is only useful for the client. */
-    { "client", GOSSIP_CLIENT_DEBUG },
-    /* Debug the varstrip distribution */
-    { "varstrip", GOSSIP_VARSTRIP_DEBUG },
-    /* Log job info */
-    { "job", GOSSIP_JOB_DEBUG },
-    /* Debug PINT_process_request calls.  EXTREMELY verbose! */
-    { "request", GOSSIP_REQUEST_DEBUG },
-    /* Log request scheduler events */
-    { "reqsched", GOSSIP_REQ_SCHED_DEBUG },
-    /* Log the flow protocol events, including flowproto_multiqueue */
-    { "flowproto", GOSSIP_FLOW_PROTO_DEBUG },
-    /* Log flow calls */
-    { "flow", GOSSIP_FLOW_DEBUG },
-    /* Debug the client name cache.  Only useful on the client. */
-    { "ncache", GOSSIP_NCACHE_DEBUG },
-    /* Debug read-ahead cache events.  Only useful on the client. */
-    { "mmaprcache", GOSSIP_MMAP_RCACHE_DEBUG },
-    /* Debug the attribute cache.  Only useful on the client. */
-    { "acache", GOSSIP_ACACHE_DEBUG },
-    /* Log/Debug distribution calls */
-    { "distribution", GOSSIP_DIST_DEBUG },
-    /* Debug the server-side dbpf attribute cache */
-    { "dbpfattrcache", GOSSIP_DBPF_ATTRCACHE_DEBUG },
-    /* Debug the client lookup state machine. */
-    { "lookup", GOSSIP_LOOKUP_DEBUG },
-    /* Debug the client remove state macine. */
-    { "remove", GOSSIP_REMOVE_DEBUG },
-    /* Debug the server getattr state machine. */
-    { "getattr", GOSSIP_GETATTR_DEBUG },
-    /* Debug the server setattr state machine. */
-    { "setattr", GOSSIP_SETATTR_DEBUG },
-    /* vectored getattr server state machine */
-    { "listattr", GOSSIP_LISTATTR_DEBUG },
-    /* Debug the client and server get ext attributes SM. */
-    { "geteattr", GOSSIP_GETEATTR_DEBUG },
-    /* Debug the client and server set ext attributes SM. */
-    { "seteattr", GOSSIP_SETEATTR_DEBUG },
-    /* Debug the readdir operation (client and server) */
-    { "readdir", GOSSIP_READDIR_DEBUG },
-    /* Debug the mkdir operation (server only) */
-    { "mkdir", GOSSIP_MKDIR_DEBUG },
-    /* Debug the io operation (reads and writes) 
-     * for both the client and server */
-    { "io", GOSSIP_IO_DEBUG },
-    /* Debug the server's open file descriptor cache */
-    { "open_cache", GOSSIP_DBPF_OPEN_CACHE_DEBUG }, 
-    /* Debug permissions checking on the server */
-    { "permissions", GOSSIP_PERMISSIONS_DEBUG }, 
-    /* Debug the cancel operation */
-    { "cancel", GOSSIP_CANCEL_DEBUG },
-    /* Debug the msgpair state machine */
-    { "msgpair", GOSSIP_MSGPAIR_DEBUG },
-    /* Debug the client core app */
-    { "clientcore", GOSSIP_CLIENTCORE_DEBUG },
-    /* Debug the client timing state machines (job timeout, etc.) */
-    { "clientcore_timing", GOSSIP_CLIENTCORE_TIMING_DEBUG },
-    /* network encoding */
-    { "endecode", GOSSIP_ENDECODE_DEBUG },
-    /* Show server file (metadata) accesses (both modify and read-only). */ 
-    { "access", GOSSIP_ACCESS_DEBUG },
-    /* Show more detailed server file accesses */
-    { "access_detail", GOSSIP_ACCESS_DETAIL_DEBUG },
-    /* Debug the listeattr operation */
-    { "listeattr", GOSSIP_LISTEATTR_DEBUG },
-    /* Debug the state machine management code */
-    { "sm", GOSSIP_STATE_MACHINE_DEBUG },
-    /* Debug the metadata dbpf keyval functions */
-    { "keyval", GOSSIP_DBPF_KEYVAL_DEBUG },
-    /* Debug the metadata sync coalescing code */
-    { "coalesce", GOSSIP_DBPF_COALESCE_DEBUG },
-    /* Display the  hostnames instead of IP addrs in debug output */
-    { "access_hostnames", GOSSIP_ACCESS_HOSTNAMES },
-    /* Show the client device events */
-    { "user_dev", GOSSIP_USER_DEV_DEBUG },
-    /* Debug security module */
-    { "security", GOSSIP_SECURITY_DEBUG },
-    /* Debug the fsck tool */
-    { "fsck", GOSSIP_FSCK_DEBUG },
-    /* Debug the bstream code */
-    { "bstream", GOSSIP_BSTREAM_DEBUG },
-    /* Debug trove in direct io mode */
-    {"directio", GOSSIP_DIRECTIO_DEBUG},
-    /* Everything except the periodic events.  Useful for debugging */
-    { "verbose",
-      (__DEBUG_ALL & ~(GOSSIP_PERFCOUNTER_DEBUG | GOSSIP_STATE_MACHINE_DEBUG |
-                       GOSSIP_ENDECODE_DEBUG | GOSSIP_USER_DEV_DEBUG))
-    },
-    /* No debug output */
-    { "none", GOSSIP_NO_DEBUG },
-    /* Everything */
-    { "all",  __DEBUG_ALL }
-};
-#undef __DEBUG_ALL
-
-static const int num_keyword_mask_map = (int)           \
-(sizeof(s_keyword_mask_map) / sizeof(__keyword_mask_t));
-
-/* map all kmod keywords to kmod debug masks here */
-static __keyword_mask_t s_kmod_keyword_mask_map[] =
-{
-    {"super" , GOSSIP_SUPER_DEBUG},
-    {"inode" , GOSSIP_INODE_DEBUG},
-    {"file"  , GOSSIP_FILE_DEBUG},
-    {"dir"   , GOSSIP_DIR_DEBUG},
-    {"utils" , GOSSIP_UTILS_DEBUG},
-    {"wait"  , GOSSIP_WAIT_DEBUG},
-    {"acl"   , GOSSIP_ACL_DEBUG},
-    {"dcache", GOSSIP_DCACHE_DEBUG},
-    {"dev"   , GOSSIP_DEV_DEBUG},
-    {"name"  , GOSSIP_NAME_DEBUG},
-    {"bufmap", GOSSIP_BUFMAP_DEBUG},
-    {"cache" , GOSSIP_CACHE_DEBUG},
-    {"proc"  , GOSSIP_PROC_DEBUG},
-    {"xattr" , GOSSIP_XATTR_DEBUG},
-    {"init"  , GOSSIP_INIT_DEBUG},
-    {"none"  , GOSSIP_NO_DEBUG},
-    {"all"   , GOSSIP_MAX_DEBUG}
-};
-
-static const int num_kmod_keyword_mask_map = (int)           \
-(sizeof(s_kmod_keyword_mask_map) / sizeof(__keyword_mask_t));
 
 static uint64_t debug_to_mask(__keyword_mask_t *mask_map, 

branches/cu-security-branch/src/common/misc/pvfs2-internal.h

@@ -94 +94 @@
 #define SPECIAL_METAFILE_HINT_KEYSTR    "meta_hint\0"
 #define SPECIAL_METAFILE_HINT_KEYLEN    21
+#define SPECIAL_MIRROR_PARAMS_KEYSTR    "mirror\0"
+#define SPECIAL_MIRROR_PARAMS_KEYLEN    18
+#define SPECIAL_MIRROR_COPIES_KEYSTR    "mirror.copies\0"
+#define SPECIAL_MIRROR_COPIES_KEYLEN    25
+#define SPECIAL_MIRROR_HANDLES_KEYSTR   "mirror.handles\0"
+#define SPECIAL_MIRROR_HANDLES_KEYLEN   26
+#define SPECIAL_MIRROR_STATUS_KEYSTR    "mirror.status\0"
+#define SPECIAL_MIRROR_STATUS_KEYLEN    25
+
 
 #define IO_MAX_REGIONS 64

branches/cu-security-branch/src/common/misc/pvfs2-util.c

@@ -438 +438 @@
         *tmp = 0;
         mntent->mnt_opts = strdup("rw");
+        mntent->fs_id = PVFS_FS_ID_NULL;
         return &s_stat_tab_array[0];
     }
@@ -1075 +1076 @@
     /* Search for mntent by fsid */
     gen_mutex_lock(&s_stat_tab_mutex);
-
     for(i = 0; i < s_stat_tab_count; i++)
     {
@@ -1110 +1110 @@
 
     gen_mutex_unlock(&s_stat_tab_mutex);
-
     return -PVFS_EINVAL;
 }
@@ -1730 +1729 @@
     if (sys_attrmask & PVFS_ATTR_SYS_DFILE_COUNT)
     {
-        attrmask |= PVFS_ATTR_META_DFILES;
+        attrmask |= (PVFS_ATTR_META_DFILES | PVFS_ATTR_META_MIRROR_DFILES);
+    }
+    if (sys_attrmask & PVFS_ATTR_SYS_MIRROR_COPIES_COUNT)
+    {
+        attrmask |= PVFS_ATTR_META_MIRROR_DFILES;
     }
 
@@ -1834 +1837 @@
         sys_mask |= PVFS_ATTR_SYS_DFILE_COUNT;
     }
+    if (obj_mask & PVFS_ATTR_META_MIRROR_DFILES)
+    {
+        sys_mask |= PVFS_ATTR_SYS_MIRROR_COPIES_COUNT;
+    }
     if (obj_mask & PVFS_ATTR_META_DIST)
     {

branches/cu-security-branch/src/common/misc/server-config.c

@@ -35 +35 @@
 
 static DOTCONF_CB(get_logstamp);
-static DOTCONF_CB(get_storage_space);
+static DOTCONF_CB(get_storage_path);
+static DOTCONF_CB(get_data_path);
+static DOTCONF_CB(get_meta_path);
 static DOTCONF_CB(enter_defaults_context);
 static DOTCONF_CB(exit_defaults_context);
@@ -79 +81 @@
 static DOTCONF_CB(get_bmi_module_list);
 static DOTCONF_CB(get_flow_module_list);
+
+static DOTCONF_CB(get_root_squash);
+static DOTCONF_CB(get_root_squash_exceptions);
 static DOTCONF_CB(get_read_only);
+static DOTCONF_CB(get_all_squash);
+static DOTCONF_CB(get_anon_gid);
+static DOTCONF_CB(get_anon_uid);
+
 static DOTCONF_CB(get_handle_recycle_timeout_seconds);
 static DOTCONF_CB(get_flow_buffer_size_bytes);
@@ -346 +355 @@
 
      /* Specifies the beginning of a ExportOptions context.
-      * This groups options specific to a filesystem and related to the 
-      * behavior of how it gets exported to various clients.
+      * This groups options specific to a filesystem and related to the behavior
+      * of how it gets exported to various clients. Most of these options
+      * will affect things like what uids get translated to and so on..
       */
      {"<ExportOptions>",ARG_NONE, enter_export_options_context, NULL,CTX_FILESYSTEM,
@@ -546 +556 @@
          CTX_DEFAULTS|CTX_SERVER_OPTIONS,"50"},
 
-    /* Specifies the local path for the pvfs2 server to use as storage space.
-     * This option specifies the default path for all servers and will appear
+    /* DEPRECATED 
+     * Specifies the local path for the pvfs2 server to use as 
+     * storage space for data files and metadata files. This option should not
+     * be used in conjuction with DataStorageSpace or MetadataStorageSpace. 
+     * This option is only meant as a migration path for configurations where i
+     * users do not want (or don't expect to need to) modify their configuration
+     * to run this version.
+     *
+     * This option specifies the default path for all servers and will appear 
      * in the Defaults context.
      *
@@ -554 +571 @@
      * Example:
      *
-     * StorageSpace /tmp/pvfs.storage
-     */
-    {"StorageSpace",ARG_STR, get_storage_space,NULL,
+     * StorageSpace /tmp/pvfs-data.storage
+     * DEPRECATED.
+     */
+    {"StorageSpace",ARG_STR, get_storage_path,NULL,
+        CTX_DEFAULTS|CTX_SERVER_OPTIONS,NULL},
+
+    /* Specifies the local path for the pvfs2 server to use as storage space 
+     * for data files. This option specifies the default path for all servers 
+     * and will appear in the Defaults context.
+     *
+     * NOTE: This can be overridden in the <ServerOptions> tag on a per-server
+     * basis. Look at the "Option" tag for more details
+     * Example:
+     *
+     * DataStorageSpace /tmp/pvfs-data.storage
+     */
+    {"DataStorageSpace",ARG_STR, get_data_path,NULL,
+        CTX_DEFAULTS|CTX_SERVER_OPTIONS,NULL},
+
+    /* Specifies the local path for the pvfs2 server to use as storage space 
+     * for metadata files. This option specifies the default path for all 
+     * servers and will appear in the Defaults context.
+     *
+     * NOTE: This can be overridden in the <ServerOptions> tag on a per-server
+     * basis. Look at the "Option" tag for more details
+     * Example:
+     *
+     * MetadataStorageSpace /tmp/pvfs-meta.storage
+     */
+    {"MetadataStorageSpace",ARG_STR, get_meta_path,NULL,
         CTX_DEFAULTS|CTX_SERVER_OPTIONS,NULL},
 
@@ -691 +735 @@
      * usec: [%H:%M:%S.%U]
      *
-     * datetime: [%m/%d %H:%M]
+     * datetime: [%m/%d/%Y %H:%M:%S]
      *
      * thread: [%H:%M:%S.%U (%lu)]
@@ -721 +765 @@
      * to the rest of the world.
      */
+
+    /* RootSquash option specifies whether the exported file-system needs to
+    *  squash accesses by root. This is an optional parameter that needs 
+    *  to be specified as part of the ExportOptions
+     * context and is a list of BMI URL specification of client addresses 
+     * for which RootSquash has to be enforced. 
+     *
+     * RootSquash tcp://192.168.2.0@24 tcp://10.0.0.* tcp://192.168.* ...
+     */
+    {"RootSquash", ARG_LIST, get_root_squash, NULL,
+        CTX_EXPORT, ""},
+  
+    /* RootSquashExceptions option specifies exceoptions to the RootSquash 
+     * list. This is an optional parameter that needs to be specified as 
+     * part of the ExportOptions context and is a list of BMI URL 
+     * specification of client addresses for which RootSquash
+     * has to be enforced. 
+     * RootSquash tcp://192.168.2.0@24 tcp://10.0.0.* tcp://192.168.* ...
+     */
+    {"RootSquashExceptions", ARG_LIST, get_root_squash_exceptions, NULL,
+        CTX_EXPORT, ""},
 
     /* ReadOnly option specifies whether the exported file-system needs to
@@ -734 +799 @@
     {"ReadOnly", ARG_LIST,  get_read_only,    NULL,
         CTX_EXPORT, ""},
+
+    /* AllSquash option specifies whether the exported file-system needs to 
+    *  squash all accesses to the file-system to a specified uid/gid!
+     * This is an optional parameter that needs to be specified as part of 
+     * the ExportOptions context and is a list of BMI URL specification of client 
+     * addresses for which AllSquash has to be enforced.
+     * An example:
+     *
+     * AllSquash tcp://192.168.2.0@24 tcp://10.0.0.* tcp://192.168.* ...
+     */
+    {"AllSquash", ARG_LIST, get_all_squash,   NULL,
+        CTX_EXPORT, ""},
+
+    /* AnonUID and AnonGID are 2 integers that tell the servers to translate 
+    *  the requesting clients' uid/gid to the specified ones whenever AllSquash
+    *  is specified!
+     * If these are not specified and AllSquash is specified then the uid used 
+     * will be that of nobody and gid that of nobody.
+     * An example:
+     *
+     * AnonUID 3454
+     * AnonGID 3454
+     */
+
+    {"AnonUID",  ARG_STR,  get_anon_uid,     NULL,
+        CTX_EXPORT, "65534"},
+    {"AnonGID",  ARG_STR,  get_anon_gid,     NULL,
+        CTX_EXPORT, "65534"},
 
     /* The TROVE storage layer has a management component that deals with
@@ -1007 +1100 @@
     }
 
-    if (server_alias_name && !config_s->storage_path)
+    if (server_alias_name && !config_s->data_path)
     {
         gossip_err("Configuration file error. "
-                   "No storage path specified for alias %s.\n", server_alias_name);
+                   "No data storage path specified for alias %s.\n", server_alias_name);
+        return 1;
+    }
+
+    if (server_alias_name && !config_s->meta_path)
+    {
+        gossip_err("Configuration file error. "
+                   "No metadata storage path specified for alias %s.\n", server_alias_name);
         return 1;
     }
@@ -1109 +1209 @@
 
 
-DOTCONF_CB(get_storage_space)
+DOTCONF_CB(get_storage_path)
 {
     struct server_configuration_s *config_s = 
@@ -1118 +1218 @@
         return NULL;
     }
-    if (config_s->storage_path)
-    {
-        free(config_s->storage_path);
-    }
-    config_s->storage_path =
+
+    if( config_s->data_path )
+    {
+        free(config_s->data_path);
+    }
+
+    if( config_s->meta_path )
+    {
+        free(config_s->meta_path);
+    }
+
+    config_s->data_path =
+        (cmd->data.str ? strdup(cmd->data.str) : NULL);
+    config_s->meta_path =
+        (cmd->data.str ? strdup(cmd->data.str) : NULL);
+    return NULL;
+}
+
+DOTCONF_CB(get_data_path)
+{
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+    if(config_s->configuration_context == CTX_SERVER_OPTIONS &&
+       config_s->my_server_options == 0)
+    {
+        return NULL;
+    }
+    if (config_s->data_path)
+    {
+        free(config_s->data_path);
+    }
+
+    config_s->data_path =
+        (cmd->data.str ? strdup(cmd->data.str) : NULL);
+    return NULL;
+}
+
+DOTCONF_CB(get_meta_path)
+{
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+    if(config_s->configuration_context == CTX_SERVER_OPTIONS &&
+       config_s->my_server_options == 0)
+    {
+        return NULL;
+    }
+    if (config_s->meta_path)
+    {
+        free(config_s->meta_path);
+    }
+
+    config_s->meta_path =
         (cmd->data.str ? strdup(cmd->data.str) : NULL);
     return NULL;
@@ -1739 +1886 @@
 }
 
+DOTCONF_CB(get_root_squash)
+{
+    struct filesystem_configuration_s *fs_conf = NULL;
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+
+    fs_conf = (struct filesystem_configuration_s *)
+        PINT_llist_head(config_s->file_systems);
+    assert(fs_conf);
+
+    if (cmd->arg_count == 0)
+    {
+        fs_conf->exp_flags &= ~TROVE_EXP_ROOT_SQUASH;
+    }
+    else 
+    {
+        fs_conf->exp_flags |= TROVE_EXP_ROOT_SQUASH;
+        fs_conf->root_squash_netmasks = (int *) calloc(cmd->arg_count, sizeof(int));
+        if (fs_conf->root_squash_netmasks == NULL)
+        {
+            fs_conf->root_squash_count = 0;
+            return("Could not allocate memory for root_squash_netmasks\n");
+        }
+        if (get_list_of_strings(cmd->arg_count, cmd->data.list,
+                    &fs_conf->root_squash_hosts) < 0)
+        {
+            free(fs_conf->root_squash_netmasks);
+            fs_conf->root_squash_netmasks = NULL;
+            fs_conf->root_squash_count = 0;
+            return("Could not allocate memory for root_squash_hosts\n");
+        }
+        fs_conf->root_squash_count = cmd->arg_count;
+        /* Setup the netmasks */
+        if (setup_netmasks(fs_conf->root_squash_count, fs_conf->root_squash_hosts, 
+                    fs_conf->root_squash_netmasks) < 0)
+        {
+            free(fs_conf->root_squash_netmasks);
+            fs_conf->root_squash_netmasks = NULL;
+            free_list_of_strings(fs_conf->root_squash_count, &fs_conf->root_squash_hosts);
+            fs_conf->root_squash_count = 0;
+            return("Could not setup netmasks for root_squash_hosts\n");
+        }
+        gossip_debug(GOSSIP_SERVER_DEBUG, "Parsed %d RootSquash wildcard entries\n",
+                cmd->arg_count);
+    }
+    return NULL;
+}
+
+DOTCONF_CB(get_root_squash_exceptions)
+{
+    struct filesystem_configuration_s *fs_conf = NULL;
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+
+    fs_conf = (struct filesystem_configuration_s *)
+        PINT_llist_head(config_s->file_systems);
+    assert(fs_conf);
+
+    if (cmd->arg_count != 0)
+    {
+        fs_conf->root_squash_exceptions_netmasks = (int *) calloc(cmd->arg_count, sizeof(int));
+        if (fs_conf->root_squash_exceptions_netmasks == NULL)
+        {
+            fs_conf->root_squash_exceptions_count = 0;
+            return("Could not allocate memory for root_squash_exceptions_netmasks\n");
+        }
+        if (get_list_of_strings(cmd->arg_count, cmd->data.list,
+                    &fs_conf->root_squash_exceptions_hosts) < 0)
+        {
+            free(fs_conf->root_squash_exceptions_netmasks);
+            fs_conf->root_squash_exceptions_netmasks = NULL;
+            fs_conf->root_squash_exceptions_count = 0;
+            return("Could not allocate memory for root_squash_exceptions_hosts\n");
+        }
+        fs_conf->root_squash_exceptions_count = cmd->arg_count;
+        /* Setup the netmasks */
+        if (setup_netmasks(fs_conf->root_squash_exceptions_count, fs_conf->root_squash_exceptions_hosts, 
+                    fs_conf->root_squash_exceptions_netmasks) < 0)
+        {
+            free(fs_conf->root_squash_exceptions_netmasks);
+            fs_conf->root_squash_exceptions_netmasks = NULL;
+            free_list_of_strings(fs_conf->root_squash_exceptions_count, &fs_conf->root_squash_exceptions_hosts);
+            fs_conf->root_squash_exceptions_count = 0;
+            return("Could not setup netmasks for root_squash_exceptions_hosts\n");
+        }
+        gossip_debug(GOSSIP_SERVER_DEBUG, "Parsed %d RootSquashExceptions wildcard entries\n",
+                cmd->arg_count);
+    }
+    return NULL;
+}
+
+
 DOTCONF_CB(get_read_only)
 {
@@ -1782 +2021 @@
                 cmd->arg_count);
     }
+    return NULL;
+}
+
+DOTCONF_CB(get_all_squash)
+{
+    struct filesystem_configuration_s *fs_conf = NULL;
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+
+    fs_conf = (struct filesystem_configuration_s *)
+        PINT_llist_head(config_s->file_systems);
+    assert(fs_conf);
+
+    if (cmd->arg_count == 0)
+    {
+        fs_conf->exp_flags &= ~TROVE_EXP_ALL_SQUASH;
+    }
+    else 
+    {
+        fs_conf->exp_flags |= TROVE_EXP_ALL_SQUASH;
+        fs_conf->all_squash_netmasks = (int *) calloc(cmd->arg_count, sizeof(int));
+        if (fs_conf->all_squash_netmasks == NULL)
+        {
+            fs_conf->all_squash_count = 0;
+            return("Could not allocate memory for all_squash_netmasks\n");
+        }
+        if (get_list_of_strings(cmd->arg_count, cmd->data.list,
+                    &fs_conf->all_squash_hosts) < 0)
+        {
+            free(fs_conf->all_squash_netmasks);
+            fs_conf->all_squash_netmasks = NULL;
+            fs_conf->all_squash_count = 0;
+            return("Could not allocate memory for all_squash_hosts\n");
+        }
+        fs_conf->all_squash_count = cmd->arg_count;
+        if (setup_netmasks(fs_conf->all_squash_count, fs_conf->all_squash_hosts, 
+                    fs_conf->all_squash_netmasks) < 0)
+        {
+            free(fs_conf->all_squash_netmasks);
+            fs_conf->all_squash_netmasks = NULL;
+            free_list_of_strings(fs_conf->all_squash_count, &fs_conf->all_squash_hosts);
+            fs_conf->all_squash_count = 0;
+            return("Could not setup netmasks for all_squash_hosts\n");
+        }
+        gossip_debug(GOSSIP_SERVER_DEBUG, "Parsed %d AllSquash wildcard entries\n", 
+                cmd->arg_count);
+    }
+    return NULL;
+}
+
+DOTCONF_CB(get_anon_uid)
+{
+    struct filesystem_configuration_s *fs_conf = NULL;
+    unsigned int tmp_var;
+    int ret = -1;
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+
+    fs_conf = (struct filesystem_configuration_s *)
+        PINT_llist_head(config_s->file_systems);
+    assert(fs_conf);
+    ret = sscanf(cmd->data.str, "%u", &tmp_var);
+    if(ret != 1)
+    {
+        return("AnonUID does not have a long long unsigned value.\n");
+    }
+    fs_conf->exp_anon_uid = tmp_var;
+    return NULL;
+}
+
+DOTCONF_CB(get_anon_gid)
+{
+    struct filesystem_configuration_s *fs_conf = NULL;
+    unsigned int tmp_var;
+    int ret = -1;
+    struct server_configuration_s *config_s = 
+        (struct server_configuration_s *)cmd->context;
+
+    fs_conf = (struct filesystem_configuration_s *)
+        PINT_llist_head(config_s->file_systems);
+    assert(fs_conf);
+    ret = sscanf(cmd->data.str, "%u", &tmp_var);
+    if(ret != 1)
+    {
+        return("AnonGID does not have a unsigned value.\n");
+    }
+    fs_conf->exp_anon_gid = tmp_var;
     return NULL;
 }
@@ -2670 +2996 @@
         }
 
-        if (config_s->storage_path)
-        {
-            free(config_s->storage_path);
-            config_s->storage_path = NULL;
+        if (config_s->data_path)
+        {
+            free(config_s->data_path);
+            config_s->data_path = NULL;
+        }
+
+        if (config_s->meta_path)
+        {
+            free(config_s->meta_path);
+            config_s->meta_path = NULL;
         }
 
@@ -2981 +3313 @@
             free(fs->ro_netmasks);
             fs->ro_netmasks = NULL;
+        }
+        /* free all root_squash_exception_hosts specifications */
+        if (fs->root_squash_exceptions_hosts)
+        {
+            free_list_of_strings(fs->root_squash_exceptions_count, &fs->root_squash_exceptions_hosts);
+            fs->root_squash_exceptions_count = 0;
+        }
+        if (fs->root_squash_exceptions_netmasks)
+        {
+            free(fs->root_squash_exceptions_netmasks);
+            fs->root_squash_exceptions_netmasks = NULL;
+        }
+        /* free all root_squash_hosts specifications */
+        if (fs->root_squash_hosts)
+        {
+            free_list_of_strings(fs->root_squash_count, &fs->root_squash_hosts);
+            fs->root_squash_count = 0;
+        }
+        if (fs->root_squash_netmasks)
+        {
+            free(fs->root_squash_netmasks);
+            fs->root_squash_netmasks = NULL;
+        }
+        /* free all all_squash_hosts specifications */
+        if (fs->all_squash_hosts)
+        {
+            free_list_of_strings(fs->all_squash_count, &fs->all_squash_hosts);
+            fs->all_squash_count = 0;
+        }
+        if (fs->all_squash_netmasks)
+        {
+            free(fs->all_squash_netmasks);
+            fs->all_squash_netmasks = NULL;
         }
         free(fs);
@@ -3097 +3462 @@
         dest_fs->exp_flags    = src_fs->exp_flags;
         dest_fs->ro_count     = src_fs->ro_count;
+        dest_fs->root_squash_count = src_fs->root_squash_count;
+        dest_fs->all_squash_count = src_fs->all_squash_count;
         if (src_fs->ro_count > 0 && src_fs->ro_hosts)
         {
@@ -3114 +3481 @@
             memcpy(dest_fs->ro_netmasks, src_fs->ro_netmasks, src_fs->ro_count * sizeof(int));
         }
+        if (src_fs->root_squash_count > 0 && src_fs->root_squash_hosts)
+        {
+            int i;
+            dest_fs->root_squash_hosts = (char **) calloc(src_fs->root_squash_count, sizeof(char *));
+            assert(dest_fs->root_squash_hosts);
+            for (i = 0; i < src_fs->root_squash_count; i++)
+            {
+                dest_fs->root_squash_hosts[i] = strdup(src_fs->root_squash_hosts[i]);
+                assert(dest_fs->root_squash_hosts[i]);
+            }
+        }
+        if (src_fs->root_squash_count > 0 && src_fs->root_squash_netmasks)
+        {
+            dest_fs->root_squash_netmasks = (int *) calloc(src_fs->root_squash_count, sizeof(int));
+            assert(dest_fs->root_squash_netmasks);
+            memcpy(dest_fs->root_squash_netmasks, src_fs->root_squash_netmasks, src_fs->root_squash_count * sizeof(int));
+        }
+        if (src_fs->all_squash_count > 0 && src_fs->all_squash_hosts)
+        {
+            int i;
+            dest_fs->all_squash_hosts = (char **) calloc(src_fs->all_squash_count, sizeof(char *));
+            assert(dest_fs->all_squash_hosts);
+            for (i = 0; i < src_fs->all_squash_count; i++)
+            {
+                dest_fs->all_squash_hosts[i] = strdup(src_fs->all_squash_hosts[i]);
+                assert(dest_fs->all_squash_hosts[i]);
+            }
+        }
+        if (src_fs->all_squash_count > 0 && src_fs->all_squash_netmasks)
+        {
+            dest_fs->all_squash_netmasks = (int *) calloc(src_fs->all_squash_count, sizeof(int));
+            assert(dest_fs->all_squash_netmasks);
+            memcpy(dest_fs->all_squash_netmasks, src_fs->all_squash_netmasks, src_fs->all_squash_count * sizeof(int));
+        }
+        dest_fs->exp_anon_uid = src_fs->exp_anon_uid;
+        dest_fs->exp_anon_gid = src_fs->exp_anon_gid;
 
         dest_fs->fp_buffer_size = src_fs->fp_buffer_size;
@@ -3119 +3522 @@
     }
 }
+
 
 static host_alias_s *find_host_alias_ptr_by_alias(
@@ -4106 +4510 @@
 
             ret = pvfs2_mkspace(
-                config->storage_path, cur_fs->file_system_name,
+                config->data_path, config->meta_path, cur_fs->file_system_name,
                 cur_fs->coll_id, root_handle, cur_meta_handle_range,
                 cur_data_handle_range, create_collection_only, 1);
@@ -4161 +4565 @@
                 (remove_collection_only ? "collection" :
                  "storage space"));
-            ret = pvfs2_rmspace(config->storage_path,
+            ret = pvfs2_rmspace(config->data_path,
+                                config->meta_path,
                                 cur_fs->file_system_name,
                                 cur_fs->coll_id,

branches/cu-security-branch/src/common/misc/server-config.h

@@ -103 +103 @@
     int   *ro_netmasks;
 
+    int    root_squash_count;
+    char **root_squash_hosts;
+    int   *root_squash_netmasks;
+
+    int    root_squash_exceptions_count;
+    char **root_squash_exceptions_hosts;
+    int   *root_squash_exceptions_netmasks;
+
+    int    all_squash_count;
+    char **all_squash_hosts;
+    int   *all_squash_netmasks;
+
+    PVFS_uid exp_anon_uid;
+    PVFS_gid exp_anon_gid;
+
     int32_t small_file_size;
 
@@ -125 +140 @@
 } distribution_configuration;
 
-enum security_keyword
-{
-    SECURITY_KEYWORD_EMAIL,
-    SECURITY_KEYWORD_EMAIL_REGEX,
-    SECURITY_KEYWORD_SUBJECT,
-    SECURITY_KEYWORD_SUBJECT_REGEX,
-};
-
 typedef struct server_configuration_s
 {
@@ -139 +146 @@
     char *server_alias;             /* the command line server-alias parameter */
     int my_server_options;
-    char *storage_path;
+    char *data_path;                /* path to data storage directory */
+    char *meta_path;                /* path to metadata storage directory */
     char *fs_config_filename;       /* the fs.conf file name            */
     size_t fs_config_buflen;        /* the fs.conf file length          */

branches/cu-security-branch/src/common/misc/state-machine-fns.c

@@ -431 +431 @@
 {
     return smcb->op == PVFS_SERVER_GET_CONFIG 
-        || smcb->op == PVFS_SERVER_FETCH_CONFIG
         || smcb->op == PVFS_CLIENT_JOB_TIMER 
         || smcb->op == PVFS_CLIENT_PERF_COUNT_TIMER 

branches/cu-security-branch/src/common/misc/state-machine.h

@@ -50 +50 @@
     SM_RUN     = 9
 };
+
+/*define msgpairarray parameters for server-to-server requests*/
+#define PINT_serv_init_msgarray_params(sm_p, __fsid)             \
+do {                                                             \
+   PINT_sm_msgpair_params *mpp = &sm_p->msgarray_op.params;      \
+   struct server_configuration_s *server_config =                \
+        get_server_config_struct();                              \
+   mpp->job_context = server_job_context;                        \
+   if (server_config)                                            \
+   {                                                             \
+      mpp->job_timeout = server_config->client_job_bmi_timeout;  \
+      mpp->retry_limit = server_config->client_retry_limit;      \
+      mpp->retry_delay = server_config->client_retry_delay_ms;   \
+   }                                                             \
+   else                                                          \
+   {                                                             \
+      mpp->job_timeout = PVFS2_CLIENT_JOB_BMI_TIMEOUT_DEFAULT;   \
+      mpp->retry_limit = PVFS2_CLIENT_RETRY_LIMIT_DEFAULT;       \
+      mpp->retry_delay = PVFS2_CLIENT_RETRY_DELAY_MS_DEFAULT;    \
+   }                                                             \
+} while (0)                                                      
 
 /* these define things like stack size and so forth for the common
@@ -204 +225 @@
                         int *remaining);
 
-/* This macro is used in calls to PINT_sm_fram() */
+/* This macro is used in calls to PINT_sm_frame() */
 #define PINT_FRAME_CURRENT 0
+#define PINT_FRAME_TOP 1
 
 struct PINT_state_machine_s pvfs2_void_sm;

branches/cu-security-branch/src/common/misc/str-utils.c

@@ -144 +144 @@
 
     /* initialize our starting position */
-    if (*inout_segp == NULL) {
-        ptr = pathname;
-    }
-    else if (*opaquep != NULL) {
-        /* replace the '/', point just past it */
-        ptr = (char *) *opaquep;
-        *ptr = '/';
-        ptr++;
-    }
-    else return -1; /* NULL *opaquep indicates last segment returned last time */
+    if (*inout_segp == NULL)
+    {
+        ptr = pathname;
+    }
+    else if (*opaquep != NULL)
+    {
+        /* replace the '/', point just past it */
+        ptr = (char *) *opaquep;
+        *ptr = '/';
+        ptr++;
+    }
+    else
+        return -1; /* NULL *opaquep indicates last segment returned last time */
 
     /* at this point, the string is back in its original state */
 
     /* jump past separators */
-    while ((*ptr != '\0') && (*ptr == '/')) ptr++;
-    if (*ptr == '\0') return -1; /* all that was left was trailing '/'s */
+    while ((*ptr != '\0') && (*ptr == '/'))
+        ptr++;
+    if (*ptr == '\0')
+        return -1; /* all that was left was trailing '/'s */
 
     *inout_segp = ptr;
 
     /* find next separator */
-    while ((*ptr != '\0') && (*ptr != '/')) ptr++;
-    if (*ptr == '\0') *opaquep = NULL; /* indicate last segment */
-    else {
-        /* terminate segment and save position of terminator */
-        *ptr = '\0';
-        *opaquep = ptr;
+    while ((*ptr != '\0') && (*ptr != '/'))
+        ptr++;
+    if (*ptr == '\0')
+        *opaquep = NULL; /* indicate last segment */
+    else
+    {
+        /* terminate segment and save position of terminator */
+        *ptr = '\0';
+        *opaquep = ptr;
     }
     return 0;
@@ -312 +320 @@
     for(i =0; i < pathlen; i++)
     {
-        if (path[i] == '/')
-        {
-            num_slashes_seen++;
-            if (num_slashes_seen > skip)
-            {
-                break;
-            }
-        }
+        if (path[i] == '/')
+        {
+                 num_slashes_seen++;
+            if (num_slashes_seen > skip)
+            {
+                break;
+            }
+        }
     }
 
@@ -356 +364 @@
     if (!comma_list || !tokens)
     {
-        return (0);
+        return (0);
     }
 
@@ -363 +371 @@
     while ((holder = index(holder, ',')))
     {
-        tokencount++;
-        holder++;
+        tokencount++;
+        holder++;
     }
 
@@ -380 +388 @@
     if (!(*tokens))
     {
-        return 0;
+        return 0;
     }
 
     if(1 == tokencount)
     {
-        (*tokens)[0] = strdup(comma_list);
-        if(!(*tokens)[0])
-        {
-            tokencount = 0;
-            goto failure;
-        }
-        return tokencount;
+        (*tokens)[0] = strdup(comma_list);
+        if(!(*tokens)[0])
+        {
+            tokencount = 0;
+            goto failure;
+        }
+        return tokencount;
     }
 
@@ -399 +407 @@
     for (i = 0; i < tokencount && holder; i++)
     {
-        holder2 = index(holder, ',');
-        if (!holder2)
-        {
-            holder2 = end;
-        }
+        holder2 = index(holder, ',');
+        if (!holder2)
+        {
+            holder2 = end;
+        }
         if (holder2 - holder == 0) {
             retval--;
-            goto out;
-        }
-        (*tokens)[i] = (char *) malloc((holder2 - holder) + 1);
-        if (!(*tokens)[i])
-        {
-            goto failure;
-        }
-        strncpy((*tokens)[i], holder, (holder2 - holder));
-        (*tokens)[i][(holder2 - holder)] = '\0';
+            return (retval);
+        }
+        (*tokens)[i] = (char *) malloc((holder2 - holder) + 1);
+        if (!(*tokens)[i])
+        {
+            goto failure;
+        }
+        strncpy((*tokens)[i], holder, (holder2 - holder));
+        (*tokens)[i][(holder2 - holder)] = '\0';
         assert(strlen((*tokens)[i]) != 0);
-        holder = holder2 + 1;
-    }
-
-out:
+        holder = holder2 + 1;
+    }
+
     return (retval);
 
-  failure:
+failure:
 
     /* free up any memory we allocated if we failed */
     if (*tokens)
     {
-        for (i = 0; i < tokencount; i++)
-        {
-            if ((*tokens)[i])
-            {
-                free((*tokens)[i]);
-            }
-        }
-        free(*tokens);
+        for (i = 0; i < tokencount; i++)
+        {
+            if ((*tokens)[i])
+            {
+                free((*tokens)[i]);
+            }
+        }
+        free(*tokens);
     }
     return (0);

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