fs/reiserfs/tail_conversion.c

   1 /*
   2  * Copyright 1999 Hans Reiser, see reiserfs/README for licensing and copyright details
   3  */
   4
   5 #include <linux/config.h>
   6 #include <linux/time.h>
   7 #include <linux/pagemap.h>
   8 #include <linux/buffer_head.h>
   9 #include <linux/reiserfs_fs.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     REISERFS_SB(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.", &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, inode,
  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, inode,
  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) || PageUptodate(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     */
 127     if (up_to_date_bh) {
 128         unsigned pgoff = (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
 129         char *kaddr=kmap_atomic(up_to_date_bh->b_page, KM_USER0);
 130         memset(kaddr + pgoff, 0, n_blk_size - total_tail) ;
 131         kunmap_atomic(kaddr, KM_USER0);
 132     }
 133
 134     REISERFS_I(inode)->i_first_direct_byte = U32_MAX;
 135
 136     return 0;
 137 }
 138
 139
 140 /* stolen from fs/buffer.c */
 141 void reiserfs_unmap_buffer(struct buffer_head *bh) {
 142     lock_buffer(bh) ;
 143     if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
 144       BUG() ;
 145     }
 146     clear_buffer_dirty(bh) ;
 147     /* Remove the buffer from whatever list it belongs to. We are mostly
 148        interested in removing it from per-sb j_dirty_buffers list, to avoid
 149         BUG() on attempt to write not mapped buffer */
 150     if ( (!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) {
 151         struct inode *inode = bh->b_page->mapping->host;
 152         struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
 153         spin_lock(&j->j_dirty_buffers_lock);
 154         list_del_init(&bh->b_assoc_buffers);
 155         reiserfs_free_jh(bh);
 156         spin_unlock(&j->j_dirty_buffers_lock);
 157     }
 158     clear_buffer_mapped(bh) ;
 159     clear_buffer_req(bh) ;
 160     clear_buffer_new(bh);
 161     bh->b_bdev = NULL;
 162     unlock_buffer(bh) ;
 163 }
 164
 165 static void
 166 unmap_buffers(struct page *page, loff_t pos) {
 167   struct buffer_head *bh ;
 168   struct buffer_head *head ;
 169   struct buffer_head *next ;
 170   unsigned long tail_index ;
 171   unsigned long cur_index ;
 172
 173   if (page) {
 174     if (page_has_buffers(page)) {
 175       tail_index = pos & (PAGE_CACHE_SIZE - 1) ;
 176       cur_index = 0 ;
 177       head = page_buffers(page) ;
 178       bh = head ;
 179       do {
 180         next = bh->b_this_page ;
 181
 182         /* we want to unmap the buffers that contain the tail, and
 183         ** all the buffers after it (since the tail must be at the
 184         ** end of the file).  We don't want to unmap file data
 185         ** before the tail, since it might be dirty and waiting to
 186         ** reach disk
 187         */
 188         cur_index += bh->b_size ;
 189         if (cur_index > tail_index) {
 190           reiserfs_unmap_buffer(bh) ;
 191         }
 192         bh = next ;
 193       } while (bh != head) ;
 194       if ( PAGE_SIZE == bh->b_size ) {
 195         clear_page_dirty(page);
 196       }
 197     }
 198   }
 199 }
 200
 201 /* this first locks inode (neither reads nor sync are permitted),
 202    reads tail through page cache, insert direct item. When direct item
 203    inserted successfully inode is left locked. Return value is always
 204    what we expect from it (number of cut bytes). But when tail remains
 205    in the unformatted node, we set mode to SKIP_BALANCING and unlock
 206    inode */
 207 int indirect2direct (struct reiserfs_transaction_handle *th,
 208                      struct inode * p_s_inode,
 209                      struct page *page,
 210                      struct path * p_s_path, /* path to the indirect item. */
 211                      const struct cpu_key * p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
 212                      loff_t n_new_file_size, /* New file size. */
 213                      char * p_c_mode)
 214 {
 215     struct super_block * p_s_sb = p_s_inode->i_sb;
 216     struct item_head      s_ih;
 217     unsigned long n_block_size = p_s_sb->s_blocksize;
 218     char * tail;
 219     int tail_len, round_tail_len;
 220     loff_t pos, pos1; /* position of first byte of the tail */
 221     struct cpu_key key;
 222
 223     REISERFS_SB(p_s_sb)->s_indirect2direct ++;
 224
 225     *p_c_mode = M_SKIP_BALANCING;
 226
 227     /* store item head path points to. */
 228     copy_item_head (&s_ih, PATH_PITEM_HEAD(p_s_path));
 229
 230     tail_len = (n_new_file_size & (n_block_size - 1));
 231     if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2)
 232         round_tail_len = ROUND_UP (tail_len);
 233     else
 234         round_tail_len = tail_len;
 235
 236     pos = le_ih_k_offset (&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 237     pos1 = pos;
 238
 239     // we are protected by i_sem. The tail can not disapper, not
 240     // append can be done either
 241     // we are in truncate or packing tail in file_release
 242
 243     tail = (char *)kmap(page) ; /* this can schedule */
 244
 245     if (path_changed (&s_ih, p_s_path)) {
 246         /* re-search indirect item */
 247         if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND )
 248             reiserfs_panic(p_s_sb, "PAP-5520: indirect2direct: "
 249                            "item to be converted %K does not exist", p_s_item_key);
 250         copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
 251 #ifdef CONFIG_REISERFS_CHECK
 252         pos = le_ih_k_offset (&s_ih) - 1 +
 253             (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 254         if (pos != pos1)
 255             reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: "
 256                             "tail position changed while we were reading it");
 257 #endif
 258     }
 259
 260
 261     /* Set direct item header to insert. */
 262     make_le_item_head (&s_ih, 0, get_inode_item_key_version (p_s_inode), pos1 + 1,
 263                        TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/);
 264
 265     /* we want a pointer to the first byte of the tail in the page.
 266     ** the page was locked and this part of the page was up to date when
 267     ** indirect2direct was called, so we know the bytes are still valid
 268     */
 269     tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ;
 270
 271     PATH_LAST_POSITION(p_s_path)++;
 272
 273     key = *p_s_item_key;
 274     set_cpu_key_k_type (&key, TYPE_DIRECT);
 275     key.key_length = 4;
 276     /* Insert tail as new direct item in the tree */
 277     if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode,
 278                               tail ? tail : NULL) < 0 ) {
 279         /* No disk memory. So we can not convert last unformatted node
 280            to the direct item.  In this case we used to adjust
 281            indirect items's ih_free_space. Now ih_free_space is not
 282            used, it would be ideal to write zeros to corresponding
 283            unformatted node. For now i_size is considered as guard for
 284            going out of file size */
 285         kunmap(page) ;
 286         return n_block_size - round_tail_len;
 287     }
 288     kunmap(page) ;
 289
 290     /* this will invalidate all the buffers in the page after
 291     ** pos1
 292     */
 293     unmap_buffers(page, pos1) ;
 294
 295     /* make sure to get the i_blocks changes from reiserfs_insert_item */
 296     reiserfs_update_sd(th, p_s_inode);
 297
 298     // note: we have now the same as in above direct2indirect
 299     // conversion: there are two keys which have matching first three
 300     // key components. They only differ by the fouhth one.
 301
 302     /* We have inserted new direct item and must remove last
 303        unformatted node. */
 304     *p_c_mode = M_CUT;
 305
 306     /* we store position of first direct item in the in-core inode */
 307     //mark_file_with_tail (p_s_inode, pos1 + 1);
 308     REISERFS_I(p_s_inode)->i_first_direct_byte = pos1 + 1;
 309
 310     return n_block_size - round_tail_len;
 311 }
 312
 313
 314