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 / src / io / buffer / state.c < prev    next >
C/C++ Source or Header  |  2006-05-15  |  13KB  |  540 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #include "internal.h"
  5. #include "state.h"
  6. #include "cache.h"
  7. #include "flags.h"
  8. #include "ncac-trove.h"
  9.  
  10.  
  11. /* this file contains state transition of an extent */
  12.  
  13. static int NCAC_move_inactive_to_active(struct cache_stack *cache_stack,struct extent *page);
  14. int  data_sync_inode(struct inode *inode);
  15.  
  16. /* NCAC_extent_read_access(): when a cached extent is accessed by a read
  17.  * request, its flags are changing.
  18.  *
  19.  */
  20. int NCAC_extent_read_access(NCAC_req_t *ncac_req, struct extent *page, unsigned long offset, unsigned long size)
  21. { 
  22.     int error;
  23.     struct cache_stack *cache_stack;
  24.     int ret;
  25.  
  26.     cache_stack = ncac_req->mapping->cache_stack;
  27.  
  28.     IncReadCount(page);
  29.  
  30.     if ( !PageActive(page) && PageLRU(page) )
  31.     {
  32.         cache_lock(&(cache_stack->lock));
  33.  
  34.         cache_stack = get_extent_cache_stack(page);
  35.         NCAC_move_inactive_to_active(cache_stack, page);
  36.         SetPageActive(page);
  37.  
  38.         cache_unlock(&(cache_stack->lock));
  39.  
  40.     }
  41.  
  42.     /* if there is any write on this extent before this access,
  43.      * there is nothing we can do at this moment.
  44.      */
  45.     if ( page->writes > page->wcmp ) {
  46.         ret = 0;
  47.         goto out;
  48.     }
  49.  
  50.     /* in active list */
  51.     if (PageLRU(page) && PageActive(page)){
  52.  
  53.         if (PageRcomm(page)){ /* read communication pending */
  54.             ret = 1;
  55.             goto out;
  56.         }
  57.  
  58.         /* write communication is pending. 
  59.          * A write is ahead of this read. wait!!!
  60.          */
  61.         if (PageWcomm(page)) {
  62.             ret = 0; goto out;
  63.         }
  64.  
  65.         /************************************/
  66.         /* The following cases are those without pending communication */
  67.  
  68.         /* clean or dirty extent */
  69.         if (PageClean(page) || PageDirty(page) ) {
  70.             SetPageRcomm(page);    ret = 1; 
  71.             goto out;
  72.         }
  73.  
  74.         /* read pending: Trove read operation is pending.  */
  75.         /* write pending: for example flushing daemon is working on it */
  76.         if (PageReadPending(page) || PageWritePending(page)) {
  77.             error = NCAC_check_ioreq(page);
  78.             if (error <0) {
  79.                 NCAC_error("%s:%d NCAC_check_ioreq error\n", __FILE__, __LINE__);
  80.                 ret = 0; goto out;
  81.             }
  82.  
  83.             if (error) {
  84.                 /* set all other related extents */
  85.                 list_set_clean_page(page);
  86.  
  87.                 /* the request is done and the read is finished.
  88.                  * Note that NCAC_check_ioreq sets page flags in this case.*/
  89.                 SetPageRcomm(page);    
  90.                 ret = 0; 
  91.                 goto out;
  92.             }
  93.             ret = 0; goto out;
  94.         }
  95.                 
  96.     }
  97.  
  98.     /* invalid flags */
  99.     ret = NCAC_INVAL_FLAGS;
  100.  
  101. out:
  102.     return ret;
  103.  
  104. }
  105.  
  106. /* NCAC_extent_write_access(): when a cached extent is accessed by a write
  107.  * request, its flags are changing.
  108.  * According to Linux 2.6, if the extent is cached in the inactive
  109.  * list, it is not moved to the active list.
  110.  */
  111. int NCAC_extent_write_access(NCAC_req_t *ncac_req, struct extent *page, unsigned long offset, unsigned long size)
  112. { 
  113.     int error;
  114.  
  115.     IncWriteCount(page);
  116.  
  117.     /* the first write */
  118.     if ( PageLRU(page) && page->writes - page->wcmp ==1 ){
  119.  
  120.         if (PageRcomm(page) || PageWcomm(page)) 
  121.             return 0;
  122.  
  123.  
  124.         if (PageReadPending(page) || PageWritePending(page)) {
  125.             error = NCAC_check_ioreq(page);
  126.             if (error <0) {
  127.                 NCAC_error("%s:%d NCAC_check_ioreq error\n", __FILE__, __LINE__);
  128.                 return error;
  129.             }
  130.             if (error) { /* completion */
  131.  
  132.             /* set all other related extents */
  133.             list_set_clean_page(page);
  134.  
  135.             /* the request is done and the read is finished.
  136.              * Note that NCAC_check_ioreq sets page flags in 
  137.              * this case.*/
  138.  
  139.             SetPageWcomm(page);    
  140.                 return 1;
  141.             }
  142.             return 0;    
  143.         }
  144.  
  145.         /* No pending comm, clean or dirty extent */
  146.         if (PageClean(page) || PageDirty(page) ) {
  147.             SetPageWcomm(page);    
  148.             return 1;
  149.         }
  150.     }
  151.  
  152.     /* it is not the first write */
  153.     if ( page->writes - page->wcmp >1 ){
  154.         return 0;
  155.     }
  156.  
  157.     /* there is pending reads */
  158.     if ( page->reads != page->rcmp  ){
  159.         return 0;
  160.     }
  161.  
  162.     /* invalid flags */
  163.     return NCAC_INVAL_FLAGS;
  164. }
  165.  
  166.  
  167. /* NCAC_extent_first_read_access(): when a new extent is allocated
  168.  * for read, this function is called. It is called before we
  169.  * put it into cache and after we initiate a Trove read request.
  170.  */
  171. int NCAC_extent_first_read_access(NCAC_req_t *ncac_req, struct extent *page)
  172. {
  173.     SetPageReadPending(page); 
  174.     IncReadCount(page);
  175.     return 0;
  176. }
  177.  
  178. /* NCAC_extent_first_write_access(): when a new extent is allocated
  179.  * for write, this function is called. It is called before we
  180.  * put it into cache.
  181.  */
  182. int NCAC_extent_first_write_access(NCAC_req_t *ncac_req, struct extent *page)
  183. {
  184.     ClearPageBlank(page);
  185.        SetPageWcomm(page); 
  186.     IncWriteCount(page);
  187.     return 1;
  188. }
  189.  
  190. /* NCAC_extent_done_access(): when communication is done, we mark
  191.  * each extent to clean/dirty. When it is dirty, add it to the
  192.  * inode dirty list.
  193.  *
  194.  * TODO: buffer information cannot not be changed by the outside.
  195.  * */
  196. int NCAC_extent_done_access(NCAC_req_t *ncac_req)
  197. {
  198.     int  i;
  199.     struct inode *inode;
  200.     struct list_head *dirty_list = NULL;
  201.     struct cache_stack *cache;
  202.     int nr_dirty = 0;
  203.     int ret = 0;
  204.  
  205.     inode = ncac_req->mapping;
  206.  
  207.     inode_lock (&inode->lock);
  208.  
  209.     if (ncac_req->optype == NCAC_READ)
  210.     {
  211.         for (i = 0; i < ncac_req->cbufcnt; i++)
  212.         {
  213.             if (ncac_req->cbufflag[i] && ncac_req->cbufhash[i])
  214.             {
  215.                 NCAC_extent_read_comm_done (ncac_req->cbufhash[i]);
  216.                 //DecReadCount(ncac_req->cbufhash[i]);
  217.                 ncac_req->cbufhash[i]->rcmp++;
  218.                 ncac_req->cbufhash[i]->reads--;
  219.             }
  220.         }
  221.       }
  222.  
  223.     if (ncac_req->optype == NCAC_WRITE)
  224.     {
  225.         dirty_list = &(inode->dirty_pages);
  226.         for (i = 0; i < ncac_req->cbufcnt; i++)
  227.         {
  228.             if (ncac_req->cbufflag[i] && ncac_req->cbufhash[i])
  229.             {
  230.                 NCAC_extent_write_comm_done (ncac_req->cbufhash[i]);
  231.                 //DecWriteCount(ncac_req->cbufhash[i]);
  232.                 ncac_req->cbufhash[i]->wcmp++;
  233.  
  234.                 /* add dirty pages */
  235.                 list_add_tail (&ncac_req->cbufhash[i]->list, dirty_list);
  236.                 nr_dirty++;
  237.  
  238.             }
  239.         }
  240.         inode->nr_dirty += nr_dirty;
  241.  
  242.         /* handle sync stuff: there are three cases:
  243.          * 1) if a file is opend with O_SYNC, we should do sync
  244.          * 2) if we define aggressive flush, we do sync here.
  245.          * 3) otherwise, sync depends on our flush policy.
  246.          * TODO: currently we don't know O_SYNC flag 
  247.          */
  248.  
  249.         /* if ( ncac_req->f_flags & O_SYNC || IS_SYNC(inode) ) {
  250.             data_sync(inode);
  251.            }
  252.          */
  253.  
  254. #if defined(LAZY_SYNC)
  255.         ret = balance_dirty_extents (ncac_req->mapping->cache_stack);
  256.  
  257. #else /* aggressive sync */
  258.         ret = data_sync_inode (inode);
  259. #endif
  260.     }
  261.  
  262.     inode_unlock (&inode->lock);
  263.  
  264.     if (dirty_list)
  265.     {                /* atomic add */
  266.         cache = inode->cache_stack;
  267.  
  268.         cache_lock (&cache->lock);
  269.         cache->nr_dirty += (nr_dirty - ret);
  270.         cache_unlock (&cache->lock);
  271.         DPRINT ("-------nr_dirty=%d, flush=%d\n", nr_dirty, ret);
  272.     }
  273.  
  274.     return 0;
  275. }
  276.  
  277. /* read commnication is done */
  278. int NCAC_extent_read_comm_done(struct extent *page)
  279. {
  280.     ClearPageRcomm(page);
  281.     return 0;
  282. }
  283.  
  284. /* read commnication is done */
  285. int NCAC_extent_write_comm_done(struct extent *page)
  286. {
  287.     ClearPageWcomm(page);
  288.     ClearPageClean(page);
  289.        SetPageDirty(page); 
  290.     return 0;
  291. }
  292.  
  293. void list_set_clean_page(struct extent *page)
  294.  
  295. {
  296.     struct extent *next;
  297.  
  298.     int cnt = 0;  
  299.  
  300.     DPRINT("iodone before: flags:%lx\n", page->flags);
  301.     ClearPageDirty(page);
  302.     SetPageClean(page);
  303.     ClearPageReadPending(page);
  304.     ClearPageWritePending(page);
  305.  
  306.     page->ioreq = INVAL_IOREQ; 
  307.     next = page->ioreq_next;
  308.  
  309.     cnt ++;
  310.  
  311.     while ( next != page ) {
  312.         SetPageClean (next);
  313.         ClearPageDirty (next);
  314.         ClearPageReadPending (next);
  315.         ClearPageWritePending (next);
  316.  
  317.         next->ioreq = INVAL_IOREQ;
  318.  
  319.         cnt++;
  320.  
  321.         next = next->ioreq_next;
  322.     }
  323.  
  324.     DPRINT("clean_page: %d\n", cnt);
  325.  
  326.     return;
  327. }
  328.  
  329.  
  330. static int NCAC_move_inactive_to_active(struct cache_stack *cache_stack,struct extent *page)
  331. {
  332.     del_page_from_inactive_list(cache_stack, page);
  333.     add_page_to_active_list(cache_stack, page);
  334.     return 0;
  335. }
  336.  
  337.  
  338. int NCAC_extent_read_access_recheck(NCAC_req_t *req, struct extent *page, unsigned int offset, unsigned int size)
  339. {
  340.     int error;
  341.  
  342.     if ( PageLRU(page) ){
  343.         if (PageRcomm(page)) 
  344.             return 1;
  345.  
  346.         /* write communication is pending. 
  347.          * A write is ahead of this read. wait!!! 
  348.          */
  349.         if (PageWcomm(page)) return 0;
  350.  
  351.         /* clean or dirty extent */
  352.         if (PageClean(page) || PageDirty(page)) {
  353.             SetPageRcomm(page); return 1;
  354.         }
  355.  
  356.         /* read pending: Trove read operation is pending.  */
  357.         /* write pending: for example flushing daemon is working on it */
  358.  
  359.         if (PageReadPending(page) || PageWritePending(page)) {
  360.             error = NCAC_check_ioreq(page);
  361.             if (error <0) {
  362.                 NCAC_error("%s:%d NCAC_check_ioreq error\n", __FILE__, __LINE__);
  363.                 return error;
  364.             }
  365.             if (error) {
  366.  
  367.                 /* set all other related extents */
  368.                 list_set_clean_page(page);
  369.  
  370.                 /* the request is done and the read is finished.
  371.                  * Note that NCAC_check_ioreq sets page flags in this case.*/
  372.                 SetPageRcomm(page); return 1; 
  373.             }
  374.             return 0;
  375.         }
  376.     }
  377.  
  378.     /* invalid flags */
  379.     return NCAC_INVAL_FLAGS;
  380. }
  381.  
  382.  
  383. int NCAC_extent_write_access_recheck(NCAC_req_t *ncac_req, struct extent *page, unsigned int offset, unsigned int size)
  384. {
  385.     int error;
  386.  
  387.     if ( PageLRU(page) ){
  388.         if ( PageRMW(page) ) {
  389.             error = NCAC_check_ioreq(page);
  390.             if (error <0) {
  391.                 NCAC_error("NCAC_check_ioreq error\n");
  392.                 return error;
  393.             }
  394.             if ( !error ) 
  395.                 return 2;  /* 2 for rmw */
  396.             else {
  397.                 ClearPageRMW(page);
  398.                 return 1;
  399.             }
  400.         }
  401.  
  402.         if (PageRcomm(page) || PageWcomm(page))
  403.             return 0;
  404.  
  405.  
  406.         if (PageReadPending(page) || PageWritePending(page)) {
  407.             error = NCAC_check_ioreq(page);
  408.             if (error <0) {
  409.                 NCAC_error("NCAC_check_ioreq error\n");
  410.                 return error;
  411.             }
  412.             if (error) {
  413.                 /* set all other related extents */
  414.                 list_set_clean_page(page);
  415.  
  416.                 /* the request is done and the read is finished.
  417.                  * Note that NCAC_check_ioreq sets page flags in this case.*/
  418.                 SetPageWcomm(page);
  419.                 return 1;
  420.             }
  421.             return 0;
  422.         }
  423.  
  424.  
  425.         /* No pending comm, clean or dirty extent */
  426.         if (PageClean(page) || PageDirty(page)) {
  427.             SetPageWcomm(page);
  428.             return 1;
  429.         }
  430.  
  431.         return 0;
  432.     }
  433.  
  434.     /* invalid flags */
  435.     return NCAC_INVAL_FLAGS;
  436. }
  437.  
  438.  
  439. #if 0
  440. static void    balance_dirty_extents( struct cache_stack *cache_stack)
  441. {
  442.     fprintf(stderr, "balance_dirty_extents is not implemented yet\n");
  443. }
  444. #endif
  445.  
  446. /* data_sync_inode(): initiate sync operation on all dirty extents so far. 
  447.  * problem here: the file offset is increasing?
  448.  * The caller holds the inode lock.
  449.  * 
  450.  * TODO: is it useful to order extents in the dirty list?
  451.  */
  452.  
  453. int data_sync_inode(struct inode *inode)
  454. {
  455.     struct list_head  *list, *tail;
  456.     struct extent *extent, *prev, *first;
  457.     int nr_dirty;
  458.     PVFS_offset *offset;
  459.     char **mem;
  460.     PVFS_size *offsize, *memsize;
  461.     int cnt = 0;
  462.     int ioreq;
  463.     int ret;
  464.     int i;
  465.  
  466.     nr_dirty = inode->nr_dirty;
  467.  
  468.     DPRINT("data_sync_inode: nr_dirty=%d\n", nr_dirty);
  469.     if ( !nr_dirty ) return 0;
  470.  
  471.     /* allocate Trove parameters */
  472.     offset = (PVFS_offset *)malloc(nr_dirty*(sizeof(PVFS_offset) + sizeof(char*) + 2*sizeof(PVFS_size)) );
  473.     mem = (char**)&offset[nr_dirty];
  474.     offsize = (PVFS_size*)&mem[nr_dirty];
  475.     memsize = &offsize[nr_dirty];
  476.     
  477.     list = &(inode->dirty_pages);
  478.     
  479.     /* from the head to the tail to keep the order */
  480.     tail = list->next; 
  481.     while ( tail != list ){
  482.         extent = list_entry(tail, struct extent, list);
  483.         offset[cnt] = extent->index * NCAC_dev.extsize;
  484.         offsize[cnt] = NCAC_dev.extsize;
  485.         mem[cnt] = extent->addr;
  486.         memsize[cnt] = NCAC_dev.extsize;
  487.  
  488.         DPRINT("to write: pos:%lld, size=%lld, buf=%p\n", 
  489.              offset[cnt], offsize[cnt], mem[cnt]);
  490.         cnt ++;
  491.         tail = tail->next;
  492.     }
  493.  
  494.     ret = NCAC_aio_write(inode->coll_id, inode->handle, 
  495.             inode->context_id, nr_dirty, 
  496.             offset, offsize, mem, memsize, &ioreq);
  497.     if ( ret < 0 ) {
  498.         NCAC_error("data_sync_inode: NCAC_aio_write error \n");
  499.         return ret;
  500.     }else{
  501.         /* we need to associate all extents to an IOreq */
  502.  
  503.         tail = list->next; 
  504.         extent = list_entry(tail, struct extent, list);
  505.  
  506.         SetPageWritePending(extent);
  507.         extent->ioreq_next = extent;
  508.         prev = first = extent;
  509.  
  510.         extent->ioreq = ioreq;
  511.         list_del(&extent->list);
  512.         tail = list->next;
  513.  
  514.         for ( i = 1; i < nr_dirty; i ++ ) { 
  515.             extent = list_entry(tail, struct extent, list);
  516.             SetPageWritePending(extent);
  517.             prev->ioreq_next = extent;
  518.             extent->ioreq = ioreq;
  519.  
  520.             prev = extent;
  521.             list_del(&extent->list);
  522.             tail = list->next;
  523.         }
  524.         extent->ioreq_next = first;
  525.  
  526.         inode->nr_dirty = 0;
  527.     }
  528.  
  529.     return nr_dirty;
  530. }
  531.  
  532.  
  533.  
  534. void mark_extent_rmw_lock(struct extent *extent, int ioreq)
  535. {
  536.     SetPageRMW(extent);
  537.     extent->ioreq = ioreq;
  538.     extent->ioreq_next = extent;
  539. }
  540.