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 /* this first locks inode (neither reads nor sync are permitted),
 166    reads tail through page cache, insert direct item. When direct item
 167    inserted successfully inode is left locked. Return value is always
 168    what we expect from it (number of cut bytes). But when tail remains
 169    in the unformatted node, we set mode to SKIP_BALANCING and unlock
 170    inode */
 171 int indirect2direct (struct reiserfs_transaction_handle *th,
 172                      struct inode * p_s_inode,
 173                      struct page *page,
 174                      struct path * p_s_path, /* path to the indirect item. */
 175                      const struct cpu_key * p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
 176                      loff_t n_new_file_size, /* New file size. */
 177                      char * p_c_mode)
 178 {
 179     struct super_block * p_s_sb = p_s_inode->i_sb;
 180     struct item_head      s_ih;
 181     unsigned long n_block_size = p_s_sb->s_blocksize;
 182     char * tail;
 183     int tail_len, round_tail_len;
 184     loff_t pos, pos1; /* position of first byte of the tail */
 185     struct cpu_key key;
 186
 187     REISERFS_SB(p_s_sb)->s_indirect2direct ++;
 188
 189     *p_c_mode = M_SKIP_BALANCING;
 190
 191     /* store item head path points to. */
 192     copy_item_head (&s_ih, PATH_PITEM_HEAD(p_s_path));
 193
 194     tail_len = (n_new_file_size & (n_block_size - 1));
 195     if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2)
 196         round_tail_len = ROUND_UP (tail_len);
 197     else
 198         round_tail_len = tail_len;
 199
 200     pos = le_ih_k_offset (&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 201     pos1 = pos;
 202
 203     // we are protected by i_sem. The tail can not disapper, not
 204     // append can be done either
 205     // we are in truncate or packing tail in file_release
 206
 207     tail = (char *)kmap(page) ; /* this can schedule */
 208
 209     if (path_changed (&s_ih, p_s_path)) {
 210         /* re-search indirect item */
 211         if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND )
 212             reiserfs_panic(p_s_sb, "PAP-5520: indirect2direct: "
 213                            "item to be converted %K does not exist", p_s_item_key);
 214         copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
 215 #ifdef CONFIG_REISERFS_CHECK
 216         pos = le_ih_k_offset (&s_ih) - 1 +
 217             (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
 218         if (pos != pos1)
 219             reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: "
 220                             "tail position changed while we were reading it");
 221 #endif
 222     }
 223
 224
 225     /* Set direct item header to insert. */
 226     make_le_item_head (&s_ih, NULL, get_inode_item_key_version (p_s_inode), pos1 + 1,
 227                        TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/);
 228
 229     /* we want a pointer to the first byte of the tail in the page.
 230     ** the page was locked and this part of the page was up to date when
 231     ** indirect2direct was called, so we know the bytes are still valid
 232     */
 233     tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ;
 234
 235     PATH_LAST_POSITION(p_s_path)++;
 236
 237     key = *p_s_item_key;
 238     set_cpu_key_k_type (&key, TYPE_DIRECT);
 239     key.key_length = 4;
 240     /* Insert tail as new direct item in the tree */
 241     if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih, p_s_inode,
 242                               tail ? tail : NULL) < 0 ) {
 243         /* No disk memory. So we can not convert last unformatted node
 244            to the direct item.  In this case we used to adjust
 245            indirect items's ih_free_space. Now ih_free_space is not
 246            used, it would be ideal to write zeros to corresponding
 247            unformatted node. For now i_size is considered as guard for
 248            going out of file size */
 249         kunmap(page) ;
 250         return n_block_size - round_tail_len;
 251     }
 252     kunmap(page) ;
 253
 254     /* make sure to get the i_blocks changes from reiserfs_insert_item */
 255     reiserfs_update_sd(th, p_s_inode);
 256
 257     // note: we have now the same as in above direct2indirect
 258     // conversion: there are two keys which have matching first three
 259     // key components. They only differ by the fouhth one.
 260
 261     /* We have inserted new direct item and must remove last
 262        unformatted node. */
 263     *p_c_mode = M_CUT;
 264
 265     /* we store position of first direct item in the in-core inode */
 266     //mark_file_with_tail (p_s_inode, pos1 + 1);
 267     REISERFS_I(p_s_inode)->i_first_direct_byte = pos1 + 1;
 268
 269     return n_block_size - round_tail_len;
 270 }
 271
 272
 273