home *** CD-ROM | disk | FTP | other *** search
/ ftp.parl.clemson.edu / 2015-02-07.ftp.parl.clemson.edu.tar / ftp.parl.clemson.edu / pub / pvfs2 / orangefs-2.8.3-20110323.tar.gz / orangefs-2.8.3-20110323.tar / orangefs / test / io / buffer / trove-init.c < prev   
C/C++ Source or Header  |  2009-09-02  |  7KB  |  241 lines
  1. #include <errno.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <sys/time.h>
  5. #include <stdlib.h>
  6. #ifdef HAVE_MALLOC_H
  7. #include <malloc.h>
  8. #endif
  9.  
  10. #include "trove.h"
  11. #include "pvfs2-internal.h"
  12.  
  13. #define MB 1024*1024
  14. enum {
  15.     INIT_TEST_SIZE = 40*MB,
  16.     SSPACE_SIZE = 64,
  17.     FS_SIZE = 64,
  18.     PATH_SIZE = 256,
  19.     FS_COLL_ID = 9,
  20.     ADMIN_COLL_ID = 10
  21. };
  22.  
  23. enum {
  24.     TROVE_TEST_DIR  = 1,
  25.     TROVE_TEST_FILE = 2,
  26.     TROVE_TEST_BSTREAM = 3
  27. };
  28.  
  29. char storage_space[SSPACE_SIZE] = "/tmp/trove-test-space";
  30. char file_system[FS_SIZE] = "fs-foo";
  31. char *method_name;
  32. TROVE_handle parent_handle;
  33. char path_to_file[PATH_SIZE] = "/baz";
  34.  
  35. int trove_init(TROVE_coll_id *coll_id_p, TROVE_handle *handle, TROVE_context_id *context_p);
  36.  
  37. int path_lookup(TROVE_coll_id coll_id,
  38.                 TROVE_context_id trove_context,
  39.                 char *path, TROVE_handle *out_handle_p);
  40.  
  41. TROVE_handle requested_file_handle = 4095;
  42.  
  43.  
  44. int trove_init(TROVE_coll_id *coll_id_p, TROVE_handle *handle, TROVE_context_id *context_p)
  45. {
  46.     TROVE_op_id op_id;
  47.     TROVE_context_id trove_context = -1;
  48.     char path_name[PATH_SIZE];
  49.     TROVE_coll_id coll_id;
  50.     TROVE_handle file_handle, parent_handle;
  51.     TROVE_extent cur_extent;
  52.     TROVE_handle_extent_array extent_array;
  53.     char *file_name;
  54.     char *mybuffer;
  55.  
  56.     int ret = -1;
  57.     int count;
  58.  
  59.  
  60.     char *mem_offset_array[4] = {0};
  61.     TROVE_size mem_size_array[4] = { 5*MB, 5*MB, 5*MB, 5*MB };
  62.     int mem_count = 4;
  63.     TROVE_offset stream_offset_array[4] = { 0, 5*MB, 10*MB, 15*MB};
  64.     TROVE_size stream_size_array[4] = { 5*MB, 5*MB, 5*MB, 5*MB };
  65.     int stream_count = 4;
  66.     TROVE_size output_size;
  67.     void *user_ptr_array[1] = { (char *) 13 };
  68.  
  69.  
  70.     TROVE_ds_state state;
  71.     TROVE_keyval_s key, val;
  72.  
  73.     ret = trove_initialize(
  74.     TROVE_METHOD_DBPF, NULL, storage_space, storage_space, 0);
  75.     if (ret < 0) {
  76.         fprintf(stderr, "initialize failed: run trove-mkfs first.\n");
  77.         return -1;
  78.     }
  79.  
  80.     /* try to look up collection used to store file system */
  81.     ret = trove_collection_lookup(
  82.     TROVE_METHOD_DBPF, file_system, &coll_id, NULL, &op_id);
  83.     if (ret < 0) {
  84.         fprintf(stderr, "collection lookup failed.\n");
  85.         return -1;
  86.     }
  87.  
  88.     ret = trove_open_context(coll_id, &trove_context);
  89.     if (ret < 0)
  90.     {
  91.         fprintf(stderr, "trove_open_context failed\n");
  92.         return -1;
  93.     }
  94.  
  95.     path_name[0] = '/';
  96.     path_name[1] = '\0';
  97.     file_name = path_to_file + strlen(path_name);
  98.     printf("path is %s, file-name=%s\n", path_name, file_name);
  99.  
  100.     /* find the parent directory handle */
  101.     ret = path_lookup(coll_id, trove_context, path_name, &parent_handle);
  102.     if (ret < 0) {
  103.         return -1;
  104.     }
  105.     fprintf(stderr, "%s: handle=%lld\n", path_name, lld(parent_handle));
  106.  
  107.     
  108.     /* find the parent directory handle */
  109.     ret = path_lookup(coll_id, trove_context, path_name, &parent_handle);
  110.     if (ret < 0) {
  111.         return -1;
  112.     }
  113.  
  114.     file_handle = 0;
  115.  
  116.     cur_extent.first = cur_extent.last = requested_file_handle;
  117.     extent_array.extent_count = 1;
  118.     extent_array.extent_array = &cur_extent;
  119.     ret = trove_dspace_create(coll_id,
  120.                               &extent_array,
  121.                               &file_handle,
  122.                               TROVE_TEST_FILE,
  123.                               NULL,
  124.                               0 /* flags */,
  125.                               NULL,
  126.                               trove_context,
  127.                               &op_id,
  128.                               NULL);
  129.     while (ret == 0) ret = trove_dspace_test(
  130.         coll_id, op_id, trove_context, &count, NULL, NULL, &state,
  131.         TROVE_DEFAULT_TEST_TIMEOUT);
  132.     if (ret < 0) {
  133.         fprintf(stderr, "dspace create failed.\n");
  134.         return -1;
  135.     }
  136.  
  137.     /* add new file name/handle pair to parent directory */
  138.     key.buffer = file_name;
  139.     key.buffer_sz = strlen(file_name) + 1;
  140.     val.buffer = &file_handle;
  141.     val.buffer_sz = sizeof(file_handle);
  142.     ret = trove_keyval_write(coll_id, parent_handle, &key, &val,
  143.                                  0, NULL, NULL, trove_context, &op_id, NULL);
  144.     while (ret == 0) ret = trove_dspace_test(
  145.          coll_id, op_id, trove_context, &count, NULL, NULL, &state,
  146.          TROVE_DEFAULT_TEST_TIMEOUT);
  147.     if (ret < 0) {
  148.          fprintf(stderr, "keyval write failed.\n");
  149.          return -1;
  150.     }
  151.  
  152.     mybuffer = (char *)malloc(INIT_TEST_SIZE);
  153.     if (!mybuffer)
  154.     {
  155.         fprintf(stderr, "mem.\n");
  156.         return(-1);
  157.     }
  158.  
  159.     
  160.     mem_offset_array[0] = mybuffer;
  161.     mem_offset_array[2] = (mem_offset_array[0] + 10*MB);
  162.     mem_offset_array[1] = (mem_offset_array[2] + 10*MB);
  163.     mem_offset_array[3] = (mem_offset_array[1] + 10*MB);
  164.  
  165.     memset(mem_offset_array[0], 0xF0, 10*MB);
  166.     memset(mem_offset_array[1], 0xF1, 10*MB);
  167.     memset(mem_offset_array[2], 0xF2, 10*MB);
  168.     memset(mem_offset_array[3], 0xF3, 10*MB);
  169.  
  170.  
  171.     ret = trove_bstream_write_list(coll_id,
  172.                                    file_handle,
  173.                                    mem_offset_array,
  174.                                    mem_size_array,
  175.                                    mem_count,
  176.                                    stream_offset_array,
  177.                                    stream_size_array,
  178.                                    stream_count,
  179.                                    &output_size,
  180.                                    0, /* flags */
  181.                                    NULL, /* vtag */
  182.                                    user_ptr_array,
  183.                                    trove_context,
  184.                                    &op_id,
  185.                                    NULL);
  186.         while (ret == 0) ret = trove_dspace_test(
  187.             coll_id, op_id, trove_context, &count, NULL, NULL, &state,
  188.             TROVE_DEFAULT_TEST_TIMEOUT);
  189.         if (ret < 0) {
  190.             fprintf(stderr, "listio write failed\n");
  191.             return -1;
  192.         }
  193.  
  194.     *coll_id_p = coll_id;
  195.     *handle = parent_handle;
  196.     *context_p = trove_context;
  197.  
  198.     fprintf(stderr, "+++++++++++++++++++++++++++++++\n");
  199.     fprintf(stderr, "Trove init: coll_id=%d, handle=%lld, context=%d\n", coll_id, lld(parent_handle), (int)trove_context);
  200.  
  201.     free(mybuffer);
  202.     return 0;
  203. }
  204.  
  205.  
  206. int path_lookup(TROVE_coll_id coll_id,
  207.                 TROVE_context_id trove_context,
  208.                 char *path, TROVE_handle *out_handle_p)
  209. {
  210.     int ret, count;
  211.     TROVE_ds_state state;
  212.     TROVE_keyval_s key, val;
  213.     TROVE_op_id op_id;
  214.     TROVE_handle handle;
  215.  
  216.     /* get root */
  217.     key.buffer = ROOT_HANDLE_KEYSTR;
  218.     key.buffer_sz = ROOT_HANDLE_KEYLEN;
  219.     val.buffer = &handle;
  220.     val.buffer_sz = sizeof(handle);
  221.  
  222.     ret = trove_collection_geteattr(coll_id, &key, &val,
  223.                                     0, NULL, trove_context, &op_id);
  224.     while (ret == 0) ret = trove_dspace_test(
  225.         coll_id, op_id, trove_context, &count, NULL, NULL, &state,
  226.         TROVE_DEFAULT_TEST_TIMEOUT);
  227.     if (ret < 0) {
  228.         fprintf(stderr, "collection geteattr (for root handle) failed.\n");
  229.         return -1;
  230.     }
  231.  
  232.     /* TODO: handle more than just a root handle! */
  233.  
  234.     *out_handle_p = handle;
  235.  
  236.     return 0;
  237. }
  238.  
  239.  
  240.  
  241.