This source file includes following definitions.
- ext2_put_inode
- block_bmap
- ext2_discard_prealloc
- ext2_alloc_block
- ext2_bmap
- inode_getblk
- block_getblk
- block_getcluster
- ext2_getblk
- ext2_getcluster
- ext2_bread
- ext2_read_inode
- ext2_update_inode
- ext2_write_inode
- ext2_sync_inode
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 #include <asm/segment.h>
19 #include <asm/system.h>
20
21 #include <linux/errno.h>
22 #include <linux/fs.h>
23 #include <linux/ext2_fs.h>
24 #include <linux/sched.h>
25 #include <linux/stat.h>
26 #include <linux/string.h>
27 #include <linux/locks.h>
28 #include <linux/mm.h>
29
30 void ext2_put_inode (struct inode * inode)
31 {
32 ext2_discard_prealloc (inode);
33 if (inode->i_nlink || inode->i_ino == EXT2_ACL_IDX_INO ||
34 inode->i_ino == EXT2_ACL_DATA_INO)
35 return;
36 inode->i_size = 0;
37 if (inode->i_blocks)
38 ext2_truncate (inode);
39 ext2_free_inode (inode);
40 }
41
42 #define inode_bmap(inode, nr) ((inode)->u.ext2_i.i_data[(nr)])
43
44 static int block_bmap (struct buffer_head * bh, int nr)
45 {
46 int tmp;
47
48 if (!bh)
49 return 0;
50 tmp = ((u32 *) bh->b_data)[nr];
51 brelse (bh);
52 return tmp;
53 }
54
55
56
57
58
59
60
61
62 void ext2_discard_prealloc (struct inode * inode)
63 {
64 #ifdef EXT2_PREALLOCATE
65 if (inode->u.ext2_i.i_prealloc_count) {
66 int i = inode->u.ext2_i.i_prealloc_count;
67 inode->u.ext2_i.i_prealloc_count = 0;
68 ext2_free_blocks (inode->i_sb,
69 inode->u.ext2_i.i_prealloc_block,
70 i);
71 }
72 #endif
73 }
74
75 static int ext2_alloc_block (struct inode * inode, unsigned long goal)
76 {
77 #ifdef EXT2FS_DEBUG
78 static unsigned long alloc_hits = 0, alloc_attempts = 0;
79 #endif
80 unsigned long result;
81 struct buffer_head * bh;
82
83 wait_on_super (inode->i_sb);
84
85 #ifdef EXT2_PREALLOCATE
86 if (inode->u.ext2_i.i_prealloc_count &&
87 (goal == inode->u.ext2_i.i_prealloc_block ||
88 goal + 1 == inode->u.ext2_i.i_prealloc_block))
89 {
90 result = inode->u.ext2_i.i_prealloc_block++;
91 inode->u.ext2_i.i_prealloc_count--;
92 ext2_debug ("preallocation hit (%lu/%lu).\n",
93 ++alloc_hits, ++alloc_attempts);
94
95
96
97
98 if (!(bh = getblk (inode->i_sb->s_dev, result,
99 inode->i_sb->s_blocksize))) {
100 ext2_error (inode->i_sb, "ext2_alloc_block",
101 "cannot get block %lu", result);
102 return 0;
103 }
104 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
105 bh->b_uptodate = 1;
106 mark_buffer_dirty(bh, 1);
107 brelse (bh);
108 } else {
109 ext2_discard_prealloc (inode);
110 ext2_debug ("preallocation miss (%lu/%lu).\n",
111 alloc_hits, ++alloc_attempts);
112 if (S_ISREG(inode->i_mode))
113 result = ext2_new_block
114 (inode->i_sb, goal,
115 &inode->u.ext2_i.i_prealloc_count,
116 &inode->u.ext2_i.i_prealloc_block);
117 else
118 result = ext2_new_block (inode->i_sb, goal, 0, 0);
119 }
120 #else
121 result = ext2_new_block (inode->i_sb, goal, 0, 0);
122 #endif
123
124 return result;
125 }
126
127
128 int ext2_bmap (struct inode * inode, int block)
129 {
130 int i;
131 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
132
133 if (block < 0) {
134 ext2_warning (inode->i_sb, "ext2_bmap", "block < 0");
135 return 0;
136 }
137 if (block >= EXT2_NDIR_BLOCKS + addr_per_block +
138 addr_per_block * addr_per_block +
139 addr_per_block * addr_per_block * addr_per_block) {
140 ext2_warning (inode->i_sb, "ext2_bmap", "block > big");
141 return 0;
142 }
143 if (block < EXT2_NDIR_BLOCKS)
144 return inode_bmap (inode, block);
145 block -= EXT2_NDIR_BLOCKS;
146 if (block < addr_per_block) {
147 i = inode_bmap (inode, EXT2_IND_BLOCK);
148 if (!i)
149 return 0;
150 return block_bmap (bread (inode->i_dev, i,
151 inode->i_sb->s_blocksize), block);
152 }
153 block -= addr_per_block;
154 if (block < addr_per_block * addr_per_block) {
155 i = inode_bmap (inode, EXT2_DIND_BLOCK);
156 if (!i)
157 return 0;
158 i = block_bmap (bread (inode->i_dev, i,
159 inode->i_sb->s_blocksize),
160 block / addr_per_block);
161 if (!i)
162 return 0;
163 return block_bmap (bread (inode->i_dev, i,
164 inode->i_sb->s_blocksize),
165 block & (addr_per_block - 1));
166 }
167 block -= addr_per_block * addr_per_block;
168 i = inode_bmap (inode, EXT2_TIND_BLOCK);
169 if (!i)
170 return 0;
171 i = block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
172 block / (addr_per_block * addr_per_block));
173 if (!i)
174 return 0;
175 i = block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
176 (block / addr_per_block) & (addr_per_block - 1));
177 if (!i)
178 return 0;
179 return block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
180 block & (addr_per_block - 1));
181 }
182
183 static struct buffer_head * inode_getblk (struct inode * inode, int nr,
184 int create, int new_block, int * err)
185 {
186 u32 * p;
187 int tmp, goal = 0;
188 struct buffer_head * result;
189 int blocks = inode->i_sb->s_blocksize / 512;
190
191 p = inode->u.ext2_i.i_data + nr;
192 repeat:
193 tmp = *p;
194 if (tmp) {
195 result = getblk (inode->i_dev, tmp, inode->i_sb->s_blocksize);
196 if (tmp == *p)
197 return result;
198 brelse (result);
199 goto repeat;
200 }
201 if (!create || new_block >=
202 (current->rlim[RLIMIT_FSIZE].rlim_cur >>
203 EXT2_BLOCK_SIZE_BITS(inode->i_sb))) {
204 *err = -EFBIG;
205 return NULL;
206 }
207 if (inode->u.ext2_i.i_next_alloc_block == new_block)
208 goal = inode->u.ext2_i.i_next_alloc_goal;
209
210 ext2_debug ("hint = %d,", goal);
211
212 if (!goal) {
213 for (tmp = nr - 1; tmp >= 0; tmp--) {
214 if (inode->u.ext2_i.i_data[tmp]) {
215 goal = inode->u.ext2_i.i_data[tmp];
216 break;
217 }
218 }
219 if (!goal)
220 goal = (inode->u.ext2_i.i_block_group *
221 EXT2_BLOCKS_PER_GROUP(inode->i_sb)) +
222 inode->i_sb->u.ext2_sb.s_es->s_first_data_block;
223 }
224
225 ext2_debug ("goal = %d.\n", goal);
226
227 tmp = ext2_alloc_block (inode, goal);
228 if (!tmp)
229 return NULL;
230 result = getblk (inode->i_dev, tmp, inode->i_sb->s_blocksize);
231 if (*p) {
232 ext2_free_blocks (inode->i_sb, tmp, 1);
233 brelse (result);
234 goto repeat;
235 }
236 *p = tmp;
237 inode->u.ext2_i.i_next_alloc_block = new_block;
238 inode->u.ext2_i.i_next_alloc_goal = tmp;
239 inode->i_ctime = CURRENT_TIME;
240 inode->i_blocks += blocks;
241 if (IS_SYNC(inode) || inode->u.ext2_i.i_osync)
242 ext2_sync_inode (inode);
243 else
244 inode->i_dirt = 1;
245 return result;
246 }
247
248 static struct buffer_head * block_getblk (struct inode * inode,
249 struct buffer_head * bh, int nr,
250 int create, int blocksize,
251 int new_block, int * err)
252 {
253 int tmp, goal = 0;
254 u32 * p;
255 struct buffer_head * result;
256 int blocks = inode->i_sb->s_blocksize / 512;
257
258 if (!bh)
259 return NULL;
260 if (!bh->b_uptodate) {
261 ll_rw_block (READ, 1, &bh);
262 wait_on_buffer (bh);
263 if (!bh->b_uptodate) {
264 brelse (bh);
265 return NULL;
266 }
267 }
268 p = (u32 *) bh->b_data + nr;
269 repeat:
270 tmp = *p;
271 if (tmp) {
272 result = getblk (bh->b_dev, tmp, blocksize);
273 if (tmp == *p) {
274 brelse (bh);
275 return result;
276 }
277 brelse (result);
278 goto repeat;
279 }
280 if (!create || new_block >=
281 (current->rlim[RLIMIT_FSIZE].rlim_cur >>
282 EXT2_BLOCK_SIZE_BITS(inode->i_sb))) {
283 brelse (bh);
284 *err = -EFBIG;
285 return NULL;
286 }
287 if (inode->u.ext2_i.i_next_alloc_block == new_block)
288 goal = inode->u.ext2_i.i_next_alloc_goal;
289 if (!goal) {
290 for (tmp = nr - 1; tmp >= 0; tmp--) {
291 if (((u32 *) bh->b_data)[tmp]) {
292 goal = ((u32 *)bh->b_data)[tmp];
293 break;
294 }
295 }
296 if (!goal)
297 goal = bh->b_blocknr;
298 }
299 tmp = ext2_alloc_block (inode, goal);
300 if (!tmp) {
301 brelse (bh);
302 return NULL;
303 }
304 result = getblk (bh->b_dev, tmp, blocksize);
305 if (*p) {
306 ext2_free_blocks (inode->i_sb, tmp, 1);
307 brelse (result);
308 goto repeat;
309 }
310 *p = tmp;
311 mark_buffer_dirty(bh, 1);
312 if (IS_SYNC(inode) || inode->u.ext2_i.i_osync) {
313 ll_rw_block (WRITE, 1, &bh);
314 wait_on_buffer (bh);
315 }
316 inode->i_ctime = CURRENT_TIME;
317 inode->i_blocks += blocks;
318 inode->i_dirt = 1;
319 inode->u.ext2_i.i_next_alloc_block = new_block;
320 inode->u.ext2_i.i_next_alloc_goal = tmp;
321 brelse (bh);
322 return result;
323 }
324
325 static int block_getcluster (struct inode * inode, struct buffer_head * bh,
326 int nr,
327 int blocksize)
328 {
329 u32 * p;
330 int firstblock = 0;
331 int result = 0;
332 int i;
333
334
335
336 if(!bh) return 0;
337
338 if(nr % (PAGE_SIZE / inode->i_sb->s_blocksize) != 0) goto out;
339 if(nr + 3 > EXT2_ADDR_PER_BLOCK(inode->i_sb)) goto out;
340
341 for(i=0; i< (PAGE_SIZE / inode->i_sb->s_blocksize); i++) {
342 p = (u32 *) bh->b_data + nr + i;
343
344
345 if(*p == 0) goto out;
346
347
348 if(i==0) firstblock = *p;
349 else if(*p != firstblock + i) goto out;
350 }
351
352 p = (u32 *) bh->b_data + nr;
353 result = generate_cluster(bh->b_dev, (int *) p, blocksize);
354
355 out:
356 brelse(bh);
357 return result;
358 }
359
360 struct buffer_head * ext2_getblk (struct inode * inode, long block,
361 int create, int * err)
362 {
363 struct buffer_head * bh;
364 unsigned long b;
365 unsigned long addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
366
367 *err = -EIO;
368 if (block < 0) {
369 ext2_warning (inode->i_sb, "ext2_getblk", "block < 0");
370 return NULL;
371 }
372 if (block > EXT2_NDIR_BLOCKS + addr_per_block +
373 addr_per_block * addr_per_block +
374 addr_per_block * addr_per_block * addr_per_block) {
375 ext2_warning (inode->i_sb, "ext2_getblk", "block > big");
376 return NULL;
377 }
378
379
380
381
382
383
384 ext2_debug ("block %lu, next %lu, goal %lu.\n", block,
385 inode->u.ext2_i.i_next_alloc_block,
386 inode->u.ext2_i.i_next_alloc_goal);
387
388 if (block == inode->u.ext2_i.i_next_alloc_block + 1) {
389 inode->u.ext2_i.i_next_alloc_block++;
390 inode->u.ext2_i.i_next_alloc_goal++;
391 }
392
393 *err = -ENOSPC;
394 b = block;
395 if (block < EXT2_NDIR_BLOCKS)
396 return inode_getblk (inode, block, create, b, err);
397 block -= EXT2_NDIR_BLOCKS;
398 if (block < addr_per_block) {
399 bh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, err);
400 return block_getblk (inode, bh, block, create,
401 inode->i_sb->s_blocksize, b, err);
402 }
403 block -= addr_per_block;
404 if (block < addr_per_block * addr_per_block) {
405 bh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, err);
406 bh = block_getblk (inode, bh, block / addr_per_block, create,
407 inode->i_sb->s_blocksize, b, err);
408 return block_getblk (inode, bh, block & (addr_per_block - 1),
409 create, inode->i_sb->s_blocksize, b, err);
410 }
411 block -= addr_per_block * addr_per_block;
412 bh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, err);
413 bh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
414 create, inode->i_sb->s_blocksize, b, err);
415 bh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
416 create, inode->i_sb->s_blocksize, b, err);
417 return block_getblk (inode, bh, block & (addr_per_block - 1), create,
418 inode->i_sb->s_blocksize, b, err);
419 }
420
421 int ext2_getcluster (struct inode * inode, long block)
422 {
423 struct buffer_head * bh;
424 int err, create;
425 unsigned long b;
426 unsigned long addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
427
428 create = 0;
429 err = -EIO;
430 if (block < 0) {
431 ext2_warning (inode->i_sb, "ext2_getblk", "block < 0");
432 return 0;
433 }
434 if (block > EXT2_NDIR_BLOCKS + addr_per_block +
435 addr_per_block * addr_per_block +
436 addr_per_block * addr_per_block * addr_per_block) {
437 ext2_warning (inode->i_sb, "ext2_getblk", "block > big");
438 return 0;
439 }
440
441 err = -ENOSPC;
442 b = block;
443 if (block < EXT2_NDIR_BLOCKS) return 0;
444
445 block -= EXT2_NDIR_BLOCKS;
446
447 if (block < addr_per_block) {
448 bh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, &err);
449 return block_getcluster (inode, bh, block,
450 inode->i_sb->s_blocksize);
451 }
452 block -= addr_per_block;
453 if (block < addr_per_block * addr_per_block) {
454 bh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, &err);
455 bh = block_getblk (inode, bh, block / addr_per_block, create,
456 inode->i_sb->s_blocksize, b, &err);
457 return block_getcluster (inode, bh, block & (addr_per_block - 1),
458 inode->i_sb->s_blocksize);
459 }
460 block -= addr_per_block * addr_per_block;
461 bh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, &err);
462 bh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
463 create, inode->i_sb->s_blocksize, b, &err);
464 bh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
465 create, inode->i_sb->s_blocksize, b, &err);
466 return block_getcluster (inode, bh, block & (addr_per_block - 1),
467 inode->i_sb->s_blocksize);
468 }
469
470 struct buffer_head * ext2_bread (struct inode * inode, int block,
471 int create, int *err)
472 {
473 struct buffer_head * bh;
474
475 bh = ext2_getblk (inode, block, create, err);
476 if (!bh || bh->b_uptodate)
477 return bh;
478 ll_rw_block (READ, 1, &bh);
479 wait_on_buffer (bh);
480 if (bh->b_uptodate)
481 return bh;
482 brelse (bh);
483 *err = -EIO;
484 return NULL;
485 }
486
487 void ext2_read_inode (struct inode * inode)
488 {
489 struct buffer_head * bh;
490 struct ext2_inode * raw_inode;
491 unsigned long block_group;
492 unsigned long group_desc;
493 unsigned long desc;
494 unsigned long block;
495 struct ext2_group_desc * gdp;
496
497 if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino != EXT2_ACL_IDX_INO &&
498 inode->i_ino != EXT2_ACL_DATA_INO && inode->i_ino < EXT2_FIRST_INO) ||
499 inode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
500 ext2_error (inode->i_sb, "ext2_read_inode",
501 "bad inode number: %lu", inode->i_ino);
502 return;
503 }
504 block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
505 if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
506 ext2_panic (inode->i_sb, "ext2_read_inode",
507 "group >= groups count");
508 group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
509 desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
510 bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
511 if (!bh)
512 ext2_panic (inode->i_sb, "ext2_read_inode",
513 "Descriptor not loaded");
514 gdp = (struct ext2_group_desc *) bh->b_data;
515 block = gdp[desc].bg_inode_table +
516 (((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
517 / EXT2_INODES_PER_BLOCK(inode->i_sb));
518 if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
519 ext2_panic (inode->i_sb, "ext2_read_inode",
520 "unable to read i-node block - "
521 "inode=%lu, block=%lu", inode->i_ino, block);
522 raw_inode = ((struct ext2_inode *) bh->b_data) +
523 (inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
524 inode->i_mode = raw_inode->i_mode;
525 inode->i_uid = raw_inode->i_uid;
526 inode->i_gid = raw_inode->i_gid;
527 inode->i_nlink = raw_inode->i_links_count;
528 inode->i_size = raw_inode->i_size;
529 inode->i_atime = raw_inode->i_atime;
530 inode->i_ctime = raw_inode->i_ctime;
531 inode->i_mtime = raw_inode->i_mtime;
532 inode->u.ext2_i.i_dtime = raw_inode->i_dtime;
533 inode->i_blksize = inode->i_sb->s_blocksize;
534 inode->i_blocks = raw_inode->i_blocks;
535 inode->i_version = ++event;
536 inode->u.ext2_i.i_flags = raw_inode->i_flags;
537 inode->u.ext2_i.i_faddr = raw_inode->i_faddr;
538 inode->u.ext2_i.i_frag_no = raw_inode->i_frag;
539 inode->u.ext2_i.i_frag_size = raw_inode->i_fsize;
540 inode->u.ext2_i.i_osync = 0;
541 inode->u.ext2_i.i_file_acl = raw_inode->i_file_acl;
542 inode->u.ext2_i.i_dir_acl = raw_inode->i_dir_acl;
543 inode->u.ext2_i.i_version = raw_inode->i_version;
544 inode->u.ext2_i.i_block_group = block_group;
545 inode->u.ext2_i.i_next_alloc_block = 0;
546 inode->u.ext2_i.i_next_alloc_goal = 0;
547 if (inode->u.ext2_i.i_prealloc_count)
548 ext2_error (inode->i_sb, "ext2_read_inode",
549 "New inode has non-zero prealloc count!");
550 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
551 inode->i_rdev = raw_inode->i_block[0];
552 else for (block = 0; block < EXT2_N_BLOCKS; block++)
553 inode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
554 brelse (bh);
555 inode->i_op = NULL;
556 if (inode->i_ino == EXT2_ACL_IDX_INO ||
557 inode->i_ino == EXT2_ACL_DATA_INO)
558 ;
559 else if (S_ISREG(inode->i_mode))
560 inode->i_op = &ext2_file_inode_operations;
561 else if (S_ISDIR(inode->i_mode))
562 inode->i_op = &ext2_dir_inode_operations;
563 else if (S_ISLNK(inode->i_mode))
564 inode->i_op = &ext2_symlink_inode_operations;
565 else if (S_ISCHR(inode->i_mode))
566 inode->i_op = &chrdev_inode_operations;
567 else if (S_ISBLK(inode->i_mode))
568 inode->i_op = &blkdev_inode_operations;
569 else if (S_ISFIFO(inode->i_mode))
570 init_fifo(inode);
571 if (inode->u.ext2_i.i_flags & EXT2_SYNC_FL)
572 inode->i_flags |= MS_SYNCHRONOUS;
573 if (inode->u.ext2_i.i_flags & EXT2_APPEND_FL)
574 inode->i_flags |= S_APPEND;
575 if (inode->u.ext2_i.i_flags & EXT2_IMMUTABLE_FL)
576 inode->i_flags |= S_IMMUTABLE;
577 }
578
579 static struct buffer_head * ext2_update_inode (struct inode * inode)
580 {
581 struct buffer_head * bh;
582 struct ext2_inode * raw_inode;
583 unsigned long block_group;
584 unsigned long group_desc;
585 unsigned long desc;
586 unsigned long block;
587 struct ext2_group_desc * gdp;
588
589 if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino < EXT2_FIRST_INO) ||
590 inode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
591 ext2_error (inode->i_sb, "ext2_write_inode",
592 "bad inode number: %lu", inode->i_ino);
593 return 0;
594 }
595 block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
596 if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
597 ext2_panic (inode->i_sb, "ext2_write_inode",
598 "group >= groups count");
599 group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
600 desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
601 bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
602 if (!bh)
603 ext2_panic (inode->i_sb, "ext2_write_inode",
604 "Descriptor not loaded");
605 gdp = (struct ext2_group_desc *) bh->b_data;
606 block = gdp[desc].bg_inode_table +
607 (((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
608 / EXT2_INODES_PER_BLOCK(inode->i_sb));
609 if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
610 ext2_panic (inode->i_sb, "ext2_write_inode",
611 "unable to read i-node block - "
612 "inode=%lu, block=%lu", inode->i_ino, block);
613 raw_inode = ((struct ext2_inode *)bh->b_data) +
614 (inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
615 raw_inode->i_mode = inode->i_mode;
616 raw_inode->i_uid = inode->i_uid;
617 raw_inode->i_gid = inode->i_gid;
618 raw_inode->i_links_count = inode->i_nlink;
619 raw_inode->i_size = inode->i_size;
620 raw_inode->i_atime = inode->i_atime;
621 raw_inode->i_ctime = inode->i_ctime;
622 raw_inode->i_mtime = inode->i_mtime;
623 raw_inode->i_blocks = inode->i_blocks;
624 raw_inode->i_dtime = inode->u.ext2_i.i_dtime;
625 raw_inode->i_flags = inode->u.ext2_i.i_flags;
626 raw_inode->i_faddr = inode->u.ext2_i.i_faddr;
627 raw_inode->i_frag = inode->u.ext2_i.i_frag_no;
628 raw_inode->i_fsize = inode->u.ext2_i.i_frag_size;
629 raw_inode->i_file_acl = inode->u.ext2_i.i_file_acl;
630 raw_inode->i_dir_acl = inode->u.ext2_i.i_dir_acl;
631 raw_inode->i_version = inode->u.ext2_i.i_version;
632 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
633 raw_inode->i_block[0] = inode->i_rdev;
634 else for (block = 0; block < EXT2_N_BLOCKS; block++)
635 raw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
636 mark_buffer_dirty(bh, 1);
637 inode->i_dirt = 0;
638 return bh;
639 }
640
641 void ext2_write_inode (struct inode * inode)
642 {
643 struct buffer_head * bh;
644 bh = ext2_update_inode (inode);
645 brelse (bh);
646 }
647
648 int ext2_sync_inode (struct inode *inode)
649 {
650 int err = 0;
651 struct buffer_head *bh;
652
653 bh = ext2_update_inode (inode);
654 if (bh && bh->b_dirt)
655 {
656 ll_rw_block (WRITE, 1, &bh);
657 wait_on_buffer (bh);
658 if (bh->b_req && !bh->b_uptodate)
659 {
660 printk ("IO error syncing ext2 inode [%04x:%08lx]\n",
661 inode->i_dev, inode->i_ino);
662 err = -1;
663 }
664 }
665 else if (!bh)
666 err = -1;
667 brelse (bh);
668 return err;
669 }