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