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
  40 #include "swab.h"
  41 #include "util.h"
  42
  43 #undef UFS_INODE_DEBUG
  44 #undef UFS_INODE_DEBUG_MORE
  45
  46 #ifdef UFS_INODE_DEBUG
  47 #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
  48 #else
  49 #define UFSD(x)
  50 #endif
  51
  52 #ifdef UFS_INODE_DEBUG_MORE
  53 static void ufs_print_inode(struct inode * inode)
  54 {
  55         unsigned swab = inode->i_sb->u.ufs_sb.s_swab;
  56         printk("ino %lu  mode 0%6.6o  nlink %d  uid %d  uid32 %u"
  57                "  gid %d  gid32 %u  size %lu blocks %lu\n",
  58                inode->i_ino, inode->i_mode, inode->i_nlink,
  59                inode->i_uid, inode->u.ufs_i.i_uid, inode->i_gid,
  60                inode->u.ufs_i.i_gid, inode->i_size, inode->i_blocks);
  61         printk("  db <%u %u %u %u %u %u %u %u %u %u %u %u>\n",
  62                 SWAB32(inode->u.ufs_i.i_u1.i_data[0]),
  63                 SWAB32(inode->u.ufs_i.i_u1.i_data[1]),
  64                 SWAB32(inode->u.ufs_i.i_u1.i_data[2]),
  65                 SWAB32(inode->u.ufs_i.i_u1.i_data[3]),
  66                 SWAB32(inode->u.ufs_i.i_u1.i_data[4]),
  67                 SWAB32(inode->u.ufs_i.i_u1.i_data[5]),
  68                 SWAB32(inode->u.ufs_i.i_u1.i_data[6]),
  69                 SWAB32(inode->u.ufs_i.i_u1.i_data[7]),
  70                 SWAB32(inode->u.ufs_i.i_u1.i_data[8]),
  71                 SWAB32(inode->u.ufs_i.i_u1.i_data[9]),
  72                 SWAB32(inode->u.ufs_i.i_u1.i_data[10]),
  73                 SWAB32(inode->u.ufs_i.i_u1.i_data[11]));
  74         printk("  gen %u ib <%u %u %u>\n",
  75                 inode->u.ufs_i.i_gen,
  76                 SWAB32(inode->u.ufs_i.i_u1.i_data[UFS_IND_BLOCK]),
  77                 SWAB32(inode->u.ufs_i.i_u1.i_data[UFS_DIND_BLOCK]),
  78                 SWAB32(inode->u.ufs_i.i_u1.i_data[UFS_TIND_BLOCK]));
  79 }
  80 #endif
  81
  82 #define ufs_inode_bmap(inode, nr) \
  83         (SWAB32((inode)->u.ufs_i.i_u1.i_data[(nr) >> uspi->s_fpbshift]) + ((nr) & uspi->s_fpbmask))
  84
  85 static inline unsigned ufs_block_bmap (struct buffer_head * bh, unsigned nr,
  86         struct ufs_sb_private_info * uspi, unsigned swab)
  87 {
  88         unsigned tmp;
  89
  90         UFSD(("ENTER, nr %u\n", nr))
  91         if (!bh)
  92                 return 0;
  93         tmp = SWAB32(((u32 *) bh->b_data)[nr >> uspi->s_fpbshift]) + (nr & uspi->s_fpbmask);
  94         brelse (bh);
  95         UFSD(("EXIT, result %u\n", tmp))
  96         return tmp;
  97 }
  98
  99 int ufs_bmap (struct inode * inode, int fragment)
 100 {
 101         struct super_block * sb;
 102         struct ufs_sb_private_info * uspi;
 103         unsigned tmp;
 104         unsigned swab;
 105
 106         sb = inode->i_sb;
 107         uspi = sb->u.ufs_sb.s_uspi;
 108         swab = sb->u.ufs_sb.s_swab;
 109
 110         UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
 111
 112         if (fragment >= ((UFS_NDADDR + uspi->s_apb + uspi->s_2apb + uspi->s_3apb) << uspi->s_fpbshift)) {
 113                 ufs_warning (sb, "ufs_bmap", "block > big");
 114                 return 0;
 115         }
 116
 117         /*
 118          * direct fragment
 119          */
 120         if (fragment < UFS_NDIR_FRAGMENT)
 121                 return (uspi->s_sbbase + ufs_inode_bmap (inode, fragment));
 122
 123         /*
 124          * indirect fragment
 125          */
 126         fragment -= UFS_NDIR_FRAGMENT;
 127         if (fragment < (1 << (uspi->s_apbshift + uspi->s_fpbshift))) {
 128                 tmp = ufs_inode_bmap (inode,
 129                         UFS_IND_FRAGMENT + (fragment >> uspi->s_apbshift));
 130                 if (!tmp)
 131                         return 0;
 132                 return (uspi->s_sbbase +
 133                         ufs_block_bmap (bread (sb->s_dev, uspi->s_sbbase + tmp, sb->s_blocksize),
 134                         fragment & uspi->s_apbmask, uspi, swab));
 135         }
 136
 137         /*
 138          * dindirect fragment
 139          */
 140         fragment -= 1 << (uspi->s_apbshift + uspi->s_fpbshift);
 141         if (fragment < (1 << (uspi->s_2apbshift + uspi->s_fpbshift))) {
 142                 tmp = ufs_inode_bmap (inode,
 143                         UFS_DIND_FRAGMENT + (fragment >> uspi->s_2apbshift));
 144                 if (!tmp)
 145                         return 0;
 146                 tmp = ufs_block_bmap (bread (sb->s_dev, uspi->s_sbbase + tmp, sb->s_blocksize),
 147                         (fragment >> uspi->s_apbshift) & uspi->s_apbmask, uspi, swab);
 148                 if (!tmp)
 149                         return 0;
 150                 return (uspi->s_sbbase +
 151                         ufs_block_bmap (bread (sb->s_dev, uspi->s_sbbase + tmp, sb->s_blocksize),
 152                         fragment & uspi->s_apbmask, uspi, swab));
 153         }
 154
 155         /*
 156          * tindirect fragment
 157          */
 158         fragment -= 1 << (uspi->s_2apbshift + uspi->s_fpbshift);
 159         tmp = ufs_inode_bmap (inode,
 160                 UFS_TIND_FRAGMENT + (fragment >> uspi->s_3apbshift));
 161         if (!tmp)
 162                 return 0;
 163         tmp = ufs_block_bmap (bread (sb->s_dev, uspi->s_sbbase + tmp, sb->s_blocksize),
 164                 (fragment >> uspi->s_2apbshift) & uspi->s_apbmask, uspi, swab);
 165         if (!tmp)
 166                 return 0;
 167         tmp = ufs_block_bmap (bread (sb->s_dev, uspi->s_sbbase + tmp, sb->s_blocksize),
 168                 (fragment >> uspi->s_apbshift) & uspi->s_apbmask, uspi, swab);
 169         if (!tmp)
 170                 return 0;
 171         return (uspi->s_sbbase +
 172                 ufs_block_bmap (bread (sb->s_dev, uspi->s_sbbase + tmp, sb->s_blocksize),
 173                 fragment & uspi->s_apbmask, uspi, swab));
 174 }
 175
 176 static struct buffer_head * ufs_inode_getfrag (struct inode * inode,
 177         unsigned fragment, unsigned new_fragment, int create,
 178         unsigned required, int * err )
 179 {
 180         struct super_block * sb;
 181         struct ufs_sb_private_info * uspi;
 182         struct buffer_head * result;
 183         unsigned long limit;
 184         unsigned block, blockoff, lastfrag, lastblock, lastblockoff;
 185         unsigned tmp, goal;
 186         u32 * p, * p2;
 187         unsigned swab;
 188
 189         UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u, required %u\n",
 190                 inode->i_ino, fragment, new_fragment, required))
 191
 192         sb = inode->i_sb;
 193         swab = sb->u.ufs_sb.s_swab;
 194         uspi = sb->u.ufs_sb.s_uspi;
 195         block = ufs_fragstoblks (fragment);
 196         blockoff = ufs_fragnum (fragment);
 197         p = inode->u.ufs_i.i_u1.i_data + block;
 198         goal = 0;
 199
 200 repeat:
 201         tmp = SWAB32(*p);
 202         lastfrag = inode->u.ufs_i.i_lastfrag;
 203         if (tmp && fragment < lastfrag) {
 204                 result = getblk (sb->s_dev, uspi->s_sbbase + tmp + blockoff, sb->s_blocksize);
 205                 if (tmp == SWAB32(*p)) {
 206                         UFSD(("EXIT, result %u\n", tmp + blockoff))
 207                         return result;
 208                 }
 209                 brelse (result);
 210                 goto repeat;
 211         }
 212         *err = -EFBIG;
 213         if (!create)
 214                 return NULL;
 215         limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
 216         if (limit < RLIM_INFINITY) {
 217                 limit >>= sb->s_blocksize_bits;
 218                 if (new_fragment >= limit) {
 219                         send_sig(SIGXFSZ, current, 0);
 220                         return NULL;
 221                 }
 222         }
 223         lastblock = ufs_fragstoblks (lastfrag);
 224         lastblockoff = ufs_fragnum (lastfrag);
 225         /*
 226          * We will extend file into new block beyond last allocated block
 227          */
 228         if (lastblock < block) {
 229                 /*
 230                  * We must reallocate last allocated block
 231                  */
 232                 if (lastblockoff) {
 233                         p2 = inode->u.ufs_i.i_u1.i_data + lastblock;
 234                         tmp = ufs_new_fragments (inode, p2, lastfrag,
 235                                 SWAB32(*p2), uspi->s_fpb - lastblockoff, err);
 236                         if (!tmp) {
 237                                 if (lastfrag != inode->u.ufs_i.i_lastfrag)
 238                                         goto repeat;
 239                                 else
 240                                         return NULL;
 241                         }
 242                         lastfrag = inode->u.ufs_i.i_lastfrag;
 243
 244                 }
 245                 goal = SWAB32(inode->u.ufs_i.i_u1.i_data[lastblock]) + uspi->s_fpb;
 246                 tmp = ufs_new_fragments (inode, p, fragment - blockoff,
 247                         goal, required + blockoff, err);
 248         }
 249         /*
 250          * We will extend last allocated block
 251          */
 252         else if (lastblock == block) {
 253                 tmp = ufs_new_fragments (inode, p, fragment - (blockoff - lastblockoff),
 254                         SWAB32(*p), required +  (blockoff - lastblockoff), err);
 255         }
 256         /*
 257          * We will allocate new block before last allocated block
 258          */
 259         else /* (lastblock > block) */ {
 260                 if (lastblock && (tmp = SWAB32(inode->u.ufs_i.i_u1.i_data[lastblock-1])))
 261                         goal = tmp + uspi->s_fpb;
 262                 tmp = ufs_new_fragments (inode, p, fragment - blockoff,
 263                         goal, uspi->s_fpb, err);
 264         }
 265         if (!tmp) {
 266                 if ((!blockoff && SWAB32(*p)) ||
 267                 (blockoff && lastfrag != inode->u.ufs_i.i_lastfrag))
 268                         goto repeat;
 269                 else
 270                         return NULL;
 271         }
 272         result = getblk (inode->i_dev, tmp + blockoff, sb->s_blocksize);
 273         inode->i_ctime = CURRENT_TIME;
 274         if (IS_SYNC(inode))
 275                 ufs_sync_inode (inode);
 276         mark_inode_dirty(inode);
 277         UFSD(("EXIT, result %u\n", tmp + blockoff))
 278         return result;
 279 }
 280
 281 static struct buffer_head * ufs_block_getfrag (struct inode * inode,
 282         struct buffer_head * bh, unsigned fragment, unsigned new_fragment,
 283         int create, unsigned blocksize, int * err)
 284 {
 285         struct super_block * sb;
 286         struct ufs_sb_private_info * uspi;
 287         struct buffer_head * result;
 288         unsigned tmp, goal, block, blockoff;
 289         u32 * p;
 290         unsigned swab;
 291
 292         sb = inode->i_sb;
 293         swab = sb->u.ufs_sb.s_swab;
 294         uspi = sb->u.ufs_sb.s_uspi;
 295         block = ufs_fragstoblks (fragment);
 296         blockoff = ufs_fragnum (fragment);
 297
 298         UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u\n", inode->i_ino, fragment, new_fragment))
 299
 300         if (!bh)
 301                 return NULL;
 302         if (!buffer_uptodate(bh)) {
 303                 ll_rw_block (READ, 1, &bh);
 304                 wait_on_buffer (bh);
 305                 if (!buffer_uptodate(bh)) {
 306                         brelse (bh);
 307                         return NULL;
 308                 }
 309         }
 310
 311         p = (u32 *) bh->b_data + block;
 312 repeat:
 313         tmp = SWAB32(*p);
 314         if (tmp) {
 315                 result = getblk (bh->b_dev, uspi->s_sbbase + tmp + blockoff, sb->s_blocksize);
 316                 if (tmp == SWAB32(*p)) {
 317                         brelse (bh);
 318                         UFSD(("EXIT, result %u\n", tmp + blockoff))
 319                         return result;
 320                 }
 321                 brelse (result);
 322                 goto repeat;
 323         }
 324         if (!create || new_fragment >= (current->rlim[RLIMIT_FSIZE].rlim_cur >> sb->s_blocksize)) {
 325                 brelse (bh);
 326                 *err = -EFBIG;
 327                 return NULL;
 328         }
 329         if (block && (tmp = SWAB32(((u32*)bh->b_data)[block-1]) + uspi->s_fpb))
 330                 goal = tmp + uspi->s_fpb;
 331         else
 332                 goal = bh->b_blocknr + uspi->s_fpb;
 333         tmp = ufs_new_fragments (inode, p, ufs_blknum(new_fragment), goal, uspi->s_fpb, err);
 334         if (!tmp) {
 335                 if (SWAB32(*p)) {
 336                         goto repeat;
 337                 }
 338                 else {
 339                         return NULL;
 340                 }
 341         }
 342         result = getblk (bh->b_dev, tmp + blockoff, sb->s_blocksize);
 343         mark_buffer_dirty(bh, 1);
 344         if (IS_SYNC(inode)) {
 345                 ll_rw_block (WRITE, 1, &bh);
 346                 wait_on_buffer (bh);
 347         }
 348         inode->i_ctime = CURRENT_TIME;
 349         mark_inode_dirty(inode);
 350         brelse (bh);
 351         UFSD(("EXIT, result %u\n", tmp + blockoff))
 352         return result;
 353 }
 354
 355 struct buffer_head * ufs_getfrag (struct inode * inode, unsigned fragment,
 356         int create, int * err)
 357 {
 358         struct super_block * sb;
 359         struct ufs_sb_private_info * uspi;
 360         struct buffer_head * bh;
 361         unsigned f;
 362         unsigned swab;
 363
 364         sb = inode->i_sb;
 365         uspi = sb->u.ufs_sb.s_uspi;
 366         swab = sb->u.ufs_sb.s_swab;
 367         *err = -EIO;
 368
 369         UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
 370         if (fragment > ((UFS_NDADDR + uspi->s_apb + uspi->s_2apb + uspi->s_3apb) << uspi->s_fpbshift)) {
 371                 ufs_warning (sb, "ufs_getblk", "block > big");
 372                 return NULL;
 373         }
 374
 375         *err = -ENOSPC;
 376         f = fragment;
 377
 378         /*
 379          * Direct fragment
 380          */
 381         if (fragment < UFS_NDIR_FRAGMENT)
 382                 return ufs_inode_getfrag (inode, fragment, fragment, create, 1, err);
 383         /*
 384          * Indirect fragment
 385          */
 386         fragment -= UFS_NDIR_FRAGMENT;
 387         if (fragment < (1 << (uspi->s_apbshift + uspi->s_fpbshift))) {
 388                 bh = ufs_inode_getfrag (inode,
 389                         UFS_IND_FRAGMENT + (fragment >> uspi->s_apbshift),
 390                         f, create, uspi->s_fpb, err);
 391                 return ufs_block_getfrag (inode, bh,
 392                         fragment & uspi->s_apbmask,
 393                         f, create, sb->s_blocksize, err);
 394         }
 395         /*
 396          * Dindirect fragment
 397          */
 398         fragment -= 1 << (uspi->s_apbshift + uspi->s_fpbshift);
 399         if ( fragment < (1 << (uspi->s_2apbshift + uspi->s_fpbshift))) {
 400                 bh = ufs_inode_getfrag (inode,
 401                         UFS_DIND_FRAGMENT + (fragment >> uspi->s_2apbshift),
 402                         f, create, uspi->s_fpb, err);
 403                 bh = ufs_block_getfrag (inode, bh,
 404                         (fragment >> uspi->s_apbshift) & uspi->s_apbmask,
 405                         f, create, sb->s_blocksize, err);
 406                 return ufs_block_getfrag (inode, bh,
 407                         fragment & uspi->s_apbmask,
 408                         f, create, sb->s_blocksize, err);
 409         }
 410         /*
 411          * Tindirect fragment
 412          */
 413         fragment -= 1 << (uspi->s_2apbshift + uspi->s_fpbshift);
 414         bh = ufs_inode_getfrag (inode,
 415                 UFS_TIND_FRAGMENT + (fragment >> uspi->s_3apbshift),
 416                 f, create, uspi->s_fpb, err);
 417         bh = ufs_block_getfrag (inode, bh,
 418                 (fragment >> uspi->s_2apbshift) & uspi->s_apbmask,
 419                 f, create, sb->s_blocksize, err);
 420         bh = ufs_block_getfrag (inode, bh,
 421                 (fragment >> uspi->s_apbshift) & uspi->s_apbmask,
 422                 f, create, sb->s_blocksize, err);
 423         return ufs_block_getfrag (inode, bh,
 424                 fragment & uspi->s_apbmask,
 425                 f, create, sb->s_blocksize, err);
 426 }
 427
 428
 429
 430 struct buffer_head * ufs_bread (struct inode * inode, unsigned fragment,
 431         int create, int * err)
 432 {
 433         struct buffer_head * bh;
 434
 435         UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
 436         bh = ufs_getfrag (inode, fragment, create, err);
 437         if (!bh || buffer_uptodate(bh))
 438                 return bh;
 439         ll_rw_block (READ, 1, &bh);
 440         wait_on_buffer (bh);
 441         if (buffer_uptodate(bh))
 442                 return bh;
 443         brelse (bh);
 444         *err = -EIO;
 445         return NULL;
 446 }
 447
 448 void ufs_read_inode (struct inode * inode)
 449 {
 450         struct super_block * sb;
 451         struct ufs_sb_private_info * uspi;
 452         struct ufs_inode * ufs_inode;
 453         struct buffer_head * bh;
 454         unsigned i;
 455         unsigned flags, swab;
 456
 457         UFSD(("ENTER, ino %lu\n", inode->i_ino))
 458
 459         sb = inode->i_sb;
 460         uspi = sb->u.ufs_sb.s_uspi;
 461         flags = sb->u.ufs_sb.s_flags;
 462         swab = sb->u.ufs_sb.s_swab;
 463
 464         if (inode->i_ino < UFS_ROOTINO ||
 465             inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
 466                 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
 467                 return;
 468         }
 469
 470         bh = bread (sb->s_dev, uspi->s_sbbase + ufs_inotofsba(inode->i_ino), sb->s_blocksize);
 471         if (!bh) {
 472                 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
 473                 return;
 474         }
 475         ufs_inode = (struct ufs_inode *) (bh->b_data + sizeof(struct ufs_inode) * ufs_inotofsbo(inode->i_ino));
 476
 477         /*
 478          * Copy data to the in-core inode.
 479          */
 480         inode->i_mode = SWAB16(ufs_inode->ui_mode);
 481         inode->i_nlink = SWAB16(ufs_inode->ui_nlink);
 482         if (inode->i_nlink == 0)
 483                 ufs_error (sb, "ufs_read_inode", "inode %lu has zero nlink\n", inode->i_ino);
 484
 485         /*
 486          * Linux has only 16-bit uid and gid, so we can't support EFT.
 487          * Files are dynamically chown()ed to root.
 488          */
 489         inode->i_uid = inode->u.ufs_i.i_uid = ufs_get_inode_uid(ufs_inode);
 490         inode->i_gid = inode->u.ufs_i.i_gid = ufs_get_inode_gid(ufs_inode);
 491         if (inode->u.ufs_i.i_uid >= UFS_USEEFT) {
 492                 inode->i_uid = 0;
 493         }
 494         if (inode->u.ufs_i.i_gid >= UFS_USEEFT) {
 495                 inode->i_gid = 0;
 496         }
 497
 498         /*
 499          * Linux i_size can be 32 on some architectures. We will mark
 500          * big files as read only and let user access first 32 bits.
 501          */
 502         inode->u.ufs_i.i_size = SWAB64(ufs_inode->ui_size);
 503         inode->i_size = (off_t) inode->u.ufs_i.i_size;
 504         if (sizeof(off_t) == 4 && (inode->u.ufs_i.i_size >> 32))
 505                 inode->i_size = (__u32)-1;
 506
 507         inode->i_atime = SWAB32(ufs_inode->ui_atime.tv_sec);
 508         inode->i_ctime = SWAB32(ufs_inode->ui_ctime.tv_sec);
 509         inode->i_mtime = SWAB32(ufs_inode->ui_mtime.tv_sec);
 510         inode->i_blocks = SWAB32(ufs_inode->ui_blocks);
 511         inode->i_blksize = PAGE_SIZE;   /* This is the optimal IO size (for stat) */
 512         inode->i_version = ++event;
 513
 514         inode->u.ufs_i.i_flags = SWAB32(ufs_inode->ui_flags);
 515         inode->u.ufs_i.i_gen = SWAB32(ufs_inode->ui_gen);
 516         inode->u.ufs_i.i_shadow = SWAB32(ufs_inode->ui_u3.ui_sun.ui_shadow);
 517         inode->u.ufs_i.i_oeftflag = SWAB32(ufs_inode->ui_u3.ui_sun.ui_oeftflag);
 518         inode->u.ufs_i.i_lastfrag = howmany (inode->i_size, uspi->s_fsize);
 519
 520         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 521                 inode->i_rdev = to_kdev_t(SWAB32(ufs_inode->ui_u2.ui_addr.ui_db[0]));
 522         else if (inode->i_blocks) {
 523                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
 524                         inode->u.ufs_i.i_u1.i_data[i] = ufs_inode->ui_u2.ui_addr.ui_db[i];
 525         }
 526         else {
 527                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
 528                         inode->u.ufs_i.i_u1.i_symlink[i] = ufs_inode->ui_u2.ui_symlink[i];
 529         }
 530
 531         brelse (bh);
 532
 533         inode->i_op = NULL;
 534
 535         if (S_ISREG(inode->i_mode))
 536                 inode->i_op = &ufs_file_inode_operations;
 537         else if (S_ISDIR(inode->i_mode))
 538                 inode->i_op = &ufs_dir_inode_operations;
 539         else if (S_ISLNK(inode->i_mode))
 540                 inode->i_op = &ufs_symlink_inode_operations;
 541         else if (S_ISCHR(inode->i_mode))
 542                 inode->i_op = &chrdev_inode_operations;
 543         else if (S_ISBLK(inode->i_mode))
 544                 inode->i_op = &blkdev_inode_operations;
 545         else if (S_ISFIFO(inode->i_mode))
 546                 init_fifo(inode);
 547
 548 #ifdef UFS_INODE_DEBUG_MORE
 549         ufs_print_inode (inode);
 550 #endif
 551         UFSD(("EXIT\n"))
 552 }
 553
 554 static int ufs_update_inode(struct inode * inode, int do_sync)
 555 {
 556         struct super_block * sb;
 557         struct ufs_sb_private_info * uspi;
 558         struct buffer_head * bh;
 559         struct ufs_inode * ufs_inode;
 560         unsigned i;
 561         unsigned flags, swab;
 562
 563         UFSD(("ENTER, ino %lu\n", inode->i_ino))
 564
 565         sb = inode->i_sb;
 566         uspi = sb->u.ufs_sb.s_uspi;
 567         flags = sb->u.ufs_sb.s_flags;
 568         swab = sb->u.ufs_sb.s_swab;
 569
 570         if (inode->i_ino < UFS_ROOTINO ||
 571             inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
 572                 ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
 573                 return -1;
 574         }
 575
 576         bh = bread (sb->s_dev, ufs_inotofsba(inode->i_ino), sb->s_blocksize);
 577         if (!bh) {
 578                 ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
 579                 return -1;
 580         }
 581         ufs_inode = (struct ufs_inode *) (bh->b_data + ufs_inotofsbo(inode->i_ino) * sizeof(struct ufs_inode));
 582
 583         ufs_inode->ui_mode = SWAB16(inode->i_mode);
 584         ufs_inode->ui_nlink = SWAB16(inode->i_nlink);
 585
 586         if (inode->i_uid == 0 && inode->u.ufs_i.i_uid >= UFS_USEEFT)
 587                 ufs_set_inode_uid (ufs_inode, inode->u.ufs_i.i_uid);
 588         else
 589                 ufs_set_inode_uid (ufs_inode, inode->i_uid);
 590
 591         if (inode->i_gid == 0 && inode->u.ufs_i.i_gid >= UFS_USEEFT)
 592                 ufs_set_inode_gid (ufs_inode, inode->u.ufs_i.i_gid);
 593         else
 594                 ufs_set_inode_gid (ufs_inode, inode->i_gid);
 595
 596         ufs_inode->ui_size = SWAB64((u64)inode->i_size);
 597         ufs_inode->ui_atime.tv_sec = SWAB32(inode->i_atime);
 598         ufs_inode->ui_atime.tv_usec = SWAB32(0);
 599         ufs_inode->ui_ctime.tv_sec = SWAB32(inode->i_ctime);
 600         ufs_inode->ui_ctime.tv_usec = SWAB32(0);
 601         ufs_inode->ui_mtime.tv_sec = SWAB32(inode->i_mtime);
 602         ufs_inode->ui_mtime.tv_usec = SWAB32(0);
 603         ufs_inode->ui_blocks = SWAB32(inode->i_blocks);
 604         ufs_inode->ui_flags = SWAB32(inode->u.ufs_i.i_flags);
 605         ufs_inode->ui_gen = SWAB32(inode->u.ufs_i.i_gen);
 606
 607         if ((flags & UFS_UID_MASK) == UFS_UID_EFT) {
 608                 ufs_inode->ui_u3.ui_sun.ui_shadow = SWAB32(inode->u.ufs_i.i_shadow);
 609                 ufs_inode->ui_u3.ui_sun.ui_oeftflag = SWAB32(inode->u.ufs_i.i_oeftflag);
 610         }
 611
 612         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
 613                 ufs_inode->ui_u2.ui_addr.ui_db[0] = SWAB32(kdev_t_to_nr(inode->i_rdev));
 614         else if (inode->i_blocks) {
 615                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
 616                         ufs_inode->ui_u2.ui_addr.ui_db[i] = inode->u.ufs_i.i_u1.i_data[i];
 617         }
 618         else {
 619                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
 620                         ufs_inode->ui_u2.ui_symlink[i] = inode->u.ufs_i.i_u1.i_symlink[i];
 621         }
 622
 623         if (!inode->i_nlink)
 624                 memset (ufs_inode, 0, sizeof(struct ufs_inode));
 625
 626         mark_buffer_dirty(bh, 1);
 627         if (do_sync) {
 628                 ll_rw_block (WRITE, 1, &bh);
 629                 wait_on_buffer (bh);
 630         }
 631         brelse (bh);
 632
 633         UFSD(("EXIT\n"))
 634         return 0;
 635 }
 636
 637 void ufs_write_inode (struct inode * inode)
 638 {
 639         ufs_update_inode (inode, 0);
 640 }
 641
 642 int ufs_sync_inode (struct inode *inode)
 643 {
 644         return ufs_update_inode (inode, 1);
 645 }
 646
 647 void ufs_put_inode (struct inode * inode)
 648 {
 649         UFSD(("ENTER & EXIT\n"))
 650 }
 651
 652 void ufs_delete_inode (struct inode * inode)
 653 {
 654         /*inode->u.ufs_i.i_dtime = CURRENT_TIME;*/
 655         mark_inode_dirty(inode);
 656         ufs_update_inode(inode, IS_SYNC(inode));
 657         inode->i_size = 0;
 658         if (inode->i_blocks)
 659                 ufs_truncate (inode);
 660         ufs_free_inode (inode);
 661 }