root/fs/ext2/inode.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. ext2_put_inode
  2. ext2_put_super
  3. convert_pre_02b_fs
  4. ext2_read_super
  5. ext2_write_super
  6. ext2_statfs
  7. block_bmap
  8. ext2_bmap
  9. inode_getblk
  10. block_getblk
  11. ext2_getblk
  12. ext2_bread
  13. ext2_read_inode
  14. ext2_write_inode

   1 /*
   2  *  linux/fs/ext2/inode.c
   3  *
   4  *  Copyright (C) 1992, 1993  Remy Card (card@masi.ibp.fr)
   5  *
   6  *  from
   7  *
   8  *  linux/fs/minix/inode.c
   9  *
  10  *  Copyright (C) 1991, 1992  Linus Torvalds
  11  */
  12 
  13 #include <linux/sched.h>
  14 #include <linux/ext2_fs.h>
  15 #include <linux/kernel.h>
  16 #include <linux/mm.h>
  17 #include <linux/string.h>
  18 #include <linux/stat.h>
  19 #include <linux/locks.h>
  20 
  21 #include <asm/system.h>
  22 #include <asm/segment.h>
  23 
  24 void ext2_put_inode (struct inode * inode)
     /* [previous][next][first][last][top][bottom][index][help] */
  25 {
  26         if (inode->i_nlink)
  27                 return;
  28         inode->i_size = 0;
  29         if (inode->i_blocks)
  30                 ext2_truncate (inode);
  31         ext2_free_inode (inode);
  32 }
  33 
  34 void ext2_put_super (struct super_block * sb)
     /* [previous][next][first][last][top][bottom][index][help] */
  35 {
  36         struct ext2_super_block * es;
  37         int i;
  38 
  39         lock_super (sb);
  40         es = (struct ext2_super_block *) sb->u.ext2_sb.s_sbh->b_data;
  41         es->s_valid = 1;
  42         sb->u.ext2_sb.s_sbh->b_dirt = 1;
  43 #ifndef DONT_USE_DCACHE
  44         ext2_dcache_invalidate (sb->s_dev);
  45 #endif
  46         sb->s_dev = 0;
  47         for (i = 0; i < EXT2_MAX_GROUP_DESC; i++)
  48                 if (sb->u.ext2_sb.s_group_desc[i])
  49                         brelse (sb->u.ext2_sb.s_group_desc[i]);
  50         for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)
  51                 if (sb->u.ext2_sb.s_inode_bitmap[i])
  52                         brelse (sb->u.ext2_sb.s_inode_bitmap[i]);
  53         for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)
  54                 if (sb->u.ext2_sb.s_block_bitmap[i])
  55                         brelse (sb->u.ext2_sb.s_block_bitmap[i]);
  56         unlock_super (sb);
  57         return;
  58 }
  59 
  60 static struct super_operations ext2_sops = { 
  61         ext2_read_inode,
  62         NULL,
  63         ext2_write_inode,
  64         ext2_put_inode,
  65         ext2_put_super,
  66         ext2_write_super,
  67         ext2_statfs
  68 };
  69 
  70 static int convert_pre_02b_fs (struct super_block * sb,
     /* [previous][next][first][last][top][bottom][index][help] */
  71                                struct buffer_head * bh)
  72 {
  73         struct ext2_super_block * es;
  74         struct ext2_old_group_desc old_group_desc [BLOCK_SIZE / sizeof (struct ext2_old_group_desc)];
  75         struct ext2_group_desc * gdp;
  76         struct buffer_head * bh2;
  77         int groups_count;
  78         int i;
  79 
  80         es = (struct ext2_super_block *) bh->b_data;
  81         bh2 = bread (sb->s_dev, 2, BLOCK_SIZE);
  82         if (!bh2) {
  83                 printk ("Cannot read descriptor blocks while converting !\n");
  84                 return 0;
  85         }
  86         memcpy (old_group_desc, bh2->b_data, BLOCK_SIZE);
  87         groups_count = (sb->u.ext2_sb.s_blocks_count - 
  88                         sb->u.ext2_sb.s_first_data_block +
  89                         (EXT2_BLOCK_SIZE(sb) * 8) - 1) /
  90                                 (EXT2_BLOCK_SIZE(sb) * 8);
  91         memset (bh2->b_data, 0, BLOCK_SIZE);
  92         gdp = (struct ext2_group_desc *) bh2->b_data;
  93         for (i = 0; i < groups_count; i++) {
  94                 gdp[i].bg_block_bitmap = old_group_desc[i].bg_block_bitmap;
  95                 gdp[i].bg_inode_bitmap = old_group_desc[i].bg_inode_bitmap;
  96                 gdp[i].bg_inode_table = old_group_desc[i].bg_inode_table;
  97                 gdp[i].bg_free_blocks_count = old_group_desc[i].bg_free_blocks_count;
  98                 gdp[i].bg_free_inodes_count = old_group_desc[i].bg_free_inodes_count;
  99         }
 100         bh2->b_dirt = 1;
 101         brelse (bh2);
 102         es->s_magic = EXT2_SUPER_MAGIC;
 103         bh->b_dirt = 1;
 104         sb->s_magic = EXT2_SUPER_MAGIC;
 105         return 1;
 106 }
 107 
 108 struct super_block * ext2_read_super (struct super_block * s, void * data)
     /* [previous][next][first][last][top][bottom][index][help] */
 109 {
 110         struct buffer_head * bh;
 111         struct ext2_super_block * es;
 112         int dev = s->s_dev;
 113         int bh_count;
 114         int i, j;
 115         int fs_converted = 0;
 116 
 117         lock_super (s);
 118         if (!(bh = bread (dev, 1, BLOCK_SIZE))) {
 119                 s->s_dev = 0;
 120                 unlock_super (s);
 121                 printk ("EXT2-fs: unable to read superblock\n");
 122                 return NULL;
 123         }
 124         es = (struct ext2_super_block *) bh->b_data;
 125         s->s_blocksize = EXT2_MIN_BLOCK_SIZE << es->s_log_block_size;
 126         s->u.ext2_sb.s_inodes_count = es->s_inodes_count;
 127         s->u.ext2_sb.s_blocks_count = es->s_blocks_count;
 128         s->u.ext2_sb.s_r_blocks_count = es->s_r_blocks_count;
 129         s->u.ext2_sb.s_first_data_block = es->s_first_data_block;
 130         s->u.ext2_sb.s_log_block_size = es->s_log_block_size;
 131         s->u.ext2_sb.s_log_frag_size = es->s_log_frag_size;
 132         s->u.ext2_sb.s_frag_size = EXT2_MIN_FRAG_SIZE <<
 133                                      es->s_log_frag_size;
 134         s->u.ext2_sb.s_frags_per_block = s->s_blocksize /
 135                                            s->u.ext2_sb.s_frag_size;
 136         s->u.ext2_sb.s_blocks_per_group = es->s_blocks_per_group;
 137         s->u.ext2_sb.s_frags_per_group = es->s_frags_per_group;
 138         s->u.ext2_sb.s_inodes_per_group = es->s_inodes_per_group;
 139         s->u.ext2_sb.s_inodes_per_block = s->s_blocksize /
 140                                             sizeof (struct ext2_inode);
 141         s->u.ext2_sb.s_desc_per_block = s->s_blocksize /
 142                                           sizeof (struct ext2_group_desc);
 143         s->s_magic = es->s_magic;
 144         s->u.ext2_sb.s_sbh = bh;
 145         s->u.ext2_sb.s_rename_lock = 0;
 146         s->u.ext2_sb.s_rename_wait = NULL;
 147         if (s->s_magic == EXT2_OLD_SUPER_MAGIC) {
 148                 if (es->s_blocks_count > 262144) {
 149                          /* fs > 256 MB can't be converted */ 
 150                         s->s_dev = 0;
 151                         unlock_super (s);
 152                         brelse (bh);
 153                         printk ("EXT2-fs: trying to mount a pre-0.2b file"
 154                                 "system which cannot be converted\n");
 155                         return NULL;
 156                 }
 157                 printk ("EXT2-fs: mounting a pre 0.2b file system, "
 158                         "will try to convert the structure\n");
 159                 if (s->s_flags & MS_RDONLY == 0) {
 160                         s->s_dev = 0;
 161                         unlock_super (s);
 162                         brelse (bh);
 163                         printk ("EXT2-fs: cannot convert a read-only fs\n");
 164                         return NULL;
 165                 }
 166                 if (!convert_pre_02b_fs (s, bh)) {
 167                         s->s_dev = 0;
 168                         unlock_super (s);
 169                         brelse (bh);
 170                         printk ("EXT2-fs: conversion failed !!!\n");
 171                         return NULL;
 172                 }
 173                 printk ("EXT2-fs: conversion succeeded !!!\n");
 174                 fs_converted = 1;
 175         }
 176         if (s->s_magic != EXT2_SUPER_MAGIC) {
 177                 s->s_dev = 0;
 178                 unlock_super (s);
 179                 brelse (bh);
 180                 printk ("EXT2-fs: magic match failed\n");
 181                 return NULL;
 182         }
 183         if (s->s_blocksize != s->u.ext2_sb.s_frag_size) {
 184                 s->s_dev = 0;
 185                 unlock_super (s);
 186                 brelse (bh);
 187                 printk ("EXT2-fs: fragsize != blocksize (not supported yet)\n");
 188                 return NULL;
 189         }
 190         if (!es->s_valid)
 191                 printk ("EXT2-fs warning: mounting non valid file system\n");
 192         s->u.ext2_sb.s_groups_count = (s->u.ext2_sb.s_blocks_count -
 193                                        s->u.ext2_sb.s_first_data_block +
 194                                        (EXT2_BLOCK_SIZE(s) * 8) - 1) /
 195                                        (EXT2_BLOCK_SIZE(s) * 8);
 196         for (i = 0; i < EXT2_MAX_GROUP_DESC; i++)
 197                 s->u.ext2_sb.s_group_desc[i] = NULL;
 198         bh_count = (s->u.ext2_sb.s_groups_count +
 199                    EXT2_DESC_PER_BLOCK(s) - 1) /
 200                    EXT2_DESC_PER_BLOCK(s);
 201         for (i = 0; i < bh_count; i++) {
 202                 s->u.ext2_sb.s_group_desc[i] = bread (dev, i + 2, s->s_blocksize);
 203                 if (!s->u.ext2_sb.s_group_desc[i]) {
 204                         s->s_dev = 0;
 205                         unlock_super (s);
 206                         for (j = 0; j < i; j++)
 207                                 brelse (s->u.ext2_sb.s_group_desc[i]);
 208                         brelse (bh);
 209                         printk ("ext2_read_super: unable to read group descriptors\n");
 210                         return NULL;
 211                 }
 212         }
 213         for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++) {
 214                 s->u.ext2_sb.s_inode_bitmap_number[i] = 0;
 215                 s->u.ext2_sb.s_inode_bitmap[i] = NULL;
 216                 s->u.ext2_sb.s_block_bitmap_number[i] = 0;
 217                 s->u.ext2_sb.s_block_bitmap[i] = NULL;
 218         }
 219         s->u.ext2_sb.s_loaded_inode_bitmaps = 0;
 220         s->u.ext2_sb.s_loaded_block_bitmaps = 0;
 221         unlock_super (s);
 222         /* set up enough so that it can read an inode */
 223         s->s_dev = dev;
 224         s->s_op = &ext2_sops;
 225         if (!(s->s_mounted = iget(s, EXT2_ROOT_INO))) {
 226                 s->s_dev = 0;
 227                 for (i = 0; i < EXT2_MAX_GROUP_DESC; i++)
 228                         if (s->u.ext2_sb.s_group_desc[i])
 229                                 brelse (s->u.ext2_sb.s_group_desc[i]);
 230                 brelse (bh);
 231                 printk ("EXT2-fs: get root inode failed\n");
 232                 return NULL;
 233         }
 234         if ((s->s_flags & MS_RDONLY) == 0) {
 235                 es->s_valid = 0;
 236                 es->s_mtime = CURRENT_TIME;
 237                 bh->b_dirt = 1;
 238                 s->s_dirt = 1;
 239         }
 240         if (fs_converted) {
 241                 for (i = 0; i < bh_count; i++)
 242                         s->u.ext2_sb.s_group_desc[i]->b_dirt = 1;
 243                 s->s_dirt = 1;
 244         }
 245         printk ("[EXT II FS %s, bs=%d, fs=%d, gc=%d, bpg=%d, ipg=%d]\n",
 246                 EXT2FS_VERSION, s->s_blocksize, s->u.ext2_sb.s_frag_size,
 247                 s->u.ext2_sb.s_groups_count,
 248                 EXT2_BLOCKS_PER_GROUP(s), EXT2_INODES_PER_GROUP(s));
 249         return s;
 250 }
 251 
 252 /*
 253  * In the second extended file system, it is not necessary to
 254  * write the super block since we use a mapping of the
 255  * disk super block in a buffer.
 256  *
 257  * However, this function is still used to set the fs valid
 258  * flags to 0.  We need to set this flag to 0 since the fs
 259  * may have been checked while mounted and e2fsck may have
 260  * set s_valid to 1 after some corrections.
 261  *
 262  * Note that this function also writes backups of the super block and
 263  * of the group descriptors in each group.
 264  */
 265 void ext2_write_super (struct super_block * sb)
     /* [previous][next][first][last][top][bottom][index][help] */
 266 {
 267         struct ext2_super_block * es;
 268         struct buffer_head * bh;
 269         unsigned long block;
 270         unsigned long bh_count;
 271         int i, j;
 272 
 273         if ((sb->s_flags & MS_RDONLY) == 0) {
 274                 es = (struct ext2_super_block *) sb->u.ext2_sb.s_sbh->b_data;
 275 #ifdef EXT2FS_DEBUG
 276                 printk ("ext2_write_super: setting valid to 0\n");
 277 #endif
 278                 es->s_valid = 0;
 279                 es->s_wtime = CURRENT_TIME;
 280                 sb->u.ext2_sb.s_sbh->b_dirt = 1;
 281                 bh_count = (sb->u.ext2_sb.s_groups_count +
 282                             EXT2_DESC_PER_BLOCK(sb) - 1) /
 283                             EXT2_DESC_PER_BLOCK(sb);
 284                 for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
 285                         block = sb->u.ext2_sb.s_first_data_block +
 286                                 i * sb->u.ext2_sb.s_blocks_per_group;
 287                         if (!(bh = bread (sb->s_dev, block, BLOCK_SIZE)))
 288                                 printk ("ext2_write_super: Unable to read backup super block for group %d\n", i);
 289                         else {
 290 #ifdef EXT2FS_DEBUG
 291                                 printk ("ext2_write_super: writing super block backup in group %d at block %d\n", i, block);
 292 #endif  
 293                                 memcpy (bh->b_data, es, BLOCK_SIZE);
 294                                 bh ->b_dirt = 1;
 295                                 brelse (bh);
 296                         }
 297                         for (j = 0; j < bh_count; j++) {
 298                                 block ++;
 299 #ifdef EXT2FS_DEBUG
 300                                 printk ("ext2_write_super: writing descriptors (block %d) backup in group %d at block %d\n", j, i, block);
 301 #endif  
 302                                 if (!(bh = bread (sb->s_dev, block, sb->s_blocksize)))
 303                                         printk ("ext2_write_super: Unable to read backup descriptor for group %d\n", i);
 304                                 else {
 305                                         memcpy (bh->b_data, sb->u.ext2_sb.s_group_desc[j]->b_data, sb->s_blocksize);
 306                                         bh ->b_dirt = 1;
 307                                         brelse (bh);
 308                                 }
 309                         }
 310                 }
 311         }
 312         sb->s_dirt = 0;
 313 }
 314 
 315 void ext2_statfs (struct super_block * sb, struct statfs * buf)
     /* [previous][next][first][last][top][bottom][index][help] */
 316 {
 317         long tmp;
 318 
 319         put_fs_long (EXT2_SUPER_MAGIC, &buf->f_type);
 320         put_fs_long (sb->s_blocksize, &buf->f_bsize);
 321         put_fs_long (sb->u.ext2_sb.s_blocks_count << sb->u.ext2_sb.s_log_block_size,
 322                 &buf->f_blocks);
 323         tmp = ext2_count_free_blocks (sb);
 324         put_fs_long (tmp, &buf->f_bfree);
 325         put_fs_long (tmp - sb->u.ext2_sb.s_r_blocks_count, &buf->f_bavail);
 326         put_fs_long (sb->u.ext2_sb.s_inodes_count, &buf->f_files);
 327         put_fs_long (ext2_count_free_inodes(sb), &buf->f_ffree);
 328         put_fs_long (EXT2_NAME_LEN, &buf->f_namelen);
 329         /* Don't know what value to put in buf->f_fsid */
 330 }
 331 
 332 #define inode_bmap(inode, nr) ((inode)->u.ext2_i.i_data[(nr)])
 333 
 334 static int block_bmap (struct buffer_head * bh, int nr)
     /* [previous][next][first][last][top][bottom][index][help] */
 335 {
 336         int tmp;
 337 
 338         if (!bh)
 339                 return 0;
 340         tmp = ((unsigned long *) bh->b_data)[nr];
 341         brelse (bh);
 342         return tmp;
 343 }
 344 
 345 int ext2_bmap (struct inode * inode, int block)
     /* [previous][next][first][last][top][bottom][index][help] */
 346 {
 347         int i;
 348         int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
 349 
 350         if (block < 0) {
 351                 printk("ext2_bmap: block < 0");
 352                 return 0;
 353         }
 354         if (block >= EXT2_NDIR_BLOCKS + addr_per_block +
 355                      addr_per_block * addr_per_block +
 356                      addr_per_block * addr_per_block * addr_per_block) {
 357                 printk ("ext2_bmap: block > big");
 358                 return 0;
 359         }
 360         if (block < EXT2_NDIR_BLOCKS)
 361                 return inode_bmap (inode, block);
 362         block -= EXT2_NDIR_BLOCKS;
 363         if (block < addr_per_block) {
 364                 i = inode_bmap (inode, EXT2_IND_BLOCK);
 365                 if (!i)
 366                         return 0;
 367                 return block_bmap (bread (inode->i_dev, i,
 368                                           inode->i_sb->s_blocksize), block);
 369         }
 370         block -= addr_per_block;
 371         if (block < addr_per_block * addr_per_block) {
 372                 i = inode_bmap (inode, EXT2_DIND_BLOCK);
 373                 if (!i)
 374                         return 0;
 375                 i = block_bmap (bread (inode->i_dev, i,
 376                                        inode->i_sb->s_blocksize),
 377                                 block / addr_per_block);
 378                 if (!i)
 379                         return 0;
 380                 return block_bmap (bread (inode->i_dev, i,
 381                                           inode->i_sb->s_blocksize),
 382                                    block & (addr_per_block - 1));
 383         }
 384         block -= addr_per_block * addr_per_block;
 385         i = inode_bmap (inode, EXT2_TIND_BLOCK);
 386         if (!i)
 387                 return 0;
 388         i = block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
 389                         block / (addr_per_block * addr_per_block));
 390         if (!i)
 391                 return 0;
 392         i = block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
 393                         (block / addr_per_block) & (addr_per_block - 1));
 394         if (!i)
 395                 return 0;
 396         return block_bmap (bread (inode->i_dev, i, inode->i_sb->s_blocksize),
 397                            block & (addr_per_block - 1));
 398 }
 399 
 400 static struct buffer_head * inode_getblk (struct inode * inode, int nr,
     /* [previous][next][first][last][top][bottom][index][help] */
 401                                           int create)
 402 {
 403         int tmp;
 404         unsigned long * p;
 405         struct buffer_head * result;
 406         int blocks = inode->i_sb->s_blocksize / 512;
 407 
 408         p = inode->u.ext2_i.i_data + nr;
 409 repeat:
 410         tmp = *p;
 411         if (tmp) {
 412                 result = getblk (inode->i_dev, tmp, inode->i_sb->s_blocksize);
 413                 if (tmp == *p)
 414                         return result;
 415                 brelse (result);
 416                 goto repeat;
 417         }
 418         if (!create)
 419                 return NULL;
 420         tmp = ext2_new_block (inode->i_sb, inode->u.ext2_i.i_block_group);
 421         if (!tmp)
 422                 return NULL;
 423         result = getblk (inode->i_dev, tmp, inode->i_sb->s_blocksize);
 424         if (*p) {
 425                 ext2_free_block (inode->i_sb, tmp);
 426                 brelse (result);
 427                 goto repeat;
 428         }
 429         *p = tmp;
 430         inode->i_ctime = CURRENT_TIME;
 431         inode->i_blocks += blocks;
 432         inode->i_dirt = 1;
 433         return result;
 434 }
 435 
 436 static struct buffer_head * block_getblk (struct inode * inode,
     /* [previous][next][first][last][top][bottom][index][help] */
 437                                           struct buffer_head * bh, int nr,
 438                                           int create, int blocksize)
 439 {
 440         int tmp;
 441         unsigned long * p;
 442         struct buffer_head * result;
 443         int blocks = inode->i_sb->s_blocksize / 512;
 444 
 445         if (!bh)
 446                 return NULL;
 447         if (!bh->b_uptodate) {
 448                 ll_rw_block (READ, 1, &bh);
 449                 wait_on_buffer (bh);
 450                 if (!bh->b_uptodate) {
 451                         brelse (bh);
 452                         return NULL;
 453                 }
 454         }
 455         p = nr + (unsigned long *) bh->b_data;
 456 repeat:
 457         tmp = *p;
 458         if (tmp) {
 459                 result = getblk (bh->b_dev, tmp, blocksize);
 460                 if (tmp == *p) {
 461                         brelse (bh);
 462                         return result;
 463                 }
 464                 brelse (result);
 465                 goto repeat;
 466         }
 467         if (!create) {
 468                 brelse (bh);
 469                 return NULL;
 470         }
 471         tmp = ext2_new_block (inode->i_sb, inode->u.ext2_i.i_block_group);
 472         if (!tmp) {
 473 #ifdef EXT2FS_DEBUG
 474                 printk ("inode_getblk: ext2_new_block returned 0\n");
 475 #endif
 476                 brelse (bh);
 477                 return NULL;
 478         }
 479         result = getblk (bh->b_dev, tmp, blocksize);
 480         if (*p) {
 481                 ext2_free_block (inode->i_sb, tmp);
 482                 brelse (result);
 483                 goto repeat;
 484         }
 485         *p = tmp;
 486         bh->b_dirt = 1;
 487         inode->i_blocks += blocks;
 488         inode->i_dirt = 1;
 489         brelse (bh);
 490         return result;
 491 }
 492 
 493 struct buffer_head * ext2_getblk (struct inode * inode, int block,
     /* [previous][next][first][last][top][bottom][index][help] */
 494                                   int create)
 495 {
 496         struct buffer_head * bh;
 497         unsigned long addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
 498 
 499         if (block < 0) {
 500                 printk ("ext2_getblk: block < 0\n");
 501                 return NULL;
 502         }
 503         if (block > EXT2_NDIR_BLOCKS + addr_per_block  +
 504                     addr_per_block * addr_per_block +
 505                     addr_per_block * addr_per_block * addr_per_block) {
 506                 printk ("ext2_getblk: block > big\n");
 507                 return NULL;
 508         }
 509         if (block < EXT2_NDIR_BLOCKS)
 510                 return inode_getblk (inode, block, create);
 511         block -= EXT2_NDIR_BLOCKS;
 512         if (block < addr_per_block) {
 513                 bh = inode_getblk (inode, EXT2_IND_BLOCK, create);
 514                 return block_getblk (inode, bh, block, create,
 515                                      inode->i_sb->s_blocksize);
 516         }
 517         block -= addr_per_block;
 518         if (block < addr_per_block * addr_per_block) {
 519                 bh = inode_getblk (inode, EXT2_DIND_BLOCK, create);
 520                 bh = block_getblk (inode, bh, block / addr_per_block, create,
 521                                    inode->i_sb->s_blocksize);
 522                 return block_getblk (inode, bh, block & (addr_per_block - 1),
 523                                      create, inode->i_sb->s_blocksize);
 524         }
 525         block -= addr_per_block * addr_per_block;
 526         bh = inode_getblk (inode, EXT2_IND_BLOCK, create);
 527         bh = block_getblk (inode, bh, block / (addr_per_block * addr_per_block),
 528                            create, inode->i_sb->s_blocksize);
 529         bh = block_getblk (inode, bh, (block / addr_per_block) & (addr_per_block - 1),
 530                            create, inode->i_sb->s_blocksize);
 531         return block_getblk (inode, bh, block & (addr_per_block - 1), create,
 532                              inode->i_sb->s_blocksize);
 533 }
 534 
 535 struct buffer_head * ext2_bread (struct inode * inode, int block, int create)
     /* [previous][next][first][last][top][bottom][index][help] */
 536 {
 537         struct buffer_head * bh;
 538 
 539         bh = ext2_getblk (inode, block, create);
 540         if (!bh || bh->b_uptodate)
 541                 return bh;
 542         ll_rw_block (READ, 1, &bh);
 543         wait_on_buffer (bh);
 544         if (bh->b_uptodate)
 545                 return bh;
 546         brelse (bh);
 547         return NULL;
 548 }
 549 
 550 void ext2_read_inode (struct inode * inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 551 {
 552         struct buffer_head * bh;
 553         struct ext2_inode * raw_inode;
 554         unsigned long block_group;
 555         unsigned long group_desc;
 556         unsigned long desc;
 557         unsigned long block;
 558         struct ext2_group_desc * gdp;
 559 
 560         if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino < EXT2_FIRST_INO) ||
 561             inode->i_ino > inode->i_sb->u.ext2_sb.s_inodes_count) {
 562                 printk ("ext2_read_inode: bad inode number of dev %0x04: %d\n",
 563                         inode->i_dev, inode->i_ino);
 564                 return;
 565         }
 566         block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
 567         if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
 568                 panic ("ext2_read_inode: group >= groups count");
 569         group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
 570         desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
 571         bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
 572         if (!bh)
 573                 panic ("ext2_read_inode: Descriptor not loaded");
 574         gdp = (struct ext2_group_desc *) bh->b_data;
 575         block = gdp[desc].bg_inode_table +
 576                 (((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
 577                  / EXT2_INODES_PER_BLOCK(inode->i_sb));
 578         if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
 579                 panic ("ext2_read_inode: unable to read i-node block");
 580         raw_inode = ((struct ext2_inode *) bh->b_data) +
 581                 (inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
 582         inode->i_mode = raw_inode->i_mode;
 583         inode->i_uid = raw_inode->i_uid;
 584         inode->i_gid = raw_inode->i_gid;
 585         inode->i_nlink = raw_inode->i_links_count;
 586         inode->i_size = raw_inode->i_size;
 587         inode->i_atime = raw_inode->i_atime;
 588         inode->i_ctime = raw_inode->i_ctime;
 589         inode->i_mtime = raw_inode->i_mtime;
 590         inode->u.ext2_i.i_dtime = raw_inode->i_dtime;
 591         inode->i_blksize = inode->i_sb->s_blocksize;
 592         inode->i_blocks = raw_inode->i_blocks;
 593         inode->u.ext2_i.i_flags = raw_inode->i_flags;
 594         inode->u.ext2_i.i_faddr = raw_inode->i_faddr;
 595         inode->u.ext2_i.i_frag = raw_inode->i_frag;
 596         inode->u.ext2_i.i_fsize = raw_inode->i_fsize;
 597         inode->u.ext2_i.i_file_acl = raw_inode->i_file_acl;
 598         inode->u.ext2_i.i_dir_acl = raw_inode->i_dir_acl;
 599         inode->u.ext2_i.i_version = raw_inode->i_version;
 600         inode->u.ext2_i.i_block_group = block_group;
 601         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 602                 inode->i_rdev = raw_inode->i_block[0];
 603         else for (block = 0; block < EXT2_N_BLOCKS; block++)
 604                 inode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
 605         brelse (bh);
 606         inode->i_op = NULL;
 607         if (S_ISREG(inode->i_mode))
 608                 inode->i_op = &ext2_file_inode_operations;
 609         else if (S_ISDIR(inode->i_mode))
 610                 inode->i_op = &ext2_dir_inode_operations;
 611         else if (S_ISLNK(inode->i_mode))
 612                 inode->i_op = &ext2_symlink_inode_operations;
 613         else if (S_ISCHR(inode->i_mode))
 614                 inode->i_op = &chrdev_inode_operations;
 615         else if (S_ISBLK(inode->i_mode))
 616                 inode->i_op = &blkdev_inode_operations;
 617         else if (S_ISFIFO(inode->i_mode)) {
 618                 inode->i_op = &fifo_inode_operations;
 619                 inode->i_pipe = 1;
 620                 PIPE_BASE(*inode) = NULL;
 621                 PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
 622                 PIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
 623                 PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
 624         }
 625 }
 626 
 627 void ext2_write_inode (struct inode * inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 628 {
 629         struct buffer_head * bh;
 630         struct ext2_inode * raw_inode;
 631         unsigned long block_group;
 632         unsigned long group_desc;
 633         unsigned long desc;
 634         unsigned long block;
 635         struct ext2_group_desc * gdp;
 636 
 637         if ((inode->i_ino != EXT2_ROOT_INO && inode->i_ino < EXT2_FIRST_INO) ||
 638             inode->i_ino > inode->i_sb->u.ext2_sb.s_inodes_count) {
 639                 printk ("ext2_write_inode: bad inode number of dev %0x04: %d\n",
 640                         inode->i_dev, inode->i_ino);
 641                 return;
 642         }
 643         block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
 644         if (block_group >= inode->i_sb->u.ext2_sb.s_groups_count)
 645                 panic ("ext2_write_inode: group >= groups count");
 646         group_desc = block_group / EXT2_DESC_PER_BLOCK(inode->i_sb);
 647         desc = block_group % EXT2_DESC_PER_BLOCK(inode->i_sb);
 648         bh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
 649         if (!bh)
 650                 panic ("ext2_write_inode: Descriptor not loaded");
 651         gdp = (struct ext2_group_desc *) bh->b_data;
 652         block = gdp[desc].bg_inode_table +
 653                 (((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb))
 654                  / EXT2_INODES_PER_BLOCK(inode->i_sb));
 655         if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
 656                 panic ("ext2_write_inode: unable to read i-node block");
 657         raw_inode = ((struct ext2_inode *)bh->b_data) +
 658                 (inode->i_ino - 1) % EXT2_INODES_PER_BLOCK(inode->i_sb);
 659         raw_inode->i_mode = inode->i_mode;
 660         raw_inode->i_uid = inode->i_uid;
 661         raw_inode->i_gid = inode->i_gid;
 662         raw_inode->i_links_count = inode->i_nlink;
 663         raw_inode->i_size = inode->i_size;
 664         raw_inode->i_atime = inode->i_atime;
 665         raw_inode->i_ctime = inode->i_ctime;
 666         raw_inode->i_mtime = inode->i_mtime;
 667         raw_inode->i_dtime = inode->u.ext2_i.i_dtime;
 668         raw_inode->i_blocks = inode->i_blocks;
 669         raw_inode->i_flags = inode->u.ext2_i.i_flags;
 670         raw_inode->i_faddr = inode->u.ext2_i.i_faddr;
 671         raw_inode->i_frag = inode->u.ext2_i.i_frag;
 672         raw_inode->i_fsize = inode->u.ext2_i.i_fsize;
 673         raw_inode->i_file_acl = inode->u.ext2_i.i_file_acl;
 674         raw_inode->i_dir_acl = inode->u.ext2_i.i_dir_acl;
 675         raw_inode->i_version = inode->u.ext2_i.i_version;
 676         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 677                 raw_inode->i_block[0] = inode->i_rdev;
 678         else for (block = 0; block < EXT2_N_BLOCKS; block++)
 679                 raw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
 680         bh->b_dirt = 1;
 681         inode->i_dirt = 0;
 682         brelse (bh);
 683 }

/* [previous][next][first][last][top][bottom][index][help] */