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     BUG_ON (!th->t_trans_id);
  38
  39     REISERFS_SB(sb)->s_direct2indirect ++;
  40
  41     n_blk_size = sb->s_blocksize;
  42
  43     /* and key to search for append or insert pointer to the new
  44        unformatted node. */
  45     copy_item_head (&ind_ih, p_le_ih);
  46     set_le_ih_k_offset (&ind_ih, tail_offset);
  47     set_le_ih_k_type (&ind_ih, TYPE_INDIRECT);
  48
  49     /* Set the key to search for the place for new unfm pointer */
  50     make_cpu_key (&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
  51
  52     // FIXME: we could avoid this
  53     if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND ) {
  54         reiserfs_warning (sb, "PAP-14030: direct2indirect: "
  55                         "pasted or inserted byte exists in the tree %K. "
  56                         "Use fsck to repair.", &end_key);
  57         pathrelse(path);
  58         return -EIO;
  59     }
  60
  61     p_le_ih = PATH_PITEM_HEAD (path);
  62
  63     unfm_ptr = cpu_to_le32 (unbh->b_blocknr);
  64
  65     if ( is_statdata_le_ih (p_le_ih) )  {
  66         /* Insert new indirect item. */
  67         set_ih_free_space (&ind_ih, 0); /* delete at nearest future */
  68         put_ih_item_len( &ind_ih, UNFM_P_SIZE );
  69         PATH_LAST_POSITION (path)++;
  70         n_retval = reiserfs_insert_item (th, path, &end_key, &ind_ih, inode,
  71                                          (char *)&unfm_ptr);
  72     } else {
  73         /* Paste into last indirect item of an object. */
  74         n_retval = reiserfs_paste_into_item(th, path, &end_key, inode,
  75                                             (char *)&unfm_ptr, UNFM_P_SIZE);
  76     }
  77     if ( n_retval ) {
  78         return n_retval;
  79     }
  80
  81     // note: from here there are two keys which have matching first
  82     // three key components. They only differ by the fourth one.
  83
  84
  85     /* Set the key to search for the direct items of the file */
  86     make_cpu_key (&end_key, inode, max_reiserfs_offset (inode), TYPE_DIRECT, 4);
  87
  88     /* Move bytes from the direct items to the new unformatted node
  89        and delete them. */
  90     while (1)  {
  91         int tail_size;
  92
  93         /* end_key.k_offset is set so, that we will always have found
  94            last item of the file */
  95         if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND )
  96             reiserfs_panic (sb, "PAP-14050: direct2indirect: "
  97                             "direct item (%K) not found", &end_key);
  98         p_le_ih = PATH_PITEM_HEAD (path);
  99         RFALSE( !is_direct_le_ih (p_le_ih),
 100                 "vs-14055: direct item expected(%K), found %h",
 101                 &end_key, p_le_ih);
 102         tail_size = (le_ih_k_offset (p_le_ih) & (n_blk_size - 1))
 103             + ih_item_len(p_le_ih) - 1;
 104
 105         /* we only send the unbh pointer if the buffer is not up to date.
 106         ** this avoids overwriting good data from writepage() with old data
 107         ** from the disk or buffer cache
 108         ** Special case: unbh->b_page will be NULL if we are coming through
 109         ** DIRECT_IO handler here.
 110         */
 111         if (!unbh->b_page || buffer_uptodate(unbh) || PageUptodate(unbh->b_page)) {
 112             up_to_date_bh = NULL ;
 113         } else {
 114             up_to_date_bh = unbh ;
 115         }
 116         n_retval = reiserfs_delete_item (th, path, &end_key, inode,
 117                                          up_to_date_bh) ;
 118
 119         total_tail += n_retval ;
 120         if (tail_size == n_retval)
 121             // done: file does not have direct items anymore
 122             break;
 123
 124     }
 125     /* if we've copied bytes from disk into the page, we need to zero
 126     ** out the unused part of the block (it was not up to date before)
 127     */
 128     if (up_to_date_bh) {
 129         unsigned pgoff = (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
 130         char *kaddr=kmap_atomic(up_to_date_bh->b_page, KM_USER0);
 131         memset(kaddr + pgoff, 0, n_blk_size - total_tail) ;
 132         kunmap_atomic(kaddr, KM_USER0);
 133     }
 134
 135     REISERFS_I(inode)->i_first_direct_byte = U32_MAX;
 136
 137     return 0;
 138 }
 139
 140
 141 /* stolen from fs/buffer.c */
 142 void reiserfs_unmap_buffer(struct buffer_head *bh) {
 143     lock_buffer(bh) ;
 144     if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
 145       BUG() ;
 146     }
 147     clear_buffer_dirty(bh) ;
 148     /* Remove the buffer from whatever list it belongs to. We are mostly
 149        interested in removing it from per-sb j_dirty_buffers list, to avoid
 150         BUG() on attempt to write not mapped buffer */
 151     if ( (!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) {
 152         struct inode *inode = bh->b_page->mapping->host;
 153         struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
 154         spin_lock(&j->j_dirty_buffers_lock);
 155         list_del_init(&bh->b_assoc_buffers);
 156         reiserfs_free_jh(bh);
 157         spin_unlock(&j->j_dirty_buffers_lock);
 158     }
 159     clear_buffer_mapped(bh) ;
 160     clear_buffer_req(bh) ;
 161     clear_buffer_new(bh);
 162     bh->b_bdev = NULL;
 163     unlock_buffer(bh) ;
 164 }
 165
 166 /* this first locks inode (neither reads nor sync are permitted),
 167    reads tail through page cache, insert direct item. When direct item
 168    inserted successfully inode is left locked. Return value is always
 169    what we expect from it (number of cut bytes). But when tail remains
 170    in the unformatted node, we set mode to SKIP_BALANCING and unlock
 171    inode */
 172 int indirect2direct (struct reiserfs_transaction_handle *th,
 173                      struct inode * p_s_inode,
 174                      struct page *page,
 175                      struct path * p_s_path, /* path to the indirect item. */
 176                      const struct cpu_key * p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
 177                      loff_t n_new_file_size, /* New file size. */
 178                      char * p_c_mode)
 179 {
 180     struct super_block * p_s_sb = p_s_inode->i_sb;
 181     struct item_head      s_ih;
 182     unsigned long n_block_size = p_s_sb->s_blocksize;
 183     char * tail;
 184     int tail_len, round_tail_len;
 185     loff_t pos, pos1; /* position of first byte of the tail */
 186     struct cpu_key key;
 187
 188     BUG_ON (!th->t_trans_id);
 189
 190     REISERFS_SB(p_s_sb)->s_indirect2direct ++;
 191
 192     *p_c_mode = M_SKIP_BALANCING;
 193
 194     /* store item head path points to. */
 195     copy_item_head (&s_ih, PATH_PITEM_HEAD(p_s_path));
 196
 197     tail_len = (n_new_file_size & (n_block_size - 1));
 198     if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2)
 199         round_tail_len = ROUND_UP (tail_len);
 200     else
 201         round_tail_len = tail_len;
 202
 203     pos = le_ih_k_offset (&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 204     pos1 = pos;
 205
 206     // we are protected by i_sem. The tail can not disapper, not
 207     // append can be done either
 208     // we are in truncate or packing tail in file_release
 209
 210     tail = (char *)kmap(page) ; /* this can schedule */
 211
 212     if (path_changed (&s_ih, p_s_path)) {
 213         /* re-search indirect item */
 214         if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND )
 215             reiserfs_panic(p_s_sb, "PAP-5520: indirect2direct: "
 216                            "item to be converted %K does not exist", p_s_item_key);
 217         copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
 218 #ifdef CONFIG_REISERFS_CHECK
 219         pos = le_ih_k_offset (&s_ih) - 1 +
 220             (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 221         if (pos != pos1)
 222             reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: "
 223                             "tail position changed while we were reading it");
 224 #endif
 225     }
 226
 227
 228     /* Set direct item header to insert. */
 229     make_le_item_head (&s_ih, NULL, get_inode_item_key_version (p_s_inode), pos1 + 1,
 230                        TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/);
 231
 232     /* we want a pointer to the first byte of the tail in the page.
 233     ** the page was locked and this part of the page was up to date when
 234     ** indirect2direct was called, so we know the bytes are still valid
 235     */
 236     tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ;
 237
 238     PATH_LAST_POSITION(p_s_path)++;
 239
 240     key = *p_s_item_key;
 241     set_cpu_key_k_type (&key, TYPE_DIRECT);
 242     key.key_length = 4;
 243     /* Insert tail as new direct item in the tree */
 244     if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode,
 245                               tail ? tail : NULL) < 0 ) {
 246         /* No disk memory. So we can not convert last unformatted node
 247            to the direct item.  In this case we used to adjust
 248            indirect items's ih_free_space. Now ih_free_space is not
 249            used, it would be ideal to write zeros to corresponding
 250            unformatted node. For now i_size is considered as guard for
 251            going out of file size */
 252         kunmap(page) ;
 253         return n_block_size - round_tail_len;
 254     }
 255     kunmap(page) ;
 256
 257     /* make sure to get the i_blocks changes from reiserfs_insert_item */
 258     reiserfs_update_sd(th, p_s_inode);
 259
 260     // note: we have now the same as in above direct2indirect
 261     // conversion: there are two keys which have matching first three
 262     // key components. They only differ by the fouhth one.
 263
 264     /* We have inserted new direct item and must remove last
 265        unformatted node. */
 266     *p_c_mode = M_CUT;
 267
 268     /* we store position of first direct item in the in-core inode */
 269     //mark_file_with_tail (p_s_inode, pos1 + 1);
 270     REISERFS_I(p_s_inode)->i_first_direct_byte = pos1 + 1;
 271
 272     return n_block_size - round_tail_len;
 273 }
 274
 275
 276