fs/reiserfs/tail_conversion.c

   1 /*
   2  * Copyright 1999-2002 Hans Reiser, see reiserfs/README for licensing and copyright details
   3  */
   4
   5 #include <linux/config.h>
   6 #include <linux/sched.h>
   7 #include <linux/pagemap.h>
   8 #include <linux/reiserfs_fs.h>
   9 #include <linux/locks.h>
  10
  11 /* access to tail : when one is going to read tail it must make sure, that is not running.
  12  direct2indirect and indirect2direct can not run concurrently */
  13
  14
  15 /* Converts direct items to an unformatted node. Panics if file has no
  16    tail. -ENOSPC if no disk space for conversion */
  17 /* path points to first direct item of the file regarless of how many of
  18    them are there */
  19 int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inode,
  20                      struct path * path, struct buffer_head * unbh,
  21                      loff_t tail_offset)
  22 {
  23     struct super_block * sb = inode->i_sb;
  24     struct buffer_head *up_to_date_bh ;
  25     struct item_head * p_le_ih = PATH_PITEM_HEAD (path);
  26     unsigned long total_tail = 0 ;
  27     struct cpu_key end_key;  /* Key to search for the last byte of the
  28                                 converted item. */
  29     struct item_head ind_ih; /* new indirect item to be inserted or
  30                                 key of unfm pointer to be pasted */
  31     int n_blk_size,
  32       n_retval;   /* returned value for reiserfs_insert_item and clones */
  33     unp_t unfm_ptr;  /* Handle on an unformatted node
  34                                        that will be inserted in the
  35                                        tree. */
  36
  37
  38     sb->u.reiserfs_sb.s_direct2indirect ++;
  39
  40     n_blk_size = sb->s_blocksize;
  41
  42     /* and key to search for append or insert pointer to the new
  43        unformatted node. */
  44     copy_item_head (&ind_ih, p_le_ih);
  45     set_le_ih_k_offset (&ind_ih, tail_offset);
  46     set_le_ih_k_type (&ind_ih, TYPE_INDIRECT);
  47
  48     /* Set the key to search for the place for new unfm pointer */
  49     make_cpu_key (&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
  50
  51     // FIXME: we could avoid this
  52     if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND ) {
  53         reiserfs_warning (sb, "PAP-14030: direct2indirect: "
  54                         "pasted or inserted byte exists in the tree %K. "
  55                         "Use fsck to repair.\n", &end_key);
  56         pathrelse(path);
  57         return -EIO;
  58     }
  59
  60     p_le_ih = PATH_PITEM_HEAD (path);
  61
  62     unfm_ptr = cpu_to_le32 (unbh->b_blocknr);
  63
  64     if ( is_statdata_le_ih (p_le_ih) )  {
  65         /* Insert new indirect item. */
  66         set_ih_free_space (&ind_ih, 0); /* delete at nearest future */
  67         put_ih_item_len( &ind_ih, UNFM_P_SIZE );
  68         PATH_LAST_POSITION (path)++;
  69         n_retval = reiserfs_insert_item (th, path, &end_key, &ind_ih,
  70                                          (char *)&unfm_ptr);
  71     } else {
  72         /* Paste into last indirect item of an object. */
  73         n_retval = reiserfs_paste_into_item(th, path, &end_key,
  74                                             (char *)&unfm_ptr, UNFM_P_SIZE);
  75     }
  76     if ( n_retval ) {
  77         return n_retval;
  78     }
  79
  80     // note: from here there are two keys which have matching first
  81     // three key components. They only differ by the fourth one.
  82
  83
  84     /* Set the key to search for the direct items of the file */
  85     make_cpu_key (&end_key, inode, max_reiserfs_offset (inode), TYPE_DIRECT, 4);
  86
  87     /* Move bytes from the direct items to the new unformatted node
  88        and delete them. */
  89     while (1)  {
  90         int tail_size;
  91
  92         /* end_key.k_offset is set so, that we will always have found
  93            last item of the file */
  94         if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND )
  95             reiserfs_panic (sb, "PAP-14050: direct2indirect: "
  96                             "direct item (%K) not found", &end_key);
  97         p_le_ih = PATH_PITEM_HEAD (path);
  98         RFALSE( !is_direct_le_ih (p_le_ih),
  99                 "vs-14055: direct item expected(%K), found %h",
 100                 &end_key, p_le_ih);
 101         tail_size = (le_ih_k_offset (p_le_ih) & (n_blk_size - 1))
 102             + ih_item_len(p_le_ih) - 1;
 103
 104         /* we only send the unbh pointer if the buffer is not up to date.
 105         ** this avoids overwriting good data from writepage() with old data
 106         ** from the disk or buffer cache
 107         ** Special case: unbh->b_page will be NULL if we are coming through
 108         ** DIRECT_IO handler here.
 109         */
 110         if ( !unbh->b_page || buffer_uptodate(unbh) || Page_Uptodate(unbh->b_page)) {
 111             up_to_date_bh = NULL ;
 112         } else {
 113             up_to_date_bh = unbh ;
 114         }
 115         n_retval = reiserfs_delete_item (th, path, &end_key, inode,
 116                                          up_to_date_bh) ;
 117
 118         total_tail += n_retval ;
 119         if (tail_size == n_retval)
 120             // done: file does not have direct items anymore
 121             break;
 122
 123     }
 124     /* if we've copied bytes from disk into the page, we need to zero
 125     ** out the unused part of the block (it was not up to date before)
 126     ** the page is still kmapped (by whoever called reiserfs_get_block)
 127     */
 128     if (up_to_date_bh) {
 129         unsigned pgoff = (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
 130         memset(page_address(unbh->b_page) + pgoff, 0, n_blk_size - total_tail) ;
 131     }
 132
 133     inode->u.reiserfs_i.i_first_direct_byte = U32_MAX;
 134
 135     reiserfs_update_tail_transaction(inode);
 136     return 0;
 137 }
 138
 139
 140 /* stolen from fs/buffer.c */
 141 void reiserfs_unmap_buffer(struct buffer_head *bh) {
 142   if (buffer_mapped(bh)) {
 143     if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
 144       BUG() ;
 145     }
 146     mark_buffer_clean(bh) ;
 147     lock_buffer(bh) ;
 148     clear_bit(BH_Mapped, &bh->b_state) ;
 149     clear_bit(BH_Req, &bh->b_state) ;
 150     clear_bit(BH_New, &bh->b_state) ;
 151     unlock_buffer(bh) ;
 152   }
 153 }
 154
 155 static void
 156 unmap_buffers(struct page *page, loff_t pos) {
 157   struct buffer_head *bh ;
 158   struct buffer_head *head ;
 159   struct buffer_head *next ;
 160   unsigned long tail_index ;
 161   unsigned long cur_index ;
 162
 163   if (page) {
 164     if (page->buffers) {
 165       tail_index = pos & (PAGE_CACHE_SIZE - 1) ;
 166       cur_index = 0 ;
 167       head = page->buffers ;
 168       bh = head ;
 169       do {
 170         next = bh->b_this_page ;
 171
 172         /* we want to unmap the buffers that contain the tail, and
 173         ** all the buffers after it (since the tail must be at the
 174         ** end of the file).  We don't want to unmap file data
 175         ** before the tail, since it might be dirty and waiting to
 176         ** reach disk
 177         */
 178         cur_index += bh->b_size ;
 179         if (cur_index > tail_index) {
 180           reiserfs_unmap_buffer(bh) ;
 181         }
 182         bh = next ;
 183       } while (bh != head) ;
 184     }
 185   }
 186 }
 187
 188 /* this first locks inode (neither reads nor sync are permitted),
 189    reads tail through page cache, insert direct item. When direct item
 190    inserted successfully inode is left locked. Return value is always
 191    what we expect from it (number of cut bytes). But when tail remains
 192    in the unformatted node, we set mode to SKIP_BALANCING and unlock
 193    inode */
 194 int indirect2direct (struct reiserfs_transaction_handle *th,
 195                      struct inode * p_s_inode,
 196                      struct page *page,
 197                      struct path * p_s_path, /* path to the indirect item. */
 198                      const struct cpu_key * p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
 199                      loff_t n_new_file_size, /* New file size. */
 200                      char * p_c_mode)
 201 {
 202     struct super_block * p_s_sb = p_s_inode->i_sb;
 203     struct item_head      s_ih;
 204     unsigned long n_block_size = p_s_sb->s_blocksize;
 205     char * tail;
 206     int tail_len, round_tail_len;
 207     loff_t pos, pos1; /* position of first byte of the tail */
 208     struct cpu_key key;
 209
 210     p_s_sb->u.reiserfs_sb.s_indirect2direct ++;
 211
 212     *p_c_mode = M_SKIP_BALANCING;
 213
 214     /* store item head path points to. */
 215     copy_item_head (&s_ih, PATH_PITEM_HEAD(p_s_path));
 216
 217     tail_len = (n_new_file_size & (n_block_size - 1));
 218     if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2)
 219         round_tail_len = ROUND_UP (tail_len);
 220     else
 221         round_tail_len = tail_len;
 222
 223     pos = le_ih_k_offset (&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 224     pos1 = pos;
 225
 226     // we are protected by i_sem. The tail can not disapper, not
 227     // append can be done either
 228     // we are in truncate or packing tail in file_release
 229
 230     tail = (char *)kmap(page) ; /* this can schedule */
 231
 232     if (path_changed (&s_ih, p_s_path)) {
 233         /* re-search indirect item */
 234         if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND )
 235             reiserfs_panic(p_s_sb, "PAP-5520: indirect2direct: "
 236                            "item to be converted %K does not exist", p_s_item_key);
 237         copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
 238 #ifdef CONFIG_REISERFS_CHECK
 239         pos = le_ih_k_offset (&s_ih) - 1 +
 240             (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 241         if (pos != pos1)
 242             reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: "
 243                             "tail position changed while we were reading it");
 244 #endif
 245     }
 246
 247
 248     /* Set direct item header to insert. */
 249     make_le_item_head (&s_ih, 0, get_inode_item_key_version (p_s_inode), pos1 + 1,
 250                        TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/);
 251
 252     /* we want a pointer to the first byte of the tail in the page.
 253     ** the page was locked and this part of the page was up to date when
 254     ** indirect2direct was called, so we know the bytes are still valid
 255     */
 256     tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ;
 257
 258     PATH_LAST_POSITION(p_s_path)++;
 259
 260     key = *p_s_item_key;
 261     set_cpu_key_k_type (&key, TYPE_DIRECT);
 262     key.key_length = 4;
 263     /* Insert tail as new direct item in the tree */
 264     if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih,
 265                               tail ? tail : NULL) < 0 ) {
 266         /* No disk memory. So we can not convert last unformatted node
 267            to the direct item.  In this case we used to adjust
 268            indirect items's ih_free_space. Now ih_free_space is not
 269            used, it would be ideal to write zeros to corresponding
 270            unformatted node. For now i_size is considered as guard for
 271            going out of file size */
 272         kunmap(page) ;
 273         return n_block_size - round_tail_len;
 274     }
 275     kunmap(page) ;
 276
 277     /* this will invalidate all the buffers in the page after
 278     ** pos1
 279     */
 280     unmap_buffers(page, pos1) ;
 281
 282     // note: we have now the same as in above direct2indirect
 283     // conversion: there are two keys which have matching first three
 284     // key components. They only differ by the fouhth one.
 285
 286     /* We have inserted new direct item and must remove last
 287        unformatted node. */
 288     p_s_inode->i_blocks += (p_s_sb->s_blocksize / 512);
 289     *p_c_mode = M_CUT;
 290
 291     /* we store position of first direct item in the in-core inode */
 292     //mark_file_with_tail (p_s_inode, pos1 + 1);
 293     p_s_inode->u.reiserfs_i.i_first_direct_byte = pos1 + 1;
 294
 295     return n_block_size - round_tail_len;
 296 }
 297
 298
 299