err.no Git - linux-2.6/blob - fs/ufs/dir.c

   1 /*
   2  *  linux/fs/ufs/ufs_dir.c
   3  *
   4  * Copyright (C) 1996
   5  * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
   6  * Laboratory for Computer Science Research Computing Facility
   7  * Rutgers, The State University of New Jersey
   8  *
   9  * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406
  10  *
  11  * 4.4BSD (FreeBSD) support added on February 1st 1998 by
  12  * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
  13  * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
  14  */
  15
  16 #include <linux/time.h>
  17 #include <linux/fs.h>
  18 #include <linux/ufs_fs.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/buffer_head.h>
  21 #include <linux/sched.h>
  22
  23 #include "swab.h"
  24 #include "util.h"
  25
  26 #undef UFS_DIR_DEBUG
  27
  28 #ifdef UFS_DIR_DEBUG
  29 #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
  30 #else
  31 #define UFSD(x)
  32 #endif
  33
  34 static int
  35 ufs_check_dir_entry (const char *, struct inode *, struct ufs_dir_entry *,
  36                      struct buffer_head *, unsigned long);
  37
  38
  39 /*
  40  * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
  41  *
  42  * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
  43  */
  44 static inline int ufs_match(struct super_block *sb, int len,
  45                 const char * const name, struct ufs_dir_entry * de)
  46 {
  47         if (len != ufs_get_de_namlen(sb, de))
  48                 return 0;
  49         if (!de->d_ino)
  50                 return 0;
  51         return !memcmp(name, de->d_name, len);
  52 }
  53
  54 /*
  55  * This is blatantly stolen from ext2fs
  56  */
  57 static int
  58 ufs_readdir (struct file * filp, void * dirent, filldir_t filldir)
  59 {
  60         struct inode *inode = filp->f_dentry->d_inode;
  61         int error = 0;
  62         unsigned long offset, lblk;
  63         int i, stored;
  64         struct buffer_head * bh;
  65         struct ufs_dir_entry * de;
  66         struct super_block * sb;
  67         int de_reclen;
  68         unsigned flags;
  69         u64     blk= 0L;
  70
  71         lock_kernel();
  72
  73         sb = inode->i_sb;
  74         flags = UFS_SB(sb)->s_flags;
  75
  76         UFSD(("ENTER, ino %lu  f_pos %lu\n", inode->i_ino, (unsigned long) filp->f_pos))
  77
  78         stored = 0;
  79         bh = NULL;
  80         offset = filp->f_pos & (sb->s_blocksize - 1);
  81
  82         while (!error && !stored && filp->f_pos < inode->i_size) {
  83                 lblk = (filp->f_pos) >> sb->s_blocksize_bits;
  84                 blk = ufs_frag_map(inode, lblk);
  85                 if (!blk || !(bh = sb_bread(sb, blk))) {
  86                         /* XXX - error - skip to the next block */
  87                         printk("ufs_readdir: "
  88                                "dir inode %lu has a hole at offset %lu\n",
  89                                inode->i_ino, (unsigned long int)filp->f_pos);
  90                         filp->f_pos += sb->s_blocksize - offset;
  91                         continue;
  92                 }
  93
  94 revalidate:
  95                 /* If the dir block has changed since the last call to
  96                  * readdir(2), then we might be pointing to an invalid
  97                  * dirent right now.  Scan from the start of the block
  98                  * to make sure. */
  99                 if (filp->f_version != inode->i_version) {
 100                         for (i = 0; i < sb->s_blocksize && i < offset; ) {
 101                                 de = (struct ufs_dir_entry *)(bh->b_data + i);
 102                                 /* It's too expensive to do a full
 103                                  * dirent test each time round this
 104                                  * loop, but we do have to test at
 105                                  * least that it is non-zero.  A
 106                                  * failure will be detected in the
 107                                  * dirent test below. */
 108                                 de_reclen = fs16_to_cpu(sb, de->d_reclen);
 109                                 if (de_reclen < 1)
 110                                         break;
 111                                 i += de_reclen;
 112                         }
 113                         offset = i;
 114                         filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))
 115                                 | offset;
 116                         filp->f_version = inode->i_version;
 117                 }
 118
 119                 while (!error && filp->f_pos < inode->i_size
 120                        && offset < sb->s_blocksize) {
 121                         de = (struct ufs_dir_entry *) (bh->b_data + offset);
 122                         /* XXX - put in a real ufs_check_dir_entry() */
 123                         if ((de->d_reclen == 0) || (ufs_get_de_namlen(sb, de) == 0)) {
 124                                 filp->f_pos = (filp->f_pos &
 125                                               (sb->s_blocksize - 1)) +
 126                                                sb->s_blocksize;
 127                                 brelse(bh);
 128                                 unlock_kernel();
 129                                 return stored;
 130                         }
 131                         if (!ufs_check_dir_entry ("ufs_readdir", inode, de,
 132                                                    bh, offset)) {
 133                                 /* On error, skip the f_pos to the
 134                                    next block. */
 135                                 filp->f_pos = (filp->f_pos |
 136                                               (sb->s_blocksize - 1)) +
 137                                                1;
 138                                 brelse (bh);
 139                                 unlock_kernel();
 140                                 return stored;
 141                         }
 142                         offset += fs16_to_cpu(sb, de->d_reclen);
 143                         if (de->d_ino) {
 144                                 /* We might block in the next section
 145                                  * if the data destination is
 146                                  * currently swapped out.  So, use a
 147                                  * version stamp to detect whether or
 148                                  * not the directory has been modified
 149                                  * during the copy operation. */
 150                                 unsigned long version = filp->f_version;
 151                                 unsigned char d_type = DT_UNKNOWN;
 152
 153                                 UFSD(("filldir(%s,%u)\n", de->d_name,
 154                                                         fs32_to_cpu(sb, de->d_ino)))
 155                                 UFSD(("namlen %u\n", ufs_get_de_namlen(sb, de)))
 156
 157                                 if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
 158                                         d_type = de->d_u.d_44.d_type;
 159                                 error = filldir(dirent, de->d_name,
 160                                                 ufs_get_de_namlen(sb, de), filp->f_pos,
 161                                                 fs32_to_cpu(sb, de->d_ino), d_type);
 162                                 if (error)
 163                                         break;
 164                                 if (version != filp->f_version)
 165                                         goto revalidate;
 166                                 stored ++;
 167                         }
 168                         filp->f_pos += fs16_to_cpu(sb, de->d_reclen);
 169                 }
 170                 offset = 0;
 171                 brelse (bh);
 172         }
 173         unlock_kernel();
 174         return 0;
 175 }
 176
 177 /*
 178  * define how far ahead to read directories while searching them.
 179  */
 180 #define NAMEI_RA_CHUNKS  2
 181 #define NAMEI_RA_BLOCKS  4
 182 #define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
 183 #define NAMEI_RA_INDEX(c,b)  (((c) * NAMEI_RA_BLOCKS) + (b))
 184
 185 /*
 186  *      ufs_find_entry()
 187  *
 188  * finds an entry in the specified directory with the wanted name. It
 189  * returns the cache buffer in which the entry was found, and the entry
 190  * itself (as a parameter - res_bh). It does NOT read the inode of the
 191  * entry - you'll have to do that yourself if you want to.
 192  */
 193 struct ufs_dir_entry * ufs_find_entry (struct dentry *dentry,
 194         struct buffer_head ** res_bh)
 195 {
 196         struct super_block * sb;
 197         struct buffer_head * bh_use[NAMEI_RA_SIZE];
 198         struct buffer_head * bh_read[NAMEI_RA_SIZE];
 199         unsigned long offset;
 200         int block, toread, i, err;
 201         struct inode *dir = dentry->d_parent->d_inode;
 202         const char *name = dentry->d_name.name;
 203         int namelen = dentry->d_name.len;
 204
 205         UFSD(("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen))
 206
 207         *res_bh = NULL;
 208
 209         sb = dir->i_sb;
 210
 211         if (namelen > UFS_MAXNAMLEN)
 212                 return NULL;
 213
 214         memset (bh_use, 0, sizeof (bh_use));
 215         toread = 0;
 216         for (block = 0; block < NAMEI_RA_SIZE; ++block) {
 217                 struct buffer_head * bh;
 218
 219                 if ((block << sb->s_blocksize_bits) >= dir->i_size)
 220                         break;
 221                 bh = ufs_getfrag (dir, block, 0, &err);
 222                 bh_use[block] = bh;
 223                 if (bh && !buffer_uptodate(bh))
 224                         bh_read[toread++] = bh;
 225         }
 226
 227         for (block = 0, offset = 0; offset < dir->i_size; block++) {
 228                 struct buffer_head * bh;
 229                 struct ufs_dir_entry * de;
 230                 char * dlimit;
 231
 232                 if ((block % NAMEI_RA_BLOCKS) == 0 && toread) {
 233                         ll_rw_block (READ, toread, bh_read);
 234                         toread = 0;
 235                 }
 236                 bh = bh_use[block % NAMEI_RA_SIZE];
 237                 if (!bh) {
 238                         ufs_error (sb, "ufs_find_entry",
 239                                 "directory #%lu contains a hole at offset %lu",
 240                                 dir->i_ino, offset);
 241                         offset += sb->s_blocksize;
 242                         continue;
 243                 }
 244                 wait_on_buffer (bh);
 245                 if (!buffer_uptodate(bh)) {
 246                         /*
 247                          * read error: all bets are off
 248                          */
 249                         break;
 250                 }
 251
 252                 de = (struct ufs_dir_entry *) bh->b_data;
 253                 dlimit = bh->b_data + sb->s_blocksize;
 254                 while ((char *) de < dlimit && offset < dir->i_size) {
 255                         /* this code is executed quadratically often */
 256                         /* do minimal checking by hand */
 257                         int de_len;
 258
 259                         if ((char *) de + namelen <= dlimit &&
 260                             ufs_match(sb, namelen, name, de)) {
 261                                 /* found a match -
 262                                 just to be sure, do a full check */
 263                                 if (!ufs_check_dir_entry("ufs_find_entry",
 264                                     dir, de, bh, offset))
 265                                         goto failed;
 266                                 for (i = 0; i < NAMEI_RA_SIZE; ++i) {
 267                                         if (bh_use[i] != bh)
 268                                                 brelse (bh_use[i]);
 269                                 }
 270                                 *res_bh = bh;
 271                                 return de;
 272                         }
 273                         /* prevent looping on a bad block */
 274                         de_len = fs16_to_cpu(sb, de->d_reclen);
 275                         if (de_len <= 0)
 276                                 goto failed;
 277                         offset += de_len;
 278                         de = (struct ufs_dir_entry *) ((char *) de + de_len);
 279                 }
 280
 281                 brelse (bh);
 282                 if (((block + NAMEI_RA_SIZE) << sb->s_blocksize_bits ) >=
 283                     dir->i_size)
 284                         bh = NULL;
 285                 else
 286                         bh = ufs_getfrag (dir, block + NAMEI_RA_SIZE, 0, &err);
 287                 bh_use[block % NAMEI_RA_SIZE] = bh;
 288                 if (bh && !buffer_uptodate(bh))
 289                         bh_read[toread++] = bh;
 290         }
 291
 292 failed:
 293         for (i = 0; i < NAMEI_RA_SIZE; ++i) brelse (bh_use[i]);
 294         UFSD(("EXIT\n"))
 295         return NULL;
 296 }
 297
 298 static int
 299 ufs_check_dir_entry (const char *function, struct inode *dir,
 300                      struct ufs_dir_entry *de, struct buffer_head *bh,
 301                      unsigned long offset)
 302 {
 303         struct super_block *sb = dir->i_sb;
 304         const char *error_msg = NULL;
 305         int rlen = fs16_to_cpu(sb, de->d_reclen);
 306
 307         if (rlen < UFS_DIR_REC_LEN(1))
 308                 error_msg = "reclen is smaller than minimal";
 309         else if (rlen % 4 != 0)
 310                 error_msg = "reclen % 4 != 0";
 311         else if (rlen < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)))
 312                 error_msg = "reclen is too small for namlen";
 313         else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
 314                 error_msg = "directory entry across blocks";
 315         else if (fs32_to_cpu(sb, de->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
 316                                       UFS_SB(sb)->s_uspi->s_ncg))
 317                 error_msg = "inode out of bounds";
 318
 319         if (error_msg != NULL)
 320                 ufs_error (sb, function, "bad entry in directory #%lu, size %Lu: %s - "
 321                             "offset=%lu, inode=%lu, reclen=%d, namlen=%d",
 322                             dir->i_ino, dir->i_size, error_msg, offset,
 323                             (unsigned long)fs32_to_cpu(sb, de->d_ino),
 324                             rlen, ufs_get_de_namlen(sb, de));
 325
 326         return (error_msg == NULL ? 1 : 0);
 327 }
 328
 329 struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct buffer_head **p)
 330 {
 331         int err;
 332         struct buffer_head *bh = ufs_bread (dir, 0, 0, &err);
 333         struct ufs_dir_entry *res = NULL;
 334
 335         if (bh) {
 336                 res = (struct ufs_dir_entry *) bh->b_data;
 337                 res = (struct ufs_dir_entry *)((char *)res +
 338                         fs16_to_cpu(dir->i_sb, res->d_reclen));
 339         }
 340         *p = bh;
 341         return res;
 342 }
 343 ino_t ufs_inode_by_name(struct inode * dir, struct dentry *dentry)
 344 {
 345         ino_t res = 0;
 346         struct ufs_dir_entry * de;
 347         struct buffer_head *bh;
 348
 349         de = ufs_find_entry (dentry, &bh);
 350         if (de) {
 351                 res = fs32_to_cpu(dir->i_sb, de->d_ino);
 352                 brelse(bh);
 353         }
 354         return res;
 355 }
 356
 357 void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
 358                 struct buffer_head *bh, struct inode *inode)
 359 {
 360         dir->i_version++;
 361         de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
 362         mark_buffer_dirty(bh);
 363         if (IS_DIRSYNC(dir))
 364                 sync_dirty_buffer(bh);
 365         brelse (bh);
 366 }
 367
 368 /*
 369  *      ufs_add_entry()
 370  *
 371  * adds a file entry to the specified directory, using the same
 372  * semantics as ufs_find_entry(). It returns NULL if it failed.
 373  */
 374 int ufs_add_link(struct dentry *dentry, struct inode *inode)
 375 {
 376         struct super_block * sb;
 377         struct ufs_sb_private_info * uspi;
 378         unsigned long offset;
 379         unsigned fragoff;
 380         unsigned short rec_len;
 381         struct buffer_head * bh;
 382         struct ufs_dir_entry * de, * de1;
 383         struct inode *dir = dentry->d_parent->d_inode;
 384         const char *name = dentry->d_name.name;
 385         int namelen = dentry->d_name.len;
 386         int err;
 387
 388         UFSD(("ENTER, name %s, namelen %u\n", name, namelen))
 389
 390         sb = dir->i_sb;
 391         uspi = UFS_SB(sb)->s_uspi;
 392
 393         if (!namelen)
 394                 return -EINVAL;
 395         bh = ufs_bread (dir, 0, 0, &err);
 396         if (!bh)
 397                 return err;
 398         rec_len = UFS_DIR_REC_LEN(namelen);
 399         offset = 0;
 400         de = (struct ufs_dir_entry *) bh->b_data;
 401         while (1) {
 402                 if ((char *)de >= UFS_SECTOR_SIZE + bh->b_data) {
 403                         fragoff = offset & ~uspi->s_fmask;
 404                         if (fragoff != 0 && fragoff != UFS_SECTOR_SIZE)
 405                                 ufs_error (sb, "ufs_add_entry", "internal error"
 406                                         " fragoff %u", fragoff);
 407                         if (!fragoff) {
 408                                 brelse (bh);
 409                                 bh = ufs_bread (dir, offset >> sb->s_blocksize_bits, 1, &err);
 410                                 if (!bh)
 411                                         return err;
 412                         }
 413                         if (dir->i_size <= offset) {
 414                                 if (dir->i_size == 0) {
 415                                         brelse(bh);
 416                                         return -ENOENT;
 417                                 }
 418                                 de = (struct ufs_dir_entry *) (bh->b_data + fragoff);
 419                                 de->d_ino = 0;
 420                                 de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE);
 421                                 ufs_set_de_namlen(sb, de, 0);
 422                                 dir->i_size = offset + UFS_SECTOR_SIZE;
 423                                 mark_inode_dirty(dir);
 424                         } else {
 425                                 de = (struct ufs_dir_entry *) bh->b_data;
 426                         }
 427                 }
 428                 if (!ufs_check_dir_entry ("ufs_add_entry", dir, de, bh, offset)) {
 429                         brelse (bh);
 430                         return -ENOENT;
 431                 }
 432                 if (ufs_match(sb, namelen, name, de)) {
 433                         brelse (bh);
 434                         return -EEXIST;
 435                 }
 436                 if (de->d_ino == 0 && fs16_to_cpu(sb, de->d_reclen) >= rec_len)
 437                         break;
 438
 439                 if (fs16_to_cpu(sb, de->d_reclen) >=
 440                      UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)) + rec_len)
 441                         break;
 442                 offset += fs16_to_cpu(sb, de->d_reclen);
 443                 de = (struct ufs_dir_entry *) ((char *) de + fs16_to_cpu(sb, de->d_reclen));
 444         }
 445
 446         if (de->d_ino) {
 447                 de1 = (struct ufs_dir_entry *) ((char *) de +
 448                         UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
 449                 de1->d_reclen =
 450                         cpu_to_fs16(sb, fs16_to_cpu(sb, de->d_reclen) -
 451                                 UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
 452                 de->d_reclen =
 453                         cpu_to_fs16(sb, UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
 454                 de = de1;
 455         }
 456         de->d_ino = 0;
 457         ufs_set_de_namlen(sb, de, namelen);
 458         memcpy (de->d_name, name, namelen + 1);
 459         de->d_ino = cpu_to_fs32(sb, inode->i_ino);
 460         ufs_set_de_type(sb, de, inode->i_mode);
 461         mark_buffer_dirty(bh);
 462         if (IS_DIRSYNC(dir))
 463                 sync_dirty_buffer(bh);
 464         brelse (bh);
 465         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 466         dir->i_version++;
 467         mark_inode_dirty(dir);
 468
 469         UFSD(("EXIT\n"))
 470         return 0;
 471 }
 472
 473 /*
 474  * ufs_delete_entry deletes a directory entry by merging it with the
 475  * previous entry.
 476  */
 477 int ufs_delete_entry (struct inode * inode, struct ufs_dir_entry * dir,
 478         struct buffer_head * bh )
 479
 480 {
 481         struct super_block * sb;
 482         struct ufs_dir_entry * de, * pde;
 483         unsigned i;
 484
 485         UFSD(("ENTER\n"))
 486
 487         sb = inode->i_sb;
 488         i = 0;
 489         pde = NULL;
 490         de = (struct ufs_dir_entry *) bh->b_data;
 491
 492         UFSD(("ino %u, reclen %u, namlen %u, name %s\n",
 493                 fs32_to_cpu(sb, de->d_ino),
 494                 fs16to_cpu(sb, de->d_reclen),
 495                 ufs_get_de_namlen(sb, de), de->d_name))
 496
 497         while (i < bh->b_size) {
 498                 if (!ufs_check_dir_entry ("ufs_delete_entry", inode, de, bh, i)) {
 499                         brelse(bh);
 500                         return -EIO;
 501                 }
 502                 if (de == dir)  {
 503                         if (pde)
 504                                 fs16_add(sb, &pde->d_reclen,
 505                                         fs16_to_cpu(sb, dir->d_reclen));
 506                         dir->d_ino = 0;
 507                         inode->i_version++;
 508                         inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 509                         mark_inode_dirty(inode);
 510                         mark_buffer_dirty(bh);
 511                         if (IS_DIRSYNC(inode))
 512                                 sync_dirty_buffer(bh);
 513                         brelse(bh);
 514                         UFSD(("EXIT\n"))
 515                         return 0;
 516                 }
 517                 i += fs16_to_cpu(sb, de->d_reclen);
 518                 if (i == UFS_SECTOR_SIZE) pde = NULL;
 519                 else pde = de;
 520                 de = (struct ufs_dir_entry *)
 521                     ((char *) de + fs16_to_cpu(sb, de->d_reclen));
 522                 if (i == UFS_SECTOR_SIZE && de->d_reclen == 0)
 523                         break;
 524         }
 525         UFSD(("EXIT\n"))
 526         brelse(bh);
 527         return -ENOENT;
 528 }
 529
 530 int ufs_make_empty(struct inode * inode, struct inode *dir)
 531 {
 532         struct super_block * sb = dir->i_sb;
 533         struct buffer_head * dir_block;
 534         struct ufs_dir_entry * de;
 535         int err;
 536
 537         dir_block = ufs_bread (inode, 0, 1, &err);
 538         if (!dir_block)
 539                 return err;
 540
 541         inode->i_blocks = sb->s_blocksize / UFS_SECTOR_SIZE;
 542         de = (struct ufs_dir_entry *) dir_block->b_data;
 543         de->d_ino = cpu_to_fs32(sb, inode->i_ino);
 544         ufs_set_de_type(sb, de, inode->i_mode);
 545         ufs_set_de_namlen(sb, de, 1);
 546         de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
 547         strcpy (de->d_name, ".");
 548         de = (struct ufs_dir_entry *)
 549                 ((char *)de + fs16_to_cpu(sb, de->d_reclen));
 550         de->d_ino = cpu_to_fs32(sb, dir->i_ino);
 551         ufs_set_de_type(sb, de, dir->i_mode);
 552         de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
 553         ufs_set_de_namlen(sb, de, 2);
 554         strcpy (de->d_name, "..");
 555         mark_buffer_dirty(dir_block);
 556         brelse (dir_block);
 557         mark_inode_dirty(inode);
 558         return 0;
 559 }
 560
 561 /*
 562  * routine to check that the specified directory is empty (for rmdir)
 563  */
 564 int ufs_empty_dir (struct inode * inode)
 565 {
 566         struct super_block * sb;
 567         unsigned long offset;
 568         struct buffer_head * bh;
 569         struct ufs_dir_entry * de, * de1;
 570         int err;
 571
 572         sb = inode->i_sb;
 573
 574         if (inode->i_size < UFS_DIR_REC_LEN(1) + UFS_DIR_REC_LEN(2) ||
 575             !(bh = ufs_bread (inode, 0, 0, &err))) {
 576                 ufs_warning (inode->i_sb, "empty_dir",
 577                               "bad directory (dir #%lu) - no data block",
 578                               inode->i_ino);
 579                 return 1;
 580         }
 581         de = (struct ufs_dir_entry *) bh->b_data;
 582         de1 = (struct ufs_dir_entry *)
 583                 ((char *)de + fs16_to_cpu(sb, de->d_reclen));
 584         if (fs32_to_cpu(sb, de->d_ino) != inode->i_ino || de1->d_ino == 0 ||
 585              strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) {
 586                 ufs_warning (inode->i_sb, "empty_dir",
 587                               "bad directory (dir #%lu) - no `.' or `..'",
 588                               inode->i_ino);
 589                 return 1;
 590         }
 591         offset = fs16_to_cpu(sb, de->d_reclen) + fs16_to_cpu(sb, de1->d_reclen);
 592         de = (struct ufs_dir_entry *)
 593                 ((char *)de1 + fs16_to_cpu(sb, de1->d_reclen));
 594         while (offset < inode->i_size ) {
 595                 if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
 596                         brelse (bh);
 597                         bh = ufs_bread (inode, offset >> sb->s_blocksize_bits, 1, &err);
 598                         if (!bh) {
 599                                 ufs_error (sb, "empty_dir",
 600                                             "directory #%lu contains a hole at offset %lu",
 601                                             inode->i_ino, offset);
 602                                 offset += sb->s_blocksize;
 603                                 continue;
 604                         }
 605                         de = (struct ufs_dir_entry *) bh->b_data;
 606                 }
 607                 if (!ufs_check_dir_entry ("empty_dir", inode, de, bh, offset)) {
 608                         brelse (bh);
 609                         return 1;
 610                 }
 611                 if (de->d_ino) {
 612                         brelse (bh);
 613                         return 0;
 614                 }
 615                 offset += fs16_to_cpu(sb, de->d_reclen);
 616                 de = (struct ufs_dir_entry *)
 617                         ((char *)de + fs16_to_cpu(sb, de->d_reclen));
 618         }
 619         brelse (bh);
 620         return 1;
 621 }
 622
 623 struct file_operations ufs_dir_operations = {
 624         .read           = generic_read_dir,
 625         .readdir        = ufs_readdir,
 626         .fsync          = file_fsync,
 627 };