fs/ufs/inode.c

   1 /*
   2  *  linux/fs/ufs/inode.c
   3  *
   4  * Copyright (C) 1998
   5  * Daniel Pirkl <daniel.pirkl@email.cz>
   6  * Charles University, Faculty of Mathematics and Physics
   7  *
   8  *  from
   9  *
  10  *  linux/fs/ext2/inode.c
  11  *
  12  * Copyright (C) 1992, 1993, 1994, 1995
  13  * Remy Card (card@masi.ibp.fr)
  14  * Laboratoire MASI - Institut Blaise Pascal
  15  * Universite Pierre et Marie Curie (Paris VI)
  16  *
  17  *  from
  18  *
  19  *  linux/fs/minix/inode.c
  20  *
  21  *  Copyright (C) 1991, 1992  Linus Torvalds
  22  *
  23  *  Goal-directed block allocation by Stephen Tweedie (sct@dcs.ed.ac.uk), 1993
  24  *  Big-endian to little-endian byte-swapping/bitmaps by
  25  *        David S. Miller (davem@caip.rutgers.edu), 1995
  26  */
  27
  28 #include <asm/uaccess.h>
  29 #include <asm/system.h>
  30
  31 #include <linux/errno.h>
  32 #include <linux/fs.h>
  33 #include <linux/ufs_fs.h>
  34 #include <linux/sched.h>
  35 #include <linux/stat.h>
  36 #include <linux/string.h>
  37 #include <linux/locks.h>
  38 #include <linux/mm.h>
  39 #include <linux/smp_lock.h>
  40
  41 #include "swab.h"
  42 #include "util.h"
  43
  44 #undef UFS_INODE_DEBUG
  45 #undef UFS_INODE_DEBUG_MORE
  46
  47 #ifdef UFS_INODE_DEBUG
  48 #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
  49 #else
  50 #define UFSD(x)
  51 #endif
  52
  53 #ifdef UFS_INODE_DEBUG_MORE
  54 static void ufs_print_inode(struct inode * inode)
  55 {
  56         unsigned swab = inode->i_sb->u.ufs_sb.s_swab;
  57         printk("ino %lu  mode 0%6.6o  nlink %d  uid %d  gid %d"
  58                "  size %lu blocks %lu\n",
  59                inode->i_ino, inode->i_mode, inode->i_nlink,
  60                inode->i_uid, inode->i_gid,
  61                inode->i_size, inode->i_blocks);
  62         printk("  db <%u %u %u %u %u %u %u %u %u %u %u %u>\n",
  63                 SWAB32(inode->u.ufs_i.i_u1.i_data[0]),
  64                 SWAB32(inode->u.ufs_i.i_u1.i_data[1]),
  65                 SWAB32(inode->u.ufs_i.i_u1.i_data[2]),
  66                 SWAB32(inode->u.ufs_i.i_u1.i_data[3]),
  67                 SWAB32(inode->u.ufs_i.i_u1.i_data[4]),
  68                 SWAB32(inode->u.ufs_i.i_u1.i_data[5]),
  69                 SWAB32(inode->u.ufs_i.i_u1.i_data[6]),
  70                 SWAB32(inode->u.ufs_i.i_u1.i_data[7]),
  71                 SWAB32(inode->u.ufs_i.i_u1.i_data[8]),
  72                 SWAB32(inode->u.ufs_i.i_u1.i_data[9]),
  73                 SWAB32(inode->u.ufs_i.i_u1.i_data[10]),
  74                 SWAB32(inode->u.ufs_i.i_u1.i_data[11]));
  75         printk("  gen %u ib <%u %u %u>\n",
  76                 inode->u.ufs_i.i_gen,
  77                 SWAB32(inode->u.ufs_i.i_u1.i_data[UFS_IND_BLOCK]),
  78                 SWAB32(inode->u.ufs_i.i_u1.i_data[UFS_DIND_BLOCK]),
  79                 SWAB32(inode->u.ufs_i.i_u1.i_data[UFS_TIND_BLOCK]));
  80 }
  81 #endif
  82
  83 #define ufs_inode_bmap(inode, nr) \
  84         (SWAB32((inode)->u.ufs_i.i_u1.i_data[(nr) >> uspi->s_fpbshift]) + ((nr) & uspi->s_fpbmask))
  85
  86 static inline unsigned int ufs_block_bmap (struct buffer_head * bh, unsigned nr,
  87         struct ufs_sb_private_info * uspi, unsigned swab)
  88 {
  89         unsigned int tmp;
  90
  91         UFSD(("ENTER, nr %u\n", nr))
  92         if (!bh)
  93                 return 0;
  94         tmp = SWAB32(((u32 *) bh->b_data)[nr >> uspi->s_fpbshift]) + (nr & uspi->s_fpbmask);
  95         brelse (bh);
  96         UFSD(("EXIT, result %u\n", tmp))
  97         return tmp;
  98 }
  99
 100 int ufs_frag_map(struct inode *inode, int frag)
 101 {
 102         struct super_block *sb;
 103         struct ufs_sb_private_info *uspi;
 104         unsigned int swab;
 105         int i, ret;
 106
 107         ret = 0;
 108         lock_kernel();
 109
 110         sb = inode->i_sb;
 111         uspi = sb->u.ufs_sb.s_uspi;
 112         swab = sb->u.ufs_sb.s_swab;
 113         if (frag < 0) {
 114                 ufs_warning(sb, "ufs_frag_map", "frag < 0");
 115                 goto out;
 116         }
 117         if (frag >=
 118             ((UFS_NDADDR + uspi->s_apb + uspi->s_2apb + uspi->s_3apb)
 119              << uspi->s_fpbshift)) {
 120                 ufs_warning(sb, "ufs_frag_map", "frag > big");
 121                 goto out;
 122         }
 123
 124         if (frag < UFS_NDIR_FRAGMENT) {
 125                 ret = uspi->s_sbbase + ufs_inode_bmap(inode, frag);
 126                 goto out;
 127         }
 128
 129         frag -= UFS_NDIR_FRAGMENT;
 130         if (frag < (1 << (uspi->s_apbshift + uspi->s_fpbshift))) {
 131                 i = ufs_inode_bmap(inode,
 132                                    UFS_IND_FRAGMENT + (frag >> uspi->s_apbshift));
 133                 if (!i)
 134                         goto out;
 135                 ret = (uspi->s_sbbase +
 136                        ufs_block_bmap(bread(sb->s_dev, uspi->s_sbbase + i,
 137                                             sb->s_blocksize),
 138                                       frag & uspi->s_apbmask, uspi, swab));
 139                 goto out;
 140         }
 141         frag -= 1 << (uspi->s_apbshift + uspi->s_fpbshift);
 142         if (frag < (1 << (uspi->s_2apbshift + uspi->s_fpbshift))) {
 143                 i = ufs_inode_bmap (inode,
 144                                     UFS_DIND_FRAGMENT + (frag >> uspi->s_2apbshift));
 145                 if (!i)
 146                         goto out;
 147                 i = ufs_block_bmap(bread(sb->s_dev, uspi->s_sbbase + i,
 148                                          sb->s_blocksize),
 149                                    (frag >> uspi->s_apbshift) & uspi->s_apbmask,
 150                                    uspi, swab);
 151                 if (!i)
 152                         goto out;
 153                 ret = (uspi->s_sbbase +
 154                        ufs_block_bmap(bread(sb->s_dev, uspi->s_sbbase + i,
 155                                             sb->s_blocksize),
 156                                       (frag & uspi->s_apbmask), uspi, swab));
 157                 goto out;
 158         }
 159         frag -= 1 << (uspi->s_2apbshift + uspi->s_fpbshift);
 160         i = ufs_inode_bmap(inode,
 161                            UFS_TIND_FRAGMENT + (frag >> uspi->s_3apbshift));
 162         if (!i)
 163                 goto out;
 164         i = ufs_block_bmap(bread(sb->s_dev, uspi->s_sbbase + i, sb->s_blocksize),
 165                            (frag >> uspi->s_2apbshift) & uspi->s_apbmask,
 166                            uspi, swab);
 167         if (!i)
 168                 goto out;
 169         i = ufs_block_bmap(bread(sb->s_dev, uspi->s_sbbase + i, sb->s_blocksize),
 170                            (frag >> uspi->s_apbshift) & uspi->s_apbmask,
 171                            uspi, swab);
 172         if (!i)
 173                 goto out;
 174         ret = (uspi->s_sbbase +
 175                ufs_block_bmap(bread(sb->s_dev, uspi->s_sbbase + i, sb->s_blocksize),
 176                               (frag & uspi->s_apbmask), uspi, swab));
 177 out:
 178         unlock_kernel();
 179         return ret;
 180 }
 181
 182 static struct buffer_head * ufs_inode_getfrag (struct inode *inode,
 183         unsigned int fragment, unsigned int new_fragment,
 184         unsigned int required, int *err, int metadata, long *phys, int *new)
 185 {
 186         struct super_block * sb;
 187         struct ufs_sb_private_info * uspi;
 188         struct buffer_head * result;
 189         unsigned block, blockoff, lastfrag, lastblock, lastblockoff;
 190         unsigned tmp, goal;
 191         u32 * p, * p2;
 192         unsigned int swab;
 193
 194         UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u, required %u\n",
 195                 inode->i_ino, fragment, new_fragment, required))
 196
 197         sb = inode->i_sb;
 198         swab = sb->u.ufs_sb.s_swab;
 199         uspi = sb->u.ufs_sb.s_uspi;
 200         block = ufs_fragstoblks (fragment);
 201         blockoff = ufs_fragnum (fragment);
 202         p = inode->u.ufs_i.i_u1.i_data + block;
 203         goal = 0;
 204
 205 repeat:
 206         tmp = SWAB32(*p);
 207         lastfrag = inode->u.ufs_i.i_lastfrag;
 208         if (tmp && fragment < lastfrag) {
 209                 if (metadata) {
 210                         result = getblk (sb->s_dev, uspi->s_sbbase + tmp + blockoff,
 211                                          sb->s_blocksize);
 212                         if (tmp == SWAB32(*p)) {
 213                                 UFSD(("EXIT, result %u\n", tmp + blockoff))
 214                                 return result;
 215                         }
 216                         brelse (result);
 217                         goto repeat;
 218                 } else {
 219                         *phys = tmp;
 220                         return NULL;
 221                 }
 222         }
 223
 224         lastblock = ufs_fragstoblks (lastfrag);
 225         lastblockoff = ufs_fragnum (lastfrag);
 226         /*
 227          * We will extend file into new block beyond last allocated block
 228          */
 229         if (lastblock < block) {
 230                 /*
 231                  * We must reallocate last allocated block
 232                  */
 233                 if (lastblockoff) {
 234                         p2 = inode->u.ufs_i.i_u1.i_data + lastblock;
 235                         tmp = ufs_new_fragments (inode, p2, lastfrag,
 236                                 SWAB32(*p2), uspi->s_fpb - lastblockoff, err);
 237                         if (!tmp) {
 238                                 if (lastfrag != inode->u.ufs_i.i_lastfrag)
 239                                         goto repeat;
 240                                 else
 241                                         return NULL;
 242                         }
 243                         lastfrag = inode->u.ufs_i.i_lastfrag;
 244
 245                 }
 246                 goal = SWAB32(inode->u.ufs_i.i_u1.i_data[lastblock]) + uspi->s_fpb;
 247                 tmp = ufs_new_fragments (inode, p, fragment - blockoff,
 248                         goal, required + blockoff, err);
 249         }
 250         /*
 251          * We will extend last allocated block
 252          */
 253         else if (lastblock == block) {
 254                 tmp = ufs_new_fragments (inode, p, fragment - (blockoff - lastblockoff),
 255                         SWAB32(*p), required +  (blockoff - lastblockoff), err);
 256         }
 257         /*
 258          * We will allocate new block before last allocated block
 259          */
 260         else /* (lastblock > block) */ {
 261                 if (lastblock && (tmp = SWAB32(inode->u.ufs_i.i_u1.i_data[lastblock-1])))
 262                         goal = tmp + uspi->s_fpb;
 263                 tmp = ufs_new_fragments (inode, p, fragment - blockoff,
 264                         goal, uspi->s_fpb, err);
 265         }
 266         if (!tmp) {
 267                 if ((!blockoff && SWAB32(*p)) ||
 268                     (blockoff && lastfrag != inode->u.ufs_i.i_lastfrag))
 269                         goto repeat;
 270                 *err = -ENOSPC;
 271                 return NULL;
 272         }
 273
 274         /* The nullification of framgents done in ufs/balloc.c is
 275          * something I don't have the stomache to move into here right
 276          * now. -DaveM
 277          */
 278         if (metadata) {
 279                 result = getblk (inode->i_dev, tmp + blockoff, sb->s_blocksize);
 280         } else {
 281                 *phys = tmp;
 282                 result = NULL;
 283                 *err = 0;
 284                 *new = 1;
 285         }
 286
 287         inode->i_ctime = CURRENT_TIME;
 288         if (IS_SYNC(inode))
 289                 ufs_sync_inode (inode);
 290         mark_inode_dirty(inode);
 291         UFSD(("EXIT, result %u\n", tmp + blockoff))
 292         return result;
 293 }
 294
 295 static struct buffer_head * ufs_block_getfrag (struct inode *inode,
 296         struct buffer_head *bh, unsigned int fragment, unsigned int new_fragment,
 297         unsigned int blocksize, int * err, int metadata, long *phys, int *new)
 298 {
 299         struct super_block * sb;
 300         struct ufs_sb_private_info * uspi;
 301         struct buffer_head * result;
 302         unsigned tmp, goal, block, blockoff;
 303         u32 * p;
 304         unsigned int swab;
 305
 306         sb = inode->i_sb;
 307         swab = sb->u.ufs_sb.s_swab;
 308         uspi = sb->u.ufs_sb.s_uspi;
 309         block = ufs_fragstoblks (fragment);
 310         blockoff = ufs_fragnum (fragment);
 311
 312         UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u\n", inode->i_ino, fragment, new_fragment))
 313
 314         result = NULL;
 315         if (!bh)
 316                 goto out;
 317         if (!buffer_uptodate(bh)) {
 318                 ll_rw_block (READ, 1, &bh);
 319                 wait_on_buffer (bh);
 320                 if (!buffer_uptodate(bh))
 321                         goto out;
 322         }
 323
 324         p = (u32 *) bh->b_data + block;
 325 repeat:
 326         tmp = SWAB32(*p);
 327         if (tmp) {
 328                 if (metadata) {
 329                         result = getblk (bh->b_dev, uspi->s_sbbase + tmp + blockoff,
 330                                          sb->s_blocksize);
 331                         if (tmp == SWAB32(*p))
 332                                 goto out;
 333                         brelse (result);
 334                         goto repeat;
 335                 } else {
 336                         *phys = tmp;
 337                         goto out;
 338                 }
 339         }
 340
 341         if (block && (tmp = SWAB32(((u32*)bh->b_data)[block-1]) + uspi->s_fpb))
 342                 goal = tmp + uspi->s_fpb;
 343         else
 344                 goal = bh->b_blocknr + uspi->s_fpb;
 345         tmp = ufs_new_fragments (inode, p, ufs_blknum(new_fragment), goal, uspi->s_fpb, err);
 346         if (!tmp) {
 347                 if (SWAB32(*p))
 348                         goto repeat;
 349                 goto out;
 350         }
 351
 352         /* The nullification of framgents done in ufs/balloc.c is
 353          * something I don't have the stomache to move into here right
 354          * now. -DaveM
 355          */
 356         if (metadata) {
 357                 result = getblk (bh->b_dev, tmp + blockoff, sb->s_blocksize);
 358         } else {
 359                 *phys = tmp;
 360                 *new = 1;
 361         }
 362
 363         mark_buffer_dirty(bh);
 364         if (IS_SYNC(inode)) {
 365                 ll_rw_block (WRITE, 1, &bh);
 366                 wait_on_buffer (bh);
 367         }
 368         inode->i_ctime = CURRENT_TIME;
 369         mark_inode_dirty(inode);
 370 out:
 371         brelse (bh);
 372         UFSD(("EXIT, result %u\n", tmp + blockoff))
 373         return result;
 374 }
 375
 376 static int ufs_getfrag_block (struct inode *inode, long fragment, struct buffer_head *bh_result, int create)
 377 {
 378         struct super_block * sb;
 379         struct ufs_sb_private_info * uspi;
 380         struct buffer_head * bh;
 381         unsigned int swab;
 382         int ret, err, new;
 383         unsigned long ptr, phys;
 384
 385         sb = inode->i_sb;
 386         uspi = sb->u.ufs_sb.s_uspi;
 387         swab = sb->u.ufs_sb.s_swab;
 388
 389         if (!create) {
 390                 phys = ufs_frag_map(inode, fragment);
 391                 if (phys) {
 392                         bh_result->b_dev = inode->i_dev;
 393                         bh_result->b_blocknr = phys;
 394                         bh_result->b_state |= (1UL << BH_Mapped);
 395                 }
 396                 return 0;
 397         }
 398
 399         err = -EIO;
 400         new = 0;
 401         ret = 0;
 402         bh = NULL;
 403
 404         lock_kernel();
 405
 406         UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
 407         if (fragment < 0)
 408                 goto abort_negative;
 409         if (fragment >
 410             ((UFS_NDADDR + uspi->s_apb + uspi->s_2apb + uspi->s_3apb)
 411              << uspi->s_fpbshift))
 412                 goto abort_too_big;
 413
 414         err = 0;
 415         ptr = fragment;
 416
 417         /*
 418          * ok, these macros clean the logic up a bit and make
 419          * it much more readable:
 420          */
 421 #define GET_INODE_DATABLOCK(x) \
 422                 ufs_inode_getfrag(inode, x, fragment, 1, &err, 0, &phys, &new)
 423 #define GET_INODE_PTR(x) \
 424                 ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, 1, NULL, NULL)
 425 #define GET_INDIRECT_DATABLOCK(x) \
 426                 ufs_block_getfrag(inode, bh, x, fragment, sb->s_blocksize, \
 427                                   &err, 0, &phys, &new);
 428 #define GET_INDIRECT_PTR(x) \
 429                 ufs_block_getfrag(inode, bh, x, fragment, sb->s_blocksize, \
 430                                   &err, 1, NULL, NULL);
 431
 432         if (ptr < UFS_NDIR_FRAGMENT) {
 433                 bh = GET_INODE_DATABLOCK(ptr);
 434                 goto out;
 435         }
 436         ptr -= UFS_NDIR_FRAGMENT;
 437         if (ptr < (1 << (uspi->s_apbshift + uspi->s_fpbshift))) {
 438                 bh = GET_INODE_PTR(UFS_IND_FRAGMENT + (ptr >> uspi->s_apbshift));
 439                 goto get_indirect;
 440         }
 441         ptr -= 1 << (uspi->s_apbshift + uspi->s_fpbshift);
 442         if (ptr < (1 << (uspi->s_2apbshift + uspi->s_fpbshift))) {
 443                 bh = GET_INODE_PTR(UFS_DIND_FRAGMENT + (ptr >> uspi->s_2apbshift));
 444                 goto get_double;
 445         }
 446         ptr -= 1 << (uspi->s_2apbshift + uspi->s_fpbshift);
 447         bh = GET_INODE_PTR(UFS_TIND_FRAGMENT + (ptr >> uspi->s_3apbshift));
 448         bh = GET_INDIRECT_PTR((ptr >> uspi->s_2apbshift) & uspi->s_apbmask);
 449 get_double:
 450         bh = GET_INDIRECT_PTR((ptr >> uspi->s_apbshift) & uspi->s_apbmask);
 451 get_indirect:
 452         bh = GET_INDIRECT_DATABLOCK(ptr & uspi->s_apbmask);
 453
 454 #undef GET_INODE_DATABLOCK
 455 #undef GET_INODE_PTR
 456 #undef GET_INDIRECT_DATABLOCK
 457 #undef GET_INDIRECT_PTR
 458
 459 out:
 460         if (err)
 461                 goto abort;
 462         bh_result->b_dev = inode->i_dev;
 463         bh_result->b_blocknr = phys;
 464         bh_result->b_state |= (1UL << BH_Mapped);
 465         if (new)
 466                 bh_result->b_state |= (1UL << BH_New);
 467 abort:
 468         unlock_kernel();
 469         return err;
 470
 471 abort_negative:
 472         ufs_warning(sb, "ufs_get_block", "block < 0");
 473         goto abort;
 474
 475 abort_too_big:
 476         ufs_warning(sb, "ufs_get_block", "block > big");
 477         goto abort;
 478 }
 479
 480 struct buffer_head *ufs_getfrag(struct inode *inode, unsigned int fragment,
 481                                 int create, int *err)
 482 {
 483         struct buffer_head dummy;
 484         int error;
 485
 486         dummy.b_state = 0;
 487         dummy.b_blocknr = -1000;
 488         error = ufs_getfrag_block(inode, fragment, &dummy, create);
 489         *err = error;
 490         if (!error && buffer_mapped(&dummy)) {
 491                 struct buffer_head *bh;
 492                 bh = getblk(dummy.b_dev, dummy.b_blocknr, inode->i_sb->s_blocksize);
 493                 if (buffer_new(&dummy)) {
 494                         memset(bh->b_data, 0, inode->i_sb->s_blocksize);
 495                         mark_buffer_uptodate(bh, 1);
 496                         mark_buffer_dirty(bh);
 497                 }
 498                 return bh;
 499         }
 500         return NULL;
 501 }
 502
 503 struct buffer_head * ufs_bread (struct inode * inode, unsigned fragment,
 504         int create, int * err)
 505 {
 506         struct buffer_head * bh;
 507
 508         UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
 509         bh = ufs_getfrag (inode, fragment, create, err);
 510         if (!bh || buffer_uptodate(bh))
 511                 return bh;
 512         ll_rw_block (READ, 1, &bh);
 513         wait_on_buffer (bh);
 514         if (buffer_uptodate(bh))
 515                 return bh;
 516         brelse (bh);
 517         *err = -EIO;
 518         return NULL;
 519 }
 520
 521 static int ufs_writepage(struct page *page)
 522 {
 523         return block_write_full_page(page,ufs_getfrag_block);
 524 }
 525 static int ufs_readpage(struct file *file, struct page *page)
 526 {
 527         return block_read_full_page(page,ufs_getfrag_block);
 528 }
 529 static int ufs_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
 530 {
 531         return block_prepare_write(page,from,to,ufs_getfrag_block);
 532 }
 533 static int ufs_bmap(struct address_space *mapping, long block)
 534 {
 535         return generic_block_bmap(mapping,block,ufs_getfrag_block);
 536 }
 537 struct address_space_operations ufs_aops = {
 538         readpage: ufs_readpage,
 539         writepage: ufs_writepage,
 540         sync_page: block_sync_page,
 541         prepare_write: ufs_prepare_write,
 542         commit_write: generic_commit_write,
 543         bmap: ufs_bmap
 544 };
 545
 546 void ufs_read_inode (struct inode * inode)
 547 {
 548         struct super_block * sb;
 549         struct ufs_sb_private_info * uspi;
 550         struct ufs_inode * ufs_inode;
 551         struct buffer_head * bh;
 552         unsigned i;
 553         unsigned flags, swab;
 554
 555         UFSD(("ENTER, ino %lu\n", inode->i_ino))
 556
 557         sb = inode->i_sb;
 558         uspi = sb->u.ufs_sb.s_uspi;
 559         flags = sb->u.ufs_sb.s_flags;
 560         swab = sb->u.ufs_sb.s_swab;
 561
 562         if (inode->i_ino < UFS_ROOTINO ||
 563             inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
 564                 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
 565                 return;
 566         }
 567
 568         bh = bread (sb->s_dev, uspi->s_sbbase + ufs_inotofsba(inode->i_ino), sb->s_blocksize);
 569         if (!bh) {
 570                 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
 571                 return;
 572         }
 573         ufs_inode = (struct ufs_inode *) (bh->b_data + sizeof(struct ufs_inode) * ufs_inotofsbo(inode->i_ino));
 574
 575         /*
 576          * Copy data to the in-core inode.
 577          */
 578         inode->i_mode = SWAB16(ufs_inode->ui_mode);
 579         inode->i_nlink = SWAB16(ufs_inode->ui_nlink);
 580         if (inode->i_nlink == 0)
 581                 ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
 582
 583         /*
 584          * Linux now has 32-bit uid and gid, so we can support EFT.
 585          */
 586         inode->i_uid = ufs_get_inode_uid(ufs_inode);
 587         inode->i_gid = ufs_get_inode_gid(ufs_inode);
 588
 589         /*
 590          * Linux i_size can be 32 on some architectures. We will mark
 591          * big files as read only and let user access first 32 bits.
 592          */
 593         inode->u.ufs_i.i_size = SWAB64(ufs_inode->ui_size);
 594         inode->i_size = (off_t) inode->u.ufs_i.i_size;
 595         if (sizeof(off_t) == 4 && (inode->u.ufs_i.i_size >> 32))
 596                 inode->i_size = (__u32)-1;
 597
 598         inode->i_atime = SWAB32(ufs_inode->ui_atime.tv_sec);
 599         inode->i_ctime = SWAB32(ufs_inode->ui_ctime.tv_sec);
 600         inode->i_mtime = SWAB32(ufs_inode->ui_mtime.tv_sec);
 601         inode->i_blocks = SWAB32(ufs_inode->ui_blocks);
 602         inode->i_blksize = PAGE_SIZE;   /* This is the optimal IO size (for stat) */
 603         inode->i_version = ++event;
 604
 605         inode->u.ufs_i.i_flags = SWAB32(ufs_inode->ui_flags);
 606         inode->u.ufs_i.i_gen = SWAB32(ufs_inode->ui_gen);
 607         inode->u.ufs_i.i_shadow = SWAB32(ufs_inode->ui_u3.ui_sun.ui_shadow);
 608         inode->u.ufs_i.i_oeftflag = SWAB32(ufs_inode->ui_u3.ui_sun.ui_oeftflag);
 609         inode->u.ufs_i.i_lastfrag = (inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;
 610
 611         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 612                 ;
 613         else if (inode->i_blocks) {
 614                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
 615                         inode->u.ufs_i.i_u1.i_data[i] = ufs_inode->ui_u2.ui_addr.ui_db[i];
 616         }
 617         else {
 618                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
 619                         inode->u.ufs_i.i_u1.i_symlink[i] = ufs_inode->ui_u2.ui_symlink[i];
 620         }
 621
 622
 623         if (S_ISREG(inode->i_mode)) {
 624                 inode->i_op = &ufs_file_inode_operations;
 625                 inode->i_fop = &ufs_file_operations;
 626                 inode->i_mapping->a_ops = &ufs_aops;
 627         } else if (S_ISDIR(inode->i_mode)) {
 628                 inode->i_op = &ufs_dir_inode_operations;
 629                 inode->i_fop = &ufs_dir_operations;
 630         } else if (S_ISLNK(inode->i_mode)) {
 631                 if (!inode->i_blocks)
 632                         inode->i_op = &ufs_fast_symlink_inode_operations;
 633                 else {
 634                         inode->i_op = &page_symlink_inode_operations;
 635                         inode->i_mapping->a_ops = &ufs_aops;
 636                 }
 637         } else
 638                 init_special_inode(inode, inode->i_mode,
 639                                    SWAB32(ufs_inode->ui_u2.ui_addr.ui_db[0]));
 640
 641         brelse (bh);
 642
 643 #ifdef UFS_INODE_DEBUG_MORE
 644         ufs_print_inode (inode);
 645 #endif
 646         UFSD(("EXIT\n"))
 647 }
 648
 649 static int ufs_update_inode(struct inode * inode, int do_sync)
 650 {
 651         struct super_block * sb;
 652         struct ufs_sb_private_info * uspi;
 653         struct buffer_head * bh;
 654         struct ufs_inode * ufs_inode;
 655         unsigned i;
 656         unsigned flags, swab;
 657
 658         UFSD(("ENTER, ino %lu\n", inode->i_ino))
 659
 660         sb = inode->i_sb;
 661         uspi = sb->u.ufs_sb.s_uspi;
 662         flags = sb->u.ufs_sb.s_flags;
 663         swab = sb->u.ufs_sb.s_swab;
 664
 665         if (inode->i_ino < UFS_ROOTINO ||
 666             inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
 667                 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
 668                 return -1;
 669         }
 670
 671         bh = bread (sb->s_dev, ufs_inotofsba(inode->i_ino), sb->s_blocksize);
 672         if (!bh) {
 673                 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
 674                 return -1;
 675         }
 676         ufs_inode = (struct ufs_inode *) (bh->b_data + ufs_inotofsbo(inode->i_ino) * sizeof(struct ufs_inode));
 677
 678         ufs_inode->ui_mode = SWAB16(inode->i_mode);
 679         ufs_inode->ui_nlink = SWAB16(inode->i_nlink);
 680
 681         ufs_set_inode_uid (ufs_inode, inode->i_uid);
 682         ufs_set_inode_gid (ufs_inode, inode->i_gid);
 683
 684         ufs_inode->ui_size = SWAB64((u64)inode->i_size);
 685         ufs_inode->ui_atime.tv_sec = SWAB32(inode->i_atime);
 686         ufs_inode->ui_atime.tv_usec = SWAB32(0);
 687         ufs_inode->ui_ctime.tv_sec = SWAB32(inode->i_ctime);
 688         ufs_inode->ui_ctime.tv_usec = SWAB32(0);
 689         ufs_inode->ui_mtime.tv_sec = SWAB32(inode->i_mtime);
 690         ufs_inode->ui_mtime.tv_usec = SWAB32(0);
 691         ufs_inode->ui_blocks = SWAB32(inode->i_blocks);
 692         ufs_inode->ui_flags = SWAB32(inode->u.ufs_i.i_flags);
 693         ufs_inode->ui_gen = SWAB32(inode->u.ufs_i.i_gen);
 694
 695         if ((flags & UFS_UID_MASK) == UFS_UID_EFT) {
 696                 ufs_inode->ui_u3.ui_sun.ui_shadow = SWAB32(inode->u.ufs_i.i_shadow);
 697                 ufs_inode->ui_u3.ui_sun.ui_oeftflag = SWAB32(inode->u.ufs_i.i_oeftflag);
 698         }
 699
 700         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 701                 ufs_inode->ui_u2.ui_addr.ui_db[0] = SWAB32(kdev_t_to_nr(inode->i_rdev));
 702         else if (inode->i_blocks) {
 703                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
 704                         ufs_inode->ui_u2.ui_addr.ui_db[i] = inode->u.ufs_i.i_u1.i_data[i];
 705         }
 706         else {
 707                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
 708                         ufs_inode->ui_u2.ui_symlink[i] = inode->u.ufs_i.i_u1.i_symlink[i];
 709         }
 710
 711         if (!inode->i_nlink)
 712                 memset (ufs_inode, 0, sizeof(struct ufs_inode));
 713
 714         mark_buffer_dirty(bh);
 715         if (do_sync) {
 716                 ll_rw_block (WRITE, 1, &bh);
 717                 wait_on_buffer (bh);
 718         }
 719         brelse (bh);
 720
 721         UFSD(("EXIT\n"))
 722         return 0;
 723 }
 724
 725 void ufs_write_inode (struct inode * inode, int wait)
 726 {
 727         lock_kernel();
 728         ufs_update_inode (inode, wait);
 729         unlock_kernel();
 730 }
 731
 732 int ufs_sync_inode (struct inode *inode)
 733 {
 734         return ufs_update_inode (inode, 1);
 735 }
 736
 737 void ufs_delete_inode (struct inode * inode)
 738 {
 739         /*inode->u.ufs_i.i_dtime = CURRENT_TIME;*/
 740         lock_kernel();
 741         mark_inode_dirty(inode);
 742         ufs_update_inode(inode, IS_SYNC(inode));
 743         inode->i_size = 0;
 744         if (inode->i_blocks)
 745                 ufs_truncate (inode);
 746         ufs_free_inode (inode);
 747         unlock_kernel();
 748 }