~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/reiserfs/tail_conversion.c

Version: ~ [ linux-5.8-rc5 ] ~ [ linux-5.7.8 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.51 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.132 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.188 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.230 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.230 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp