aboutsummaryrefslogtreecommitdiffstats
path: root/fs/reiserfs/inode.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@g5.osdl.org>2005-07-12 23:21:28 -0400
committerLinus Torvalds <torvalds@g5.osdl.org>2005-07-12 23:21:28 -0400
commitbd4c625c061c2a38568d0add3478f59172455159 (patch)
tree1c44a17c55bce2ee7ad5ea3d15a208ecc0955f74 /fs/reiserfs/inode.c
parent7fa94c8868edfef8cb6a201fcc9a5078b7b961da (diff)
reiserfs: run scripts/Lindent on reiserfs code
This was a pure indentation change, using: scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h to make reiserfs match the regular Linux indentation style. As Jeff Mahoney <jeffm@suse.com> writes: The ReiserFS code is a mix of a number of different coding styles, sometimes different even from line-to-line. Since the code has been relatively stable for quite some time and there are few outstanding patches to be applied, it is time to reformat the code to conform to the Linux style standard outlined in Documentation/CodingStyle. This patch contains the result of running scripts/Lindent against fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the code can be made to look better, but I'd rather keep those patches separate so that there isn't a subtle by-hand hand accident in the middle of a huge patch. To be clear: This patch is reformatting *only*. A number of patches may follow that continue to make the code more consistent with the Linux coding style. Hans wasn't particularly enthusiastic about these patches, but said he wouldn't really oppose them either. Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Diffstat (limited to 'fs/reiserfs/inode.c')
-rw-r--r--fs/reiserfs/inode.c4915
1 files changed, 2521 insertions, 2394 deletions
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 289d864fe731..1aaf2c7d44e6 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -18,107 +18,109 @@
18#include <linux/writeback.h> 18#include <linux/writeback.h>
19#include <linux/quotaops.h> 19#include <linux/quotaops.h>
20 20
21extern int reiserfs_default_io_size; /* default io size devuned in super.c */ 21extern int reiserfs_default_io_size; /* default io size devuned in super.c */
22 22
23static int reiserfs_commit_write(struct file *f, struct page *page, 23static int reiserfs_commit_write(struct file *f, struct page *page,
24 unsigned from, unsigned to); 24 unsigned from, unsigned to);
25static int reiserfs_prepare_write(struct file *f, struct page *page, 25static int reiserfs_prepare_write(struct file *f, struct page *page,
26 unsigned from, unsigned to); 26 unsigned from, unsigned to);
27 27
28void reiserfs_delete_inode (struct inode * inode) 28void reiserfs_delete_inode(struct inode *inode)
29{ 29{
30 /* We need blocks for transaction + (user+group) quota update (possibly delete) */ 30 /* We need blocks for transaction + (user+group) quota update (possibly delete) */
31 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb); 31 int jbegin_count =
32 struct reiserfs_transaction_handle th ; 32 JOURNAL_PER_BALANCE_CNT * 2 +
33 33 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
34 reiserfs_write_lock(inode->i_sb); 34 struct reiserfs_transaction_handle th;
35 35
36 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */ 36 reiserfs_write_lock(inode->i_sb);
37 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
38 down (&inode->i_sem);
39 37
40 reiserfs_delete_xattrs (inode); 38 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
39 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
40 down(&inode->i_sem);
41 41
42 if (journal_begin(&th, inode->i_sb, jbegin_count)) { 42 reiserfs_delete_xattrs(inode);
43 up (&inode->i_sem);
44 goto out;
45 }
46 reiserfs_update_inode_transaction(inode) ;
47 43
48 if (reiserfs_delete_object (&th, inode)) { 44 if (journal_begin(&th, inode->i_sb, jbegin_count)) {
49 up (&inode->i_sem); 45 up(&inode->i_sem);
50 goto out; 46 goto out;
51 } 47 }
48 reiserfs_update_inode_transaction(inode);
52 49
53 /* Do quota update inside a transaction for journaled quotas. We must do that 50 if (reiserfs_delete_object(&th, inode)) {
54 * after delete_object so that quota updates go into the same transaction as 51 up(&inode->i_sem);
55 * stat data deletion */ 52 goto out;
56 DQUOT_FREE_INODE(inode); 53 }
57 54
58 if (journal_end(&th, inode->i_sb, jbegin_count)) { 55 /* Do quota update inside a transaction for journaled quotas. We must do that
59 up (&inode->i_sem); 56 * after delete_object so that quota updates go into the same transaction as
60 goto out; 57 * stat data deletion */
61 } 58 DQUOT_FREE_INODE(inode);
59
60 if (journal_end(&th, inode->i_sb, jbegin_count)) {
61 up(&inode->i_sem);
62 goto out;
63 }
62 64
63 up (&inode->i_sem); 65 up(&inode->i_sem);
64 66
65 /* all items of file are deleted, so we can remove "save" link */ 67 /* all items of file are deleted, so we can remove "save" link */
66 remove_save_link (inode, 0/* not truncate */); /* we can't do anything 68 remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything
67 * about an error here */ 69 * about an error here */
68 } else { 70 } else {
69 /* no object items are in the tree */ 71 /* no object items are in the tree */
70 ; 72 ;
71 } 73 }
72out: 74 out:
73 clear_inode (inode); /* note this must go after the journal_end to prevent deadlock */ 75 clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */
74 inode->i_blocks = 0; 76 inode->i_blocks = 0;
75 reiserfs_write_unlock(inode->i_sb); 77 reiserfs_write_unlock(inode->i_sb);
76} 78}
77 79
78static void _make_cpu_key (struct cpu_key * key, int version, __u32 dirid, __u32 objectid, 80static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
79 loff_t offset, int type, int length ) 81 __u32 objectid, loff_t offset, int type, int length)
80{ 82{
81 key->version = version; 83 key->version = version;
82 84
83 key->on_disk_key.k_dir_id = dirid; 85 key->on_disk_key.k_dir_id = dirid;
84 key->on_disk_key.k_objectid = objectid; 86 key->on_disk_key.k_objectid = objectid;
85 set_cpu_key_k_offset (key, offset); 87 set_cpu_key_k_offset(key, offset);
86 set_cpu_key_k_type (key, type); 88 set_cpu_key_k_type(key, type);
87 key->key_length = length; 89 key->key_length = length;
88} 90}
89 91
90
91/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set 92/* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set
92 offset and type of key */ 93 offset and type of key */
93void make_cpu_key (struct cpu_key * key, struct inode * inode, loff_t offset, 94void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
94 int type, int length ) 95 int type, int length)
95{ 96{
96 _make_cpu_key (key, get_inode_item_key_version (inode), le32_to_cpu (INODE_PKEY (inode)->k_dir_id), 97 _make_cpu_key(key, get_inode_item_key_version(inode),
97 le32_to_cpu (INODE_PKEY (inode)->k_objectid), 98 le32_to_cpu(INODE_PKEY(inode)->k_dir_id),
98 offset, type, length); 99 le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,
100 length);
99} 101}
100 102
101
102// 103//
103// when key is 0, do not set version and short key 104// when key is 0, do not set version and short key
104// 105//
105inline void make_le_item_head (struct item_head * ih, const struct cpu_key * key, 106inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
106 int version, 107 int version,
107 loff_t offset, int type, int length, 108 loff_t offset, int type, int length,
108 int entry_count/*or ih_free_space*/) 109 int entry_count /*or ih_free_space */ )
109{ 110{
110 if (key) { 111 if (key) {
111 ih->ih_key.k_dir_id = cpu_to_le32 (key->on_disk_key.k_dir_id); 112 ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);
112 ih->ih_key.k_objectid = cpu_to_le32 (key->on_disk_key.k_objectid); 113 ih->ih_key.k_objectid =
113 } 114 cpu_to_le32(key->on_disk_key.k_objectid);
114 put_ih_version( ih, version ); 115 }
115 set_le_ih_k_offset (ih, offset); 116 put_ih_version(ih, version);
116 set_le_ih_k_type (ih, type); 117 set_le_ih_k_offset(ih, offset);
117 put_ih_item_len( ih, length ); 118 set_le_ih_k_type(ih, type);
118 /* set_ih_free_space (ih, 0);*/ 119 put_ih_item_len(ih, length);
119 // for directory items it is entry count, for directs and stat 120 /* set_ih_free_space (ih, 0); */
120 // datas - 0xffff, for indirects - 0 121 // for directory items it is entry count, for directs and stat
121 put_ih_entry_count( ih, entry_count ); 122 // datas - 0xffff, for indirects - 0
123 put_ih_entry_count(ih, entry_count);
122} 124}
123 125
124// 126//
@@ -153,84 +155,84 @@ inline void make_le_item_head (struct item_head * ih, const struct cpu_key * key
153** to be unmapped, so that block_prepare_write will correctly call 155** to be unmapped, so that block_prepare_write will correctly call
154** reiserfs_get_block to convert the tail into an unformatted node 156** reiserfs_get_block to convert the tail into an unformatted node
155*/ 157*/
156static inline void fix_tail_page_for_writing(struct page *page) { 158static inline void fix_tail_page_for_writing(struct page *page)
157 struct buffer_head *head, *next, *bh ; 159{
158 160 struct buffer_head *head, *next, *bh;
159 if (page && page_has_buffers(page)) { 161
160 head = page_buffers(page) ; 162 if (page && page_has_buffers(page)) {
161 bh = head ; 163 head = page_buffers(page);
162 do { 164 bh = head;
163 next = bh->b_this_page ; 165 do {
164 if (buffer_mapped(bh) && bh->b_blocknr == 0) { 166 next = bh->b_this_page;
165 reiserfs_unmap_buffer(bh) ; 167 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
166 } 168 reiserfs_unmap_buffer(bh);
167 bh = next ; 169 }
168 } while (bh != head) ; 170 bh = next;
169 } 171 } while (bh != head);
172 }
170} 173}
171 174
172/* reiserfs_get_block does not need to allocate a block only if it has been 175/* reiserfs_get_block does not need to allocate a block only if it has been
173 done already or non-hole position has been found in the indirect item */ 176 done already or non-hole position has been found in the indirect item */
174static inline int allocation_needed (int retval, b_blocknr_t allocated, 177static inline int allocation_needed(int retval, b_blocknr_t allocated,
175 struct item_head * ih, 178 struct item_head *ih,
176 __le32 * item, int pos_in_item) 179 __le32 * item, int pos_in_item)
177{ 180{
178 if (allocated) 181 if (allocated)
179 return 0; 182 return 0;
180 if (retval == POSITION_FOUND && is_indirect_le_ih (ih) && 183 if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
181 get_block_num(item, pos_in_item)) 184 get_block_num(item, pos_in_item))
182 return 0; 185 return 0;
183 return 1; 186 return 1;
184} 187}
185 188
186static inline int indirect_item_found (int retval, struct item_head * ih) 189static inline int indirect_item_found(int retval, struct item_head *ih)
187{ 190{
188 return (retval == POSITION_FOUND) && is_indirect_le_ih (ih); 191 return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
189} 192}
190 193
191 194static inline void set_block_dev_mapped(struct buffer_head *bh,
192static inline void set_block_dev_mapped (struct buffer_head * bh, 195 b_blocknr_t block, struct inode *inode)
193 b_blocknr_t block, struct inode * inode)
194{ 196{
195 map_bh(bh, inode->i_sb, block); 197 map_bh(bh, inode->i_sb, block);
196} 198}
197 199
198
199// 200//
200// files which were created in the earlier version can not be longer, 201// files which were created in the earlier version can not be longer,
201// than 2 gb 202// than 2 gb
202// 203//
203static int file_capable (struct inode * inode, long block) 204static int file_capable(struct inode *inode, long block)
204{ 205{
205 if (get_inode_item_key_version (inode) != KEY_FORMAT_3_5 || // it is new file. 206 if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.
206 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb 207 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb
207 return 1; 208 return 1;
208 209
209 return 0; 210 return 0;
210} 211}
211 212
212/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th, 213/*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,
213 struct inode *inode, struct path *path) { 214 struct inode *inode, struct path *path)
214 struct super_block *s = th->t_super ; 215{
215 int len = th->t_blocks_allocated ; 216 struct super_block *s = th->t_super;
216 int err; 217 int len = th->t_blocks_allocated;
217 218 int err;
218 BUG_ON (!th->t_trans_id); 219
219 BUG_ON (!th->t_refcount); 220 BUG_ON(!th->t_trans_id);
220 221 BUG_ON(!th->t_refcount);
221 /* we cannot restart while nested */ 222
222 if (th->t_refcount > 1) { 223 /* we cannot restart while nested */
223 return 0 ; 224 if (th->t_refcount > 1) {
224 } 225 return 0;
225 pathrelse(path) ; 226 }
226 reiserfs_update_sd(th, inode) ; 227 pathrelse(path);
227 err = journal_end(th, s, len) ; 228 reiserfs_update_sd(th, inode);
228 if (!err) { 229 err = journal_end(th, s, len);
229 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6) ; 230 if (!err) {
230 if (!err) 231 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
231 reiserfs_update_inode_transaction(inode) ; 232 if (!err)
232 } 233 reiserfs_update_inode_transaction(inode);
233 return err; 234 }
235 return err;
234} 236}
235 237
236// it is called by get_block when create == 0. Returns block number 238// it is called by get_block when create == 0. Returns block number
@@ -241,190 +243,192 @@ static int file_capable (struct inode * inode, long block)
241// Please improve the english/clarity in the comment above, as it is 243// Please improve the english/clarity in the comment above, as it is
242// hard to understand. 244// hard to understand.
243 245
244static int _get_block_create_0 (struct inode * inode, long block, 246static int _get_block_create_0(struct inode *inode, long block,
245 struct buffer_head * bh_result, 247 struct buffer_head *bh_result, int args)
246 int args)
247{ 248{
248 INITIALIZE_PATH (path); 249 INITIALIZE_PATH(path);
249 struct cpu_key key; 250 struct cpu_key key;
250 struct buffer_head * bh; 251 struct buffer_head *bh;
251 struct item_head * ih, tmp_ih; 252 struct item_head *ih, tmp_ih;
252 int fs_gen ; 253 int fs_gen;
253 int blocknr; 254 int blocknr;
254 char * p = NULL; 255 char *p = NULL;
255 int chars; 256 int chars;
256 int ret ; 257 int ret;
257 int result ; 258 int result;
258 int done = 0 ; 259 int done = 0;
259 unsigned long offset ; 260 unsigned long offset;
260 261
261 // prepare the key to look for the 'block'-th block of file 262 // prepare the key to look for the 'block'-th block of file
262 make_cpu_key (&key, inode, 263 make_cpu_key(&key, inode,
263 (loff_t)block * inode->i_sb->s_blocksize + 1, TYPE_ANY, 3); 264 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
264 265 3);
265research: 266
266 result = search_for_position_by_key (inode->i_sb, &key, &path) ; 267 research:
267 if (result != POSITION_FOUND) { 268 result = search_for_position_by_key(inode->i_sb, &key, &path);
268 pathrelse (&path); 269 if (result != POSITION_FOUND) {
269 if (p) 270 pathrelse(&path);
270 kunmap(bh_result->b_page) ; 271 if (p)
271 if (result == IO_ERROR) 272 kunmap(bh_result->b_page);
272 return -EIO; 273 if (result == IO_ERROR)
273 // We do not return -ENOENT if there is a hole but page is uptodate, because it means 274 return -EIO;
274 // That there is some MMAPED data associated with it that is yet to be written to disk. 275 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
275 if ((args & GET_BLOCK_NO_HOLE) && !PageUptodate(bh_result->b_page) ) { 276 // That there is some MMAPED data associated with it that is yet to be written to disk.
276 return -ENOENT ; 277 if ((args & GET_BLOCK_NO_HOLE)
277 } 278 && !PageUptodate(bh_result->b_page)) {
278 return 0 ; 279 return -ENOENT;
279 } 280 }
280 281 return 0;
281 // 282 }
282 bh = get_last_bh (&path); 283 //
283 ih = get_ih (&path); 284 bh = get_last_bh(&path);
284 if (is_indirect_le_ih (ih)) { 285 ih = get_ih(&path);
285 __le32 * ind_item = (__le32 *)B_I_PITEM (bh, ih); 286 if (is_indirect_le_ih(ih)) {
286 287 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
287 /* FIXME: here we could cache indirect item or part of it in 288
288 the inode to avoid search_by_key in case of subsequent 289 /* FIXME: here we could cache indirect item or part of it in
289 access to file */ 290 the inode to avoid search_by_key in case of subsequent
290 blocknr = get_block_num(ind_item, path.pos_in_item) ; 291 access to file */
291 ret = 0 ; 292 blocknr = get_block_num(ind_item, path.pos_in_item);
292 if (blocknr) { 293 ret = 0;
293 map_bh(bh_result, inode->i_sb, blocknr); 294 if (blocknr) {
294 if (path.pos_in_item == ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) { 295 map_bh(bh_result, inode->i_sb, blocknr);
295 set_buffer_boundary(bh_result); 296 if (path.pos_in_item ==
296 } 297 ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
297 } else 298 set_buffer_boundary(bh_result);
298 // We do not return -ENOENT if there is a hole but page is uptodate, because it means 299 }
299 // That there is some MMAPED data associated with it that is yet to be written to disk. 300 } else
300 if ((args & GET_BLOCK_NO_HOLE) && !PageUptodate(bh_result->b_page) ) { 301 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
301 ret = -ENOENT ; 302 // That there is some MMAPED data associated with it that is yet to be written to disk.
302 } 303 if ((args & GET_BLOCK_NO_HOLE)
303 304 && !PageUptodate(bh_result->b_page)) {
304 pathrelse (&path); 305 ret = -ENOENT;
305 if (p) 306 }
306 kunmap(bh_result->b_page) ; 307
307 return ret ; 308 pathrelse(&path);
308 } 309 if (p)
309 310 kunmap(bh_result->b_page);
310 // requested data are in direct item(s) 311 return ret;
311 if (!(args & GET_BLOCK_READ_DIRECT)) { 312 }
312 // we are called by bmap. FIXME: we can not map block of file 313 // requested data are in direct item(s)
313 // when it is stored in direct item(s) 314 if (!(args & GET_BLOCK_READ_DIRECT)) {
314 pathrelse (&path); 315 // we are called by bmap. FIXME: we can not map block of file
315 if (p) 316 // when it is stored in direct item(s)
316 kunmap(bh_result->b_page) ; 317 pathrelse(&path);
317 return -ENOENT; 318 if (p)
318 } 319 kunmap(bh_result->b_page);
319 320 return -ENOENT;
320 /* if we've got a direct item, and the buffer or page was uptodate, 321 }
321 ** we don't want to pull data off disk again. skip to the 322
322 ** end, where we map the buffer and return 323 /* if we've got a direct item, and the buffer or page was uptodate,
323 */ 324 ** we don't want to pull data off disk again. skip to the
324 if (buffer_uptodate(bh_result)) { 325 ** end, where we map the buffer and return
325 goto finished ; 326 */
326 } else 327 if (buffer_uptodate(bh_result)) {
327 /* 328 goto finished;
328 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date 329 } else
329 ** pages without any buffers. If the page is up to date, we don't want 330 /*
330 ** read old data off disk. Set the up to date bit on the buffer instead 331 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date
331 ** and jump to the end 332 ** pages without any buffers. If the page is up to date, we don't want
332 */ 333 ** read old data off disk. Set the up to date bit on the buffer instead
333 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) { 334 ** and jump to the end
335 */
336 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
334 set_buffer_uptodate(bh_result); 337 set_buffer_uptodate(bh_result);
335 goto finished ; 338 goto finished;
336 } 339 }
337 340 // read file tail into part of page
338 // read file tail into part of page 341 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
339 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1) ; 342 fs_gen = get_generation(inode->i_sb);
340 fs_gen = get_generation(inode->i_sb) ; 343 copy_item_head(&tmp_ih, ih);
341 copy_item_head (&tmp_ih, ih); 344
342 345 /* we only want to kmap if we are reading the tail into the page.
343 /* we only want to kmap if we are reading the tail into the page. 346 ** this is not the common case, so we don't kmap until we are
344 ** this is not the common case, so we don't kmap until we are 347 ** sure we need to. But, this means the item might move if
345 ** sure we need to. But, this means the item might move if 348 ** kmap schedules
346 ** kmap schedules 349 */
347 */ 350 if (!p) {
348 if (!p) { 351 p = (char *)kmap(bh_result->b_page);
349 p = (char *)kmap(bh_result->b_page) ; 352 if (fs_changed(fs_gen, inode->i_sb)
350 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) { 353 && item_moved(&tmp_ih, &path)) {
351 goto research; 354 goto research;
352 } 355 }
353 } 356 }
354 p += offset ; 357 p += offset;
355 memset (p, 0, inode->i_sb->s_blocksize); 358 memset(p, 0, inode->i_sb->s_blocksize);
356 do { 359 do {
357 if (!is_direct_le_ih (ih)) { 360 if (!is_direct_le_ih(ih)) {
358 BUG (); 361 BUG();
359 } 362 }
360 /* make sure we don't read more bytes than actually exist in 363 /* make sure we don't read more bytes than actually exist in
361 ** the file. This can happen in odd cases where i_size isn't 364 ** the file. This can happen in odd cases where i_size isn't
362 ** correct, and when direct item padding results in a few 365 ** correct, and when direct item padding results in a few
363 ** extra bytes at the end of the direct item 366 ** extra bytes at the end of the direct item
364 */ 367 */
365 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size) 368 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
366 break ; 369 break;
367 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) { 370 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
368 chars = inode->i_size - (le_ih_k_offset(ih) - 1) - path.pos_in_item; 371 chars =
369 done = 1 ; 372 inode->i_size - (le_ih_k_offset(ih) - 1) -
370 } else { 373 path.pos_in_item;
371 chars = ih_item_len(ih) - path.pos_in_item; 374 done = 1;
372 } 375 } else {
373 memcpy (p, B_I_PITEM (bh, ih) + path.pos_in_item, chars); 376 chars = ih_item_len(ih) - path.pos_in_item;
374 377 }
375 if (done) 378 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
376 break ; 379
377 380 if (done)
378 p += chars; 381 break;
379 382
380 if (PATH_LAST_POSITION (&path) != (B_NR_ITEMS (bh) - 1)) 383 p += chars;
381 // we done, if read direct item is not the last item of 384
382 // node FIXME: we could try to check right delimiting key 385 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
383 // to see whether direct item continues in the right 386 // we done, if read direct item is not the last item of
384 // neighbor or rely on i_size 387 // node FIXME: we could try to check right delimiting key
385 break; 388 // to see whether direct item continues in the right
386 389 // neighbor or rely on i_size
387 // update key to look for the next piece 390 break;
388 set_cpu_key_k_offset (&key, cpu_key_k_offset (&key) + chars); 391
389 result = search_for_position_by_key (inode->i_sb, &key, &path); 392 // update key to look for the next piece
390 if (result != POSITION_FOUND) 393 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
391 // i/o error most likely 394 result = search_for_position_by_key(inode->i_sb, &key, &path);
392 break; 395 if (result != POSITION_FOUND)
393 bh = get_last_bh (&path); 396 // i/o error most likely
394 ih = get_ih (&path); 397 break;
395 } while (1); 398 bh = get_last_bh(&path);
396 399 ih = get_ih(&path);
397 flush_dcache_page(bh_result->b_page) ; 400 } while (1);
398 kunmap(bh_result->b_page) ; 401
399 402 flush_dcache_page(bh_result->b_page);
400finished: 403 kunmap(bh_result->b_page);
401 pathrelse (&path); 404
402 405 finished:
403 if (result == IO_ERROR) 406 pathrelse(&path);
404 return -EIO; 407
405 408 if (result == IO_ERROR)
406 /* this buffer has valid data, but isn't valid for io. mapping it to 409 return -EIO;
407 * block #0 tells the rest of reiserfs it just has a tail in it
408 */
409 map_bh(bh_result, inode->i_sb, 0);
410 set_buffer_uptodate (bh_result);
411 return 0;
412}
413 410
411 /* this buffer has valid data, but isn't valid for io. mapping it to
412 * block #0 tells the rest of reiserfs it just has a tail in it
413 */
414 map_bh(bh_result, inode->i_sb, 0);
415 set_buffer_uptodate(bh_result);
416 return 0;
417}
414 418
415// this is called to create file map. So, _get_block_create_0 will not 419// this is called to create file map. So, _get_block_create_0 will not
416// read direct item 420// read direct item
417static int reiserfs_bmap (struct inode * inode, sector_t block, 421static int reiserfs_bmap(struct inode *inode, sector_t block,
418 struct buffer_head * bh_result, int create) 422 struct buffer_head *bh_result, int create)
419{ 423{
420 if (!file_capable (inode, block)) 424 if (!file_capable(inode, block))
421 return -EFBIG; 425 return -EFBIG;
422 426
423 reiserfs_write_lock(inode->i_sb); 427 reiserfs_write_lock(inode->i_sb);
424 /* do not read the direct item */ 428 /* do not read the direct item */
425 _get_block_create_0 (inode, block, bh_result, 0) ; 429 _get_block_create_0(inode, block, bh_result, 0);
426 reiserfs_write_unlock(inode->i_sb); 430 reiserfs_write_unlock(inode->i_sb);
427 return 0; 431 return 0;
428} 432}
429 433
430/* special version of get_block that is only used by grab_tail_page right 434/* special version of get_block that is only used by grab_tail_page right
@@ -444,9 +448,11 @@ static int reiserfs_bmap (struct inode * inode, sector_t block,
444** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block, 448** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
445** don't use this function. 449** don't use this function.
446*/ 450*/
447static int reiserfs_get_block_create_0 (struct inode * inode, sector_t block, 451static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
448 struct buffer_head * bh_result, int create) { 452 struct buffer_head *bh_result,
449 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE) ; 453 int create)
454{
455 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
450} 456}
451 457
452/* This is special helper for reiserfs_get_block in case we are executing 458/* This is special helper for reiserfs_get_block in case we are executing
@@ -457,43 +463,42 @@ static int reiserfs_get_blocks_direct_io(struct inode *inode,
457 struct buffer_head *bh_result, 463 struct buffer_head *bh_result,
458 int create) 464 int create)
459{ 465{
460 int ret ; 466 int ret;
461 467
462 bh_result->b_page = NULL; 468 bh_result->b_page = NULL;
463
464 /* We set the b_size before reiserfs_get_block call since it is
465 referenced in convert_tail_for_hole() that may be called from
466 reiserfs_get_block() */
467 bh_result->b_size = (1 << inode->i_blkbits);
468
469 ret = reiserfs_get_block(inode, iblock, bh_result,
470 create | GET_BLOCK_NO_DANGLE) ;
471 if (ret)
472 goto out;
473
474 /* don't allow direct io onto tail pages */
475 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
476 /* make sure future calls to the direct io funcs for this offset
477 ** in the file fail by unmapping the buffer
478 */
479 clear_buffer_mapped(bh_result);
480 ret = -EINVAL ;
481 }
482 /* Possible unpacked tail. Flush the data before pages have
483 disappeared */
484 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
485 int err;
486 lock_kernel();
487 err = reiserfs_commit_for_inode(inode);
488 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
489 unlock_kernel();
490 if (err < 0)
491 ret = err;
492 }
493out:
494 return ret ;
495}
496 469
470 /* We set the b_size before reiserfs_get_block call since it is
471 referenced in convert_tail_for_hole() that may be called from
472 reiserfs_get_block() */
473 bh_result->b_size = (1 << inode->i_blkbits);
474
475 ret = reiserfs_get_block(inode, iblock, bh_result,
476 create | GET_BLOCK_NO_DANGLE);
477 if (ret)
478 goto out;
479
480 /* don't allow direct io onto tail pages */
481 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
482 /* make sure future calls to the direct io funcs for this offset
483 ** in the file fail by unmapping the buffer
484 */
485 clear_buffer_mapped(bh_result);
486 ret = -EINVAL;
487 }
488 /* Possible unpacked tail. Flush the data before pages have
489 disappeared */
490 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
491 int err;
492 lock_kernel();
493 err = reiserfs_commit_for_inode(inode);
494 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
495 unlock_kernel();
496 if (err < 0)
497 ret = err;
498 }
499 out:
500 return ret;
501}
497 502
498/* 503/*
499** helper function for when reiserfs_get_block is called for a hole 504** helper function for when reiserfs_get_block is called for a hole
@@ -505,490 +510,547 @@ out:
505** you should not be in a transaction, or have any paths held when you 510** you should not be in a transaction, or have any paths held when you
506** call this. 511** call this.
507*/ 512*/
508static int convert_tail_for_hole(struct inode *inode, 513static int convert_tail_for_hole(struct inode *inode,
509 struct buffer_head *bh_result, 514 struct buffer_head *bh_result,
510 loff_t tail_offset) { 515 loff_t tail_offset)
511 unsigned long index ; 516{
512 unsigned long tail_end ; 517 unsigned long index;
513 unsigned long tail_start ; 518 unsigned long tail_end;
514 struct page * tail_page ; 519 unsigned long tail_start;
515 struct page * hole_page = bh_result->b_page ; 520 struct page *tail_page;
516 int retval = 0 ; 521 struct page *hole_page = bh_result->b_page;
517 522 int retval = 0;
518 if ((tail_offset & (bh_result->b_size - 1)) != 1) 523
519 return -EIO ; 524 if ((tail_offset & (bh_result->b_size - 1)) != 1)
520 525 return -EIO;
521 /* always try to read until the end of the block */ 526
522 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1) ; 527 /* always try to read until the end of the block */
523 tail_end = (tail_start | (bh_result->b_size - 1)) + 1 ; 528 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
524 529 tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
525 index = tail_offset >> PAGE_CACHE_SHIFT ; 530
526 /* hole_page can be zero in case of direct_io, we are sure 531 index = tail_offset >> PAGE_CACHE_SHIFT;
527 that we cannot get here if we write with O_DIRECT into 532 /* hole_page can be zero in case of direct_io, we are sure
528 tail page */ 533 that we cannot get here if we write with O_DIRECT into
529 if (!hole_page || index != hole_page->index) { 534 tail page */
530 tail_page = grab_cache_page(inode->i_mapping, index) ; 535 if (!hole_page || index != hole_page->index) {
531 retval = -ENOMEM; 536 tail_page = grab_cache_page(inode->i_mapping, index);
532 if (!tail_page) { 537 retval = -ENOMEM;
533 goto out ; 538 if (!tail_page) {
534 } 539 goto out;
535 } else { 540 }
536 tail_page = hole_page ; 541 } else {
537 } 542 tail_page = hole_page;
538 543 }
539 /* we don't have to make sure the conversion did not happen while 544
540 ** we were locking the page because anyone that could convert 545 /* we don't have to make sure the conversion did not happen while
541 ** must first take i_sem. 546 ** we were locking the page because anyone that could convert
542 ** 547 ** must first take i_sem.
543 ** We must fix the tail page for writing because it might have buffers 548 **
544 ** that are mapped, but have a block number of 0. This indicates tail 549 ** We must fix the tail page for writing because it might have buffers
545 ** data that has been read directly into the page, and block_prepare_write 550 ** that are mapped, but have a block number of 0. This indicates tail
546 ** won't trigger a get_block in this case. 551 ** data that has been read directly into the page, and block_prepare_write
547 */ 552 ** won't trigger a get_block in this case.
548 fix_tail_page_for_writing(tail_page) ; 553 */
549 retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end); 554 fix_tail_page_for_writing(tail_page);
550 if (retval) 555 retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);
551 goto unlock ; 556 if (retval)
552 557 goto unlock;
553 /* tail conversion might change the data in the page */ 558
554 flush_dcache_page(tail_page) ; 559 /* tail conversion might change the data in the page */
555 560 flush_dcache_page(tail_page);
556 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end) ; 561
557 562 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
558unlock: 563
559 if (tail_page != hole_page) { 564 unlock:
560 unlock_page(tail_page) ; 565 if (tail_page != hole_page) {
561 page_cache_release(tail_page) ; 566 unlock_page(tail_page);
562 } 567 page_cache_release(tail_page);
563out: 568 }
564 return retval ; 569 out:
570 return retval;
565} 571}
566 572
567static inline int _allocate_block(struct reiserfs_transaction_handle *th, 573static inline int _allocate_block(struct reiserfs_transaction_handle *th,
568 long block, 574 long block,
569 struct inode *inode, 575 struct inode *inode,
570 b_blocknr_t *allocated_block_nr, 576 b_blocknr_t * allocated_block_nr,
571 struct path * path, 577 struct path *path, int flags)
572 int flags) { 578{
573 BUG_ON (!th->t_trans_id); 579 BUG_ON(!th->t_trans_id);
574 580
575#ifdef REISERFS_PREALLOCATE 581#ifdef REISERFS_PREALLOCATE
576 if (!(flags & GET_BLOCK_NO_ISEM)) { 582 if (!(flags & GET_BLOCK_NO_ISEM)) {
577 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr, path, block); 583 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
578 } 584 path, block);
585 }
579#endif 586#endif
580 return reiserfs_new_unf_blocknrs (th, inode, allocated_block_nr, path, block); 587 return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
588 block);
581} 589}
582 590
583int reiserfs_get_block (struct inode * inode, sector_t block, 591int reiserfs_get_block(struct inode *inode, sector_t block,
584 struct buffer_head * bh_result, int create) 592 struct buffer_head *bh_result, int create)
585{ 593{
586 int repeat, retval = 0; 594 int repeat, retval = 0;
587 b_blocknr_t allocated_block_nr = 0;// b_blocknr_t is (unsigned) 32 bit int 595 b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int
588 INITIALIZE_PATH(path); 596 INITIALIZE_PATH(path);
589 int pos_in_item; 597 int pos_in_item;
590 struct cpu_key key; 598 struct cpu_key key;
591 struct buffer_head * bh, * unbh = NULL; 599 struct buffer_head *bh, *unbh = NULL;
592 struct item_head * ih, tmp_ih; 600 struct item_head *ih, tmp_ih;
593 __le32 * item; 601 __le32 *item;
594 int done; 602 int done;
595 int fs_gen; 603 int fs_gen;
596 struct reiserfs_transaction_handle *th = NULL; 604 struct reiserfs_transaction_handle *th = NULL;
597 /* space reserved in transaction batch: 605 /* space reserved in transaction batch:
598 . 3 balancings in direct->indirect conversion 606 . 3 balancings in direct->indirect conversion
599 . 1 block involved into reiserfs_update_sd() 607 . 1 block involved into reiserfs_update_sd()
600 XXX in practically impossible worst case direct2indirect() 608 XXX in practically impossible worst case direct2indirect()
601 can incur (much) more than 3 balancings. 609 can incur (much) more than 3 balancings.
602 quota update for user, group */ 610 quota update for user, group */
603 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 1 + 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb); 611 int jbegin_count =
604 int version; 612 JOURNAL_PER_BALANCE_CNT * 3 + 1 +
605 int dangle = 1; 613 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
606 loff_t new_offset = (((loff_t)block) << inode->i_sb->s_blocksize_bits) + 1 ; 614 int version;
607 615 int dangle = 1;
608 /* bad.... */ 616 loff_t new_offset =
609 reiserfs_write_lock(inode->i_sb); 617 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
610 version = get_inode_item_key_version (inode); 618
611 619 /* bad.... */
612 if (block < 0) { 620 reiserfs_write_lock(inode->i_sb);
613 reiserfs_write_unlock(inode->i_sb); 621 version = get_inode_item_key_version(inode);
614 return -EIO;
615 }
616 622
617 if (!file_capable (inode, block)) { 623 if (block < 0) {
618 reiserfs_write_unlock(inode->i_sb); 624 reiserfs_write_unlock(inode->i_sb);
619 return -EFBIG; 625 return -EIO;
620 } 626 }
621
622 /* if !create, we aren't changing the FS, so we don't need to
623 ** log anything, so we don't need to start a transaction
624 */
625 if (!(create & GET_BLOCK_CREATE)) {
626 int ret ;
627 /* find number of block-th logical block of the file */
628 ret = _get_block_create_0 (inode, block, bh_result,
629 create | GET_BLOCK_READ_DIRECT) ;
630 reiserfs_write_unlock(inode->i_sb);
631 return ret;
632 }
633 /*
634 * if we're already in a transaction, make sure to close
635 * any new transactions we start in this func
636 */
637 if ((create & GET_BLOCK_NO_DANGLE) ||
638 reiserfs_transaction_running(inode->i_sb))
639 dangle = 0;
640
641 /* If file is of such a size, that it might have a tail and tails are enabled
642 ** we should mark it as possibly needing tail packing on close
643 */
644 if ( (have_large_tails (inode->i_sb) && inode->i_size < i_block_size (inode)*4) ||
645 (have_small_tails (inode->i_sb) && inode->i_size < i_block_size(inode)) )
646 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask ;
647
648 /* set the key of the first byte in the 'block'-th block of file */
649 make_cpu_key (&key, inode, new_offset,
650 TYPE_ANY, 3/*key length*/);
651 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
652start_trans:
653 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
654 if (!th) {
655 retval = -ENOMEM;
656 goto failure;
657 }
658 reiserfs_update_inode_transaction(inode) ;
659 }
660 research:
661
662 retval = search_for_position_by_key (inode->i_sb, &key, &path);
663 if (retval == IO_ERROR) {
664 retval = -EIO;
665 goto failure;
666 }
667
668 bh = get_last_bh (&path);
669 ih = get_ih (&path);
670 item = get_item (&path);
671 pos_in_item = path.pos_in_item;
672
673 fs_gen = get_generation (inode->i_sb);
674 copy_item_head (&tmp_ih, ih);
675
676 if (allocation_needed (retval, allocated_block_nr, ih, item, pos_in_item)) {
677 /* we have to allocate block for the unformatted node */
678 if (!th) {
679 pathrelse(&path) ;
680 goto start_trans;
681 }
682
683 repeat = _allocate_block(th, block, inode, &allocated_block_nr, &path, create);
684
685 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
686 /* restart the transaction to give the journal a chance to free
687 ** some blocks. releases the path, so we have to go back to
688 ** research if we succeed on the second try
689 */
690 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
691 retval = restart_transaction(th, inode, &path) ;
692 if (retval)
693 goto failure;
694 repeat = _allocate_block(th, block, inode, &allocated_block_nr, NULL, create);
695
696 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
697 goto research ;
698 }
699 if (repeat == QUOTA_EXCEEDED)
700 retval = -EDQUOT;
701 else
702 retval = -ENOSPC;
703 goto failure;
704 }
705
706 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) {
707 goto research;
708 }
709 }
710
711 if (indirect_item_found (retval, ih)) {
712 b_blocknr_t unfm_ptr;
713 /* 'block'-th block is in the file already (there is
714 corresponding cell in some indirect item). But it may be
715 zero unformatted node pointer (hole) */
716 unfm_ptr = get_block_num (item, pos_in_item);
717 if (unfm_ptr == 0) {
718 /* use allocated block to plug the hole */
719 reiserfs_prepare_for_journal(inode->i_sb, bh, 1) ;
720 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) {
721 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ;
722 goto research;
723 }
724 set_buffer_new(bh_result);
725 if (buffer_dirty(bh_result) && reiserfs_data_ordered(inode->i_sb))
726 reiserfs_add_ordered_list(inode, bh_result);
727 put_block_num(item, pos_in_item, allocated_block_nr) ;
728 unfm_ptr = allocated_block_nr;
729 journal_mark_dirty (th, inode->i_sb, bh);
730 reiserfs_update_sd(th, inode) ;
731 }
732 set_block_dev_mapped(bh_result, unfm_ptr, inode);
733 pathrelse (&path);
734 retval = 0;
735 if (!dangle && th)
736 retval = reiserfs_end_persistent_transaction(th);
737 627
738 reiserfs_write_unlock(inode->i_sb); 628 if (!file_capable(inode, block)) {
739 629 reiserfs_write_unlock(inode->i_sb);
740 /* the item was found, so new blocks were not added to the file 630 return -EFBIG;
741 ** there is no need to make sure the inode is updated with this 631 }
742 ** transaction 632
743 */ 633 /* if !create, we aren't changing the FS, so we don't need to
744 return retval; 634 ** log anything, so we don't need to start a transaction
745 } 635 */
746 636 if (!(create & GET_BLOCK_CREATE)) {
747 if (!th) { 637 int ret;
748 pathrelse(&path) ; 638 /* find number of block-th logical block of the file */
749 goto start_trans; 639 ret = _get_block_create_0(inode, block, bh_result,
750 } 640 create | GET_BLOCK_READ_DIRECT);
751 641 reiserfs_write_unlock(inode->i_sb);
752 /* desired position is not found or is in the direct item. We have 642 return ret;
753 to append file with holes up to 'block'-th block converting 643 }
754 direct items to indirect one if necessary */ 644 /*
755 done = 0; 645 * if we're already in a transaction, make sure to close
756 do { 646 * any new transactions we start in this func
757 if (is_statdata_le_ih (ih)) { 647 */
758 __le32 unp = 0; 648 if ((create & GET_BLOCK_NO_DANGLE) ||
759 struct cpu_key tmp_key; 649 reiserfs_transaction_running(inode->i_sb))
760 650 dangle = 0;
761 /* indirect item has to be inserted */ 651
762 make_le_item_head (&tmp_ih, &key, version, 1, TYPE_INDIRECT, 652 /* If file is of such a size, that it might have a tail and tails are enabled
763 UNFM_P_SIZE, 0/* free_space */); 653 ** we should mark it as possibly needing tail packing on close
764 654 */
765 if (cpu_key_k_offset (&key) == 1) { 655 if ((have_large_tails(inode->i_sb)
766 /* we are going to add 'block'-th block to the file. Use 656 && inode->i_size < i_block_size(inode) * 4)
767 allocated block for that */ 657 || (have_small_tails(inode->i_sb)
768 unp = cpu_to_le32 (allocated_block_nr); 658 && inode->i_size < i_block_size(inode)))
769 set_block_dev_mapped (bh_result, allocated_block_nr, inode); 659 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
770 set_buffer_new(bh_result); 660
771 done = 1; 661 /* set the key of the first byte in the 'block'-th block of file */
772 } 662 make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
773 tmp_key = key; // ;) 663 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
774 set_cpu_key_k_offset (&tmp_key, 1); 664 start_trans:
775 PATH_LAST_POSITION(&path) ++; 665 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
776 666 if (!th) {
777 retval = reiserfs_insert_item (th, &path, &tmp_key, &tmp_ih, inode, (char *)&unp); 667 retval = -ENOMEM;
778 if (retval) {
779 reiserfs_free_block (th, inode, allocated_block_nr, 1);
780 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
781 }
782 //mark_tail_converted (inode);
783 } else if (is_direct_le_ih (ih)) {
784 /* direct item has to be converted */
785 loff_t tail_offset;
786
787 tail_offset = ((le_ih_k_offset (ih) - 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
788 if (tail_offset == cpu_key_k_offset (&key)) {
789 /* direct item we just found fits into block we have
790 to map. Convert it into unformatted node: use
791 bh_result for the conversion */
792 set_block_dev_mapped (bh_result, allocated_block_nr, inode);
793 unbh = bh_result;
794 done = 1;
795 } else {
796 /* we have to padd file tail stored in direct item(s)
797 up to block size and convert it to unformatted
798 node. FIXME: this should also get into page cache */
799
800 pathrelse(&path) ;
801 /*
802 * ugly, but we can only end the transaction if
803 * we aren't nested
804 */
805 BUG_ON (!th->t_refcount);
806 if (th->t_refcount == 1) {
807 retval = reiserfs_end_persistent_transaction(th);
808 th = NULL;
809 if (retval)
810 goto failure; 668 goto failure;
811 } 669 }
670 reiserfs_update_inode_transaction(inode);
671 }
672 research:
812 673
813 retval = convert_tail_for_hole(inode, bh_result, tail_offset) ; 674 retval = search_for_position_by_key(inode->i_sb, &key, &path);
814 if (retval) {
815 if ( retval != -ENOSPC )
816 reiserfs_warning (inode->i_sb, "clm-6004: convert tail failed inode %lu, error %d", inode->i_ino, retval) ;
817 if (allocated_block_nr) {
818 /* the bitmap, the super, and the stat data == 3 */
819 if (!th)
820 th = reiserfs_persistent_transaction(inode->i_sb,3);
821 if (th)
822 reiserfs_free_block (th,inode,allocated_block_nr,1);
823 }
824 goto failure ;
825 }
826 goto research ;
827 }
828 retval = direct2indirect (th, inode, &path, unbh, tail_offset);
829 if (retval) {
830 reiserfs_unmap_buffer(unbh);
831 reiserfs_free_block (th, inode, allocated_block_nr, 1);
832 goto failure;
833 }
834 /* it is important the set_buffer_uptodate is done after
835 ** the direct2indirect. The buffer might contain valid
836 ** data newer than the data on disk (read by readpage, changed,
837 ** and then sent here by writepage). direct2indirect needs
838 ** to know if unbh was already up to date, so it can decide
839 ** if the data in unbh needs to be replaced with data from
840 ** the disk
841 */
842 set_buffer_uptodate (unbh);
843
844 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
845 buffer will disappear shortly, so it should not be added to
846 */
847 if ( unbh->b_page ) {
848 /* we've converted the tail, so we must
849 ** flush unbh before the transaction commits
850 */
851 reiserfs_add_tail_list(inode, unbh) ;
852
853 /* mark it dirty now to prevent commit_write from adding
854 ** this buffer to the inode's dirty buffer list
855 */
856 /*
857 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
858 * It's still atomic, but it sets the page dirty too,
859 * which makes it eligible for writeback at any time by the
860 * VM (which was also the case with __mark_buffer_dirty())
861 */
862 mark_buffer_dirty(unbh) ;
863 }
864 } else {
865 /* append indirect item with holes if needed, when appending
866 pointer to 'block'-th block use block, which is already
867 allocated */
868 struct cpu_key tmp_key;
869 unp_t unf_single=0; // We use this in case we need to allocate only
870 // one block which is a fastpath
871 unp_t *un;
872 __u64 max_to_insert=MAX_ITEM_LEN(inode->i_sb->s_blocksize)/UNFM_P_SIZE;
873 __u64 blocks_needed;
874
875 RFALSE( pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
876 "vs-804: invalid position for append");
877 /* indirect item has to be appended, set up key of that position */
878 make_cpu_key (&tmp_key, inode,
879 le_key_k_offset (version, &(ih->ih_key)) + op_bytes_number (ih, inode->i_sb->s_blocksize),
880 //pos_in_item * inode->i_sb->s_blocksize,
881 TYPE_INDIRECT, 3);// key type is unimportant
882
883 blocks_needed = 1 + ((cpu_key_k_offset (&key) - cpu_key_k_offset (&tmp_key)) >> inode->i_sb->s_blocksize_bits);
884 RFALSE( blocks_needed < 0, "green-805: invalid offset");
885
886 if ( blocks_needed == 1 ) {
887 un = &unf_single;
888 } else {
889 un=kmalloc( min(blocks_needed,max_to_insert)*UNFM_P_SIZE,
890 GFP_ATOMIC); // We need to avoid scheduling.
891 if ( !un) {
892 un = &unf_single;
893 blocks_needed = 1;
894 max_to_insert = 0;
895 } else
896 memset(un, 0, UNFM_P_SIZE * min(blocks_needed,max_to_insert));
897 }
898 if ( blocks_needed <= max_to_insert) {
899 /* we are going to add target block to the file. Use allocated
900 block for that */
901 un[blocks_needed-1] = cpu_to_le32 (allocated_block_nr);
902 set_block_dev_mapped (bh_result, allocated_block_nr, inode);
903 set_buffer_new(bh_result);
904 done = 1;
905 } else {
906 /* paste hole to the indirect item */
907 /* If kmalloc failed, max_to_insert becomes zero and it means we
908 only have space for one block */
909 blocks_needed=max_to_insert?max_to_insert:1;
910 }
911 retval = reiserfs_paste_into_item (th, &path, &tmp_key, inode, (char *)un, UNFM_P_SIZE * blocks_needed);
912
913 if (blocks_needed != 1)
914 kfree(un);
915
916 if (retval) {
917 reiserfs_free_block (th, inode, allocated_block_nr, 1);
918 goto failure;
919 }
920 if (!done) {
921 /* We need to mark new file size in case this function will be
922 interrupted/aborted later on. And we may do this only for
923 holes. */
924 inode->i_size += inode->i_sb->s_blocksize * blocks_needed;
925 }
926 }
927
928 if (done == 1)
929 break;
930
931 /* this loop could log more blocks than we had originally asked
932 ** for. So, we have to allow the transaction to end if it is
933 ** too big or too full. Update the inode so things are
934 ** consistent if we crash before the function returns
935 **
936 ** release the path so that anybody waiting on the path before
937 ** ending their transaction will be able to continue.
938 */
939 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
940 retval = restart_transaction(th, inode, &path) ;
941 if (retval)
942 goto failure;
943 }
944 /* inserting indirect pointers for a hole can take a
945 ** long time. reschedule if needed
946 */
947 cond_resched();
948
949 retval = search_for_position_by_key (inode->i_sb, &key, &path);
950 if (retval == IO_ERROR) { 675 if (retval == IO_ERROR) {
951 retval = -EIO; 676 retval = -EIO;
952 goto failure; 677 goto failure;
953 } 678 }
954 if (retval == POSITION_FOUND) { 679
955 reiserfs_warning (inode->i_sb, "vs-825: reiserfs_get_block: " 680 bh = get_last_bh(&path);
956 "%K should not be found", &key); 681 ih = get_ih(&path);
957 retval = -EEXIST; 682 item = get_item(&path);
958 if (allocated_block_nr)
959 reiserfs_free_block (th, inode, allocated_block_nr, 1);
960 pathrelse(&path) ;
961 goto failure;
962 }
963 bh = get_last_bh (&path);
964 ih = get_ih (&path);
965 item = get_item (&path);
966 pos_in_item = path.pos_in_item; 683 pos_in_item = path.pos_in_item;
967 } while (1);
968 684
685 fs_gen = get_generation(inode->i_sb);
686 copy_item_head(&tmp_ih, ih);
687
688 if (allocation_needed
689 (retval, allocated_block_nr, ih, item, pos_in_item)) {
690 /* we have to allocate block for the unformatted node */
691 if (!th) {
692 pathrelse(&path);
693 goto start_trans;
694 }
695
696 repeat =
697 _allocate_block(th, block, inode, &allocated_block_nr,
698 &path, create);
699
700 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
701 /* restart the transaction to give the journal a chance to free
702 ** some blocks. releases the path, so we have to go back to
703 ** research if we succeed on the second try
704 */
705 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
706 retval = restart_transaction(th, inode, &path);
707 if (retval)
708 goto failure;
709 repeat =
710 _allocate_block(th, block, inode,
711 &allocated_block_nr, NULL, create);
712
713 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
714 goto research;
715 }
716 if (repeat == QUOTA_EXCEEDED)
717 retval = -EDQUOT;
718 else
719 retval = -ENOSPC;
720 goto failure;
721 }
722
723 if (fs_changed(fs_gen, inode->i_sb)
724 && item_moved(&tmp_ih, &path)) {
725 goto research;
726 }
727 }
728
729 if (indirect_item_found(retval, ih)) {
730 b_blocknr_t unfm_ptr;
731 /* 'block'-th block is in the file already (there is
732 corresponding cell in some indirect item). But it may be
733 zero unformatted node pointer (hole) */
734 unfm_ptr = get_block_num(item, pos_in_item);
735 if (unfm_ptr == 0) {
736 /* use allocated block to plug the hole */
737 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
738 if (fs_changed(fs_gen, inode->i_sb)
739 && item_moved(&tmp_ih, &path)) {
740 reiserfs_restore_prepared_buffer(inode->i_sb,
741 bh);
742 goto research;
743 }
744 set_buffer_new(bh_result);
745 if (buffer_dirty(bh_result)
746 && reiserfs_data_ordered(inode->i_sb))
747 reiserfs_add_ordered_list(inode, bh_result);
748 put_block_num(item, pos_in_item, allocated_block_nr);
749 unfm_ptr = allocated_block_nr;
750 journal_mark_dirty(th, inode->i_sb, bh);
751 reiserfs_update_sd(th, inode);
752 }
753 set_block_dev_mapped(bh_result, unfm_ptr, inode);
754 pathrelse(&path);
755 retval = 0;
756 if (!dangle && th)
757 retval = reiserfs_end_persistent_transaction(th);
758
759 reiserfs_write_unlock(inode->i_sb);
760
761 /* the item was found, so new blocks were not added to the file
762 ** there is no need to make sure the inode is updated with this
763 ** transaction
764 */
765 return retval;
766 }
767
768 if (!th) {
769 pathrelse(&path);
770 goto start_trans;
771 }
772
773 /* desired position is not found or is in the direct item. We have
774 to append file with holes up to 'block'-th block converting
775 direct items to indirect one if necessary */
776 done = 0;
777 do {
778 if (is_statdata_le_ih(ih)) {
779 __le32 unp = 0;
780 struct cpu_key tmp_key;
781
782 /* indirect item has to be inserted */
783 make_le_item_head(&tmp_ih, &key, version, 1,
784 TYPE_INDIRECT, UNFM_P_SIZE,
785 0 /* free_space */ );
786
787 if (cpu_key_k_offset(&key) == 1) {
788 /* we are going to add 'block'-th block to the file. Use
789 allocated block for that */
790 unp = cpu_to_le32(allocated_block_nr);
791 set_block_dev_mapped(bh_result,
792 allocated_block_nr, inode);
793 set_buffer_new(bh_result);
794 done = 1;
795 }
796 tmp_key = key; // ;)
797 set_cpu_key_k_offset(&tmp_key, 1);
798 PATH_LAST_POSITION(&path)++;
799
800 retval =
801 reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
802 inode, (char *)&unp);
803 if (retval) {
804 reiserfs_free_block(th, inode,
805 allocated_block_nr, 1);
806 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
807 }
808 //mark_tail_converted (inode);
809 } else if (is_direct_le_ih(ih)) {
810 /* direct item has to be converted */
811 loff_t tail_offset;
812
813 tail_offset =
814 ((le_ih_k_offset(ih) -
815 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
816 if (tail_offset == cpu_key_k_offset(&key)) {
817 /* direct item we just found fits into block we have
818 to map. Convert it into unformatted node: use
819 bh_result for the conversion */
820 set_block_dev_mapped(bh_result,
821 allocated_block_nr, inode);
822 unbh = bh_result;
823 done = 1;
824 } else {
825 /* we have to padd file tail stored in direct item(s)
826 up to block size and convert it to unformatted
827 node. FIXME: this should also get into page cache */
828
829 pathrelse(&path);
830 /*
831 * ugly, but we can only end the transaction if
832 * we aren't nested
833 */
834 BUG_ON(!th->t_refcount);
835 if (th->t_refcount == 1) {
836 retval =
837 reiserfs_end_persistent_transaction
838 (th);
839 th = NULL;
840 if (retval)
841 goto failure;
842 }
843
844 retval =
845 convert_tail_for_hole(inode, bh_result,
846 tail_offset);
847 if (retval) {
848 if (retval != -ENOSPC)
849 reiserfs_warning(inode->i_sb,
850 "clm-6004: convert tail failed inode %lu, error %d",
851 inode->i_ino,
852 retval);
853 if (allocated_block_nr) {
854 /* the bitmap, the super, and the stat data == 3 */
855 if (!th)
856 th = reiserfs_persistent_transaction(inode->i_sb, 3);
857 if (th)
858 reiserfs_free_block(th,
859 inode,
860 allocated_block_nr,
861 1);
862 }
863 goto failure;
864 }
865 goto research;
866 }
867 retval =
868 direct2indirect(th, inode, &path, unbh,
869 tail_offset);
870 if (retval) {
871 reiserfs_unmap_buffer(unbh);
872 reiserfs_free_block(th, inode,
873 allocated_block_nr, 1);
874 goto failure;
875 }
876 /* it is important the set_buffer_uptodate is done after
877 ** the direct2indirect. The buffer might contain valid
878 ** data newer than the data on disk (read by readpage, changed,
879 ** and then sent here by writepage). direct2indirect needs
880 ** to know if unbh was already up to date, so it can decide
881 ** if the data in unbh needs to be replaced with data from
882 ** the disk
883 */
884 set_buffer_uptodate(unbh);
885
886 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
887 buffer will disappear shortly, so it should not be added to
888 */
889 if (unbh->b_page) {
890 /* we've converted the tail, so we must
891 ** flush unbh before the transaction commits
892 */
893 reiserfs_add_tail_list(inode, unbh);
894
895 /* mark it dirty now to prevent commit_write from adding
896 ** this buffer to the inode's dirty buffer list
897 */
898 /*
899 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
900 * It's still atomic, but it sets the page dirty too,
901 * which makes it eligible for writeback at any time by the
902 * VM (which was also the case with __mark_buffer_dirty())
903 */
904 mark_buffer_dirty(unbh);
905 }
906 } else {
907 /* append indirect item with holes if needed, when appending
908 pointer to 'block'-th block use block, which is already
909 allocated */
910 struct cpu_key tmp_key;
911 unp_t unf_single = 0; // We use this in case we need to allocate only
912 // one block which is a fastpath
913 unp_t *un;
914 __u64 max_to_insert =
915 MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
916 UNFM_P_SIZE;
917 __u64 blocks_needed;
918
919 RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
920 "vs-804: invalid position for append");
921 /* indirect item has to be appended, set up key of that position */
922 make_cpu_key(&tmp_key, inode,
923 le_key_k_offset(version,
924 &(ih->ih_key)) +
925 op_bytes_number(ih,
926 inode->i_sb->s_blocksize),
927 //pos_in_item * inode->i_sb->s_blocksize,
928 TYPE_INDIRECT, 3); // key type is unimportant
929
930 blocks_needed =
931 1 +
932 ((cpu_key_k_offset(&key) -
933 cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
934 s_blocksize_bits);
935 RFALSE(blocks_needed < 0, "green-805: invalid offset");
936
937 if (blocks_needed == 1) {
938 un = &unf_single;
939 } else {
940 un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC); // We need to avoid scheduling.
941 if (!un) {
942 un = &unf_single;
943 blocks_needed = 1;
944 max_to_insert = 0;
945 } else
946 memset(un, 0,
947 UNFM_P_SIZE * min(blocks_needed,
948 max_to_insert));
949 }
950 if (blocks_needed <= max_to_insert) {
951 /* we are going to add target block to the file. Use allocated
952 block for that */
953 un[blocks_needed - 1] =
954 cpu_to_le32(allocated_block_nr);
955 set_block_dev_mapped(bh_result,
956 allocated_block_nr, inode);
957 set_buffer_new(bh_result);
958 done = 1;
959 } else {
960 /* paste hole to the indirect item */
961 /* If kmalloc failed, max_to_insert becomes zero and it means we
962 only have space for one block */
963 blocks_needed =
964 max_to_insert ? max_to_insert : 1;
965 }
966 retval =
967 reiserfs_paste_into_item(th, &path, &tmp_key, inode,
968 (char *)un,
969 UNFM_P_SIZE *
970 blocks_needed);
971
972 if (blocks_needed != 1)
973 kfree(un);
974
975 if (retval) {
976 reiserfs_free_block(th, inode,
977 allocated_block_nr, 1);
978 goto failure;
979 }
980 if (!done) {
981 /* We need to mark new file size in case this function will be
982 interrupted/aborted later on. And we may do this only for
983 holes. */
984 inode->i_size +=
985 inode->i_sb->s_blocksize * blocks_needed;
986 }
987 }
969 988
970 retval = 0; 989 if (done == 1)
990 break;
971 991
972 failure: 992 /* this loop could log more blocks than we had originally asked
973 if (th && (!dangle || (retval && !th->t_trans_id))) { 993 ** for. So, we have to allow the transaction to end if it is
974 int err; 994 ** too big or too full. Update the inode so things are
975 if (th->t_trans_id) 995 ** consistent if we crash before the function returns
976 reiserfs_update_sd(th, inode); 996 **
977 err = reiserfs_end_persistent_transaction(th); 997 ** release the path so that anybody waiting on the path before
978 if (err) 998 ** ending their transaction will be able to continue.
979 retval = err; 999 */
980 } 1000 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
1001 retval = restart_transaction(th, inode, &path);
1002 if (retval)
1003 goto failure;
1004 }
1005 /* inserting indirect pointers for a hole can take a
1006 ** long time. reschedule if needed
1007 */
1008 cond_resched();
981 1009
982 reiserfs_write_unlock(inode->i_sb); 1010 retval = search_for_position_by_key(inode->i_sb, &key, &path);
983 reiserfs_check_path(&path) ; 1011 if (retval == IO_ERROR) {
984 return retval; 1012 retval = -EIO;
1013 goto failure;
1014 }
1015 if (retval == POSITION_FOUND) {
1016 reiserfs_warning(inode->i_sb,
1017 "vs-825: reiserfs_get_block: "
1018 "%K should not be found", &key);
1019 retval = -EEXIST;
1020 if (allocated_block_nr)
1021 reiserfs_free_block(th, inode,
1022 allocated_block_nr, 1);
1023 pathrelse(&path);
1024 goto failure;
1025 }
1026 bh = get_last_bh(&path);
1027 ih = get_ih(&path);
1028 item = get_item(&path);
1029 pos_in_item = path.pos_in_item;
1030 } while (1);
1031
1032 retval = 0;
1033
1034 failure:
1035 if (th && (!dangle || (retval && !th->t_trans_id))) {
1036 int err;
1037 if (th->t_trans_id)
1038 reiserfs_update_sd(th, inode);
1039 err = reiserfs_end_persistent_transaction(th);
1040 if (err)
1041 retval = err;
1042 }
1043
1044 reiserfs_write_unlock(inode->i_sb);
1045 reiserfs_check_path(&path);
1046 return retval;
985} 1047}
986 1048
987static int 1049static int
988reiserfs_readpages(struct file *file, struct address_space *mapping, 1050reiserfs_readpages(struct file *file, struct address_space *mapping,
989 struct list_head *pages, unsigned nr_pages) 1051 struct list_head *pages, unsigned nr_pages)
990{ 1052{
991 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block); 1053 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
992} 1054}
993 1055
994/* Compute real number of used bytes by file 1056/* Compute real number of used bytes by file
@@ -996,51 +1058,56 @@ reiserfs_readpages(struct file *file, struct address_space *mapping,
996 */ 1058 */
997static int real_space_diff(struct inode *inode, int sd_size) 1059static int real_space_diff(struct inode *inode, int sd_size)
998{ 1060{
999 int bytes; 1061 int bytes;
1000 loff_t blocksize = inode->i_sb->s_blocksize ; 1062 loff_t blocksize = inode->i_sb->s_blocksize;
1001 1063
1002 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) 1064 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1003 return sd_size ; 1065 return sd_size;
1004 1066
1005 /* End of file is also in full block with indirect reference, so round 1067 /* End of file is also in full block with indirect reference, so round
1006 ** up to the next block. 1068 ** up to the next block.
1007 ** 1069 **
1008 ** there is just no way to know if the tail is actually packed 1070 ** there is just no way to know if the tail is actually packed
1009 ** on the file, so we have to assume it isn't. When we pack the 1071 ** on the file, so we have to assume it isn't. When we pack the
1010 ** tail, we add 4 bytes to pretend there really is an unformatted 1072 ** tail, we add 4 bytes to pretend there really is an unformatted
1011 ** node pointer 1073 ** node pointer
1012 */ 1074 */
1013 bytes = ((inode->i_size + (blocksize-1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE + sd_size; 1075 bytes =
1014 return bytes ; 1076 ((inode->i_size +
1077 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1078 sd_size;
1079 return bytes;
1015} 1080}
1016 1081
1017static inline loff_t to_real_used_space(struct inode *inode, ulong blocks, 1082static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
1018 int sd_size) 1083 int sd_size)
1019{ 1084{
1020 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) { 1085 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1021 return inode->i_size + (loff_t)(real_space_diff(inode, sd_size)) ; 1086 return inode->i_size +
1022 } 1087 (loff_t) (real_space_diff(inode, sd_size));
1023 return ((loff_t)real_space_diff(inode, sd_size)) + (((loff_t)blocks) << 9); 1088 }
1089 return ((loff_t) real_space_diff(inode, sd_size)) +
1090 (((loff_t) blocks) << 9);
1024} 1091}
1025 1092
1026/* Compute number of blocks used by file in ReiserFS counting */ 1093/* Compute number of blocks used by file in ReiserFS counting */
1027static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size) 1094static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1028{ 1095{
1029 loff_t bytes = inode_get_bytes(inode) ; 1096 loff_t bytes = inode_get_bytes(inode);
1030 loff_t real_space = real_space_diff(inode, sd_size) ; 1097 loff_t real_space = real_space_diff(inode, sd_size);
1031 1098
1032 /* keeps fsck and non-quota versions of reiserfs happy */ 1099 /* keeps fsck and non-quota versions of reiserfs happy */
1033 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) { 1100 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1034 bytes += (loff_t)511 ; 1101 bytes += (loff_t) 511;
1035 } 1102 }
1036 1103
1037 /* files from before the quota patch might i_blocks such that 1104 /* files from before the quota patch might i_blocks such that
1038 ** bytes < real_space. Deal with that here to prevent it from 1105 ** bytes < real_space. Deal with that here to prevent it from
1039 ** going negative. 1106 ** going negative.
1040 */ 1107 */
1041 if (bytes < real_space) 1108 if (bytes < real_space)
1042 return 0 ; 1109 return 0;
1043 return (bytes - real_space) >> 9; 1110 return (bytes - real_space) >> 9;
1044} 1111}
1045 1112
1046// 1113//
@@ -1051,263 +1118,269 @@ static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1051// 1118//
1052 1119
1053// called by read_locked_inode 1120// called by read_locked_inode
1054static void init_inode (struct inode * inode, struct path * path) 1121static void init_inode(struct inode *inode, struct path *path)
1055{ 1122{
1056 struct buffer_head * bh; 1123 struct buffer_head *bh;
1057 struct item_head * ih; 1124 struct item_head *ih;
1058 __u32 rdev; 1125 __u32 rdev;
1059 //int version = ITEM_VERSION_1; 1126 //int version = ITEM_VERSION_1;
1060 1127
1061 bh = PATH_PLAST_BUFFER (path); 1128 bh = PATH_PLAST_BUFFER(path);
1062 ih = PATH_PITEM_HEAD (path); 1129 ih = PATH_PITEM_HEAD(path);
1063 1130
1064 1131 copy_key(INODE_PKEY(inode), &(ih->ih_key));
1065 copy_key (INODE_PKEY (inode), &(ih->ih_key)); 1132 inode->i_blksize = reiserfs_default_io_size;
1066 inode->i_blksize = reiserfs_default_io_size; 1133
1067 1134 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1068 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list )); 1135 REISERFS_I(inode)->i_flags = 0;
1069 REISERFS_I(inode)->i_flags = 0; 1136 REISERFS_I(inode)->i_prealloc_block = 0;
1070 REISERFS_I(inode)->i_prealloc_block = 0; 1137 REISERFS_I(inode)->i_prealloc_count = 0;
1071 REISERFS_I(inode)->i_prealloc_count = 0; 1138 REISERFS_I(inode)->i_trans_id = 0;
1072 REISERFS_I(inode)->i_trans_id = 0; 1139 REISERFS_I(inode)->i_jl = NULL;
1073 REISERFS_I(inode)->i_jl = NULL; 1140 REISERFS_I(inode)->i_acl_access = NULL;
1074 REISERFS_I(inode)->i_acl_access = NULL; 1141 REISERFS_I(inode)->i_acl_default = NULL;
1075 REISERFS_I(inode)->i_acl_default = NULL; 1142 init_rwsem(&REISERFS_I(inode)->xattr_sem);
1076 init_rwsem (&REISERFS_I(inode)->xattr_sem); 1143
1077 1144 if (stat_data_v1(ih)) {
1078 if (stat_data_v1 (ih)) { 1145 struct stat_data_v1 *sd =
1079 struct stat_data_v1 * sd = (struct stat_data_v1 *)B_I_PITEM (bh, ih); 1146 (struct stat_data_v1 *)B_I_PITEM(bh, ih);
1080 unsigned long blocks; 1147 unsigned long blocks;
1081 1148
1082 set_inode_item_key_version (inode, KEY_FORMAT_3_5); 1149 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1083 set_inode_sd_version (inode, STAT_DATA_V1); 1150 set_inode_sd_version(inode, STAT_DATA_V1);
1084 inode->i_mode = sd_v1_mode(sd); 1151 inode->i_mode = sd_v1_mode(sd);
1085 inode->i_nlink = sd_v1_nlink(sd); 1152 inode->i_nlink = sd_v1_nlink(sd);
1086 inode->i_uid = sd_v1_uid(sd); 1153 inode->i_uid = sd_v1_uid(sd);
1087 inode->i_gid = sd_v1_gid(sd); 1154 inode->i_gid = sd_v1_gid(sd);
1088 inode->i_size = sd_v1_size(sd); 1155 inode->i_size = sd_v1_size(sd);
1089 inode->i_atime.tv_sec = sd_v1_atime(sd); 1156 inode->i_atime.tv_sec = sd_v1_atime(sd);
1090 inode->i_mtime.tv_sec = sd_v1_mtime(sd); 1157 inode->i_mtime.tv_sec = sd_v1_mtime(sd);
1091 inode->i_ctime.tv_sec = sd_v1_ctime(sd); 1158 inode->i_ctime.tv_sec = sd_v1_ctime(sd);
1092 inode->i_atime.tv_nsec = 0; 1159 inode->i_atime.tv_nsec = 0;
1093 inode->i_ctime.tv_nsec = 0; 1160 inode->i_ctime.tv_nsec = 0;
1094 inode->i_mtime.tv_nsec = 0; 1161 inode->i_mtime.tv_nsec = 0;
1095 1162
1096 inode->i_blocks = sd_v1_blocks(sd); 1163 inode->i_blocks = sd_v1_blocks(sd);
1097 inode->i_generation = le32_to_cpu (INODE_PKEY (inode)->k_dir_id); 1164 inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1098 blocks = (inode->i_size + 511) >> 9; 1165 blocks = (inode->i_size + 511) >> 9;
1099 blocks = _ROUND_UP (blocks, inode->i_sb->s_blocksize >> 9); 1166 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
1100 if (inode->i_blocks > blocks) { 1167 if (inode->i_blocks > blocks) {
1101 // there was a bug in <=3.5.23 when i_blocks could take negative 1168 // there was a bug in <=3.5.23 when i_blocks could take negative
1102 // values. Starting from 3.5.17 this value could even be stored in 1169 // values. Starting from 3.5.17 this value could even be stored in
1103 // stat data. For such files we set i_blocks based on file 1170 // stat data. For such files we set i_blocks based on file
1104 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be 1171 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be
1105 // only updated if file's inode will ever change 1172 // only updated if file's inode will ever change
1106 inode->i_blocks = blocks; 1173 inode->i_blocks = blocks;
1107 } 1174 }
1108
1109 rdev = sd_v1_rdev(sd);
1110 REISERFS_I(inode)->i_first_direct_byte = sd_v1_first_direct_byte(sd);
1111 /* an early bug in the quota code can give us an odd number for the
1112 ** block count. This is incorrect, fix it here.
1113 */
1114 if (inode->i_blocks & 1) {
1115 inode->i_blocks++ ;
1116 }
1117 inode_set_bytes(inode, to_real_used_space(inode, inode->i_blocks,
1118 SD_V1_SIZE));
1119 /* nopack is initially zero for v1 objects. For v2 objects,
1120 nopack is initialised from sd_attrs */
1121 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1122 } else {
1123 // new stat data found, but object may have old items
1124 // (directories and symlinks)
1125 struct stat_data * sd = (struct stat_data *)B_I_PITEM (bh, ih);
1126
1127 inode->i_mode = sd_v2_mode(sd);
1128 inode->i_nlink = sd_v2_nlink(sd);
1129 inode->i_uid = sd_v2_uid(sd);
1130 inode->i_size = sd_v2_size(sd);
1131 inode->i_gid = sd_v2_gid(sd);
1132 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1133 inode->i_atime.tv_sec = sd_v2_atime(sd);
1134 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1135 inode->i_ctime.tv_nsec = 0;
1136 inode->i_mtime.tv_nsec = 0;
1137 inode->i_atime.tv_nsec = 0;
1138 inode->i_blocks = sd_v2_blocks(sd);
1139 rdev = sd_v2_rdev(sd);
1140 if( S_ISCHR( inode -> i_mode ) || S_ISBLK( inode -> i_mode ) )
1141 inode->i_generation = le32_to_cpu (INODE_PKEY (inode)->k_dir_id);
1142 else
1143 inode->i_generation = sd_v2_generation(sd);
1144 1175
1145 if (S_ISDIR (inode->i_mode) || S_ISLNK (inode->i_mode)) 1176 rdev = sd_v1_rdev(sd);
1146 set_inode_item_key_version (inode, KEY_FORMAT_3_5); 1177 REISERFS_I(inode)->i_first_direct_byte =
1147 else 1178 sd_v1_first_direct_byte(sd);
1148 set_inode_item_key_version (inode, KEY_FORMAT_3_6); 1179 /* an early bug in the quota code can give us an odd number for the
1149 REISERFS_I(inode)->i_first_direct_byte = 0; 1180 ** block count. This is incorrect, fix it here.
1150 set_inode_sd_version (inode, STAT_DATA_V2); 1181 */
1151 inode_set_bytes(inode, to_real_used_space(inode, inode->i_blocks, 1182 if (inode->i_blocks & 1) {
1152 SD_V2_SIZE)); 1183 inode->i_blocks++;
1153 /* read persistent inode attributes from sd and initalise 1184 }
1154 generic inode flags from them */ 1185 inode_set_bytes(inode,
1155 REISERFS_I(inode)->i_attrs = sd_v2_attrs( sd ); 1186 to_real_used_space(inode, inode->i_blocks,
1156 sd_attrs_to_i_attrs( sd_v2_attrs( sd ), inode ); 1187 SD_V1_SIZE));
1157 } 1188 /* nopack is initially zero for v1 objects. For v2 objects,
1158 1189 nopack is initialised from sd_attrs */
1159 pathrelse (path); 1190 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1160 if (S_ISREG (inode->i_mode)) { 1191 } else {
1161 inode->i_op = &reiserfs_file_inode_operations; 1192 // new stat data found, but object may have old items
1162 inode->i_fop = &reiserfs_file_operations; 1193 // (directories and symlinks)
1163 inode->i_mapping->a_ops = &reiserfs_address_space_operations ; 1194 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
1164 } else if (S_ISDIR (inode->i_mode)) { 1195
1165 inode->i_op = &reiserfs_dir_inode_operations; 1196 inode->i_mode = sd_v2_mode(sd);
1166 inode->i_fop = &reiserfs_dir_operations; 1197 inode->i_nlink = sd_v2_nlink(sd);
1167 } else if (S_ISLNK (inode->i_mode)) { 1198 inode->i_uid = sd_v2_uid(sd);
1168 inode->i_op = &reiserfs_symlink_inode_operations; 1199 inode->i_size = sd_v2_size(sd);
1169 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 1200 inode->i_gid = sd_v2_gid(sd);
1170 } else { 1201 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1171 inode->i_blocks = 0; 1202 inode->i_atime.tv_sec = sd_v2_atime(sd);
1172 inode->i_op = &reiserfs_special_inode_operations; 1203 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1173 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev)); 1204 inode->i_ctime.tv_nsec = 0;
1174 } 1205 inode->i_mtime.tv_nsec = 0;
1175} 1206 inode->i_atime.tv_nsec = 0;
1207 inode->i_blocks = sd_v2_blocks(sd);
1208 rdev = sd_v2_rdev(sd);
1209 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1210 inode->i_generation =
1211 le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1212 else
1213 inode->i_generation = sd_v2_generation(sd);
1176 1214
1215 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1216 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1217 else
1218 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1219 REISERFS_I(inode)->i_first_direct_byte = 0;
1220 set_inode_sd_version(inode, STAT_DATA_V2);
1221 inode_set_bytes(inode,
1222 to_real_used_space(inode, inode->i_blocks,
1223 SD_V2_SIZE));
1224 /* read persistent inode attributes from sd and initalise
1225 generic inode flags from them */
1226 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1227 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
1228 }
1229
1230 pathrelse(path);
1231 if (S_ISREG(inode->i_mode)) {
1232 inode->i_op = &reiserfs_file_inode_operations;
1233 inode->i_fop = &reiserfs_file_operations;
1234 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1235 } else if (S_ISDIR(inode->i_mode)) {
1236 inode->i_op = &reiserfs_dir_inode_operations;
1237 inode->i_fop = &reiserfs_dir_operations;
1238 } else if (S_ISLNK(inode->i_mode)) {
1239 inode->i_op = &reiserfs_symlink_inode_operations;
1240 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1241 } else {
1242 inode->i_blocks = 0;
1243 inode->i_op = &reiserfs_special_inode_operations;
1244 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
1245 }
1246}
1177 1247
1178// update new stat data with inode fields 1248// update new stat data with inode fields
1179static void inode2sd (void * sd, struct inode * inode, loff_t size) 1249static void inode2sd(void *sd, struct inode *inode, loff_t size)
1180{ 1250{
1181 struct stat_data * sd_v2 = (struct stat_data *)sd; 1251 struct stat_data *sd_v2 = (struct stat_data *)sd;
1182 __u16 flags; 1252 __u16 flags;
1183 1253
1184 set_sd_v2_mode(sd_v2, inode->i_mode ); 1254 set_sd_v2_mode(sd_v2, inode->i_mode);
1185 set_sd_v2_nlink(sd_v2, inode->i_nlink ); 1255 set_sd_v2_nlink(sd_v2, inode->i_nlink);
1186 set_sd_v2_uid(sd_v2, inode->i_uid ); 1256 set_sd_v2_uid(sd_v2, inode->i_uid);
1187 set_sd_v2_size(sd_v2, size ); 1257 set_sd_v2_size(sd_v2, size);
1188 set_sd_v2_gid(sd_v2, inode->i_gid ); 1258 set_sd_v2_gid(sd_v2, inode->i_gid);
1189 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec ); 1259 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);
1190 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec ); 1260 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);
1191 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec ); 1261 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);
1192 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE)); 1262 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));
1193 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 1263 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1194 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev)); 1264 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));
1195 else 1265 else
1196 set_sd_v2_generation(sd_v2, inode->i_generation); 1266 set_sd_v2_generation(sd_v2, inode->i_generation);
1197 flags = REISERFS_I(inode)->i_attrs; 1267 flags = REISERFS_I(inode)->i_attrs;
1198 i_attrs_to_sd_attrs( inode, &flags ); 1268 i_attrs_to_sd_attrs(inode, &flags);
1199 set_sd_v2_attrs( sd_v2, flags ); 1269 set_sd_v2_attrs(sd_v2, flags);
1200} 1270}
1201 1271
1202
1203// used to copy inode's fields to old stat data 1272// used to copy inode's fields to old stat data
1204static void inode2sd_v1 (void * sd, struct inode * inode, loff_t size) 1273static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
1205{ 1274{
1206 struct stat_data_v1 * sd_v1 = (struct stat_data_v1 *)sd; 1275 struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
1207 1276
1208 set_sd_v1_mode(sd_v1, inode->i_mode ); 1277 set_sd_v1_mode(sd_v1, inode->i_mode);
1209 set_sd_v1_uid(sd_v1, inode->i_uid ); 1278 set_sd_v1_uid(sd_v1, inode->i_uid);
1210 set_sd_v1_gid(sd_v1, inode->i_gid ); 1279 set_sd_v1_gid(sd_v1, inode->i_gid);
1211 set_sd_v1_nlink(sd_v1, inode->i_nlink ); 1280 set_sd_v1_nlink(sd_v1, inode->i_nlink);
1212 set_sd_v1_size(sd_v1, size ); 1281 set_sd_v1_size(sd_v1, size);
1213 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec ); 1282 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);
1214 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec ); 1283 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);
1215 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec ); 1284 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);
1216 1285
1217 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 1286 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1218 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev)); 1287 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));
1219 else 1288 else
1220 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE)); 1289 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
1221
1222 // Sigh. i_first_direct_byte is back
1223 set_sd_v1_first_direct_byte(sd_v1, REISERFS_I(inode)->i_first_direct_byte);
1224}
1225 1290
1291 // Sigh. i_first_direct_byte is back
1292 set_sd_v1_first_direct_byte(sd_v1,
1293 REISERFS_I(inode)->i_first_direct_byte);
1294}
1226 1295
1227/* NOTE, you must prepare the buffer head before sending it here, 1296/* NOTE, you must prepare the buffer head before sending it here,
1228** and then log it after the call 1297** and then log it after the call
1229*/ 1298*/
1230static void update_stat_data (struct path * path, struct inode * inode, 1299static void update_stat_data(struct path *path, struct inode *inode,
1231 loff_t size) 1300 loff_t size)
1232{ 1301{
1233 struct buffer_head * bh; 1302 struct buffer_head *bh;
1234 struct item_head * ih; 1303 struct item_head *ih;
1235 1304
1236 bh = PATH_PLAST_BUFFER (path); 1305 bh = PATH_PLAST_BUFFER(path);
1237 ih = PATH_PITEM_HEAD (path); 1306 ih = PATH_PITEM_HEAD(path);
1238 1307
1239 if (!is_statdata_le_ih (ih)) 1308 if (!is_statdata_le_ih(ih))
1240 reiserfs_panic (inode->i_sb, "vs-13065: update_stat_data: key %k, found item %h", 1309 reiserfs_panic(inode->i_sb,
1241 INODE_PKEY (inode), ih); 1310 "vs-13065: update_stat_data: key %k, found item %h",
1242 1311 INODE_PKEY(inode), ih);
1243 if (stat_data_v1 (ih)) { 1312
1244 // path points to old stat data 1313 if (stat_data_v1(ih)) {
1245 inode2sd_v1 (B_I_PITEM (bh, ih), inode, size); 1314 // path points to old stat data
1246 } else { 1315 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1247 inode2sd (B_I_PITEM (bh, ih), inode, size); 1316 } else {
1248 } 1317 inode2sd(B_I_PITEM(bh, ih), inode, size);
1249 1318 }
1250 return;
1251}
1252 1319
1320 return;
1321}
1253 1322
1254void reiserfs_update_sd_size (struct reiserfs_transaction_handle *th, 1323void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1255 struct inode * inode, loff_t size) 1324 struct inode *inode, loff_t size)
1256{ 1325{
1257 struct cpu_key key; 1326 struct cpu_key key;
1258 INITIALIZE_PATH(path); 1327 INITIALIZE_PATH(path);
1259 struct buffer_head *bh ; 1328 struct buffer_head *bh;
1260 int fs_gen ; 1329 int fs_gen;
1261 struct item_head *ih, tmp_ih ; 1330 struct item_head *ih, tmp_ih;
1262 int retval; 1331 int retval;
1263 1332
1264 BUG_ON (!th->t_trans_id); 1333 BUG_ON(!th->t_trans_id);
1265 1334
1266 make_cpu_key (&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3);//key type is unimportant 1335 make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant
1267 1336
1268 for(;;) { 1337 for (;;) {
1269 int pos; 1338 int pos;
1270 /* look for the object's stat data */ 1339 /* look for the object's stat data */
1271 retval = search_item (inode->i_sb, &key, &path); 1340 retval = search_item(inode->i_sb, &key, &path);
1272 if (retval == IO_ERROR) { 1341 if (retval == IO_ERROR) {
1273 reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: " 1342 reiserfs_warning(inode->i_sb,
1274 "i/o failure occurred trying to update %K stat data", 1343 "vs-13050: reiserfs_update_sd: "
1275 &key); 1344 "i/o failure occurred trying to update %K stat data",
1276 return; 1345 &key);
1277 } 1346 return;
1278 if (retval == ITEM_NOT_FOUND) { 1347 }
1279 pos = PATH_LAST_POSITION (&path); 1348 if (retval == ITEM_NOT_FOUND) {
1280 pathrelse(&path) ; 1349 pos = PATH_LAST_POSITION(&path);
1281 if (inode->i_nlink == 0) { 1350 pathrelse(&path);
1282 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found");*/ 1351 if (inode->i_nlink == 0) {
1283 return; 1352 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1284 } 1353 return;
1285 reiserfs_warning (inode->i_sb, "vs-13060: reiserfs_update_sd: " 1354 }
1286 "stat data of object %k (nlink == %d) not found (pos %d)", 1355 reiserfs_warning(inode->i_sb,
1287 INODE_PKEY (inode), inode->i_nlink, pos); 1356 "vs-13060: reiserfs_update_sd: "
1288 reiserfs_check_path(&path) ; 1357 "stat data of object %k (nlink == %d) not found (pos %d)",
1289 return; 1358 INODE_PKEY(inode), inode->i_nlink,
1290 } 1359 pos);
1291 1360 reiserfs_check_path(&path);
1292 /* sigh, prepare_for_journal might schedule. When it schedules the 1361 return;
1293 ** FS might change. We have to detect that, and loop back to the 1362 }
1294 ** search if the stat data item has moved 1363
1295 */ 1364 /* sigh, prepare_for_journal might schedule. When it schedules the
1296 bh = get_last_bh(&path) ; 1365 ** FS might change. We have to detect that, and loop back to the
1297 ih = get_ih(&path) ; 1366 ** search if the stat data item has moved
1298 copy_item_head (&tmp_ih, ih); 1367 */
1299 fs_gen = get_generation (inode->i_sb); 1368 bh = get_last_bh(&path);
1300 reiserfs_prepare_for_journal(inode->i_sb, bh, 1) ; 1369 ih = get_ih(&path);
1301 if (fs_changed (fs_gen, inode->i_sb) && item_moved(&tmp_ih, &path)) { 1370 copy_item_head(&tmp_ih, ih);
1302 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ; 1371 fs_gen = get_generation(inode->i_sb);
1303 continue ; /* Stat_data item has been moved after scheduling. */ 1372 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
1304 } 1373 if (fs_changed(fs_gen, inode->i_sb)
1305 break; 1374 && item_moved(&tmp_ih, &path)) {
1306 } 1375 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
1307 update_stat_data (&path, inode, size); 1376 continue; /* Stat_data item has been moved after scheduling. */
1308 journal_mark_dirty(th, th->t_super, bh) ; 1377 }
1309 pathrelse (&path); 1378 break;
1310 return; 1379 }
1380 update_stat_data(&path, inode, size);
1381 journal_mark_dirty(th, th->t_super, bh);
1382 pathrelse(&path);
1383 return;
1311} 1384}
1312 1385
1313/* reiserfs_read_locked_inode is called to read the inode off disk, and it 1386/* reiserfs_read_locked_inode is called to read the inode off disk, and it
@@ -1316,9 +1389,10 @@ void reiserfs_update_sd_size (struct reiserfs_transaction_handle *th,
1316** corresponding iput might try to delete whatever object the inode last 1389** corresponding iput might try to delete whatever object the inode last
1317** represented. 1390** represented.
1318*/ 1391*/
1319static void reiserfs_make_bad_inode(struct inode *inode) { 1392static void reiserfs_make_bad_inode(struct inode *inode)
1320 memset(INODE_PKEY(inode), 0, KEY_SIZE); 1393{
1321 make_bad_inode(inode); 1394 memset(INODE_PKEY(inode), 0, KEY_SIZE);
1395 make_bad_inode(inode);
1322} 1396}
1323 1397
1324// 1398//
@@ -1326,77 +1400,79 @@ static void reiserfs_make_bad_inode(struct inode *inode) {
1326// evolved as the prototype did 1400// evolved as the prototype did
1327// 1401//
1328 1402
1329int reiserfs_init_locked_inode (struct inode * inode, void *p) 1403int reiserfs_init_locked_inode(struct inode *inode, void *p)
1330{ 1404{
1331 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p ; 1405 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;
1332 inode->i_ino = args->objectid; 1406 inode->i_ino = args->objectid;
1333 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid); 1407 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);
1334 return 0; 1408 return 0;
1335} 1409}
1336 1410
1337/* looks for stat data in the tree, and fills up the fields of in-core 1411/* looks for stat data in the tree, and fills up the fields of in-core
1338 inode stat data fields */ 1412 inode stat data fields */
1339void reiserfs_read_locked_inode (struct inode * inode, struct reiserfs_iget_args *args) 1413void reiserfs_read_locked_inode(struct inode *inode,
1414 struct reiserfs_iget_args *args)
1340{ 1415{
1341 INITIALIZE_PATH (path_to_sd); 1416 INITIALIZE_PATH(path_to_sd);
1342 struct cpu_key key; 1417 struct cpu_key key;
1343 unsigned long dirino; 1418 unsigned long dirino;
1344 int retval; 1419 int retval;
1345 1420
1346 dirino = args->dirid ; 1421 dirino = args->dirid;
1347 1422
1348 /* set version 1, version 2 could be used too, because stat data 1423 /* set version 1, version 2 could be used too, because stat data
1349 key is the same in both versions */ 1424 key is the same in both versions */
1350 key.version = KEY_FORMAT_3_5; 1425 key.version = KEY_FORMAT_3_5;
1351 key.on_disk_key.k_dir_id = dirino; 1426 key.on_disk_key.k_dir_id = dirino;
1352 key.on_disk_key.k_objectid = inode->i_ino; 1427 key.on_disk_key.k_objectid = inode->i_ino;
1353 key.on_disk_key.k_offset = 0; 1428 key.on_disk_key.k_offset = 0;
1354 key.on_disk_key.k_type = 0; 1429 key.on_disk_key.k_type = 0;
1355 1430
1356 /* look for the object's stat data */ 1431 /* look for the object's stat data */
1357 retval = search_item (inode->i_sb, &key, &path_to_sd); 1432 retval = search_item(inode->i_sb, &key, &path_to_sd);
1358 if (retval == IO_ERROR) { 1433 if (retval == IO_ERROR) {
1359 reiserfs_warning (inode->i_sb, "vs-13070: reiserfs_read_locked_inode: " 1434 reiserfs_warning(inode->i_sb,
1360 "i/o failure occurred trying to find stat data of %K", 1435 "vs-13070: reiserfs_read_locked_inode: "
1361 &key); 1436 "i/o failure occurred trying to find stat data of %K",
1362 reiserfs_make_bad_inode(inode) ; 1437 &key);
1363 return; 1438 reiserfs_make_bad_inode(inode);
1364 } 1439 return;
1365 if (retval != ITEM_FOUND) { 1440 }
1366 /* a stale NFS handle can trigger this without it being an error */ 1441 if (retval != ITEM_FOUND) {
1367 pathrelse (&path_to_sd); 1442 /* a stale NFS handle can trigger this without it being an error */
1368 reiserfs_make_bad_inode(inode) ; 1443 pathrelse(&path_to_sd);
1369 inode->i_nlink = 0; 1444 reiserfs_make_bad_inode(inode);
1370 return; 1445 inode->i_nlink = 0;
1371 } 1446 return;
1372 1447 }
1373 init_inode (inode, &path_to_sd); 1448
1374 1449 init_inode(inode, &path_to_sd);
1375 /* It is possible that knfsd is trying to access inode of a file 1450
1376 that is being removed from the disk by some other thread. As we 1451 /* It is possible that knfsd is trying to access inode of a file
1377 update sd on unlink all that is required is to check for nlink 1452 that is being removed from the disk by some other thread. As we
1378 here. This bug was first found by Sizif when debugging 1453 update sd on unlink all that is required is to check for nlink
1379 SquidNG/Butterfly, forgotten, and found again after Philippe 1454 here. This bug was first found by Sizif when debugging
1380 Gramoulle <philippe.gramoulle@mmania.com> reproduced it. 1455 SquidNG/Butterfly, forgotten, and found again after Philippe
1381 1456 Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
1382 More logical fix would require changes in fs/inode.c:iput() to 1457
1383 remove inode from hash-table _after_ fs cleaned disk stuff up and 1458 More logical fix would require changes in fs/inode.c:iput() to
1384 in iget() to return NULL if I_FREEING inode is found in 1459 remove inode from hash-table _after_ fs cleaned disk stuff up and
1385 hash-table. */ 1460 in iget() to return NULL if I_FREEING inode is found in
1386 /* Currently there is one place where it's ok to meet inode with 1461 hash-table. */
1387 nlink==0: processing of open-unlinked and half-truncated files 1462 /* Currently there is one place where it's ok to meet inode with
1388 during mount (fs/reiserfs/super.c:finish_unfinished()). */ 1463 nlink==0: processing of open-unlinked and half-truncated files
1389 if( ( inode -> i_nlink == 0 ) && 1464 during mount (fs/reiserfs/super.c:finish_unfinished()). */
1390 ! REISERFS_SB(inode -> i_sb) -> s_is_unlinked_ok ) { 1465 if ((inode->i_nlink == 0) &&
1391 reiserfs_warning (inode->i_sb, 1466 !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
1392 "vs-13075: reiserfs_read_locked_inode: " 1467 reiserfs_warning(inode->i_sb,
1393 "dead inode read from disk %K. " 1468 "vs-13075: reiserfs_read_locked_inode: "
1394 "This is likely to be race with knfsd. Ignore", 1469 "dead inode read from disk %K. "
1395 &key ); 1470 "This is likely to be race with knfsd. Ignore",
1396 reiserfs_make_bad_inode( inode ); 1471 &key);
1397 } 1472 reiserfs_make_bad_inode(inode);
1398 1473 }
1399 reiserfs_check_path(&path_to_sd) ; /* init inode should be relsing */ 1474
1475 reiserfs_check_path(&path_to_sd); /* init inode should be relsing */
1400 1476
1401} 1477}
1402 1478
@@ -1412,140 +1488,148 @@ void reiserfs_read_locked_inode (struct inode * inode, struct reiserfs_iget_args
1412 * inode numbers (objectids) are distinguished by parent directory ids. 1488 * inode numbers (objectids) are distinguished by parent directory ids.
1413 * 1489 *
1414 */ 1490 */
1415int reiserfs_find_actor( struct inode *inode, void *opaque ) 1491int reiserfs_find_actor(struct inode *inode, void *opaque)
1416{ 1492{
1417 struct reiserfs_iget_args *args; 1493 struct reiserfs_iget_args *args;
1418 1494
1419 args = opaque; 1495 args = opaque;
1420 /* args is already in CPU order */ 1496 /* args is already in CPU order */
1421 return (inode->i_ino == args->objectid) && 1497 return (inode->i_ino == args->objectid) &&
1422 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid); 1498 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
1423} 1499}
1424 1500
1425struct inode * reiserfs_iget (struct super_block * s, const struct cpu_key * key) 1501struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
1426{ 1502{
1427 struct inode * inode; 1503 struct inode *inode;
1428 struct reiserfs_iget_args args ; 1504 struct reiserfs_iget_args args;
1429 1505
1430 args.objectid = key->on_disk_key.k_objectid ; 1506 args.objectid = key->on_disk_key.k_objectid;
1431 args.dirid = key->on_disk_key.k_dir_id ; 1507 args.dirid = key->on_disk_key.k_dir_id;
1432 inode = iget5_locked (s, key->on_disk_key.k_objectid, 1508 inode = iget5_locked(s, key->on_disk_key.k_objectid,
1433 reiserfs_find_actor, reiserfs_init_locked_inode, (void *)(&args)); 1509 reiserfs_find_actor, reiserfs_init_locked_inode,
1434 if (!inode) 1510 (void *)(&args));
1435 return ERR_PTR(-ENOMEM) ; 1511 if (!inode)
1436 1512 return ERR_PTR(-ENOMEM);
1437 if (inode->i_state & I_NEW) { 1513
1438 reiserfs_read_locked_inode(inode, &args); 1514 if (inode->i_state & I_NEW) {
1439 unlock_new_inode(inode); 1515 reiserfs_read_locked_inode(inode, &args);
1440 } 1516 unlock_new_inode(inode);
1441 1517 }
1442 if (comp_short_keys (INODE_PKEY (inode), key) || is_bad_inode (inode)) { 1518
1443 /* either due to i/o error or a stale NFS handle */ 1519 if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1444 iput (inode); 1520 /* either due to i/o error or a stale NFS handle */
1445 inode = NULL; 1521 iput(inode);
1446 } 1522 inode = NULL;
1447 return inode; 1523 }
1524 return inode;
1448} 1525}
1449 1526
1450struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp) 1527struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)
1451{ 1528{
1452 __u32 *data = vobjp; 1529 __u32 *data = vobjp;
1453 struct cpu_key key ; 1530 struct cpu_key key;
1454 struct dentry *result; 1531 struct dentry *result;
1455 struct inode *inode; 1532 struct inode *inode;
1456 1533
1457 key.on_disk_key.k_objectid = data[0] ; 1534 key.on_disk_key.k_objectid = data[0];
1458 key.on_disk_key.k_dir_id = data[1] ; 1535 key.on_disk_key.k_dir_id = data[1];
1459 reiserfs_write_lock(sb); 1536 reiserfs_write_lock(sb);
1460 inode = reiserfs_iget(sb, &key) ; 1537 inode = reiserfs_iget(sb, &key);
1461 if (inode && !IS_ERR(inode) && data[2] != 0 && 1538 if (inode && !IS_ERR(inode) && data[2] != 0 &&
1462 data[2] != inode->i_generation) { 1539 data[2] != inode->i_generation) {
1463 iput(inode) ; 1540 iput(inode);
1464 inode = NULL ; 1541 inode = NULL;
1465 } 1542 }
1466 reiserfs_write_unlock(sb); 1543 reiserfs_write_unlock(sb);
1467 if (!inode) 1544 if (!inode)
1468 inode = ERR_PTR(-ESTALE); 1545 inode = ERR_PTR(-ESTALE);
1469 if (IS_ERR(inode)) 1546 if (IS_ERR(inode))
1470 return ERR_PTR(PTR_ERR(inode)); 1547 return ERR_PTR(PTR_ERR(inode));
1471 result = d_alloc_anon(inode); 1548 result = d_alloc_anon(inode);
1472 if (!result) { 1549 if (!result) {
1473 iput(inode); 1550 iput(inode);
1474 return ERR_PTR(-ENOMEM); 1551 return ERR_PTR(-ENOMEM);
1475 } 1552 }
1476 return result; 1553 return result;
1477} 1554}
1478 1555
1479struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 *data, 1556struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,
1480 int len, int fhtype, 1557 int len, int fhtype,
1481 int (*acceptable)(void *contect, struct dentry *de), 1558 int (*acceptable) (void *contect,
1482 void *context) { 1559 struct dentry * de),
1483 __u32 obj[3], parent[3]; 1560 void *context)
1484 1561{
1485 /* fhtype happens to reflect the number of u32s encoded. 1562 __u32 obj[3], parent[3];
1486 * due to a bug in earlier code, fhtype might indicate there 1563
1487 * are more u32s then actually fitted. 1564 /* fhtype happens to reflect the number of u32s encoded.
1488 * so if fhtype seems to be more than len, reduce fhtype. 1565 * due to a bug in earlier code, fhtype might indicate there
1489 * Valid types are: 1566 * are more u32s then actually fitted.
1490 * 2 - objectid + dir_id - legacy support 1567 * so if fhtype seems to be more than len, reduce fhtype.
1491 * 3 - objectid + dir_id + generation 1568 * Valid types are:
1492 * 4 - objectid + dir_id + objectid and dirid of parent - legacy 1569 * 2 - objectid + dir_id - legacy support
1493 * 5 - objectid + dir_id + generation + objectid and dirid of parent 1570 * 3 - objectid + dir_id + generation
1494 * 6 - as above plus generation of directory 1571 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1495 * 6 does not fit in NFSv2 handles 1572 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1496 */ 1573 * 6 - as above plus generation of directory
1497 if (fhtype > len) { 1574 * 6 does not fit in NFSv2 handles
1498 if (fhtype != 6 || len != 5) 1575 */
1499 reiserfs_warning (sb, "nfsd/reiserfs, fhtype=%d, len=%d - odd", 1576 if (fhtype > len) {
1500 fhtype, len); 1577 if (fhtype != 6 || len != 5)
1501 fhtype = 5; 1578 reiserfs_warning(sb,
1502 } 1579 "nfsd/reiserfs, fhtype=%d, len=%d - odd",
1503 1580 fhtype, len);
1504 obj[0] = data[0]; 1581 fhtype = 5;
1505 obj[1] = data[1]; 1582 }
1506 if (fhtype == 3 || fhtype >= 5) 1583
1507 obj[2] = data[2]; 1584 obj[0] = data[0];
1508 else obj[2] = 0; /* generation number */ 1585 obj[1] = data[1];
1509 1586 if (fhtype == 3 || fhtype >= 5)
1510 if (fhtype >= 4) { 1587 obj[2] = data[2];
1511 parent[0] = data[fhtype>=5?3:2] ; 1588 else
1512 parent[1] = data[fhtype>=5?4:3] ; 1589 obj[2] = 0; /* generation number */
1513 if (fhtype == 6)
1514 parent[2] = data[5];
1515 else parent[2] = 0;
1516 }
1517 return sb->s_export_op->find_exported_dentry(sb, obj, fhtype < 4 ? NULL : parent,
1518 acceptable, context);
1519}
1520 1590
1521int reiserfs_encode_fh(struct dentry *dentry, __u32 *data, int *lenp, int need_parent) { 1591 if (fhtype >= 4) {
1522 struct inode *inode = dentry->d_inode ; 1592 parent[0] = data[fhtype >= 5 ? 3 : 2];
1523 int maxlen = *lenp; 1593 parent[1] = data[fhtype >= 5 ? 4 : 3];
1524 1594 if (fhtype == 6)
1525 if (maxlen < 3) 1595 parent[2] = data[5];
1526 return 255 ; 1596 else
1527 1597 parent[2] = 0;
1528 data[0] = inode->i_ino ; 1598 }
1529 data[1] = le32_to_cpu(INODE_PKEY (inode)->k_dir_id) ; 1599 return sb->s_export_op->find_exported_dentry(sb, obj,
1530 data[2] = inode->i_generation ; 1600 fhtype < 4 ? NULL : parent,
1531 *lenp = 3 ; 1601 acceptable, context);
1532 /* no room for directory info? return what we've stored so far */
1533 if (maxlen < 5 || ! need_parent)
1534 return 3 ;
1535
1536 spin_lock(&dentry->d_lock);
1537 inode = dentry->d_parent->d_inode ;
1538 data[3] = inode->i_ino ;
1539 data[4] = le32_to_cpu(INODE_PKEY (inode)->k_dir_id) ;
1540 *lenp = 5 ;
1541 if (maxlen >= 6) {
1542 data[5] = inode->i_generation ;
1543 *lenp = 6 ;
1544 }
1545 spin_unlock(&dentry->d_lock);
1546 return *lenp ;
1547} 1602}
1548 1603
1604int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
1605 int need_parent)
1606{
1607 struct inode *inode = dentry->d_inode;
1608 int maxlen = *lenp;
1609
1610 if (maxlen < 3)
1611 return 255;
1612
1613 data[0] = inode->i_ino;
1614 data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1615 data[2] = inode->i_generation;
1616 *lenp = 3;
1617 /* no room for directory info? return what we've stored so far */
1618 if (maxlen < 5 || !need_parent)
1619 return 3;
1620
1621 spin_lock(&dentry->d_lock);
1622 inode = dentry->d_parent->d_inode;
1623 data[3] = inode->i_ino;
1624 data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1625 *lenp = 5;
1626 if (maxlen >= 6) {
1627 data[5] = inode->i_generation;
1628 *lenp = 6;
1629 }
1630 spin_unlock(&dentry->d_lock);
1631 return *lenp;
1632}
1549 1633
1550/* looks for stat data, then copies fields to it, marks the buffer 1634/* looks for stat data, then copies fields to it, marks the buffer
1551 containing stat data as dirty */ 1635 containing stat data as dirty */
@@ -1554,120 +1638,127 @@ int reiserfs_encode_fh(struct dentry *dentry, __u32 *data, int *lenp, int need_p
1554** to properly mark inodes for datasync and such, but only actually 1638** to properly mark inodes for datasync and such, but only actually
1555** does something when called for a synchronous update. 1639** does something when called for a synchronous update.
1556*/ 1640*/
1557int reiserfs_write_inode (struct inode * inode, int do_sync) { 1641int reiserfs_write_inode(struct inode *inode, int do_sync)
1558 struct reiserfs_transaction_handle th ; 1642{
1559 int jbegin_count = 1 ; 1643 struct reiserfs_transaction_handle th;
1560 1644 int jbegin_count = 1;
1561 if (inode->i_sb->s_flags & MS_RDONLY) 1645
1562 return -EROFS; 1646 if (inode->i_sb->s_flags & MS_RDONLY)
1563 /* memory pressure can sometimes initiate write_inode calls with sync == 1, 1647 return -EROFS;
1564 ** these cases are just when the system needs ram, not when the 1648 /* memory pressure can sometimes initiate write_inode calls with sync == 1,
1565 ** inode needs to reach disk for safety, and they can safely be 1649 ** these cases are just when the system needs ram, not when the
1566 ** ignored because the altered inode has already been logged. 1650 ** inode needs to reach disk for safety, and they can safely be
1567 */ 1651 ** ignored because the altered inode has already been logged.
1568 if (do_sync && !(current->flags & PF_MEMALLOC)) { 1652 */
1569 reiserfs_write_lock(inode->i_sb); 1653 if (do_sync && !(current->flags & PF_MEMALLOC)) {
1570 if (!journal_begin(&th, inode->i_sb, jbegin_count)) { 1654 reiserfs_write_lock(inode->i_sb);
1571 reiserfs_update_sd (&th, inode); 1655 if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
1572 journal_end_sync(&th, inode->i_sb, jbegin_count) ; 1656 reiserfs_update_sd(&th, inode);
1573 } 1657 journal_end_sync(&th, inode->i_sb, jbegin_count);
1574 reiserfs_write_unlock(inode->i_sb); 1658 }
1575 } 1659 reiserfs_write_unlock(inode->i_sb);
1576 return 0; 1660 }
1661 return 0;
1577} 1662}
1578 1663
1579/* stat data of new object is inserted already, this inserts the item 1664/* stat data of new object is inserted already, this inserts the item
1580 containing "." and ".." entries */ 1665 containing "." and ".." entries */
1581static int reiserfs_new_directory (struct reiserfs_transaction_handle *th, 1666static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1582 struct inode *inode, 1667 struct inode *inode,
1583 struct item_head * ih, struct path * path, 1668 struct item_head *ih, struct path *path,
1584 struct inode * dir) 1669 struct inode *dir)
1585{ 1670{
1586 struct super_block * sb = th->t_super; 1671 struct super_block *sb = th->t_super;
1587 char empty_dir [EMPTY_DIR_SIZE]; 1672 char empty_dir[EMPTY_DIR_SIZE];
1588 char * body = empty_dir; 1673 char *body = empty_dir;
1589 struct cpu_key key; 1674 struct cpu_key key;
1590 int retval; 1675 int retval;
1591 1676
1592 BUG_ON (!th->t_trans_id); 1677 BUG_ON(!th->t_trans_id);
1593 1678
1594 _make_cpu_key (&key, KEY_FORMAT_3_5, le32_to_cpu (ih->ih_key.k_dir_id), 1679 _make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),
1595 le32_to_cpu (ih->ih_key.k_objectid), DOT_OFFSET, TYPE_DIRENTRY, 3/*key length*/); 1680 le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,
1596 1681 TYPE_DIRENTRY, 3 /*key length */ );
1597 /* compose item head for new item. Directories consist of items of 1682
1598 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it 1683 /* compose item head for new item. Directories consist of items of
1599 is done by reiserfs_new_inode */ 1684 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1600 if (old_format_only (sb)) { 1685 is done by reiserfs_new_inode */
1601 make_le_item_head (ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET, TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2); 1686 if (old_format_only(sb)) {
1602 1687 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1603 make_empty_dir_item_v1 (body, ih->ih_key.k_dir_id, ih->ih_key.k_objectid, 1688 TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);
1604 INODE_PKEY (dir)->k_dir_id, 1689
1605 INODE_PKEY (dir)->k_objectid ); 1690 make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,
1606 } else { 1691 ih->ih_key.k_objectid,
1607 make_le_item_head (ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET, TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2); 1692 INODE_PKEY(dir)->k_dir_id,
1608 1693 INODE_PKEY(dir)->k_objectid);
1609 make_empty_dir_item (body, ih->ih_key.k_dir_id, ih->ih_key.k_objectid, 1694 } else {
1610 INODE_PKEY (dir)->k_dir_id, 1695 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1611 INODE_PKEY (dir)->k_objectid ); 1696 TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
1612 } 1697
1613 1698 make_empty_dir_item(body, ih->ih_key.k_dir_id,
1614 /* look for place in the tree for new item */ 1699 ih->ih_key.k_objectid,
1615 retval = search_item (sb, &key, path); 1700 INODE_PKEY(dir)->k_dir_id,
1616 if (retval == IO_ERROR) { 1701 INODE_PKEY(dir)->k_objectid);
1617 reiserfs_warning (sb, "vs-13080: reiserfs_new_directory: " 1702 }
1618 "i/o failure occurred creating new directory"); 1703
1619 return -EIO; 1704 /* look for place in the tree for new item */
1620 } 1705 retval = search_item(sb, &key, path);
1621 if (retval == ITEM_FOUND) { 1706 if (retval == IO_ERROR) {
1622 pathrelse (path); 1707 reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "
1623 reiserfs_warning (sb, "vs-13070: reiserfs_new_directory: " 1708 "i/o failure occurred creating new directory");
1624 "object with this key exists (%k)", &(ih->ih_key)); 1709 return -EIO;
1625 return -EEXIST; 1710 }
1626 } 1711 if (retval == ITEM_FOUND) {
1627 1712 pathrelse(path);
1628 /* insert item, that is empty directory item */ 1713 reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "
1629 return reiserfs_insert_item (th, path, &key, ih, inode, body); 1714 "object with this key exists (%k)",
1630} 1715 &(ih->ih_key));
1716 return -EEXIST;
1717 }
1631 1718
1719 /* insert item, that is empty directory item */
1720 return reiserfs_insert_item(th, path, &key, ih, inode, body);
1721}
1632 1722
1633/* stat data of object has been inserted, this inserts the item 1723/* stat data of object has been inserted, this inserts the item
1634 containing the body of symlink */ 1724 containing the body of symlink */
1635static int reiserfs_new_symlink (struct reiserfs_transaction_handle *th, 1725static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */
1636 struct inode *inode, /* Inode of symlink */ 1726 struct item_head *ih,
1637 struct item_head * ih, 1727 struct path *path, const char *symname,
1638 struct path * path, const char * symname, int item_len) 1728 int item_len)
1639{ 1729{
1640 struct super_block * sb = th->t_super; 1730 struct super_block *sb = th->t_super;
1641 struct cpu_key key; 1731 struct cpu_key key;
1642 int retval; 1732 int retval;
1643 1733
1644 BUG_ON (!th->t_trans_id); 1734 BUG_ON(!th->t_trans_id);
1645 1735
1646 _make_cpu_key (&key, KEY_FORMAT_3_5, 1736 _make_cpu_key(&key, KEY_FORMAT_3_5,
1647 le32_to_cpu (ih->ih_key.k_dir_id), 1737 le32_to_cpu(ih->ih_key.k_dir_id),
1648 le32_to_cpu (ih->ih_key.k_objectid), 1738 le32_to_cpu(ih->ih_key.k_objectid),
1649 1, TYPE_DIRECT, 3/*key length*/); 1739 1, TYPE_DIRECT, 3 /*key length */ );
1650 1740
1651 make_le_item_head (ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len, 0/*free_space*/); 1741 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1652 1742 0 /*free_space */ );
1653 /* look for place in the tree for new item */ 1743
1654 retval = search_item (sb, &key, path); 1744 /* look for place in the tree for new item */
1655 if (retval == IO_ERROR) { 1745 retval = search_item(sb, &key, path);
1656 reiserfs_warning (sb, "vs-13080: reiserfs_new_symlinik: " 1746 if (retval == IO_ERROR) {
1657 "i/o failure occurred creating new symlink"); 1747 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "
1658 return -EIO; 1748 "i/o failure occurred creating new symlink");
1659 } 1749 return -EIO;
1660 if (retval == ITEM_FOUND) { 1750 }
1661 pathrelse (path); 1751 if (retval == ITEM_FOUND) {
1662 reiserfs_warning (sb, "vs-13080: reiserfs_new_symlink: " 1752 pathrelse(path);
1663 "object with this key exists (%k)", &(ih->ih_key)); 1753 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "
1664 return -EEXIST; 1754 "object with this key exists (%k)",
1665 } 1755 &(ih->ih_key));
1666 1756 return -EEXIST;
1667 /* insert item, that is body of symlink */ 1757 }
1668 return reiserfs_insert_item (th, path, &key, ih, inode, symname);
1669}
1670 1758
1759 /* insert item, that is body of symlink */
1760 return reiserfs_insert_item(th, path, &key, ih, inode, symname);
1761}
1671 1762
1672/* inserts the stat data into the tree, and then calls 1763/* inserts the stat data into the tree, and then calls
1673 reiserfs_new_directory (to insert ".", ".." item if new object is 1764 reiserfs_new_directory (to insert ".", ".." item if new object is
@@ -1678,213 +1769,219 @@ static int reiserfs_new_symlink (struct reiserfs_transaction_handle *th,
1678 non-zero due to an error, we have to drop the quota previously allocated 1769 non-zero due to an error, we have to drop the quota previously allocated
1679 for the fresh inode. This can only be done outside a transaction, so 1770 for the fresh inode. This can only be done outside a transaction, so
1680 if we return non-zero, we also end the transaction. */ 1771 if we return non-zero, we also end the transaction. */
1681int reiserfs_new_inode (struct reiserfs_transaction_handle *th, 1772int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1682 struct inode * dir, int mode, 1773 struct inode *dir, int mode, const char *symname,
1683 const char * symname, 1774 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1684 /* 0 for regular, EMTRY_DIR_SIZE for dirs, 1775 strlen (symname) for symlinks) */
1685 strlen (symname) for symlinks)*/ 1776 loff_t i_size, struct dentry *dentry,
1686 loff_t i_size, struct dentry *dentry, 1777 struct inode *inode)
1687 struct inode *inode)
1688{ 1778{
1689 struct super_block * sb; 1779 struct super_block *sb;
1690 INITIALIZE_PATH (path_to_key); 1780 INITIALIZE_PATH(path_to_key);
1691 struct cpu_key key; 1781 struct cpu_key key;
1692 struct item_head ih; 1782 struct item_head ih;
1693 struct stat_data sd; 1783 struct stat_data sd;
1694 int retval; 1784 int retval;
1695 int err; 1785 int err;
1696 1786
1697 BUG_ON (!th->t_trans_id); 1787 BUG_ON(!th->t_trans_id);
1698 1788
1699 if (DQUOT_ALLOC_INODE(inode)) { 1789 if (DQUOT_ALLOC_INODE(inode)) {
1700 err = -EDQUOT; 1790 err = -EDQUOT;
1701 goto out_end_trans; 1791 goto out_end_trans;
1702 } 1792 }
1703 if (!dir || !dir->i_nlink) { 1793 if (!dir || !dir->i_nlink) {
1704 err = -EPERM; 1794 err = -EPERM;
1705 goto out_bad_inode; 1795 goto out_bad_inode;
1706 } 1796 }
1707 1797
1708 sb = dir->i_sb; 1798 sb = dir->i_sb;
1709 1799
1710 /* item head of new item */ 1800 /* item head of new item */
1711 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir); 1801 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);
1712 ih.ih_key.k_objectid = cpu_to_le32 (reiserfs_get_unused_objectid (th)); 1802 ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));
1713 if (!ih.ih_key.k_objectid) { 1803 if (!ih.ih_key.k_objectid) {
1714 err = -ENOMEM; 1804 err = -ENOMEM;
1715 goto out_bad_inode ; 1805 goto out_bad_inode;
1716 } 1806 }
1717 if (old_format_only (sb)) 1807 if (old_format_only(sb))
1718 /* not a perfect generation count, as object ids can be reused, but 1808 /* not a perfect generation count, as object ids can be reused, but
1719 ** this is as good as reiserfs can do right now. 1809 ** this is as good as reiserfs can do right now.
1720 ** note that the private part of inode isn't filled in yet, we have 1810 ** note that the private part of inode isn't filled in yet, we have
1721 ** to use the directory. 1811 ** to use the directory.
1722 */ 1812 */
1723 inode->i_generation = le32_to_cpu (INODE_PKEY (dir)->k_objectid); 1813 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1724 else 1814 else
1725#if defined( USE_INODE_GENERATION_COUNTER ) 1815#if defined( USE_INODE_GENERATION_COUNTER )
1726 inode->i_generation = le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation); 1816 inode->i_generation =
1817 le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1727#else 1818#else
1728 inode->i_generation = ++event; 1819 inode->i_generation = ++event;
1729#endif 1820#endif
1730 1821
1731 /* fill stat data */ 1822 /* fill stat data */
1732 inode->i_nlink = (S_ISDIR (mode) ? 2 : 1); 1823 inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);
1733 1824
1734 /* uid and gid must already be set by the caller for quota init */ 1825 /* uid and gid must already be set by the caller for quota init */
1735 1826
1736 /* symlink cannot be immutable or append only, right? */ 1827 /* symlink cannot be immutable or append only, right? */
1737 if( S_ISLNK( inode -> i_mode ) ) 1828 if (S_ISLNK(inode->i_mode))
1738 inode -> i_flags &= ~ ( S_IMMUTABLE | S_APPEND ); 1829 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1739 1830
1740 inode->i_mtime = inode->i_atime = inode->i_ctime = 1831 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1741 CURRENT_TIME_SEC; 1832 inode->i_size = i_size;
1742 inode->i_size = i_size; 1833 inode->i_blocks = 0;
1743 inode->i_blocks = 0; 1834 inode->i_bytes = 0;
1744 inode->i_bytes = 0; 1835 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1745 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 : 1836 U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;
1746 U32_MAX/*NO_BYTES_IN_DIRECT_ITEM*/; 1837
1747 1838 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1748 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list )); 1839 REISERFS_I(inode)->i_flags = 0;
1749 REISERFS_I(inode)->i_flags = 0; 1840 REISERFS_I(inode)->i_prealloc_block = 0;
1750 REISERFS_I(inode)->i_prealloc_block = 0; 1841 REISERFS_I(inode)->i_prealloc_count = 0;
1751 REISERFS_I(inode)->i_prealloc_count = 0; 1842 REISERFS_I(inode)->i_trans_id = 0;
1752 REISERFS_I(inode)->i_trans_id = 0; 1843 REISERFS_I(inode)->i_jl = NULL;
1753 REISERFS_I(inode)->i_jl = NULL; 1844 REISERFS_I(inode)->i_attrs =
1754 REISERFS_I(inode)->i_attrs = 1845 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;
1755 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK; 1846 sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);
1756 sd_attrs_to_i_attrs( REISERFS_I(inode) -> i_attrs, inode ); 1847 REISERFS_I(inode)->i_acl_access = NULL;
1757 REISERFS_I(inode)->i_acl_access = NULL; 1848 REISERFS_I(inode)->i_acl_default = NULL;
1758 REISERFS_I(inode)->i_acl_default = NULL; 1849 init_rwsem(&REISERFS_I(inode)->xattr_sem);
1759 init_rwsem (&REISERFS_I(inode)->xattr_sem); 1850
1760 1851 if (old_format_only(sb))
1761 if (old_format_only (sb)) 1852 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1762 make_le_item_head (&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET, TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT); 1853 TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1763 else 1854 else
1764 make_le_item_head (&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET, TYPE_STAT_DATA, SD_SIZE, MAX_US_INT); 1855 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1765 1856 TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1766 /* key to search for correct place for new stat data */ 1857
1767 _make_cpu_key (&key, KEY_FORMAT_3_6, le32_to_cpu (ih.ih_key.k_dir_id), 1858 /* key to search for correct place for new stat data */
1768 le32_to_cpu (ih.ih_key.k_objectid), SD_OFFSET, TYPE_STAT_DATA, 3/*key length*/); 1859 _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1769 1860 le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1770 /* find proper place for inserting of stat data */ 1861 TYPE_STAT_DATA, 3 /*key length */ );
1771 retval = search_item (sb, &key, &path_to_key); 1862
1772 if (retval == IO_ERROR) { 1863 /* find proper place for inserting of stat data */
1773 err = -EIO; 1864 retval = search_item(sb, &key, &path_to_key);
1774 goto out_bad_inode; 1865 if (retval == IO_ERROR) {
1775 } 1866 err = -EIO;
1776 if (retval == ITEM_FOUND) { 1867 goto out_bad_inode;
1777 pathrelse (&path_to_key); 1868 }
1778 err = -EEXIST; 1869 if (retval == ITEM_FOUND) {
1779 goto out_bad_inode; 1870 pathrelse(&path_to_key);
1780 } 1871 err = -EEXIST;
1781 if (old_format_only (sb)) { 1872 goto out_bad_inode;
1782 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) { 1873 }
1783 pathrelse (&path_to_key); 1874 if (old_format_only(sb)) {
1784 /* i_uid or i_gid is too big to be stored in stat data v3.5 */ 1875 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1785 err = -EINVAL; 1876 pathrelse(&path_to_key);
1786 goto out_bad_inode; 1877 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1787 } 1878 err = -EINVAL;
1788 inode2sd_v1 (&sd, inode, inode->i_size); 1879 goto out_bad_inode;
1789 } else { 1880 }
1790 inode2sd (&sd, inode, inode->i_size); 1881 inode2sd_v1(&sd, inode, inode->i_size);
1791 } 1882 } else {
1792 // these do not go to on-disk stat data 1883 inode2sd(&sd, inode, inode->i_size);
1793 inode->i_ino = le32_to_cpu (ih.ih_key.k_objectid); 1884 }
1794 inode->i_blksize = reiserfs_default_io_size; 1885 // these do not go to on-disk stat data
1795 1886 inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1796 // store in in-core inode the key of stat data and version all 1887 inode->i_blksize = reiserfs_default_io_size;
1797 // object items will have (directory items will have old offset 1888
1798 // format, other new objects will consist of new items) 1889 // store in in-core inode the key of stat data and version all
1799 memcpy (INODE_PKEY (inode), &(ih.ih_key), KEY_SIZE); 1890 // object items will have (directory items will have old offset
1800 if (old_format_only (sb) || S_ISDIR(mode) || S_ISLNK(mode)) 1891 // format, other new objects will consist of new items)
1801 set_inode_item_key_version (inode, KEY_FORMAT_3_5); 1892 memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1802 else 1893 if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1803 set_inode_item_key_version (inode, KEY_FORMAT_3_6); 1894 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1804 if (old_format_only (sb)) 1895 else
1805 set_inode_sd_version (inode, STAT_DATA_V1); 1896 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1806 else 1897 if (old_format_only(sb))
1807 set_inode_sd_version (inode, STAT_DATA_V2); 1898 set_inode_sd_version(inode, STAT_DATA_V1);
1808 1899 else
1809 /* insert the stat data into the tree */ 1900 set_inode_sd_version(inode, STAT_DATA_V2);
1901
1902 /* insert the stat data into the tree */
1810#ifdef DISPLACE_NEW_PACKING_LOCALITIES 1903#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1811 if (REISERFS_I(dir)->new_packing_locality) 1904 if (REISERFS_I(dir)->new_packing_locality)
1812 th->displace_new_blocks = 1; 1905 th->displace_new_blocks = 1;
1813#endif 1906#endif
1814 retval = reiserfs_insert_item (th, &path_to_key, &key, &ih, inode, (char *)(&sd)); 1907 retval =
1815 if (retval) { 1908 reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1816 err = retval; 1909 (char *)(&sd));
1817 reiserfs_check_path(&path_to_key) ; 1910 if (retval) {
1818 goto out_bad_inode; 1911 err = retval;
1819 } 1912 reiserfs_check_path(&path_to_key);
1820 1913 goto out_bad_inode;
1914 }
1821#ifdef DISPLACE_NEW_PACKING_LOCALITIES 1915#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1822 if (!th->displace_new_blocks) 1916 if (!th->displace_new_blocks)
1823 REISERFS_I(dir)->new_packing_locality = 0; 1917 REISERFS_I(dir)->new_packing_locality = 0;
1824#endif 1918#endif
1825 if (S_ISDIR(mode)) { 1919 if (S_ISDIR(mode)) {
1826 /* insert item with "." and ".." */ 1920 /* insert item with "." and ".." */
1827 retval = reiserfs_new_directory (th, inode, &ih, &path_to_key, dir); 1921 retval =
1828 } 1922 reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1829 1923 }
1830 if (S_ISLNK(mode)) { 1924
1831 /* insert body of symlink */ 1925 if (S_ISLNK(mode)) {
1832 if (!old_format_only (sb)) 1926 /* insert body of symlink */
1833 i_size = ROUND_UP(i_size); 1927 if (!old_format_only(sb))
1834 retval = reiserfs_new_symlink (th, inode, &ih, &path_to_key, symname, i_size); 1928 i_size = ROUND_UP(i_size);
1835 } 1929 retval =
1836 if (retval) { 1930 reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1837 err = retval; 1931 i_size);
1838 reiserfs_check_path(&path_to_key) ; 1932 }
1839 journal_end(th, th->t_super, th->t_blocks_allocated); 1933 if (retval) {
1840 goto out_inserted_sd; 1934 err = retval;
1841 } 1935 reiserfs_check_path(&path_to_key);
1842 1936 journal_end(th, th->t_super, th->t_blocks_allocated);
1843 /* XXX CHECK THIS */ 1937 goto out_inserted_sd;
1844 if (reiserfs_posixacl (inode->i_sb)) { 1938 }
1845 retval = reiserfs_inherit_default_acl (dir, dentry, inode); 1939
1846 if (retval) { 1940 /* XXX CHECK THIS */
1847 err = retval; 1941 if (reiserfs_posixacl(inode->i_sb)) {
1848 reiserfs_check_path(&path_to_key) ; 1942 retval = reiserfs_inherit_default_acl(dir, dentry, inode);
1849 journal_end(th, th->t_super, th->t_blocks_allocated); 1943 if (retval) {
1850 goto out_inserted_sd; 1944 err = retval;
1851 } 1945 reiserfs_check_path(&path_to_key);
1852 } else if (inode->i_sb->s_flags & MS_POSIXACL) { 1946 journal_end(th, th->t_super, th->t_blocks_allocated);
1853 reiserfs_warning (inode->i_sb, "ACLs aren't enabled in the fs, " 1947 goto out_inserted_sd;
1854 "but vfs thinks they are!"); 1948 }
1855 } else if (is_reiserfs_priv_object (dir)) { 1949 } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1856 reiserfs_mark_inode_private (inode); 1950 reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
1857 } 1951 "but vfs thinks they are!");
1858 1952 } else if (is_reiserfs_priv_object(dir)) {
1859 insert_inode_hash (inode); 1953 reiserfs_mark_inode_private(inode);
1860 reiserfs_update_sd(th, inode); 1954 }
1861 reiserfs_check_path(&path_to_key) ; 1955
1862 1956 insert_inode_hash(inode);
1863 return 0; 1957 reiserfs_update_sd(th, inode);
1958 reiserfs_check_path(&path_to_key);
1959
1960 return 0;
1864 1961
1865/* it looks like you can easily compress these two goto targets into 1962/* it looks like you can easily compress these two goto targets into
1866 * one. Keeping it like this doesn't actually hurt anything, and they 1963 * one. Keeping it like this doesn't actually hurt anything, and they
1867 * are place holders for what the quota code actually needs. 1964 * are place holders for what the quota code actually needs.
1868 */ 1965 */
1869out_bad_inode: 1966 out_bad_inode:
1870 /* Invalidate the object, nothing was inserted yet */ 1967 /* Invalidate the object, nothing was inserted yet */
1871 INODE_PKEY(inode)->k_objectid = 0; 1968 INODE_PKEY(inode)->k_objectid = 0;
1872 1969
1873 /* Quota change must be inside a transaction for journaling */ 1970 /* Quota change must be inside a transaction for journaling */
1874 DQUOT_FREE_INODE(inode); 1971 DQUOT_FREE_INODE(inode);
1875 1972
1876out_end_trans: 1973 out_end_trans:
1877 journal_end(th, th->t_super, th->t_blocks_allocated) ; 1974 journal_end(th, th->t_super, th->t_blocks_allocated);
1878 /* Drop can be outside and it needs more credits so it's better to have it outside */ 1975 /* Drop can be outside and it needs more credits so it's better to have it outside */
1879 DQUOT_DROP(inode); 1976 DQUOT_DROP(inode);
1880 inode->i_flags |= S_NOQUOTA; 1977 inode->i_flags |= S_NOQUOTA;
1881 make_bad_inode(inode); 1978 make_bad_inode(inode);
1882 1979
1883out_inserted_sd: 1980 out_inserted_sd:
1884 inode->i_nlink = 0; 1981 inode->i_nlink = 0;
1885 th->t_trans_id = 0; /* so the caller can't use this handle later */ 1982 th->t_trans_id = 0; /* so the caller can't use this handle later */
1886 iput(inode); 1983 iput(inode);
1887 return err; 1984 return err;
1888} 1985}
1889 1986
1890/* 1987/*
@@ -1900,77 +1997,78 @@ out_inserted_sd:
1900** 1997**
1901** on failure, nonzero is returned, page_result and bh_result are untouched. 1998** on failure, nonzero is returned, page_result and bh_result are untouched.
1902*/ 1999*/
1903static int grab_tail_page(struct inode *p_s_inode, 2000static int grab_tail_page(struct inode *p_s_inode,
1904 struct page **page_result, 2001 struct page **page_result,
1905 struct buffer_head **bh_result) { 2002 struct buffer_head **bh_result)
1906 2003{
1907 /* we want the page with the last byte in the file, 2004
1908 ** not the page that will hold the next byte for appending 2005 /* we want the page with the last byte in the file,
1909 */ 2006 ** not the page that will hold the next byte for appending
1910 unsigned long index = (p_s_inode->i_size-1) >> PAGE_CACHE_SHIFT ; 2007 */
1911 unsigned long pos = 0 ; 2008 unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;
1912 unsigned long start = 0 ; 2009 unsigned long pos = 0;
1913 unsigned long blocksize = p_s_inode->i_sb->s_blocksize ; 2010 unsigned long start = 0;
1914 unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1) ; 2011 unsigned long blocksize = p_s_inode->i_sb->s_blocksize;
1915 struct buffer_head *bh ; 2012 unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);
1916 struct buffer_head *head ; 2013 struct buffer_head *bh;
1917 struct page * page ; 2014 struct buffer_head *head;
1918 int error ; 2015 struct page *page;
1919 2016 int error;
1920 /* we know that we are only called with inode->i_size > 0. 2017
1921 ** we also know that a file tail can never be as big as a block 2018 /* we know that we are only called with inode->i_size > 0.
1922 ** If i_size % blocksize == 0, our file is currently block aligned 2019 ** we also know that a file tail can never be as big as a block
1923 ** and it won't need converting or zeroing after a truncate. 2020 ** If i_size % blocksize == 0, our file is currently block aligned
1924 */ 2021 ** and it won't need converting or zeroing after a truncate.
1925 if ((offset & (blocksize - 1)) == 0) { 2022 */
1926 return -ENOENT ; 2023 if ((offset & (blocksize - 1)) == 0) {
1927 } 2024 return -ENOENT;
1928 page = grab_cache_page(p_s_inode->i_mapping, index) ; 2025 }
1929 error = -ENOMEM ; 2026 page = grab_cache_page(p_s_inode->i_mapping, index);
1930 if (!page) { 2027 error = -ENOMEM;
1931 goto out ; 2028 if (!page) {
1932 } 2029 goto out;
1933 /* start within the page of the last block in the file */ 2030 }
1934 start = (offset / blocksize) * blocksize ; 2031 /* start within the page of the last block in the file */
1935 2032 start = (offset / blocksize) * blocksize;
1936 error = block_prepare_write(page, start, offset, 2033
1937 reiserfs_get_block_create_0) ; 2034 error = block_prepare_write(page, start, offset,
1938 if (error) 2035 reiserfs_get_block_create_0);
1939 goto unlock ; 2036 if (error)
1940 2037 goto unlock;
1941 head = page_buffers(page) ; 2038
1942 bh = head; 2039 head = page_buffers(page);
1943 do { 2040 bh = head;
1944 if (pos >= start) { 2041 do {
1945 break ; 2042 if (pos >= start) {
1946 } 2043 break;
1947 bh = bh->b_this_page ; 2044 }
1948 pos += blocksize ; 2045 bh = bh->b_this_page;
1949 } while(bh != head) ; 2046 pos += blocksize;
1950 2047 } while (bh != head);
1951 if (!buffer_uptodate(bh)) { 2048
1952 /* note, this should never happen, prepare_write should 2049 if (!buffer_uptodate(bh)) {
1953 ** be taking care of this for us. If the buffer isn't up to date, 2050 /* note, this should never happen, prepare_write should
1954 ** I've screwed up the code to find the buffer, or the code to 2051 ** be taking care of this for us. If the buffer isn't up to date,
1955 ** call prepare_write 2052 ** I've screwed up the code to find the buffer, or the code to
1956 */ 2053 ** call prepare_write
1957 reiserfs_warning (p_s_inode->i_sb, 2054 */
1958 "clm-6000: error reading block %lu on dev %s", 2055 reiserfs_warning(p_s_inode->i_sb,
1959 bh->b_blocknr, 2056 "clm-6000: error reading block %lu on dev %s",
1960 reiserfs_bdevname (p_s_inode->i_sb)) ; 2057 bh->b_blocknr,
1961 error = -EIO ; 2058 reiserfs_bdevname(p_s_inode->i_sb));
1962 goto unlock ; 2059 error = -EIO;
1963 } 2060 goto unlock;
1964 *bh_result = bh ; 2061 }
1965 *page_result = page ; 2062 *bh_result = bh;
1966 2063 *page_result = page;
1967out: 2064
1968 return error ; 2065 out:
1969 2066 return error;
1970unlock: 2067
1971 unlock_page(page) ; 2068 unlock:
1972 page_cache_release(page) ; 2069 unlock_page(page);
1973 return error ; 2070 page_cache_release(page);
2071 return error;
1974} 2072}
1975 2073
1976/* 2074/*
@@ -1979,235 +2077,247 @@ unlock:
1979** 2077**
1980** some code taken from block_truncate_page 2078** some code taken from block_truncate_page
1981*/ 2079*/
1982int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps) { 2080int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
1983 struct reiserfs_transaction_handle th ; 2081{
1984 /* we want the offset for the first byte after the end of the file */ 2082 struct reiserfs_transaction_handle th;
1985 unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1) ; 2083 /* we want the offset for the first byte after the end of the file */
1986 unsigned blocksize = p_s_inode->i_sb->s_blocksize ; 2084 unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);
1987 unsigned length ; 2085 unsigned blocksize = p_s_inode->i_sb->s_blocksize;
1988 struct page *page = NULL ; 2086 unsigned length;
1989 int error ; 2087 struct page *page = NULL;
1990 struct buffer_head *bh = NULL ; 2088 int error;
1991 2089 struct buffer_head *bh = NULL;
1992 reiserfs_write_lock(p_s_inode->i_sb); 2090
1993 2091 reiserfs_write_lock(p_s_inode->i_sb);
1994 if (p_s_inode->i_size > 0) { 2092
1995 if ((error = grab_tail_page(p_s_inode, &page, &bh))) { 2093 if (p_s_inode->i_size > 0) {
1996 // -ENOENT means we truncated past the end of the file, 2094 if ((error = grab_tail_page(p_s_inode, &page, &bh))) {
1997 // and get_block_create_0 could not find a block to read in, 2095 // -ENOENT means we truncated past the end of the file,
1998 // which is ok. 2096 // and get_block_create_0 could not find a block to read in,
1999 if (error != -ENOENT) 2097 // which is ok.
2000 reiserfs_warning (p_s_inode->i_sb, 2098 if (error != -ENOENT)
2001 "clm-6001: grab_tail_page failed %d", 2099 reiserfs_warning(p_s_inode->i_sb,
2002 error); 2100 "clm-6001: grab_tail_page failed %d",
2003 page = NULL ; 2101 error);
2004 bh = NULL ; 2102 page = NULL;
2005 } 2103 bh = NULL;
2006 } 2104 }
2007 2105 }
2008 /* so, if page != NULL, we have a buffer head for the offset at
2009 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2010 ** then we have an unformatted node. Otherwise, we have a direct item,
2011 ** and no zeroing is required on disk. We zero after the truncate,
2012 ** because the truncate might pack the item anyway
2013 ** (it will unmap bh if it packs).
2014 */
2015 /* it is enough to reserve space in transaction for 2 balancings:
2016 one for "save" link adding and another for the first
2017 cut_from_item. 1 is for update_sd */
2018 error = journal_begin (&th, p_s_inode->i_sb,
2019 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2020 if (error)
2021 goto out;
2022 reiserfs_update_inode_transaction(p_s_inode) ;
2023 if (update_timestamps)
2024 /* we are doing real truncate: if the system crashes before the last
2025 transaction of truncating gets committed - on reboot the file
2026 either appears truncated properly or not truncated at all */
2027 add_save_link (&th, p_s_inode, 1);
2028 error = reiserfs_do_truncate (&th, p_s_inode, page, update_timestamps) ;
2029 if (error)
2030 goto out;
2031 error = journal_end (&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2032 if (error)
2033 goto out;
2034
2035 if (update_timestamps) {
2036 error = remove_save_link (p_s_inode, 1/* truncate */);
2037 if (error)
2038 goto out;
2039 }
2040
2041 if (page) {
2042 length = offset & (blocksize - 1) ;
2043 /* if we are not on a block boundary */
2044 if (length) {
2045 char *kaddr;
2046
2047 length = blocksize - length ;
2048 kaddr = kmap_atomic(page, KM_USER0) ;
2049 memset(kaddr + offset, 0, length) ;
2050 flush_dcache_page(page) ;
2051 kunmap_atomic(kaddr, KM_USER0) ;
2052 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2053 mark_buffer_dirty(bh) ;
2054 }
2055 }
2056 unlock_page(page) ;
2057 page_cache_release(page) ;
2058 }
2059
2060 reiserfs_write_unlock(p_s_inode->i_sb);
2061 return 0;
2062out:
2063 if (page) {
2064 unlock_page (page);
2065 page_cache_release (page);
2066 }
2067 reiserfs_write_unlock(p_s_inode->i_sb);
2068 return error;
2069}
2070 2106
2071static int map_block_for_writepage(struct inode *inode, 2107 /* so, if page != NULL, we have a buffer head for the offset at
2072 struct buffer_head *bh_result, 2108 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2073 unsigned long block) { 2109 ** then we have an unformatted node. Otherwise, we have a direct item,
2074 struct reiserfs_transaction_handle th ; 2110 ** and no zeroing is required on disk. We zero after the truncate,
2075 int fs_gen ; 2111 ** because the truncate might pack the item anyway
2076 struct item_head tmp_ih ; 2112 ** (it will unmap bh if it packs).
2077 struct item_head *ih ;
2078 struct buffer_head *bh ;
2079 __le32 *item ;
2080 struct cpu_key key ;
2081 INITIALIZE_PATH(path) ;
2082 int pos_in_item ;
2083 int jbegin_count = JOURNAL_PER_BALANCE_CNT ;
2084 loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1 ;
2085 int retval ;
2086 int use_get_block = 0 ;
2087 int bytes_copied = 0 ;
2088 int copy_size ;
2089 int trans_running = 0;
2090
2091 /* catch places below that try to log something without starting a trans */
2092 th.t_trans_id = 0;
2093
2094 if (!buffer_uptodate(bh_result)) {
2095 return -EIO;
2096 }
2097
2098 kmap(bh_result->b_page) ;
2099start_over:
2100 reiserfs_write_lock(inode->i_sb);
2101 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3) ;
2102
2103research:
2104 retval = search_for_position_by_key(inode->i_sb, &key, &path) ;
2105 if (retval != POSITION_FOUND) {
2106 use_get_block = 1;
2107 goto out ;
2108 }
2109
2110 bh = get_last_bh(&path) ;
2111 ih = get_ih(&path) ;
2112 item = get_item(&path) ;
2113 pos_in_item = path.pos_in_item ;
2114
2115 /* we've found an unformatted node */
2116 if (indirect_item_found(retval, ih)) {
2117 if (bytes_copied > 0) {
2118 reiserfs_warning (inode->i_sb, "clm-6002: bytes_copied %d",
2119 bytes_copied) ;
2120 }
2121 if (!get_block_num(item, pos_in_item)) {
2122 /* crap, we are writing to a hole */
2123 use_get_block = 1;
2124 goto out ;
2125 }
2126 set_block_dev_mapped(bh_result, get_block_num(item,pos_in_item),inode);
2127 } else if (is_direct_le_ih(ih)) {
2128 char *p ;
2129 p = page_address(bh_result->b_page) ;
2130 p += (byte_offset -1) & (PAGE_CACHE_SIZE - 1) ;
2131 copy_size = ih_item_len(ih) - pos_in_item;
2132
2133 fs_gen = get_generation(inode->i_sb) ;
2134 copy_item_head(&tmp_ih, ih) ;
2135
2136 if (!trans_running) {
2137 /* vs-3050 is gone, no need to drop the path */
2138 retval = journal_begin(&th, inode->i_sb, jbegin_count) ;
2139 if (retval)
2140 goto out;
2141 reiserfs_update_inode_transaction(inode) ;
2142 trans_running = 1;
2143 if (fs_changed(fs_gen, inode->i_sb) && item_moved(&tmp_ih, &path)) {
2144 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ;
2145 goto research;
2146 }
2147 }
2148
2149 reiserfs_prepare_for_journal(inode->i_sb, bh, 1) ;
2150
2151 if (fs_changed (fs_gen, inode->i_sb) && item_moved (&tmp_ih, &path)) {
2152 reiserfs_restore_prepared_buffer(inode->i_sb, bh) ;
2153 goto research;
2154 }
2155
2156 memcpy( B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied, copy_size) ;
2157
2158 journal_mark_dirty(&th, inode->i_sb, bh) ;
2159 bytes_copied += copy_size ;
2160 set_block_dev_mapped(bh_result, 0, inode);
2161
2162 /* are there still bytes left? */
2163 if (bytes_copied < bh_result->b_size &&
2164 (byte_offset + bytes_copied) < inode->i_size) {
2165 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + copy_size) ;
2166 goto research ;
2167 }
2168 } else {
2169 reiserfs_warning (inode->i_sb,
2170 "clm-6003: bad item inode %lu, device %s",
2171 inode->i_ino, reiserfs_bdevname (inode->i_sb)) ;
2172 retval = -EIO ;
2173 goto out ;
2174 }
2175 retval = 0 ;
2176
2177out:
2178 pathrelse(&path) ;
2179 if (trans_running) {
2180 int err = journal_end(&th, inode->i_sb, jbegin_count) ;
2181 if (err)
2182 retval = err;
2183 trans_running = 0;
2184 }
2185 reiserfs_write_unlock(inode->i_sb);
2186
2187 /* this is where we fill in holes in the file. */
2188 if (use_get_block) {
2189 retval = reiserfs_get_block(inode, block, bh_result,
2190 GET_BLOCK_CREATE | GET_BLOCK_NO_ISEM |
2191 GET_BLOCK_NO_DANGLE);
2192 if (!retval) {
2193 if (!buffer_mapped(bh_result) || bh_result->b_blocknr == 0) {
2194 /* get_block failed to find a mapped unformatted node. */
2195 use_get_block = 0 ;
2196 goto start_over ;
2197 }
2198 }
2199 }
2200 kunmap(bh_result->b_page) ;
2201
2202 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2203 /* we've copied data from the page into the direct item, so the
2204 * buffer in the page is now clean, mark it to reflect that.
2205 */ 2113 */
2206 lock_buffer(bh_result); 2114 /* it is enough to reserve space in transaction for 2 balancings:
2207 clear_buffer_dirty(bh_result); 2115 one for "save" link adding and another for the first
2208 unlock_buffer(bh_result); 2116 cut_from_item. 1 is for update_sd */
2209 } 2117 error = journal_begin(&th, p_s_inode->i_sb,
2210 return retval ; 2118 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2119 if (error)
2120 goto out;
2121 reiserfs_update_inode_transaction(p_s_inode);
2122 if (update_timestamps)
2123 /* we are doing real truncate: if the system crashes before the last
2124 transaction of truncating gets committed - on reboot the file
2125 either appears truncated properly or not truncated at all */
2126 add_save_link(&th, p_s_inode, 1);
2127 error = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);
2128 if (error)
2129 goto out;
2130 error =
2131 journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2132 if (error)
2133 goto out;
2134
2135 if (update_timestamps) {
2136 error = remove_save_link(p_s_inode, 1 /* truncate */ );
2137 if (error)
2138 goto out;
2139 }
2140
2141 if (page) {
2142 length = offset & (blocksize - 1);
2143 /* if we are not on a block boundary */
2144 if (length) {
2145 char *kaddr;
2146
2147 length = blocksize - length;
2148 kaddr = kmap_atomic(page, KM_USER0);
2149 memset(kaddr + offset, 0, length);
2150 flush_dcache_page(page);
2151 kunmap_atomic(kaddr, KM_USER0);
2152 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2153 mark_buffer_dirty(bh);
2154 }
2155 }
2156 unlock_page(page);
2157 page_cache_release(page);
2158 }
2159
2160 reiserfs_write_unlock(p_s_inode->i_sb);
2161 return 0;
2162 out:
2163 if (page) {
2164 unlock_page(page);
2165 page_cache_release(page);
2166 }
2167 reiserfs_write_unlock(p_s_inode->i_sb);
2168 return error;
2169}
2170
2171static int map_block_for_writepage(struct inode *inode,
2172 struct buffer_head *bh_result,
2173 unsigned long block)
2174{
2175 struct reiserfs_transaction_handle th;
2176 int fs_gen;
2177 struct item_head tmp_ih;
2178 struct item_head *ih;
2179 struct buffer_head *bh;
2180 __le32 *item;
2181 struct cpu_key key;
2182 INITIALIZE_PATH(path);
2183 int pos_in_item;
2184 int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2185 loff_t byte_offset = (block << inode->i_sb->s_blocksize_bits) + 1;
2186 int retval;
2187 int use_get_block = 0;
2188 int bytes_copied = 0;
2189 int copy_size;
2190 int trans_running = 0;
2191
2192 /* catch places below that try to log something without starting a trans */
2193 th.t_trans_id = 0;
2194
2195 if (!buffer_uptodate(bh_result)) {
2196 return -EIO;
2197 }
2198
2199 kmap(bh_result->b_page);
2200 start_over:
2201 reiserfs_write_lock(inode->i_sb);
2202 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
2203
2204 research:
2205 retval = search_for_position_by_key(inode->i_sb, &key, &path);
2206 if (retval != POSITION_FOUND) {
2207 use_get_block = 1;
2208 goto out;
2209 }
2210
2211 bh = get_last_bh(&path);
2212 ih = get_ih(&path);
2213 item = get_item(&path);
2214 pos_in_item = path.pos_in_item;
2215
2216 /* we've found an unformatted node */
2217 if (indirect_item_found(retval, ih)) {
2218 if (bytes_copied > 0) {
2219 reiserfs_warning(inode->i_sb,
2220 "clm-6002: bytes_copied %d",
2221 bytes_copied);
2222 }
2223 if (!get_block_num(item, pos_in_item)) {
2224 /* crap, we are writing to a hole */
2225 use_get_block = 1;
2226 goto out;
2227 }
2228 set_block_dev_mapped(bh_result,
2229 get_block_num(item, pos_in_item), inode);
2230 } else if (is_direct_le_ih(ih)) {
2231 char *p;
2232 p = page_address(bh_result->b_page);
2233 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2234 copy_size = ih_item_len(ih) - pos_in_item;
2235
2236 fs_gen = get_generation(inode->i_sb);
2237 copy_item_head(&tmp_ih, ih);
2238
2239 if (!trans_running) {
2240 /* vs-3050 is gone, no need to drop the path */
2241 retval = journal_begin(&th, inode->i_sb, jbegin_count);
2242 if (retval)
2243 goto out;
2244 reiserfs_update_inode_transaction(inode);
2245 trans_running = 1;
2246 if (fs_changed(fs_gen, inode->i_sb)
2247 && item_moved(&tmp_ih, &path)) {
2248 reiserfs_restore_prepared_buffer(inode->i_sb,
2249 bh);
2250 goto research;
2251 }
2252 }
2253
2254 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2255
2256 if (fs_changed(fs_gen, inode->i_sb)
2257 && item_moved(&tmp_ih, &path)) {
2258 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2259 goto research;
2260 }
2261
2262 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2263 copy_size);
2264
2265 journal_mark_dirty(&th, inode->i_sb, bh);
2266 bytes_copied += copy_size;
2267 set_block_dev_mapped(bh_result, 0, inode);
2268
2269 /* are there still bytes left? */
2270 if (bytes_copied < bh_result->b_size &&
2271 (byte_offset + bytes_copied) < inode->i_size) {
2272 set_cpu_key_k_offset(&key,
2273 cpu_key_k_offset(&key) +
2274 copy_size);
2275 goto research;
2276 }
2277 } else {
2278 reiserfs_warning(inode->i_sb,
2279 "clm-6003: bad item inode %lu, device %s",
2280 inode->i_ino, reiserfs_bdevname(inode->i_sb));
2281 retval = -EIO;
2282 goto out;
2283 }
2284 retval = 0;
2285
2286 out:
2287 pathrelse(&path);
2288 if (trans_running) {
2289 int err = journal_end(&th, inode->i_sb, jbegin_count);
2290 if (err)
2291 retval = err;
2292 trans_running = 0;
2293 }
2294 reiserfs_write_unlock(inode->i_sb);
2295
2296 /* this is where we fill in holes in the file. */
2297 if (use_get_block) {
2298 retval = reiserfs_get_block(inode, block, bh_result,
2299 GET_BLOCK_CREATE | GET_BLOCK_NO_ISEM
2300 | GET_BLOCK_NO_DANGLE);
2301 if (!retval) {
2302 if (!buffer_mapped(bh_result)
2303 || bh_result->b_blocknr == 0) {
2304 /* get_block failed to find a mapped unformatted node. */
2305 use_get_block = 0;
2306 goto start_over;
2307 }
2308 }
2309 }
2310 kunmap(bh_result->b_page);
2311
2312 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2313 /* we've copied data from the page into the direct item, so the
2314 * buffer in the page is now clean, mark it to reflect that.
2315 */
2316 lock_buffer(bh_result);
2317 clear_buffer_dirty(bh_result);
2318 unlock_buffer(bh_result);
2319 }
2320 return retval;
2211} 2321}
2212 2322
2213/* 2323/*
@@ -2215,383 +2325,390 @@ out:
2215 * start/recovery path as __block_write_full_page, along with special 2325 * start/recovery path as __block_write_full_page, along with special
2216 * code to handle reiserfs tails. 2326 * code to handle reiserfs tails.
2217 */ 2327 */
2218static int reiserfs_write_full_page(struct page *page, struct writeback_control *wbc) { 2328static int reiserfs_write_full_page(struct page *page,
2219 struct inode *inode = page->mapping->host ; 2329 struct writeback_control *wbc)
2220 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT ; 2330{
2221 int error = 0; 2331 struct inode *inode = page->mapping->host;
2222 unsigned long block ; 2332 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2223 struct buffer_head *head, *bh; 2333 int error = 0;
2224 int partial = 0 ; 2334 unsigned long block;
2225 int nr = 0; 2335 struct buffer_head *head, *bh;
2226 int checked = PageChecked(page); 2336 int partial = 0;
2227 struct reiserfs_transaction_handle th; 2337 int nr = 0;
2228 struct super_block *s = inode->i_sb; 2338 int checked = PageChecked(page);
2229 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize; 2339 struct reiserfs_transaction_handle th;
2230 th.t_trans_id = 0; 2340 struct super_block *s = inode->i_sb;
2231 2341 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2232 /* The page dirty bit is cleared before writepage is called, which 2342 th.t_trans_id = 0;
2233 * means we have to tell create_empty_buffers to make dirty buffers 2343
2234 * The page really should be up to date at this point, so tossing 2344 /* The page dirty bit is cleared before writepage is called, which
2235 * in the BH_Uptodate is just a sanity check. 2345 * means we have to tell create_empty_buffers to make dirty buffers
2236 */ 2346 * The page really should be up to date at this point, so tossing
2237 if (!page_has_buffers(page)) { 2347 * in the BH_Uptodate is just a sanity check.
2238 create_empty_buffers(page, s->s_blocksize, 2348 */
2239 (1 << BH_Dirty) | (1 << BH_Uptodate)); 2349 if (!page_has_buffers(page)) {
2240 } 2350 create_empty_buffers(page, s->s_blocksize,
2241 head = page_buffers(page) ; 2351 (1 << BH_Dirty) | (1 << BH_Uptodate));
2242 2352 }
2243 /* last page in the file, zero out any contents past the 2353 head = page_buffers(page);
2244 ** last byte in the file
2245 */
2246 if (page->index >= end_index) {
2247 char *kaddr;
2248 unsigned last_offset;
2249
2250 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1) ;
2251 /* no file contents in this page */
2252 if (page->index >= end_index + 1 || !last_offset) {
2253 unlock_page(page);
2254 return 0;
2255 }
2256 kaddr = kmap_atomic(page, KM_USER0);
2257 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE-last_offset) ;
2258 flush_dcache_page(page) ;
2259 kunmap_atomic(kaddr, KM_USER0) ;
2260 }
2261 bh = head ;
2262 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits) ;
2263 /* first map all the buffers, logging any direct items we find */
2264 do {
2265 if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
2266 (buffer_mapped(bh) && bh->b_blocknr == 0))) {
2267 /* not mapped yet, or it points to a direct item, search
2268 * the btree for the mapping info, and log any direct
2269 * items found
2270 */
2271 if ((error = map_block_for_writepage(inode, bh, block))) {
2272 goto fail ;
2273 }
2274 }
2275 bh = bh->b_this_page;
2276 block++;
2277 } while(bh != head) ;
2278
2279 /*
2280 * we start the transaction after map_block_for_writepage,
2281 * because it can create holes in the file (an unbounded operation).
2282 * starting it here, we can make a reliable estimate for how many
2283 * blocks we're going to log
2284 */
2285 if (checked) {
2286 ClearPageChecked(page);
2287 reiserfs_write_lock(s);
2288 error = journal_begin(&th, s, bh_per_page + 1);
2289 if (error) {
2290 reiserfs_write_unlock(s);
2291 goto fail;
2292 }
2293 reiserfs_update_inode_transaction(inode);
2294 }
2295 /* now go through and lock any dirty buffers on the page */
2296 do {
2297 get_bh(bh);
2298 if (!buffer_mapped(bh))
2299 continue;
2300 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2301 continue;
2302 2354
2303 if (checked) { 2355 /* last page in the file, zero out any contents past the
2304 reiserfs_prepare_for_journal(s, bh, 1); 2356 ** last byte in the file
2305 journal_mark_dirty(&th, s, bh); 2357 */
2306 continue; 2358 if (page->index >= end_index) {
2359 char *kaddr;
2360 unsigned last_offset;
2361
2362 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2363 /* no file contents in this page */
2364 if (page->index >= end_index + 1 || !last_offset) {
2365 unlock_page(page);
2366 return 0;
2367 }
2368 kaddr = kmap_atomic(page, KM_USER0);
2369 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);
2370 flush_dcache_page(page);
2371 kunmap_atomic(kaddr, KM_USER0);
2307 } 2372 }
2308 /* from this point on, we know the buffer is mapped to a 2373 bh = head;
2309 * real block and not a direct item 2374 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2375 /* first map all the buffers, logging any direct items we find */
2376 do {
2377 if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
2378 (buffer_mapped(bh)
2379 && bh->b_blocknr ==
2380 0))) {
2381 /* not mapped yet, or it points to a direct item, search
2382 * the btree for the mapping info, and log any direct
2383 * items found
2384 */
2385 if ((error = map_block_for_writepage(inode, bh, block))) {
2386 goto fail;
2387 }
2388 }
2389 bh = bh->b_this_page;
2390 block++;
2391 } while (bh != head);
2392
2393 /*
2394 * we start the transaction after map_block_for_writepage,
2395 * because it can create holes in the file (an unbounded operation).
2396 * starting it here, we can make a reliable estimate for how many
2397 * blocks we're going to log
2310 */ 2398 */
2311 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) { 2399 if (checked) {
2312 lock_buffer(bh); 2400 ClearPageChecked(page);
2313 } else { 2401 reiserfs_write_lock(s);
2314 if (test_set_buffer_locked(bh)) { 2402 error = journal_begin(&th, s, bh_per_page + 1);
2315 redirty_page_for_writepage(wbc, page); 2403 if (error) {
2316 continue; 2404 reiserfs_write_unlock(s);
2317 } 2405 goto fail;
2406 }
2407 reiserfs_update_inode_transaction(inode);
2318 } 2408 }
2319 if (test_clear_buffer_dirty(bh)) { 2409 /* now go through and lock any dirty buffers on the page */
2320 mark_buffer_async_write(bh); 2410 do {
2321 } else { 2411 get_bh(bh);
2322 unlock_buffer(bh); 2412 if (!buffer_mapped(bh))
2413 continue;
2414 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2415 continue;
2416
2417 if (checked) {
2418 reiserfs_prepare_for_journal(s, bh, 1);
2419 journal_mark_dirty(&th, s, bh);
2420 continue;
2421 }
2422 /* from this point on, we know the buffer is mapped to a
2423 * real block and not a direct item
2424 */
2425 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
2426 lock_buffer(bh);
2427 } else {
2428 if (test_set_buffer_locked(bh)) {
2429 redirty_page_for_writepage(wbc, page);
2430 continue;
2431 }
2432 }
2433 if (test_clear_buffer_dirty(bh)) {
2434 mark_buffer_async_write(bh);
2435 } else {
2436 unlock_buffer(bh);
2437 }
2438 } while ((bh = bh->b_this_page) != head);
2439
2440 if (checked) {
2441 error = journal_end(&th, s, bh_per_page + 1);
2442 reiserfs_write_unlock(s);
2443 if (error)
2444 goto fail;
2323 } 2445 }
2324 } while((bh = bh->b_this_page) != head); 2446 BUG_ON(PageWriteback(page));
2447 set_page_writeback(page);
2448 unlock_page(page);
2325 2449
2326 if (checked) { 2450 /*
2327 error = journal_end(&th, s, bh_per_page + 1); 2451 * since any buffer might be the only dirty buffer on the page,
2328 reiserfs_write_unlock(s); 2452 * the first submit_bh can bring the page out of writeback.
2329 if (error) 2453 * be careful with the buffers.
2330 goto fail;
2331 }
2332 BUG_ON(PageWriteback(page));
2333 set_page_writeback(page);
2334 unlock_page(page);
2335
2336 /*
2337 * since any buffer might be the only dirty buffer on the page,
2338 * the first submit_bh can bring the page out of writeback.
2339 * be careful with the buffers.
2340 */
2341 do {
2342 struct buffer_head *next = bh->b_this_page;
2343 if (buffer_async_write(bh)) {
2344 submit_bh(WRITE, bh);
2345 nr++;
2346 }
2347 put_bh(bh);
2348 bh = next;
2349 } while(bh != head);
2350
2351 error = 0;
2352done:
2353 if (nr == 0) {
2354 /*
2355 * if this page only had a direct item, it is very possible for
2356 * no io to be required without there being an error. Or,
2357 * someone else could have locked them and sent them down the
2358 * pipe without locking the page
2359 */ 2454 */
2360 bh = head ;
2361 do { 2455 do {
2362 if (!buffer_uptodate(bh)) { 2456 struct buffer_head *next = bh->b_this_page;
2363 partial = 1; 2457 if (buffer_async_write(bh)) {
2364 break; 2458 submit_bh(WRITE, bh);
2365 } 2459 nr++;
2366 bh = bh->b_this_page; 2460 }
2367 } while(bh != head); 2461 put_bh(bh);
2368 if (!partial) 2462 bh = next;
2369 SetPageUptodate(page); 2463 } while (bh != head);
2370 end_page_writeback(page);
2371 }
2372 return error;
2373
2374fail:
2375 /* catches various errors, we need to make sure any valid dirty blocks
2376 * get to the media. The page is currently locked and not marked for
2377 * writeback
2378 */
2379 ClearPageUptodate(page);
2380 bh = head;
2381 do {
2382 get_bh(bh);
2383 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2384 lock_buffer(bh);
2385 mark_buffer_async_write(bh);
2386 } else {
2387 /*
2388 * clear any dirty bits that might have come from getting
2389 * attached to a dirty page
2390 */
2391 clear_buffer_dirty(bh);
2392 }
2393 bh = bh->b_this_page;
2394 } while(bh != head);
2395 SetPageError(page);
2396 BUG_ON(PageWriteback(page));
2397 set_page_writeback(page);
2398 unlock_page(page);
2399 do {
2400 struct buffer_head *next = bh->b_this_page;
2401 if (buffer_async_write(bh)) {
2402 clear_buffer_dirty(bh);
2403 submit_bh(WRITE, bh);
2404 nr++;
2405 }
2406 put_bh(bh);
2407 bh = next;
2408 } while(bh != head);
2409 goto done;
2410}
2411 2464
2465 error = 0;
2466 done:
2467 if (nr == 0) {
2468 /*
2469 * if this page only had a direct item, it is very possible for
2470 * no io to be required without there being an error. Or,
2471 * someone else could have locked them and sent them down the
2472 * pipe without locking the page
2473 */
2474 bh = head;
2475 do {
2476 if (!buffer_uptodate(bh)) {
2477 partial = 1;
2478 break;
2479 }
2480 bh = bh->b_this_page;
2481 } while (bh != head);
2482 if (!partial)
2483 SetPageUptodate(page);
2484 end_page_writeback(page);
2485 }
2486 return error;
2412 2487
2413static int reiserfs_readpage (struct file *f, struct page * page) 2488 fail:
2414{ 2489 /* catches various errors, we need to make sure any valid dirty blocks
2415 return block_read_full_page (page, reiserfs_get_block); 2490 * get to the media. The page is currently locked and not marked for
2491 * writeback
2492 */
2493 ClearPageUptodate(page);
2494 bh = head;
2495 do {
2496 get_bh(bh);
2497 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2498 lock_buffer(bh);
2499 mark_buffer_async_write(bh);
2500 } else {
2501 /*
2502 * clear any dirty bits that might have come from getting
2503 * attached to a dirty page
2504 */
2505 clear_buffer_dirty(bh);
2506 }
2507 bh = bh->b_this_page;
2508 } while (bh != head);
2509 SetPageError(page);
2510 BUG_ON(PageWriteback(page));
2511 set_page_writeback(page);
2512 unlock_page(page);
2513 do {
2514 struct buffer_head *next = bh->b_this_page;
2515 if (buffer_async_write(bh)) {
2516 clear_buffer_dirty(bh);
2517 submit_bh(WRITE, bh);
2518 nr++;
2519 }
2520 put_bh(bh);
2521 bh = next;
2522 } while (bh != head);
2523 goto done;
2416} 2524}
2417 2525
2526static int reiserfs_readpage(struct file *f, struct page *page)
2527{
2528 return block_read_full_page(page, reiserfs_get_block);
2529}
2418 2530
2419static int reiserfs_writepage (struct page * page, struct writeback_control *wbc) 2531static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
2420{ 2532{
2421 struct inode *inode = page->mapping->host ; 2533 struct inode *inode = page->mapping->host;
2422 reiserfs_wait_on_write_block(inode->i_sb) ; 2534 reiserfs_wait_on_write_block(inode->i_sb);
2423 return reiserfs_write_full_page(page, wbc) ; 2535 return reiserfs_write_full_page(page, wbc);
2424} 2536}
2425 2537
2426static int reiserfs_prepare_write(struct file *f, struct page *page, 2538static int reiserfs_prepare_write(struct file *f, struct page *page,
2427 unsigned from, unsigned to) { 2539 unsigned from, unsigned to)
2428 struct inode *inode = page->mapping->host ; 2540{
2429 int ret; 2541 struct inode *inode = page->mapping->host;
2430 int old_ref = 0; 2542 int ret;
2431 2543 int old_ref = 0;
2432 reiserfs_wait_on_write_block(inode->i_sb) ; 2544
2433 fix_tail_page_for_writing(page) ; 2545 reiserfs_wait_on_write_block(inode->i_sb);
2434 if (reiserfs_transaction_running(inode->i_sb)) { 2546 fix_tail_page_for_writing(page);
2435 struct reiserfs_transaction_handle *th; 2547 if (reiserfs_transaction_running(inode->i_sb)) {
2436 th = (struct reiserfs_transaction_handle *)current->journal_info; 2548 struct reiserfs_transaction_handle *th;
2437 BUG_ON (!th->t_refcount); 2549 th = (struct reiserfs_transaction_handle *)current->
2438 BUG_ON (!th->t_trans_id); 2550 journal_info;
2439 old_ref = th->t_refcount; 2551 BUG_ON(!th->t_refcount);
2440 th->t_refcount++; 2552 BUG_ON(!th->t_trans_id);
2441 } 2553 old_ref = th->t_refcount;
2442 2554 th->t_refcount++;
2443 ret = block_prepare_write(page, from, to, reiserfs_get_block) ;
2444 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2445 struct reiserfs_transaction_handle *th = current->journal_info;
2446 /* this gets a little ugly. If reiserfs_get_block returned an
2447 * error and left a transacstion running, we've got to close it,
2448 * and we've got to free handle if it was a persistent transaction.
2449 *
2450 * But, if we had nested into an existing transaction, we need
2451 * to just drop the ref count on the handle.
2452 *
2453 * If old_ref == 0, the transaction is from reiserfs_get_block,
2454 * and it was a persistent trans. Otherwise, it was nested above.
2455 */
2456 if (th->t_refcount > old_ref) {
2457 if (old_ref)
2458 th->t_refcount--;
2459 else {
2460 int err;
2461 reiserfs_write_lock(inode->i_sb);
2462 err = reiserfs_end_persistent_transaction(th);
2463 reiserfs_write_unlock(inode->i_sb);
2464 if (err)
2465 ret = err;
2466 }
2467 } 2555 }
2468 }
2469 return ret;
2470 2556
2471} 2557 ret = block_prepare_write(page, from, to, reiserfs_get_block);
2558 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2559 struct reiserfs_transaction_handle *th = current->journal_info;
2560 /* this gets a little ugly. If reiserfs_get_block returned an
2561 * error and left a transacstion running, we've got to close it,
2562 * and we've got to free handle if it was a persistent transaction.
2563 *
2564 * But, if we had nested into an existing transaction, we need
2565 * to just drop the ref count on the handle.
2566 *
2567 * If old_ref == 0, the transaction is from reiserfs_get_block,
2568 * and it was a persistent trans. Otherwise, it was nested above.
2569 */
2570 if (th->t_refcount > old_ref) {
2571 if (old_ref)
2572 th->t_refcount--;
2573 else {
2574 int err;
2575 reiserfs_write_lock(inode->i_sb);
2576 err = reiserfs_end_persistent_transaction(th);
2577 reiserfs_write_unlock(inode->i_sb);
2578 if (err)
2579 ret = err;
2580 }
2581 }
2582 }
2583 return ret;
2472 2584
2585}
2473 2586
2474static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block) { 2587static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2475 return generic_block_bmap(as, block, reiserfs_bmap) ; 2588{
2589 return generic_block_bmap(as, block, reiserfs_bmap);
2476} 2590}
2477 2591
2478static int reiserfs_commit_write(struct file *f, struct page *page, 2592static int reiserfs_commit_write(struct file *f, struct page *page,
2479 unsigned from, unsigned to) { 2593 unsigned from, unsigned to)
2480 struct inode *inode = page->mapping->host ; 2594{
2481 loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 2595 struct inode *inode = page->mapping->host;
2482 int ret = 0; 2596 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2483 int update_sd = 0; 2597 int ret = 0;
2484 struct reiserfs_transaction_handle *th = NULL; 2598 int update_sd = 0;
2485 2599 struct reiserfs_transaction_handle *th = NULL;
2486 reiserfs_wait_on_write_block(inode->i_sb) ; 2600
2487 if (reiserfs_transaction_running(inode->i_sb)) { 2601 reiserfs_wait_on_write_block(inode->i_sb);
2488 th = current->journal_info; 2602 if (reiserfs_transaction_running(inode->i_sb)) {
2489 } 2603 th = current->journal_info;
2490 reiserfs_commit_page(inode, page, from, to); 2604 }
2491 2605 reiserfs_commit_page(inode, page, from, to);
2492 /* generic_commit_write does this for us, but does not update the
2493 ** transaction tracking stuff when the size changes. So, we have
2494 ** to do the i_size updates here.
2495 */
2496 if (pos > inode->i_size) {
2497 struct reiserfs_transaction_handle myth ;
2498 reiserfs_write_lock(inode->i_sb);
2499 /* If the file have grown beyond the border where it
2500 can have a tail, unmark it as needing a tail
2501 packing */
2502 if ( (have_large_tails (inode->i_sb) && inode->i_size > i_block_size (inode)*4) ||
2503 (have_small_tails (inode->i_sb) && inode->i_size > i_block_size(inode)) )
2504 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask ;
2505
2506 ret = journal_begin(&myth, inode->i_sb, 1) ;
2507 if (ret) {
2508 reiserfs_write_unlock(inode->i_sb);
2509 goto journal_error;
2510 }
2511 reiserfs_update_inode_transaction(inode) ;
2512 inode->i_size = pos ;
2513 reiserfs_update_sd(&myth, inode) ;
2514 update_sd = 1;
2515 ret = journal_end(&myth, inode->i_sb, 1) ;
2516 reiserfs_write_unlock(inode->i_sb);
2517 if (ret)
2518 goto journal_error;
2519 }
2520 if (th) {
2521 reiserfs_write_lock(inode->i_sb);
2522 if (!update_sd)
2523 reiserfs_update_sd(th, inode) ;
2524 ret = reiserfs_end_persistent_transaction(th);
2525 reiserfs_write_unlock(inode->i_sb);
2526 if (ret)
2527 goto out;
2528 }
2529
2530 /* we test for O_SYNC here so we can commit the transaction
2531 ** for any packed tails the file might have had
2532 */
2533 if (f && (f->f_flags & O_SYNC)) {
2534 reiserfs_write_lock(inode->i_sb);
2535 ret = reiserfs_commit_for_inode(inode) ;
2536 reiserfs_write_unlock(inode->i_sb);
2537 }
2538out:
2539 return ret ;
2540 2606
2541journal_error: 2607 /* generic_commit_write does this for us, but does not update the
2542 if (th) { 2608 ** transaction tracking stuff when the size changes. So, we have
2543 reiserfs_write_lock(inode->i_sb); 2609 ** to do the i_size updates here.
2544 if (!update_sd) 2610 */
2545 reiserfs_update_sd(th, inode) ; 2611 if (pos > inode->i_size) {
2546 ret = reiserfs_end_persistent_transaction(th); 2612 struct reiserfs_transaction_handle myth;
2547 reiserfs_write_unlock(inode->i_sb); 2613 reiserfs_write_lock(inode->i_sb);
2548 } 2614 /* If the file have grown beyond the border where it
2615 can have a tail, unmark it as needing a tail
2616 packing */
2617 if ((have_large_tails(inode->i_sb)
2618 && inode->i_size > i_block_size(inode) * 4)
2619 || (have_small_tails(inode->i_sb)
2620 && inode->i_size > i_block_size(inode)))
2621 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2622
2623 ret = journal_begin(&myth, inode->i_sb, 1);
2624 if (ret) {
2625 reiserfs_write_unlock(inode->i_sb);
2626 goto journal_error;
2627 }
2628 reiserfs_update_inode_transaction(inode);
2629 inode->i_size = pos;
2630 reiserfs_update_sd(&myth, inode);
2631 update_sd = 1;
2632 ret = journal_end(&myth, inode->i_sb, 1);
2633 reiserfs_write_unlock(inode->i_sb);
2634 if (ret)
2635 goto journal_error;
2636 }
2637 if (th) {
2638 reiserfs_write_lock(inode->i_sb);
2639 if (!update_sd)
2640 reiserfs_update_sd(th, inode);
2641 ret = reiserfs_end_persistent_transaction(th);
2642 reiserfs_write_unlock(inode->i_sb);
2643 if (ret)
2644 goto out;
2645 }
2646
2647 /* we test for O_SYNC here so we can commit the transaction
2648 ** for any packed tails the file might have had
2649 */
2650 if (f && (f->f_flags & O_SYNC)) {
2651 reiserfs_write_lock(inode->i_sb);
2652 ret = reiserfs_commit_for_inode(inode);
2653 reiserfs_write_unlock(inode->i_sb);
2654 }
2655 out:
2656 return ret;
2549 2657
2550 return ret; 2658 journal_error:
2659 if (th) {
2660 reiserfs_write_lock(inode->i_sb);
2661 if (!update_sd)
2662 reiserfs_update_sd(th, inode);
2663 ret = reiserfs_end_persistent_transaction(th);
2664 reiserfs_write_unlock(inode->i_sb);
2665 }
2666
2667 return ret;
2551} 2668}
2552 2669
2553void sd_attrs_to_i_attrs( __u16 sd_attrs, struct inode *inode ) 2670void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2554{ 2671{
2555 if( reiserfs_attrs( inode -> i_sb ) ) { 2672 if (reiserfs_attrs(inode->i_sb)) {
2556 if( sd_attrs & REISERFS_SYNC_FL ) 2673 if (sd_attrs & REISERFS_SYNC_FL)
2557 inode -> i_flags |= S_SYNC; 2674 inode->i_flags |= S_SYNC;
2558 else 2675 else
2559 inode -> i_flags &= ~S_SYNC; 2676 inode->i_flags &= ~S_SYNC;
2560 if( sd_attrs & REISERFS_IMMUTABLE_FL ) 2677 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2561 inode -> i_flags |= S_IMMUTABLE; 2678 inode->i_flags |= S_IMMUTABLE;
2562 else 2679 else
2563 inode -> i_flags &= ~S_IMMUTABLE; 2680 inode->i_flags &= ~S_IMMUTABLE;
2564 if( sd_attrs & REISERFS_APPEND_FL ) 2681 if (sd_attrs & REISERFS_APPEND_FL)
2565 inode -> i_flags |= S_APPEND; 2682 inode->i_flags |= S_APPEND;
2566 else 2683 else
2567 inode -> i_flags &= ~S_APPEND; 2684 inode->i_flags &= ~S_APPEND;
2568 if( sd_attrs & REISERFS_NOATIME_FL ) 2685 if (sd_attrs & REISERFS_NOATIME_FL)
2569 inode -> i_flags |= S_NOATIME; 2686 inode->i_flags |= S_NOATIME;
2570 else 2687 else
2571 inode -> i_flags &= ~S_NOATIME; 2688 inode->i_flags &= ~S_NOATIME;
2572 if( sd_attrs & REISERFS_NOTAIL_FL ) 2689 if (sd_attrs & REISERFS_NOTAIL_FL)
2573 REISERFS_I(inode)->i_flags |= i_nopack_mask; 2690 REISERFS_I(inode)->i_flags |= i_nopack_mask;
2574 else 2691 else
2575 REISERFS_I(inode)->i_flags &= ~i_nopack_mask; 2692 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2576 } 2693 }
2577} 2694}
2578 2695
2579void i_attrs_to_sd_attrs( struct inode *inode, __u16 *sd_attrs ) 2696void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
2580{ 2697{
2581 if( reiserfs_attrs( inode -> i_sb ) ) { 2698 if (reiserfs_attrs(inode->i_sb)) {
2582 if( inode -> i_flags & S_IMMUTABLE ) 2699 if (inode->i_flags & S_IMMUTABLE)
2583 *sd_attrs |= REISERFS_IMMUTABLE_FL; 2700 *sd_attrs |= REISERFS_IMMUTABLE_FL;
2584 else 2701 else
2585 *sd_attrs &= ~REISERFS_IMMUTABLE_FL; 2702 *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
2586 if( inode -> i_flags & S_SYNC ) 2703 if (inode->i_flags & S_SYNC)
2587 *sd_attrs |= REISERFS_SYNC_FL; 2704 *sd_attrs |= REISERFS_SYNC_FL;
2588 else 2705 else
2589 *sd_attrs &= ~REISERFS_SYNC_FL; 2706 *sd_attrs &= ~REISERFS_SYNC_FL;
2590 if( inode -> i_flags & S_NOATIME ) 2707 if (inode->i_flags & S_NOATIME)
2591 *sd_attrs |= REISERFS_NOATIME_FL; 2708 *sd_attrs |= REISERFS_NOATIME_FL;
2592 else 2709 else
2593 *sd_attrs &= ~REISERFS_NOATIME_FL; 2710 *sd_attrs &= ~REISERFS_NOATIME_FL;
2594 if( REISERFS_I(inode)->i_flags & i_nopack_mask ) 2711 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
2595 *sd_attrs |= REISERFS_NOTAIL_FL; 2712 *sd_attrs |= REISERFS_NOTAIL_FL;
2596 else 2713 else
2597 *sd_attrs &= ~REISERFS_NOTAIL_FL; 2714 *sd_attrs &= ~REISERFS_NOTAIL_FL;
@@ -2603,106 +2720,107 @@ void i_attrs_to_sd_attrs( struct inode *inode, __u16 *sd_attrs )
2603*/ 2720*/
2604static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh) 2721static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2605{ 2722{
2606 int ret = 1 ; 2723 int ret = 1;
2607 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb) ; 2724 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2608 2725
2609 spin_lock(&j->j_dirty_buffers_lock) ; 2726 spin_lock(&j->j_dirty_buffers_lock);
2610 if (!buffer_mapped(bh)) { 2727 if (!buffer_mapped(bh)) {
2611 goto free_jh; 2728 goto free_jh;
2612 } 2729 }
2613 /* the page is locked, and the only places that log a data buffer 2730 /* the page is locked, and the only places that log a data buffer
2614 * also lock the page. 2731 * also lock the page.
2615 */
2616 if (reiserfs_file_data_log(inode)) {
2617 /*
2618 * very conservative, leave the buffer pinned if
2619 * anyone might need it.
2620 */
2621 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2622 ret = 0 ;
2623 }
2624 } else
2625 if (buffer_dirty(bh) || buffer_locked(bh)) {
2626 struct reiserfs_journal_list *jl;
2627 struct reiserfs_jh *jh = bh->b_private;
2628
2629 /* why is this safe?
2630 * reiserfs_setattr updates i_size in the on disk
2631 * stat data before allowing vmtruncate to be called.
2632 *
2633 * If buffer was put onto the ordered list for this
2634 * transaction, we know for sure either this transaction
2635 * or an older one already has updated i_size on disk,
2636 * and this ordered data won't be referenced in the file
2637 * if we crash.
2638 *
2639 * if the buffer was put onto the ordered list for an older
2640 * transaction, we need to leave it around
2641 */ 2732 */
2642 if (jh && (jl = jh->jl) && jl != SB_JOURNAL(inode->i_sb)->j_current_jl) 2733 if (reiserfs_file_data_log(inode)) {
2643 ret = 0; 2734 /*
2644 } 2735 * very conservative, leave the buffer pinned if
2645free_jh: 2736 * anyone might need it.
2646 if (ret && bh->b_private) { 2737 */
2647 reiserfs_free_jh(bh); 2738 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2648 } 2739 ret = 0;
2649 spin_unlock(&j->j_dirty_buffers_lock) ; 2740 }
2650 return ret ; 2741 } else if (buffer_dirty(bh) || buffer_locked(bh)) {
2742 struct reiserfs_journal_list *jl;
2743 struct reiserfs_jh *jh = bh->b_private;
2744
2745 /* why is this safe?
2746 * reiserfs_setattr updates i_size in the on disk
2747 * stat data before allowing vmtruncate to be called.
2748 *
2749 * If buffer was put onto the ordered list for this
2750 * transaction, we know for sure either this transaction
2751 * or an older one already has updated i_size on disk,
2752 * and this ordered data won't be referenced in the file
2753 * if we crash.
2754 *
2755 * if the buffer was put onto the ordered list for an older
2756 * transaction, we need to leave it around
2757 */
2758 if (jh && (jl = jh->jl)
2759 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2760 ret = 0;
2761 }
2762 free_jh:
2763 if (ret && bh->b_private) {
2764 reiserfs_free_jh(bh);
2765 }
2766 spin_unlock(&j->j_dirty_buffers_lock);
2767 return ret;
2651} 2768}
2652 2769
2653/* clm -- taken from fs/buffer.c:block_invalidate_page */ 2770/* clm -- taken from fs/buffer.c:block_invalidate_page */
2654static int reiserfs_invalidatepage(struct page *page, unsigned long offset) 2771static int reiserfs_invalidatepage(struct page *page, unsigned long offset)
2655{ 2772{
2656 struct buffer_head *head, *bh, *next; 2773 struct buffer_head *head, *bh, *next;
2657 struct inode *inode = page->mapping->host; 2774 struct inode *inode = page->mapping->host;
2658 unsigned int curr_off = 0; 2775 unsigned int curr_off = 0;
2659 int ret = 1; 2776 int ret = 1;
2660 2777
2661 BUG_ON(!PageLocked(page)); 2778 BUG_ON(!PageLocked(page));
2662 2779
2663 if (offset == 0) 2780 if (offset == 0)
2664 ClearPageChecked(page); 2781 ClearPageChecked(page);
2665 2782
2666 if (!page_has_buffers(page)) 2783 if (!page_has_buffers(page))
2667 goto out; 2784 goto out;
2785
2786 head = page_buffers(page);
2787 bh = head;
2788 do {
2789 unsigned int next_off = curr_off + bh->b_size;
2790 next = bh->b_this_page;
2668 2791
2669 head = page_buffers(page); 2792 /*
2670 bh = head; 2793 * is this block fully invalidated?
2671 do { 2794 */
2672 unsigned int next_off = curr_off + bh->b_size; 2795 if (offset <= curr_off) {
2673 next = bh->b_this_page; 2796 if (invalidatepage_can_drop(inode, bh))
2797 reiserfs_unmap_buffer(bh);
2798 else
2799 ret = 0;
2800 }
2801 curr_off = next_off;
2802 bh = next;
2803 } while (bh != head);
2674 2804
2675 /* 2805 /*
2676 * is this block fully invalidated? 2806 * We release buffers only if the entire page is being invalidated.
2807 * The get_block cached value has been unconditionally invalidated,
2808 * so real IO is not possible anymore.
2677 */ 2809 */
2678 if (offset <= curr_off) { 2810 if (!offset && ret)
2679 if (invalidatepage_can_drop(inode, bh)) 2811 ret = try_to_release_page(page, 0);
2680 reiserfs_unmap_buffer(bh); 2812 out:
2681 else 2813 return ret;
2682 ret = 0;
2683 }
2684 curr_off = next_off;
2685 bh = next;
2686 } while (bh != head);
2687
2688 /*
2689 * We release buffers only if the entire page is being invalidated.
2690 * The get_block cached value has been unconditionally invalidated,
2691 * so real IO is not possible anymore.
2692 */
2693 if (!offset && ret)
2694 ret = try_to_release_page(page, 0);
2695out:
2696 return ret;
2697} 2814}
2698 2815
2699static int reiserfs_set_page_dirty(struct page *page) { 2816static int reiserfs_set_page_dirty(struct page *page)
2700 struct inode *inode = page->mapping->host; 2817{
2701 if (reiserfs_file_data_log(inode)) { 2818 struct inode *inode = page->mapping->host;
2702 SetPageChecked(page); 2819 if (reiserfs_file_data_log(inode)) {
2703 return __set_page_dirty_nobuffers(page); 2820 SetPageChecked(page);
2704 } 2821 return __set_page_dirty_nobuffers(page);
2705 return __set_page_dirty_buffers(page); 2822 }
2823 return __set_page_dirty_buffers(page);
2706} 2824}
2707 2825
2708/* 2826/*
@@ -2716,143 +2834,152 @@ static int reiserfs_set_page_dirty(struct page *page) {
2716 */ 2834 */
2717static int reiserfs_releasepage(struct page *page, int unused_gfp_flags) 2835static int reiserfs_releasepage(struct page *page, int unused_gfp_flags)
2718{ 2836{
2719 struct inode *inode = page->mapping->host ; 2837 struct inode *inode = page->mapping->host;
2720 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb) ; 2838 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2721 struct buffer_head *head ; 2839 struct buffer_head *head;
2722 struct buffer_head *bh ; 2840 struct buffer_head *bh;
2723 int ret = 1 ; 2841 int ret = 1;
2724 2842
2725 WARN_ON(PageChecked(page)); 2843 WARN_ON(PageChecked(page));
2726 spin_lock(&j->j_dirty_buffers_lock) ; 2844 spin_lock(&j->j_dirty_buffers_lock);
2727 head = page_buffers(page) ; 2845 head = page_buffers(page);
2728 bh = head ; 2846 bh = head;
2729 do { 2847 do {
2730 if (bh->b_private) { 2848 if (bh->b_private) {
2731 if (!buffer_dirty(bh) && !buffer_locked(bh)) { 2849 if (!buffer_dirty(bh) && !buffer_locked(bh)) {
2732 reiserfs_free_jh(bh); 2850 reiserfs_free_jh(bh);
2733 } else { 2851 } else {
2734 ret = 0 ; 2852 ret = 0;
2735 break ; 2853 break;
2736 } 2854 }
2737 } 2855 }
2738 bh = bh->b_this_page ; 2856 bh = bh->b_this_page;
2739 } while (bh != head) ; 2857 } while (bh != head);
2740 if (ret) 2858 if (ret)
2741 ret = try_to_free_buffers(page) ; 2859 ret = try_to_free_buffers(page);
2742 spin_unlock(&j->j_dirty_buffers_lock) ; 2860 spin_unlock(&j->j_dirty_buffers_lock);
2743 return ret ; 2861 return ret;
2744} 2862}
2745 2863
2746/* We thank Mingming Cao for helping us understand in great detail what 2864/* We thank Mingming Cao for helping us understand in great detail what
2747 to do in this section of the code. */ 2865 to do in this section of the code. */
2748static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb, 2866static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
2749 const struct iovec *iov, loff_t offset, unsigned long nr_segs) 2867 const struct iovec *iov, loff_t offset,
2868 unsigned long nr_segs)
2750{ 2869{
2751 struct file *file = iocb->ki_filp; 2870 struct file *file = iocb->ki_filp;
2752 struct inode *inode = file->f_mapping->host; 2871 struct inode *inode = file->f_mapping->host;
2753 2872
2754 return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 2873 return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2755 offset, nr_segs, reiserfs_get_blocks_direct_io, NULL); 2874 offset, nr_segs,
2875 reiserfs_get_blocks_direct_io, NULL);
2756} 2876}
2757 2877
2758int reiserfs_setattr(struct dentry *dentry, struct iattr *attr) { 2878int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
2759 struct inode *inode = dentry->d_inode ; 2879{
2760 int error ; 2880 struct inode *inode = dentry->d_inode;
2761 unsigned int ia_valid = attr->ia_valid; 2881 int error;
2762 reiserfs_write_lock(inode->i_sb); 2882 unsigned int ia_valid = attr->ia_valid;
2763 if (attr->ia_valid & ATTR_SIZE) { 2883 reiserfs_write_lock(inode->i_sb);
2764 /* version 2 items will be caught by the s_maxbytes check 2884 if (attr->ia_valid & ATTR_SIZE) {
2765 ** done for us in vmtruncate 2885 /* version 2 items will be caught by the s_maxbytes check
2766 */ 2886 ** done for us in vmtruncate
2767 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 && 2887 */
2768 attr->ia_size > MAX_NON_LFS) { 2888 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
2769 error = -EFBIG ; 2889 attr->ia_size > MAX_NON_LFS) {
2770 goto out; 2890 error = -EFBIG;
2771 } 2891 goto out;
2772 /* fill in hole pointers in the expanding truncate case. */ 2892 }
2773 if (attr->ia_size > inode->i_size) { 2893 /* fill in hole pointers in the expanding truncate case. */
2774 error = generic_cont_expand(inode, attr->ia_size) ; 2894 if (attr->ia_size > inode->i_size) {
2775 if (REISERFS_I(inode)->i_prealloc_count > 0) { 2895 error = generic_cont_expand(inode, attr->ia_size);
2776 int err; 2896 if (REISERFS_I(inode)->i_prealloc_count > 0) {
2777 struct reiserfs_transaction_handle th ; 2897 int err;
2778 /* we're changing at most 2 bitmaps, inode + super */ 2898 struct reiserfs_transaction_handle th;
2779 err = journal_begin(&th, inode->i_sb, 4) ; 2899 /* we're changing at most 2 bitmaps, inode + super */
2780 if (!err) { 2900 err = journal_begin(&th, inode->i_sb, 4);
2781 reiserfs_discard_prealloc (&th, inode); 2901 if (!err) {
2782 err = journal_end(&th, inode->i_sb, 4) ; 2902 reiserfs_discard_prealloc(&th, inode);
2903 err = journal_end(&th, inode->i_sb, 4);
2904 }
2905 if (err)
2906 error = err;
2907 }
2908 if (error)
2909 goto out;
2783 } 2910 }
2784 if (err)
2785 error = err;
2786 }
2787 if (error)
2788 goto out;
2789 } 2911 }
2790 }
2791 2912
2792 if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) || 2913 if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||
2793 ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) && 2914 ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&
2794 (get_inode_sd_version (inode) == STAT_DATA_V1)) { 2915 (get_inode_sd_version(inode) == STAT_DATA_V1)) {
2795 /* stat data of format v3.5 has 16 bit uid and gid */ 2916 /* stat data of format v3.5 has 16 bit uid and gid */
2796 error = -EINVAL; 2917 error = -EINVAL;
2797 goto out; 2918 goto out;
2798 } 2919 }
2799
2800 error = inode_change_ok(inode, attr) ;
2801 if (!error) {
2802 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2803 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2804 error = reiserfs_chown_xattrs (inode, attr);
2805
2806 if (!error) {
2807 struct reiserfs_transaction_handle th;
2808 int jbegin_count = 2*(REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb)+REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb))+2;
2809
2810 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2811 error = journal_begin(&th, inode->i_sb, jbegin_count);
2812 if (error)
2813 goto out;
2814 error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2815 if (error) {
2816 journal_end(&th, inode->i_sb, jbegin_count);
2817 goto out;
2818 }
2819 /* Update corresponding info in inode so that everything is in
2820 * one transaction */
2821 if (attr->ia_valid & ATTR_UID)
2822 inode->i_uid = attr->ia_uid;
2823 if (attr->ia_valid & ATTR_GID)
2824 inode->i_gid = attr->ia_gid;
2825 mark_inode_dirty(inode);
2826 error = journal_end(&th, inode->i_sb, jbegin_count);
2827 }
2828 }
2829 if (!error)
2830 error = inode_setattr(inode, attr) ;
2831 }
2832 2920
2921 error = inode_change_ok(inode, attr);
2922 if (!error) {
2923 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2924 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2925 error = reiserfs_chown_xattrs(inode, attr);
2926
2927 if (!error) {
2928 struct reiserfs_transaction_handle th;
2929 int jbegin_count =
2930 2 *
2931 (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
2932 REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
2933 2;
2934
2935 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2936 error =
2937 journal_begin(&th, inode->i_sb,
2938 jbegin_count);
2939 if (error)
2940 goto out;
2941 error =
2942 DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2943 if (error) {
2944 journal_end(&th, inode->i_sb,
2945 jbegin_count);
2946 goto out;
2947 }
2948 /* Update corresponding info in inode so that everything is in
2949 * one transaction */
2950 if (attr->ia_valid & ATTR_UID)
2951 inode->i_uid = attr->ia_uid;
2952 if (attr->ia_valid & ATTR_GID)
2953 inode->i_gid = attr->ia_gid;
2954 mark_inode_dirty(inode);
2955 error =
2956 journal_end(&th, inode->i_sb, jbegin_count);
2957 }
2958 }
2959 if (!error)
2960 error = inode_setattr(inode, attr);
2961 }
2833 2962
2834 if (!error && reiserfs_posixacl (inode->i_sb)) { 2963 if (!error && reiserfs_posixacl(inode->i_sb)) {
2835 if (attr->ia_valid & ATTR_MODE) 2964 if (attr->ia_valid & ATTR_MODE)
2836 error = reiserfs_acl_chmod (inode); 2965 error = reiserfs_acl_chmod(inode);
2837 } 2966 }
2838 2967
2839out: 2968 out:
2840 reiserfs_write_unlock(inode->i_sb); 2969 reiserfs_write_unlock(inode->i_sb);
2841 return error ; 2970 return error;
2842} 2971}
2843 2972
2844
2845
2846struct address_space_operations reiserfs_address_space_operations = { 2973struct address_space_operations reiserfs_address_space_operations = {
2847 .writepage = reiserfs_writepage, 2974 .writepage = reiserfs_writepage,
2848 .readpage = reiserfs_readpage, 2975 .readpage = reiserfs_readpage,
2849 .readpages = reiserfs_readpages, 2976 .readpages = reiserfs_readpages,
2850 .releasepage = reiserfs_releasepage, 2977 .releasepage = reiserfs_releasepage,
2851 .invalidatepage = reiserfs_invalidatepage, 2978 .invalidatepage = reiserfs_invalidatepage,
2852 .sync_page = block_sync_page, 2979 .sync_page = block_sync_page,
2853 .prepare_write = reiserfs_prepare_write, 2980 .prepare_write = reiserfs_prepare_write,
2854 .commit_write = reiserfs_commit_write, 2981 .commit_write = reiserfs_commit_write,
2855 .bmap = reiserfs_aop_bmap, 2982 .bmap = reiserfs_aop_bmap,
2856 .direct_IO = reiserfs_direct_IO, 2983 .direct_IO = reiserfs_direct_IO,
2857 .set_page_dirty = reiserfs_set_page_dirty, 2984 .set_page_dirty = reiserfs_set_page_dirty,
2858} ; 2985};
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-08 14:46:36 -0500