Changeset 8949

Show
Ignore:
Timestamp:
07/14/11 09:44:37 (23 months ago)
Author:
mtmoore
Message:

cleanup some of create-immutable-copies.sm to use coding standards

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • branches/Orange-Branch/src/server/create-immutable-copies.sm

    r8948 r8949  
    13341334                                          "\ttask_id:%d" 
    13351335                                          "\terror_code:%d(%0x)" 
    1336                                           "\tremaining:%d\n" 
     1336                                          "\tremaining:%d\n", 
    13371337                                          mirror_op->op, 
    13381338                                          task_id, 
    … …  
    13701370                { 
    13711371                    gossip_debug(GOSSIP_MIRROR_DEBUG, "\tStatus already " 
    1372                                                       "established:%d(0x%0x)\n" 
     1372                                                      "established:%d(0x%0x)\n", 
    13731373                                 js_p->error_code, js_p->error_code); 
    13741374                } 
    … …  
    13771377                    gossip_debug(GOSSIP_MIRROR_DEBUG, "\tStatus came from " 
    13781378                                                      "error_code %d(0x%0x)\n", 
    1379                                                       error_code 
     1379                                                      error_code, 
    13801380                                                      error_code); 
    13811381                    js_p->error_code = respmir->write_status_code[i]; 
    … …  
    15951595    for (j=0; j<(imm_p->dfile_count*imm_p->copies); j++) 
    15961596    { 
    1597      gossip_debug(GOSSIP_MIRROR_DEBUG,"\t\thandle(%d):%llu\n", j,  
    1598                   llu(myHandle[j])); 
     1597        gossip_debug(GOSSIP_MIRROR_DEBUG,"\t\thandle(%d):%llu\n", j,  
     1598                     llu(myHandle[j])); 
    15991599    } 
    16001600 
    … …  
    16811681 
    16821682 
    1683 static PINT_sm_action check_store_job (struct PINT_smcb *smcb 
    1684                                       ,job_status_s *js_p) 
     1683static PINT_sm_action check_store_job (struct PINT_smcb *smcb, 
     1684                                       job_status_s *js_p) 
    16851685{    
    1686    gossip_debug(GOSSIP_MIRROR_DEBUG, 
    1687                       "Executing check_store_job....\n"); 
    1688    struct PINT_server_op *sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
    1689    PINT_server_create_copies_op *imm_p = &(sm_p->u.create_copies); 
    1690    int i; 
     1686    gossip_debug(GOSSIP_MIRROR_DEBUG, "Executing check_store_job....\n"); 
     1687    struct PINT_server_op *sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
     1688    PINT_server_create_copies_op *imm_p = &(sm_p->u.create_copies); 
     1689    int i; 
     1690 
     1691    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tjs_p->error_code:%d\n", 
     1692                 js_p->error_code); 
     1693 
     1694    if (js_p->error_code) 
     1695    { 
     1696        gossip_err("Unable to store datahandles and number of copies for this " 
     1697                   "mirror operation.\n"); 
     1698        gossip_err("\tMeta data handle is %llu\n",llu(imm_p->metadata_handle)); 
     1699        return SM_ACTION_COMPLETE; 
     1700    } 
     1701 
     1702    /* release memory used in previous job call */ 
     1703    for (i=0; i<sm_p->keyval_count; i++) 
     1704    { 
     1705        free(sm_p->key_a[i].buffer); 
     1706        free(sm_p->val_a[i].buffer); 
     1707    } 
     1708    free(sm_p->key_a); 
     1709    free(sm_p->val_a); 
     1710    sm_p->key_a = sm_p->val_a = NULL; 
     1711    sm_p->keyval_count = 0; 
     1712 
     1713    js_p->error_code = 0; 
     1714 
     1715    return SM_ACTION_COMPLETE; 
     1716} /* end state check_store_job */ 
     1717 
     1718 
     1719static PINT_sm_action replace_remote_datahandle_objects(struct PINT_smcb *smcb, 
     1720                                                        job_status_s *js_p) 
     1721{    
     1722    gossip_debug(GOSSIP_MIRROR_DEBUG, "Executing replace_remote_datahandle_" 
     1723                 "objects....\n"); 
     1724 
     1725    struct PINT_server_op *sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
     1726    PINT_server_create_copies_op *imm_p = &(sm_p->u.create_copies); 
     1727    job_id_t job_id; 
     1728    int ret;   
     1729    int tmpindex; 
     1730    PVFS_handle pool_handle; 
     1731 
     1732    js_p->error_code = 0; 
     1733 
     1734    if (!imm_p->handle_array_copies_remote) 
     1735    { 
     1736        gossip_debug(GOSSIP_MIRROR_DEBUG, "handle_array_copies_remote is " 
     1737                                          "null: %p\n", 
     1738                                          imm_p->handle_array_copies_remote); 
     1739        js_p->error_code = REPLACE_DONE; 
     1740        return SM_ACTION_COMPLETE; 
     1741    } 
     1742 
     1743    imm_p->handle_array_copies_remote_count--; 
     1744    if (imm_p->handle_array_copies_remote_count < 0) 
     1745    { 
     1746        js_p->error_code = REPLACE_DONE; 
     1747        return SM_ACTION_COMPLETE; 
     1748    } 
     1749 
     1750    tmpindex = imm_p->handle_array_copies_remote_count; 
     1751 
     1752    /* find the pool that this handle belongs to */ 
     1753    ret = job_precreate_pool_lookup_server( imm_p->remote_io_servers[tmpindex], 
     1754                                            PVFS_TYPE_DATAFILE,  
     1755                                            imm_p->fs_id, 
     1756                                            &pool_handle ); 
     1757    if (ret < 0) 
     1758    { 
     1759        imm_p->handle_array_copies_remote_count++; 
     1760        js_p->error_code = ret; 
     1761        return SM_ACTION_COMPLETE; 
     1762    } 
     1763 
     1764    ret = job_precreate_pool_fill( pool_handle, 
     1765                                   imm_p->fs_id, 
     1766                                   &(imm_p->handle_array_copies_remote 
     1767                                    [tmpindex]), 
     1768                                   1, 
     1769                                   smcb, 
     1770                                   0, 
     1771                                   js_p, 
     1772                                   &job_id, 
     1773                                   server_job_context, 
     1774                                   NULL ); 
     1775 
     1776    return ret; 
     1777} /* end action replace_remote_datahandle_objects */ 
     1778 
     1779 
     1780static PINT_sm_action remove_local_datahandle_objects(struct PINT_smcb *smcb, 
     1781                                                      job_status_s *js_p) 
     1782{    
     1783    gossip_debug(GOSSIP_MIRROR_DEBUG, "Executing remove_local_datahandle_" 
     1784                 "objects....\n"); 
    16911785   
    1692  
    1693    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tjs_p->error_code:%d\n" 
    1694                                    ,js_p->error_code); 
    1695  
    1696    if (js_p->error_code) 
    1697    { 
    1698       gossip_err("Unable to store datahandles and number of copies for this " 
    1699                  "mirror operation.\n"); 
    1700       gossip_err("\tMeta data handle is %llu\n",llu(imm_p->metadata_handle)); 
    1701       return SM_ACTION_COMPLETE; 
    1702    } 
    1703  
    1704    /*release memory used in previous job call*/ 
    1705    for (i=0; i<sm_p->keyval_count; i++) 
    1706    { 
    1707           free(sm_p->key_a[i].buffer); 
    1708           free(sm_p->val_a[i].buffer); 
    1709    } 
    1710    free(sm_p->key_a); 
    1711    free(sm_p->val_a); 
    1712    sm_p->key_a = sm_p->val_a = NULL; 
    1713    sm_p->keyval_count = 0; 
    1714  
    1715    js_p->error_code = 0; 
    1716  
    1717    return SM_ACTION_COMPLETE; 
    1718 }/*end state check_store_job*/ 
    1719  
    1720  
    1721  
    1722  
    1723 static PINT_sm_action replace_remote_datahandle_objects(struct PINT_smcb *smcb 
    1724                                                        ,job_status_s *js_p) 
    1725 {    
    1726    gossip_debug(GOSSIP_MIRROR_DEBUG, 
    1727                       "Executing replace_remote_datahandle_objects....\n"); 
    1728  
    1729    struct PINT_server_op *sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
    1730    PINT_server_create_copies_op *imm_p = &(sm_p->u.create_copies); 
    1731    job_id_t job_id; 
    1732    int ret;   
    1733    int tmpindex; 
    1734    PVFS_handle pool_handle; 
    1735  
    1736    js_p->error_code = 0; 
    1737  
    1738    if (!imm_p->handle_array_copies_remote) 
    1739    { 
    1740        gossip_debug(GOSSIP_MIRROR_DEBUG,"handle_array_copies_remote is " 
    1741                                         "null: %p\n" 
    1742                                         ,imm_p->handle_array_copies_remote); 
    1743        js_p->error_code = REPLACE_DONE; 
    1744        return SM_ACTION_COMPLETE; 
    1745    } 
    1746  
    1747    imm_p->handle_array_copies_remote_count--; 
    1748    if (imm_p->handle_array_copies_remote_count < 0) 
    1749    { 
    1750        js_p->error_code = REPLACE_DONE; 
    1751        return SM_ACTION_COMPLETE; 
    1752    } 
    1753  
    1754    tmpindex = imm_p->handle_array_copies_remote_count; 
    1755  
    1756    /* find the pool that this handle belongs to */ 
    1757    ret = job_precreate_pool_lookup_server( imm_p->remote_io_servers[tmpindex], 
    1758                                            PVFS_TYPE_DATAFILE,  
    1759                                           imm_p->fs_id 
    1760                                           ,&pool_handle ); 
    1761    if (ret < 0) 
    1762    { 
    1763       imm_p->handle_array_copies_remote_count++; 
    1764       js_p->error_code = ret; 
    1765       return SM_ACTION_COMPLETE; 
    1766    } 
    1767  
    1768    ret = job_precreate_pool_fill( pool_handle 
    1769                                  ,imm_p->fs_id 
    1770                                  ,&(imm_p->handle_array_copies_remote[tmpindex]) 
    1771                                  ,1 
    1772                                  ,smcb 
    1773                                  ,0 
    1774                                  ,js_p 
    1775                                  ,&job_id 
    1776                                  ,server_job_context 
    1777                                  ,NULL ); 
    1778  
    1779    return ret; 
    1780 }/*end action replace_remote_datahandle_objects*/ 
    1781  
    1782  
    1783  
    1784 static PINT_sm_action remove_local_datahandle_objects(struct PINT_smcb *smcb 
    1785                                                      ,job_status_s *js_p) 
    1786 {    
    1787    gossip_debug(GOSSIP_MIRROR_DEBUG, 
    1788                              "Executing remove_local_datahandle_objects....\n"); 
    1789    
    1790    struct PINT_server_op *sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
    1791    PINT_server_create_copies_op *imm_p = &(sm_p->u.create_copies); 
    1792    job_id_t job_id; 
    1793    int ret; 
    1794  
    1795    if (js_p->error_code) 
    1796        imm_p->saved_error_code = js_p->error_code; 
    1797  
    1798    js_p->error_code = 0; 
    1799  
    1800    if (!imm_p->handle_array_copies_local) 
    1801        return SM_ACTION_COMPLETE; 
    1802  
    1803  
    1804    ret = job_trove_dspace_remove_list( imm_p->fs_id 
    1805                                       ,imm_p->handle_array_copies_local 
    1806                                       ,NULL 
    1807                                       ,imm_p->handle_array_copies_local_count 
    1808                                       ,TROVE_SYNC 
    1809                                       ,smcb 
    1810                                       ,0 
    1811                                       ,js_p 
    1812                                       ,&job_id 
    1813                                       ,server_job_context 
    1814                                       ,NULL ); 
    1815  
    1816    return ret; 
    1817 }/*end action remove_local_datahandle_objects*/ 
    1818  
    1819  
     1786    struct PINT_server_op *sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
     1787    PINT_server_create_copies_op *imm_p = &(sm_p->u.create_copies); 
     1788    job_id_t job_id; 
     1789    int ret; 
     1790 
     1791    if (js_p->error_code) 
     1792        imm_p->saved_error_code = js_p->error_code; 
     1793 
     1794    js_p->error_code = 0; 
     1795 
     1796    if (!imm_p->handle_array_copies_local) 
     1797        return SM_ACTION_COMPLETE; 
     1798 
     1799    ret = job_trove_dspace_remove_list( imm_p->fs_id,  
     1800                                        imm_p->handle_array_copies_local, 
     1801                                        NULL, 
     1802                                        imm_p->handle_array_copies_local_count, 
     1803                                        TROVE_SYNC, 
     1804                                        smcb, 
     1805                                        0, 
     1806                                        js_p, 
     1807                                        &job_id, 
     1808                                        server_job_context, 
     1809                                        NULL ); 
     1810 
     1811    return ret; 
     1812} /* end action remove_local_datahandle_objects */ 
    18201813 
    18211814 
    18221815static PINT_sm_action cleanup (struct PINT_smcb *smcb, job_status_s *js_p) 
    18231816{    
    1824    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing cleanup....\n"); 
    1825  
    1826    struct PINT_server_op *sm_p = NULL; 
    1827    PINT_server_create_copies_op *imm_p = NULL; 
    1828    int i; 
    1829  
    1830    sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
    1831    imm_p = &(sm_p->u.create_copies); 
    1832  
    1833    if (js_p->error_code == NOTHING_TO_DO) 
    1834        js_p->error_code = 0; 
    1835  
    1836    if (imm_p->my_remote_servers) 
    1837        free(imm_p->my_remote_servers); 
    1838  
    1839    if (imm_p->writes_completed) 
    1840        free(imm_p->writes_completed); 
    1841  
    1842    if (imm_p->handle_array_copies_local) 
    1843        free(imm_p->handle_array_copies_local); 
    1844  
    1845    if (imm_p->handle_array_copies_remote) 
    1846        free(imm_p->handle_array_copies_remote); 
    1847  
    1848    if (imm_p->remote_io_servers) 
    1849    { 
    1850        for (i=0;i<imm_p->remote_io_servers_count;i++) 
     1817    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing cleanup....\n"); 
     1818 
     1819    struct PINT_server_op *sm_p = NULL; 
     1820    PINT_server_create_copies_op *imm_p = NULL; 
     1821    int i; 
     1822 
     1823    sm_p = PINT_sm_frame(smcb,PINT_FRAME_CURRENT); 
     1824    imm_p = &(sm_p->u.create_copies); 
     1825 
     1826    if (js_p->error_code == NOTHING_TO_DO) 
     1827        js_p->error_code = 0; 
     1828 
     1829    if (imm_p->my_remote_servers) 
     1830        free(imm_p->my_remote_servers); 
     1831 
     1832    if (imm_p->writes_completed) 
     1833        free(imm_p->writes_completed); 
     1834 
     1835    if (imm_p->handle_array_copies_local) 
     1836        free(imm_p->handle_array_copies_local); 
     1837 
     1838    if (imm_p->handle_array_copies_remote) 
     1839        free(imm_p->handle_array_copies_remote); 
     1840 
     1841    if (imm_p->remote_io_servers) 
     1842    { 
     1843        for (i=0;i<imm_p->remote_io_servers_count;i++) 
    18511844            free(imm_p->remote_io_servers[i]); 
    1852        free(imm_p->remote_io_servers); 
    1853    } 
    1854  
    1855    if (imm_p->local_io_servers) 
    1856    { 
    1857       for (i=0; i<imm_p->local_io_servers_count; i++) 
    1858           free(imm_p->local_io_servers[i]); 
    1859       free(imm_p->local_io_servers); 
    1860    } 
    1861  
    1862    if (imm_p->handle_array_base) 
    1863        free(imm_p->handle_array_base); 
    1864  
    1865    if (imm_p->handle_array_base_local) 
    1866        free(imm_p->handle_array_base_local); 
    1867  
    1868    if (imm_p->handle_array_copies) 
    1869        free(imm_p->handle_array_copies); 
    1870  
    1871    if (imm_p->io_servers) 
    1872    { 
    1873       for (i=0;i<imm_p->io_servers_required;i++) 
    1874           free(imm_p->io_servers[i]); 
    1875       free(imm_p->io_servers); 
    1876    } 
    1877  
    1878    if (imm_p->ds_attr_a) 
    1879       free(imm_p->ds_attr_a); 
    1880  
    1881    if (imm_p->bstream_array_base_local) 
    1882       free(imm_p->bstream_array_base_local); 
    1883  
    1884    if (!js_p->error_code && imm_p->saved_error_code) 
    1885       js_p->error_code = imm_p->saved_error_code; 
    1886  
    1887    if (imm_p->dist && imm_p->dist->dist_name) 
    1888       free(imm_p->dist->dist_name); 
    1889    if (imm_p->dist) 
    1890       free(imm_p->dist); 
    1891  
    1892    gossip_debug(GOSSIP_MIRROR_DEBUG,"Leaving cleanup: error_code:%d.....\n" 
    1893                                    ,js_p->error_code); 
    1894  
     1845        free(imm_p->remote_io_servers); 
     1846    } 
     1847 
     1848    if (imm_p->local_io_servers) 
     1849    { 
     1850        for (i=0; i<imm_p->local_io_servers_count; i++) 
     1851            free(imm_p->local_io_servers[i]); 
     1852        free(imm_p->local_io_servers); 
     1853    } 
     1854 
     1855    if (imm_p->handle_array_base) 
     1856        free(imm_p->handle_array_base); 
     1857 
     1858    if (imm_p->handle_array_base_local) 
     1859        free(imm_p->handle_array_base_local); 
     1860 
     1861    if (imm_p->handle_array_copies) 
     1862        free(imm_p->handle_array_copies); 
     1863 
     1864    if (imm_p->io_servers) 
     1865    { 
     1866        for (i=0;i<imm_p->io_servers_required;i++) 
     1867        { 
     1868            free(imm_p->io_servers[i]); 
     1869        } 
     1870        free(imm_p->io_servers); 
     1871    } 
     1872 
     1873    if (imm_p->ds_attr_a) 
     1874        free(imm_p->ds_attr_a); 
     1875 
     1876    if (imm_p->bstream_array_base_local) 
     1877        free(imm_p->bstream_array_base_local); 
     1878 
     1879    if (!js_p->error_code && imm_p->saved_error_code) 
     1880        js_p->error_code = imm_p->saved_error_code; 
     1881 
     1882    if (imm_p->dist && imm_p->dist->dist_name) 
     1883        free(imm_p->dist->dist_name); 
     1884    if (imm_p->dist) 
     1885        free(imm_p->dist); 
     1886 
     1887    gossip_debug(GOSSIP_MIRROR_DEBUG, "Leaving cleanup: error_code:%d.....\n", 
     1888                                      js_p->error_code); 
    18951889       
    1896    return SM_ACTION_COMPLETE; 
    1897 }/*end action cleanup*/ 
     1890    return SM_ACTION_COMPLETE; 
     1891} /* end action cleanup */ 
    18981892 
    18991893 
    19001894int mirror_comp_fn(void *v_p, struct PVFS_server_resp *resp_p, int i) 
    19011895{ 
    1902    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing mirror_comp_fn.....\n"); 
    1903  
    1904    PINT_smcb *smcb = v_p; 
    1905    struct PINT_server_op *mirror_op =  
    1906                                    PINT_sm_frame(smcb, PINT_MSGPAIR_PARENT_SM); 
    1907    struct PVFS_servresp_mirror *respmir = &(mirror_op->resp.u.mirror);  
    1908    int k; 
    1909  
    1910    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tmirror_op:%p\n",mirror_op); 
    1911  
    1912    /* only posted one msgpair per source handle*/ 
    1913    assert(i==0); 
    1914  
    1915    /* If the response status is non-zero, then the rest of the response is  */ 
    1916    /* NOT encoded in final-response.sm.  So, there are no values to access. */ 
    1917    /* NOTE: An error code will be returned in the status field IFF NONE of  */ 
    1918    /* the writes were successful.  Otherwise, the status of each write will */ 
    1919    /* be contained in the write_status_code field.                          */  
    1920    if (resp_p->status != 0) 
    1921       return(resp_p->status); 
    1922  
    1923    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tresp->src_handle:%llu " 
    1924                                     "\tresp->src_server_nr:%d " 
    1925                                     "\tresp->status:%d\n" 
    1926                                    ,llu(resp_p->u.mirror.src_handle) 
    1927                                    ,resp_p->u.mirror.src_server_nr 
    1928                                    ,resp_p->status ); 
    1929    for (k=0; k<resp_p->u.mirror.dst_count; k++) 
    1930    { 
    1931        gossip_debug(GOSSIP_MIRROR_DEBUG,"\tresp->bytes_written[%d]:%d" 
    1932                                         "\tresp->write_status_code[%d]:%d\n" 
    1933                                        ,k 
    1934                                        ,resp_p->u.mirror.bytes_written[k] 
    1935                                        ,k 
    1936                                        ,resp_p->u.mirror.write_status_code[k]); 
    1937    } 
    1938  
    1939    assert(mirror_op->op == PVFS_SERV_MIRROR); 
    1940  
    1941    memset(&(mirror_op->resp),0,sizeof(mirror_op->resp)); 
    1942  
    1943    /*capture information from the mirror operation.*/ 
    1944    respmir->src_handle    = resp_p->u.mirror.src_handle; 
    1945    respmir->src_server_nr = resp_p->u.mirror.src_server_nr; 
    1946    respmir->dst_count     = resp_p->u.mirror.dst_count; 
    1947  
    1948    respmir->bytes_written = malloc(sizeof(uint32_t) * respmir->dst_count); 
    1949    if (!respmir->bytes_written) 
    1950    { 
    1951       gossip_lerr("Unable to allocate respmir->bytes_written\n"); 
    1952       return (-PVFS_ENOMEM); 
    1953    } 
    1954    memset(respmir->bytes_written,0,sizeof(uint32_t) * respmir->dst_count); 
    1955  
    1956    respmir->write_status_code = malloc(sizeof(uint32_t) * respmir->dst_count); 
    1957    if (!respmir->write_status_code) 
    1958    { 
    1959        gossip_lerr("Unable to allocate respmir->write_status_code.\n"); 
    1960        return (-PVFS_ENOMEM); 
    1961    } 
    1962    memset(respmir->write_status_code,0,sizeof(uint32_t) * respmir->dst_count); 
    1963  
    1964    memcpy(respmir->bytes_written,resp_p->u.mirror.bytes_written 
    1965          ,sizeof(uint32_t) * respmir->dst_count); 
    1966    memcpy(respmir->write_status_code,resp_p->u.mirror.write_status_code 
    1967          ,sizeof(uint32_t) * respmir->dst_count); 
    1968  
    1969    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tsmcb->base_frame:%d\tframe_count:%d\n" 
    1970                                    ,smcb->base_frame,smcb->frame_count); 
    1971  
    1972    return(0); 
    1973 } /*end msgpair completion function mirror_comp_fn*/ 
    1974  
    1975  
     1896    gossip_debug(GOSSIP_MIRROR_DEBUG, "Executing mirror_comp_fn.....\n"); 
     1897 
     1898    PINT_smcb *smcb = v_p; 
     1899    struct PINT_server_op *mirror_op = PINT_sm_frame(smcb,  
     1900        PINT_MSGPAIR_PARENT_SM); 
     1901    struct PVFS_servresp_mirror *respmir = &(mirror_op->resp.u.mirror);  
     1902    int k; 
     1903 
     1904    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tmirror_op:%p\n",mirror_op); 
     1905 
     1906    /* only posted one msgpair per source handle*/ 
     1907    assert(i==0); 
     1908 
     1909    /* If the response status is non-zero, then the rest of the response is  
     1910     * NOT encoded in final-response.sm.  So, there are no values to access. 
     1911     * NOTE: An error code will be returned in the status field IFF NONE of 
     1912     * the writes were successful.  Otherwise, the status of each write will 
     1913     * be contained in the write_status_code field. */  
     1914    if (resp_p->status != 0) 
     1915        return(resp_p->status); 
     1916 
     1917    gossip_debug(GOSSIP_MIRROR_DEBUG, "\tresp->src_handle:%llu " 
     1918                                      "\tresp->src_server_nr:%d " 
     1919                                      "\tresp->status:%d\n", 
     1920                                      llu(resp_p->u.mirror.src_handle), 
     1921                                      resp_p->u.mirror.src_server_nr, 
     1922                                      resp_p->status ); 
     1923    for (k=0; k<resp_p->u.mirror.dst_count; k++) 
     1924    { 
     1925        gossip_debug(GOSSIP_MIRROR_DEBUG, "\tresp->bytes_written[%d]:%d" 
     1926                                          "\tresp->write_status_code[%d]:%d\n", 
     1927                                          k, 
     1928                                          resp_p->u.mirror.bytes_written[k], 
     1929                                          k, 
     1930                                          resp_p->u.mirror. 
     1931                                            write_status_code[k]); 
     1932    } 
     1933 
     1934    assert(mirror_op->op == PVFS_SERV_MIRROR); 
     1935 
     1936    memset(&(mirror_op->resp),0,sizeof(mirror_op->resp)); 
     1937 
     1938    /* capture information from the mirror operation. */ 
     1939    respmir->src_handle = resp_p->u.mirror.src_handle; 
     1940    respmir->src_server_nr = resp_p->u.mirror.src_server_nr; 
     1941    respmir->dst_count = resp_p->u.mirror.dst_count; 
     1942 
     1943    respmir->bytes_written = malloc(sizeof(uint32_t) * respmir->dst_count); 
     1944    if (!respmir->bytes_written) 
     1945    { 
     1946        gossip_lerr("Unable to allocate respmir->bytes_written\n"); 
     1947        return (-PVFS_ENOMEM); 
     1948    } 
     1949    memset(respmir->bytes_written,0,sizeof(uint32_t) * respmir->dst_count); 
     1950 
     1951    respmir->write_status_code = malloc(sizeof(uint32_t) * respmir->dst_count); 
     1952    if (!respmir->write_status_code) 
     1953    { 
     1954        gossip_lerr("Unable to allocate respmir->write_status_code.\n"); 
     1955        return (-PVFS_ENOMEM); 
     1956    } 
     1957    memset(respmir->write_status_code,0,sizeof(uint32_t) * respmir->dst_count); 
     1958 
     1959    memcpy(respmir->bytes_written,resp_p->u.mirror.bytes_written,  
     1960        sizeof(uint32_t) * respmir->dst_count); 
     1961    memcpy(respmir->write_status_code,resp_p->u.mirror.write_status_code,  
     1962        sizeof(uint32_t) * respmir->dst_count); 
     1963 
     1964    gossip_debug(GOSSIP_MIRROR_DEBUG, "\tsmcb->base_frame:%d\tframe_count:%d\n", 
     1965                 smcb->base_frame,smcb->frame_count); 
     1966 
     1967    return(0); 
     1968} /* end msgpair completion function mirror_comp_fn */ 
    19761969 
    19771970 
    … …  
    19791972                    struct PINT_server_create_copies_op *imm_p) 
    19801973{ 
    1981    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing reorganize_copy_handles..\n"); 
    1982  
    1983    uint64_t i,j,k,rows,in_cols,out_cols; 
    1984    PVFS_handle *copies_out = NULL; 
    1985    PVFS_handle *copies_in  = imm_p->handle_array_copies; 
    1986  
    1987  
    1988    rows     = imm_p->copies; 
    1989    in_cols  = imm_p->io_servers_required; 
    1990    out_cols = imm_p->dfile_count; 
    1991  
    1992    /* allocate copies_out array */ 
    1993    copies_out = malloc(sizeof(PVFS_handle) * rows * out_cols); 
    1994    if (!copies_out) 
    1995    { 
    1996       gossip_lerr("Unable to allocate memeory.\n"); 
    1997       return (NULL); 
    1998    } 
    1999    memset(copies_out,0,sizeof(PVFS_handle) * rows * out_cols); 
    2000  
    2001    for (i=0; i<(in_cols*rows); i++) 
    2002    { 
    2003        gossip_debug(GOSSIP_MIRROR_DEBUG,"\thandle_array_copies(%d):%llu\n" 
    2004                                        ,(int)i 
    2005                                        ,llu(copies_in[i])); 
    2006    } 
    2007  
    2008    /*this code copies copies_in[n+1] to copies_out[n] within the same row*/ 
    2009    /*each row represents one copy of the logical file, i.e., each of its */ 
    2010    /*datahandles.                                                        */ 
    2011    for (i=0,k=1; i<rows; i++,k++) 
    2012    { 
    2013        for (j=0; j<out_cols; j++) 
    2014        { 
    2015            copies_out[(i*out_cols)+j] = copies_in[(i*in_cols)+((j+k)%in_cols)]; 
    2016        } 
    2017    } 
     1974    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing reorganize_copy_handles..\n"); 
     1975 
     1976    uint64_t i, j, k, rows, in_cols, out_cols; 
     1977    PVFS_handle *copies_out = NULL; 
     1978    PVFS_handle *copies_in = imm_p->handle_array_copies; 
     1979 
     1980    rows = imm_p->copies; 
     1981    in_cols = imm_p->io_servers_required; 
     1982    out_cols = imm_p->dfile_count; 
     1983 
     1984    /* allocate copies_out array */ 
     1985    copies_out = malloc(sizeof(PVFS_handle) * rows * out_cols); 
     1986    if (!copies_out) 
     1987    { 
     1988        gossip_lerr("Unable to allocate memeory.\n"); 
     1989        return (NULL); 
     1990    } 
     1991    memset(copies_out, 0, sizeof(PVFS_handle) * rows * out_cols); 
     1992 
     1993    for (i=0; i<(in_cols*rows); i++) 
     1994    { 
     1995        gossip_debug(GOSSIP_MIRROR_DEBUG, "\thandle_array_copies(%d):%llu\n", 
     1996                                          (int)i, 
     1997                                          llu(copies_in[i])); 
     1998    } 
     1999 
     2000    /* this code copies copies_in[n+1] to copies_out[n] within the same row 
     2001     * each row represents one copy of the logical file, i.e., each of its 
     2002     * datahandles. */ 
     2003    for (i=0,k=1; i<rows; i++,k++) 
     2004    { 
     2005        for (j=0; j<out_cols; j++) 
     2006        { 
     2007            copies_out[(i*out_cols)+j] = copies_in[(i*in_cols)+((j+k)%in_cols)]; 
     2008        } 
     2009    } 
    20182010    
    2019    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tReorg'd Handles Array:\n"); 
    2020    for (i=0; i<rows; i++) 
    2021    { 
    2022        for (j=0; j<out_cols; j++) 
    2023        { 
    2024            gossip_debug(GOSSIP_MIRROR_DEBUG,"\t\t(%d,%d):%llu\n" 
    2025                                 ,(int)i,(int)j 
    2026                                 ,llu(copies_out[(i*out_cols)+j])); 
    2027        } 
    2028    } 
    2029  
    2030    return(copies_out); 
    2031 }/*end function reorganize_copy_handles*/ 
     2011    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tReorg'd Handles Array:\n"); 
     2012    for (i=0; i<rows; i++) 
     2013    { 
     2014        for (j=0; j<out_cols; j++) 
     2015        { 
     2016            gossip_debug(GOSSIP_MIRROR_DEBUG, "\t\t(%d,%d):%llu\n", 
     2017                                              (int)i, (int)j, 
     2018                                              llu(copies_out[(i*out_cols)+j])); 
     2019        } 
     2020    } 
     2021 
     2022    return(copies_out); 
     2023} /* end function reorganize_copy_handles */ 
    20322024 
    20332025static int get_server_names(PINT_server_create_copies_op *imm_p) 
    20342026{ 
    2035   char **list=NULL; 
    2036   int size=0 
    2037      ,i,j,ret; 
    2038  
    2039   gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing get_server_names....\n"); 
    2040  
    2041   gossip_debug(GOSSIP_MIRROR_DEBUG,    "\tio_servers(before):\n"); 
    2042   for (i=0; i<imm_p->io_servers_required; i++) 
    2043       gossip_debug(GOSSIP_MIRROR_DEBUG,"\t              [%d]:%s" 
    2044                                        "\tlength:%d\n" 
    2045                                       ,i 
    2046                                       ,imm_p->io_servers[i] 
    2047                                       ,(int)strlen(imm_p->io_servers[i])); 
    2048  
    2049  
    2050  
    2051   /*Get access to the io server names residing in the cache*/ 
    2052   ret = PINT_cached_config_io_server_names(&list,&size,imm_p->fs_id); 
    2053   if (ret) 
    2054   { 
    2055       if (list) 
    2056          free(list); 
    2057       gossip_lerr("Unable to retrieve IO server names from the cache.\n"); 
    2058       return(ret); 
    2059   } 
    2060  
    2061   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tReturned from PINT_cached_config...\n"); 
    2062   for (i=0; i<size; i++) 
    2063     gossip_debug(GOSSIP_MIRROR_DEBUG,"\t\tValue of      size:%d\n" 
    2064                                      "\t\t\t\tValue of   list[%d]:%p\n" 
    2065                                      "\t\t\t\tValue of  *list[%d]:%s\n" 
    2066                                      "\t\t\t\tstrlen of  list[%d]:%d\n\n" 
    2067                                     ,size 
    2068                                     ,i,list[i],i,list[i] 
    2069                                     ,i,(int)strlen(list[i])); 
    2070  
    2071   /*Remove server names that are already being used in the io_servers list*/ 
    2072   for (i=0; i<size; i++) 
    2073   { 
    2074      for (j=0; j<imm_p->dfile_count; j++) 
    2075      { 
    2076         if (strncmp(list[i],imm_p->io_servers[j],strlen(list[i])) == 0) 
    2077         { 
    2078          list[i] = NULL; 
    2079          break; 
    2080         } 
    2081      }/*end for*/ 
    2082   }/*end for*/ 
    2083  
    2084   /*Add server names to io_servers list*/ 
    2085   for (i=0,j=imm_p->dfile_count; i<size && j<imm_p->io_servers_required; i++) 
    2086   { 
    2087      if (list[i]) 
    2088      { 
    2089         strncpy(imm_p->io_servers[j],list[i],SERVER_NAME_MAX-1); 
    2090         j++; 
    2091      } 
    2092   }/*end for*/ 
    2093  
    2094   gossip_debug(GOSSIP_MIRROR_DEBUG,    "\tio_servers(after):\n"); 
    2095   for (i=0; i<imm_p->io_servers_required; i++) 
    2096       gossip_debug(GOSSIP_MIRROR_DEBUG,"\t             [%d]:%s\n" 
    2097                                       ,i 
    2098                                       ,imm_p->io_servers[i]); 
    2099  
    2100   /*deallocate memory used for "list"*/ 
    2101   free(list); 
    2102  
    2103   return (0); 
    2104 }/*end function get_server_names*/ 
    2105  
    2106 /******************************************************************************/ 
    2107 /* Right now, this state machine is not called as a standalone request. It is */ 
    2108 /* only called as a nested machine from seteattr; however, when time comes to */ 
    2109 /* create a standalone server request, the values used for the request        */ 
    2110 /* parameters are listed below.                                               */ 
    2111 /******************************************************************************/ 
    2112 static inline int PINT_get_object_ref_copies( struct PVFS_server_req *req 
    2113                                              ,PVFS_fs_id *fs_id 
    2114                                              ,PVFS_handle *handle ) 
     2027    char **list=NULL; 
     2028    int size=0,i,j,ret; 
     2029 
     2030    gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing get_server_names....\n"); 
     2031 
     2032    gossip_debug(GOSSIP_MIRROR_DEBUG,    "\tio_servers(before):\n"); 
     2033    for (i=0; i<imm_p->io_servers_required; i++) 
     2034        gossip_debug(GOSSIP_MIRROR_DEBUG, "\t              [%d]:%s" 
     2035                                          "\tlength:%d\n", 
     2036                                          i, 
     2037                                          imm_p->io_servers[i], 
     2038                                          (int)strlen(imm_p->io_servers[i])); 
     2039 
     2040    /* Get access to the io server names residing in the cache */ 
     2041    ret = PINT_cached_config_io_server_names(&list, &size, imm_p->fs_id); 
     2042    if (ret) 
     2043    { 
     2044        if (list) 
     2045            free(list); 
     2046        gossip_lerr("Unable to retrieve IO server names from the cache.\n"); 
     2047        return(ret); 
     2048    } 
     2049 
     2050    gossip_debug(GOSSIP_MIRROR_DEBUG,"\tReturned from PINT_cached_config...\n"); 
     2051    for (i=0; i<size; i++) 
     2052        gossip_debug(GOSSIP_MIRROR_DEBUG, "\t\tValue of      size:%d\n" 
     2053                                          "\t\t\t\tValue of   list[%d]:%p\n" 
     2054                                          "\t\t\t\tValue of  *list[%d]:%s\n" 
     2055                                          "\t\t\t\tstrlen of  list[%d]:%d\n\n", 
     2056                                          size, 
     2057                                          i, list[i], i, list[i], 
     2058                                          i, (int)strlen(list[i])); 
     2059 
     2060    /* Remove server names that are already being used in the io_servers list */ 
     2061    for (i=0; i<size; i++) 
     2062    { 
     2063        for (j=0; j<imm_p->dfile_count; j++) 
     2064        { 
     2065            if (strncmp(list[i],imm_p->io_servers[j],strlen(list[i])) == 0) 
     2066            { 
     2067                list[i] = NULL; 
     2068                break; 
     2069            } 
     2070        } /* end for */ 
     2071    } /* end for */ 
     2072 
     2073    /* Add server names to io_servers list */ 
     2074    for (i=0,j=imm_p->dfile_count; i<size && j<imm_p->io_servers_required; i++) 
     2075    { 
     2076        if (list[i]) 
     2077        { 
     2078            strncpy(imm_p->io_servers[j],list[i],SERVER_NAME_MAX-1); 
     2079            j++; 
     2080        } 
     2081    } /*end for*/ 
     2082 
     2083    gossip_debug(GOSSIP_MIRROR_DEBUG,    "\tio_servers(after):\n"); 
     2084    for (i=0; i<imm_p->io_servers_required; i++) 
     2085        gossip_debug(GOSSIP_MIRROR_DEBUG,"\t             [%d]:%s\n", 
     2086                     i, imm_p->io_servers[i]); 
     2087 
     2088    /* deallocate memory used for "list" */ 
     2089    free(list); 
     2090 
     2091    return (0); 
     2092} /* end function get_server_names */ 
     2093 
     2094/* Right now, this state machine is not called as a standalone request. It is 
     2095 * only called as a nested machine from seteattr; however, when time comes to 
     2096 * create a standalone server request, the values used for the request  
     2097 * parameters are listed below. */ 
     2098static inline int PINT_get_object_ref_copies( struct PVFS_server_req *req, 
     2099                                              PVFS_fs_id *fs_id, 
     2100                                              PVFS_handle *handle ) 
    21152101{ 
    2116    *fs_id  = req->u.seteattr.fs_id; 
    2117    *handle = req->u.seteattr.handle;      
     2102    *fs_id  = req->u.seteattr.fs_id; 
     2103    *handle = req->u.seteattr.handle;      
    21182104 
    21192105    return 0; 
    21202106}; 
    21212107 
    2122 /*request parameters*/ 
     2108/* request parameters */ 
    21232109struct PINT_server_req_params pvfs2_create_immutable_copies_params = 
    21242110{ 
    … …  
    21302116        .state_machine = &pvfs2_create_immutable_copies_sm 
    21312117}; 
    2132  
    2133 /****** E N D  O F  F I L E *******************************/