home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.0 / LINUX-1.0 / LINUX-1 / linux / fs / ext2 / inode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-07  |  16.8 KB  |  586 lines
  1. /*
  2.  *  linux/fs/ext2/inode.c
  3.  *
  4.  *  Copyright (C) 1992, 1993, 1994  Remy Card (card@masi.ibp.fr)
  5.  *                                  Laboratoire MASI - Institut Blaise Pascal
  6.  *                                  Universite Pierre et Marie Curie (Paris VI)
  7.  *
  8.  *  from
  9.  *
  10.  *  linux/fs/minix/inode.c
  11.  *
  12.  *  Copyright (C) 1991, 1992  Linus Torvalds
  13.  *
  14.  *  Goal-directed block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
  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.  * ext2_discard_prealloc and ext2_alloc_block are atomic wrt. the
  63.  * superblock in the same manner as are ext2_free_blocks and
  64.  * ext2_new_block.  We just wait on the super rather than locking it
  65.  * here, since ext2_new_block will do the necessary locking and we
  66.  * can't block until then.
  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.         /* It doesn't matter if we block in getblk() since
  102.            we have already atomically allocated the block, and
  103.            are only clearing it now. */
  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.         bh->b_dirt = 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.     bh->b_dirt = 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. struct buffer_head * ext2_getblk (struct inode * inode, long block,
  332.                   int create, int * err)
  333. {
  334.     struct buffer_head * bh;
  335.     unsigned long b;
  336.     unsigned long addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
  337.  
  338.     *err = -EIO;
  339.     if (block < 0) {
  340.         ext2_warning (inode->i_sb, "ext2_getblk", "block < 0");
  341.         return NULL;
  342.     }
  343.     if (block > EXT2_NDIR_BLOCKS + addr_per_block  +
  344.             addr_per_block * addr_per_block +
  345.             addr_per_block * addr_per_block * addr_per_block) {
  346.         ext2_warning (inode->i_sb, "ext2_getblk", "block > big");
  347.         return NULL;
  348.     }
  349.     /*
  350.      * If this is a sequential block allocation, set the next_alloc_block
  351.      * to this block now so that all the indblock and data block
  352.      * allocations use the same goal zone
  353.      */
  354.  
  355.     ext2_debug ("block %lu, next %lu, goal %lu.\n", block, 
  356.             inode->u.ext2_i.i_next_alloc_block,
  357.             inode->u.ext2_i.i_next_alloc_goal);
  358.  
  359.     if (block == inode->u.ext2_i.i_next_alloc_block + 1) {
  360.         inode->u.ext2_i.i_next_alloc_block++;
  361.         inode->u.ext2_i.i_next_alloc_goal++;
  362.     }
  363.  
  364.     *err = -ENOSPC;
  365.     b = block;
  366.     if (block < EXT2_NDIR_BLOCKS)
  367.         return inode_getblk (inode, block, create, b, err);
  368.     block -= EXT2_NDIR_BLOCKS;
  369.     if (block < addr_per_block) {
  370.         bh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, err);
  371.         return block_getblk (inode, bh, block, create,
  372.                      inode->i_sb->s_blocksize, b, err);
  373.     }
  374.     block -= addr_per_block;
  375.     if (block < addr_per_block * addr_per_block) {
  376.         bh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, err);
  377.         bh = block_getblk (inode, bh, block / addr_per_block, create,
  378.                    inode->i_sb->s_blocksize, b, err);
  379.         return block_getblk (inode, bh, block & (addr_per_block - 1),
  380.                      create, inode->i_sb->s_blocksize, b, err);
  381.     }
  382.     block -= addr_per_block * addr_per_block;
  383.     bh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, err);
  384.     bh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
  385.                create, inode->i_sb->s_blocksize, b, err);
  386.     bh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
  387.                create, inode->i_sb->s_blocksize, b, err);
  388.     return block_getblk (inode, bh, block & (addr_per_block - 1), create,
  389.                  inode->i_sb->s_blocksize, b, err);
  390. }
  391.  
  392. struct buffer_head * ext2_bread (struct inode * inode, int block, 
  393.                  int create, int *err)
  394. {
  395.     struct buffer_head * bh;
  396.  
  397.     bh = ext2_getblk (inode, block, create, err);
  398.     if (!bh || bh->b_uptodate)
  399.         return bh;
  400.     ll_rw_block (READ, 1, &bh);
  401.     wait_on_buffer (bh);
  402.     if (bh->b_uptodate)
  403.         return bh;
  404.     brelse (bh);
  405.     *err = -EIO;
  406.     return NULL;
  407. }
  408.  
  409. void ext2_read_inode (struct inode * inode)
  410. {
  411.     struct buffer_head * bh;
  412.     struct ext2_inode * raw_inode;
  413.     unsigned long block_group;
  414.     unsigned long group_desc;
  415.     unsigned long desc;
  416.     unsigned long block;
  417.     struct ext2_group_desc * gdp;
  418.  
  419.     if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino != EXT2_ACL_IDX_INO &&
  420.          inode->i_ino != EXT2_ACL_DATA_INO && inode->i_ino < EXT2_FIRST_INO) ||
  421.         inode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
  422.         ext2_error (inode->i_sb, "ext2_read_inode",
  423.                 "bad inode number: %lu", inode->i_ino);
  424.         return;
  425.     }
  426.     block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
  427.     if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
  428.         ext2_panic (inode->i_sb, "ext2_read_inode",
  429.                 "group >= groups count");
  430.     group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
  431.     desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
  432.     bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
  433.     if (!bh)
  434.         ext2_panic (inode->i_sb, "ext2_read_inode",
  435.                 "Descriptor not loaded");
  436.     gdp = (struct ext2_group_desc *) bh->b_data;
  437.     block = gdp[desc].bg_inode_table +
  438.         (((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
  439.          / EXT2_INODES_PER_BLOCK(inode->i_sb));
  440.     if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
  441.         ext2_panic (inode->i_sb, "ext2_read_inode",
  442.                 "unable to read i-node block\n"
  443.                 "inode=%lu, block=%lu", inode->i_ino, block);
  444.     raw_inode = ((struct ext2_inode *) bh->b_data) +
  445.         (inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
  446.     inode->i_mode = raw_inode->i_mode;
  447.     inode->i_uid = raw_inode->i_uid;
  448.     inode->i_gid = raw_inode->i_gid;
  449.     inode->i_nlink = raw_inode->i_links_count;
  450.     inode->i_size = raw_inode->i_size;
  451.     inode->i_atime = raw_inode->i_atime;
  452.     inode->i_ctime = raw_inode->i_ctime;
  453.     inode->i_mtime = raw_inode->i_mtime;
  454.     inode->u.ext2_i.i_dtime = raw_inode->i_dtime;
  455.     inode->i_blksize = inode->i_sb->s_blocksize;
  456.     inode->i_blocks = raw_inode->i_blocks;
  457.     inode->u.ext2_i.i_flags = raw_inode->i_flags;
  458.     inode->u.ext2_i.i_faddr = raw_inode->i_faddr;
  459.     inode->u.ext2_i.i_frag = raw_inode->i_frag;
  460.     inode->u.ext2_i.i_fsize = raw_inode->i_fsize;
  461.     inode->u.ext2_i.i_file_acl = raw_inode->i_file_acl;
  462.     inode->u.ext2_i.i_dir_acl = raw_inode->i_dir_acl;
  463.     inode->u.ext2_i.i_version = raw_inode->i_version;
  464.     inode->u.ext2_i.i_block_group = block_group;
  465.     inode->u.ext2_i.i_next_alloc_block = 0;
  466.     inode->u.ext2_i.i_next_alloc_goal = 0;
  467.     if (inode->u.ext2_i.i_prealloc_count)
  468.         ext2_error (inode->i_sb, "ext2_read_inode",
  469.                 "New inode has non-zero prealloc count!");
  470.     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  471.         inode->i_rdev = raw_inode->i_block[0];
  472.     else for (block = 0; block < EXT2_N_BLOCKS; block++)
  473.         inode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
  474.     brelse (bh);
  475.     inode->i_op = NULL;
  476.     if (inode->i_ino == EXT2_ACL_IDX_INO ||
  477.         inode->i_ino == EXT2_ACL_DATA_INO)
  478.         /* Nothing to do */ ;
  479.     else if (S_ISREG(inode->i_mode))
  480.         inode->i_op = &ext2_file_inode_operations;
  481.     else if (S_ISDIR(inode->i_mode))
  482.         inode->i_op = &ext2_dir_inode_operations;
  483.     else if (S_ISLNK(inode->i_mode))
  484.         inode->i_op = &ext2_symlink_inode_operations;
  485.     else if (S_ISCHR(inode->i_mode))
  486.         inode->i_op = &chrdev_inode_operations;
  487.     else if (S_ISBLK(inode->i_mode))
  488.         inode->i_op = &blkdev_inode_operations;
  489.     else if (S_ISFIFO(inode->i_mode))
  490.         init_fifo(inode);
  491.     if (inode->u.ext2_i.i_flags & EXT2_SYNC_FL)
  492.         inode->i_flags |= MS_SYNC;
  493. }
  494.  
  495. static struct buffer_head * ext2_update_inode (struct inode * inode)
  496. {
  497.     struct buffer_head * bh;
  498.     struct ext2_inode * raw_inode;
  499.     unsigned long block_group;
  500.     unsigned long group_desc;
  501.     unsigned long desc;
  502.     unsigned long block;
  503.     struct ext2_group_desc * gdp;
  504.  
  505.     if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino < EXT2_FIRST_INO) ||
  506.         inode->i_ino > inode->i_sb->u.ext2_sb.s_es->s_inodes_count) {
  507.         ext2_error (inode->i_sb, "ext2_write_inode",
  508.                 "bad inode number: %lu", inode->i_ino);
  509.         return 0;
  510.     }
  511.     block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
  512.     if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
  513.         ext2_panic (inode->i_sb, "ext2_write_inode",
  514.                 "group >= groups count");
  515.     group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
  516.     desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
  517.     bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
  518.     if (!bh)
  519.         ext2_panic (inode->i_sb, "ext2_write_inode",
  520.                 "Descriptor not loaded");
  521.     gdp = (struct ext2_group_desc *) bh->b_data;
  522.     block = gdp[desc].bg_inode_table +
  523.         (((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
  524.          / EXT2_INODES_PER_BLOCK(inode->i_sb));
  525.     if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
  526.         ext2_panic (inode->i_sb, "ext2_write_inode",
  527.                 "unable to read i-node block\n"
  528.                 "inode=%lu, block=%lu", inode->i_ino, block);
  529.     raw_inode = ((struct ext2_inode *)bh->b_data) +
  530.         (inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
  531.     raw_inode->i_mode = inode->i_mode;
  532.     raw_inode->i_uid = inode->i_uid;
  533.     raw_inode->i_gid = inode->i_gid;
  534.     raw_inode->i_links_count = inode->i_nlink;
  535.     raw_inode->i_size = inode->i_size;
  536.     raw_inode->i_atime = inode->i_atime;
  537.     raw_inode->i_ctime = inode->i_ctime;
  538.     raw_inode->i_mtime = inode->i_mtime;
  539.     raw_inode->i_blocks = inode->i_blocks;
  540.     raw_inode->i_dtime = inode->u.ext2_i.i_dtime;
  541.     raw_inode->i_flags = inode->u.ext2_i.i_flags;
  542.     raw_inode->i_faddr = inode->u.ext2_i.i_faddr;
  543.     raw_inode->i_frag = inode->u.ext2_i.i_frag;
  544.     raw_inode->i_fsize = inode->u.ext2_i.i_fsize;
  545.     raw_inode->i_file_acl = inode->u.ext2_i.i_file_acl;
  546.     raw_inode->i_dir_acl = inode->u.ext2_i.i_dir_acl;
  547.     raw_inode->i_version = inode->u.ext2_i.i_version;
  548.     if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  549.         raw_inode->i_block[0] = inode->i_rdev;
  550.     else for (block = 0; block < EXT2_N_BLOCKS; block++)
  551.         raw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
  552.     bh->b_dirt = 1;
  553.     inode->i_dirt = 0;
  554.     return bh;
  555. }
  556.  
  557. void ext2_write_inode (struct inode * inode)
  558. {
  559.     struct buffer_head * bh;
  560.     bh = ext2_update_inode (inode);
  561.     brelse (bh);
  562. }
  563.  
  564. int ext2_sync_inode (struct inode *inode)
  565. {
  566.     int err = 0;
  567.     struct buffer_head *bh;
  568.  
  569.     bh = ext2_update_inode (inode);
  570.     if (bh && bh->b_dirt)
  571.     {
  572.         ll_rw_block (WRITE, 1, &bh);
  573.         wait_on_buffer (bh);
  574.         if (bh->b_req && !bh->b_uptodate)
  575.         {
  576.             printk ("IO error syncing ext2 inode [%04x:%08lx]\n",
  577.                 inode->i_dev, inode->i_ino);
  578.             err = -1;
  579.         }
  580.     }
  581.     else if (!bh)
  582.         err = -1;
  583.     brelse (bh);
  584.     return err;
  585. }
  586.