blob: 477eaa2fcf6aac9cccbf04eb949752afb91e7795 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#include <linux/time.h>
6#include <linux/fs.h>
7#include <linux/reiserfs_fs.h>
8#include <linux/reiserfs_acl.h>
9#include <linux/reiserfs_xattr.h>
10#include <linux/smp_lock.h>
11#include <linux/pagemap.h>
12#include <linux/highmem.h>
13#include <asm/uaccess.h>
14#include <asm/unaligned.h>
15#include <linux/buffer_head.h>
16#include <linux/mpage.h>
17#include <linux/writeback.h>
18#include <linux/quotaops.h>
19
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070020extern int reiserfs_default_io_size; /* default io size devuned in super.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22static int reiserfs_commit_write(struct file *f, struct page *page,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070023 unsigned from, unsigned to);
Linus Torvalds1da177e2005-04-16 15:20:36 -070024static int reiserfs_prepare_write(struct file *f, struct page *page,
25 unsigned from, unsigned to);
26
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070027void reiserfs_delete_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070029 /* We need blocks for transaction + (user+group) quota update (possibly delete) */
30 int jbegin_count =
31 JOURNAL_PER_BALANCE_CNT * 2 +
32 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
33 struct reiserfs_transaction_handle th;
Jeff Mahoney24996042005-12-14 14:38:05 -050034 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Mark Fashehfef26652005-09-09 13:01:31 -070036 truncate_inode_pages(&inode->i_data, 0);
37
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070038 reiserfs_write_lock(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070040 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
41 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080042 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070044 reiserfs_delete_xattrs(inode);
45
46 if (journal_begin(&th, inode->i_sb, jbegin_count)) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080047 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070048 goto out;
49 }
50 reiserfs_update_inode_transaction(inode);
51
Jeff Mahoney24996042005-12-14 14:38:05 -050052 err = reiserfs_delete_object(&th, inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070053
54 /* Do quota update inside a transaction for journaled quotas. We must do that
55 * after delete_object so that quota updates go into the same transaction as
56 * stat data deletion */
Jeff Mahoney24996042005-12-14 14:38:05 -050057 if (!err)
58 DQUOT_FREE_INODE(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070059
60 if (journal_end(&th, inode->i_sb, jbegin_count)) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080061 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070062 goto out;
63 }
64
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080065 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070066
Jeff Mahoney24996042005-12-14 14:38:05 -050067 /* check return value from reiserfs_delete_object after
68 * ending the transaction
69 */
70 if (err)
71 goto out;
72
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070073 /* all items of file are deleted, so we can remove "save" link */
74 remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything
75 * about an error here */
76 } else {
77 /* no object items are in the tree */
78 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070080 out:
81 clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */
82 inode->i_blocks = 0;
83 reiserfs_write_unlock(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070086static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
87 __u32 objectid, loff_t offset, int type, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070089 key->version = version;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070091 key->on_disk_key.k_dir_id = dirid;
92 key->on_disk_key.k_objectid = objectid;
93 set_cpu_key_k_offset(key, offset);
94 set_cpu_key_k_type(key, type);
95 key->key_length = length;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096}
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set
99 offset and type of key */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700100void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
101 int type, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700103 _make_cpu_key(key, get_inode_item_key_version(inode),
104 le32_to_cpu(INODE_PKEY(inode)->k_dir_id),
105 le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,
106 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109//
110// when key is 0, do not set version and short key
111//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700112inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
113 int version,
114 loff_t offset, int type, int length,
115 int entry_count /*or ih_free_space */ )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700117 if (key) {
118 ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);
119 ih->ih_key.k_objectid =
120 cpu_to_le32(key->on_disk_key.k_objectid);
121 }
122 put_ih_version(ih, version);
123 set_le_ih_k_offset(ih, offset);
124 set_le_ih_k_type(ih, type);
125 put_ih_item_len(ih, length);
126 /* set_ih_free_space (ih, 0); */
127 // for directory items it is entry count, for directs and stat
128 // datas - 0xffff, for indirects - 0
129 put_ih_entry_count(ih, entry_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130}
131
132//
133// FIXME: we might cache recently accessed indirect item
134
135// Ugh. Not too eager for that....
136// I cut the code until such time as I see a convincing argument (benchmark).
137// I don't want a bloated inode struct..., and I don't like code complexity....
138
139/* cutting the code is fine, since it really isn't in use yet and is easy
140** to add back in. But, Vladimir has a really good idea here. Think
141** about what happens for reading a file. For each page,
142** The VFS layer calls reiserfs_readpage, who searches the tree to find
143** an indirect item. This indirect item has X number of pointers, where
144** X is a big number if we've done the block allocation right. But,
145** we only use one or two of these pointers during each call to readpage,
146** needlessly researching again later on.
147**
148** The size of the cache could be dynamic based on the size of the file.
149**
150** I'd also like to see us cache the location the stat data item, since
151** we are needlessly researching for that frequently.
152**
153** --chris
154*/
155
156/* If this page has a file tail in it, and
157** it was read in by get_block_create_0, the page data is valid,
158** but tail is still sitting in a direct item, and we can't write to
159** it. So, look through this page, and check all the mapped buffers
160** to make sure they have valid block numbers. Any that don't need
161** to be unmapped, so that block_prepare_write will correctly call
162** reiserfs_get_block to convert the tail into an unformatted node
163*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700164static inline void fix_tail_page_for_writing(struct page *page)
165{
166 struct buffer_head *head, *next, *bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700168 if (page && page_has_buffers(page)) {
169 head = page_buffers(page);
170 bh = head;
171 do {
172 next = bh->b_this_page;
173 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
174 reiserfs_unmap_buffer(bh);
175 }
176 bh = next;
177 } while (bh != head);
178 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
181/* reiserfs_get_block does not need to allocate a block only if it has been
182 done already or non-hole position has been found in the indirect item */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700183static inline int allocation_needed(int retval, b_blocknr_t allocated,
184 struct item_head *ih,
185 __le32 * item, int pos_in_item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700187 if (allocated)
188 return 0;
189 if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
190 get_block_num(item, pos_in_item))
191 return 0;
192 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193}
194
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700195static inline int indirect_item_found(int retval, struct item_head *ih)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700197 return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198}
199
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700200static inline void set_block_dev_mapped(struct buffer_head *bh,
201 b_blocknr_t block, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
203 map_bh(bh, inode->i_sb, block);
204}
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206//
207// files which were created in the earlier version can not be longer,
208// than 2 gb
209//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700210static int file_capable(struct inode *inode, long block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700212 if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.
213 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb
214 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700216 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
219/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700220 struct inode *inode, struct path *path)
221{
222 struct super_block *s = th->t_super;
223 int len = th->t_blocks_allocated;
224 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700226 BUG_ON(!th->t_trans_id);
227 BUG_ON(!th->t_refcount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700229 /* we cannot restart while nested */
230 if (th->t_refcount > 1) {
231 return 0;
232 }
233 pathrelse(path);
234 reiserfs_update_sd(th, inode);
235 err = journal_end(th, s, len);
236 if (!err) {
237 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
238 if (!err)
239 reiserfs_update_inode_transaction(inode);
240 }
241 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242}
243
244// it is called by get_block when create == 0. Returns block number
245// for 'block'-th logical block of file. When it hits direct item it
246// returns 0 (being called from bmap) or read direct item into piece
247// of page (bh_result)
248
249// Please improve the english/clarity in the comment above, as it is
250// hard to understand.
251
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700252static int _get_block_create_0(struct inode *inode, long block,
253 struct buffer_head *bh_result, int args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700255 INITIALIZE_PATH(path);
256 struct cpu_key key;
257 struct buffer_head *bh;
258 struct item_head *ih, tmp_ih;
259 int fs_gen;
260 int blocknr;
261 char *p = NULL;
262 int chars;
263 int ret;
264 int result;
265 int done = 0;
266 unsigned long offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700268 // prepare the key to look for the 'block'-th block of file
269 make_cpu_key(&key, inode,
270 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
271 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700273 research:
274 result = search_for_position_by_key(inode->i_sb, &key, &path);
275 if (result != POSITION_FOUND) {
276 pathrelse(&path);
277 if (p)
278 kunmap(bh_result->b_page);
279 if (result == IO_ERROR)
280 return -EIO;
281 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
282 // That there is some MMAPED data associated with it that is yet to be written to disk.
283 if ((args & GET_BLOCK_NO_HOLE)
284 && !PageUptodate(bh_result->b_page)) {
285 return -ENOENT;
286 }
287 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700289 //
290 bh = get_last_bh(&path);
291 ih = get_ih(&path);
292 if (is_indirect_le_ih(ih)) {
293 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700295 /* FIXME: here we could cache indirect item or part of it in
296 the inode to avoid search_by_key in case of subsequent
297 access to file */
298 blocknr = get_block_num(ind_item, path.pos_in_item);
299 ret = 0;
300 if (blocknr) {
301 map_bh(bh_result, inode->i_sb, blocknr);
302 if (path.pos_in_item ==
303 ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
304 set_buffer_boundary(bh_result);
305 }
306 } else
307 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
308 // That there is some MMAPED data associated with it that is yet to be written to disk.
309 if ((args & GET_BLOCK_NO_HOLE)
310 && !PageUptodate(bh_result->b_page)) {
311 ret = -ENOENT;
312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700314 pathrelse(&path);
315 if (p)
316 kunmap(bh_result->b_page);
317 return ret;
318 }
319 // requested data are in direct item(s)
320 if (!(args & GET_BLOCK_READ_DIRECT)) {
321 // we are called by bmap. FIXME: we can not map block of file
322 // when it is stored in direct item(s)
323 pathrelse(&path);
324 if (p)
325 kunmap(bh_result->b_page);
326 return -ENOENT;
327 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700329 /* if we've got a direct item, and the buffer or page was uptodate,
330 ** we don't want to pull data off disk again. skip to the
331 ** end, where we map the buffer and return
332 */
333 if (buffer_uptodate(bh_result)) {
334 goto finished;
335 } else
336 /*
337 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date
338 ** pages without any buffers. If the page is up to date, we don't want
339 ** read old data off disk. Set the up to date bit on the buffer instead
340 ** and jump to the end
341 */
342 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 set_buffer_uptodate(bh_result);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700344 goto finished;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700346 // read file tail into part of page
347 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
348 fs_gen = get_generation(inode->i_sb);
349 copy_item_head(&tmp_ih, ih);
350
351 /* we only want to kmap if we are reading the tail into the page.
352 ** this is not the common case, so we don't kmap until we are
353 ** sure we need to. But, this means the item might move if
354 ** kmap schedules
355 */
356 if (!p) {
357 p = (char *)kmap(bh_result->b_page);
358 if (fs_changed(fs_gen, inode->i_sb)
359 && item_moved(&tmp_ih, &path)) {
360 goto research;
361 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700363 p += offset;
364 memset(p, 0, inode->i_sb->s_blocksize);
365 do {
366 if (!is_direct_le_ih(ih)) {
367 BUG();
368 }
369 /* make sure we don't read more bytes than actually exist in
370 ** the file. This can happen in odd cases where i_size isn't
371 ** correct, and when direct item padding results in a few
372 ** extra bytes at the end of the direct item
373 */
374 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
375 break;
376 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
377 chars =
378 inode->i_size - (le_ih_k_offset(ih) - 1) -
379 path.pos_in_item;
380 done = 1;
381 } else {
382 chars = ih_item_len(ih) - path.pos_in_item;
383 }
384 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700386 if (done)
387 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700389 p += chars;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700391 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
392 // we done, if read direct item is not the last item of
393 // node FIXME: we could try to check right delimiting key
394 // to see whether direct item continues in the right
395 // neighbor or rely on i_size
396 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700398 // update key to look for the next piece
399 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
400 result = search_for_position_by_key(inode->i_sb, &key, &path);
401 if (result != POSITION_FOUND)
402 // i/o error most likely
403 break;
404 bh = get_last_bh(&path);
405 ih = get_ih(&path);
406 } while (1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700408 flush_dcache_page(bh_result->b_page);
409 kunmap(bh_result->b_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700411 finished:
412 pathrelse(&path);
Qu Fuping6283d582005-06-25 14:55:44 -0700413
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700414 if (result == IO_ERROR)
415 return -EIO;
Qu Fuping6283d582005-06-25 14:55:44 -0700416
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700417 /* this buffer has valid data, but isn't valid for io. mapping it to
418 * block #0 tells the rest of reiserfs it just has a tail in it
419 */
420 map_bh(bh_result, inode->i_sb, 0);
421 set_buffer_uptodate(bh_result);
422 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423}
424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425// this is called to create file map. So, _get_block_create_0 will not
426// read direct item
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700427static int reiserfs_bmap(struct inode *inode, sector_t block,
428 struct buffer_head *bh_result, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700430 if (!file_capable(inode, block))
431 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700433 reiserfs_write_lock(inode->i_sb);
434 /* do not read the direct item */
435 _get_block_create_0(inode, block, bh_result, 0);
436 reiserfs_write_unlock(inode->i_sb);
437 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438}
439
440/* special version of get_block that is only used by grab_tail_page right
441** now. It is sent to block_prepare_write, and when you try to get a
442** block past the end of the file (or a block from a hole) it returns
443** -ENOENT instead of a valid buffer. block_prepare_write expects to
444** be able to do i/o on the buffers returned, unless an error value
445** is also returned.
446**
447** So, this allows block_prepare_write to be used for reading a single block
448** in a page. Where it does not produce a valid page for holes, or past the
449** end of the file. This turns out to be exactly what we need for reading
450** tails for conversion.
451**
452** The point of the wrapper is forcing a certain value for create, even
453** though the VFS layer is calling this function with create==1. If you
454** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
455** don't use this function.
456*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700457static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
458 struct buffer_head *bh_result,
459 int create)
460{
461 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462}
463
464/* This is special helper for reiserfs_get_block in case we are executing
465 direct_IO request. */
466static int reiserfs_get_blocks_direct_io(struct inode *inode,
467 sector_t iblock,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 struct buffer_head *bh_result,
469 int create)
470{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700471 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700473 bh_result->b_page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700475 /* We set the b_size before reiserfs_get_block call since it is
476 referenced in convert_tail_for_hole() that may be called from
477 reiserfs_get_block() */
478 bh_result->b_size = (1 << inode->i_blkbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700480 ret = reiserfs_get_block(inode, iblock, bh_result,
481 create | GET_BLOCK_NO_DANGLE);
482 if (ret)
483 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700485 /* don't allow direct io onto tail pages */
486 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
487 /* make sure future calls to the direct io funcs for this offset
488 ** in the file fail by unmapping the buffer
489 */
490 clear_buffer_mapped(bh_result);
491 ret = -EINVAL;
492 }
493 /* Possible unpacked tail. Flush the data before pages have
494 disappeared */
495 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
496 int err;
497 lock_kernel();
498 err = reiserfs_commit_for_inode(inode);
499 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
500 unlock_kernel();
501 if (err < 0)
502 ret = err;
503 }
504 out:
505 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506}
507
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508/*
509** helper function for when reiserfs_get_block is called for a hole
510** but the file tail is still in a direct item
511** bh_result is the buffer head for the hole
512** tail_offset is the offset of the start of the tail in the file
513**
514** This calls prepare_write, which will start a new transaction
515** you should not be in a transaction, or have any paths held when you
516** call this.
517*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700518static int convert_tail_for_hole(struct inode *inode,
519 struct buffer_head *bh_result,
520 loff_t tail_offset)
521{
522 unsigned long index;
523 unsigned long tail_end;
524 unsigned long tail_start;
525 struct page *tail_page;
526 struct page *hole_page = bh_result->b_page;
527 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700529 if ((tail_offset & (bh_result->b_size - 1)) != 1)
530 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700532 /* always try to read until the end of the block */
533 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
534 tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700536 index = tail_offset >> PAGE_CACHE_SHIFT;
537 /* hole_page can be zero in case of direct_io, we are sure
538 that we cannot get here if we write with O_DIRECT into
539 tail page */
540 if (!hole_page || index != hole_page->index) {
541 tail_page = grab_cache_page(inode->i_mapping, index);
542 retval = -ENOMEM;
543 if (!tail_page) {
544 goto out;
545 }
546 } else {
547 tail_page = hole_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700550 /* we don't have to make sure the conversion did not happen while
551 ** we were locking the page because anyone that could convert
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800552 ** must first take i_mutex.
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700553 **
554 ** We must fix the tail page for writing because it might have buffers
555 ** that are mapped, but have a block number of 0. This indicates tail
556 ** data that has been read directly into the page, and block_prepare_write
557 ** won't trigger a get_block in this case.
558 */
559 fix_tail_page_for_writing(tail_page);
560 retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);
561 if (retval)
562 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700564 /* tail conversion might change the data in the page */
565 flush_dcache_page(tail_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700567 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700569 unlock:
570 if (tail_page != hole_page) {
571 unlock_page(tail_page);
572 page_cache_release(tail_page);
573 }
574 out:
575 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
578static inline int _allocate_block(struct reiserfs_transaction_handle *th,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700579 long block,
580 struct inode *inode,
581 b_blocknr_t * allocated_block_nr,
582 struct path *path, int flags)
583{
584 BUG_ON(!th->t_trans_id);
585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586#ifdef REISERFS_PREALLOCATE
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800587 if (!(flags & GET_BLOCK_NO_IMUX)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700588 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
589 path, block);
590 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700592 return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
593 block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594}
595
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700596int reiserfs_get_block(struct inode *inode, sector_t block,
597 struct buffer_head *bh_result, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700599 int repeat, retval = 0;
600 b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int
601 INITIALIZE_PATH(path);
602 int pos_in_item;
603 struct cpu_key key;
604 struct buffer_head *bh, *unbh = NULL;
605 struct item_head *ih, tmp_ih;
606 __le32 *item;
607 int done;
608 int fs_gen;
609 struct reiserfs_transaction_handle *th = NULL;
610 /* space reserved in transaction batch:
611 . 3 balancings in direct->indirect conversion
612 . 1 block involved into reiserfs_update_sd()
613 XXX in practically impossible worst case direct2indirect()
614 can incur (much) more than 3 balancings.
615 quota update for user, group */
616 int jbegin_count =
617 JOURNAL_PER_BALANCE_CNT * 3 + 1 +
618 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
619 int version;
620 int dangle = 1;
621 loff_t new_offset =
622 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700624 /* bad.... */
625 reiserfs_write_lock(inode->i_sb);
626 version = get_inode_item_key_version(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700628 if (!file_capable(inode, block)) {
629 reiserfs_write_unlock(inode->i_sb);
630 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700633 /* if !create, we aren't changing the FS, so we don't need to
634 ** log anything, so we don't need to start a transaction
635 */
636 if (!(create & GET_BLOCK_CREATE)) {
637 int ret;
638 /* find number of block-th logical block of the file */
639 ret = _get_block_create_0(inode, block, bh_result,
640 create | GET_BLOCK_READ_DIRECT);
641 reiserfs_write_unlock(inode->i_sb);
642 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700644 /*
645 * if we're already in a transaction, make sure to close
646 * any new transactions we start in this func
647 */
648 if ((create & GET_BLOCK_NO_DANGLE) ||
649 reiserfs_transaction_running(inode->i_sb))
650 dangle = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700652 /* If file is of such a size, that it might have a tail and tails are enabled
653 ** we should mark it as possibly needing tail packing on close
654 */
655 if ((have_large_tails(inode->i_sb)
656 && inode->i_size < i_block_size(inode) * 4)
657 || (have_small_tails(inode->i_sb)
658 && inode->i_size < i_block_size(inode)))
659 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
660
661 /* set the key of the first byte in the 'block'-th block of file */
662 make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
663 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
664 start_trans:
665 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
666 if (!th) {
667 retval = -ENOMEM;
668 goto failure;
669 }
670 reiserfs_update_inode_transaction(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700672 research:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700674 retval = search_for_position_by_key(inode->i_sb, &key, &path);
675 if (retval == IO_ERROR) {
676 retval = -EIO;
677 goto failure;
678 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700680 bh = get_last_bh(&path);
681 ih = get_ih(&path);
682 item = get_item(&path);
683 pos_in_item = path.pos_in_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700685 fs_gen = get_generation(inode->i_sb);
686 copy_item_head(&tmp_ih, ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700688 if (allocation_needed
689 (retval, allocated_block_nr, ih, item, pos_in_item)) {
690 /* we have to allocate block for the unformatted node */
691 if (!th) {
692 pathrelse(&path);
693 goto start_trans;
694 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700696 repeat =
697 _allocate_block(th, block, inode, &allocated_block_nr,
698 &path, create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700700 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
701 /* restart the transaction to give the journal a chance to free
702 ** some blocks. releases the path, so we have to go back to
703 ** research if we succeed on the second try
704 */
705 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
706 retval = restart_transaction(th, inode, &path);
707 if (retval)
708 goto failure;
709 repeat =
710 _allocate_block(th, block, inode,
711 &allocated_block_nr, NULL, create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700713 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
714 goto research;
715 }
716 if (repeat == QUOTA_EXCEEDED)
717 retval = -EDQUOT;
718 else
719 retval = -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 goto failure;
721 }
722
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700723 if (fs_changed(fs_gen, inode->i_sb)
724 && item_moved(&tmp_ih, &path)) {
725 goto research;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700727 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700729 if (indirect_item_found(retval, ih)) {
730 b_blocknr_t unfm_ptr;
731 /* 'block'-th block is in the file already (there is
732 corresponding cell in some indirect item). But it may be
733 zero unformatted node pointer (hole) */
734 unfm_ptr = get_block_num(item, pos_in_item);
735 if (unfm_ptr == 0) {
736 /* use allocated block to plug the hole */
737 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
738 if (fs_changed(fs_gen, inode->i_sb)
739 && item_moved(&tmp_ih, &path)) {
740 reiserfs_restore_prepared_buffer(inode->i_sb,
741 bh);
742 goto research;
743 }
744 set_buffer_new(bh_result);
745 if (buffer_dirty(bh_result)
746 && reiserfs_data_ordered(inode->i_sb))
747 reiserfs_add_ordered_list(inode, bh_result);
748 put_block_num(item, pos_in_item, allocated_block_nr);
749 unfm_ptr = allocated_block_nr;
750 journal_mark_dirty(th, inode->i_sb, bh);
751 reiserfs_update_sd(th, inode);
752 }
753 set_block_dev_mapped(bh_result, unfm_ptr, inode);
754 pathrelse(&path);
755 retval = 0;
756 if (!dangle && th)
757 retval = reiserfs_end_persistent_transaction(th);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700759 reiserfs_write_unlock(inode->i_sb);
760
761 /* the item was found, so new blocks were not added to the file
762 ** there is no need to make sure the inode is updated with this
763 ** transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700765 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 }
767
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700768 if (!th) {
769 pathrelse(&path);
770 goto start_trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700773 /* desired position is not found or is in the direct item. We have
774 to append file with holes up to 'block'-th block converting
775 direct items to indirect one if necessary */
776 done = 0;
777 do {
778 if (is_statdata_le_ih(ih)) {
779 __le32 unp = 0;
780 struct cpu_key tmp_key;
781
782 /* indirect item has to be inserted */
783 make_le_item_head(&tmp_ih, &key, version, 1,
784 TYPE_INDIRECT, UNFM_P_SIZE,
785 0 /* free_space */ );
786
787 if (cpu_key_k_offset(&key) == 1) {
788 /* we are going to add 'block'-th block to the file. Use
789 allocated block for that */
790 unp = cpu_to_le32(allocated_block_nr);
791 set_block_dev_mapped(bh_result,
792 allocated_block_nr, inode);
793 set_buffer_new(bh_result);
794 done = 1;
795 }
796 tmp_key = key; // ;)
797 set_cpu_key_k_offset(&tmp_key, 1);
798 PATH_LAST_POSITION(&path)++;
799
800 retval =
801 reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
802 inode, (char *)&unp);
803 if (retval) {
804 reiserfs_free_block(th, inode,
805 allocated_block_nr, 1);
806 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
807 }
808 //mark_tail_converted (inode);
809 } else if (is_direct_le_ih(ih)) {
810 /* direct item has to be converted */
811 loff_t tail_offset;
812
813 tail_offset =
814 ((le_ih_k_offset(ih) -
815 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
816 if (tail_offset == cpu_key_k_offset(&key)) {
817 /* direct item we just found fits into block we have
818 to map. Convert it into unformatted node: use
819 bh_result for the conversion */
820 set_block_dev_mapped(bh_result,
821 allocated_block_nr, inode);
822 unbh = bh_result;
823 done = 1;
824 } else {
825 /* we have to padd file tail stored in direct item(s)
826 up to block size and convert it to unformatted
827 node. FIXME: this should also get into page cache */
828
829 pathrelse(&path);
830 /*
831 * ugly, but we can only end the transaction if
832 * we aren't nested
833 */
834 BUG_ON(!th->t_refcount);
835 if (th->t_refcount == 1) {
836 retval =
837 reiserfs_end_persistent_transaction
838 (th);
839 th = NULL;
840 if (retval)
841 goto failure;
842 }
843
844 retval =
845 convert_tail_for_hole(inode, bh_result,
846 tail_offset);
847 if (retval) {
848 if (retval != -ENOSPC)
849 reiserfs_warning(inode->i_sb,
850 "clm-6004: convert tail failed inode %lu, error %d",
851 inode->i_ino,
852 retval);
853 if (allocated_block_nr) {
854 /* the bitmap, the super, and the stat data == 3 */
855 if (!th)
856 th = reiserfs_persistent_transaction(inode->i_sb, 3);
857 if (th)
858 reiserfs_free_block(th,
859 inode,
860 allocated_block_nr,
861 1);
862 }
863 goto failure;
864 }
865 goto research;
866 }
867 retval =
868 direct2indirect(th, inode, &path, unbh,
869 tail_offset);
870 if (retval) {
871 reiserfs_unmap_buffer(unbh);
872 reiserfs_free_block(th, inode,
873 allocated_block_nr, 1);
874 goto failure;
875 }
876 /* it is important the set_buffer_uptodate is done after
877 ** the direct2indirect. The buffer might contain valid
878 ** data newer than the data on disk (read by readpage, changed,
879 ** and then sent here by writepage). direct2indirect needs
880 ** to know if unbh was already up to date, so it can decide
881 ** if the data in unbh needs to be replaced with data from
882 ** the disk
883 */
884 set_buffer_uptodate(unbh);
885
886 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
887 buffer will disappear shortly, so it should not be added to
888 */
889 if (unbh->b_page) {
890 /* we've converted the tail, so we must
891 ** flush unbh before the transaction commits
892 */
893 reiserfs_add_tail_list(inode, unbh);
894
895 /* mark it dirty now to prevent commit_write from adding
896 ** this buffer to the inode's dirty buffer list
897 */
898 /*
899 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
900 * It's still atomic, but it sets the page dirty too,
901 * which makes it eligible for writeback at any time by the
902 * VM (which was also the case with __mark_buffer_dirty())
903 */
904 mark_buffer_dirty(unbh);
905 }
906 } else {
907 /* append indirect item with holes if needed, when appending
908 pointer to 'block'-th block use block, which is already
909 allocated */
910 struct cpu_key tmp_key;
911 unp_t unf_single = 0; // We use this in case we need to allocate only
912 // one block which is a fastpath
913 unp_t *un;
914 __u64 max_to_insert =
915 MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
916 UNFM_P_SIZE;
917 __u64 blocks_needed;
918
919 RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
920 "vs-804: invalid position for append");
921 /* indirect item has to be appended, set up key of that position */
922 make_cpu_key(&tmp_key, inode,
923 le_key_k_offset(version,
924 &(ih->ih_key)) +
925 op_bytes_number(ih,
926 inode->i_sb->s_blocksize),
927 //pos_in_item * inode->i_sb->s_blocksize,
928 TYPE_INDIRECT, 3); // key type is unimportant
929
Vladimir V. Savelievc499ec22006-03-02 02:54:39 -0800930 RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),
931 "green-805: invalid offset");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700932 blocks_needed =
933 1 +
934 ((cpu_key_k_offset(&key) -
935 cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
936 s_blocksize_bits);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700937
938 if (blocks_needed == 1) {
939 un = &unf_single;
940 } else {
941 un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC); // We need to avoid scheduling.
942 if (!un) {
943 un = &unf_single;
944 blocks_needed = 1;
945 max_to_insert = 0;
946 } else
947 memset(un, 0,
948 UNFM_P_SIZE * min(blocks_needed,
949 max_to_insert));
950 }
951 if (blocks_needed <= max_to_insert) {
952 /* we are going to add target block to the file. Use allocated
953 block for that */
954 un[blocks_needed - 1] =
955 cpu_to_le32(allocated_block_nr);
956 set_block_dev_mapped(bh_result,
957 allocated_block_nr, inode);
958 set_buffer_new(bh_result);
959 done = 1;
960 } else {
961 /* paste hole to the indirect item */
962 /* If kmalloc failed, max_to_insert becomes zero and it means we
963 only have space for one block */
964 blocks_needed =
965 max_to_insert ? max_to_insert : 1;
966 }
967 retval =
968 reiserfs_paste_into_item(th, &path, &tmp_key, inode,
969 (char *)un,
970 UNFM_P_SIZE *
971 blocks_needed);
972
973 if (blocks_needed != 1)
974 kfree(un);
975
976 if (retval) {
977 reiserfs_free_block(th, inode,
978 allocated_block_nr, 1);
979 goto failure;
980 }
981 if (!done) {
982 /* We need to mark new file size in case this function will be
983 interrupted/aborted later on. And we may do this only for
984 holes. */
985 inode->i_size +=
986 inode->i_sb->s_blocksize * blocks_needed;
987 }
988 }
989
990 if (done == 1)
991 break;
992
993 /* this loop could log more blocks than we had originally asked
994 ** for. So, we have to allow the transaction to end if it is
995 ** too big or too full. Update the inode so things are
996 ** consistent if we crash before the function returns
997 **
998 ** release the path so that anybody waiting on the path before
999 ** ending their transaction will be able to continue.
1000 */
1001 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
1002 retval = restart_transaction(th, inode, &path);
1003 if (retval)
1004 goto failure;
1005 }
1006 /* inserting indirect pointers for a hole can take a
1007 ** long time. reschedule if needed
1008 */
1009 cond_resched();
1010
1011 retval = search_for_position_by_key(inode->i_sb, &key, &path);
1012 if (retval == IO_ERROR) {
1013 retval = -EIO;
1014 goto failure;
1015 }
1016 if (retval == POSITION_FOUND) {
1017 reiserfs_warning(inode->i_sb,
1018 "vs-825: reiserfs_get_block: "
1019 "%K should not be found", &key);
1020 retval = -EEXIST;
1021 if (allocated_block_nr)
1022 reiserfs_free_block(th, inode,
1023 allocated_block_nr, 1);
1024 pathrelse(&path);
1025 goto failure;
1026 }
1027 bh = get_last_bh(&path);
1028 ih = get_ih(&path);
1029 item = get_item(&path);
1030 pos_in_item = path.pos_in_item;
1031 } while (1);
1032
1033 retval = 0;
1034
1035 failure:
1036 if (th && (!dangle || (retval && !th->t_trans_id))) {
1037 int err;
1038 if (th->t_trans_id)
1039 reiserfs_update_sd(th, inode);
1040 err = reiserfs_end_persistent_transaction(th);
1041 if (err)
1042 retval = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001045 reiserfs_write_unlock(inode->i_sb);
1046 reiserfs_check_path(&path);
1047 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048}
1049
1050static int
1051reiserfs_readpages(struct file *file, struct address_space *mapping,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001052 struct list_head *pages, unsigned nr_pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001054 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055}
1056
1057/* Compute real number of used bytes by file
1058 * Following three functions can go away when we'll have enough space in stat item
1059 */
1060static int real_space_diff(struct inode *inode, int sd_size)
1061{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001062 int bytes;
1063 loff_t blocksize = inode->i_sb->s_blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001065 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1066 return sd_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001068 /* End of file is also in full block with indirect reference, so round
1069 ** up to the next block.
1070 **
1071 ** there is just no way to know if the tail is actually packed
1072 ** on the file, so we have to assume it isn't. When we pack the
1073 ** tail, we add 4 bytes to pretend there really is an unformatted
1074 ** node pointer
1075 */
1076 bytes =
1077 ((inode->i_size +
1078 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1079 sd_size;
1080 return bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081}
1082
1083static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001084 int sd_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001086 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1087 return inode->i_size +
1088 (loff_t) (real_space_diff(inode, sd_size));
1089 }
1090 return ((loff_t) real_space_diff(inode, sd_size)) +
1091 (((loff_t) blocks) << 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092}
1093
1094/* Compute number of blocks used by file in ReiserFS counting */
1095static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1096{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001097 loff_t bytes = inode_get_bytes(inode);
1098 loff_t real_space = real_space_diff(inode, sd_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001100 /* keeps fsck and non-quota versions of reiserfs happy */
1101 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1102 bytes += (loff_t) 511;
1103 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001105 /* files from before the quota patch might i_blocks such that
1106 ** bytes < real_space. Deal with that here to prevent it from
1107 ** going negative.
1108 */
1109 if (bytes < real_space)
1110 return 0;
1111 return (bytes - real_space) >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112}
1113
1114//
1115// BAD: new directories have stat data of new type and all other items
1116// of old type. Version stored in the inode says about body items, so
1117// in update_stat_data we can not rely on inode, but have to check
1118// item version directly
1119//
1120
1121// called by read_locked_inode
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001122static void init_inode(struct inode *inode, struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001124 struct buffer_head *bh;
1125 struct item_head *ih;
1126 __u32 rdev;
1127 //int version = ITEM_VERSION_1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001129 bh = PATH_PLAST_BUFFER(path);
1130 ih = PATH_PITEM_HEAD(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001132 copy_key(INODE_PKEY(inode), &(ih->ih_key));
1133 inode->i_blksize = reiserfs_default_io_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001135 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1136 REISERFS_I(inode)->i_flags = 0;
1137 REISERFS_I(inode)->i_prealloc_block = 0;
1138 REISERFS_I(inode)->i_prealloc_count = 0;
1139 REISERFS_I(inode)->i_trans_id = 0;
1140 REISERFS_I(inode)->i_jl = NULL;
1141 REISERFS_I(inode)->i_acl_access = NULL;
1142 REISERFS_I(inode)->i_acl_default = NULL;
1143 init_rwsem(&REISERFS_I(inode)->xattr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001145 if (stat_data_v1(ih)) {
1146 struct stat_data_v1 *sd =
1147 (struct stat_data_v1 *)B_I_PITEM(bh, ih);
1148 unsigned long blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001150 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1151 set_inode_sd_version(inode, STAT_DATA_V1);
1152 inode->i_mode = sd_v1_mode(sd);
1153 inode->i_nlink = sd_v1_nlink(sd);
1154 inode->i_uid = sd_v1_uid(sd);
1155 inode->i_gid = sd_v1_gid(sd);
1156 inode->i_size = sd_v1_size(sd);
1157 inode->i_atime.tv_sec = sd_v1_atime(sd);
1158 inode->i_mtime.tv_sec = sd_v1_mtime(sd);
1159 inode->i_ctime.tv_sec = sd_v1_ctime(sd);
1160 inode->i_atime.tv_nsec = 0;
1161 inode->i_ctime.tv_nsec = 0;
1162 inode->i_mtime.tv_nsec = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001164 inode->i_blocks = sd_v1_blocks(sd);
1165 inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1166 blocks = (inode->i_size + 511) >> 9;
1167 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
1168 if (inode->i_blocks > blocks) {
1169 // there was a bug in <=3.5.23 when i_blocks could take negative
1170 // values. Starting from 3.5.17 this value could even be stored in
1171 // stat data. For such files we set i_blocks based on file
1172 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be
1173 // only updated if file's inode will ever change
1174 inode->i_blocks = blocks;
1175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001177 rdev = sd_v1_rdev(sd);
1178 REISERFS_I(inode)->i_first_direct_byte =
1179 sd_v1_first_direct_byte(sd);
1180 /* an early bug in the quota code can give us an odd number for the
1181 ** block count. This is incorrect, fix it here.
1182 */
1183 if (inode->i_blocks & 1) {
1184 inode->i_blocks++;
1185 }
1186 inode_set_bytes(inode,
1187 to_real_used_space(inode, inode->i_blocks,
1188 SD_V1_SIZE));
1189 /* nopack is initially zero for v1 objects. For v2 objects,
1190 nopack is initialised from sd_attrs */
1191 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1192 } else {
1193 // new stat data found, but object may have old items
1194 // (directories and symlinks)
1195 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
1196
1197 inode->i_mode = sd_v2_mode(sd);
1198 inode->i_nlink = sd_v2_nlink(sd);
1199 inode->i_uid = sd_v2_uid(sd);
1200 inode->i_size = sd_v2_size(sd);
1201 inode->i_gid = sd_v2_gid(sd);
1202 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1203 inode->i_atime.tv_sec = sd_v2_atime(sd);
1204 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1205 inode->i_ctime.tv_nsec = 0;
1206 inode->i_mtime.tv_nsec = 0;
1207 inode->i_atime.tv_nsec = 0;
1208 inode->i_blocks = sd_v2_blocks(sd);
1209 rdev = sd_v2_rdev(sd);
1210 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1211 inode->i_generation =
1212 le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1213 else
1214 inode->i_generation = sd_v2_generation(sd);
1215
1216 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1217 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1218 else
1219 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1220 REISERFS_I(inode)->i_first_direct_byte = 0;
1221 set_inode_sd_version(inode, STAT_DATA_V2);
1222 inode_set_bytes(inode,
1223 to_real_used_space(inode, inode->i_blocks,
1224 SD_V2_SIZE));
1225 /* read persistent inode attributes from sd and initalise
1226 generic inode flags from them */
1227 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1228 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
1230
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001231 pathrelse(path);
1232 if (S_ISREG(inode->i_mode)) {
1233 inode->i_op = &reiserfs_file_inode_operations;
1234 inode->i_fop = &reiserfs_file_operations;
1235 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1236 } else if (S_ISDIR(inode->i_mode)) {
1237 inode->i_op = &reiserfs_dir_inode_operations;
1238 inode->i_fop = &reiserfs_dir_operations;
1239 } else if (S_ISLNK(inode->i_mode)) {
1240 inode->i_op = &reiserfs_symlink_inode_operations;
1241 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1242 } else {
1243 inode->i_blocks = 0;
1244 inode->i_op = &reiserfs_special_inode_operations;
1245 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247}
1248
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249// update new stat data with inode fields
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001250static void inode2sd(void *sd, struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001252 struct stat_data *sd_v2 = (struct stat_data *)sd;
1253 __u16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001255 set_sd_v2_mode(sd_v2, inode->i_mode);
1256 set_sd_v2_nlink(sd_v2, inode->i_nlink);
1257 set_sd_v2_uid(sd_v2, inode->i_uid);
1258 set_sd_v2_size(sd_v2, size);
1259 set_sd_v2_gid(sd_v2, inode->i_gid);
1260 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);
1261 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);
1262 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);
1263 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));
1264 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1265 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));
1266 else
1267 set_sd_v2_generation(sd_v2, inode->i_generation);
1268 flags = REISERFS_I(inode)->i_attrs;
1269 i_attrs_to_sd_attrs(inode, &flags);
1270 set_sd_v2_attrs(sd_v2, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271}
1272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273// used to copy inode's fields to old stat data
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001274static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001276 struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001278 set_sd_v1_mode(sd_v1, inode->i_mode);
1279 set_sd_v1_uid(sd_v1, inode->i_uid);
1280 set_sd_v1_gid(sd_v1, inode->i_gid);
1281 set_sd_v1_nlink(sd_v1, inode->i_nlink);
1282 set_sd_v1_size(sd_v1, size);
1283 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);
1284 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);
1285 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001287 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1288 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));
1289 else
1290 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001292 // Sigh. i_first_direct_byte is back
1293 set_sd_v1_first_direct_byte(sd_v1,
1294 REISERFS_I(inode)->i_first_direct_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295}
1296
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297/* NOTE, you must prepare the buffer head before sending it here,
1298** and then log it after the call
1299*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001300static void update_stat_data(struct path *path, struct inode *inode,
1301 loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001303 struct buffer_head *bh;
1304 struct item_head *ih;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001306 bh = PATH_PLAST_BUFFER(path);
1307 ih = PATH_PITEM_HEAD(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001309 if (!is_statdata_le_ih(ih))
1310 reiserfs_panic(inode->i_sb,
1311 "vs-13065: update_stat_data: key %k, found item %h",
1312 INODE_PKEY(inode), ih);
1313
1314 if (stat_data_v1(ih)) {
1315 // path points to old stat data
1316 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1317 } else {
1318 inode2sd(B_I_PITEM(bh, ih), inode, size);
1319 }
1320
1321 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322}
1323
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001324void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1325 struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001327 struct cpu_key key;
1328 INITIALIZE_PATH(path);
1329 struct buffer_head *bh;
1330 int fs_gen;
1331 struct item_head *ih, tmp_ih;
1332 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001334 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001336 make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant
1337
1338 for (;;) {
1339 int pos;
1340 /* look for the object's stat data */
1341 retval = search_item(inode->i_sb, &key, &path);
1342 if (retval == IO_ERROR) {
1343 reiserfs_warning(inode->i_sb,
1344 "vs-13050: reiserfs_update_sd: "
1345 "i/o failure occurred trying to update %K stat data",
1346 &key);
1347 return;
1348 }
1349 if (retval == ITEM_NOT_FOUND) {
1350 pos = PATH_LAST_POSITION(&path);
1351 pathrelse(&path);
1352 if (inode->i_nlink == 0) {
1353 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1354 return;
1355 }
1356 reiserfs_warning(inode->i_sb,
1357 "vs-13060: reiserfs_update_sd: "
1358 "stat data of object %k (nlink == %d) not found (pos %d)",
1359 INODE_PKEY(inode), inode->i_nlink,
1360 pos);
1361 reiserfs_check_path(&path);
1362 return;
1363 }
1364
1365 /* sigh, prepare_for_journal might schedule. When it schedules the
1366 ** FS might change. We have to detect that, and loop back to the
1367 ** search if the stat data item has moved
1368 */
1369 bh = get_last_bh(&path);
1370 ih = get_ih(&path);
1371 copy_item_head(&tmp_ih, ih);
1372 fs_gen = get_generation(inode->i_sb);
1373 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
1374 if (fs_changed(fs_gen, inode->i_sb)
1375 && item_moved(&tmp_ih, &path)) {
1376 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
1377 continue; /* Stat_data item has been moved after scheduling. */
1378 }
1379 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001381 update_stat_data(&path, inode, size);
1382 journal_mark_dirty(th, th->t_super, bh);
1383 pathrelse(&path);
1384 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385}
1386
1387/* reiserfs_read_locked_inode is called to read the inode off disk, and it
1388** does a make_bad_inode when things go wrong. But, we need to make sure
1389** and clear the key in the private portion of the inode, otherwise a
1390** corresponding iput might try to delete whatever object the inode last
1391** represented.
1392*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001393static void reiserfs_make_bad_inode(struct inode *inode)
1394{
1395 memset(INODE_PKEY(inode), 0, KEY_SIZE);
1396 make_bad_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397}
1398
1399//
1400// initially this function was derived from minix or ext2's analog and
1401// evolved as the prototype did
1402//
1403
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001404int reiserfs_init_locked_inode(struct inode *inode, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001406 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;
1407 inode->i_ino = args->objectid;
1408 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);
1409 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410}
1411
1412/* looks for stat data in the tree, and fills up the fields of in-core
1413 inode stat data fields */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001414void reiserfs_read_locked_inode(struct inode *inode,
1415 struct reiserfs_iget_args *args)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001417 INITIALIZE_PATH(path_to_sd);
1418 struct cpu_key key;
1419 unsigned long dirino;
1420 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001422 dirino = args->dirid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001424 /* set version 1, version 2 could be used too, because stat data
1425 key is the same in both versions */
1426 key.version = KEY_FORMAT_3_5;
1427 key.on_disk_key.k_dir_id = dirino;
1428 key.on_disk_key.k_objectid = inode->i_ino;
1429 key.on_disk_key.k_offset = 0;
1430 key.on_disk_key.k_type = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001432 /* look for the object's stat data */
1433 retval = search_item(inode->i_sb, &key, &path_to_sd);
1434 if (retval == IO_ERROR) {
1435 reiserfs_warning(inode->i_sb,
1436 "vs-13070: reiserfs_read_locked_inode: "
1437 "i/o failure occurred trying to find stat data of %K",
1438 &key);
1439 reiserfs_make_bad_inode(inode);
1440 return;
1441 }
1442 if (retval != ITEM_FOUND) {
1443 /* a stale NFS handle can trigger this without it being an error */
1444 pathrelse(&path_to_sd);
1445 reiserfs_make_bad_inode(inode);
1446 inode->i_nlink = 0;
1447 return;
1448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001450 init_inode(inode, &path_to_sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001452 /* It is possible that knfsd is trying to access inode of a file
1453 that is being removed from the disk by some other thread. As we
1454 update sd on unlink all that is required is to check for nlink
1455 here. This bug was first found by Sizif when debugging
1456 SquidNG/Butterfly, forgotten, and found again after Philippe
1457 Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001459 More logical fix would require changes in fs/inode.c:iput() to
1460 remove inode from hash-table _after_ fs cleaned disk stuff up and
1461 in iget() to return NULL if I_FREEING inode is found in
1462 hash-table. */
1463 /* Currently there is one place where it's ok to meet inode with
1464 nlink==0: processing of open-unlinked and half-truncated files
1465 during mount (fs/reiserfs/super.c:finish_unfinished()). */
1466 if ((inode->i_nlink == 0) &&
1467 !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
1468 reiserfs_warning(inode->i_sb,
1469 "vs-13075: reiserfs_read_locked_inode: "
1470 "dead inode read from disk %K. "
1471 "This is likely to be race with knfsd. Ignore",
1472 &key);
1473 reiserfs_make_bad_inode(inode);
1474 }
1475
1476 reiserfs_check_path(&path_to_sd); /* init inode should be relsing */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
1478}
1479
1480/**
1481 * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().
1482 *
1483 * @inode: inode from hash table to check
1484 * @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.
1485 *
1486 * This function is called by iget5_locked() to distinguish reiserfs inodes
1487 * having the same inode numbers. Such inodes can only exist due to some
1488 * error condition. One of them should be bad. Inodes with identical
1489 * inode numbers (objectids) are distinguished by parent directory ids.
1490 *
1491 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001492int reiserfs_find_actor(struct inode *inode, void *opaque)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001494 struct reiserfs_iget_args *args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001496 args = opaque;
1497 /* args is already in CPU order */
1498 return (inode->i_ino == args->objectid) &&
1499 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500}
1501
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001502struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001504 struct inode *inode;
1505 struct reiserfs_iget_args args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001507 args.objectid = key->on_disk_key.k_objectid;
1508 args.dirid = key->on_disk_key.k_dir_id;
1509 inode = iget5_locked(s, key->on_disk_key.k_objectid,
1510 reiserfs_find_actor, reiserfs_init_locked_inode,
1511 (void *)(&args));
1512 if (!inode)
1513 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001515 if (inode->i_state & I_NEW) {
1516 reiserfs_read_locked_inode(inode, &args);
1517 unlock_new_inode(inode);
1518 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001520 if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1521 /* either due to i/o error or a stale NFS handle */
1522 iput(inode);
1523 inode = NULL;
1524 }
1525 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526}
1527
1528struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)
1529{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001530 __u32 *data = vobjp;
1531 struct cpu_key key;
1532 struct dentry *result;
1533 struct inode *inode;
1534
1535 key.on_disk_key.k_objectid = data[0];
1536 key.on_disk_key.k_dir_id = data[1];
1537 reiserfs_write_lock(sb);
1538 inode = reiserfs_iget(sb, &key);
1539 if (inode && !IS_ERR(inode) && data[2] != 0 &&
1540 data[2] != inode->i_generation) {
1541 iput(inode);
1542 inode = NULL;
1543 }
1544 reiserfs_write_unlock(sb);
1545 if (!inode)
1546 inode = ERR_PTR(-ESTALE);
1547 if (IS_ERR(inode))
1548 return ERR_PTR(PTR_ERR(inode));
1549 result = d_alloc_anon(inode);
1550 if (!result) {
1551 iput(inode);
1552 return ERR_PTR(-ENOMEM);
1553 }
1554 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555}
1556
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001557struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,
1558 int len, int fhtype,
1559 int (*acceptable) (void *contect,
1560 struct dentry * de),
1561 void *context)
1562{
1563 __u32 obj[3], parent[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001565 /* fhtype happens to reflect the number of u32s encoded.
1566 * due to a bug in earlier code, fhtype might indicate there
1567 * are more u32s then actually fitted.
1568 * so if fhtype seems to be more than len, reduce fhtype.
1569 * Valid types are:
1570 * 2 - objectid + dir_id - legacy support
1571 * 3 - objectid + dir_id + generation
1572 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1573 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1574 * 6 - as above plus generation of directory
1575 * 6 does not fit in NFSv2 handles
1576 */
1577 if (fhtype > len) {
1578 if (fhtype != 6 || len != 5)
1579 reiserfs_warning(sb,
1580 "nfsd/reiserfs, fhtype=%d, len=%d - odd",
1581 fhtype, len);
1582 fhtype = 5;
1583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001585 obj[0] = data[0];
1586 obj[1] = data[1];
1587 if (fhtype == 3 || fhtype >= 5)
1588 obj[2] = data[2];
1589 else
1590 obj[2] = 0; /* generation number */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001592 if (fhtype >= 4) {
1593 parent[0] = data[fhtype >= 5 ? 3 : 2];
1594 parent[1] = data[fhtype >= 5 ? 4 : 3];
1595 if (fhtype == 6)
1596 parent[2] = data[5];
1597 else
1598 parent[2] = 0;
1599 }
1600 return sb->s_export_op->find_exported_dentry(sb, obj,
1601 fhtype < 4 ? NULL : parent,
1602 acceptable, context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603}
1604
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001605int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
1606 int need_parent)
1607{
1608 struct inode *inode = dentry->d_inode;
1609 int maxlen = *lenp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001611 if (maxlen < 3)
1612 return 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001614 data[0] = inode->i_ino;
1615 data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1616 data[2] = inode->i_generation;
1617 *lenp = 3;
1618 /* no room for directory info? return what we've stored so far */
1619 if (maxlen < 5 || !need_parent)
1620 return 3;
1621
1622 spin_lock(&dentry->d_lock);
1623 inode = dentry->d_parent->d_inode;
1624 data[3] = inode->i_ino;
1625 data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1626 *lenp = 5;
1627 if (maxlen >= 6) {
1628 data[5] = inode->i_generation;
1629 *lenp = 6;
1630 }
1631 spin_unlock(&dentry->d_lock);
1632 return *lenp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633}
1634
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635/* looks for stat data, then copies fields to it, marks the buffer
1636 containing stat data as dirty */
1637/* reiserfs inodes are never really dirty, since the dirty inode call
1638** always logs them. This call allows the VFS inode marking routines
1639** to properly mark inodes for datasync and such, but only actually
1640** does something when called for a synchronous update.
1641*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001642int reiserfs_write_inode(struct inode *inode, int do_sync)
1643{
1644 struct reiserfs_transaction_handle th;
1645 int jbegin_count = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001647 if (inode->i_sb->s_flags & MS_RDONLY)
1648 return -EROFS;
1649 /* memory pressure can sometimes initiate write_inode calls with sync == 1,
1650 ** these cases are just when the system needs ram, not when the
1651 ** inode needs to reach disk for safety, and they can safely be
1652 ** ignored because the altered inode has already been logged.
1653 */
1654 if (do_sync && !(current->flags & PF_MEMALLOC)) {
1655 reiserfs_write_lock(inode->i_sb);
1656 if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
1657 reiserfs_update_sd(&th, inode);
1658 journal_end_sync(&th, inode->i_sb, jbegin_count);
1659 }
1660 reiserfs_write_unlock(inode->i_sb);
1661 }
1662 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663}
1664
1665/* stat data of new object is inserted already, this inserts the item
1666 containing "." and ".." entries */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001667static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1668 struct inode *inode,
1669 struct item_head *ih, struct path *path,
1670 struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001672 struct super_block *sb = th->t_super;
1673 char empty_dir[EMPTY_DIR_SIZE];
1674 char *body = empty_dir;
1675 struct cpu_key key;
1676 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001678 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001680 _make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),
1681 le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,
1682 TYPE_DIRENTRY, 3 /*key length */ );
1683
1684 /* compose item head for new item. Directories consist of items of
1685 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1686 is done by reiserfs_new_inode */
1687 if (old_format_only(sb)) {
1688 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1689 TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);
1690
1691 make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,
1692 ih->ih_key.k_objectid,
1693 INODE_PKEY(dir)->k_dir_id,
1694 INODE_PKEY(dir)->k_objectid);
1695 } else {
1696 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1697 TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
1698
1699 make_empty_dir_item(body, ih->ih_key.k_dir_id,
1700 ih->ih_key.k_objectid,
1701 INODE_PKEY(dir)->k_dir_id,
1702 INODE_PKEY(dir)->k_objectid);
1703 }
1704
1705 /* look for place in the tree for new item */
1706 retval = search_item(sb, &key, path);
1707 if (retval == IO_ERROR) {
1708 reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "
1709 "i/o failure occurred creating new directory");
1710 return -EIO;
1711 }
1712 if (retval == ITEM_FOUND) {
1713 pathrelse(path);
1714 reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "
1715 "object with this key exists (%k)",
1716 &(ih->ih_key));
1717 return -EEXIST;
1718 }
1719
1720 /* insert item, that is empty directory item */
1721 return reiserfs_insert_item(th, path, &key, ih, inode, body);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722}
1723
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724/* stat data of object has been inserted, this inserts the item
1725 containing the body of symlink */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001726static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */
1727 struct item_head *ih,
1728 struct path *path, const char *symname,
1729 int item_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001731 struct super_block *sb = th->t_super;
1732 struct cpu_key key;
1733 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001735 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001737 _make_cpu_key(&key, KEY_FORMAT_3_5,
1738 le32_to_cpu(ih->ih_key.k_dir_id),
1739 le32_to_cpu(ih->ih_key.k_objectid),
1740 1, TYPE_DIRECT, 3 /*key length */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001742 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1743 0 /*free_space */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001745 /* look for place in the tree for new item */
1746 retval = search_item(sb, &key, path);
1747 if (retval == IO_ERROR) {
1748 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "
1749 "i/o failure occurred creating new symlink");
1750 return -EIO;
1751 }
1752 if (retval == ITEM_FOUND) {
1753 pathrelse(path);
1754 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "
1755 "object with this key exists (%k)",
1756 &(ih->ih_key));
1757 return -EEXIST;
1758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001760 /* insert item, that is body of symlink */
1761 return reiserfs_insert_item(th, path, &key, ih, inode, symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762}
1763
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764/* inserts the stat data into the tree, and then calls
1765 reiserfs_new_directory (to insert ".", ".." item if new object is
1766 directory) or reiserfs_new_symlink (to insert symlink body if new
1767 object is symlink) or nothing (if new object is regular file)
1768
1769 NOTE! uid and gid must already be set in the inode. If we return
1770 non-zero due to an error, we have to drop the quota previously allocated
1771 for the fresh inode. This can only be done outside a transaction, so
1772 if we return non-zero, we also end the transaction. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001773int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1774 struct inode *dir, int mode, const char *symname,
1775 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1776 strlen (symname) for symlinks) */
1777 loff_t i_size, struct dentry *dentry,
1778 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001780 struct super_block *sb;
1781 INITIALIZE_PATH(path_to_key);
1782 struct cpu_key key;
1783 struct item_head ih;
1784 struct stat_data sd;
1785 int retval;
1786 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001788 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001790 if (DQUOT_ALLOC_INODE(inode)) {
1791 err = -EDQUOT;
1792 goto out_end_trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001794 if (!dir || !dir->i_nlink) {
1795 err = -EPERM;
1796 goto out_bad_inode;
1797 }
1798
1799 sb = dir->i_sb;
1800
1801 /* item head of new item */
1802 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);
1803 ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));
1804 if (!ih.ih_key.k_objectid) {
1805 err = -ENOMEM;
1806 goto out_bad_inode;
1807 }
1808 if (old_format_only(sb))
1809 /* not a perfect generation count, as object ids can be reused, but
1810 ** this is as good as reiserfs can do right now.
1811 ** note that the private part of inode isn't filled in yet, we have
1812 ** to use the directory.
1813 */
1814 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1815 else
1816#if defined( USE_INODE_GENERATION_COUNTER )
1817 inode->i_generation =
1818 le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1819#else
1820 inode->i_generation = ++event;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001823 /* fill stat data */
1824 inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);
1825
1826 /* uid and gid must already be set by the caller for quota init */
1827
1828 /* symlink cannot be immutable or append only, right? */
1829 if (S_ISLNK(inode->i_mode))
1830 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1831
1832 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1833 inode->i_size = i_size;
1834 inode->i_blocks = 0;
1835 inode->i_bytes = 0;
1836 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1837 U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;
1838
1839 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1840 REISERFS_I(inode)->i_flags = 0;
1841 REISERFS_I(inode)->i_prealloc_block = 0;
1842 REISERFS_I(inode)->i_prealloc_count = 0;
1843 REISERFS_I(inode)->i_trans_id = 0;
1844 REISERFS_I(inode)->i_jl = NULL;
1845 REISERFS_I(inode)->i_attrs =
1846 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;
1847 sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);
1848 REISERFS_I(inode)->i_acl_access = NULL;
1849 REISERFS_I(inode)->i_acl_default = NULL;
1850 init_rwsem(&REISERFS_I(inode)->xattr_sem);
1851
1852 if (old_format_only(sb))
1853 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1854 TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1855 else
1856 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1857 TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1858
1859 /* key to search for correct place for new stat data */
1860 _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1861 le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1862 TYPE_STAT_DATA, 3 /*key length */ );
1863
1864 /* find proper place for inserting of stat data */
1865 retval = search_item(sb, &key, &path_to_key);
1866 if (retval == IO_ERROR) {
1867 err = -EIO;
1868 goto out_bad_inode;
1869 }
1870 if (retval == ITEM_FOUND) {
1871 pathrelse(&path_to_key);
1872 err = -EEXIST;
1873 goto out_bad_inode;
1874 }
1875 if (old_format_only(sb)) {
1876 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1877 pathrelse(&path_to_key);
1878 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1879 err = -EINVAL;
1880 goto out_bad_inode;
1881 }
1882 inode2sd_v1(&sd, inode, inode->i_size);
1883 } else {
1884 inode2sd(&sd, inode, inode->i_size);
1885 }
1886 // these do not go to on-disk stat data
1887 inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1888 inode->i_blksize = reiserfs_default_io_size;
1889
1890 // store in in-core inode the key of stat data and version all
1891 // object items will have (directory items will have old offset
1892 // format, other new objects will consist of new items)
1893 memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1894 if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1895 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1896 else
1897 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1898 if (old_format_only(sb))
1899 set_inode_sd_version(inode, STAT_DATA_V1);
1900 else
1901 set_inode_sd_version(inode, STAT_DATA_V2);
1902
1903 /* insert the stat data into the tree */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904#ifdef DISPLACE_NEW_PACKING_LOCALITIES
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001905 if (REISERFS_I(dir)->new_packing_locality)
1906 th->displace_new_blocks = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001908 retval =
1909 reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1910 (char *)(&sd));
1911 if (retval) {
1912 err = retval;
1913 reiserfs_check_path(&path_to_key);
1914 goto out_bad_inode;
1915 }
1916#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1917 if (!th->displace_new_blocks)
1918 REISERFS_I(dir)->new_packing_locality = 0;
1919#endif
1920 if (S_ISDIR(mode)) {
1921 /* insert item with "." and ".." */
1922 retval =
1923 reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1924 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001926 if (S_ISLNK(mode)) {
1927 /* insert body of symlink */
1928 if (!old_format_only(sb))
1929 i_size = ROUND_UP(i_size);
1930 retval =
1931 reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1932 i_size);
1933 }
1934 if (retval) {
1935 err = retval;
1936 reiserfs_check_path(&path_to_key);
1937 journal_end(th, th->t_super, th->t_blocks_allocated);
1938 goto out_inserted_sd;
1939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001941 /* XXX CHECK THIS */
1942 if (reiserfs_posixacl(inode->i_sb)) {
1943 retval = reiserfs_inherit_default_acl(dir, dentry, inode);
1944 if (retval) {
1945 err = retval;
1946 reiserfs_check_path(&path_to_key);
1947 journal_end(th, th->t_super, th->t_blocks_allocated);
1948 goto out_inserted_sd;
1949 }
1950 } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1951 reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
1952 "but vfs thinks they are!");
1953 } else if (is_reiserfs_priv_object(dir)) {
1954 reiserfs_mark_inode_private(inode);
1955 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001957 insert_inode_hash(inode);
1958 reiserfs_update_sd(th, inode);
1959 reiserfs_check_path(&path_to_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001961 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962
1963/* it looks like you can easily compress these two goto targets into
1964 * one. Keeping it like this doesn't actually hurt anything, and they
1965 * are place holders for what the quota code actually needs.
1966 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001967 out_bad_inode:
1968 /* Invalidate the object, nothing was inserted yet */
1969 INODE_PKEY(inode)->k_objectid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001971 /* Quota change must be inside a transaction for journaling */
1972 DQUOT_FREE_INODE(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001974 out_end_trans:
1975 journal_end(th, th->t_super, th->t_blocks_allocated);
1976 /* Drop can be outside and it needs more credits so it's better to have it outside */
1977 DQUOT_DROP(inode);
1978 inode->i_flags |= S_NOQUOTA;
1979 make_bad_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001981 out_inserted_sd:
1982 inode->i_nlink = 0;
1983 th->t_trans_id = 0; /* so the caller can't use this handle later */
Jeff Mahoneyb3bb8af2005-07-27 11:43:38 -07001984
1985 /* If we were inheriting an ACL, we need to release the lock so that
1986 * iput doesn't deadlock in reiserfs_delete_xattrs. The locking
1987 * code really needs to be reworked, but this will take care of it
1988 * for now. -jeffm */
Jan Karad86c3902005-08-18 11:24:17 -07001989 if (REISERFS_I(dir)->i_acl_default && !IS_ERR(REISERFS_I(dir)->i_acl_default)) {
Jeff Mahoneyb3bb8af2005-07-27 11:43:38 -07001990 reiserfs_write_unlock_xattrs(dir->i_sb);
1991 iput(inode);
1992 reiserfs_write_lock_xattrs(dir->i_sb);
1993 } else
1994 iput(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001995 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996}
1997
1998/*
1999** finds the tail page in the page cache,
2000** reads the last block in.
2001**
2002** On success, page_result is set to a locked, pinned page, and bh_result
2003** is set to an up to date buffer for the last block in the file. returns 0.
2004**
2005** tail conversion is not done, so bh_result might not be valid for writing
2006** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
2007** trying to write the block.
2008**
2009** on failure, nonzero is returned, page_result and bh_result are untouched.
2010*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002011static int grab_tail_page(struct inode *p_s_inode,
2012 struct page **page_result,
2013 struct buffer_head **bh_result)
2014{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002016 /* we want the page with the last byte in the file,
2017 ** not the page that will hold the next byte for appending
2018 */
2019 unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;
2020 unsigned long pos = 0;
2021 unsigned long start = 0;
2022 unsigned long blocksize = p_s_inode->i_sb->s_blocksize;
2023 unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);
2024 struct buffer_head *bh;
2025 struct buffer_head *head;
2026 struct page *page;
2027 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002029 /* we know that we are only called with inode->i_size > 0.
2030 ** we also know that a file tail can never be as big as a block
2031 ** If i_size % blocksize == 0, our file is currently block aligned
2032 ** and it won't need converting or zeroing after a truncate.
2033 */
2034 if ((offset & (blocksize - 1)) == 0) {
2035 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002037 page = grab_cache_page(p_s_inode->i_mapping, index);
2038 error = -ENOMEM;
2039 if (!page) {
2040 goto out;
2041 }
2042 /* start within the page of the last block in the file */
2043 start = (offset / blocksize) * blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002045 error = block_prepare_write(page, start, offset,
2046 reiserfs_get_block_create_0);
2047 if (error)
2048 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002050 head = page_buffers(page);
2051 bh = head;
2052 do {
2053 if (pos >= start) {
2054 break;
2055 }
2056 bh = bh->b_this_page;
2057 pos += blocksize;
2058 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002060 if (!buffer_uptodate(bh)) {
2061 /* note, this should never happen, prepare_write should
2062 ** be taking care of this for us. If the buffer isn't up to date,
2063 ** I've screwed up the code to find the buffer, or the code to
2064 ** call prepare_write
2065 */
2066 reiserfs_warning(p_s_inode->i_sb,
2067 "clm-6000: error reading block %lu on dev %s",
2068 bh->b_blocknr,
2069 reiserfs_bdevname(p_s_inode->i_sb));
2070 error = -EIO;
2071 goto unlock;
2072 }
2073 *bh_result = bh;
2074 *page_result = page;
2075
2076 out:
2077 return error;
2078
2079 unlock:
2080 unlock_page(page);
2081 page_cache_release(page);
2082 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083}
2084
2085/*
2086** vfs version of truncate file. Must NOT be called with
2087** a transaction already started.
2088**
2089** some code taken from block_truncate_page
2090*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002091int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
2092{
2093 struct reiserfs_transaction_handle th;
2094 /* we want the offset for the first byte after the end of the file */
2095 unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);
2096 unsigned blocksize = p_s_inode->i_sb->s_blocksize;
2097 unsigned length;
2098 struct page *page = NULL;
2099 int error;
2100 struct buffer_head *bh = NULL;
Jeff Mahoney24996042005-12-14 14:38:05 -05002101 int err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002103 reiserfs_write_lock(p_s_inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002105 if (p_s_inode->i_size > 0) {
2106 if ((error = grab_tail_page(p_s_inode, &page, &bh))) {
2107 // -ENOENT means we truncated past the end of the file,
2108 // and get_block_create_0 could not find a block to read in,
2109 // which is ok.
2110 if (error != -ENOENT)
2111 reiserfs_warning(p_s_inode->i_sb,
2112 "clm-6001: grab_tail_page failed %d",
2113 error);
2114 page = NULL;
2115 bh = NULL;
2116 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002119 /* so, if page != NULL, we have a buffer head for the offset at
2120 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2121 ** then we have an unformatted node. Otherwise, we have a direct item,
2122 ** and no zeroing is required on disk. We zero after the truncate,
2123 ** because the truncate might pack the item anyway
2124 ** (it will unmap bh if it packs).
2125 */
2126 /* it is enough to reserve space in transaction for 2 balancings:
2127 one for "save" link adding and another for the first
2128 cut_from_item. 1 is for update_sd */
2129 error = journal_begin(&th, p_s_inode->i_sb,
2130 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2131 if (error)
2132 goto out;
2133 reiserfs_update_inode_transaction(p_s_inode);
2134 if (update_timestamps)
2135 /* we are doing real truncate: if the system crashes before the last
2136 transaction of truncating gets committed - on reboot the file
2137 either appears truncated properly or not truncated at all */
2138 add_save_link(&th, p_s_inode, 1);
Jeff Mahoney24996042005-12-14 14:38:05 -05002139 err2 = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002140 error =
2141 journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2142 if (error)
2143 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Jeff Mahoney24996042005-12-14 14:38:05 -05002145 /* check reiserfs_do_truncate after ending the transaction */
2146 if (err2) {
2147 error = err2;
2148 goto out;
2149 }
2150
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002151 if (update_timestamps) {
2152 error = remove_save_link(p_s_inode, 1 /* truncate */ );
2153 if (error)
2154 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002157 if (page) {
2158 length = offset & (blocksize - 1);
2159 /* if we are not on a block boundary */
2160 if (length) {
2161 char *kaddr;
2162
2163 length = blocksize - length;
2164 kaddr = kmap_atomic(page, KM_USER0);
2165 memset(kaddr + offset, 0, length);
2166 flush_dcache_page(page);
2167 kunmap_atomic(kaddr, KM_USER0);
2168 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2169 mark_buffer_dirty(bh);
2170 }
2171 }
2172 unlock_page(page);
2173 page_cache_release(page);
2174 }
2175
2176 reiserfs_write_unlock(p_s_inode->i_sb);
2177 return 0;
2178 out:
2179 if (page) {
2180 unlock_page(page);
2181 page_cache_release(page);
2182 }
2183 reiserfs_write_unlock(p_s_inode->i_sb);
2184 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185}
2186
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002187static int map_block_for_writepage(struct inode *inode,
2188 struct buffer_head *bh_result,
2189 unsigned long block)
2190{
2191 struct reiserfs_transaction_handle th;
2192 int fs_gen;
2193 struct item_head tmp_ih;
2194 struct item_head *ih;
2195 struct buffer_head *bh;
2196 __le32 *item;
2197 struct cpu_key key;
2198 INITIALIZE_PATH(path);
2199 int pos_in_item;
2200 int jbegin_count = JOURNAL_PER_BALANCE_CNT;
Oleg Drokin7729ac52005-11-28 13:43:53 -08002201 loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002202 int retval;
2203 int use_get_block = 0;
2204 int bytes_copied = 0;
2205 int copy_size;
2206 int trans_running = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002208 /* catch places below that try to log something without starting a trans */
2209 th.t_trans_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002211 if (!buffer_uptodate(bh_result)) {
2212 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 }
2214
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002215 kmap(bh_result->b_page);
2216 start_over:
2217 reiserfs_write_lock(inode->i_sb);
2218 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002220 research:
2221 retval = search_for_position_by_key(inode->i_sb, &key, &path);
2222 if (retval != POSITION_FOUND) {
2223 use_get_block = 1;
2224 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 }
2226
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002227 bh = get_last_bh(&path);
2228 ih = get_ih(&path);
2229 item = get_item(&path);
2230 pos_in_item = path.pos_in_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002232 /* we've found an unformatted node */
2233 if (indirect_item_found(retval, ih)) {
2234 if (bytes_copied > 0) {
2235 reiserfs_warning(inode->i_sb,
2236 "clm-6002: bytes_copied %d",
2237 bytes_copied);
2238 }
2239 if (!get_block_num(item, pos_in_item)) {
2240 /* crap, we are writing to a hole */
2241 use_get_block = 1;
2242 goto out;
2243 }
2244 set_block_dev_mapped(bh_result,
2245 get_block_num(item, pos_in_item), inode);
2246 } else if (is_direct_le_ih(ih)) {
2247 char *p;
2248 p = page_address(bh_result->b_page);
2249 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2250 copy_size = ih_item_len(ih) - pos_in_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002252 fs_gen = get_generation(inode->i_sb);
2253 copy_item_head(&tmp_ih, ih);
2254
2255 if (!trans_running) {
2256 /* vs-3050 is gone, no need to drop the path */
2257 retval = journal_begin(&th, inode->i_sb, jbegin_count);
2258 if (retval)
2259 goto out;
2260 reiserfs_update_inode_transaction(inode);
2261 trans_running = 1;
2262 if (fs_changed(fs_gen, inode->i_sb)
2263 && item_moved(&tmp_ih, &path)) {
2264 reiserfs_restore_prepared_buffer(inode->i_sb,
2265 bh);
2266 goto research;
2267 }
2268 }
2269
2270 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2271
2272 if (fs_changed(fs_gen, inode->i_sb)
2273 && item_moved(&tmp_ih, &path)) {
2274 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2275 goto research;
2276 }
2277
2278 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2279 copy_size);
2280
2281 journal_mark_dirty(&th, inode->i_sb, bh);
2282 bytes_copied += copy_size;
2283 set_block_dev_mapped(bh_result, 0, inode);
2284
2285 /* are there still bytes left? */
2286 if (bytes_copied < bh_result->b_size &&
2287 (byte_offset + bytes_copied) < inode->i_size) {
2288 set_cpu_key_k_offset(&key,
2289 cpu_key_k_offset(&key) +
2290 copy_size);
2291 goto research;
2292 }
2293 } else {
2294 reiserfs_warning(inode->i_sb,
2295 "clm-6003: bad item inode %lu, device %s",
2296 inode->i_ino, reiserfs_bdevname(inode->i_sb));
2297 retval = -EIO;
2298 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002300 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002302 out:
2303 pathrelse(&path);
2304 if (trans_running) {
2305 int err = journal_end(&th, inode->i_sb, jbegin_count);
2306 if (err)
2307 retval = err;
2308 trans_running = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002310 reiserfs_write_unlock(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002312 /* this is where we fill in holes in the file. */
2313 if (use_get_block) {
2314 retval = reiserfs_get_block(inode, block, bh_result,
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002315 GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002316 | GET_BLOCK_NO_DANGLE);
2317 if (!retval) {
2318 if (!buffer_mapped(bh_result)
2319 || bh_result->b_blocknr == 0) {
2320 /* get_block failed to find a mapped unformatted node. */
2321 use_get_block = 0;
2322 goto start_over;
2323 }
2324 }
2325 }
2326 kunmap(bh_result->b_page);
2327
2328 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2329 /* we've copied data from the page into the direct item, so the
2330 * buffer in the page is now clean, mark it to reflect that.
2331 */
2332 lock_buffer(bh_result);
2333 clear_buffer_dirty(bh_result);
2334 unlock_buffer(bh_result);
2335 }
2336 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337}
2338
2339/*
2340 * mason@suse.com: updated in 2.5.54 to follow the same general io
2341 * start/recovery path as __block_write_full_page, along with special
2342 * code to handle reiserfs tails.
2343 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002344static int reiserfs_write_full_page(struct page *page,
2345 struct writeback_control *wbc)
2346{
2347 struct inode *inode = page->mapping->host;
2348 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2349 int error = 0;
2350 unsigned long block;
2351 struct buffer_head *head, *bh;
2352 int partial = 0;
2353 int nr = 0;
2354 int checked = PageChecked(page);
2355 struct reiserfs_transaction_handle th;
2356 struct super_block *s = inode->i_sb;
2357 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2358 th.t_trans_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
Chris Masone0e851c2006-02-01 03:06:49 -08002360 /* no logging allowed when nonblocking or from PF_MEMALLOC */
2361 if (checked && (current->flags & PF_MEMALLOC)) {
2362 redirty_page_for_writepage(wbc, page);
2363 unlock_page(page);
2364 return 0;
2365 }
2366
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002367 /* The page dirty bit is cleared before writepage is called, which
2368 * means we have to tell create_empty_buffers to make dirty buffers
2369 * The page really should be up to date at this point, so tossing
2370 * in the BH_Uptodate is just a sanity check.
2371 */
2372 if (!page_has_buffers(page)) {
2373 create_empty_buffers(page, s->s_blocksize,
2374 (1 << BH_Dirty) | (1 << BH_Uptodate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002376 head = page_buffers(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002378 /* last page in the file, zero out any contents past the
2379 ** last byte in the file
2380 */
2381 if (page->index >= end_index) {
2382 char *kaddr;
2383 unsigned last_offset;
2384
2385 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2386 /* no file contents in this page */
2387 if (page->index >= end_index + 1 || !last_offset) {
2388 unlock_page(page);
2389 return 0;
2390 }
2391 kaddr = kmap_atomic(page, KM_USER0);
2392 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);
2393 flush_dcache_page(page);
2394 kunmap_atomic(kaddr, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002396 bh = head;
2397 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2398 /* first map all the buffers, logging any direct items we find */
2399 do {
2400 if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
2401 (buffer_mapped(bh)
2402 && bh->b_blocknr ==
2403 0))) {
2404 /* not mapped yet, or it points to a direct item, search
2405 * the btree for the mapping info, and log any direct
2406 * items found
2407 */
2408 if ((error = map_block_for_writepage(inode, bh, block))) {
2409 goto fail;
2410 }
2411 }
2412 bh = bh->b_this_page;
2413 block++;
2414 } while (bh != head);
2415
2416 /*
2417 * we start the transaction after map_block_for_writepage,
2418 * because it can create holes in the file (an unbounded operation).
2419 * starting it here, we can make a reliable estimate for how many
2420 * blocks we're going to log
2421 */
2422 if (checked) {
2423 ClearPageChecked(page);
2424 reiserfs_write_lock(s);
2425 error = journal_begin(&th, s, bh_per_page + 1);
2426 if (error) {
2427 reiserfs_write_unlock(s);
2428 goto fail;
2429 }
2430 reiserfs_update_inode_transaction(inode);
2431 }
2432 /* now go through and lock any dirty buffers on the page */
2433 do {
2434 get_bh(bh);
2435 if (!buffer_mapped(bh))
2436 continue;
2437 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2438 continue;
2439
2440 if (checked) {
2441 reiserfs_prepare_for_journal(s, bh, 1);
2442 journal_mark_dirty(&th, s, bh);
2443 continue;
2444 }
2445 /* from this point on, we know the buffer is mapped to a
2446 * real block and not a direct item
2447 */
2448 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
2449 lock_buffer(bh);
2450 } else {
2451 if (test_set_buffer_locked(bh)) {
2452 redirty_page_for_writepage(wbc, page);
2453 continue;
2454 }
2455 }
2456 if (test_clear_buffer_dirty(bh)) {
2457 mark_buffer_async_write(bh);
2458 } else {
2459 unlock_buffer(bh);
2460 }
2461 } while ((bh = bh->b_this_page) != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462
2463 if (checked) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002464 error = journal_end(&th, s, bh_per_page + 1);
2465 reiserfs_write_unlock(s);
2466 if (error)
2467 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002469 BUG_ON(PageWriteback(page));
2470 set_page_writeback(page);
2471 unlock_page(page);
2472
2473 /*
2474 * since any buffer might be the only dirty buffer on the page,
2475 * the first submit_bh can bring the page out of writeback.
2476 * be careful with the buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 do {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002479 struct buffer_head *next = bh->b_this_page;
2480 if (buffer_async_write(bh)) {
2481 submit_bh(WRITE, bh);
2482 nr++;
2483 }
2484 put_bh(bh);
2485 bh = next;
2486 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002488 error = 0;
2489 done:
2490 if (nr == 0) {
2491 /*
2492 * if this page only had a direct item, it is very possible for
2493 * no io to be required without there being an error. Or,
2494 * someone else could have locked them and sent them down the
2495 * pipe without locking the page
2496 */
2497 bh = head;
2498 do {
2499 if (!buffer_uptodate(bh)) {
2500 partial = 1;
2501 break;
2502 }
2503 bh = bh->b_this_page;
2504 } while (bh != head);
2505 if (!partial)
2506 SetPageUptodate(page);
2507 end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002509 return error;
2510
2511 fail:
2512 /* catches various errors, we need to make sure any valid dirty blocks
2513 * get to the media. The page is currently locked and not marked for
2514 * writeback
2515 */
2516 ClearPageUptodate(page);
2517 bh = head;
2518 do {
2519 get_bh(bh);
2520 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2521 lock_buffer(bh);
2522 mark_buffer_async_write(bh);
2523 } else {
2524 /*
2525 * clear any dirty bits that might have come from getting
2526 * attached to a dirty page
2527 */
2528 clear_buffer_dirty(bh);
2529 }
2530 bh = bh->b_this_page;
2531 } while (bh != head);
2532 SetPageError(page);
2533 BUG_ON(PageWriteback(page));
2534 set_page_writeback(page);
2535 unlock_page(page);
2536 do {
2537 struct buffer_head *next = bh->b_this_page;
2538 if (buffer_async_write(bh)) {
2539 clear_buffer_dirty(bh);
2540 submit_bh(WRITE, bh);
2541 nr++;
2542 }
2543 put_bh(bh);
2544 bh = next;
2545 } while (bh != head);
2546 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547}
2548
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002549static int reiserfs_readpage(struct file *f, struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002551 return block_read_full_page(page, reiserfs_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552}
2553
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002554static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002556 struct inode *inode = page->mapping->host;
2557 reiserfs_wait_on_write_block(inode->i_sb);
2558 return reiserfs_write_full_page(page, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559}
2560
2561static int reiserfs_prepare_write(struct file *f, struct page *page,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002562 unsigned from, unsigned to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002564 struct inode *inode = page->mapping->host;
2565 int ret;
2566 int old_ref = 0;
2567
2568 reiserfs_wait_on_write_block(inode->i_sb);
2569 fix_tail_page_for_writing(page);
2570 if (reiserfs_transaction_running(inode->i_sb)) {
2571 struct reiserfs_transaction_handle *th;
2572 th = (struct reiserfs_transaction_handle *)current->
2573 journal_info;
2574 BUG_ON(!th->t_refcount);
2575 BUG_ON(!th->t_trans_id);
2576 old_ref = th->t_refcount;
2577 th->t_refcount++;
2578 }
2579
2580 ret = block_prepare_write(page, from, to, reiserfs_get_block);
2581 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2582 struct reiserfs_transaction_handle *th = current->journal_info;
2583 /* this gets a little ugly. If reiserfs_get_block returned an
2584 * error and left a transacstion running, we've got to close it,
2585 * and we've got to free handle if it was a persistent transaction.
2586 *
2587 * But, if we had nested into an existing transaction, we need
2588 * to just drop the ref count on the handle.
2589 *
2590 * If old_ref == 0, the transaction is from reiserfs_get_block,
2591 * and it was a persistent trans. Otherwise, it was nested above.
2592 */
2593 if (th->t_refcount > old_ref) {
2594 if (old_ref)
2595 th->t_refcount--;
2596 else {
2597 int err;
2598 reiserfs_write_lock(inode->i_sb);
2599 err = reiserfs_end_persistent_transaction(th);
2600 reiserfs_write_unlock(inode->i_sb);
2601 if (err)
2602 ret = err;
2603 }
2604 }
2605 }
2606 return ret;
2607
2608}
2609
2610static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2611{
2612 return generic_block_bmap(as, block, reiserfs_bmap);
2613}
2614
2615static int reiserfs_commit_write(struct file *f, struct page *page,
2616 unsigned from, unsigned to)
2617{
2618 struct inode *inode = page->mapping->host;
2619 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2620 int ret = 0;
2621 int update_sd = 0;
2622 struct reiserfs_transaction_handle *th = NULL;
2623
2624 reiserfs_wait_on_write_block(inode->i_sb);
2625 if (reiserfs_transaction_running(inode->i_sb)) {
2626 th = current->journal_info;
2627 }
2628 reiserfs_commit_page(inode, page, from, to);
2629
2630 /* generic_commit_write does this for us, but does not update the
2631 ** transaction tracking stuff when the size changes. So, we have
2632 ** to do the i_size updates here.
2633 */
2634 if (pos > inode->i_size) {
2635 struct reiserfs_transaction_handle myth;
2636 reiserfs_write_lock(inode->i_sb);
2637 /* If the file have grown beyond the border where it
2638 can have a tail, unmark it as needing a tail
2639 packing */
2640 if ((have_large_tails(inode->i_sb)
2641 && inode->i_size > i_block_size(inode) * 4)
2642 || (have_small_tails(inode->i_sb)
2643 && inode->i_size > i_block_size(inode)))
2644 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2645
2646 ret = journal_begin(&myth, inode->i_sb, 1);
2647 if (ret) {
2648 reiserfs_write_unlock(inode->i_sb);
2649 goto journal_error;
2650 }
2651 reiserfs_update_inode_transaction(inode);
2652 inode->i_size = pos;
Chris Mason9f037832005-09-13 01:25:17 -07002653 /*
2654 * this will just nest into our transaction. It's important
2655 * to use mark_inode_dirty so the inode gets pushed around on the
2656 * dirty lists, and so that O_SYNC works as expected
2657 */
2658 mark_inode_dirty(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002659 reiserfs_update_sd(&myth, inode);
2660 update_sd = 1;
2661 ret = journal_end(&myth, inode->i_sb, 1);
2662 reiserfs_write_unlock(inode->i_sb);
2663 if (ret)
2664 goto journal_error;
2665 }
2666 if (th) {
2667 reiserfs_write_lock(inode->i_sb);
2668 if (!update_sd)
Chris Mason9f037832005-09-13 01:25:17 -07002669 mark_inode_dirty(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002670 ret = reiserfs_end_persistent_transaction(th);
2671 reiserfs_write_unlock(inode->i_sb);
2672 if (ret)
2673 goto out;
2674 }
2675
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002676 out:
2677 return ret;
2678
2679 journal_error:
2680 if (th) {
2681 reiserfs_write_lock(inode->i_sb);
2682 if (!update_sd)
2683 reiserfs_update_sd(th, inode);
2684 ret = reiserfs_end_persistent_transaction(th);
2685 reiserfs_write_unlock(inode->i_sb);
2686 }
2687
2688 return ret;
2689}
2690
2691void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2692{
2693 if (reiserfs_attrs(inode->i_sb)) {
2694 if (sd_attrs & REISERFS_SYNC_FL)
2695 inode->i_flags |= S_SYNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002697 inode->i_flags &= ~S_SYNC;
2698 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2699 inode->i_flags |= S_IMMUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002701 inode->i_flags &= ~S_IMMUTABLE;
2702 if (sd_attrs & REISERFS_APPEND_FL)
2703 inode->i_flags |= S_APPEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002705 inode->i_flags &= ~S_APPEND;
2706 if (sd_attrs & REISERFS_NOATIME_FL)
2707 inode->i_flags |= S_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002709 inode->i_flags &= ~S_NOATIME;
2710 if (sd_attrs & REISERFS_NOTAIL_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 REISERFS_I(inode)->i_flags |= i_nopack_mask;
2712 else
2713 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2714 }
2715}
2716
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002717void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002719 if (reiserfs_attrs(inode->i_sb)) {
2720 if (inode->i_flags & S_IMMUTABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 *sd_attrs |= REISERFS_IMMUTABLE_FL;
2722 else
2723 *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002724 if (inode->i_flags & S_SYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 *sd_attrs |= REISERFS_SYNC_FL;
2726 else
2727 *sd_attrs &= ~REISERFS_SYNC_FL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002728 if (inode->i_flags & S_NOATIME)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 *sd_attrs |= REISERFS_NOATIME_FL;
2730 else
2731 *sd_attrs &= ~REISERFS_NOATIME_FL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002732 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 *sd_attrs |= REISERFS_NOTAIL_FL;
2734 else
2735 *sd_attrs &= ~REISERFS_NOTAIL_FL;
2736 }
2737}
2738
2739/* decide if this buffer needs to stay around for data logging or ordered
2740** write purposes
2741*/
2742static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2743{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002744 int ret = 1;
2745 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746
Chris Masond62b1b82006-02-01 03:06:47 -08002747 lock_buffer(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002748 spin_lock(&j->j_dirty_buffers_lock);
2749 if (!buffer_mapped(bh)) {
2750 goto free_jh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002751 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002752 /* the page is locked, and the only places that log a data buffer
2753 * also lock the page.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002755 if (reiserfs_file_data_log(inode)) {
2756 /*
2757 * very conservative, leave the buffer pinned if
2758 * anyone might need it.
2759 */
2760 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2761 ret = 0;
2762 }
Chris Masond62b1b82006-02-01 03:06:47 -08002763 } else if (buffer_dirty(bh)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002764 struct reiserfs_journal_list *jl;
2765 struct reiserfs_jh *jh = bh->b_private;
2766
2767 /* why is this safe?
2768 * reiserfs_setattr updates i_size in the on disk
2769 * stat data before allowing vmtruncate to be called.
2770 *
2771 * If buffer was put onto the ordered list for this
2772 * transaction, we know for sure either this transaction
2773 * or an older one already has updated i_size on disk,
2774 * and this ordered data won't be referenced in the file
2775 * if we crash.
2776 *
2777 * if the buffer was put onto the ordered list for an older
2778 * transaction, we need to leave it around
2779 */
2780 if (jh && (jl = jh->jl)
2781 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2782 ret = 0;
2783 }
2784 free_jh:
2785 if (ret && bh->b_private) {
2786 reiserfs_free_jh(bh);
2787 }
2788 spin_unlock(&j->j_dirty_buffers_lock);
Chris Masond62b1b82006-02-01 03:06:47 -08002789 unlock_buffer(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002790 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791}
2792
2793/* clm -- taken from fs/buffer.c:block_invalidate_page */
NeilBrown2ff28e22006-03-26 01:37:18 -08002794static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002796 struct buffer_head *head, *bh, *next;
2797 struct inode *inode = page->mapping->host;
2798 unsigned int curr_off = 0;
2799 int ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002801 BUG_ON(!PageLocked(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002803 if (offset == 0)
2804 ClearPageChecked(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002806 if (!page_has_buffers(page))
2807 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002809 head = page_buffers(page);
2810 bh = head;
2811 do {
2812 unsigned int next_off = curr_off + bh->b_size;
2813 next = bh->b_this_page;
2814
2815 /*
2816 * is this block fully invalidated?
2817 */
2818 if (offset <= curr_off) {
2819 if (invalidatepage_can_drop(inode, bh))
2820 reiserfs_unmap_buffer(bh);
2821 else
2822 ret = 0;
2823 }
2824 curr_off = next_off;
2825 bh = next;
2826 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827
2828 /*
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002829 * We release buffers only if the entire page is being invalidated.
2830 * The get_block cached value has been unconditionally invalidated,
2831 * so real IO is not possible anymore.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 */
NeilBrown2ff28e22006-03-26 01:37:18 -08002833 if (!offset && ret) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002834 ret = try_to_release_page(page, 0);
NeilBrown2ff28e22006-03-26 01:37:18 -08002835 /* maybe should BUG_ON(!ret); - neilb */
2836 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002837 out:
NeilBrown2ff28e22006-03-26 01:37:18 -08002838 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839}
2840
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002841static int reiserfs_set_page_dirty(struct page *page)
2842{
2843 struct inode *inode = page->mapping->host;
2844 if (reiserfs_file_data_log(inode)) {
2845 SetPageChecked(page);
2846 return __set_page_dirty_nobuffers(page);
2847 }
2848 return __set_page_dirty_buffers(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849}
2850
2851/*
2852 * Returns 1 if the page's buffers were dropped. The page is locked.
2853 *
2854 * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads
2855 * in the buffers at page_buffers(page).
2856 *
2857 * even in -o notail mode, we can't be sure an old mount without -o notail
2858 * didn't create files with tails.
2859 */
Al Viro27496a82005-10-21 03:20:48 -04002860static int reiserfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002862 struct inode *inode = page->mapping->host;
2863 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2864 struct buffer_head *head;
2865 struct buffer_head *bh;
2866 int ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002868 WARN_ON(PageChecked(page));
2869 spin_lock(&j->j_dirty_buffers_lock);
2870 head = page_buffers(page);
2871 bh = head;
2872 do {
2873 if (bh->b_private) {
2874 if (!buffer_dirty(bh) && !buffer_locked(bh)) {
2875 reiserfs_free_jh(bh);
2876 } else {
2877 ret = 0;
2878 break;
2879 }
2880 }
2881 bh = bh->b_this_page;
2882 } while (bh != head);
2883 if (ret)
2884 ret = try_to_free_buffers(page);
2885 spin_unlock(&j->j_dirty_buffers_lock);
2886 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887}
2888
2889/* We thank Mingming Cao for helping us understand in great detail what
2890 to do in this section of the code. */
2891static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002892 const struct iovec *iov, loff_t offset,
2893 unsigned long nr_segs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002895 struct file *file = iocb->ki_filp;
2896 struct inode *inode = file->f_mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002898 return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2899 offset, nr_segs,
2900 reiserfs_get_blocks_direct_io, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901}
2902
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002903int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
2904{
2905 struct inode *inode = dentry->d_inode;
2906 int error;
2907 unsigned int ia_valid = attr->ia_valid;
2908 reiserfs_write_lock(inode->i_sb);
2909 if (attr->ia_valid & ATTR_SIZE) {
2910 /* version 2 items will be caught by the s_maxbytes check
2911 ** done for us in vmtruncate
2912 */
2913 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
2914 attr->ia_size > MAX_NON_LFS) {
2915 error = -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002918 /* fill in hole pointers in the expanding truncate case. */
2919 if (attr->ia_size > inode->i_size) {
2920 error = generic_cont_expand(inode, attr->ia_size);
2921 if (REISERFS_I(inode)->i_prealloc_count > 0) {
2922 int err;
2923 struct reiserfs_transaction_handle th;
2924 /* we're changing at most 2 bitmaps, inode + super */
2925 err = journal_begin(&th, inode->i_sb, 4);
2926 if (!err) {
2927 reiserfs_discard_prealloc(&th, inode);
2928 err = journal_end(&th, inode->i_sb, 4);
2929 }
2930 if (err)
2931 error = err;
2932 }
2933 if (error)
2934 goto out;
2935 }
2936 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002938 if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||
2939 ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&
2940 (get_inode_sd_version(inode) == STAT_DATA_V1)) {
2941 /* stat data of format v3.5 has 16 bit uid and gid */
2942 error = -EINVAL;
2943 goto out;
2944 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002946 error = inode_change_ok(inode, attr);
2947 if (!error) {
2948 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2949 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2950 error = reiserfs_chown_xattrs(inode, attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002952 if (!error) {
2953 struct reiserfs_transaction_handle th;
2954 int jbegin_count =
2955 2 *
2956 (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
2957 REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
2958 2;
2959
2960 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2961 error =
2962 journal_begin(&th, inode->i_sb,
2963 jbegin_count);
2964 if (error)
2965 goto out;
2966 error =
2967 DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2968 if (error) {
2969 journal_end(&th, inode->i_sb,
2970 jbegin_count);
2971 goto out;
2972 }
2973 /* Update corresponding info in inode so that everything is in
2974 * one transaction */
2975 if (attr->ia_valid & ATTR_UID)
2976 inode->i_uid = attr->ia_uid;
2977 if (attr->ia_valid & ATTR_GID)
2978 inode->i_gid = attr->ia_gid;
2979 mark_inode_dirty(inode);
2980 error =
2981 journal_end(&th, inode->i_sb, jbegin_count);
2982 }
2983 }
2984 if (!error)
2985 error = inode_setattr(inode, attr);
2986 }
2987
2988 if (!error && reiserfs_posixacl(inode->i_sb)) {
2989 if (attr->ia_valid & ATTR_MODE)
2990 error = reiserfs_acl_chmod(inode);
2991 }
2992
2993 out:
2994 reiserfs_write_unlock(inode->i_sb);
2995 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996}
2997
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002998const struct address_space_operations reiserfs_address_space_operations = {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002999 .writepage = reiserfs_writepage,
3000 .readpage = reiserfs_readpage,
3001 .readpages = reiserfs_readpages,
3002 .releasepage = reiserfs_releasepage,
3003 .invalidatepage = reiserfs_invalidatepage,
3004 .sync_page = block_sync_page,
3005 .prepare_write = reiserfs_prepare_write,
3006 .commit_write = reiserfs_commit_write,
3007 .bmap = reiserfs_aop_bmap,
3008 .direct_IO = reiserfs_direct_IO,
3009 .set_page_dirty = reiserfs_set_page_dirty,
3010};