blob: d60f6238c66a48184fa7c35ec749ba8e6f110456 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
5#include <linux/config.h>
6#include <linux/time.h>
7#include <linux/fs.h>
8#include <linux/reiserfs_fs.h>
9#include <linux/reiserfs_acl.h>
10#include <linux/reiserfs_xattr.h>
11#include <linux/smp_lock.h>
12#include <linux/pagemap.h>
13#include <linux/highmem.h>
14#include <asm/uaccess.h>
15#include <asm/unaligned.h>
16#include <linux/buffer_head.h>
17#include <linux/mpage.h>
18#include <linux/writeback.h>
19#include <linux/quotaops.h>
20
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070021extern int reiserfs_default_io_size; /* default io size devuned in super.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
23static int reiserfs_commit_write(struct file *f, struct page *page,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070024 unsigned from, unsigned to);
Linus Torvalds1da177e2005-04-16 15:20:36 -070025static int reiserfs_prepare_write(struct file *f, struct page *page,
26 unsigned from, unsigned to);
27
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070028void reiserfs_delete_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070029{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070030 /* We need blocks for transaction + (user+group) quota update (possibly delete) */
31 int jbegin_count =
32 JOURNAL_PER_BALANCE_CNT * 2 +
33 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
34 struct reiserfs_transaction_handle th;
Jeff Mahoney24996042005-12-14 14:38:05 -050035 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Mark Fashehfef26652005-09-09 13:01:31 -070037 truncate_inode_pages(&inode->i_data, 0);
38
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070039 reiserfs_write_lock(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070041 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
42 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080043 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070045 reiserfs_delete_xattrs(inode);
46
47 if (journal_begin(&th, inode->i_sb, jbegin_count)) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080048 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070049 goto out;
50 }
51 reiserfs_update_inode_transaction(inode);
52
Jeff Mahoney24996042005-12-14 14:38:05 -050053 err = reiserfs_delete_object(&th, inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070054
55 /* Do quota update inside a transaction for journaled quotas. We must do that
56 * after delete_object so that quota updates go into the same transaction as
57 * stat data deletion */
Jeff Mahoney24996042005-12-14 14:38:05 -050058 if (!err)
59 DQUOT_FREE_INODE(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070060
61 if (journal_end(&th, inode->i_sb, jbegin_count)) {
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080062 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070063 goto out;
64 }
65
Jes Sorensen1b1dcc12006-01-09 15:59:24 -080066 mutex_unlock(&inode->i_mutex);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070067
Jeff Mahoney24996042005-12-14 14:38:05 -050068 /* check return value from reiserfs_delete_object after
69 * ending the transaction
70 */
71 if (err)
72 goto out;
73
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070074 /* all items of file are deleted, so we can remove "save" link */
75 remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything
76 * about an error here */
77 } else {
78 /* no object items are in the tree */
79 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070081 out:
82 clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */
83 inode->i_blocks = 0;
84 reiserfs_write_unlock(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085}
86
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070087static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
88 __u32 objectid, loff_t offset, int type, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070090 key->version = version;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Linus Torvaldsbd4c6252005-07-12 20:21:28 -070092 key->on_disk_key.k_dir_id = dirid;
93 key->on_disk_key.k_objectid = objectid;
94 set_cpu_key_k_offset(key, offset);
95 set_cpu_key_k_type(key, type);
96 key->key_length = length;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set
100 offset and type of key */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700101void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
102 int type, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700104 _make_cpu_key(key, get_inode_item_key_version(inode),
105 le32_to_cpu(INODE_PKEY(inode)->k_dir_id),
106 le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,
107 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110//
111// when key is 0, do not set version and short key
112//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700113inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
114 int version,
115 loff_t offset, int type, int length,
116 int entry_count /*or ih_free_space */ )
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700118 if (key) {
119 ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);
120 ih->ih_key.k_objectid =
121 cpu_to_le32(key->on_disk_key.k_objectid);
122 }
123 put_ih_version(ih, version);
124 set_le_ih_k_offset(ih, offset);
125 set_le_ih_k_type(ih, type);
126 put_ih_item_len(ih, length);
127 /* set_ih_free_space (ih, 0); */
128 // for directory items it is entry count, for directs and stat
129 // datas - 0xffff, for indirects - 0
130 put_ih_entry_count(ih, entry_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
133//
134// FIXME: we might cache recently accessed indirect item
135
136// Ugh. Not too eager for that....
137// I cut the code until such time as I see a convincing argument (benchmark).
138// I don't want a bloated inode struct..., and I don't like code complexity....
139
140/* cutting the code is fine, since it really isn't in use yet and is easy
141** to add back in. But, Vladimir has a really good idea here. Think
142** about what happens for reading a file. For each page,
143** The VFS layer calls reiserfs_readpage, who searches the tree to find
144** an indirect item. This indirect item has X number of pointers, where
145** X is a big number if we've done the block allocation right. But,
146** we only use one or two of these pointers during each call to readpage,
147** needlessly researching again later on.
148**
149** The size of the cache could be dynamic based on the size of the file.
150**
151** I'd also like to see us cache the location the stat data item, since
152** we are needlessly researching for that frequently.
153**
154** --chris
155*/
156
157/* If this page has a file tail in it, and
158** it was read in by get_block_create_0, the page data is valid,
159** but tail is still sitting in a direct item, and we can't write to
160** it. So, look through this page, and check all the mapped buffers
161** to make sure they have valid block numbers. Any that don't need
162** to be unmapped, so that block_prepare_write will correctly call
163** reiserfs_get_block to convert the tail into an unformatted node
164*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700165static inline void fix_tail_page_for_writing(struct page *page)
166{
167 struct buffer_head *head, *next, *bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700169 if (page && page_has_buffers(page)) {
170 head = page_buffers(page);
171 bh = head;
172 do {
173 next = bh->b_this_page;
174 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
175 reiserfs_unmap_buffer(bh);
176 }
177 bh = next;
178 } while (bh != head);
179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180}
181
182/* reiserfs_get_block does not need to allocate a block only if it has been
183 done already or non-hole position has been found in the indirect item */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700184static inline int allocation_needed(int retval, b_blocknr_t allocated,
185 struct item_head *ih,
186 __le32 * item, int pos_in_item)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700188 if (allocated)
189 return 0;
190 if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
191 get_block_num(item, pos_in_item))
192 return 0;
193 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194}
195
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700196static inline int indirect_item_found(int retval, struct item_head *ih)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700198 return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199}
200
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700201static inline void set_block_dev_mapped(struct buffer_head *bh,
202 b_blocknr_t block, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
204 map_bh(bh, inode->i_sb, block);
205}
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207//
208// files which were created in the earlier version can not be longer,
209// than 2 gb
210//
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700211static int file_capable(struct inode *inode, long block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700213 if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.
214 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb
215 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700217 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
220/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700221 struct inode *inode, struct path *path)
222{
223 struct super_block *s = th->t_super;
224 int len = th->t_blocks_allocated;
225 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700227 BUG_ON(!th->t_trans_id);
228 BUG_ON(!th->t_refcount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700230 /* we cannot restart while nested */
231 if (th->t_refcount > 1) {
232 return 0;
233 }
234 pathrelse(path);
235 reiserfs_update_sd(th, inode);
236 err = journal_end(th, s, len);
237 if (!err) {
238 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
239 if (!err)
240 reiserfs_update_inode_transaction(inode);
241 }
242 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243}
244
245// it is called by get_block when create == 0. Returns block number
246// for 'block'-th logical block of file. When it hits direct item it
247// returns 0 (being called from bmap) or read direct item into piece
248// of page (bh_result)
249
250// Please improve the english/clarity in the comment above, as it is
251// hard to understand.
252
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700253static int _get_block_create_0(struct inode *inode, long block,
254 struct buffer_head *bh_result, int args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700256 INITIALIZE_PATH(path);
257 struct cpu_key key;
258 struct buffer_head *bh;
259 struct item_head *ih, tmp_ih;
260 int fs_gen;
261 int blocknr;
262 char *p = NULL;
263 int chars;
264 int ret;
265 int result;
266 int done = 0;
267 unsigned long offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700269 // prepare the key to look for the 'block'-th block of file
270 make_cpu_key(&key, inode,
271 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
272 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700274 research:
275 result = search_for_position_by_key(inode->i_sb, &key, &path);
276 if (result != POSITION_FOUND) {
277 pathrelse(&path);
278 if (p)
279 kunmap(bh_result->b_page);
280 if (result == IO_ERROR)
281 return -EIO;
282 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
283 // That there is some MMAPED data associated with it that is yet to be written to disk.
284 if ((args & GET_BLOCK_NO_HOLE)
285 && !PageUptodate(bh_result->b_page)) {
286 return -ENOENT;
287 }
288 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700290 //
291 bh = get_last_bh(&path);
292 ih = get_ih(&path);
293 if (is_indirect_le_ih(ih)) {
294 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700296 /* FIXME: here we could cache indirect item or part of it in
297 the inode to avoid search_by_key in case of subsequent
298 access to file */
299 blocknr = get_block_num(ind_item, path.pos_in_item);
300 ret = 0;
301 if (blocknr) {
302 map_bh(bh_result, inode->i_sb, blocknr);
303 if (path.pos_in_item ==
304 ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
305 set_buffer_boundary(bh_result);
306 }
307 } else
308 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
309 // That there is some MMAPED data associated with it that is yet to be written to disk.
310 if ((args & GET_BLOCK_NO_HOLE)
311 && !PageUptodate(bh_result->b_page)) {
312 ret = -ENOENT;
313 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700315 pathrelse(&path);
316 if (p)
317 kunmap(bh_result->b_page);
318 return ret;
319 }
320 // requested data are in direct item(s)
321 if (!(args & GET_BLOCK_READ_DIRECT)) {
322 // we are called by bmap. FIXME: we can not map block of file
323 // when it is stored in direct item(s)
324 pathrelse(&path);
325 if (p)
326 kunmap(bh_result->b_page);
327 return -ENOENT;
328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700330 /* if we've got a direct item, and the buffer or page was uptodate,
331 ** we don't want to pull data off disk again. skip to the
332 ** end, where we map the buffer and return
333 */
334 if (buffer_uptodate(bh_result)) {
335 goto finished;
336 } else
337 /*
338 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date
339 ** pages without any buffers. If the page is up to date, we don't want
340 ** read old data off disk. Set the up to date bit on the buffer instead
341 ** and jump to the end
342 */
343 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 set_buffer_uptodate(bh_result);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700345 goto finished;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700347 // read file tail into part of page
348 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
349 fs_gen = get_generation(inode->i_sb);
350 copy_item_head(&tmp_ih, ih);
351
352 /* we only want to kmap if we are reading the tail into the page.
353 ** this is not the common case, so we don't kmap until we are
354 ** sure we need to. But, this means the item might move if
355 ** kmap schedules
356 */
357 if (!p) {
358 p = (char *)kmap(bh_result->b_page);
359 if (fs_changed(fs_gen, inode->i_sb)
360 && item_moved(&tmp_ih, &path)) {
361 goto research;
362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700364 p += offset;
365 memset(p, 0, inode->i_sb->s_blocksize);
366 do {
367 if (!is_direct_le_ih(ih)) {
368 BUG();
369 }
370 /* make sure we don't read more bytes than actually exist in
371 ** the file. This can happen in odd cases where i_size isn't
372 ** correct, and when direct item padding results in a few
373 ** extra bytes at the end of the direct item
374 */
375 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
376 break;
377 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
378 chars =
379 inode->i_size - (le_ih_k_offset(ih) - 1) -
380 path.pos_in_item;
381 done = 1;
382 } else {
383 chars = ih_item_len(ih) - path.pos_in_item;
384 }
385 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700387 if (done)
388 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700390 p += chars;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700392 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
393 // we done, if read direct item is not the last item of
394 // node FIXME: we could try to check right delimiting key
395 // to see whether direct item continues in the right
396 // neighbor or rely on i_size
397 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700399 // update key to look for the next piece
400 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
401 result = search_for_position_by_key(inode->i_sb, &key, &path);
402 if (result != POSITION_FOUND)
403 // i/o error most likely
404 break;
405 bh = get_last_bh(&path);
406 ih = get_ih(&path);
407 } while (1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700409 flush_dcache_page(bh_result->b_page);
410 kunmap(bh_result->b_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700412 finished:
413 pathrelse(&path);
Qu Fuping6283d582005-06-25 14:55:44 -0700414
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700415 if (result == IO_ERROR)
416 return -EIO;
Qu Fuping6283d582005-06-25 14:55:44 -0700417
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700418 /* this buffer has valid data, but isn't valid for io. mapping it to
419 * block #0 tells the rest of reiserfs it just has a tail in it
420 */
421 map_bh(bh_result, inode->i_sb, 0);
422 set_buffer_uptodate(bh_result);
423 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424}
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426// this is called to create file map. So, _get_block_create_0 will not
427// read direct item
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700428static int reiserfs_bmap(struct inode *inode, sector_t block,
429 struct buffer_head *bh_result, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700431 if (!file_capable(inode, block))
432 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700434 reiserfs_write_lock(inode->i_sb);
435 /* do not read the direct item */
436 _get_block_create_0(inode, block, bh_result, 0);
437 reiserfs_write_unlock(inode->i_sb);
438 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439}
440
441/* special version of get_block that is only used by grab_tail_page right
442** now. It is sent to block_prepare_write, and when you try to get a
443** block past the end of the file (or a block from a hole) it returns
444** -ENOENT instead of a valid buffer. block_prepare_write expects to
445** be able to do i/o on the buffers returned, unless an error value
446** is also returned.
447**
448** So, this allows block_prepare_write to be used for reading a single block
449** in a page. Where it does not produce a valid page for holes, or past the
450** end of the file. This turns out to be exactly what we need for reading
451** tails for conversion.
452**
453** The point of the wrapper is forcing a certain value for create, even
454** though the VFS layer is calling this function with create==1. If you
455** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
456** don't use this function.
457*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700458static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
459 struct buffer_head *bh_result,
460 int create)
461{
462 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463}
464
465/* This is special helper for reiserfs_get_block in case we are executing
466 direct_IO request. */
467static int reiserfs_get_blocks_direct_io(struct inode *inode,
468 sector_t iblock,
469 unsigned long max_blocks,
470 struct buffer_head *bh_result,
471 int create)
472{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700473 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700475 bh_result->b_page = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700477 /* We set the b_size before reiserfs_get_block call since it is
478 referenced in convert_tail_for_hole() that may be called from
479 reiserfs_get_block() */
480 bh_result->b_size = (1 << inode->i_blkbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700482 ret = reiserfs_get_block(inode, iblock, bh_result,
483 create | GET_BLOCK_NO_DANGLE);
484 if (ret)
485 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700487 /* don't allow direct io onto tail pages */
488 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
489 /* make sure future calls to the direct io funcs for this offset
490 ** in the file fail by unmapping the buffer
491 */
492 clear_buffer_mapped(bh_result);
493 ret = -EINVAL;
494 }
495 /* Possible unpacked tail. Flush the data before pages have
496 disappeared */
497 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
498 int err;
499 lock_kernel();
500 err = reiserfs_commit_for_inode(inode);
501 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
502 unlock_kernel();
503 if (err < 0)
504 ret = err;
505 }
506 out:
507 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508}
509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510/*
511** helper function for when reiserfs_get_block is called for a hole
512** but the file tail is still in a direct item
513** bh_result is the buffer head for the hole
514** tail_offset is the offset of the start of the tail in the file
515**
516** This calls prepare_write, which will start a new transaction
517** you should not be in a transaction, or have any paths held when you
518** call this.
519*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700520static int convert_tail_for_hole(struct inode *inode,
521 struct buffer_head *bh_result,
522 loff_t tail_offset)
523{
524 unsigned long index;
525 unsigned long tail_end;
526 unsigned long tail_start;
527 struct page *tail_page;
528 struct page *hole_page = bh_result->b_page;
529 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700531 if ((tail_offset & (bh_result->b_size - 1)) != 1)
532 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700534 /* always try to read until the end of the block */
535 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
536 tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700538 index = tail_offset >> PAGE_CACHE_SHIFT;
539 /* hole_page can be zero in case of direct_io, we are sure
540 that we cannot get here if we write with O_DIRECT into
541 tail page */
542 if (!hole_page || index != hole_page->index) {
543 tail_page = grab_cache_page(inode->i_mapping, index);
544 retval = -ENOMEM;
545 if (!tail_page) {
546 goto out;
547 }
548 } else {
549 tail_page = hole_page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700552 /* we don't have to make sure the conversion did not happen while
553 ** we were locking the page because anyone that could convert
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800554 ** must first take i_mutex.
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700555 **
556 ** We must fix the tail page for writing because it might have buffers
557 ** that are mapped, but have a block number of 0. This indicates tail
558 ** data that has been read directly into the page, and block_prepare_write
559 ** won't trigger a get_block in this case.
560 */
561 fix_tail_page_for_writing(tail_page);
562 retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);
563 if (retval)
564 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700566 /* tail conversion might change the data in the page */
567 flush_dcache_page(tail_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700569 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700571 unlock:
572 if (tail_page != hole_page) {
573 unlock_page(tail_page);
574 page_cache_release(tail_page);
575 }
576 out:
577 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
580static inline int _allocate_block(struct reiserfs_transaction_handle *th,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700581 long block,
582 struct inode *inode,
583 b_blocknr_t * allocated_block_nr,
584 struct path *path, int flags)
585{
586 BUG_ON(!th->t_trans_id);
587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588#ifdef REISERFS_PREALLOCATE
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800589 if (!(flags & GET_BLOCK_NO_IMUX)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700590 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
591 path, block);
592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700594 return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
595 block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596}
597
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700598int reiserfs_get_block(struct inode *inode, sector_t block,
599 struct buffer_head *bh_result, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700601 int repeat, retval = 0;
602 b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int
603 INITIALIZE_PATH(path);
604 int pos_in_item;
605 struct cpu_key key;
606 struct buffer_head *bh, *unbh = NULL;
607 struct item_head *ih, tmp_ih;
608 __le32 *item;
609 int done;
610 int fs_gen;
611 struct reiserfs_transaction_handle *th = NULL;
612 /* space reserved in transaction batch:
613 . 3 balancings in direct->indirect conversion
614 . 1 block involved into reiserfs_update_sd()
615 XXX in practically impossible worst case direct2indirect()
616 can incur (much) more than 3 balancings.
617 quota update for user, group */
618 int jbegin_count =
619 JOURNAL_PER_BALANCE_CNT * 3 + 1 +
620 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
621 int version;
622 int dangle = 1;
623 loff_t new_offset =
624 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700626 /* bad.... */
627 reiserfs_write_lock(inode->i_sb);
628 version = get_inode_item_key_version(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700630 if (!file_capable(inode, block)) {
631 reiserfs_write_unlock(inode->i_sb);
632 return -EFBIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
634
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700635 /* if !create, we aren't changing the FS, so we don't need to
636 ** log anything, so we don't need to start a transaction
637 */
638 if (!(create & GET_BLOCK_CREATE)) {
639 int ret;
640 /* find number of block-th logical block of the file */
641 ret = _get_block_create_0(inode, block, bh_result,
642 create | GET_BLOCK_READ_DIRECT);
643 reiserfs_write_unlock(inode->i_sb);
644 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700646 /*
647 * if we're already in a transaction, make sure to close
648 * any new transactions we start in this func
649 */
650 if ((create & GET_BLOCK_NO_DANGLE) ||
651 reiserfs_transaction_running(inode->i_sb))
652 dangle = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700654 /* If file is of such a size, that it might have a tail and tails are enabled
655 ** we should mark it as possibly needing tail packing on close
656 */
657 if ((have_large_tails(inode->i_sb)
658 && inode->i_size < i_block_size(inode) * 4)
659 || (have_small_tails(inode->i_sb)
660 && inode->i_size < i_block_size(inode)))
661 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
662
663 /* set the key of the first byte in the 'block'-th block of file */
664 make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
665 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
666 start_trans:
667 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
668 if (!th) {
669 retval = -ENOMEM;
670 goto failure;
671 }
672 reiserfs_update_inode_transaction(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700674 research:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700676 retval = search_for_position_by_key(inode->i_sb, &key, &path);
677 if (retval == IO_ERROR) {
678 retval = -EIO;
679 goto failure;
680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700682 bh = get_last_bh(&path);
683 ih = get_ih(&path);
684 item = get_item(&path);
685 pos_in_item = path.pos_in_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700687 fs_gen = get_generation(inode->i_sb);
688 copy_item_head(&tmp_ih, ih);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700690 if (allocation_needed
691 (retval, allocated_block_nr, ih, item, pos_in_item)) {
692 /* we have to allocate block for the unformatted node */
693 if (!th) {
694 pathrelse(&path);
695 goto start_trans;
696 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700698 repeat =
699 _allocate_block(th, block, inode, &allocated_block_nr,
700 &path, create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700702 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
703 /* restart the transaction to give the journal a chance to free
704 ** some blocks. releases the path, so we have to go back to
705 ** research if we succeed on the second try
706 */
707 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
708 retval = restart_transaction(th, inode, &path);
709 if (retval)
710 goto failure;
711 repeat =
712 _allocate_block(th, block, inode,
713 &allocated_block_nr, NULL, create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700715 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
716 goto research;
717 }
718 if (repeat == QUOTA_EXCEEDED)
719 retval = -EDQUOT;
720 else
721 retval = -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 goto failure;
723 }
724
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700725 if (fs_changed(fs_gen, inode->i_sb)
726 && item_moved(&tmp_ih, &path)) {
727 goto research;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700729 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700731 if (indirect_item_found(retval, ih)) {
732 b_blocknr_t unfm_ptr;
733 /* 'block'-th block is in the file already (there is
734 corresponding cell in some indirect item). But it may be
735 zero unformatted node pointer (hole) */
736 unfm_ptr = get_block_num(item, pos_in_item);
737 if (unfm_ptr == 0) {
738 /* use allocated block to plug the hole */
739 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
740 if (fs_changed(fs_gen, inode->i_sb)
741 && item_moved(&tmp_ih, &path)) {
742 reiserfs_restore_prepared_buffer(inode->i_sb,
743 bh);
744 goto research;
745 }
746 set_buffer_new(bh_result);
747 if (buffer_dirty(bh_result)
748 && reiserfs_data_ordered(inode->i_sb))
749 reiserfs_add_ordered_list(inode, bh_result);
750 put_block_num(item, pos_in_item, allocated_block_nr);
751 unfm_ptr = allocated_block_nr;
752 journal_mark_dirty(th, inode->i_sb, bh);
753 reiserfs_update_sd(th, inode);
754 }
755 set_block_dev_mapped(bh_result, unfm_ptr, inode);
756 pathrelse(&path);
757 retval = 0;
758 if (!dangle && th)
759 retval = reiserfs_end_persistent_transaction(th);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700761 reiserfs_write_unlock(inode->i_sb);
762
763 /* the item was found, so new blocks were not added to the file
764 ** there is no need to make sure the inode is updated with this
765 ** transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700767 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 }
769
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700770 if (!th) {
771 pathrelse(&path);
772 goto start_trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700775 /* desired position is not found or is in the direct item. We have
776 to append file with holes up to 'block'-th block converting
777 direct items to indirect one if necessary */
778 done = 0;
779 do {
780 if (is_statdata_le_ih(ih)) {
781 __le32 unp = 0;
782 struct cpu_key tmp_key;
783
784 /* indirect item has to be inserted */
785 make_le_item_head(&tmp_ih, &key, version, 1,
786 TYPE_INDIRECT, UNFM_P_SIZE,
787 0 /* free_space */ );
788
789 if (cpu_key_k_offset(&key) == 1) {
790 /* we are going to add 'block'-th block to the file. Use
791 allocated block for that */
792 unp = cpu_to_le32(allocated_block_nr);
793 set_block_dev_mapped(bh_result,
794 allocated_block_nr, inode);
795 set_buffer_new(bh_result);
796 done = 1;
797 }
798 tmp_key = key; // ;)
799 set_cpu_key_k_offset(&tmp_key, 1);
800 PATH_LAST_POSITION(&path)++;
801
802 retval =
803 reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
804 inode, (char *)&unp);
805 if (retval) {
806 reiserfs_free_block(th, inode,
807 allocated_block_nr, 1);
808 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
809 }
810 //mark_tail_converted (inode);
811 } else if (is_direct_le_ih(ih)) {
812 /* direct item has to be converted */
813 loff_t tail_offset;
814
815 tail_offset =
816 ((le_ih_k_offset(ih) -
817 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
818 if (tail_offset == cpu_key_k_offset(&key)) {
819 /* direct item we just found fits into block we have
820 to map. Convert it into unformatted node: use
821 bh_result for the conversion */
822 set_block_dev_mapped(bh_result,
823 allocated_block_nr, inode);
824 unbh = bh_result;
825 done = 1;
826 } else {
827 /* we have to padd file tail stored in direct item(s)
828 up to block size and convert it to unformatted
829 node. FIXME: this should also get into page cache */
830
831 pathrelse(&path);
832 /*
833 * ugly, but we can only end the transaction if
834 * we aren't nested
835 */
836 BUG_ON(!th->t_refcount);
837 if (th->t_refcount == 1) {
838 retval =
839 reiserfs_end_persistent_transaction
840 (th);
841 th = NULL;
842 if (retval)
843 goto failure;
844 }
845
846 retval =
847 convert_tail_for_hole(inode, bh_result,
848 tail_offset);
849 if (retval) {
850 if (retval != -ENOSPC)
851 reiserfs_warning(inode->i_sb,
852 "clm-6004: convert tail failed inode %lu, error %d",
853 inode->i_ino,
854 retval);
855 if (allocated_block_nr) {
856 /* the bitmap, the super, and the stat data == 3 */
857 if (!th)
858 th = reiserfs_persistent_transaction(inode->i_sb, 3);
859 if (th)
860 reiserfs_free_block(th,
861 inode,
862 allocated_block_nr,
863 1);
864 }
865 goto failure;
866 }
867 goto research;
868 }
869 retval =
870 direct2indirect(th, inode, &path, unbh,
871 tail_offset);
872 if (retval) {
873 reiserfs_unmap_buffer(unbh);
874 reiserfs_free_block(th, inode,
875 allocated_block_nr, 1);
876 goto failure;
877 }
878 /* it is important the set_buffer_uptodate is done after
879 ** the direct2indirect. The buffer might contain valid
880 ** data newer than the data on disk (read by readpage, changed,
881 ** and then sent here by writepage). direct2indirect needs
882 ** to know if unbh was already up to date, so it can decide
883 ** if the data in unbh needs to be replaced with data from
884 ** the disk
885 */
886 set_buffer_uptodate(unbh);
887
888 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
889 buffer will disappear shortly, so it should not be added to
890 */
891 if (unbh->b_page) {
892 /* we've converted the tail, so we must
893 ** flush unbh before the transaction commits
894 */
895 reiserfs_add_tail_list(inode, unbh);
896
897 /* mark it dirty now to prevent commit_write from adding
898 ** this buffer to the inode's dirty buffer list
899 */
900 /*
901 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
902 * It's still atomic, but it sets the page dirty too,
903 * which makes it eligible for writeback at any time by the
904 * VM (which was also the case with __mark_buffer_dirty())
905 */
906 mark_buffer_dirty(unbh);
907 }
908 } else {
909 /* append indirect item with holes if needed, when appending
910 pointer to 'block'-th block use block, which is already
911 allocated */
912 struct cpu_key tmp_key;
913 unp_t unf_single = 0; // We use this in case we need to allocate only
914 // one block which is a fastpath
915 unp_t *un;
916 __u64 max_to_insert =
917 MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
918 UNFM_P_SIZE;
919 __u64 blocks_needed;
920
921 RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
922 "vs-804: invalid position for append");
923 /* indirect item has to be appended, set up key of that position */
924 make_cpu_key(&tmp_key, inode,
925 le_key_k_offset(version,
926 &(ih->ih_key)) +
927 op_bytes_number(ih,
928 inode->i_sb->s_blocksize),
929 //pos_in_item * inode->i_sb->s_blocksize,
930 TYPE_INDIRECT, 3); // key type is unimportant
931
Vladimir V. Savelievc499ec22006-03-02 02:54:39 -0800932 RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),
933 "green-805: invalid offset");
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700934 blocks_needed =
935 1 +
936 ((cpu_key_k_offset(&key) -
937 cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
938 s_blocksize_bits);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -0700939
940 if (blocks_needed == 1) {
941 un = &unf_single;
942 } else {
943 un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC); // We need to avoid scheduling.
944 if (!un) {
945 un = &unf_single;
946 blocks_needed = 1;
947 max_to_insert = 0;
948 } else
949 memset(un, 0,
950 UNFM_P_SIZE * min(blocks_needed,
951 max_to_insert));
952 }
953 if (blocks_needed <= max_to_insert) {
954 /* we are going to add target block to the file. Use allocated
955 block for that */
956 un[blocks_needed - 1] =
957 cpu_to_le32(allocated_block_nr);
958 set_block_dev_mapped(bh_result,
959 allocated_block_nr, inode);
960 set_buffer_new(bh_result);
961 done = 1;
962 } else {
963 /* paste hole to the indirect item */
964 /* If kmalloc failed, max_to_insert becomes zero and it means we
965 only have space for one block */
966 blocks_needed =
967 max_to_insert ? max_to_insert : 1;
968 }
969 retval =
970 reiserfs_paste_into_item(th, &path, &tmp_key, inode,
971 (char *)un,
972 UNFM_P_SIZE *
973 blocks_needed);
974
975 if (blocks_needed != 1)
976 kfree(un);
977
978 if (retval) {
979 reiserfs_free_block(th, inode,
980 allocated_block_nr, 1);
981 goto failure;
982 }
983 if (!done) {
984 /* We need to mark new file size in case this function will be
985 interrupted/aborted later on. And we may do this only for
986 holes. */
987 inode->i_size +=
988 inode->i_sb->s_blocksize * blocks_needed;
989 }
990 }
991
992 if (done == 1)
993 break;
994
995 /* this loop could log more blocks than we had originally asked
996 ** for. So, we have to allow the transaction to end if it is
997 ** too big or too full. Update the inode so things are
998 ** consistent if we crash before the function returns
999 **
1000 ** release the path so that anybody waiting on the path before
1001 ** ending their transaction will be able to continue.
1002 */
1003 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
1004 retval = restart_transaction(th, inode, &path);
1005 if (retval)
1006 goto failure;
1007 }
1008 /* inserting indirect pointers for a hole can take a
1009 ** long time. reschedule if needed
1010 */
1011 cond_resched();
1012
1013 retval = search_for_position_by_key(inode->i_sb, &key, &path);
1014 if (retval == IO_ERROR) {
1015 retval = -EIO;
1016 goto failure;
1017 }
1018 if (retval == POSITION_FOUND) {
1019 reiserfs_warning(inode->i_sb,
1020 "vs-825: reiserfs_get_block: "
1021 "%K should not be found", &key);
1022 retval = -EEXIST;
1023 if (allocated_block_nr)
1024 reiserfs_free_block(th, inode,
1025 allocated_block_nr, 1);
1026 pathrelse(&path);
1027 goto failure;
1028 }
1029 bh = get_last_bh(&path);
1030 ih = get_ih(&path);
1031 item = get_item(&path);
1032 pos_in_item = path.pos_in_item;
1033 } while (1);
1034
1035 retval = 0;
1036
1037 failure:
1038 if (th && (!dangle || (retval && !th->t_trans_id))) {
1039 int err;
1040 if (th->t_trans_id)
1041 reiserfs_update_sd(th, inode);
1042 err = reiserfs_end_persistent_transaction(th);
1043 if (err)
1044 retval = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001047 reiserfs_write_unlock(inode->i_sb);
1048 reiserfs_check_path(&path);
1049 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050}
1051
1052static int
1053reiserfs_readpages(struct file *file, struct address_space *mapping,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001054 struct list_head *pages, unsigned nr_pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001056 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057}
1058
1059/* Compute real number of used bytes by file
1060 * Following three functions can go away when we'll have enough space in stat item
1061 */
1062static int real_space_diff(struct inode *inode, int sd_size)
1063{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001064 int bytes;
1065 loff_t blocksize = inode->i_sb->s_blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001067 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1068 return sd_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001070 /* End of file is also in full block with indirect reference, so round
1071 ** up to the next block.
1072 **
1073 ** there is just no way to know if the tail is actually packed
1074 ** on the file, so we have to assume it isn't. When we pack the
1075 ** tail, we add 4 bytes to pretend there really is an unformatted
1076 ** node pointer
1077 */
1078 bytes =
1079 ((inode->i_size +
1080 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1081 sd_size;
1082 return bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083}
1084
1085static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001086 int sd_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001088 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1089 return inode->i_size +
1090 (loff_t) (real_space_diff(inode, sd_size));
1091 }
1092 return ((loff_t) real_space_diff(inode, sd_size)) +
1093 (((loff_t) blocks) << 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094}
1095
1096/* Compute number of blocks used by file in ReiserFS counting */
1097static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1098{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001099 loff_t bytes = inode_get_bytes(inode);
1100 loff_t real_space = real_space_diff(inode, sd_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001102 /* keeps fsck and non-quota versions of reiserfs happy */
1103 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1104 bytes += (loff_t) 511;
1105 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001107 /* files from before the quota patch might i_blocks such that
1108 ** bytes < real_space. Deal with that here to prevent it from
1109 ** going negative.
1110 */
1111 if (bytes < real_space)
1112 return 0;
1113 return (bytes - real_space) >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114}
1115
1116//
1117// BAD: new directories have stat data of new type and all other items
1118// of old type. Version stored in the inode says about body items, so
1119// in update_stat_data we can not rely on inode, but have to check
1120// item version directly
1121//
1122
1123// called by read_locked_inode
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001124static void init_inode(struct inode *inode, struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001126 struct buffer_head *bh;
1127 struct item_head *ih;
1128 __u32 rdev;
1129 //int version = ITEM_VERSION_1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001131 bh = PATH_PLAST_BUFFER(path);
1132 ih = PATH_PITEM_HEAD(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001134 copy_key(INODE_PKEY(inode), &(ih->ih_key));
1135 inode->i_blksize = reiserfs_default_io_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001137 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1138 REISERFS_I(inode)->i_flags = 0;
1139 REISERFS_I(inode)->i_prealloc_block = 0;
1140 REISERFS_I(inode)->i_prealloc_count = 0;
1141 REISERFS_I(inode)->i_trans_id = 0;
1142 REISERFS_I(inode)->i_jl = NULL;
1143 REISERFS_I(inode)->i_acl_access = NULL;
1144 REISERFS_I(inode)->i_acl_default = NULL;
1145 init_rwsem(&REISERFS_I(inode)->xattr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001147 if (stat_data_v1(ih)) {
1148 struct stat_data_v1 *sd =
1149 (struct stat_data_v1 *)B_I_PITEM(bh, ih);
1150 unsigned long blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001152 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1153 set_inode_sd_version(inode, STAT_DATA_V1);
1154 inode->i_mode = sd_v1_mode(sd);
1155 inode->i_nlink = sd_v1_nlink(sd);
1156 inode->i_uid = sd_v1_uid(sd);
1157 inode->i_gid = sd_v1_gid(sd);
1158 inode->i_size = sd_v1_size(sd);
1159 inode->i_atime.tv_sec = sd_v1_atime(sd);
1160 inode->i_mtime.tv_sec = sd_v1_mtime(sd);
1161 inode->i_ctime.tv_sec = sd_v1_ctime(sd);
1162 inode->i_atime.tv_nsec = 0;
1163 inode->i_ctime.tv_nsec = 0;
1164 inode->i_mtime.tv_nsec = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001166 inode->i_blocks = sd_v1_blocks(sd);
1167 inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1168 blocks = (inode->i_size + 511) >> 9;
1169 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
1170 if (inode->i_blocks > blocks) {
1171 // there was a bug in <=3.5.23 when i_blocks could take negative
1172 // values. Starting from 3.5.17 this value could even be stored in
1173 // stat data. For such files we set i_blocks based on file
1174 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be
1175 // only updated if file's inode will ever change
1176 inode->i_blocks = blocks;
1177 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001179 rdev = sd_v1_rdev(sd);
1180 REISERFS_I(inode)->i_first_direct_byte =
1181 sd_v1_first_direct_byte(sd);
1182 /* an early bug in the quota code can give us an odd number for the
1183 ** block count. This is incorrect, fix it here.
1184 */
1185 if (inode->i_blocks & 1) {
1186 inode->i_blocks++;
1187 }
1188 inode_set_bytes(inode,
1189 to_real_used_space(inode, inode->i_blocks,
1190 SD_V1_SIZE));
1191 /* nopack is initially zero for v1 objects. For v2 objects,
1192 nopack is initialised from sd_attrs */
1193 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1194 } else {
1195 // new stat data found, but object may have old items
1196 // (directories and symlinks)
1197 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
1198
1199 inode->i_mode = sd_v2_mode(sd);
1200 inode->i_nlink = sd_v2_nlink(sd);
1201 inode->i_uid = sd_v2_uid(sd);
1202 inode->i_size = sd_v2_size(sd);
1203 inode->i_gid = sd_v2_gid(sd);
1204 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1205 inode->i_atime.tv_sec = sd_v2_atime(sd);
1206 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1207 inode->i_ctime.tv_nsec = 0;
1208 inode->i_mtime.tv_nsec = 0;
1209 inode->i_atime.tv_nsec = 0;
1210 inode->i_blocks = sd_v2_blocks(sd);
1211 rdev = sd_v2_rdev(sd);
1212 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1213 inode->i_generation =
1214 le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1215 else
1216 inode->i_generation = sd_v2_generation(sd);
1217
1218 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1219 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1220 else
1221 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1222 REISERFS_I(inode)->i_first_direct_byte = 0;
1223 set_inode_sd_version(inode, STAT_DATA_V2);
1224 inode_set_bytes(inode,
1225 to_real_used_space(inode, inode->i_blocks,
1226 SD_V2_SIZE));
1227 /* read persistent inode attributes from sd and initalise
1228 generic inode flags from them */
1229 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1230 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 }
1232
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001233 pathrelse(path);
1234 if (S_ISREG(inode->i_mode)) {
1235 inode->i_op = &reiserfs_file_inode_operations;
1236 inode->i_fop = &reiserfs_file_operations;
1237 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1238 } else if (S_ISDIR(inode->i_mode)) {
1239 inode->i_op = &reiserfs_dir_inode_operations;
1240 inode->i_fop = &reiserfs_dir_operations;
1241 } else if (S_ISLNK(inode->i_mode)) {
1242 inode->i_op = &reiserfs_symlink_inode_operations;
1243 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1244 } else {
1245 inode->i_blocks = 0;
1246 inode->i_op = &reiserfs_special_inode_operations;
1247 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249}
1250
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251// update new stat data with inode fields
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001252static void inode2sd(void *sd, struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001254 struct stat_data *sd_v2 = (struct stat_data *)sd;
1255 __u16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001257 set_sd_v2_mode(sd_v2, inode->i_mode);
1258 set_sd_v2_nlink(sd_v2, inode->i_nlink);
1259 set_sd_v2_uid(sd_v2, inode->i_uid);
1260 set_sd_v2_size(sd_v2, size);
1261 set_sd_v2_gid(sd_v2, inode->i_gid);
1262 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);
1263 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);
1264 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);
1265 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));
1266 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1267 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));
1268 else
1269 set_sd_v2_generation(sd_v2, inode->i_generation);
1270 flags = REISERFS_I(inode)->i_attrs;
1271 i_attrs_to_sd_attrs(inode, &flags);
1272 set_sd_v2_attrs(sd_v2, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273}
1274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275// used to copy inode's fields to old stat data
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001276static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001278 struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001280 set_sd_v1_mode(sd_v1, inode->i_mode);
1281 set_sd_v1_uid(sd_v1, inode->i_uid);
1282 set_sd_v1_gid(sd_v1, inode->i_gid);
1283 set_sd_v1_nlink(sd_v1, inode->i_nlink);
1284 set_sd_v1_size(sd_v1, size);
1285 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);
1286 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);
1287 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001289 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1290 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));
1291 else
1292 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001294 // Sigh. i_first_direct_byte is back
1295 set_sd_v1_first_direct_byte(sd_v1,
1296 REISERFS_I(inode)->i_first_direct_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297}
1298
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299/* NOTE, you must prepare the buffer head before sending it here,
1300** and then log it after the call
1301*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001302static void update_stat_data(struct path *path, struct inode *inode,
1303 loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001305 struct buffer_head *bh;
1306 struct item_head *ih;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001308 bh = PATH_PLAST_BUFFER(path);
1309 ih = PATH_PITEM_HEAD(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001311 if (!is_statdata_le_ih(ih))
1312 reiserfs_panic(inode->i_sb,
1313 "vs-13065: update_stat_data: key %k, found item %h",
1314 INODE_PKEY(inode), ih);
1315
1316 if (stat_data_v1(ih)) {
1317 // path points to old stat data
1318 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1319 } else {
1320 inode2sd(B_I_PITEM(bh, ih), inode, size);
1321 }
1322
1323 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324}
1325
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001326void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1327 struct inode *inode, loff_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001329 struct cpu_key key;
1330 INITIALIZE_PATH(path);
1331 struct buffer_head *bh;
1332 int fs_gen;
1333 struct item_head *ih, tmp_ih;
1334 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001336 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001338 make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant
1339
1340 for (;;) {
1341 int pos;
1342 /* look for the object's stat data */
1343 retval = search_item(inode->i_sb, &key, &path);
1344 if (retval == IO_ERROR) {
1345 reiserfs_warning(inode->i_sb,
1346 "vs-13050: reiserfs_update_sd: "
1347 "i/o failure occurred trying to update %K stat data",
1348 &key);
1349 return;
1350 }
1351 if (retval == ITEM_NOT_FOUND) {
1352 pos = PATH_LAST_POSITION(&path);
1353 pathrelse(&path);
1354 if (inode->i_nlink == 0) {
1355 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1356 return;
1357 }
1358 reiserfs_warning(inode->i_sb,
1359 "vs-13060: reiserfs_update_sd: "
1360 "stat data of object %k (nlink == %d) not found (pos %d)",
1361 INODE_PKEY(inode), inode->i_nlink,
1362 pos);
1363 reiserfs_check_path(&path);
1364 return;
1365 }
1366
1367 /* sigh, prepare_for_journal might schedule. When it schedules the
1368 ** FS might change. We have to detect that, and loop back to the
1369 ** search if the stat data item has moved
1370 */
1371 bh = get_last_bh(&path);
1372 ih = get_ih(&path);
1373 copy_item_head(&tmp_ih, ih);
1374 fs_gen = get_generation(inode->i_sb);
1375 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
1376 if (fs_changed(fs_gen, inode->i_sb)
1377 && item_moved(&tmp_ih, &path)) {
1378 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
1379 continue; /* Stat_data item has been moved after scheduling. */
1380 }
1381 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001383 update_stat_data(&path, inode, size);
1384 journal_mark_dirty(th, th->t_super, bh);
1385 pathrelse(&path);
1386 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387}
1388
1389/* reiserfs_read_locked_inode is called to read the inode off disk, and it
1390** does a make_bad_inode when things go wrong. But, we need to make sure
1391** and clear the key in the private portion of the inode, otherwise a
1392** corresponding iput might try to delete whatever object the inode last
1393** represented.
1394*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001395static void reiserfs_make_bad_inode(struct inode *inode)
1396{
1397 memset(INODE_PKEY(inode), 0, KEY_SIZE);
1398 make_bad_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399}
1400
1401//
1402// initially this function was derived from minix or ext2's analog and
1403// evolved as the prototype did
1404//
1405
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001406int reiserfs_init_locked_inode(struct inode *inode, void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001408 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;
1409 inode->i_ino = args->objectid;
1410 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);
1411 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412}
1413
1414/* looks for stat data in the tree, and fills up the fields of in-core
1415 inode stat data fields */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001416void reiserfs_read_locked_inode(struct inode *inode,
1417 struct reiserfs_iget_args *args)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001419 INITIALIZE_PATH(path_to_sd);
1420 struct cpu_key key;
1421 unsigned long dirino;
1422 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001424 dirino = args->dirid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001426 /* set version 1, version 2 could be used too, because stat data
1427 key is the same in both versions */
1428 key.version = KEY_FORMAT_3_5;
1429 key.on_disk_key.k_dir_id = dirino;
1430 key.on_disk_key.k_objectid = inode->i_ino;
1431 key.on_disk_key.k_offset = 0;
1432 key.on_disk_key.k_type = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001434 /* look for the object's stat data */
1435 retval = search_item(inode->i_sb, &key, &path_to_sd);
1436 if (retval == IO_ERROR) {
1437 reiserfs_warning(inode->i_sb,
1438 "vs-13070: reiserfs_read_locked_inode: "
1439 "i/o failure occurred trying to find stat data of %K",
1440 &key);
1441 reiserfs_make_bad_inode(inode);
1442 return;
1443 }
1444 if (retval != ITEM_FOUND) {
1445 /* a stale NFS handle can trigger this without it being an error */
1446 pathrelse(&path_to_sd);
1447 reiserfs_make_bad_inode(inode);
1448 inode->i_nlink = 0;
1449 return;
1450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001452 init_inode(inode, &path_to_sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001454 /* It is possible that knfsd is trying to access inode of a file
1455 that is being removed from the disk by some other thread. As we
1456 update sd on unlink all that is required is to check for nlink
1457 here. This bug was first found by Sizif when debugging
1458 SquidNG/Butterfly, forgotten, and found again after Philippe
1459 Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001461 More logical fix would require changes in fs/inode.c:iput() to
1462 remove inode from hash-table _after_ fs cleaned disk stuff up and
1463 in iget() to return NULL if I_FREEING inode is found in
1464 hash-table. */
1465 /* Currently there is one place where it's ok to meet inode with
1466 nlink==0: processing of open-unlinked and half-truncated files
1467 during mount (fs/reiserfs/super.c:finish_unfinished()). */
1468 if ((inode->i_nlink == 0) &&
1469 !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
1470 reiserfs_warning(inode->i_sb,
1471 "vs-13075: reiserfs_read_locked_inode: "
1472 "dead inode read from disk %K. "
1473 "This is likely to be race with knfsd. Ignore",
1474 &key);
1475 reiserfs_make_bad_inode(inode);
1476 }
1477
1478 reiserfs_check_path(&path_to_sd); /* init inode should be relsing */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
1480}
1481
1482/**
1483 * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().
1484 *
1485 * @inode: inode from hash table to check
1486 * @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.
1487 *
1488 * This function is called by iget5_locked() to distinguish reiserfs inodes
1489 * having the same inode numbers. Such inodes can only exist due to some
1490 * error condition. One of them should be bad. Inodes with identical
1491 * inode numbers (objectids) are distinguished by parent directory ids.
1492 *
1493 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001494int reiserfs_find_actor(struct inode *inode, void *opaque)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001496 struct reiserfs_iget_args *args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001498 args = opaque;
1499 /* args is already in CPU order */
1500 return (inode->i_ino == args->objectid) &&
1501 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502}
1503
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001504struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001506 struct inode *inode;
1507 struct reiserfs_iget_args args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001509 args.objectid = key->on_disk_key.k_objectid;
1510 args.dirid = key->on_disk_key.k_dir_id;
1511 inode = iget5_locked(s, key->on_disk_key.k_objectid,
1512 reiserfs_find_actor, reiserfs_init_locked_inode,
1513 (void *)(&args));
1514 if (!inode)
1515 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001517 if (inode->i_state & I_NEW) {
1518 reiserfs_read_locked_inode(inode, &args);
1519 unlock_new_inode(inode);
1520 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001522 if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1523 /* either due to i/o error or a stale NFS handle */
1524 iput(inode);
1525 inode = NULL;
1526 }
1527 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528}
1529
1530struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)
1531{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001532 __u32 *data = vobjp;
1533 struct cpu_key key;
1534 struct dentry *result;
1535 struct inode *inode;
1536
1537 key.on_disk_key.k_objectid = data[0];
1538 key.on_disk_key.k_dir_id = data[1];
1539 reiserfs_write_lock(sb);
1540 inode = reiserfs_iget(sb, &key);
1541 if (inode && !IS_ERR(inode) && data[2] != 0 &&
1542 data[2] != inode->i_generation) {
1543 iput(inode);
1544 inode = NULL;
1545 }
1546 reiserfs_write_unlock(sb);
1547 if (!inode)
1548 inode = ERR_PTR(-ESTALE);
1549 if (IS_ERR(inode))
1550 return ERR_PTR(PTR_ERR(inode));
1551 result = d_alloc_anon(inode);
1552 if (!result) {
1553 iput(inode);
1554 return ERR_PTR(-ENOMEM);
1555 }
1556 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557}
1558
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001559struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,
1560 int len, int fhtype,
1561 int (*acceptable) (void *contect,
1562 struct dentry * de),
1563 void *context)
1564{
1565 __u32 obj[3], parent[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001567 /* fhtype happens to reflect the number of u32s encoded.
1568 * due to a bug in earlier code, fhtype might indicate there
1569 * are more u32s then actually fitted.
1570 * so if fhtype seems to be more than len, reduce fhtype.
1571 * Valid types are:
1572 * 2 - objectid + dir_id - legacy support
1573 * 3 - objectid + dir_id + generation
1574 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1575 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1576 * 6 - as above plus generation of directory
1577 * 6 does not fit in NFSv2 handles
1578 */
1579 if (fhtype > len) {
1580 if (fhtype != 6 || len != 5)
1581 reiserfs_warning(sb,
1582 "nfsd/reiserfs, fhtype=%d, len=%d - odd",
1583 fhtype, len);
1584 fhtype = 5;
1585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001587 obj[0] = data[0];
1588 obj[1] = data[1];
1589 if (fhtype == 3 || fhtype >= 5)
1590 obj[2] = data[2];
1591 else
1592 obj[2] = 0; /* generation number */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001594 if (fhtype >= 4) {
1595 parent[0] = data[fhtype >= 5 ? 3 : 2];
1596 parent[1] = data[fhtype >= 5 ? 4 : 3];
1597 if (fhtype == 6)
1598 parent[2] = data[5];
1599 else
1600 parent[2] = 0;
1601 }
1602 return sb->s_export_op->find_exported_dentry(sb, obj,
1603 fhtype < 4 ? NULL : parent,
1604 acceptable, context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605}
1606
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001607int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
1608 int need_parent)
1609{
1610 struct inode *inode = dentry->d_inode;
1611 int maxlen = *lenp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001613 if (maxlen < 3)
1614 return 255;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001616 data[0] = inode->i_ino;
1617 data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1618 data[2] = inode->i_generation;
1619 *lenp = 3;
1620 /* no room for directory info? return what we've stored so far */
1621 if (maxlen < 5 || !need_parent)
1622 return 3;
1623
1624 spin_lock(&dentry->d_lock);
1625 inode = dentry->d_parent->d_inode;
1626 data[3] = inode->i_ino;
1627 data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1628 *lenp = 5;
1629 if (maxlen >= 6) {
1630 data[5] = inode->i_generation;
1631 *lenp = 6;
1632 }
1633 spin_unlock(&dentry->d_lock);
1634 return *lenp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635}
1636
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637/* looks for stat data, then copies fields to it, marks the buffer
1638 containing stat data as dirty */
1639/* reiserfs inodes are never really dirty, since the dirty inode call
1640** always logs them. This call allows the VFS inode marking routines
1641** to properly mark inodes for datasync and such, but only actually
1642** does something when called for a synchronous update.
1643*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001644int reiserfs_write_inode(struct inode *inode, int do_sync)
1645{
1646 struct reiserfs_transaction_handle th;
1647 int jbegin_count = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001649 if (inode->i_sb->s_flags & MS_RDONLY)
1650 return -EROFS;
1651 /* memory pressure can sometimes initiate write_inode calls with sync == 1,
1652 ** these cases are just when the system needs ram, not when the
1653 ** inode needs to reach disk for safety, and they can safely be
1654 ** ignored because the altered inode has already been logged.
1655 */
1656 if (do_sync && !(current->flags & PF_MEMALLOC)) {
1657 reiserfs_write_lock(inode->i_sb);
1658 if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
1659 reiserfs_update_sd(&th, inode);
1660 journal_end_sync(&th, inode->i_sb, jbegin_count);
1661 }
1662 reiserfs_write_unlock(inode->i_sb);
1663 }
1664 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665}
1666
1667/* stat data of new object is inserted already, this inserts the item
1668 containing "." and ".." entries */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001669static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1670 struct inode *inode,
1671 struct item_head *ih, struct path *path,
1672 struct inode *dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001674 struct super_block *sb = th->t_super;
1675 char empty_dir[EMPTY_DIR_SIZE];
1676 char *body = empty_dir;
1677 struct cpu_key key;
1678 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001680 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001682 _make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),
1683 le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,
1684 TYPE_DIRENTRY, 3 /*key length */ );
1685
1686 /* compose item head for new item. Directories consist of items of
1687 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1688 is done by reiserfs_new_inode */
1689 if (old_format_only(sb)) {
1690 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1691 TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);
1692
1693 make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,
1694 ih->ih_key.k_objectid,
1695 INODE_PKEY(dir)->k_dir_id,
1696 INODE_PKEY(dir)->k_objectid);
1697 } else {
1698 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1699 TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
1700
1701 make_empty_dir_item(body, ih->ih_key.k_dir_id,
1702 ih->ih_key.k_objectid,
1703 INODE_PKEY(dir)->k_dir_id,
1704 INODE_PKEY(dir)->k_objectid);
1705 }
1706
1707 /* look for place in the tree for new item */
1708 retval = search_item(sb, &key, path);
1709 if (retval == IO_ERROR) {
1710 reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "
1711 "i/o failure occurred creating new directory");
1712 return -EIO;
1713 }
1714 if (retval == ITEM_FOUND) {
1715 pathrelse(path);
1716 reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "
1717 "object with this key exists (%k)",
1718 &(ih->ih_key));
1719 return -EEXIST;
1720 }
1721
1722 /* insert item, that is empty directory item */
1723 return reiserfs_insert_item(th, path, &key, ih, inode, body);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724}
1725
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726/* stat data of object has been inserted, this inserts the item
1727 containing the body of symlink */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001728static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */
1729 struct item_head *ih,
1730 struct path *path, const char *symname,
1731 int item_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001733 struct super_block *sb = th->t_super;
1734 struct cpu_key key;
1735 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001737 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001739 _make_cpu_key(&key, KEY_FORMAT_3_5,
1740 le32_to_cpu(ih->ih_key.k_dir_id),
1741 le32_to_cpu(ih->ih_key.k_objectid),
1742 1, TYPE_DIRECT, 3 /*key length */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001744 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1745 0 /*free_space */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001747 /* look for place in the tree for new item */
1748 retval = search_item(sb, &key, path);
1749 if (retval == IO_ERROR) {
1750 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "
1751 "i/o failure occurred creating new symlink");
1752 return -EIO;
1753 }
1754 if (retval == ITEM_FOUND) {
1755 pathrelse(path);
1756 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "
1757 "object with this key exists (%k)",
1758 &(ih->ih_key));
1759 return -EEXIST;
1760 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001762 /* insert item, that is body of symlink */
1763 return reiserfs_insert_item(th, path, &key, ih, inode, symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764}
1765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766/* inserts the stat data into the tree, and then calls
1767 reiserfs_new_directory (to insert ".", ".." item if new object is
1768 directory) or reiserfs_new_symlink (to insert symlink body if new
1769 object is symlink) or nothing (if new object is regular file)
1770
1771 NOTE! uid and gid must already be set in the inode. If we return
1772 non-zero due to an error, we have to drop the quota previously allocated
1773 for the fresh inode. This can only be done outside a transaction, so
1774 if we return non-zero, we also end the transaction. */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001775int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1776 struct inode *dir, int mode, const char *symname,
1777 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1778 strlen (symname) for symlinks) */
1779 loff_t i_size, struct dentry *dentry,
1780 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001782 struct super_block *sb;
1783 INITIALIZE_PATH(path_to_key);
1784 struct cpu_key key;
1785 struct item_head ih;
1786 struct stat_data sd;
1787 int retval;
1788 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001790 BUG_ON(!th->t_trans_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001792 if (DQUOT_ALLOC_INODE(inode)) {
1793 err = -EDQUOT;
1794 goto out_end_trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001796 if (!dir || !dir->i_nlink) {
1797 err = -EPERM;
1798 goto out_bad_inode;
1799 }
1800
1801 sb = dir->i_sb;
1802
1803 /* item head of new item */
1804 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);
1805 ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));
1806 if (!ih.ih_key.k_objectid) {
1807 err = -ENOMEM;
1808 goto out_bad_inode;
1809 }
1810 if (old_format_only(sb))
1811 /* not a perfect generation count, as object ids can be reused, but
1812 ** this is as good as reiserfs can do right now.
1813 ** note that the private part of inode isn't filled in yet, we have
1814 ** to use the directory.
1815 */
1816 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1817 else
1818#if defined( USE_INODE_GENERATION_COUNTER )
1819 inode->i_generation =
1820 le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1821#else
1822 inode->i_generation = ++event;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001825 /* fill stat data */
1826 inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);
1827
1828 /* uid and gid must already be set by the caller for quota init */
1829
1830 /* symlink cannot be immutable or append only, right? */
1831 if (S_ISLNK(inode->i_mode))
1832 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1833
1834 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1835 inode->i_size = i_size;
1836 inode->i_blocks = 0;
1837 inode->i_bytes = 0;
1838 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1839 U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;
1840
1841 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1842 REISERFS_I(inode)->i_flags = 0;
1843 REISERFS_I(inode)->i_prealloc_block = 0;
1844 REISERFS_I(inode)->i_prealloc_count = 0;
1845 REISERFS_I(inode)->i_trans_id = 0;
1846 REISERFS_I(inode)->i_jl = NULL;
1847 REISERFS_I(inode)->i_attrs =
1848 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;
1849 sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);
1850 REISERFS_I(inode)->i_acl_access = NULL;
1851 REISERFS_I(inode)->i_acl_default = NULL;
1852 init_rwsem(&REISERFS_I(inode)->xattr_sem);
1853
1854 if (old_format_only(sb))
1855 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1856 TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1857 else
1858 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1859 TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1860
1861 /* key to search for correct place for new stat data */
1862 _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1863 le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1864 TYPE_STAT_DATA, 3 /*key length */ );
1865
1866 /* find proper place for inserting of stat data */
1867 retval = search_item(sb, &key, &path_to_key);
1868 if (retval == IO_ERROR) {
1869 err = -EIO;
1870 goto out_bad_inode;
1871 }
1872 if (retval == ITEM_FOUND) {
1873 pathrelse(&path_to_key);
1874 err = -EEXIST;
1875 goto out_bad_inode;
1876 }
1877 if (old_format_only(sb)) {
1878 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1879 pathrelse(&path_to_key);
1880 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1881 err = -EINVAL;
1882 goto out_bad_inode;
1883 }
1884 inode2sd_v1(&sd, inode, inode->i_size);
1885 } else {
1886 inode2sd(&sd, inode, inode->i_size);
1887 }
1888 // these do not go to on-disk stat data
1889 inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1890 inode->i_blksize = reiserfs_default_io_size;
1891
1892 // store in in-core inode the key of stat data and version all
1893 // object items will have (directory items will have old offset
1894 // format, other new objects will consist of new items)
1895 memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1896 if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1897 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1898 else
1899 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1900 if (old_format_only(sb))
1901 set_inode_sd_version(inode, STAT_DATA_V1);
1902 else
1903 set_inode_sd_version(inode, STAT_DATA_V2);
1904
1905 /* insert the stat data into the tree */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906#ifdef DISPLACE_NEW_PACKING_LOCALITIES
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001907 if (REISERFS_I(dir)->new_packing_locality)
1908 th->displace_new_blocks = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909#endif
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001910 retval =
1911 reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1912 (char *)(&sd));
1913 if (retval) {
1914 err = retval;
1915 reiserfs_check_path(&path_to_key);
1916 goto out_bad_inode;
1917 }
1918#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1919 if (!th->displace_new_blocks)
1920 REISERFS_I(dir)->new_packing_locality = 0;
1921#endif
1922 if (S_ISDIR(mode)) {
1923 /* insert item with "." and ".." */
1924 retval =
1925 reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1926 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001928 if (S_ISLNK(mode)) {
1929 /* insert body of symlink */
1930 if (!old_format_only(sb))
1931 i_size = ROUND_UP(i_size);
1932 retval =
1933 reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1934 i_size);
1935 }
1936 if (retval) {
1937 err = retval;
1938 reiserfs_check_path(&path_to_key);
1939 journal_end(th, th->t_super, th->t_blocks_allocated);
1940 goto out_inserted_sd;
1941 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001943 /* XXX CHECK THIS */
1944 if (reiserfs_posixacl(inode->i_sb)) {
1945 retval = reiserfs_inherit_default_acl(dir, dentry, inode);
1946 if (retval) {
1947 err = retval;
1948 reiserfs_check_path(&path_to_key);
1949 journal_end(th, th->t_super, th->t_blocks_allocated);
1950 goto out_inserted_sd;
1951 }
1952 } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1953 reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
1954 "but vfs thinks they are!");
1955 } else if (is_reiserfs_priv_object(dir)) {
1956 reiserfs_mark_inode_private(inode);
1957 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001959 insert_inode_hash(inode);
1960 reiserfs_update_sd(th, inode);
1961 reiserfs_check_path(&path_to_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001963 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964
1965/* it looks like you can easily compress these two goto targets into
1966 * one. Keeping it like this doesn't actually hurt anything, and they
1967 * are place holders for what the quota code actually needs.
1968 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001969 out_bad_inode:
1970 /* Invalidate the object, nothing was inserted yet */
1971 INODE_PKEY(inode)->k_objectid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001973 /* Quota change must be inside a transaction for journaling */
1974 DQUOT_FREE_INODE(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001976 out_end_trans:
1977 journal_end(th, th->t_super, th->t_blocks_allocated);
1978 /* Drop can be outside and it needs more credits so it's better to have it outside */
1979 DQUOT_DROP(inode);
1980 inode->i_flags |= S_NOQUOTA;
1981 make_bad_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001983 out_inserted_sd:
1984 inode->i_nlink = 0;
1985 th->t_trans_id = 0; /* so the caller can't use this handle later */
Jeff Mahoneyb3bb8af2005-07-27 11:43:38 -07001986
1987 /* If we were inheriting an ACL, we need to release the lock so that
1988 * iput doesn't deadlock in reiserfs_delete_xattrs. The locking
1989 * code really needs to be reworked, but this will take care of it
1990 * for now. -jeffm */
Jan Karad86c3902005-08-18 11:24:17 -07001991 if (REISERFS_I(dir)->i_acl_default && !IS_ERR(REISERFS_I(dir)->i_acl_default)) {
Jeff Mahoneyb3bb8af2005-07-27 11:43:38 -07001992 reiserfs_write_unlock_xattrs(dir->i_sb);
1993 iput(inode);
1994 reiserfs_write_lock_xattrs(dir->i_sb);
1995 } else
1996 iput(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07001997 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998}
1999
2000/*
2001** finds the tail page in the page cache,
2002** reads the last block in.
2003**
2004** On success, page_result is set to a locked, pinned page, and bh_result
2005** is set to an up to date buffer for the last block in the file. returns 0.
2006**
2007** tail conversion is not done, so bh_result might not be valid for writing
2008** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
2009** trying to write the block.
2010**
2011** on failure, nonzero is returned, page_result and bh_result are untouched.
2012*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002013static int grab_tail_page(struct inode *p_s_inode,
2014 struct page **page_result,
2015 struct buffer_head **bh_result)
2016{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002018 /* we want the page with the last byte in the file,
2019 ** not the page that will hold the next byte for appending
2020 */
2021 unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;
2022 unsigned long pos = 0;
2023 unsigned long start = 0;
2024 unsigned long blocksize = p_s_inode->i_sb->s_blocksize;
2025 unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);
2026 struct buffer_head *bh;
2027 struct buffer_head *head;
2028 struct page *page;
2029 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002031 /* we know that we are only called with inode->i_size > 0.
2032 ** we also know that a file tail can never be as big as a block
2033 ** If i_size % blocksize == 0, our file is currently block aligned
2034 ** and it won't need converting or zeroing after a truncate.
2035 */
2036 if ((offset & (blocksize - 1)) == 0) {
2037 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002039 page = grab_cache_page(p_s_inode->i_mapping, index);
2040 error = -ENOMEM;
2041 if (!page) {
2042 goto out;
2043 }
2044 /* start within the page of the last block in the file */
2045 start = (offset / blocksize) * blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002047 error = block_prepare_write(page, start, offset,
2048 reiserfs_get_block_create_0);
2049 if (error)
2050 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002052 head = page_buffers(page);
2053 bh = head;
2054 do {
2055 if (pos >= start) {
2056 break;
2057 }
2058 bh = bh->b_this_page;
2059 pos += blocksize;
2060 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002062 if (!buffer_uptodate(bh)) {
2063 /* note, this should never happen, prepare_write should
2064 ** be taking care of this for us. If the buffer isn't up to date,
2065 ** I've screwed up the code to find the buffer, or the code to
2066 ** call prepare_write
2067 */
2068 reiserfs_warning(p_s_inode->i_sb,
2069 "clm-6000: error reading block %lu on dev %s",
2070 bh->b_blocknr,
2071 reiserfs_bdevname(p_s_inode->i_sb));
2072 error = -EIO;
2073 goto unlock;
2074 }
2075 *bh_result = bh;
2076 *page_result = page;
2077
2078 out:
2079 return error;
2080
2081 unlock:
2082 unlock_page(page);
2083 page_cache_release(page);
2084 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085}
2086
2087/*
2088** vfs version of truncate file. Must NOT be called with
2089** a transaction already started.
2090**
2091** some code taken from block_truncate_page
2092*/
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002093int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
2094{
2095 struct reiserfs_transaction_handle th;
2096 /* we want the offset for the first byte after the end of the file */
2097 unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);
2098 unsigned blocksize = p_s_inode->i_sb->s_blocksize;
2099 unsigned length;
2100 struct page *page = NULL;
2101 int error;
2102 struct buffer_head *bh = NULL;
Jeff Mahoney24996042005-12-14 14:38:05 -05002103 int err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002105 reiserfs_write_lock(p_s_inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002107 if (p_s_inode->i_size > 0) {
2108 if ((error = grab_tail_page(p_s_inode, &page, &bh))) {
2109 // -ENOENT means we truncated past the end of the file,
2110 // and get_block_create_0 could not find a block to read in,
2111 // which is ok.
2112 if (error != -ENOENT)
2113 reiserfs_warning(p_s_inode->i_sb,
2114 "clm-6001: grab_tail_page failed %d",
2115 error);
2116 page = NULL;
2117 bh = NULL;
2118 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002121 /* so, if page != NULL, we have a buffer head for the offset at
2122 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2123 ** then we have an unformatted node. Otherwise, we have a direct item,
2124 ** and no zeroing is required on disk. We zero after the truncate,
2125 ** because the truncate might pack the item anyway
2126 ** (it will unmap bh if it packs).
2127 */
2128 /* it is enough to reserve space in transaction for 2 balancings:
2129 one for "save" link adding and another for the first
2130 cut_from_item. 1 is for update_sd */
2131 error = journal_begin(&th, p_s_inode->i_sb,
2132 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2133 if (error)
2134 goto out;
2135 reiserfs_update_inode_transaction(p_s_inode);
2136 if (update_timestamps)
2137 /* we are doing real truncate: if the system crashes before the last
2138 transaction of truncating gets committed - on reboot the file
2139 either appears truncated properly or not truncated at all */
2140 add_save_link(&th, p_s_inode, 1);
Jeff Mahoney24996042005-12-14 14:38:05 -05002141 err2 = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002142 error =
2143 journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2144 if (error)
2145 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146
Jeff Mahoney24996042005-12-14 14:38:05 -05002147 /* check reiserfs_do_truncate after ending the transaction */
2148 if (err2) {
2149 error = err2;
2150 goto out;
2151 }
2152
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002153 if (update_timestamps) {
2154 error = remove_save_link(p_s_inode, 1 /* truncate */ );
2155 if (error)
2156 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002159 if (page) {
2160 length = offset & (blocksize - 1);
2161 /* if we are not on a block boundary */
2162 if (length) {
2163 char *kaddr;
2164
2165 length = blocksize - length;
2166 kaddr = kmap_atomic(page, KM_USER0);
2167 memset(kaddr + offset, 0, length);
2168 flush_dcache_page(page);
2169 kunmap_atomic(kaddr, KM_USER0);
2170 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2171 mark_buffer_dirty(bh);
2172 }
2173 }
2174 unlock_page(page);
2175 page_cache_release(page);
2176 }
2177
2178 reiserfs_write_unlock(p_s_inode->i_sb);
2179 return 0;
2180 out:
2181 if (page) {
2182 unlock_page(page);
2183 page_cache_release(page);
2184 }
2185 reiserfs_write_unlock(p_s_inode->i_sb);
2186 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187}
2188
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002189static int map_block_for_writepage(struct inode *inode,
2190 struct buffer_head *bh_result,
2191 unsigned long block)
2192{
2193 struct reiserfs_transaction_handle th;
2194 int fs_gen;
2195 struct item_head tmp_ih;
2196 struct item_head *ih;
2197 struct buffer_head *bh;
2198 __le32 *item;
2199 struct cpu_key key;
2200 INITIALIZE_PATH(path);
2201 int pos_in_item;
2202 int jbegin_count = JOURNAL_PER_BALANCE_CNT;
Oleg Drokin7729ac52005-11-28 13:43:53 -08002203 loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002204 int retval;
2205 int use_get_block = 0;
2206 int bytes_copied = 0;
2207 int copy_size;
2208 int trans_running = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002210 /* catch places below that try to log something without starting a trans */
2211 th.t_trans_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002213 if (!buffer_uptodate(bh_result)) {
2214 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 }
2216
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002217 kmap(bh_result->b_page);
2218 start_over:
2219 reiserfs_write_lock(inode->i_sb);
2220 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002222 research:
2223 retval = search_for_position_by_key(inode->i_sb, &key, &path);
2224 if (retval != POSITION_FOUND) {
2225 use_get_block = 1;
2226 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 }
2228
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002229 bh = get_last_bh(&path);
2230 ih = get_ih(&path);
2231 item = get_item(&path);
2232 pos_in_item = path.pos_in_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002234 /* we've found an unformatted node */
2235 if (indirect_item_found(retval, ih)) {
2236 if (bytes_copied > 0) {
2237 reiserfs_warning(inode->i_sb,
2238 "clm-6002: bytes_copied %d",
2239 bytes_copied);
2240 }
2241 if (!get_block_num(item, pos_in_item)) {
2242 /* crap, we are writing to a hole */
2243 use_get_block = 1;
2244 goto out;
2245 }
2246 set_block_dev_mapped(bh_result,
2247 get_block_num(item, pos_in_item), inode);
2248 } else if (is_direct_le_ih(ih)) {
2249 char *p;
2250 p = page_address(bh_result->b_page);
2251 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2252 copy_size = ih_item_len(ih) - pos_in_item;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002254 fs_gen = get_generation(inode->i_sb);
2255 copy_item_head(&tmp_ih, ih);
2256
2257 if (!trans_running) {
2258 /* vs-3050 is gone, no need to drop the path */
2259 retval = journal_begin(&th, inode->i_sb, jbegin_count);
2260 if (retval)
2261 goto out;
2262 reiserfs_update_inode_transaction(inode);
2263 trans_running = 1;
2264 if (fs_changed(fs_gen, inode->i_sb)
2265 && item_moved(&tmp_ih, &path)) {
2266 reiserfs_restore_prepared_buffer(inode->i_sb,
2267 bh);
2268 goto research;
2269 }
2270 }
2271
2272 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2273
2274 if (fs_changed(fs_gen, inode->i_sb)
2275 && item_moved(&tmp_ih, &path)) {
2276 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2277 goto research;
2278 }
2279
2280 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2281 copy_size);
2282
2283 journal_mark_dirty(&th, inode->i_sb, bh);
2284 bytes_copied += copy_size;
2285 set_block_dev_mapped(bh_result, 0, inode);
2286
2287 /* are there still bytes left? */
2288 if (bytes_copied < bh_result->b_size &&
2289 (byte_offset + bytes_copied) < inode->i_size) {
2290 set_cpu_key_k_offset(&key,
2291 cpu_key_k_offset(&key) +
2292 copy_size);
2293 goto research;
2294 }
2295 } else {
2296 reiserfs_warning(inode->i_sb,
2297 "clm-6003: bad item inode %lu, device %s",
2298 inode->i_ino, reiserfs_bdevname(inode->i_sb));
2299 retval = -EIO;
2300 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002302 retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002304 out:
2305 pathrelse(&path);
2306 if (trans_running) {
2307 int err = journal_end(&th, inode->i_sb, jbegin_count);
2308 if (err)
2309 retval = err;
2310 trans_running = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002312 reiserfs_write_unlock(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002314 /* this is where we fill in holes in the file. */
2315 if (use_get_block) {
2316 retval = reiserfs_get_block(inode, block, bh_result,
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002317 GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002318 | GET_BLOCK_NO_DANGLE);
2319 if (!retval) {
2320 if (!buffer_mapped(bh_result)
2321 || bh_result->b_blocknr == 0) {
2322 /* get_block failed to find a mapped unformatted node. */
2323 use_get_block = 0;
2324 goto start_over;
2325 }
2326 }
2327 }
2328 kunmap(bh_result->b_page);
2329
2330 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2331 /* we've copied data from the page into the direct item, so the
2332 * buffer in the page is now clean, mark it to reflect that.
2333 */
2334 lock_buffer(bh_result);
2335 clear_buffer_dirty(bh_result);
2336 unlock_buffer(bh_result);
2337 }
2338 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339}
2340
2341/*
2342 * mason@suse.com: updated in 2.5.54 to follow the same general io
2343 * start/recovery path as __block_write_full_page, along with special
2344 * code to handle reiserfs tails.
2345 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002346static int reiserfs_write_full_page(struct page *page,
2347 struct writeback_control *wbc)
2348{
2349 struct inode *inode = page->mapping->host;
2350 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2351 int error = 0;
2352 unsigned long block;
2353 struct buffer_head *head, *bh;
2354 int partial = 0;
2355 int nr = 0;
2356 int checked = PageChecked(page);
2357 struct reiserfs_transaction_handle th;
2358 struct super_block *s = inode->i_sb;
2359 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2360 th.t_trans_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361
Chris Masone0e851c2006-02-01 03:06:49 -08002362 /* no logging allowed when nonblocking or from PF_MEMALLOC */
2363 if (checked && (current->flags & PF_MEMALLOC)) {
2364 redirty_page_for_writepage(wbc, page);
2365 unlock_page(page);
2366 return 0;
2367 }
2368
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002369 /* The page dirty bit is cleared before writepage is called, which
2370 * means we have to tell create_empty_buffers to make dirty buffers
2371 * The page really should be up to date at this point, so tossing
2372 * in the BH_Uptodate is just a sanity check.
2373 */
2374 if (!page_has_buffers(page)) {
2375 create_empty_buffers(page, s->s_blocksize,
2376 (1 << BH_Dirty) | (1 << BH_Uptodate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002378 head = page_buffers(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002380 /* last page in the file, zero out any contents past the
2381 ** last byte in the file
2382 */
2383 if (page->index >= end_index) {
2384 char *kaddr;
2385 unsigned last_offset;
2386
2387 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2388 /* no file contents in this page */
2389 if (page->index >= end_index + 1 || !last_offset) {
2390 unlock_page(page);
2391 return 0;
2392 }
2393 kaddr = kmap_atomic(page, KM_USER0);
2394 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);
2395 flush_dcache_page(page);
2396 kunmap_atomic(kaddr, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002398 bh = head;
2399 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2400 /* first map all the buffers, logging any direct items we find */
2401 do {
2402 if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
2403 (buffer_mapped(bh)
2404 && bh->b_blocknr ==
2405 0))) {
2406 /* not mapped yet, or it points to a direct item, search
2407 * the btree for the mapping info, and log any direct
2408 * items found
2409 */
2410 if ((error = map_block_for_writepage(inode, bh, block))) {
2411 goto fail;
2412 }
2413 }
2414 bh = bh->b_this_page;
2415 block++;
2416 } while (bh != head);
2417
2418 /*
2419 * we start the transaction after map_block_for_writepage,
2420 * because it can create holes in the file (an unbounded operation).
2421 * starting it here, we can make a reliable estimate for how many
2422 * blocks we're going to log
2423 */
2424 if (checked) {
2425 ClearPageChecked(page);
2426 reiserfs_write_lock(s);
2427 error = journal_begin(&th, s, bh_per_page + 1);
2428 if (error) {
2429 reiserfs_write_unlock(s);
2430 goto fail;
2431 }
2432 reiserfs_update_inode_transaction(inode);
2433 }
2434 /* now go through and lock any dirty buffers on the page */
2435 do {
2436 get_bh(bh);
2437 if (!buffer_mapped(bh))
2438 continue;
2439 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2440 continue;
2441
2442 if (checked) {
2443 reiserfs_prepare_for_journal(s, bh, 1);
2444 journal_mark_dirty(&th, s, bh);
2445 continue;
2446 }
2447 /* from this point on, we know the buffer is mapped to a
2448 * real block and not a direct item
2449 */
2450 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
2451 lock_buffer(bh);
2452 } else {
2453 if (test_set_buffer_locked(bh)) {
2454 redirty_page_for_writepage(wbc, page);
2455 continue;
2456 }
2457 }
2458 if (test_clear_buffer_dirty(bh)) {
2459 mark_buffer_async_write(bh);
2460 } else {
2461 unlock_buffer(bh);
2462 }
2463 } while ((bh = bh->b_this_page) != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464
2465 if (checked) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002466 error = journal_end(&th, s, bh_per_page + 1);
2467 reiserfs_write_unlock(s);
2468 if (error)
2469 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002471 BUG_ON(PageWriteback(page));
2472 set_page_writeback(page);
2473 unlock_page(page);
2474
2475 /*
2476 * since any buffer might be the only dirty buffer on the page,
2477 * the first submit_bh can bring the page out of writeback.
2478 * be careful with the buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 do {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002481 struct buffer_head *next = bh->b_this_page;
2482 if (buffer_async_write(bh)) {
2483 submit_bh(WRITE, bh);
2484 nr++;
2485 }
2486 put_bh(bh);
2487 bh = next;
2488 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002490 error = 0;
2491 done:
2492 if (nr == 0) {
2493 /*
2494 * if this page only had a direct item, it is very possible for
2495 * no io to be required without there being an error. Or,
2496 * someone else could have locked them and sent them down the
2497 * pipe without locking the page
2498 */
2499 bh = head;
2500 do {
2501 if (!buffer_uptodate(bh)) {
2502 partial = 1;
2503 break;
2504 }
2505 bh = bh->b_this_page;
2506 } while (bh != head);
2507 if (!partial)
2508 SetPageUptodate(page);
2509 end_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002511 return error;
2512
2513 fail:
2514 /* catches various errors, we need to make sure any valid dirty blocks
2515 * get to the media. The page is currently locked and not marked for
2516 * writeback
2517 */
2518 ClearPageUptodate(page);
2519 bh = head;
2520 do {
2521 get_bh(bh);
2522 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2523 lock_buffer(bh);
2524 mark_buffer_async_write(bh);
2525 } else {
2526 /*
2527 * clear any dirty bits that might have come from getting
2528 * attached to a dirty page
2529 */
2530 clear_buffer_dirty(bh);
2531 }
2532 bh = bh->b_this_page;
2533 } while (bh != head);
2534 SetPageError(page);
2535 BUG_ON(PageWriteback(page));
2536 set_page_writeback(page);
2537 unlock_page(page);
2538 do {
2539 struct buffer_head *next = bh->b_this_page;
2540 if (buffer_async_write(bh)) {
2541 clear_buffer_dirty(bh);
2542 submit_bh(WRITE, bh);
2543 nr++;
2544 }
2545 put_bh(bh);
2546 bh = next;
2547 } while (bh != head);
2548 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549}
2550
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002551static int reiserfs_readpage(struct file *f, struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002553 return block_read_full_page(page, reiserfs_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554}
2555
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002556static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002558 struct inode *inode = page->mapping->host;
2559 reiserfs_wait_on_write_block(inode->i_sb);
2560 return reiserfs_write_full_page(page, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561}
2562
2563static int reiserfs_prepare_write(struct file *f, struct page *page,
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002564 unsigned from, unsigned to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002566 struct inode *inode = page->mapping->host;
2567 int ret;
2568 int old_ref = 0;
2569
2570 reiserfs_wait_on_write_block(inode->i_sb);
2571 fix_tail_page_for_writing(page);
2572 if (reiserfs_transaction_running(inode->i_sb)) {
2573 struct reiserfs_transaction_handle *th;
2574 th = (struct reiserfs_transaction_handle *)current->
2575 journal_info;
2576 BUG_ON(!th->t_refcount);
2577 BUG_ON(!th->t_trans_id);
2578 old_ref = th->t_refcount;
2579 th->t_refcount++;
2580 }
2581
2582 ret = block_prepare_write(page, from, to, reiserfs_get_block);
2583 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2584 struct reiserfs_transaction_handle *th = current->journal_info;
2585 /* this gets a little ugly. If reiserfs_get_block returned an
2586 * error and left a transacstion running, we've got to close it,
2587 * and we've got to free handle if it was a persistent transaction.
2588 *
2589 * But, if we had nested into an existing transaction, we need
2590 * to just drop the ref count on the handle.
2591 *
2592 * If old_ref == 0, the transaction is from reiserfs_get_block,
2593 * and it was a persistent trans. Otherwise, it was nested above.
2594 */
2595 if (th->t_refcount > old_ref) {
2596 if (old_ref)
2597 th->t_refcount--;
2598 else {
2599 int err;
2600 reiserfs_write_lock(inode->i_sb);
2601 err = reiserfs_end_persistent_transaction(th);
2602 reiserfs_write_unlock(inode->i_sb);
2603 if (err)
2604 ret = err;
2605 }
2606 }
2607 }
2608 return ret;
2609
2610}
2611
2612static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2613{
2614 return generic_block_bmap(as, block, reiserfs_bmap);
2615}
2616
2617static int reiserfs_commit_write(struct file *f, struct page *page,
2618 unsigned from, unsigned to)
2619{
2620 struct inode *inode = page->mapping->host;
2621 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2622 int ret = 0;
2623 int update_sd = 0;
2624 struct reiserfs_transaction_handle *th = NULL;
2625
2626 reiserfs_wait_on_write_block(inode->i_sb);
2627 if (reiserfs_transaction_running(inode->i_sb)) {
2628 th = current->journal_info;
2629 }
2630 reiserfs_commit_page(inode, page, from, to);
2631
2632 /* generic_commit_write does this for us, but does not update the
2633 ** transaction tracking stuff when the size changes. So, we have
2634 ** to do the i_size updates here.
2635 */
2636 if (pos > inode->i_size) {
2637 struct reiserfs_transaction_handle myth;
2638 reiserfs_write_lock(inode->i_sb);
2639 /* If the file have grown beyond the border where it
2640 can have a tail, unmark it as needing a tail
2641 packing */
2642 if ((have_large_tails(inode->i_sb)
2643 && inode->i_size > i_block_size(inode) * 4)
2644 || (have_small_tails(inode->i_sb)
2645 && inode->i_size > i_block_size(inode)))
2646 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2647
2648 ret = journal_begin(&myth, inode->i_sb, 1);
2649 if (ret) {
2650 reiserfs_write_unlock(inode->i_sb);
2651 goto journal_error;
2652 }
2653 reiserfs_update_inode_transaction(inode);
2654 inode->i_size = pos;
Chris Mason9f037832005-09-13 01:25:17 -07002655 /*
2656 * this will just nest into our transaction. It's important
2657 * to use mark_inode_dirty so the inode gets pushed around on the
2658 * dirty lists, and so that O_SYNC works as expected
2659 */
2660 mark_inode_dirty(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002661 reiserfs_update_sd(&myth, inode);
2662 update_sd = 1;
2663 ret = journal_end(&myth, inode->i_sb, 1);
2664 reiserfs_write_unlock(inode->i_sb);
2665 if (ret)
2666 goto journal_error;
2667 }
2668 if (th) {
2669 reiserfs_write_lock(inode->i_sb);
2670 if (!update_sd)
Chris Mason9f037832005-09-13 01:25:17 -07002671 mark_inode_dirty(inode);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002672 ret = reiserfs_end_persistent_transaction(th);
2673 reiserfs_write_unlock(inode->i_sb);
2674 if (ret)
2675 goto out;
2676 }
2677
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002678 out:
2679 return ret;
2680
2681 journal_error:
2682 if (th) {
2683 reiserfs_write_lock(inode->i_sb);
2684 if (!update_sd)
2685 reiserfs_update_sd(th, inode);
2686 ret = reiserfs_end_persistent_transaction(th);
2687 reiserfs_write_unlock(inode->i_sb);
2688 }
2689
2690 return ret;
2691}
2692
2693void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2694{
2695 if (reiserfs_attrs(inode->i_sb)) {
2696 if (sd_attrs & REISERFS_SYNC_FL)
2697 inode->i_flags |= S_SYNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002699 inode->i_flags &= ~S_SYNC;
2700 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2701 inode->i_flags |= S_IMMUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002703 inode->i_flags &= ~S_IMMUTABLE;
2704 if (sd_attrs & REISERFS_APPEND_FL)
2705 inode->i_flags |= S_APPEND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002707 inode->i_flags &= ~S_APPEND;
2708 if (sd_attrs & REISERFS_NOATIME_FL)
2709 inode->i_flags |= S_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 else
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002711 inode->i_flags &= ~S_NOATIME;
2712 if (sd_attrs & REISERFS_NOTAIL_FL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 REISERFS_I(inode)->i_flags |= i_nopack_mask;
2714 else
2715 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2716 }
2717}
2718
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002719void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002721 if (reiserfs_attrs(inode->i_sb)) {
2722 if (inode->i_flags & S_IMMUTABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 *sd_attrs |= REISERFS_IMMUTABLE_FL;
2724 else
2725 *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002726 if (inode->i_flags & S_SYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727 *sd_attrs |= REISERFS_SYNC_FL;
2728 else
2729 *sd_attrs &= ~REISERFS_SYNC_FL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002730 if (inode->i_flags & S_NOATIME)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 *sd_attrs |= REISERFS_NOATIME_FL;
2732 else
2733 *sd_attrs &= ~REISERFS_NOATIME_FL;
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002734 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 *sd_attrs |= REISERFS_NOTAIL_FL;
2736 else
2737 *sd_attrs &= ~REISERFS_NOTAIL_FL;
2738 }
2739}
2740
2741/* decide if this buffer needs to stay around for data logging or ordered
2742** write purposes
2743*/
2744static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2745{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002746 int ret = 1;
2747 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748
Chris Masond62b1b82006-02-01 03:06:47 -08002749 lock_buffer(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002750 spin_lock(&j->j_dirty_buffers_lock);
2751 if (!buffer_mapped(bh)) {
2752 goto free_jh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753 }
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002754 /* the page is locked, and the only places that log a data buffer
2755 * also lock the page.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002757 if (reiserfs_file_data_log(inode)) {
2758 /*
2759 * very conservative, leave the buffer pinned if
2760 * anyone might need it.
2761 */
2762 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2763 ret = 0;
2764 }
Chris Masond62b1b82006-02-01 03:06:47 -08002765 } else if (buffer_dirty(bh)) {
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002766 struct reiserfs_journal_list *jl;
2767 struct reiserfs_jh *jh = bh->b_private;
2768
2769 /* why is this safe?
2770 * reiserfs_setattr updates i_size in the on disk
2771 * stat data before allowing vmtruncate to be called.
2772 *
2773 * If buffer was put onto the ordered list for this
2774 * transaction, we know for sure either this transaction
2775 * or an older one already has updated i_size on disk,
2776 * and this ordered data won't be referenced in the file
2777 * if we crash.
2778 *
2779 * if the buffer was put onto the ordered list for an older
2780 * transaction, we need to leave it around
2781 */
2782 if (jh && (jl = jh->jl)
2783 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2784 ret = 0;
2785 }
2786 free_jh:
2787 if (ret && bh->b_private) {
2788 reiserfs_free_jh(bh);
2789 }
2790 spin_unlock(&j->j_dirty_buffers_lock);
Chris Masond62b1b82006-02-01 03:06:47 -08002791 unlock_buffer(bh);
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002792 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793}
2794
2795/* clm -- taken from fs/buffer.c:block_invalidate_page */
2796static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
2797{
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002798 struct buffer_head *head, *bh, *next;
2799 struct inode *inode = page->mapping->host;
2800 unsigned int curr_off = 0;
2801 int ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002803 BUG_ON(!PageLocked(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002805 if (offset == 0)
2806 ClearPageChecked(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002808 if (!page_has_buffers(page))
2809 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002811 head = page_buffers(page);
2812 bh = head;
2813 do {
2814 unsigned int next_off = curr_off + bh->b_size;
2815 next = bh->b_this_page;
2816
2817 /*
2818 * is this block fully invalidated?
2819 */
2820 if (offset <= curr_off) {
2821 if (invalidatepage_can_drop(inode, bh))
2822 reiserfs_unmap_buffer(bh);
2823 else
2824 ret = 0;
2825 }
2826 curr_off = next_off;
2827 bh = next;
2828 } while (bh != head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829
2830 /*
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002831 * We release buffers only if the entire page is being invalidated.
2832 * The get_block cached value has been unconditionally invalidated,
2833 * so real IO is not possible anymore.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 */
Linus Torvaldsbd4c6252005-07-12 20:21:28 -07002835 if (!offset && ret)
2836 ret = try_to_release_page(page, 0);
2837 out:
2838 return ret;
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
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998struct 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};