Changeset 8480

Show
Ignore:
Timestamp:
08/22/10 20:10:19 (3 years ago)
Author:
shuangy
Message:

incorporate dist-dir-struct to the source tree. It's compilable but not runnable. still have a lot to change and add. Commit as a touch base.

Location:
branches/Orange-Elaine-Distr-Dir-Branch
Files:
1 added
22 modified

Legend:

Unmodified
Added
Removed

  • branches/Orange-Elaine-Distr-Dir-Branch/Makefile.in

    r8259 r8480  
    313313SERVERCFLAGS += -D__STATIC_FLOWPROTO_BMI_CACHE__ 
    314314 
    315 SERVERLIBS = -lpvfs2-server @LIBS@ @DB_LIB@ -lpthread  
     315SERVERLIBS = -lpvfs2-server @LIBS@ @DB_LIB@ -lpthread -lm 
    316316 
    317317ifdef NEEDS_LIBRT  

  • branches/Orange-Elaine-Distr-Dir-Branch/include/pvfs2-types.h

    r8478 r8480  
    510510        int32_t tree_height; /* ceil(log2(num_servers)) */ 
    511511        int32_t num_servers; /* total number of servers */ 
    512         int32_t bitmap_size; /* number of bytes of the bitmap tree stored under the key DIST_DIR_BITMAP, 
    513         should be a multiple of 4*/ 
     512        int32_t bitmap_size; /* number of PVFS_dist_dir_bitmap_basetype stored under the key DIST_DIR_BITMAP */ 
    514513        int32_t split_size; /* maximum number of entries before a split */ 
    515514 
    … …  
    518517        int32_t branch_level; /* level of branching on this server */ 
    519518} PVFS_dist_dir_attr; 
    520  
    521 /* bitmap type */ 
     519endecode_fields_6( 
     520    PVFS_dist_dir_attr, 
     521    int32_t, tree_height, 
     522    int32_t, num_servers, 
     523    int32_t, bitmap_size, 
     524    int32_t, split_size, 
     525    int32_t, server_no, 
     526    int32_t, branch_level); 
     527 
    522528typedef uint32_t PVFS_dist_dir_bitmap_basetype; 
    523 typedef uint32_t* PVFS_dist_dir_bitmap; 
     529typedef uint32_t *PVFS_dist_dir_bitmap; 
    524530typedef uint64_t PVFS_dist_dir_hash_type; 
    525531 
    526  
     532#define encode_PVFS_dist_dir_bitmap_basetype encode_uint32_t 
     533#define decode_PVFS_dist_dir_bitmap_basetype decode_uint32_t 
     534#define encode_PVFS_dist_dir_hash_type encode_uint64_t 
     535#define decode_PVFS_dist_dir_hash_type decode_uint64_t 
    527536 
    528537/** Predefined server parameters that can be manipulated at run-time 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/acache.c

    r8418 r8480  
    1515#include "gossip.h" 
    1616#include "pvfs2-internal.h" 
     17#include "dist-dir-utils.h" 
    1718   
    1819/** \file 
    … …  
    7071    PVFS_handle *mirror_dfile_array; 
    7172    uint32_t mirror_copies_count; 
     73    /* 
    7274    PVFS_handle *dirent_handle; 
    7375    uint32_t dirent_file_count; 
     76    */ 
     77    /* distributed directory parameters */ 
     78    PVFS_dist_dir_attr dist_dir_attr; 
     79    PVFS_dist_dir_bitmap dist_dir_bitmap; 
     80    PVFS_handle *dirdata_handles; 
    7481}; 
    7582   
    … …  
    369376  
    370377#if 0 
    371     gossip_debug(GOSSIP_ACACHE_DEBUG, "acache:  
    372 status=%d, attr_status=%d, size_status=%d\n", 
     378    gossip_debug(GOSSIP_ACACHE_DEBUG, "acache: status=%d, attr_status=%d, size_status=%d\n", 
    373379                 status, tmp_payload->attr_status, tmp_payload->size_status); 
    374380#endif 
    … …  
    454460        { 
    455461            uint32_t tmp_i; 
    456  
    457             if(attr->u.dir.dirent_handle) 
    458                 free(attr->u.dir.dirent_handle); 
    459             attr->u.dir.dirent_handle = 
    460                 malloc(tmp_static_payload->dirent_file_count*sizeof(PVFS_handle)); 
    461             if (!attr->u.dir.dirent_handle) 
     462            /* test if num_servers > 0 */ 
     463 
     464            if(attr->u.dir.dist_dir_bitmap) 
     465            { 
     466                free(attr->u.dir.dist_dir_bitmap); 
     467                attr->u.dir.dist_dir_bitmap = NULL; 
     468            } 
     469            if(attr->u.dir.dirdata_handles) 
     470            { 
     471                free(attr->u.dir.dirdata_handles); 
     472                attr->u.dir.dirdata_handles = NULL; 
     473            } 
     474 
     475            if(tmp_static_payload->dist_dir_attr.num_servers == 0) 
     476            { /* no dirdata servers, for debug */ 
     477                gen_mutex_unlock(&acache_mutex); 
     478                return(0); /* ??? not sure */ 
     479            } 
     480 
     481            /* copy dist_dir_attr */ 
     482            PINT_dist_dir_attr_copyto(attr->u.dir.dist_dir_attr, 
     483                tmp_static_payload->dist_dir_attr); 
     484 
     485            attr->u.dir.dist_dir_bitmap = 
     486                malloc(tmp_static_payload->dist_dir_attr.bitmap_size *  
     487                        sizeof(PVFS_dist_dir_bitmap_basetype)); 
     488            attr->u.dir.dirdata_handles = 
     489                malloc(tmp_static_payload->dist_dir_attr.num_servers * 
     490                        sizeof(PVFS_handle)); 
     491            if (!attr->u.dir.dist_dir_bitmap || !attr->u.dir.dirdata_handles) 
    462492            { 
    463493                gen_mutex_unlock(&acache_mutex); 
    464494                return(-PVFS_ENOMEM); 
    465495            } 
    466             memcpy(attr->u.dir.dirent_handle, 
    467                    tmp_static_payload->dirent_handle, 
    468                    tmp_static_payload->dirent_file_count*sizeof(PVFS_handle)); 
    469             attr->u.dir.dirent_file_count = tmp_static_payload->dirent_file_count; 
    470             gossip_debug(GOSSIP_ACACHE_DEBUG, "acache: get_cached_entry(): dirent_file_count=%d\n", attr->u.dir.dirent_file_count); 
    471             for (tmp_i=0; tmp_i < attr->u.dir.dirent_file_count; tmp_i++) 
     496            memcpy(attr->u.dir.dist_dir_bitmap, 
     497                   tmp_static_payload->dist_dir_bitmap, 
     498                   tmp_static_payload->dist_dir_attr.bitmap_size *  
     499                   sizeof(PVFS_dist_dir_bitmap_basetype)); 
     500            memcpy(attr->u.dir.dirdata_handles, 
     501                   tmp_static_payload->dirdata_handles, 
     502                   tmp_static_payload->dist_dir_attr.num_servers *  
     503                   sizeof(PVFS_handle)); 
     504 
     505/* !!! change later */ 
     506            gossip_debug(GOSSIP_ACACHE_DEBUG, "acache: get_cached_entry(): dirdata_count=%d\n", attr->u.dir.dist_dir_attr.num_servers); 
     507            for (tmp_i=0; tmp_i < attr->u.dir.dist_dir_attr.num_servers; tmp_i++) 
    472508            { 
    473                 gossip_debug(GOSSIP_ACACHE_DEBUG, "                           dirent_handle[%d]=%llu\n", tmp_i, llu(attr->u.dir.dirent_handle[tmp_i])); 
     509                gossip_debug(GOSSIP_ACACHE_DEBUG, "                           dirdata_handle[%d]=%llu\n", tmp_i, llu(attr->u.dir.dirdata_handles[tmp_i])); 
    474510            } 
    475511        } 
    … …  
    676712            uint32_t tmp_i; 
    677713 
    678             gossip_debug(GOSSIP_ACACHE_DEBUG, "acache: update(): dirent_file_count=%d\n", attr->u.dir.dirent_file_count); 
    679             for (tmp_i=0; tmp_i < attr->u.dir.dirent_file_count; tmp_i++) 
     714            if(attr->u.dir.dist_dir_attr.num_servers == 0) 
     715            { /* empty dist-dir structure, not going to store, only in development phase */ 
     716                ret = -PVFS_ENOMEM; /* temporarily */ 
     717                goto err; 
     718            } 
     719 
     720            /* change gossip format later */ 
     721            gossip_debug(GOSSIP_ACACHE_DEBUG, "acache: update(): dirdata_count=%d\n",  
     722                    attr->u.dir.dist_dir_attr.num_servers); 
     723            for (tmp_i=0; tmp_i < attr->u.dir.dist_dir_attr.num_servers; tmp_i++) 
    680724            { 
    681                 gossip_debug(GOSSIP_ACACHE_DEBUG, "                  dirent_handle[%d]=%llu\n", tmp_i, llu(attr->u.dir.dirent_handle[tmp_i])); 
     725                gossip_debug(GOSSIP_ACACHE_DEBUG, "                  dirdata_handle[%d]=%llu\n", tmp_i, llu(attr->u.dir.dirdata_handles[tmp_i])); 
    682726            } 
    683727  
    684            tmp_static_payload->dirent_handle = 
    685                 malloc(attr->u.dir.dirent_file_count * sizeof(PVFS_handle)); 
    686            if (!tmp_static_payload->dirent_handle) 
     728            PINT_dist_dir_attr_copyto(tmp_static_payload->dist_dir_attr,  
     729                    attr->u.dir.dist_dir_attr); 
     730 
     731           tmp_static_payload->dist_dir_bitmap = 
     732                malloc(attr->u.dir.dist_dir_attr.bitmap_size *  
     733                        sizeof(PVFS_dist_dir_bitmap_basetype)); 
     734           tmp_static_payload->dirdata_handles = 
     735                malloc(attr->u.dir.dist_dir_attr.num_servers * sizeof(PVFS_handle)); 
     736           if (!tmp_static_payload->dirdata_handles || 
     737               !tmp_static_payload->dist_dir_bitmap ) 
    687738           { 
    688739                ret = -PVFS_ENOMEM; 
    689740                goto err; 
    690741           } 
    691            memcpy(tmp_static_payload->dirent_handle 
    692                  ,attr->u.dir.dirent_handle 
    693                  ,attr->u.dir.dirent_file_count * sizeof(PVFS_handle)); 
    694            tmp_static_payload->dirent_file_count = 
    695                 attr->u.dir.dirent_file_count; 
     742           memcpy(tmp_static_payload->dirdata_handles, 
     743                 attr->u.dir.dirdata_handles, 
     744                 attr->u.dir.dist_dir_attr.num_servers * sizeof(PVFS_handle)); 
     745           memcpy(tmp_static_payload->dist_dir_bitmap, 
     746                 attr->u.dir.dist_dir_bitmap, 
     747                 attr->u.dir.dist_dir_attr.bitmap_size *  
     748                 sizeof(PVFS_dist_dir_bitmap_basetype)); 
    696749        } 
    697750    } 
    … …  
    763816        if(tmp_static_payload->mirror_dfile_array) 
    764817            free(tmp_static_payload->mirror_dfile_array); 
    765         if(tmp_static_payload->dirent_handle) 
    766             free(tmp_static_payload->dirent_handle); 
     818        if(tmp_static_payload->dist_dir_bitmap) 
     819            free(tmp_static_payload->dist_dir_bitmap); 
     820        if(tmp_static_payload->dirdata_handles) 
     821            free(tmp_static_payload->dirdata_handles); 
    767822        if(tmp_static_payload->dist) 
    768823            PINT_dist_free(tmp_static_payload->dist); 
    … …  
    864919        free(tmp_static_payload->mirror_dfile_array); 
    865920    } 
    866     if(tmp_static_payload->dirent_handle) 
    867     { 
    868         free(tmp_static_payload->dirent_handle); 
     921    if(tmp_static_payload->dist_dir_bitmap) 
     922    { 
     923        free(tmp_static_payload->dist_dir_bitmap); 
     924    } 
     925    if(tmp_static_payload->dirdata_handles) 
     926    { 
     927        free(tmp_static_payload->dirdata_handles); 
    869928    } 
    870929    if(tmp_static_payload->dist) 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/client-state-machine.h

    r8478 r8480  
    109109    int stored_error_code; 
    110110    PVFS_handle metafile_handle; 
    111     int dirent_file_count; 
    112     PVFS_handle *dirent_handle; 
    113  
     111 
     112    /* store the dist-dir-struct of the parent directory */ 
     113    /* distributed directory parameters */ 
     114    PVFS_dist_dir_attr dist_dir_attr; 
     115    PVFS_dist_dir_bitmap dist_dir_bitmap; 
     116    PVFS_handle *dirdata_handles; 
     117 
     118    /* keep first */ 
    114119    PINT_dist *dist; 
    115120    PVFS_sys_layout layout; 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/mgmt-create-dirent.sm

    r8418 r8480  
    207207        sm_p->u.mgmt_create_dirent.entry_handle, 
    208208        sm_p->parent_ref.handle, 
    209         sm_p->getattr.attr.u.dir.dirent_handle[0], 
     209        sm_p->getattr.attr.u.dir.dirdata_handles[0], 
    210210        sm_p->parent_ref.fs_id, 
    211211        sm_p->hints); 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/mgmt-remove-dirent.sm

    r8418 r8480  
    196196        sm_p->parent_ref.fs_id, 
    197197        sm_p->parent_ref.handle, 
    198         sm_p->getattr.attr.u.dir.dirent_handle[0], 
     198        sm_p->getattr.attr.u.dir.dirdata_handles[0], 
    199199        sm_p->u.mgmt_remove_dirent.entry, 
    200200        sm_p->hints); 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-create.sm

    r8418 r8480  
    676676        /* note that permission checking is left to server even in this case */ 
    677677    } 
     678    /* !!! change more later */ 
    678679    gossip_debug(GOSSIP_CLIENT_DEBUG, "create_parent_getattr: [%p] " 
    679         "dirent_file_count = %d " 
     680        "dirdata_server_count = %d " 
    680681        "dfile_count     = %d " 
    681682        "dist_name_len   = %d " 
    682683        "dist_params_len = %d\n", 
    683684        attr, 
    684         attr->u.dir.dirent_file_count, 
     685        attr->u.dir.dist_dir_attr.num_servers, 
    685686        attr->u.dir.hint.dfile_count, 
    686687        attr->u.dir.hint.dist_name_len, 
    687688        attr->u.dir.hint.dist_params_len); 
    688689 
    689     for (tmp_i = 0; tmp_i < attr->u.dir.dirent_file_count; tmp_i++) 
     690    /* !!! change more later */ 
     691    for (tmp_i = 0; tmp_i < attr->u.dir.dist_dir_attr.num_servers; tmp_i++) 
    690692    { 
    691693        gossip_debug(GOSSIP_CLIENT_DEBUG, 
    692                      "                           dirent_handle[%d] = %llu\n", 
    693                      tmp_i, llu(attr->u.dir.dirent_handle[tmp_i])); 
     694                     "                           dirdata_handle[%d] = %llu\n", 
     695                     tmp_i, llu(attr->u.dir.dirdata_handles[tmp_i])); 
    694696    } 
    695697         
     698    /* !!! need to talk to Elaine and revise this part, what to store in u.create */ 
    696699    sm_p->u.create.dirent_handle = malloc( 
    697         sizeof(*attr->u.dir.dirent_handle) * attr->u.dir.dirent_file_count); 
     700        sizeof(*attr->u.dir.dirdata_handles) * attr->u.dir.dist_dir_attr.num_servers); 
    698701    if (!sm_p->u.create.dirent_handle) 
    699702    { 
    … …  
    701704    } 
    702705    memcpy(sm_p->u.create.dirent_handle, 
    703            attr->u.dir.dirent_handle, 
    704            sizeof(*attr->u.dir.dirent_handle) * attr->u.dir.dirent_file_count); 
    705     sm_p->u.create.dirent_file_count = attr->u.dir.dirent_file_count; 
     706           attr->u.dir.dirdata_handles, 
     707           sizeof(*attr->u.dir.dirdata_handles) * attr->u.dir.dist_dir_attr.num_servers); 
     708    sm_p->u.create.dirent_file_count = attr->u.dir.dist_dir_attr.num_servers; 
    706709 
    707710    current_dist = sm_p->u.create.dist; 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-getattr.sm

    r8478 r8480  
    636636            uint32_t dirent_file_count_i; 
    637637 
     638            /* !!! change more later */ 
    638639            gossip_debug(GOSSIP_CLIENT_DEBUG, 
    639640                "getattr comp_fn [%p] " 
    … …  
    642643                "dist_params_len = %d " 
    643644                "dirent_count = %llu " 
    644                 "dirent_file_count = %d\n", 
     645                "dirdata_server_count = %d\n", 
    645646                attr, 
    646647                attr->u.dir.hint.dfile_count, 
    … …  
    648649                attr->u.dir.hint.dist_params_len, 
    649650                llu(attr->u.dir.dirent_count), 
    650                 attr->u.dir.dirent_file_count); 
     651                attr->u.dir.dist_dir_attr.num_servers); 
    651652/* 
    652653            gossip_debug(GOSSIP_CLIENT_DEBUG, 
    … …  
    655656*/ 
    656657 
     658            /* !!! change more later */ 
    657659            for (dirent_file_count_i = 0; 
    658                  dirent_file_count_i < attr->u.dir.dirent_file_count; 
     660                 dirent_file_count_i < attr->u.dir.dist_dir_attr.num_servers; 
    659661                 dirent_file_count_i++) { 
    660662                gossip_debug(GOSSIP_CLIENT_DEBUG, 
    661                     "    dirent_handle[%d] = %llu\n", 
     663                    "    dirdata_handle[%d] = %llu\n", 
    662664                    dirent_file_count_i, 
    663                     llu(attr->u.dir.dirent_handle[dirent_file_count_i])); 
     665                    llu(attr->u.dir.dirdata_handles[dirent_file_count_i])); 
    664666            } 
    665667 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-mkdir.sm

    r8478 r8480  
    2828#include "pvfs2-internal.h" 
    2929#include "pvfs2-dist-simple-stripe.h" 
     30#include "dist-dir-utils.h" 
    3031 
    3132extern job_context_id pint_client_sm_context; 
    … …  
    415416 
    416417    /* TODO: Need to find the correct dirent_handle */ 
     418    /* !!! change later */ 
    417419    gossip_debug(GOSSIP_CLIENT_DEBUG, "hooking dirent %s (%llu) under " 
    418420                 "parent handle %llu, dirent_handle %llu\n", 
    … …  
    420422                 llu(sm_p->u.mkdir.metafile_handle), 
    421423                 llu(sm_p->object_ref.handle), 
    422                  llu(sm_p->u.mkdir.dirent_handle[0])); 
     424                 llu(sm_p->u.mkdir.dirdata_handles[0])); 
    423425 
    424426    PINT_msgpair_init(&sm_p->msgarray_op); 
    … …  
    431433        sm_p->u.mkdir.metafile_handle, 
    432434        sm_p->object_ref.handle, 
    433         sm_p->u.mkdir.dirent_handle[0], 
     435        sm_p->u.mkdir.dirdata_handles[0], 
    434436        sm_p->object_ref.fs_id, 
    435437        sm_p->hints); 
    … …  
    575577    } 
    576578 
    577     if(sm_p->u.mkdir.dirent_handle) 
    578     { 
    579         free(sm_p->u.mkdir.dirent_handle); 
    580         sm_p->u.mkdir.dirent_handle = NULL; 
     579    if(sm_p->u.mkdir.dist_dir_bitmap) 
     580    { 
     581        free(sm_p->u.mkdir.dist_dir_bitmap); 
     582        sm_p->u.mkdir.dist_dir_bitmap = NULL; 
     583    } 
     584 
     585    if(sm_p->u.mkdir.dirdata_handles) 
     586    { 
     587        free(sm_p->u.mkdir.dirdata_handles); 
     588        sm_p->u.mkdir.dirdata_handles = NULL; 
    581589    } 
    582590 
    … …  
    601609    assert(attr); 
    602610 
     611    /* !!! change later */ 
    603612    gossip_debug(GOSSIP_CLIENT_DEBUG, 
    604         "parent owner: %d, group: %d, perms: %d, dirent_file_count: %d\n", 
     613        "parent owner: %d, group: %d, perms: %d, dirdata_server_count: %d\n", 
    605614        (int)attr->owner, (int)attr->group, (int)attr->perms, 
    606         attr->u.dir.dirent_file_count); 
    607     for (i = 0; i < attr->u.dir.dirent_file_count; i++) 
     615        attr->u.dir.dist_dir_attr.num_servers); 
     616    for (i = 0; i < attr->u.dir.dist_dir_attr.num_servers; i++) 
    608617    { 
    609618        gossip_debug(GOSSIP_CLIENT_DEBUG, 
    610                      "                           dirent_handle[%d] = %llu\n", 
    611                      i, llu(attr->u.dir.dirent_handle[i])); 
     619                     "                           dirdata_handle[%d] = %llu\n", 
     620                     i, llu(attr->u.dir.dirdata_handles[i])); 
    612621    } 
    613622 
    … …  
    622631    } 
    623632 
    624     sm_p->u.mkdir.dirent_handle = malloc( 
    625         sizeof(*attr->u.dir.dirent_handle) * attr->u.dir.dirent_file_count); 
    626     if (!sm_p->u.mkdir.dirent_handle) 
     633    PINT_dist_dir_attr_copyto(sm_p->u.mkdir.dist_dir_attr, attr->u.dir.dist_dir_attr); 
     634 
     635    sm_p->u.mkdir.dist_dir_bitmap = malloc( 
     636        sizeof(PVFS_dist_dir_bitmap_basetype) * attr->u.dir.dist_dir_attr.bitmap_size); 
     637    sm_p->u.mkdir.dirdata_handles = malloc( 
     638        sizeof(*attr->u.dir.dirdata_handles) * attr->u.dir.dist_dir_attr.num_servers); 
     639    if (!sm_p->u.mkdir.dist_dir_bitmap ||  
     640            !sm_p->u.mkdir.dirdata_handles) 
    627641    { 
    628642        return -PVFS_ENOMEM; 
    629643    } 
    630     memcpy(sm_p->u.mkdir.dirent_handle, 
    631            attr->u.dir.dirent_handle, 
    632            sizeof(*attr->u.dir.dirent_handle) * attr->u.dir.dirent_file_count); 
    633     sm_p->u.mkdir.dirent_file_count = attr->u.dir.dirent_file_count; 
     644    memcpy(sm_p->u.mkdir.dist_dir_bitmap, 
     645            attr->u.dir.dist_dir_bitmap, 
     646            sizeof(PVFS_dist_dir_bitmap_basetype) * attr->u.dir.dist_dir_attr.bitmap_size); 
     647    memcpy(sm_p->u.mkdir.dirdata_handles, 
     648           attr->u.dir.dirdata_handles, 
     649           sizeof(*attr->u.dir.dirdata_handles) * attr->u.dir.dist_dir_attr.num_servers); 
    634650 
    635651    /* Determine the number of dirent files. For now just assume we will use 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-readdir.sm

    r8418 r8480  
    244244        GOSSIP_READDIR_DEBUG, "%llu|%llu|%d | token is %llu | limit is %d\n", 
    245245        llu(sm_p->object_ref.handle), 
    246         llu(sm_p->getattr.attr.u.dir.dirent_handle[0]), 
     246        llu(sm_p->getattr.attr.u.dir.dirdata_handles[0]), 
    247247        sm_p->object_ref.fs_id, 
    248248        llu(sm_p->readdir.pos_token), 
    … …  
    257257        sm_p->object_ref.fs_id, 
    258258        sm_p->object_ref.handle, 
    259         sm_p->getattr.attr.u.dir.dirent_handle[0], 
     259        sm_p->getattr.attr.u.dir.dirdata_handles[0], 
    260260        sm_p->u.readdir.pos_token, 
    261261        sm_p->u.readdir.dirent_limit, 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-remove.sm

    r8418 r8480  
    306306        sm_p->parent_ref.fs_id, 
    307307        sm_p->parent_ref.handle, 
    308         sm_p->getattr.attr.u.dir.dirent_handle[0], 
     308        sm_p->getattr.attr.u.dir.dirdata_handles[0], 
    309309        sm_p->u.remove.object_name, 
    310310        sm_p->hints); 
    … …  
    373373 
    374374    /* TODO: Need to find the correct dirent_handle */ 
    375     gossip_debug(GOSSIP_CLIENT_DEBUG, "dirent_handle: %llu\n", 
    376         llu(attr->u.dir.dirent_handle[0])); 
     375    gossip_debug(GOSSIP_CLIENT_DEBUG, "dirdata_handle: %llu\n", 
     376        llu(attr->u.dir.dirdata_handles[0])); 
    377377  
    378378    PINT_msgpair_init(&sm_p->msgarray_op); 
    … …  
    385385        sm_p->object_ref.handle, 
    386386        sm_p->parent_ref.handle, 
    387         attr->u.dir.dirent_handle[0], 
     387        attr->u.dir.dirdata_handles[0], 
    388388        sm_p->parent_ref.fs_id, 
    389389        sm_p->hints); 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-rename.sm

    r8418 r8480  
    414414    /* TODO: Need to find the correct dirent_handle */ 
    415415    sm_p->u.rename.dirent_handle[index] = 
    416         resp_p->u.lookup_path.attr_array[0].u.dir.dirent_handle[0]; 
     416        resp_p->u.lookup_path.attr_array[0].u.dir.dirdata_handles[0]; 
    417417 
    418418    if (index == 0) 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/client/sysint/sys-symlink.sm

    r8418 r8480  
    432432        sm_p->u.sym.symlink_handle, 
    433433        sm_p->object_ref.handle, 
    434         sm_p->getattr.attr.u.dir.dirent_handle[0], 
     434        sm_p->getattr.attr.u.dir.dirdata_handles[0], 
    435435        sm_p->object_ref.fs_id, 
    436436        sm_p->hints); 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/common/misc/dist-dir-utils.c

    r8464 r8480  
    268268} 
    269269 
     270 
     271 
     272/* set server_no field and update branch_level if necessary */ 
     273int PINT_dist_dir_set_serverno(const int server_no,  
     274        PVFS_dist_dir_attr *ddattr,  
     275        PVFS_dist_dir_bitmap ddbitmap) 
     276{ 
     277        assert(ddattr != NULL &&  
     278                        ddbitmap != NULL && 
     279                        server_no >= -1 && 
     280                        server_no < ddattr->num_servers); 
     281 
     282        ddattr->server_no = server_no; 
     283         
     284        ddattr->branch_level = dist_dir_calc_branch_level(ddattr, ddbitmap); 
     285 
     286        return 0; 
     287} 
     288 
    270289/* 
    271290 * Local variables: 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/common/misc/dist-dir-utils.h

    r8461 r8480  
    3838#define PVFS_DIST_DIR_MAX_ENTRIES 16000 
    3939 
    40 /* set a fixed value for testing */ 
    41 #define PVFS_DIST_DIR_DEFAULT_TOTAL_DIRDATA_NUM 4 
    42 #define PVFS_DIST_DIR_DEFAULT_INITIAL_DIRDATA_NUM 4 
    43  
    44  
    45 static double my_log2(const double n); 
    46 static int dist_dir_calc_branch_level( 
    47         const PVFS_dist_dir_attr *dist_dir_attr, 
    48         const PVFS_dist_dir_bitmap bitmap); 
    4940int PINT_init_dist_dir_state( 
    5041                PVFS_dist_dir_attr *dist_dir_attr,  
    … …  
    6657                const PVFS_dist_dir_bitmap from_dir_bitmap); 
    6758PVFS_dist_dir_hash_type PINT_encrypt_dirdata(const char *const name); 
     59int PINT_dist_dir_set_serverno(const int server_no,  
     60        PVFS_dist_dir_attr *ddattr,  
     61        PVFS_dist_dir_bitmap ddbitmap); 
    6862 
    69  
     63#define PINT_dist_dir_attr_copyto(to_attr, from_attr) \ 
     64do { \ 
     65        to_attr.tree_height = from_attr.tree_height; \ 
     66        to_attr.num_servers = from_attr.num_servers; \ 
     67        to_attr.bitmap_size = from_attr.bitmap_size; \ 
     68        to_attr.split_size = from_attr.split_size; \ 
     69        to_attr.server_no = from_attr.server_no; \ 
     70        to_attr.branch_level = from_attr.branch_level; \ 
     71} while(0) 
     72         
    7073 
    7174 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/common/misc/pint-util.c

    r8478 r8480  
    2626#include <src/common/misc/pvfs2-internal.h>  /* lld(), llu() */ 
    2727#include "pvfs2-req-proto.h" 
     28#include "dist-dir-utils.h" 
    2829 
    2930void PINT_time_mark(PINT_time_marker *out_marker) 
    … …  
    129130        if (src->mask & PVFS_ATTR_DIR_DIRENT_FILES) 
    130131        { 
     132            PINT_dist_dir_attr_copyto(dest->u.dir.dist_dir_attr, src->u.dir.dist_dir_attr); 
     133            dest->u.dir.dist_dir_bitmap = src->u.dir.dist_dir_bitmap; 
     134            dest->u.dir.dirdata_handles = src->u.dir.dirdata_handles; 
     135 
     136            /* 
    131137            dest->u.dir.dirent_file_count = src->u.dir.dirent_file_count; 
    132138            dest->u.dir.dirent_handle = src->u.dir.dirent_handle; 
     139            */ 
    133140/* 
    134141            PVFS_size dirent_file_array_size = src->u.dir.dirent_file_count * 
    … …  
    385392            if (attr->mask & PVFS_ATTR_DIR_DIRENT_FILES) 
    386393            { 
    387                 if (attr->u.dir.dirent_handle) 
    388                 { 
    389                     free(attr->u.dir.dirent_handle); 
    390                     attr->u.dir.dirent_handle = NULL; 
     394                if (attr->u.dir.dist_dir_bitmap) 
     395                { 
     396                    free(attr->u.dir.dist_dir_bitmap); 
     397                    attr->u.dir.dist_dir_bitmap = NULL; 
     398                } 
     399                if (attr->u.dir.dirdata_handles) 
     400                { 
     401                    free(attr->u.dir.dirdata_handles); 
     402                    attr->u.dir.dirdata_handles = NULL; 
    391403                } 
    392404            } 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/proto/pvfs2-attr.h

    r8418 r8480  
    185185{ 
    186186    /* list of files to hold directory entries */ 
    187     PVFS_handle *dirent_handle; 
    188     uint32_t dirent_file_count; 
     187    /*  
     188    PVFS_handle *dirent_handle;  
     189    uint32_t dirent_file_count;  
     190    */ 
    189191    PVFS_size dirent_count; 
    190192    PVFS_directory_hint hint; 
     193 
     194    /* distributed directory parameters */ 
     195    PVFS_dist_dir_attr dist_dir_attr; 
     196    PVFS_dist_dir_bitmap dist_dir_bitmap; 
     197    PVFS_handle *dirdata_handles; 
    191198}; 
    192199typedef struct PVFS_directory_attr_s PVFS_directory_attr; 
    … …  
    194201#ifdef __PINT_REQPROTO_ENCODE_FUNCS_C 
    195202#define encode_PVFS_directory_attr(pptr, x) do { \ 
    196     int dirent_files_i;\ 
    197     encode_uint32_t(pptr, &(x)->dirent_file_count);\ 
    198     for (dirent_files_i=0; dirent_files_i<(x)->dirent_file_count; dirent_files_i++)\ 
    199         encode_PVFS_handle(pptr, &(x)->dirent_handle[dirent_files_i]);\ 
    200     encode_skip4(pptr,);\ 
     203    int index_i;\ 
    201204    encode_PVFS_size(pptr, &(x)->dirent_count);\ 
    202205    encode_PVFS_directory_hint(pptr, &(x)->hint);\ 
     206    encode_PVFS_dist_dir_attr(pptr, &(x)->dist_dir_attr);\ 
     207    for (index_i=0; index_i<(x)->dist_dir_attr.bitmap_size; index_i++)\ 
     208        encode_PVFS_dist_dir_bitmap_basetype(pptr, &(x)->dist_dir_bitmap[index_i]);\ 
     209    encode_skip4(pptr,);\ 
     210    for (index_i=0; index_i<(x)->dist_dir_attr.num_servers; index_i++)\ 
     211        encode_PVFS_handle(pptr, &(x)->dirdata_handles[index_i]);\ 
    203212} while(0) 
    204213 
    … …  
    211220 
    212221#define decode_PVFS_directory_attr(pptr, x) do { \ 
    213     int dirent_files_i;\ 
    214     decode_uint32_t(pptr, &(x)->dirent_file_count);\ 
    215     (x)->dirent_handle = decode_malloc((x)->dirent_file_count \ 
    216       * sizeof(*(x)->dirent_handle));\ 
    217     for (dirent_files_i=0; dirent_files_i<(x)->dirent_file_count; dirent_files_i++)\ 
    218     { \ 
    219         decode_PVFS_handle(pptr, &(x)->dirent_handle[dirent_files_i]);\ 
    220     } \ 
    221     decode_skip4(pptr,);\ 
     222    int index_i;\ 
    222223    decode_PVFS_size(pptr, &(x)->dirent_count);\ 
    223224    decode_PVFS_directory_hint(pptr, &(x)->hint);\ 
     225    decode_PVFS_dist_dir_attr(pptr, &(x)->dist_dir_attr);\ 
     226    (x)->dist_dir_bitmap = decode_malloc((x)->dist_dir_attr.bitmap_size * \ 
     227        sizeof(PVFS_dist_dir_bitmap_basetype));\ 
     228    for(index_i=0; index_i<(x)->dist_dir_attr.bitmap_size; index_i++)\ 
     229        decode_PVFS_dist_dir_bitmap_basetype(pptr, &(x)->dist_dir_bitmap[index_i]);\ 
     230    decode_skip4(pptr,);\ 
     231    (x)->dirdata_handles = decode_malloc((x)->dist_dir_attr.num_servers * \ 
     232        sizeof(*(x)->dirdata_handles));\ 
     233    for(index_i=0; index_i<(x)->dist_dir_attr.num_servers; index_i++)\ 
     234        decode_PVFS_handle(pptr, &(x)->dirdata_handles[index_i]);\ 
    224235} while(0) 
    225236#endif 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/proto/pvfs2-req-proto.h

    r8478 r8480  
    749749    */ 
    750750    PVFS_handle_extent_array handle_extent_array; 
     751 
     752    /* NOTE: not using these now, may add these fields upon discussion */ 
     753    /* distributed directory request parameters */ 
     754    /* 
     755       uint32_t num_total_dirdata_servers; 
     756       uint32_t num_initial_dirdata_servers; 
     757       */ 
     758         
     759    /* assume all num_dirent_files are active */ 
    751760    int32_t num_dirent_files_req; 
    752761    /* NOTE: leave layout as final field so that we can deal with encoding 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/server/get-attr.sm

    r8478 r8480  
    6565        STATE_SYMLINK => read_symlink_target; 
    6666        STATE_METAFILE => read_metafile_hint; 
    67         STATE_DIR => get_num_dirdata_handles; 
     67        STATE_DIR => get_dist_dir_attr; 
    6868        default => setup_resp; 
    6969    } 
    … …  
    155155    } 
    156156 
    157     state get_num_dirdata_handles 
    158     { 
    159         run getattr_get_num_dirdata_handles; 
    160         default => get_dirdata_handles; 
    161 /* 
    162         success => get_dirdata_handles; 
    163         default => setup_resp; 
    164 */ 
    165     } 
    166  
    167     state get_dirdata_handles 
    168     { 
    169         run getattr_get_dirdata_handles; 
     157    state get_dist_dir_attr 
     158    { 
     159        run getattr_get_dist_dir_attr; 
     160        default => get_bitmap_and_dirdata_handles; 
     161    } 
     162 
     163    state get_bitmap_and_dirdata_handles 
     164    { 
     165        run getattr_get_bitmap_and_dirdata_handles; 
    170166        success => get_dirent_count; 
    171167        default => setup_resp; 
    … …  
    14141410        uint32_t dirent_file_count_i; 
    14151411 
     1412        /* !!! may change later */ 
    14161413        gossip_debug(GOSSIP_GETATTR_DEBUG, " server returning " 
    14171414            "dirent_count = %llu " 
    1418             "dirent_file_count = %d " 
     1415            "dirdata_servers_count = %d " 
    14191416            "dfile_count = %d " 
    14201417            "dist_name_len    = %d " 
    14211418            "dist_params_len  = %d\n", 
    14221419            llu(resp_attr->u.dir.dirent_count), 
    1423             resp_attr->u.dir.dirent_file_count, 
     1420            resp_attr->u.dir.dist_dir_attr.num_servers,  
    14241421            resp_attr->u.dir.hint.dfile_count, 
    14251422            resp_attr->u.dir.hint.dist_name_len, 
    14261423            resp_attr->u.dir.hint.dist_params_len); 
     1424        /* !!! gossip bitmap */ 
    14271425        for (dirent_file_count_i = 0; 
    1428              dirent_file_count_i < resp_attr->u.dir.dirent_file_count; 
     1426             dirent_file_count_i < resp_attr->u.dir.dist_dir_attr.num_servers; 
    14291427             dirent_file_count_i++) { 
    14301428            gossip_debug(GOSSIP_GETATTR_DEBUG, 
    1431                 "    dirent_handle[%d] = %lld\n", 
     1429                "    dirdata_handle[%d] = %lld\n", 
    14321430                dirent_file_count_i, 
    1433                 lld(resp_attr->u.dir.dirent_handle[dirent_file_count_i])); 
     1431                lld(resp_attr->u.dir.dirdata_handles[dirent_file_count_i])); 
    14341432        } 
    14351433  
    … …  
    14831481        s_op->u.getattr.mirror_dfile_status_array = NULL; 
    14841482    } 
    1485     if (s_op->resp.u.getattr.attr.objtype == PVFS_TYPE_DIRECTORY && 
    1486         s_op->u.getattr.dirent_handle) 
    1487     { 
    1488         free(s_op->u.getattr.dirent_handle); 
    1489         s_op->u.getattr.dirent_handle = NULL; 
     1483    if (s_op->resp.u.getattr.attr.objtype == PVFS_TYPE_DIRECTORY) 
     1484    { 
     1485        if(s_op->resp.u.getattr.attr.u.dir.dist_dir_bitmap) 
     1486        { 
     1487            free(s_op->resp.u.getattr.attr.u.dir.dist_dir_bitmap); 
     1488            s_op->resp.u.getattr.attr.u.dir.dist_dir_bitmap = NULL; 
     1489        } 
     1490        if(s_op->resp.u.getattr.attr.u.dir.dirdata_handles) 
     1491        { 
     1492            free(s_op->resp.u.getattr.attr.u.dir.dirdata_handles); 
     1493            s_op->resp.u.getattr.attr.u.dir.dirdata_handles = NULL; 
     1494        } 
    14901495    } 
    14911496    if(s_op->free_val) 
    … …  
    15641569} 
    15651570 
    1566 static PINT_sm_action getattr_get_num_dirdata_handles( 
     1571static PINT_sm_action getattr_get_dist_dir_attr( 
    15671572        struct PINT_smcb *smcb, job_status_s *js_p) 
    15681573{ 
    … …  
    15711576    job_id_t tmp_id; 
    15721577 
    1573     s_op->key.buffer = Trove_Common_Keys[NUM_DIR_ENT_KEYS].key; 
    1574     s_op->key.buffer_sz = Trove_Common_Keys[NUM_DIR_ENT_KEYS].size; 
     1578    s_op->key.buffer = Trove_Common_Keys[DIST_DIR_ATTR_KEY].key; 
     1579    s_op->key.buffer_sz = Trove_Common_Keys[DIST_DIR_ATTR_KEY].size; 
    15751580    if(s_op->free_val) 
    15761581    { 
    15771582        free(s_op->val.buffer); 
    15781583    } 
    1579     s_op->u.getattr.num_dirent_handles = 0; 
    1580     s_op->val.buffer = &s_op->u.getattr.num_dirent_handles; 
    1581     s_op->val.buffer_sz = sizeof(int32_t); 
     1584    s_op->val.buffer = &s_op->resp.u.getattr.attr.u.dir.dist_dir_attr; 
     1585    s_op->val.buffer_sz = sizeof(PVFS_dist_dir_attr); 
    15821586    s_op->free_val = 0; 
    15831587 
    … …  
    15971601} 
    15981602 
    1599 static PINT_sm_action getattr_get_dirdata_handles( 
     1603static PINT_sm_action getattr_get_bitmap_and_dirdata_handles( 
    16001604        struct PINT_smcb *smcb, job_status_s *js_p) 
    16011605{ 
    … …  
    16031607    int ret; 
    16041608    job_id_t tmp_id; 
    1605  
    1606     gossip_debug(GOSSIP_GETATTR_DEBUG, "getattr: num_dirent_handles: %d\n", 
    1607         s_op->u.getattr.num_dirent_handles); 
     1609    PVFS_object_attr *attr; 
     1610    int keyval_count; 
     1611     
     1612    attr = &s_op->resp.u.getattr.attr; 
     1613 
    16081614    if(js_p->error_code == -TROVE_ENOENT) 
    16091615    { 
    1610         gossip_debug(GOSSIP_GETATTR_DEBUG, "getattr: setting num_dirent_handles to 1\n"); 
    1611         s_op->u.getattr.num_dirent_handles = 1; 
    1612     } 
    1613     s_op->key.buffer = Trove_Common_Keys[DIR_ENT_KEY].key; 
    1614     s_op->key.buffer_sz = Trove_Common_Keys[DIR_ENT_KEY].size; 
    1615     if(s_op->free_val) 
    1616     { 
    1617         free(s_op->val.buffer); 
    1618     } 
    1619     s_op->u.getattr.dirent_handle = 
    1620             (PVFS_handle *) calloc(s_op->u.getattr.num_dirent_handles, 
    1621                                    sizeof(PVFS_handle)); 
    1622     if (! s_op->u.getattr.dirent_handle) { 
     1616        gossip_debug(GOSSIP_GETATTR_DEBUG, "getattr: no DIST_DIR_ATTR key present!!\n"); 
     1617        attr->u.dir.dist_dir_bitmap = NULL; 
     1618        attr->u.dir.dirdata_handles = NULL; 
     1619        return SM_ACTION_COMPLETE; 
     1620    } 
     1621 
     1622    assert(attr->u.dir.dist_dir_attr.num_servers > 0 && 
     1623        attr->u.dir.dist_dir_attr.bitmap_size > 0); 
     1624     
     1625    gossip_debug(GOSSIP_GETATTR_DEBUG,  
     1626            "getattr: get dist-dir-attr for dir meta handle %llu " 
     1627            "with tree_height=%d, num_servers=%d, bitmap_size=%d, " 
     1628            "split_size=%d, server_no=%d and branch_level=%d\n", 
     1629            llu(s_op->u.getattr.handle), 
     1630            attr->u.dir.dist_dir_attr.tree_height, 
     1631            attr->u.dir.dist_dir_attr.num_servers, 
     1632            attr->u.dir.dist_dir_attr.bitmap_size, 
     1633            attr->u.dir.dist_dir_attr.split_size, 
     1634            attr->u.dir.dist_dir_attr.server_no, 
     1635            attr->u.dir.dist_dir_attr.branch_level); 
     1636 
     1637    /* allocate space for bitmap and dirdata handles */ 
     1638    attr->u.dir.dist_dir_bitmap =  
     1639        malloc(attr->u.dir.dist_dir_attr.bitmap_size * 
     1640                sizeof(PVFS_dist_dir_bitmap_basetype)); 
     1641    attr->u.dir.dirdata_handles =  
     1642        malloc(attr->u.dir.dist_dir_attr.num_servers * 
     1643                sizeof(PVFS_handle)); 
     1644    if(!attr->u.dir.dist_dir_bitmap ||  
     1645            !attr->u.dir.dirdata_handles) 
     1646    { 
    16231647        js_p->error_code = -PVFS_ENOMEM; 
    16241648        return SM_ACTION_COMPLETE; 
    16251649    } 
    1626     s_op->val.buffer = s_op->u.getattr.dirent_handle; 
    1627     s_op->val.buffer_sz = s_op->u.getattr.num_dirent_handles * sizeof(PVFS_handle); 
    1628     s_op->free_val = 0; 
     1650 
     1651 
     1652    /* total 2 keyvals, DIST_DIRDATA_BITMAP, DIST_DIRDATA_HANDLES */ 
     1653    keyval_count = 2; 
     1654 
     1655    s_op->key_a = malloc(sizeof(PVFS_ds_keyval) * keyval_count); 
     1656    if(!s_op->key_a) 
     1657    { 
     1658        js_p->error_code = -PVFS_ENOMEM; 
     1659        return SM_ACTION_COMPLETE; 
     1660    } 
     1661 
     1662    s_op->val_a = malloc(sizeof(PVFS_ds_keyval) * keyval_count); 
     1663    if(!s_op->val_a) 
     1664    { 
     1665        free(s_op->key_a); 
     1666        js_p->error_code = -PVFS_ENOMEM; 
     1667        return SM_ACTION_COMPLETE; 
     1668    } 
     1669    memset(s_op->val_a, 0, sizeof(PVFS_ds_keyval) * keyval_count); 
     1670 
     1671    s_op->key_a[0].buffer = Trove_Common_Keys[DIST_DIRDATA_BITMAP_KEY].key; 
     1672    s_op->key_a[0].buffer_sz = Trove_Common_Keys[DIST_DIRDATA_BITMAP_KEY].size; 
     1673 
     1674    s_op->val_a[0].buffer_sz = 
     1675        attr->u.dir.dist_dir_attr.bitmap_size *  
     1676        sizeof(PVFS_dist_dir_bitmap_basetype); 
     1677    s_op->val_a[0].buffer = attr->u.dir.dist_dir_bitmap; 
     1678 
     1679    s_op->key_a[1].buffer = Trove_Common_Keys[DIST_DIRDATA_HANDLES_KEY].key; 
     1680    s_op->key_a[1].buffer_sz = Trove_Common_Keys[DIST_DIRDATA_HANDLES_KEY].size; 
     1681 
     1682    s_op->val_a[1].buffer = attr->u.dir.dirdata_handles; 
     1683    s_op->val_a[1].buffer_sz = attr->u.dir.dist_dir_attr.num_servers *  
     1684        sizeof(PVFS_handle); 
    16291685 
    16301686    js_p->error_code = 0; 
    1631     ret = job_trove_keyval_read( 
     1687    ret = job_trove_keyval_read_list( 
    16321688        s_op->u.getattr.fs_id, s_op->u.getattr.handle, 
    1633         &s_op->key, &s_op->val, 
     1689        s_op->key_a, s_op->val_a, 
     1690        s_op->u.getattr.err_array, 
     1691        keyval_count, 
    16341692        0, 
    16351693        NULL, 
    … …  
    16491707    int ret; 
    16501708    job_id_t tmp_id; 
     1709    PVFS_object_attr *attr; 
    16511710    int i; 
    16521711 
     1712    if(js_p->error_code == -TROVE_ENOENT) 
     1713    { 
     1714        gossip_debug(GOSSIP_GETATTR_DEBUG, "getattr: no DIST_DIR_ATTR key present, not getting dirent_count! \n"); 
     1715        return SM_ACTION_COMPLETE; 
     1716    } 
     1717 
     1718    attr = &s_op->resp.u.getattr.attr; 
     1719 
     1720    /* should return DIRENT_FILES always, already in resp.u.getattr.attr.u.dir.dirdata_handles */ 
     1721    /* 
    16531722    if (s_op->u.getattr.attrmask & PVFS_ATTR_DIR_DIRENT_FILES) 
    1654     { 
    1655         /* Implementation of distributed directories will mean there 
    1656            may be multiple. */ 
    1657         s_op->resp.u.getattr.attr.u.dir.dirent_file_count = s_op->u.getattr.num_dirent_handles; 
    1658         s_op->resp.u.getattr.attr.u.dir.dirent_handle =  
    1659             (PVFS_handle *) calloc(s_op->resp.u.getattr.attr.u.dir.dirent_file_count, 
    1660                                    sizeof(PVFS_handle)); 
    1661         if (! s_op->resp.u.getattr.attr.u.dir.dirent_handle) { 
    1662             js_p->error_code = -PVFS_ENOMEM; 
    1663             return SM_ACTION_COMPLETE; 
    1664         } 
    1665         memcpy(s_op->resp.u.getattr.attr.u.dir.dirent_handle, 
    1666           s_op->u.getattr.dirent_handle, 
    1667           s_op->resp.u.getattr.attr.u.dir.dirent_file_count * sizeof(PVFS_handle)); 
    1668         gossip_debug(GOSSIP_GETATTR_DEBUG, "getattr: num_dirent_handles: %d\n", 
    1669             s_op->resp.u.getattr.attr.u.dir.dirent_file_count); 
    1670         for (i = 0; i < s_op->resp.u.getattr.attr.u.dir.dirent_file_count; i++) 
    1671         { 
    1672             gossip_debug(GOSSIP_GETATTR_DEBUG, "getattr: dirent_handle[%d]: %llu\n", 
    1673                 i, llu(s_op->resp.u.getattr.attr.u.dir.dirent_handle[i])); 
    1674         } 
    1675     } 
    1676     else 
    1677     { 
    1678         s_op->resp.u.getattr.attr.u.dir.dirent_file_count = 0; 
    1679     } 
     1723    */ 
     1724 
     1725    /* !!! gossip bitmap */ 
     1726 
     1727    gossip_debug(GOSSIP_GETATTR_DEBUG,  
     1728            "\t getattr: dirdata handles array of directory %llu.\n", 
     1729            llu(s_op->u.getattr.handle)); 
     1730 
     1731    for(i=0; i < attr->u.dir.dist_dir_attr.num_servers; i++) 
     1732    { 
     1733        gossip_debug(GOSSIP_MKDIR_DEBUG,  
     1734                "\t\tdirdata server %d: %llu.\n", 
     1735                i, llu(attr->u.dir.dirdata_handles[i])); 
     1736    } 
     1737 
    16801738 
    16811739    if (!(s_op->u.getattr.attrmask & PVFS_ATTR_DIR_DIRENT_COUNT)) 
    … …  
    16871745         return SM_ACTION_COMPLETE; 
    16881746    } 
     1747 
    16891748    /* TODO: Have to gather counts from all dirent handles. */ 
     1749    /* only get dirent of local dirdata servers, later, should let TYPE_DIRDATA do these */ 
    16901750    ret = job_trove_keyval_get_handle_info( 
    16911751        s_op->u.getattr.fs_id, 
    1692         s_op->u.getattr.dirent_handle[0], 
     1752        attr->u.dir.dirdata_handles[0], 
    16931753        TROVE_KEYVAL_HANDLE_COUNT | 
    16941754        0, 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/server/mkdir.sm

    r8478 r8480  
    1717#include "pint-cached-config.h" 
    1818#include "pvfs2-dist-basic.h" 
     19#include "dist-dir-utils.h" 
    1920 
    2021%% 
    … …  
    3233    { 
    3334        run mkdir_setattrib; 
    34         success => create_dirdata_dspace; 
     35        success => create_dist_dir_struct; 
    3536        default => err_msg; 
    3637    } 
    3738 
    38     state create_dirdata_dspace 
    39     { 
    40         run mkdir_create_dirdata_dspace; 
     39/* 1. now use err_msg as the error handling, will change if necessary */ 
     40 
     41    state create_dist_dir_struct 
     42    { 
     43        run mkdir_create_dist_dir_struct; 
     44        success => select_dirdata_servers; 
     45        default => err_msg; 
     46    } 
     47 
     48    state select_dirdata_servers 
     49    { 
     50        run mkdir_select_dirdata_servers; 
    4151        success => create_local_dirdata_dspace; 
    4252        default => err_msg; 
    … …  
    4555    state create_local_dirdata_dspace 
    4656    { 
     57        run mkdir_create_local_dirdata_dspace; 
     58        success => request_remote_dirdata_dspace; 
     59        default => err_msg; 
     60    } 
     61 
     62    state request_remote_dirdata_dspace 
     63    { 
    4764        run mkdir_request_remote_dirdata_dspace; 
    48         success => write_dirdata_handle; 
     65        success => fill_handles_to_dist_dir_struct; 
    4966        default => err_msg; 
    5067    } 
    5168 
    52     state write_dirdata_handle 
    53     { 
    54         run mkdir_write_dirdata_handles; 
     69    state fill_handles_to_dist_dir_struct 
     70    { 
     71        run mkdir_fill_handles_to_dist_dir_struct; 
     72        default => write_keyval_to_local_dirdata_handle; 
     73    } 
     74 
     75    state write_keyval_to_local_dirdata_handle 
     76    { 
     77        run mkdir_write_keyval_to_local_dirdata_handle; 
     78        /* uncomment when the msgpair is finished 
     79        success => remote_dirdata_keyval_setup_msgpair; 
     80        */ 
     81        success => write_keyval_to_meta_handle; 
     82        default => err_msg; 
     83    } 
     84 
     85/* msgpairarray? may lookat sys-rename */ 
     86/* comment now, add later */ 
     87/*************** 
     88        state remote_dirdata_keyval_setup_msgpair 
     89        { 
     90                run mkdir_remote_dirdata_keyval_setup_msgpair; 
     91                success => remote_dirdata_keyval_xfer_msgpair; 
     92                default => err_msg; 
     93        } 
     94 
     95        state remote_dirdata_keyval_xfer_msgpair 
     96        { 
     97                jump pvfs2_msgpairarray_sm; 
     98                success => write_keyval_to_meta_handle; 
     99                default => err_msg; 
     100        } 
     101***************************/ 
     102 
     103    state write_keyval_to_meta_handle 
     104    { 
     105        run mkdir_write_keyval_to_meta_handle; 
    55106        success => return; 
    56107        default => err_msg; 
    … …  
    180231} 
    181232 
    182 static int mkdir_create_dirdata_dspace( 
    183     struct PINT_smcb *smcb, job_status_s *js_p) 
    184 { 
    185     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     233 
     234/* init dist_dir_struct in s_op->attr.u.dir and s_op->u.mkdir */ 
     235static PINT_sm_action mkdir_create_dist_dir_struct( 
     236        struct PINT_smcb *smcb, job_status_s *js_p) 
     237{ 
     238    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     239    PVFS_object_attr *attr; 
     240    int num_total_dirdata_servers, num_initial_dirdata_servers; 
     241    int ret = -1; 
     242 
     243    attr = (&s_op->attr); 
     244 
     245    /* get num_dirdata_servers */ 
     246    s_op->u.mkdir.num_dirdata_servers = 
     247        s_op->req->u.mkdir.num_dirent_files_req; 
     248 
     249    /* make all dirdata servers active */ 
     250    num_total_dirdata_servers = s_op->req->u.mkdir.num_dirent_files_req; 
     251    num_initial_dirdata_servers = s_op->req->u.mkdir.num_dirent_files_req; 
     252 
     253    /* init meta handle dist_dir_struct, server_no = -1 */ 
     254    ret = PINT_init_dist_dir_state(&attr->u.dir.dist_dir_attr, 
     255            &attr->u.dir.dist_dir_bitmap, 
     256            num_total_dirdata_servers, 
     257            -1, 
     258            num_initial_dirdata_servers); 
     259 
     260    assert(ret == 0); 
     261 
     262    gossip_debug(GOSSIP_MKDIR_DEBUG,  
     263            "mkdir: Init dist-dir-attr for dir meta handle %llu " 
     264            "with tree_height=%d, num_servers=%d, bitmap_size=%d, " 
     265            "split_size=%d, server_no=%d and branch_level=%d\n", 
     266            llu(s_op->resp.u.mkdir.handle), 
     267            attr->u.dir.dist_dir_attr.tree_height, 
     268            attr->u.dir.dist_dir_attr.num_servers, 
     269            attr->u.dir.dist_dir_attr.bitmap_size, 
     270            attr->u.dir.dist_dir_attr.split_size, 
     271            attr->u.dir.dist_dir_attr.server_no, 
     272            attr->u.dir.dist_dir_attr.branch_level); 
     273 
     274    /* !!! gossip bitmap */ 
     275 
     276    /* allocate dirdata handle space, similar to create.sm */ 
     277    attr->u.dir.dirdata_handles = malloc( 
     278            sizeof(*attr->u.dir.dirdata_handles) * 
     279            num_total_dirdata_servers); 
     280    s_op->u.mkdir.handle_array_local = malloc( 
     281            sizeof(*s_op->u.mkdir.handle_array_local) * 
     282            num_total_dirdata_servers); 
     283    s_op->u.mkdir.handle_array_remote = malloc( 
     284            sizeof(*s_op->u.mkdir.handle_array_remote) * 
     285            num_total_dirdata_servers); 
     286 
     287    if(!attr->u.dir.dirdata_handles || 
     288            !s_op->u.mkdir.handle_array_local || 
     289            !s_op->u.mkdir.handle_array_remote ) 
     290    { 
     291        js_p->error_code = -PVFS_ENOMEM; 
     292        return SM_ACTION_COMPLETE; 
     293    } 
     294 
     295    return ret;  
     296} 
     297 
     298 
     299static PINT_sm_action mkdir_select_dirdata_servers( 
     300        struct PINT_smcb *smcb, job_status_s *js_p) 
     301{ 
     302    /* 
     303    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     304    PVFS_object_attr *attr; 
     305    */ 
     306    int ret = 0; 
     307 
     308/* not selecting servers now, suppose has dirdata on every metadata server */ 
     309 
     310        /******** if use the function in create.sm to get server list: 
     311* 
     312int PINT_cached_config_get_server_list( 
     313    PVFS_fs_id fs_id, 
     314    PINT_dist *dist, 
     315    int num_dfiles_req, 
     316    PVFS_sys_layout *layout, 
     317    const char ***server_names, 
     318    int *server_count) 
     319 
     3201. need to provide dist & layout 
     3212. server_count might be different from num_dfiles_req, then better put create dist-dir-struct after the servers selection function. 
     322 
     323****************/ 
     324 
     325 
     326        return ret; 
     327 
     328} 
     329 
     330 
     331 
     332static PINT_sm_action mkdir_create_local_dirdata_dspace( 
     333        struct PINT_smcb *smcb, job_status_s *js_p) 
     334{ 
     335    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     336        PVFS_object_attr *attr; 
    186337    int ret = -PVFS_ENOMEM; 
    187338    job_id_t tmp_id; 
    188339    PVFS_handle_extent_array extent_array; 
    189     struct server_configuration_s *user_opts = get_server_config_struct(); 
    190  
    191     gossip_debug(GOSSIP_MKDIR_DEBUG, " creating dspace on coll_id %d\n", 
    192                  s_op->u.mkdir.fs_id); 
    193  
    194     /* TODO: Determine how many dspace handles to create.  For now just 
    195              default to all metadata servers. Eventually this should work 
    196              similar to specifying the number of datafiles for a file. 
    197              (See function create_parent_getattr_inspect of sys-create.sm.) */ 
    198     s_op->u.mkdir.dirent_handle = malloc( 
    199         sizeof(*s_op->u.mkdir.dirent_handle) * s_op->req->u.mkdir.num_dirent_files_req); 
    200     if(!s_op->u.mkdir.dirent_handle) 
    201     { 
    202         js_p->error_code = -PVFS_ENOMEM; 
    203         return SM_ACTION_COMPLETE; 
    204     } 
    205     ret = SM_ACTION_COMPLETE; 
    206  
     340    server_configuration_s *user_opts = get_server_config_struct(); 
     341 
     342    attr = (&s_op->attr); 
     343 
     344    assert(s_op->u.mkdir.num_dirdata_servers > 0); 
     345 
     346    /* dirdata on every meta server */ 
    207347    s_op->u.mkdir.handle_array_local_count = 1; 
    208     s_op->u.mkdir.handle_array_remote_count = s_op->req->u.mkdir.num_dirent_files_req - 1; 
    209  
    210     gossip_debug(GOSSIP_MKDIR_DEBUG, "creating %d local dirent files\n", 
     348    s_op->u.mkdir.handle_array_remote_count =  
     349        s_op->u.mkdir.num_dirdata_servers - 1; 
     350 
     351    gossip_debug(GOSSIP_MKDIR_DEBUG, "creating %d local dirdata files\n",  
    211352        s_op->u.mkdir.handle_array_local_count); 
    212     gossip_debug(GOSSIP_MKDIR_DEBUG, "creating %d remote dirent files\n", 
     353    gossip_debug(GOSSIP_MKDIR_DEBUG, "creating %d remote dirdata files\n",  
    213354        s_op->u.mkdir.handle_array_remote_count); 
    214355 
    215     /* find our meta handle range for this create */ 
     356    if(s_op->u.mkdir.handle_array_local_count == 0) 
     357    { 
     358        /* no local work to do */ 
     359        js_p->error_code = 0; 
     360        return(SM_ACTION_COMPLETE); 
     361    } 
     362 
    216363    ret = PINT_config_get_meta_handle_extent_array( 
    217364        user_opts, s_op->u.mkdir.fs_id, &extent_array); 
    … …  
    224371                 llu(extent_array.extent_array[0].last)); 
    225372 
    226  
    227373    ret = job_trove_dspace_create_list( 
    228374        s_op->req->u.mkdir.fs_id, 
    229375        &extent_array, 
    230         s_op->u.mkdir.dirent_handle, 
     376        s_op->u.mkdir.handle_array_local, 
    231377        s_op->u.mkdir.handle_array_local_count, 
    232         PVFS_TYPE_DIRDATA, 
     378        PVFS_TYPE_DIRDATA,  
    233379        NULL, 
    234380        TROVE_SYNC, 
    … …  
    237383        js_p, 
    238384        &tmp_id, 
    239         server_job_context, 
     385        server_job_context,  
    240386        s_op->req->hints); 
    241387 
    242     free(extent_array.extent_array); 
    243     js_p->error_code = 0; 
    244     return ret; 
    245 } 
     388    return(ret); 
     389} 
     390 
    246391 
    247392static PINT_sm_action mkdir_request_remote_dirdata_dspace( 
    … …  
    249394{ 
    250395    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
    251     int ret = -PVFS_EINVAL; 
    252     job_id_t tmp_id; 
     396    int ret = -1; 
     397    job_id_t j_id; 
    253398 
    254399    gossip_debug( 
    255400        GOSSIP_MKDIR_DEBUG, "  local dirdata handle (%llu)\n", 
    256         llu(s_op->u.mkdir.dirent_handle[0])); 
     401        llu(s_op->u.mkdir.handle_array_local[0])); 
    257402 
    258403    if(s_op->u.mkdir.handle_array_remote_count == 0) 
    259404    { 
    260405        js_p->error_code = 0; 
    261         return SM_ACTION_COMPLETE; 
     406        return(SM_ACTION_COMPLETE); 
    262407    } 
    263408 
    264409    ret = job_precreate_pool_get_handles( 
    265         s_op->u.mkdir.fs_id, 
     410        s_op->req->u.mkdir.fs_id, 
    266411        s_op->u.mkdir.handle_array_remote_count, 
    267412        PVFS_TYPE_DIRDATA, 
    268         NULL, 
    269         &s_op->u.mkdir.dirent_handle[1], 
     413        NULL, /* server string set to NULL for now */ 
     414        s_op->u.mkdir.handle_array_remote, 
    270415        0, 
    271416        smcb, 
    272417        0, 
    273418        js_p, 
    274         &tmp_id, 
     419        &j_id, 
    275420        server_job_context, 
    276421        s_op->req->hints); 
     422 
    277423    return ret; 
    278 } 
    279  
    280 static PINT_sm_action mkdir_write_dirdata_handles( 
    281         struct PINT_smcb *smcb, job_status_s *js_p) 
    282 { 
    283     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
    284     int ret = -PVFS_EINVAL; 
    285     job_id_t i; 
    286  
    287     gossip_debug( 
    288         GOSSIP_MKDIR_DEBUG, "  mkdir_write_dirdata_handles: error_code = %d\n", 
    289         js_p->error_code); 
    290  
    291     if (js_p->error_code) 
    292     { 
    293         return SM_ACTION_COMPLETE; 
    294     } 
    295  
    296     int32_t keyval_count = 2; 
     424 
     425} 
     426 
     427 
     428static PINT_sm_action mkdir_fill_handles_to_dist_dir_struct( 
     429        struct PINT_smcb *smcb, job_status_s *js_p) 
     430{ 
     431    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     432    PVFS_object_attr *attr; 
     433    int i; 
     434 
     435    attr = &s_op->attr; 
     436 
     437    /* fill dirdata_handles array */ 
     438    attr->u.dir.dirdata_handles[0] = 
     439        s_op->u.mkdir.handle_array_local[0]; 
     440 
     441    for(i = 0; i < s_op->u.mkdir.num_dirdata_servers - 1; i++) 
     442    { 
     443        attr->u.dir.dirdata_handles[i+1] = 
     444            s_op->u.mkdir.handle_array_remote[i]; 
     445    } 
     446 
     447    gossip_debug(GOSSIP_MKDIR_DEBUG,  
     448            "\t mkdir: dirdata handles array of directory %llu.\n", 
     449            llu(s_op->resp.u.mkdir.handle)); 
     450 
     451    for(i=0; i<s_op->u.mkdir.num_dirdata_servers; i++) 
     452    { 
     453        gossip_debug(GOSSIP_MKDIR_DEBUG,  
     454                "\t\tdirdata server %d: %llu.\n", 
     455                i, llu(attr->u.dir.dirdata_handles[i])); 
     456    } 
     457 
     458    return 0; 
     459} 
     460 
     461 
     462/* write dist-dir-struct key/val to local dirdata handle 
     463 * need to use a new attr struct and set the correct server_no 
     464 */ 
     465static PINT_sm_action mkdir_write_keyval_to_local_dirdata_handle( 
     466        struct PINT_smcb *smcb, job_status_s *js_p) 
     467{ 
     468    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     469    PVFS_object_attr *attr; 
     470    int ret = -1; 
     471    job_id_t j_id; 
     472    /* total 3 keyvals, DIST_DIR_ATTR, DIST_DIRDATA_BITMAP, DIST_DIRDATA_HANDLES */ 
     473    int keyval_count = 3; 
     474    PVFS_dist_dir_attr tmp_ddattr; 
     475 
     476    /* !!!! this is to set dirdata handle keyval, 
     477     * the dist_dir_attr in s_op->attr is for the meta handle 
     478     * thus needs to create a dist_dir_attr and set server_no correctly!! 
     479     */ 
     480 
     481    attr = &s_op->attr; 
     482    PINT_dist_dir_attr_copyto(tmp_ddattr, attr->u.dir.dist_dir_attr); 
    297483 
    298484    s_op->key_a = malloc(sizeof(PVFS_ds_keyval) * keyval_count); 
    … …  
    301487        js_p->error_code = -PVFS_ENOMEM; 
    302488        return SM_ACTION_COMPLETE; 
    303     }        
    304              
     489    } 
     490 
    305491    s_op->val_a = malloc(sizeof(PVFS_ds_keyval) * keyval_count); 
    306492    if(!s_op->val_a) 
    307     {                
     493    { 
    308494        free(s_op->key_a); 
    309495        js_p->error_code = -PVFS_ENOMEM; 
    … …  
    311497    } 
    312498    memset(s_op->val_a, 0, sizeof(PVFS_ds_keyval) * keyval_count); 
    313   
    314     s_op->key_a[0].buffer = Trove_Common_Keys[NUM_DIR_ENT_KEYS].key; 
    315     s_op->key_a[0].buffer_sz = Trove_Common_Keys[NUM_DIR_ENT_KEYS].size; 
    316  
    317     s_op->val_a[0].buffer = &s_op->req->u.mkdir.num_dirent_files_req; 
    318     s_op->val_a[0].buffer_sz = sizeof(int32_t); 
    319  
    320     s_op->key_a[1].buffer = Trove_Common_Keys[DIR_ENT_KEY].key; 
    321     s_op->key_a[1].buffer_sz = Trove_Common_Keys[DIR_ENT_KEY].size; 
    322  
    323     s_op->val_a[1].buffer = s_op->u.mkdir.dirent_handle; 
    324     s_op->val_a[1].buffer_sz = sizeof(PVFS_handle) * s_op->req->u.mkdir.num_dirent_files_req; 
    325  
    326     gossip_debug( 
    327         GOSSIP_MKDIR_DEBUG, "  num_dirent_files_req = %d\n", 
    328         s_op->req->u.mkdir.num_dirent_files_req); 
    329     for (i=0; i<s_op->req->u.mkdir.num_dirent_files_req; i++) 
    330     { 
    331         gossip_debug( 
    332             GOSSIP_MKDIR_DEBUG, "  writing dirdata handle (%llu) " 
    333             "into parent dir (%llu)\n", llu(s_op->u.mkdir.dirent_handle[i]), 
    334             llu(s_op->resp.u.mkdir.handle)); 
    335     } 
    336  
    337     /* we don't sync here since we're going to anyway in the following 
    338      * operation (setting the dirent count). 
     499 
     500    s_op->key_a[0].buffer = Trove_Common_Keys[DIST_DIR_ATTR_KEY].key; 
     501    s_op->key_a[0].buffer_sz = Trove_Common_Keys[DIST_DIR_ATTR_KEY].size; 
     502 
     503    s_op->val_a[0].buffer = &tmp_ddattr; 
     504    s_op->val_a[0].buffer_sz = 
     505         sizeof(tmp_ddattr); 
     506 
     507    s_op->key_a[1].buffer = Trove_Common_Keys[DIST_DIRDATA_BITMAP_KEY].key; 
     508    s_op->key_a[1].buffer_sz = Trove_Common_Keys[DIST_DIRDATA_BITMAP_KEY].size; 
     509 
     510    s_op->val_a[1].buffer_sz = 
     511        attr->u.dir.dist_dir_attr.bitmap_size *  
     512        sizeof(PVFS_dist_dir_bitmap_basetype); 
     513    s_op->val_a[1].buffer = attr->u.dir.dist_dir_bitmap; 
     514 
     515    s_op->key_a[2].buffer = Trove_Common_Keys[DIST_DIRDATA_HANDLES_KEY].key; 
     516    s_op->key_a[2].buffer_sz = Trove_Common_Keys[DIST_DIRDATA_HANDLES_KEY].size; 
     517 
     518    s_op->val_a[2].buffer = attr->u.dir.dirdata_handles; 
     519    s_op->val_a[2].buffer_sz = attr->u.dir.dist_dir_attr.num_servers *  
     520        sizeof(*attr->u.dir.dirdata_handles); 
     521 
     522    /* local handle is the first handle, so has server_no=0 */ 
     523    PINT_dist_dir_set_serverno(0, &tmp_ddattr, attr->u.dir.dist_dir_bitmap); 
     524 
     525    gossip_debug(GOSSIP_MKDIR_DEBUG,  
     526            " mkdir: writing dist-dir-struct keyvals for local dirdata handle: %llu " 
     527            "(parent dir %llu),\n" 
     528            "\t with server_no=%d and branch_level=%d \n",  
     529            llu(attr->u.dir.dirdata_handles[0]), 
     530            llu(s_op->resp.u.mkdir.handle), 
     531            tmp_ddattr.server_no, 
     532            tmp_ddattr.branch_level); 
     533 
     534 
     535    ret = job_trove_keyval_write_list( 
     536            s_op->req->u.mkdir.fs_id, 
     537            attr->u.dir.dirdata_handles[0], /* dirdata handle */ 
     538            s_op->key_a, s_op->val_a, 
     539            keyval_count, TROVE_SYNC, NULL, smcb, 
     540            0, js_p, &j_id, server_job_context, 
     541            s_op->req->hints); 
     542 
     543    return ret; 
     544} 
     545 
     546 
     547 
     548/* sending keys to remote dirdata server is next task! */ 
     549 
     550 
     551 
     552static PINT_sm_action mkdir_write_keyval_to_meta_handle( 
     553        struct PINT_smcb *smcb, job_status_s *js_p) 
     554{ 
     555    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
     556    PVFS_object_attr *attr; 
     557    int ret = -1; 
     558    job_id_t j_id; 
     559 
     560    /* total 3 keyvals, PVFS_DIST_DIR_ATTR, PVFS_DIRDATA_BITMAP, PVFS_DIRDATA_HANDLES */ 
     561    int keyval_count = 3; 
     562 
     563    /* !!!! this is to set meta handle keyval, 
     564     * use dist_dir_attr in s_op->attr  
    339565     */ 
     566    attr = &s_op->attr; 
     567 
     568    s_op->key_a = malloc(sizeof(PVFS_ds_keyval) * keyval_count); 
     569    if(!s_op->key_a) 
     570    { 
     571        js_p->error_code = -PVFS_ENOMEM; 
     572        return SM_ACTION_COMPLETE; 
     573    } 
     574 
     575    s_op->val_a = malloc(sizeof(PVFS_ds_keyval) * keyval_count); 
     576    if(!s_op->val_a) 
     577    { 
     578        free(s_op->key_a); 
     579        js_p->error_code = -PVFS_ENOMEM; 
     580        return SM_ACTION_COMPLETE; 
     581    } 
     582    memset(s_op->val_a, 0, sizeof(PVFS_ds_keyval) * keyval_count); 
     583 
     584    s_op->key_a[0].buffer = Trove_Common_Keys[DIST_DIR_ATTR_KEY].key; 
     585    s_op->key_a[0].buffer_sz = Trove_Common_Keys[DIST_DIR_ATTR_KEY].size; 
     586 
     587    s_op->val_a[0].buffer = &attr->u.dir.dist_dir_attr; 
     588    s_op->val_a[0].buffer_sz = 
     589         sizeof(attr->u.dir.dist_dir_attr); 
     590 
     591    s_op->key_a[1].buffer = Trove_Common_Keys[DIST_DIRDATA_BITMAP_KEY].key; 
     592    s_op->key_a[1].buffer_sz = Trove_Common_Keys[DIST_DIRDATA_BITMAP_KEY].size; 
     593 
     594    s_op->val_a[1].buffer_sz = 
     595        attr->u.dir.dist_dir_attr.bitmap_size *  
     596        sizeof(PVFS_dist_dir_bitmap_basetype); 
     597    s_op->val_a[1].buffer = attr->u.dir.dist_dir_bitmap; 
     598 
     599    s_op->key_a[2].buffer = Trove_Common_Keys[DIST_DIRDATA_HANDLES_KEY].key; 
     600    s_op->key_a[2].buffer_sz = Trove_Common_Keys[DIST_DIRDATA_HANDLES_KEY].size; 
     601 
     602    s_op->val_a[2].buffer = attr->u.dir.dirdata_handles; 
     603    s_op->val_a[2].buffer_sz = attr->u.dir.dist_dir_attr.num_servers *  
     604        sizeof(*attr->u.dir.dirdata_handles); 
     605 
     606    gossip_debug(GOSSIP_MKDIR_DEBUG,  
     607            "  writing dist-dir-struct keyvals for meta handle: %llu " 
     608            "\t with server_no=%d and branch_level=%d \n",  
     609            llu(s_op->resp.u.mkdir.handle), 
     610            attr->u.dir.dist_dir_attr.server_no, 
     611            attr->u.dir.dist_dir_attr.branch_level); 
     612 
     613 
    340614    ret = job_trove_keyval_write_list( 
    341         s_op->u.mkdir.fs_id, 
    342         s_op->resp.u.mkdir.handle, 
    343         s_op->key_a, s_op->val_a,  
    344         keyval_count, 
    345         TROVE_SYNC, 
    346         NULL, smcb, 0, js_p, &i, server_job_context, s_op->req->hints); 
     615            s_op->req->u.mkdir.fs_id, 
     616            s_op->resp.u.mkdir.handle, /* meta handle */ 
     617            s_op->key_a, s_op->val_a, 
     618            keyval_count, TROVE_SYNC, NULL, smcb, 
     619            0, js_p, &j_id, server_job_context, 
     620            s_op->req->hints); 
    347621 
    348622    return ret; 
    349623} 
     624 
     625 
     626 
    350627 
    351628static int mkdir_error(struct PINT_smcb *smcb, job_status_s *js_p) 
    … …  
    364641    return 1; 
    365642} 
     643 
    366644 
    367645/* 
    … …  
    381659    struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); 
    382660 
    383     if (s_op->u.mkdir.dirent_handle) 
    384     { 
    385         free(s_op->u.mkdir.dirent_handle); 
    386     } 
    387  
    388661    if(s_op->key_a) 
    389662    { 
    … …  
    394667    { 
    395668        free(s_op->val_a); 
     669    } 
     670 
     671    /* not sure s_op->attr should be released here */ 
     672    if(s_op->attr.u.dir.dist_dir_bitmap) 
     673    { 
     674        free(s_op->attr.u.dir.dist_dir_bitmap); 
     675        s_op->attr.u.dir.dist_dir_bitmap = NULL; 
     676    } 
     677 
     678    if(s_op->attr.u.dir.dirdata_handles) 
     679    { 
     680        free(s_op->attr.u.dir.dirdata_handles); 
     681        s_op->attr.u.dir.dirdata_handles = NULL; 
     682    } 
     683 
     684    if(s_op->u.mkdir.handle_array_local) 
     685    { 
     686        free(s_op->u.mkdir.handle_array_local); 
     687    } 
     688 
     689    if(s_op->u.mkdir.handle_array_remote) 
     690    { 
     691        free(s_op->u.mkdir.handle_array_remote); 
    396692    } 
    397693 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/server/pvfs2-server.c

    r8478 r8480  
    135135    {DIST_DIR_ATTR_KEYSTR, DIST_DIR_ATTR_KEYLEN}, 
    136136    {DIST_DIRDATA_HANDLES_KEYSTR, DIST_DIRDATA_HANDLES_KEYLEN}, 
    137     {DIST_DIRDATA_BITMAP_KEYSTR, DIST_DIRDATA_BITMAP_KEYLEN}, 
    138     {NUM_DIRECTORY_ENTRY_KEYSTR, NUM_DIRECTORY_ENTRY_KEYLEN} 
     137    {DIST_DIRDATA_BITMAP_KEYSTR, DIST_DIRDATA_BITMAP_KEYLEN} 
    139138}; 
    140139 

  • branches/Orange-Elaine-Distr-Dir-Branch/src/server/pvfs2-server.h

    r8478 r8480  
    172172    NUM_DFILES_REQ_KEY   = 6, 
    173173    DIST_DIR_ATTR_KEY    = 7, 
    174     DIST_DIRDATA_HANDLES = 8, 
    175     DIST_DIRDATA_BITMAP  = 9, 
    176     NUM_DIR_ENT_KEYS     =10 
     174    DIST_DIRDATA_HANDLES_KEY = 8, 
     175    DIST_DIRDATA_BITMAP_KEY      = 9 
    177176}; 
    178177 
    … …  
    531530    PVFS_fs_id fs_id; 
    532531    PVFS_handle_extent_array handle_extent_array; 
    533     PVFS_handle *dirent_handle; 
    534 //    PVFS_handle *handle_array_local; 
    535 //    PVFS_handle *handle_array_remote; 
     532    PVFS_size init_dirdata_size; 
     533 
     534    /* dist-dir-struct   
     535     * not in resp, only return meta handle  
     536     * should be in attr up-level, PINT_server_op*/ 
     537 
     538    /* inherit from create_op */ 
     539    /* not using these right now 
     540    const char **dirdata_servers; 
     541    const char **remote_dirdata_servers; 
     542    */ 
     543    int num_dirdata_servers; 
     544    PVFS_handle* handle_array_local;  
     545    PVFS_handle* handle_array_remote;  
    536546    int handle_array_local_count; 
    537547    int handle_array_remote_count; 
    538 //    const char **meta_servers; 
    539 //    const char **remote_meta_servers; 
    540     int num_meta_servers; 
    541     PVFS_size init_dirdata_size; 
     548    PVFS_error saved_error_code; 
     549    int handle_index; 
     550         
    542551}; 
    543552 
    … …  
    550559    PVFS_error* err_array; 
    551560    PVFS_ds_keyval_handle_info keyval_handle_info; 
     561    /* store them in resp.u.getattr.attr.u.dir 
    552562    int32_t num_dirent_handles; 
    553563    PVFS_handle *dirent_handle; 
     564    */ 
    554565    int num_dfiles_req; 
    555566    PVFS_handle *mirror_dfile_status_array;