root/fs/hpfs/hpfs_fs.c

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

DEFINITIONS

This source file includes following definitions.
  1. file_ino
  2. dir_ino
  3. ino_secno
  4. ino_is_dir
  5. local_to_gmt
  6. hpfs_read_super
  7. check_warn
  8. zerop
  9. parse_opts
  10. hpfs_read_inode
  11. hpfs_put_super
  12. hpfs_statfs
  13. hpfs_remount_fs
  14. count_dnodes
  15. count_bitmap
  16. count_one_bitmap
  17. hpfs_file_read
  18. choose_conv
  19. convcpy_tofs
  20. hpfs_bmap
  21. bplus_lookup
  22. hpfs_lookup
  23. memcasecmp
  24. map_dirent
  25. hpfs_readdir
  26. write_one_dirent
  27. map_pos_dirent
  28. dir_subdno
  29. map_nth_dirent
  30. hpfs_dir_read
  31. fnode_dno
  32. map_fnode
  33. map_anode
  34. map_dnode
  35. map_sector
  36. map_4sectors
  37. brelse4

   1 /*
   2  *  linux/fs/hpfs/hpfs_fs.c
   3  *  read-only HPFS
   4  *  version 1.0
   5  *
   6  *  Chris Smith 1993
   7  *
   8  *  Sources & references:
   9  *   Duncan, _Design ... of HPFS_, MSJ 4(5)   (C) 1989 Microsoft Corp
  10  *   linux/fs/minix  Copyright (C) 1991, 1992, 1993  Linus Torvalds
  11  *   linux/fs/msdos  Written 1992, 1993 by Werner Almesberger
  12  *   linux/fs/isofs  Copyright (C) 1991  Eric Youngdale
  13  */
  14 
  15 #include <linux/fs.h>
  16 #include <linux/hpfs_fs.h>
  17 #include <linux/errno.h>
  18 #include <linux/malloc.h>
  19 #include <linux/kernel.h>
  20 #include <linux/sched.h>
  21 #include <linux/locks.h>
  22 #include <linux/stat.h>
  23 #include <linux/string.h>
  24 #include <asm/bitops.h>
  25 #include <asm/segment.h>
  26 
  27 #include "hpfs.h"
  28 #include "hpfs_caps.h"
  29 
  30 /* 
  31  * HPFS is a mixture of 512-byte blocks and 2048-byte blocks.  The 2k blocks
  32  * are used for directories and bitmaps.  For bmap to work, we must run the
  33  * file system with 512-byte blocks.  The 2k blocks are assembled in buffers
  34  * obtained from kmalloc.
  35  *
  36  * For a file's i-number we use the sector number of its fnode, coded.
  37  * (Directory ino's are even, file ino's are odd, and ino >> 1 is the
  38  * sector address of the fnode.  This is a hack to allow lookup() to
  39  * tell read_inode() whether it is necessary to read the fnode.)
  40  *
  41  * The map_xxx routines all read something into a buffer and return a
  42  * pointer somewhere in the buffer.  The caller must do the brelse.
  43  * The other routines are balanced.
  44  *
  45  * For details on the data structures see hpfs.h and the Duncan paper.
  46  *
  47  * Overview
  48  *
  49  * [ The names of these data structures, except fnode, are not Microsoft's
  50  * or IBM's.  I don't know what names they use.  The semantics described
  51  * here are those of this implementation, and any coincidence between it
  52  * and real HPFS is to be hoped for but not guaranteed by me, and
  53  * certainly not guaranteed by MS or IBM.  Who know nothing about this. ]
  54  *
  55  * [ Also, the following will make little sense if you haven't read the
  56  * Duncan paper, which is excellent. ]
  57  *
  58  * HPFS is a tree.  There are 3 kinds of nodes.  A directory is a tree
  59  * of dnodes, and a file's allocation info is a tree of sector runs
  60  * stored in fnodes and anodes.
  61  *
  62  * The top pointer is in the super block, it points to the fnode of the
  63  * root directory.
  64  *
  65  * The root directory -- all directories -- gives file names, dates &c,
  66  * and fnode addresses.  If the directory fits in one dnode, that's it,
  67  * otherwise the top dnode points to other dnodes, forming a tree.  A
  68  * dnode tree (one directory) might look like
  69  *
  70  *     ((a b c) d (e f g) h (i j) k l (m n o p))
  71  *
  72  * The subtrees appear between the files.  Each dir entry contains, along
  73  * with the name and fnode, a dnode pointer to the subtree that precedes it
  74  * (if there is one; a flag tells that).  The first entry in every directory
  75  * is ^A^A, the "." entry for the directory itself.  The last entry in every
  76  * dnode is \377, a fake entry whose only valid fields are the bit marking
  77  * it last and the down pointer to the subtree preceding it, if any.
  78  *
  79  * The "value" field of directory entries is an fnode address.  The fnode
  80  * tells where the sectors of the file are.  The fnode for a subdirectory
  81  * contains one pointer, to the root dnode of the subdirectory.  The fnode
  82  * for a data file contains, in effect, a tiny anode.  (Most of the space
  83  * in fnodes is for extended attributes.)
  84  *
  85  * anodes and the anode part of fnodes are trees of extents.  An extent
  86  * is a (length, disk address) pair, labeled with the file address being
  87  * mapped.  E.g.,
  88  *
  89  *     (0: 3@1000  3: 1@2000  4: 2@10)
  90  *
  91  * means the file:disk sector map (0:1000 1:1001 2:1002 3:2000 4:10 5:11).
  92  *
  93  * There is space for 8 file:len@disk triples in an fnode, or for 40 in an
  94  * anode.  If this is insufficient, subtrees are used, as in
  95  *
  96  *  (6: (0: 3@1000  3: 1@2000  4: 2@10)  12: (6: 3@8000  9: 1@9000  10: 2@20))
  97  *
  98  * The label on a subtree is the first address *after* that tree.  The
  99  * subtrees are always anodes.  The label:subtree pairs require only
 100  * two words each, so non-leaf subtrees have a different format; there
 101  * is room for 12 label:subtree pairs in an fnode, or 60 in an anode.
 102  *
 103  * Within a directory, each dnode contains a pointer up to its parent
 104  * dnode.  The root dnode points up to the directory's fnode.
 105  *
 106  * Each fnode contains a pointer to the directory that contains it
 107  * (to the fnode of the directory).  So this pointer in a directory
 108  * fnode is "..".
 109  *
 110  * On the disk, dnodes are all together in the center of the partition,
 111  * and HPFS even manages to put all the dnodes for a single directory
 112  * together, generally.  fnodes are out with the data.  anodes are seldom
 113  * seen -- in fact noncontiguous files are seldom seen.  I think this is
 114  * partly the open() call that lets programs specify the length of an
 115  * output file when they know it, and partly because HPFS.IFS really is
 116  * very good at resisting fragmentation. 
 117  */
 118 
 119 /* notation */
 120 
 121 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
 122 #define ROUND_UP(x) (((x)+3) & ~3)
 123 
 124 #define little_ushort(x) (*(unsigned short *) &(x))
 125 typedef void nonconst;
 126 
 127 /* super block ops */
 128 
 129 static void hpfs_read_inode(struct inode *);
 130 static void hpfs_put_super(struct super_block *);
 131 static void hpfs_statfs(struct super_block *, struct statfs *);
 132 static int hpfs_remount_fs(struct super_block *, int *, char *);
 133 
 134 static const struct super_operations hpfs_sops =
 135 {
 136         hpfs_read_inode,                /* read_inode */
 137         NULL,                           /* notify_change */
 138         NULL,                           /* write_inode */
 139         NULL,                           /* put_inode */
 140         hpfs_put_super,                 /* put_super */
 141         NULL,                           /* write_super */
 142         hpfs_statfs,                    /* statfs */
 143         hpfs_remount_fs,                /* remount_fs */
 144 };
 145 
 146 /* file ops */
 147 
 148 static int hpfs_file_read(struct inode *, struct file *, char *, int);
 149 static secno hpfs_bmap(struct inode *, unsigned);
 150 
 151 static const struct file_operations hpfs_file_ops =
 152 {
 153         NULL,                           /* lseek - default */
 154         hpfs_file_read,                 /* read */
 155         NULL,                           /* write */
 156         NULL,                           /* readdir - bad */
 157         NULL,                           /* select - default */
 158         NULL,                           /* ioctl - default */
 159         generic_mmap,                   /* mmap */
 160         NULL,                           /* no special open is needed */
 161         NULL,                           /* release */
 162         file_fsync,                     /* fsync */
 163 };
 164 
 165 static const struct inode_operations hpfs_file_iops =
 166 {
 167         (nonconst *) & hpfs_file_ops,   /* default file operations */
 168         NULL,                           /* create */
 169         NULL,                           /* lookup */
 170         NULL,                           /* link */
 171         NULL,                           /* unlink */
 172         NULL,                           /* symlink */
 173         NULL,                           /* mkdir */
 174         NULL,                           /* rmdir */
 175         NULL,                           /* mknod */
 176         NULL,                           /* rename */
 177         NULL,                           /* readlink */
 178         NULL,                           /* follow_link */
 179         (int (*)(struct inode *, int))
 180         &hpfs_bmap,                     /* bmap */
 181         NULL,                           /* truncate */
 182         NULL,                           /* permission */
 183 };
 184 
 185 /* directory ops */
 186 
 187 static int hpfs_dir_read(struct inode *inode, struct file *filp,
 188                          char *buf, int count);
 189 static int hpfs_readdir(struct inode *inode, struct file *filp,
 190                         struct dirent *dirent, int count);
 191 static int hpfs_lookup(struct inode *, const char *, int, struct inode **);
 192 
 193 static const struct file_operations hpfs_dir_ops =
 194 {
 195         NULL,                           /* lseek - default */
 196         hpfs_dir_read,                  /* read */
 197         NULL,                           /* write - bad */
 198         hpfs_readdir,                   /* readdir */
 199         NULL,                           /* select - default */
 200         NULL,                           /* ioctl - default */
 201         NULL,                           /* mmap */
 202         NULL,                           /* no special open code */
 203         NULL,                           /* no special release code */
 204         file_fsync,                     /* fsync */
 205 };
 206 
 207 static const struct inode_operations hpfs_dir_iops =
 208 {
 209         (nonconst *) & hpfs_dir_ops,    /* default directory file ops */
 210         NULL,                           /* create */
 211         hpfs_lookup,                    /* lookup */
 212         NULL,                           /* link */
 213         NULL,                           /* unlink */
 214         NULL,                           /* symlink */
 215         NULL,                           /* mkdir */
 216         NULL,                           /* rmdir */
 217         NULL,                           /* mknod */
 218         NULL,                           /* rename */
 219         NULL,                           /* readlink */
 220         NULL,                           /* follow_link */
 221         NULL,                           /* bmap */
 222         NULL,                           /* truncate */
 223         NULL,                           /* permission */
 224 };
 225 
 226 /* Four 512-byte buffers and the 2k block obtained by concatenating them */
 227 
 228 struct quad_buffer_head {
 229         struct buffer_head *bh[4];
 230         void *data;
 231 };
 232 
 233 /* forwards */
 234 
 235 static int parse_opts(char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
 236                       int *lowercase, int *conv);
 237 static int check_warn(int not_ok,
 238                       const char *p1, const char *p2, const char *p3);
 239 static int zerop(void *addr, unsigned len);
 240 static void count_dnodes(struct inode *inode, dnode_secno dno,
 241                          unsigned *n_dnodes, unsigned *n_subdirs);
 242 static unsigned count_bitmap(struct super_block *s);
 243 static unsigned count_one_bitmap(dev_t dev, secno secno);
 244 static secno bplus_lookup(struct inode *inode, struct bplus_header *b,
 245                           secno file_secno, struct buffer_head **bhp);
 246 static struct hpfs_dirent *map_dirent(struct inode *inode, dnode_secno dno,
 247                                     const unsigned char *name, unsigned len,
 248                                       struct quad_buffer_head *qbh);
 249 static struct hpfs_dirent *map_pos_dirent(struct inode *inode, loff_t *posp,
 250                                           struct quad_buffer_head *qbh);
 251 static void write_one_dirent(struct dirent *dirent, const unsigned char *name,
 252                              unsigned namelen, ino_t ino, int lowercase);
 253 static dnode_secno dir_subdno(struct inode *inode, unsigned pos);
 254 static struct hpfs_dirent *map_nth_dirent(dev_t dev, dnode_secno dno,
 255                                           int n,
 256                                           struct quad_buffer_head *qbh);
 257 static unsigned choose_conv(unsigned char *p, unsigned len);
 258 static unsigned convcpy_tofs(unsigned char *out, unsigned char *in,
 259                              unsigned len);
 260 static dnode_secno fnode_dno(dev_t dev, ino_t ino);
 261 static struct fnode *map_fnode(dev_t dev, ino_t ino,
 262                                struct buffer_head **bhp);
 263 static struct anode *map_anode(dev_t dev, unsigned secno,
 264                                struct buffer_head **bhp);
 265 static struct dnode *map_dnode(dev_t dev, unsigned secno,
 266                                struct quad_buffer_head *qbh);
 267 static void *map_sector(dev_t dev, unsigned secno, struct buffer_head **bhp);
 268 static void *map_4sectors(dev_t dev, unsigned secno,
 269                           struct quad_buffer_head *qbh);
 270 static void brelse4(struct quad_buffer_head *qbh);
 271 
 272 /*
 273  * make inode number for a file
 274  */
 275 
 276 static inline ino_t file_ino(fnode_secno secno)
     /* [previous][next][first][last][top][bottom][index][help] */
 277 {
 278         return secno << 1 | 1;
 279 }
 280 
 281 /*
 282  * make inode number for a directory
 283  */
 284 
 285 static inline ino_t dir_ino(fnode_secno secno)
     /* [previous][next][first][last][top][bottom][index][help] */
 286 {
 287         return secno << 1;
 288 }
 289 
 290 /*
 291  * get fnode address from an inode number
 292  */
 293 
 294 static inline fnode_secno ino_secno(ino_t ino)
     /* [previous][next][first][last][top][bottom][index][help] */
 295 {
 296         return ino >> 1;
 297 }
 298 
 299 /*
 300  * test for directory's inode number 
 301  */
 302 
 303 static inline int ino_is_dir(ino_t ino)
     /* [previous][next][first][last][top][bottom][index][help] */
 304 {
 305         return (ino & 1) == 0;
 306 }
 307 
 308 /*
 309  * conv= options
 310  */
 311 
 312 #define CONV_BINARY 0                   /* no conversion */
 313 #define CONV_TEXT 1                     /* crlf->newline */
 314 #define CONV_AUTO 2                     /* decide based on file contents */
 315 
 316 /*
 317  * local time (HPFS) to GMT (Unix)
 318  */
 319 
 320 static inline time_t local_to_gmt(time_t t)
     /* [previous][next][first][last][top][bottom][index][help] */
 321 {
 322         extern struct timezone sys_tz;
 323         return t + sys_tz.tz_minuteswest * 60;
 324 }
 325 
 326 /* super block ops */
 327 
 328 /*
 329  * mount.  This gets one thing, the root directory inode.  It does a
 330  * bunch of guessed-at consistency checks.
 331  */
 332 
 333 struct super_block *hpfs_read_super(struct super_block *s,
     /* [previous][next][first][last][top][bottom][index][help] */
 334                                     void *options, int silent)
 335 {
 336         struct hpfs_boot_block *bootblock;
 337         struct hpfs_super_block *superblock;
 338         struct hpfs_spare_block *spareblock;
 339         struct hpfs_dirent *de;
 340         struct buffer_head *bh0, *bh1, *bh2;
 341         struct quad_buffer_head qbh;
 342         dnode_secno root_dno;
 343         dev_t dev;
 344         uid_t uid;
 345         gid_t gid;
 346         umode_t umask;
 347         int lowercase;
 348         int conv;
 349         int dubious;
 350 
 351         /*
 352          * Get the mount options
 353          */
 354 
 355         if (!parse_opts(options, &uid, &gid, &umask, &lowercase, &conv)) {
 356                 printk("HPFS: syntax error in mount options.  Not mounted.\n");
 357                 s->s_dev = 0;
 358                 return 0;
 359         }
 360 
 361         /*
 362          * Fill in the super block struct
 363          */
 364 
 365         lock_super(s);
 366         dev = s->s_dev;
 367         set_blocksize(dev, 512);
 368 
 369         /*
 370          * fetch sectors 0, 16, 17
 371          */
 372 
 373         bootblock = map_sector(dev, 0, &bh0);
 374         if (!bootblock)
 375                 goto bail;
 376 
 377         superblock = map_sector(dev, 16, &bh1);
 378         if (!superblock)
 379                 goto bail0;
 380 
 381         spareblock = map_sector(dev, 17, &bh2);
 382         if (!spareblock)
 383                 goto bail1;
 384 
 385         /*
 386          * Check that this fs looks enough like a known one that we can find
 387          * and read the root directory.
 388          */
 389 
 390         if (bootblock->magic != 0xaa55
 391             || superblock->magic != SB_MAGIC
 392             || spareblock->magic != SP_MAGIC
 393             || bootblock->sig_28h != 0x28
 394             || memcmp(&bootblock->sig_hpfs, "HPFS    ", 8)
 395             || little_ushort(bootblock->bytes_per_sector) != 512) {
 396                 printk("HPFS: hpfs_read_super: Not HPFS\n");
 397                 goto bail2;
 398         }
 399 
 400         /*
 401          * Check for inconsistencies -- possibly wrong guesses here, possibly
 402          * filesystem problems.
 403          */
 404 
 405         dubious = 0;
 406 
 407         dubious |= check_warn(spareblock->dirty != 0,
 408                        "`Improperly stopped'", "flag is set", "run CHKDSK");
 409         dubious |= check_warn(spareblock->n_spares_used != 0,
 410                               "Spare blocks", "may be in use", "run CHKDSK");
 411 
 412         /*
 413          * Above errors mean we could get wrong answers if we proceed,
 414          * so don't
 415          */
 416 
 417         if (dubious)
 418                 goto bail2;
 419 
 420         dubious |= check_warn((spareblock->n_dnode_spares !=
 421                                spareblock->n_dnode_spares_free),
 422                               "Spare dnodes", "may be in use", "run CHKDSK");
 423         dubious |= check_warn(superblock->zero1 != 0,
 424                               "#1", "unknown word nonzero", "investigate");
 425         dubious |= check_warn(superblock->zero3 != 0,
 426                               "#3", "unknown word nonzero", "investigate");
 427         dubious |= check_warn(superblock->zero4 != 0,
 428                               "#4", "unknown word nonzero", "investigate");
 429         dubious |= check_warn(!zerop(superblock->zero5,
 430                                      sizeof superblock->zero5),
 431                               "#5", "unknown word nonzero", "investigate");
 432         dubious |= check_warn(!zerop(superblock->zero6,
 433                                      sizeof superblock->zero6),
 434                               "#6", "unknown word nonzero", "investigate");
 435 
 436         if (dubious)
 437                 printk("HPFS: Proceeding, but operation may be unreliable\n");
 438 
 439         /*
 440          * set fs read only
 441          */
 442 
 443         s->s_flags |= MS_RDONLY;
 444 
 445         /*
 446          * fill in standard stuff
 447          */
 448 
 449         s->s_magic = HPFS_SUPER_MAGIC;
 450         s->s_blocksize = 512;
 451         s->s_blocksize_bits = 9;
 452         s->s_op = (struct super_operations *) &hpfs_sops;
 453 
 454         /*
 455          * fill in hpfs stuff
 456          */
 457 
 458         s->s_hpfs_root = dir_ino(superblock->root);
 459         s->s_hpfs_fs_size = superblock->n_sectors;
 460         s->s_hpfs_dirband_size = superblock->n_dir_band / 4;
 461         s->s_hpfs_dmap = superblock->dir_band_bitmap;
 462         s->s_hpfs_bitmaps = superblock->bitmaps;
 463         s->s_hpfs_uid = uid;
 464         s->s_hpfs_gid = gid;
 465         s->s_hpfs_mode = 0777 & ~umask;
 466         s->s_hpfs_n_free = -1;
 467         s->s_hpfs_n_free_dnodes = -1;
 468         s->s_hpfs_lowercase = lowercase;
 469         s->s_hpfs_conv = conv;
 470 
 471         /*
 472          * done with the low blocks
 473          */
 474 
 475         brelse(bh2);
 476         brelse(bh1);
 477         brelse(bh0);
 478 
 479         /*
 480          * all set.  try it out.
 481          */
 482 
 483         s->s_mounted = iget(s, s->s_hpfs_root);
 484         unlock_super(s);
 485 
 486         if (!s->s_mounted) {
 487                 printk("HPFS: hpfs_read_super: inode get failed\n");
 488                 s->s_dev = 0;
 489                 return 0;
 490         }
 491 
 492         /*
 493          * find the root directory's . pointer & finish filling in the inode
 494          */
 495 
 496         root_dno = fnode_dno(dev, s->s_hpfs_root);
 497         if (root_dno)
 498                 de = map_dirent(s->s_mounted, root_dno, "\001\001", 2, &qbh);
 499         if (!root_dno || !de) {
 500                 printk("HPFS: "
 501                        "hpfs_read_super: root dir isn't in the root dir\n");
 502                 s->s_dev = 0;
 503                 return 0;
 504         }
 505 
 506         s->s_mounted->i_atime = local_to_gmt(de->read_date);
 507         s->s_mounted->i_mtime = local_to_gmt(de->write_date);
 508         s->s_mounted->i_ctime = local_to_gmt(de->creation_date);
 509 
 510         brelse4(&qbh);
 511         return s;
 512 
 513  bail2:
 514         brelse(bh2);
 515  bail1:
 516         brelse(bh1);
 517  bail0:
 518         brelse(bh0);
 519  bail:
 520         s->s_dev = 0;
 521         unlock_super(s);
 522         return 0;
 523 }
 524 
 525 static int check_warn(int not_ok,
     /* [previous][next][first][last][top][bottom][index][help] */
 526                       const char *p1, const char *p2, const char *p3)
 527 {
 528         if (not_ok)
 529                 printk("HPFS: %s %s. Please %s\n", p1, p2, p3);
 530         return not_ok;
 531 }
 532 
 533 static int zerop(void *addr, unsigned len)
     /* [previous][next][first][last][top][bottom][index][help] */
 534 {
 535         unsigned char *p = addr;
 536         return p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
 537 }
 538 
 539 /*
 540  * A tiny parser for option strings, stolen from dosfs.
 541  */
 542 
 543 static int parse_opts(char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
     /* [previous][next][first][last][top][bottom][index][help] */
 544                       int *lowercase, int *conv)
 545 {
 546         char *p, *rhs;
 547 
 548         *uid = current->uid;
 549         *gid = current->gid;
 550         *umask = current->fs->umask;
 551         *lowercase = 1;
 552         *conv = CONV_BINARY;
 553 
 554         if (!opts)
 555                 return 1;
 556 
 557         for (p = strtok(opts, ","); p != 0; p = strtok(0, ",")) {
 558                 if ((rhs = strchr(p, '=')) != 0)
 559                         *rhs++ = '\0';
 560                 if (!strcmp(p, "uid")) {
 561                         if (!rhs || !*rhs)
 562                                 return 0;
 563                         *uid = simple_strtoul(rhs, &rhs, 0);
 564                         if (*rhs)
 565                                 return 0;
 566                 }
 567                 else if (!strcmp(p, "gid")) {
 568                         if (!rhs || !*rhs)
 569                                 return 0;
 570                         *gid = simple_strtoul(rhs, &rhs, 0);
 571                         if (*rhs)
 572                                 return 0;
 573                 }
 574                 else if (!strcmp(p, "umask")) {
 575                         if (!rhs || !*rhs)
 576                                 return 0;
 577                         *umask = simple_strtoul(rhs, &rhs, 8);
 578                         if (*rhs)
 579                                 return 0;
 580                 }
 581                 else if (!strcmp(p, "case")) {
 582                         if (!strcmp(rhs, "lower"))
 583                                 *lowercase = 1;
 584                         else if (!strcmp(rhs, "asis"))
 585                                 *lowercase = 0;
 586                         else
 587                                 return 0;
 588                 }
 589                 else if (!strcmp(p, "conv")) {
 590                         if (!strcmp(rhs, "binary"))
 591                                 *conv = CONV_BINARY;
 592                         else if (!strcmp(rhs, "text"))
 593                                 *conv = CONV_TEXT;
 594                         else if (!strcmp(rhs, "auto"))
 595                                 *conv = CONV_AUTO;
 596                         else
 597                                 return 0;
 598                 }
 599                 else
 600                         return 0;
 601         }
 602 
 603         return 1;
 604 }
 605 
 606 /*
 607  * read_inode.  This is called with exclusive access to a new inode that
 608  * has only (i_dev,i_ino) set.  It is responsible for filling in the rest.
 609  * We leave the dates blank, to be filled in from the dir entry.
 610  *
 611  * NOTE that there must be no sleeping from the return in this routine
 612  * until lookup() finishes filling in the inode, otherwise the partly
 613  * completed inode would be visible during the sleep.
 614  *
 615  * It is done in this strange and sinful way because the alternative
 616  * is to read the fnode, find the dir pointer in it, read that fnode
 617  * to get the dnode pointer, search through that whole directory for
 618  * the ino we're reading, and get the dates.  It works that way, but
 619  * ls sounds like fsck.
 620  */
 621 
 622 static void hpfs_read_inode(struct inode *inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 623 {
 624         struct super_block *s = inode->i_sb;
 625 
 626         /* be ready to bail out */
 627 
 628         inode->i_op = 0;
 629         inode->i_mode = 0;
 630 
 631         if (inode->i_ino == 0
 632             || ino_secno(inode->i_ino) >= inode->i_sb->s_hpfs_fs_size) {
 633                 printk("HPFS: read_inode: bad ino\n");
 634                 return;
 635         }
 636 
 637         /*
 638          * canned stuff
 639          */
 640 
 641         inode->i_uid = s->s_hpfs_uid;
 642         inode->i_gid = s->s_hpfs_gid;
 643         inode->i_mode = s->s_hpfs_mode;
 644         inode->i_hpfs_conv = s->s_hpfs_conv;
 645 
 646         inode->i_hpfs_dno = 0;
 647         inode->i_hpfs_n_secs = 0;
 648         inode->i_hpfs_file_sec = 0;
 649         inode->i_hpfs_disk_sec = 0;
 650         inode->i_hpfs_dpos = 0;
 651         inode->i_hpfs_dsubdno = 0;
 652 
 653         /*
 654          * figure out whether we are looking at a directory or a file
 655          */
 656 
 657         if (ino_is_dir(inode->i_ino))
 658                 inode->i_mode |= S_IFDIR;
 659         else {
 660                 inode->i_mode |= S_IFREG;
 661                 inode->i_mode &= ~0111;
 662         }
 663 
 664         /*
 665          * these fields must be filled in from the dir entry, which we don't
 666          * have but lookup does.  It will fill them in before letting the
 667          * inode out of its grasp.
 668          */
 669 
 670         inode->i_atime = 0;
 671         inode->i_mtime = 0;
 672         inode->i_ctime = 0;
 673         inode->i_size = 0;
 674 
 675         /*
 676          * fill in the rest
 677          */
 678 
 679         if (S_ISREG(inode->i_mode)) {
 680 
 681                 inode->i_op = (struct inode_operations *) &hpfs_file_iops;
 682                 inode->i_nlink = 1;
 683                 inode->i_blksize = 512;
 684 
 685         }
 686         else {
 687                 unsigned n_dnodes, n_subdirs;
 688                 struct buffer_head *bh0;
 689                 struct fnode *fnode = map_fnode(inode->i_dev,
 690                                                 inode->i_ino, &bh0);
 691 
 692                 if (!fnode) {
 693                         printk("HPFS: read_inode: no fnode\n");
 694                         inode->i_mode = 0;
 695                         return;
 696                 }
 697 
 698                 inode->i_hpfs_parent_dir = dir_ino(fnode->up);
 699                 inode->i_hpfs_dno = fnode->u.external[0].disk_secno;
 700 
 701                 brelse(bh0);
 702 
 703                 n_dnodes = n_subdirs = 0;
 704                 count_dnodes(inode, inode->i_hpfs_dno, &n_dnodes, &n_subdirs);
 705 
 706                 inode->i_op = (struct inode_operations *) &hpfs_dir_iops;
 707                 inode->i_blksize = 512; /* 2048 here confuses ls & du & ... */
 708                 inode->i_blocks = 4 * n_dnodes;
 709                 inode->i_size = 512 * inode->i_blocks;
 710                 inode->i_nlink = 2 + n_subdirs;
 711         }
 712 }
 713 
 714 /*
 715  * unmount.
 716  */
 717 
 718 static void hpfs_put_super(struct super_block *s)
     /* [previous][next][first][last][top][bottom][index][help] */
 719 {
 720         lock_super(s);
 721         s->s_dev = 0;
 722         unlock_super(s);
 723 }
 724 
 725 /*
 726  * statfs.  For free inode counts we report the count of dnodes in the
 727  * directory band -- not exactly right but pretty analogous.
 728  */
 729 
 730 static void hpfs_statfs(struct super_block *s, struct statfs *buf)
     /* [previous][next][first][last][top][bottom][index][help] */
 731 {
 732         /*
 733          * count the bits in the bitmaps, unless we already have
 734          */
 735 
 736         if (s->s_hpfs_n_free == -1) {
 737                 s->s_hpfs_n_free = count_bitmap(s);
 738                 s->s_hpfs_n_free_dnodes =
 739                     count_one_bitmap(s->s_dev, s->s_hpfs_dmap);
 740         }
 741 
 742         /*
 743          * fill in the user statfs struct
 744          */
 745 
 746         put_fs_long(s->s_magic, &buf->f_type);
 747         put_fs_long(512, &buf->f_bsize);
 748         put_fs_long(s->s_hpfs_fs_size, &buf->f_blocks);
 749         put_fs_long(s->s_hpfs_n_free, &buf->f_bfree);
 750         put_fs_long(s->s_hpfs_n_free, &buf->f_bavail);
 751         put_fs_long(s->s_hpfs_dirband_size, &buf->f_files);
 752         put_fs_long(s->s_hpfs_n_free_dnodes, &buf->f_ffree);
 753         put_fs_long(254, &buf->f_namelen);
 754 }
 755 
 756 /*
 757  * remount.  Don't let read only be turned off.
 758  */
 759 
 760 static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
     /* [previous][next][first][last][top][bottom][index][help] */
 761 {
 762         if (!(*flags & MS_RDONLY))
 763                 return -EINVAL;
 764         return 0;
 765 }
 766 
 767 /*
 768  * count the dnodes in a directory, and the subdirs.
 769  */
 770 
 771 static void count_dnodes(struct inode *inode, dnode_secno dno,
     /* [previous][next][first][last][top][bottom][index][help] */
 772                          unsigned *n_dnodes, unsigned *n_subdirs)
 773 {
 774         struct quad_buffer_head qbh;
 775         struct dnode *dnode;
 776         struct hpfs_dirent *de;
 777         struct hpfs_dirent *de_end;
 778 
 779         dnode = map_dnode(inode->i_dev, dno, &qbh);
 780         if (!dnode)
 781                 return;
 782         de = dnode_first_de(dnode);
 783         de_end = dnode_end_de(dnode);
 784 
 785         (*n_dnodes)++;
 786 
 787         for (; de < de_end; de = de_next_de(de)) {
 788                 if (de->down)
 789                         count_dnodes(inode, de_down_pointer(de),
 790                                      n_dnodes, n_subdirs);
 791                 if (de->directory && !de->first)
 792                         (*n_subdirs)++;
 793                 if (de->last || de->length == 0)
 794                         break;
 795         }
 796 
 797         brelse4(&qbh);
 798 }
 799 
 800 /*
 801  * count the bits in the free space bit maps
 802  */
 803 
 804 static unsigned count_bitmap(struct super_block *s)
     /* [previous][next][first][last][top][bottom][index][help] */
 805 {
 806         unsigned n, count, n_bands;
 807         secno *bitmaps;
 808         struct quad_buffer_head qbh;
 809 
 810         /*
 811          * there is one bit map for each 16384 sectors
 812          */
 813         n_bands = (s->s_hpfs_fs_size + 0x3fff) >> 14;
 814 
 815         /*
 816          * their locations are given in an array pointed to by the super
 817          * block
 818          */
 819         bitmaps = map_4sectors(s->s_dev, s->s_hpfs_bitmaps, &qbh);
 820         if (!bitmaps)
 821                 return 0;
 822 
 823         count = 0;
 824 
 825         /*
 826          * map each one and count the free sectors
 827          */
 828         for (n = 0; n < n_bands; n++)
 829                 if (bitmaps[n] == 0)
 830                         printk("HPFS: bit map pointer missing\n");
 831                 else
 832                         count += count_one_bitmap(s->s_dev, bitmaps[n]);
 833 
 834         brelse4(&qbh);
 835         return count;
 836 }
 837 
 838 /*
 839  * Read in one bit map, count the bits, return the count.
 840  */
 841 
 842 static unsigned count_one_bitmap(dev_t dev, secno secno)
     /* [previous][next][first][last][top][bottom][index][help] */
 843 {
 844         struct quad_buffer_head qbh;
 845         char *bits;
 846         unsigned i, count;
 847 
 848         bits = map_4sectors(dev, secno, &qbh);
 849         if (!bits)
 850                 return 0;
 851 
 852         count = 0;
 853 
 854         for (i = 0; i < 8 * 2048; i++)
 855                 count += (test_bit(i, bits) != 0);
 856         brelse4(&qbh);
 857 
 858         return count;
 859 }
 860 
 861 /* file ops */
 862 
 863 /*
 864  * read.  Read the bytes, put them in buf, return the count.
 865  */
 866 
 867 static int hpfs_file_read(struct inode *inode, struct file *filp,
     /* [previous][next][first][last][top][bottom][index][help] */
 868                           char *buf, int count)
 869 {
 870         unsigned q, r, n, n0;
 871         struct buffer_head *bh;
 872         char *block;
 873         char *start;
 874 
 875         if (inode == 0 || !S_ISREG(inode->i_mode))
 876                 return -EINVAL;
 877 
 878         /*
 879          * truncate count at EOF
 880          */
 881         if (count > inode->i_size - (off_t) filp->f_pos)
 882                 count = inode->i_size - filp->f_pos;
 883 
 884         start = buf;
 885         while (count > 0) {
 886                 /*
 887                  * get file sector number, offset in sector, length to end of
 888                  * sector
 889                  */
 890                 q = filp->f_pos >> 9;
 891                 r = filp->f_pos & 511;
 892                 n = 512 - r;
 893 
 894                 /*
 895                  * get length to copy to user buffer
 896                  */
 897                 if (n > count)
 898                         n = count;
 899 
 900                 /*
 901                  * read the sector, copy to user
 902                  */
 903                 block = map_sector(inode->i_dev, hpfs_bmap(inode, q), &bh);
 904                 if (!block)
 905                         return -EIO;
 906 
 907                 /*
 908                  * but first decide if it has \r\n, if the mount option said
 909                  * to do that
 910                  */
 911                 if (inode->i_hpfs_conv == CONV_AUTO)
 912                         inode->i_hpfs_conv = choose_conv(block + r, n);
 913 
 914                 if (inode->i_hpfs_conv == CONV_BINARY) {
 915                         /*
 916                          * regular copy, output length is same as input
 917                          * length
 918                          */
 919                         memcpy_tofs(buf, block + r, n);
 920                         n0 = n;
 921                 }
 922                 else {
 923                         /*
 924                          * squeeze out \r, output length varies
 925                          */
 926                         n0 = convcpy_tofs(buf, block + r, n);
 927                         if (count > inode->i_size - (off_t) filp->f_pos - n + n0)
 928                                 count = inode->i_size - filp->f_pos - n + n0;
 929                 }
 930 
 931                 brelse(bh);
 932 
 933                 /*
 934                  * advance input n bytes, output n0 bytes
 935                  */
 936                 filp->f_pos += n;
 937                 buf += n0;
 938                 count -= n0;
 939         }
 940 
 941         return buf - start;
 942 }
 943 
 944 /*
 945  * This routine implements conv=auto.  Return CONV_BINARY or CONV_TEXT.
 946  */
 947 
 948 static unsigned choose_conv(unsigned char *p, unsigned len)
     /* [previous][next][first][last][top][bottom][index][help] */
 949 {
 950         unsigned tvote, bvote;
 951         unsigned c;
 952 
 953         tvote = bvote = 0;
 954 
 955         while (len--) {
 956                 c = *p++;
 957                 if (c < ' ')
 958                         if (c == '\r' && len && *p == '\n')
 959                                 tvote += 10;
 960                         else if (c == '\t' || c == '\n');
 961                         else
 962                                 bvote += 5;
 963                 else if (c < '\177')
 964                         tvote++;
 965                 else
 966                         bvote += 5;
 967         }
 968 
 969         if (tvote > bvote)
 970                 return CONV_TEXT;
 971         else
 972                 return CONV_BINARY;
 973 }
 974 
 975 /*
 976  * This routine implements conv=text.  :s/crlf/nl/
 977  */
 978 
 979 static unsigned convcpy_tofs(unsigned char *out, unsigned char *in,
     /* [previous][next][first][last][top][bottom][index][help] */
 980                              unsigned len)
 981 {
 982         unsigned char *start = out;
 983 
 984         while (len--) {
 985                 unsigned c = *in++;
 986                 if (c == '\r' && (len == 0 || *in == '\n'));
 987                 else
 988                         put_fs_byte(c, out++);
 989         }
 990 
 991         return out - start;
 992 }
 993 
 994 /*
 995  * Return the disk sector number containing a file sector.
 996  */
 997 
 998 static secno hpfs_bmap(struct inode *inode, unsigned file_secno)
     /* [previous][next][first][last][top][bottom][index][help] */
 999 {
1000         unsigned n, disk_secno;
1001         struct fnode *fnode;
1002         struct buffer_head *bh;
1003 
1004         /*
1005          * There is one sector run cached in the inode. See if the sector is
1006          * in it.
1007          */
1008 
1009         n = file_secno - inode->i_hpfs_file_sec;
1010         if (n < inode->i_hpfs_n_secs)
1011                 return inode->i_hpfs_disk_sec + n;
1012 
1013         /*
1014          * No, read the fnode and go find the sector.
1015          */
1016 
1017         else {
1018                 fnode = map_fnode(inode->i_dev, inode->i_ino, &bh);
1019                 if (!fnode)
1020                         return 0;
1021                 disk_secno = bplus_lookup(inode, &fnode->btree,
1022                                           file_secno, &bh);
1023                 brelse(bh);
1024                 return disk_secno;
1025         }
1026 }
1027 
1028 /*
1029  * Search allocation tree *b for the given file sector number and return
1030  * the disk sector number.  Buffer *bhp has the tree in it, and can be
1031  * reused for subtrees when access to *b is no longer needed.
1032  * *bhp is busy on entry and exit. 
1033  */
1034 
1035 static secno bplus_lookup(struct inode *inode, struct bplus_header *b,
     /* [previous][next][first][last][top][bottom][index][help] */
1036                           secno file_secno, struct buffer_head **bhp)
1037 {
1038         int i;
1039 
1040         /*
1041          * A leaf-level tree gives a list of sector runs.  Find the one
1042          * containing the file sector we want, cache the map info in the
1043          * inode for later, and return the corresponding disk sector.
1044          */
1045 
1046         if (!b->internal) {
1047                 struct bplus_leaf_node *n = b->u.external;
1048                 for (i = 0; i < b->n_used_nodes; i++) {
1049                         unsigned t = file_secno - n[i].file_secno;
1050                         if (t < n[i].length) {
1051                                 inode->i_hpfs_file_sec = n[i].file_secno;
1052                                 inode->i_hpfs_disk_sec = n[i].disk_secno;
1053                                 inode->i_hpfs_n_secs = n[i].length;
1054                                 return n[i].disk_secno + t;
1055                         }
1056                 }
1057         }
1058 
1059         /*
1060          * A non-leaf tree gives a list of subtrees.  Find the one containing
1061          * the file sector we want, read it in, and recurse to search it.
1062          */
1063 
1064         else {
1065                 struct bplus_internal_node *n = b->u.internal;
1066                 for (i = 0; i < b->n_used_nodes; i++) {
1067                         if (file_secno < n[i].file_secno) {
1068                                 struct anode *anode;
1069                                 anode_secno ano = n[i].down;
1070                                 brelse(*bhp);
1071                                 anode = map_anode(inode->i_dev, ano, bhp);
1072                                 if (!anode)
1073                                         break;
1074                                 return bplus_lookup(inode, &anode->btree,
1075                                                     file_secno, bhp);
1076                         }
1077                 }
1078         }
1079 
1080         /*
1081          * If we get here there was a hole in the file.  As far as I know we
1082          * never do get here, but falling off the end would be indelicate. So
1083          * return a pointer to a handy all-zero sector.  This is not a
1084          * reasonable way to handle files with holes if they really do
1085          * happen.
1086          */
1087 
1088         printk("HPFS: bplus_lookup: sector not found\n");
1089         return 15;
1090 }
1091 
1092 /* directory ops */
1093 
1094 /*
1095  * lookup.  Search the specified directory for the specified name, set
1096  * *result to the corresponding inode.
1097  *
1098  * lookup uses the inode number to tell read_inode whether it is reading
1099  * the inode of a directory or a file -- file ino's are odd, directory
1100  * ino's are even.  read_inode avoids i/o for file inodes; everything
1101  * needed is up here in the directory.  (And file fnodes are out in
1102  * the boondocks.)
1103  */
1104 
1105 static int hpfs_lookup(struct inode *dir, const char *name, int len,
     /* [previous][next][first][last][top][bottom][index][help] */
1106                        struct inode **result)
1107 {
1108         struct quad_buffer_head qbh;
1109         struct hpfs_dirent *de;
1110         struct inode *inode;
1111         ino_t ino;
1112 
1113         /* In case of madness */
1114 
1115         *result = 0;
1116         if (dir == 0)
1117                 return -ENOENT;
1118         if (!S_ISDIR(dir->i_mode))
1119                 goto bail;
1120 
1121         /*
1122          * Read in the directory entry. "." is there under the name ^A^A .
1123          * Always read the dir even for . and .. in case we need the dates.
1124          */
1125 
1126         if (name[0] == '.' && len == 1)
1127                 de = map_dirent(dir, dir->i_hpfs_dno, "\001\001", 2, &qbh);
1128         else if (name[0] == '.' && name[1] == '.' && len == 2)
1129                 de = map_dirent(dir,
1130                                 fnode_dno(dir->i_dev, dir->i_hpfs_parent_dir),
1131                                 "\001\001", 2, &qbh);
1132         else
1133                 de = map_dirent(dir, dir->i_hpfs_dno, name, len, &qbh);
1134 
1135         /*
1136          * This is not really a bailout, just means file not found.
1137          */
1138 
1139         if (!de)
1140                 goto bail;
1141 
1142         /*
1143          * Get inode number, what we're after.
1144          */
1145 
1146         if (de->directory)
1147                 ino = dir_ino(de->fnode);
1148         else
1149                 ino = file_ino(de->fnode);
1150 
1151         /*
1152          * Go find or make an inode.
1153          */
1154 
1155         if (!(inode = iget(dir->i_sb, ino)))
1156                 goto bail1;
1157 
1158         /*
1159          * Fill in the info from the directory if this is a newly created
1160          * inode.
1161          */
1162 
1163         if (!inode->i_atime) {
1164                 inode->i_atime = local_to_gmt(de->read_date);
1165                 inode->i_mtime = local_to_gmt(de->write_date);
1166                 inode->i_ctime = local_to_gmt(de->creation_date);
1167                 if (de->read_only)
1168                         inode->i_mode &= ~0222;
1169                 if (!de->directory) {
1170                         inode->i_size = de->file_size;
1171                         /*
1172                          * i_blocks should count the fnode and any anodes.
1173                          * We count 1 for the fnode and don't bother about
1174                          * anodes -- the disk heads are on the directory band
1175                          * and we want them to stay there.
1176                          */
1177                         inode->i_blocks = 1 + ((inode->i_size + 511) >> 9);
1178                 }
1179         }
1180 
1181         brelse4(&qbh);
1182 
1183         /*
1184          * Made it.
1185          */
1186 
1187         *result = inode;
1188         iput(dir);
1189         return 0;
1190 
1191         /*
1192          * Didn't.
1193          */
1194  bail1:
1195         brelse4(&qbh);
1196  bail:
1197         iput(dir);
1198         return -ENOENT;
1199 }
1200 
1201 /*
1202  * Compare two counted strings ignoring case.
1203  * HPFS directory order sorts letters as if they're upper case.
1204  */
1205 
1206 static inline int memcasecmp(const unsigned char *s1, const unsigned char *s2,
     /* [previous][next][first][last][top][bottom][index][help] */
1207                              unsigned n)
1208 {
1209         int t;
1210 
1211         if (n != 0)
1212                 do {
1213                         unsigned c1 = linux_char_to_upper_linux (*s1++);
1214                         unsigned c2 = hpfs_char_to_upper_linux (*s2++);
1215                         if ((t = c1 - c2) != 0)
1216                                 return t;
1217                 } while (--n != 0);
1218 
1219         return 0;
1220 }
1221 
1222 /*
1223  * Search a directory for the given name, return a pointer to its dir entry
1224  * and a pointer to the buffer containing it.
1225  */
1226 
1227 static struct hpfs_dirent *map_dirent(struct inode *inode, dnode_secno dno,
     /* [previous][next][first][last][top][bottom][index][help] */
1228                                       const unsigned char *name, unsigned len,
1229                                       struct quad_buffer_head *qbh)
1230 {
1231         struct dnode *dnode;
1232         struct hpfs_dirent *de;
1233         struct hpfs_dirent *de_end;
1234         int t, l;
1235 
1236         /*
1237          * read the dnode at the root of our subtree
1238          */
1239         dnode = map_dnode(inode->i_dev, dno, qbh);
1240         if (!dnode)
1241                 return 0;
1242 
1243         /*
1244          * get pointers to start and end+1 of dir entries
1245          */
1246         de = dnode_first_de(dnode);
1247         de_end = dnode_end_de(dnode);
1248 
1249         /*
1250          * look through the entries for the name we're after
1251          */
1252         for ( ; de < de_end; de = de_next_de(de)) {
1253 
1254                 /*
1255                  * compare names
1256                  */
1257                 l = len < de->namelen ? len : de->namelen;
1258                 t = memcasecmp(name, de->name, l);
1259 
1260                 /*
1261                  * initial substring matches, compare lengths
1262                  */
1263                 if (t == 0) {
1264                         t = len - de->namelen;
1265                         /* bingo */
1266                         if (t == 0)
1267                                 return de;
1268                 }
1269 
1270                 /*
1271                  * wanted name .lt. dir name => not present.
1272                  */
1273                 if (t < 0) {
1274                         /*
1275                          * if there is a subtree, search it.
1276                          */
1277                         if (de->down) {
1278                                 dnode_secno sub_dno = de_down_pointer(de);
1279                                 brelse4(qbh);
1280                                 return map_dirent(inode, sub_dno,
1281                                                   name, len, qbh);
1282                         }
1283                         else
1284                                 break;
1285                 }
1286 
1287                 /*
1288                  * de->last is set on the last name in the dnode (it's always
1289                  * a "\377" pseudo entry).  de->length == 0 means we're about
1290                  * to infinite loop. This test does nothing in a well-formed
1291                  * dnode.
1292                  */
1293                 if (de->last || de->length == 0)
1294                         break;
1295         }
1296 
1297         /*
1298          * name not found.
1299          */
1300 
1301         return 0;
1302 }
1303 
1304 /*
1305  * readdir.  Return exactly 1 dirent.  (I tried and tried, but currently
1306  * the interface with libc just does not permit more than 1.  If it gets
1307  * fixed, throw this out and just walk the tree and write records into
1308  * the user buffer.)
1309  *
1310  * We keep track of our position in the dnode tree with a sort of
1311  * dewey-decimal record of subtree locations.  Like so:
1312  *
1313  *   (1 (1.1 1.2 1.3) 2 3 (3.1 (3.1.1 3.1.2) 3.2 3.3 (3.3.1)) 4)
1314  *
1315  * Subtrees appear after their file, out of lexical order,
1316  * which would be before their file.  It's easier.
1317  *
1318  * A directory can't hold more than 56 files, so 6 bits are used for
1319  * position numbers.  If the tree is so deep that the position encoding
1320  * doesn't fit, I'm sure something absolutely fascinating happens.
1321  *
1322  * The actual sequence of f_pos values is
1323  *     0 => .   -1 => ..   1 1.1 ... 8.9 9 => files  -2 => eof
1324  *
1325  * The directory inode caches one position-to-dnode correspondence so
1326  * we won't have to repeatedly scan the top levels of the tree. 
1327  */
1328 
1329 static int hpfs_readdir(struct inode *inode, struct file *filp,
     /* [previous][next][first][last][top][bottom][index][help] */
1330                         struct dirent *dirent, int likely_story)
1331 {
1332         struct quad_buffer_head qbh;
1333         struct hpfs_dirent *de;
1334         int namelen, lc;
1335         ino_t ino;
1336 
1337         if (inode == 0
1338             || inode->i_sb == 0
1339             || !S_ISDIR(inode->i_mode))
1340                 return -EBADF;
1341 
1342         lc = inode->i_sb->s_hpfs_lowercase;
1343 
1344         switch ((off_t) filp->f_pos) {
1345         case 0:
1346                 write_one_dirent(dirent, ".", 1, inode->i_ino, lc);
1347                 filp->f_pos = -1;
1348                 return ROUND_UP(NAME_OFFSET(dirent) + 2);
1349 
1350         case -1:
1351                 write_one_dirent(dirent, "..", 2,
1352                                  inode->i_hpfs_parent_dir, lc);
1353                 filp->f_pos = 1;
1354                 return ROUND_UP(NAME_OFFSET(dirent) + 3);
1355 
1356         case -2:
1357                 return 0;
1358 
1359         default:
1360                 de = map_pos_dirent(inode, &filp->f_pos, &qbh);
1361                 if (!de) {
1362                         filp->f_pos = -2;
1363                         return 0;
1364                 }
1365 
1366                 namelen = de->namelen;
1367                 if (de->directory)
1368                         ino = dir_ino(de->fnode);
1369                 else
1370                         ino = file_ino(de->fnode);
1371                 write_one_dirent(dirent, de->name, namelen, ino, lc);
1372                 brelse4(&qbh);
1373 
1374                 return ROUND_UP(NAME_OFFSET(dirent) + namelen + 1);
1375         }
1376 }
1377 
1378 /*
1379  * Send the given name and ino off to the user dirent struct at *dirent.
1380  * Blam it to lowercase if the mount option said to.
1381  *
1382  * Note that Linux d_reclen is the length of the file name, and has nothing
1383  * to do with the length of the dirent record.
1384  */
1385 
1386 static void write_one_dirent(struct dirent *dirent, const unsigned char *name,
     /* [previous][next][first][last][top][bottom][index][help] */
1387                              unsigned namelen, ino_t ino, int lowercase)
1388 {
1389         unsigned n;
1390 
1391         put_fs_long(ino, &dirent->d_ino);
1392         put_fs_word(namelen, &dirent->d_reclen);
1393 
1394         for (n = namelen; n != 0;) {
1395                 unsigned t = name[--n];
1396                 if (lowercase)
1397                         t = hpfs_char_to_lower_linux (t);
1398                 else
1399                         t = hpfs_char_to_linux (t);
1400                 put_fs_byte(t, &dirent->d_name[n]);
1401         }
1402 
1403         put_fs_byte(0, &dirent->d_name[namelen]);
1404 }
1405 
1406 /*
1407  * Map the dir entry at subtree coordinates given by *posp, and
1408  * increment *posp to point to the following dir entry. 
1409  */
1410 
1411 static struct hpfs_dirent *map_pos_dirent(struct inode *inode, loff_t *posp,
     /* [previous][next][first][last][top][bottom][index][help] */
1412                                           struct quad_buffer_head *qbh)
1413 {
1414         unsigned pos, q, r;
1415         dnode_secno dno;
1416         struct hpfs_dirent *de;
1417 
1418         /*
1419          * Get the position code and split off the rightmost index r
1420          */
1421 
1422         pos = *posp;
1423         q = pos >> 6;
1424         r = pos & 077;
1425 
1426         /*
1427          * Get the sector address of the dnode
1428          * pointed to by the leading part q
1429          */
1430 
1431         dno = dir_subdno(inode, q);
1432         if (!dno)
1433                 return 0;
1434 
1435         /*
1436          * Get the entry at index r in dnode q
1437          */
1438 
1439         de = map_nth_dirent(inode->i_dev, dno, r, qbh);
1440 
1441         /*
1442          * If none, we're out of files in this dnode.  Ascend.
1443          */
1444 
1445         if (!de) {
1446                 if (q == 0)
1447                         return 0;
1448                 *posp = q + 1;
1449                 return map_pos_dirent(inode, posp, qbh);
1450         }
1451 
1452         /*
1453          * If a subtree is here, descend.
1454          */
1455 
1456         if (de->down)
1457                 *posp = pos << 6 | 1;
1458         else
1459                 *posp = pos + 1;
1460 
1461         /*
1462          * Don't return the ^A^A and \377 entries.
1463          */
1464 
1465         if (de->first || de->last) {
1466                 brelse4(qbh);
1467                 return map_pos_dirent(inode, posp, qbh);
1468         }
1469         else
1470                 return de;
1471 }
1472 
1473 /*
1474  * Return the address of the dnode with subtree coordinates given by pos.
1475  */
1476 
1477 static dnode_secno dir_subdno(struct inode *inode, unsigned pos)
     /* [previous][next][first][last][top][bottom][index][help] */
1478 {
1479         struct hpfs_dirent *de;
1480         struct quad_buffer_head qbh;
1481 
1482         /*
1483          * 0 is the root dnode
1484          */
1485 
1486         if (pos == 0)
1487                 return inode->i_hpfs_dno;
1488 
1489         /*
1490          * we have one pos->dnode translation cached in the inode
1491          */
1492 
1493         else if (pos == inode->i_hpfs_dpos)
1494                 return inode->i_hpfs_dsubdno;
1495 
1496         /*
1497          * otherwise go look
1498          */
1499 
1500         else {
1501                 unsigned q = pos >> 6;
1502                 unsigned r = pos & 077;
1503                 dnode_secno dno;
1504 
1505                 /*
1506                  * dnode at position q
1507                  */
1508                 dno = dir_subdno(inode, q);
1509                 if (dno == 0)
1510                         return 0;
1511 
1512                 /*
1513                  * entry at index r
1514                  */
1515                 de = map_nth_dirent(inode->i_dev, dno, r, &qbh);
1516                 if (!de || !de->down)
1517                         return 0;
1518 
1519                 /*
1520                  * get the dnode down pointer
1521                  */
1522                 dno = de_down_pointer(de);
1523                 brelse4(&qbh);
1524 
1525                 /*
1526                  * cache it for next time
1527                  */
1528                 inode->i_hpfs_dpos = pos;
1529                 inode->i_hpfs_dsubdno = dno;
1530                 return dno;
1531         }
1532 }
1533 
1534 /*
1535  * Return the dir entry at index n in dnode dno, or 0 if there isn't one
1536  */
1537 
1538 static struct hpfs_dirent *map_nth_dirent(dev_t dev, dnode_secno dno,
     /* [previous][next][first][last][top][bottom][index][help] */
1539                                           int n,
1540                                           struct quad_buffer_head *qbh)
1541 {
1542         int i;
1543         struct hpfs_dirent *de, *de_end;
1544         struct dnode *dnode = map_dnode(dev, dno, qbh);
1545 
1546         de = dnode_first_de(dnode);
1547         de_end = dnode_end_de(dnode);
1548 
1549         for (i = 1; de < de_end; i++, de = de_next_de(de)) {
1550                 if (i == n)
1551                         return de;
1552                 if (de->last || de->length == 0)
1553                         break;
1554         }
1555 
1556         brelse4(qbh);
1557         return 0;
1558 }
1559 
1560 static int hpfs_dir_read(struct inode *inode, struct file *filp,
     /* [previous][next][first][last][top][bottom][index][help] */
1561                          char *buf, int count)
1562 {
1563         return -EISDIR;
1564 }
1565 
1566 /* Return the dnode pointer in a directory fnode */
1567 
1568 static dnode_secno fnode_dno(dev_t dev, ino_t ino)
     /* [previous][next][first][last][top][bottom][index][help] */
1569 {
1570         struct buffer_head *bh;
1571         struct fnode *fnode;
1572         dnode_secno dno;
1573 
1574         fnode = map_fnode(dev, ino, &bh);
1575         if (!fnode)
1576                 return 0;
1577 
1578         dno = fnode->u.external[0].disk_secno;
1579         brelse(bh);
1580         return dno;
1581 }
1582 
1583 /* Map an fnode into a buffer and return pointers to it and to the buffer. */
1584 
1585 static struct fnode *map_fnode(dev_t dev, ino_t ino, struct buffer_head **bhp)
     /* [previous][next][first][last][top][bottom][index][help] */
1586 {
1587         struct fnode *fnode;
1588 
1589         if (ino == 0) {
1590                 printk("HPFS: missing fnode\n");
1591                 return 0;
1592         }
1593 
1594         fnode = map_sector(dev, ino_secno(ino), bhp);
1595         if (fnode)
1596                 if (fnode->magic != FNODE_MAGIC) {
1597                         printk("HPFS: map_fnode: bad fnode pointer\n");
1598                         brelse(*bhp);
1599                         return 0;
1600                 }
1601         return fnode;
1602 }
1603 
1604 /* Map an anode into a buffer and return pointers to it and to the buffer. */
1605 
1606 static struct anode *map_anode(dev_t dev, unsigned secno,
     /* [previous][next][first][last][top][bottom][index][help] */
1607                                struct buffer_head **bhp)
1608 {
1609         struct anode *anode;
1610 
1611         if (secno == 0) {
1612                 printk("HPFS: missing anode\n");
1613                 return 0;
1614         }
1615 
1616         anode = map_sector(dev, secno, bhp);
1617         if (anode)
1618                 if (anode->magic != ANODE_MAGIC || anode->self != secno) {
1619                         printk("HPFS: map_anode: bad anode pointer\n");
1620                         brelse(*bhp);
1621                         return 0;
1622                 }
1623         return anode;
1624 }
1625 
1626 /* Map a dnode into a buffer and return pointers to it and to the buffer. */
1627 
1628 static struct dnode *map_dnode(dev_t dev, unsigned secno,
     /* [previous][next][first][last][top][bottom][index][help] */
1629                                struct quad_buffer_head *qbh)
1630 {
1631         struct dnode *dnode;
1632 
1633         if (secno == 0) {
1634                 printk("HPFS: missing dnode\n");
1635                 return 0;
1636         }
1637 
1638         dnode = map_4sectors(dev, secno, qbh);
1639         if (dnode)
1640                 if (dnode->magic != DNODE_MAGIC || dnode->self != secno) {
1641                         printk("HPFS: map_dnode: bad dnode pointer\n");
1642                         brelse4(qbh);
1643                         return 0;
1644                 }
1645         return dnode;
1646 }
1647 
1648 /* Map a sector into a buffer and return pointers to it and to the buffer. */
1649 
1650 static void *map_sector(dev_t dev, unsigned secno, struct buffer_head **bhp)
     /* [previous][next][first][last][top][bottom][index][help] */
1651 {
1652         struct buffer_head *bh;
1653 
1654         if ((*bhp = bh = bread(dev, secno, 512)) != 0)
1655                 return bh->b_data;
1656         else {
1657                 printk("HPFS: map_sector: read error\n");
1658                 return 0;
1659         }
1660 }
1661 
1662 /* Map 4 sectors into a 4buffer and return pointers to it and to the buffer. */
1663 
1664 static void *map_4sectors(dev_t dev, unsigned secno,
     /* [previous][next][first][last][top][bottom][index][help] */
1665                           struct quad_buffer_head *qbh)
1666 {
1667         struct buffer_head *bh;
1668         char *data;
1669 
1670         if (secno & 3) {
1671                 printk("HPFS: map_4sectors: unaligned read\n");
1672                 return 0;
1673         }
1674 
1675         qbh->data = data = kmalloc(2048, GFP_KERNEL);
1676         if (!data)
1677                 goto bail;
1678 
1679         qbh->bh[0] = bh = breada(dev, secno, 512, 0, UINT_MAX);
1680         if (!bh)
1681                 goto bail0;
1682         memcpy(data, bh->b_data, 512);
1683 
1684         qbh->bh[1] = bh = bread(dev, secno + 1, 512);
1685         if (!bh)
1686                 goto bail1;
1687         memcpy(data + 512, bh->b_data, 512);
1688 
1689         qbh->bh[2] = bh = bread(dev, secno + 2, 512);
1690         if (!bh)
1691                 goto bail2;
1692         memcpy(data + 2 * 512, bh->b_data, 512);
1693 
1694         qbh->bh[3] = bh = bread(dev, secno + 3, 512);
1695         if (!bh)
1696                 goto bail3;
1697         memcpy(data + 3 * 512, bh->b_data, 512);
1698 
1699         return data;
1700 
1701  bail3:
1702         brelse(qbh->bh[2]);
1703  bail2:
1704         brelse(qbh->bh[1]);
1705  bail1:
1706         brelse(qbh->bh[0]);
1707  bail0:
1708         kfree_s(data, 2048);
1709  bail:
1710         printk("HPFS: map_4sectors: read error\n");
1711         return 0;
1712 }
1713 
1714 /* Deallocate a 4-buffer block */
1715 
1716 static void brelse4(struct quad_buffer_head *qbh)
     /* [previous][next][first][last][top][bottom][index][help] */
1717 {
1718         brelse(qbh->bh[3]);
1719         brelse(qbh->bh[2]);
1720         brelse(qbh->bh[1]);
1721         brelse(qbh->bh[0]);
1722         kfree_s(qbh->data, 2048);
1723 }

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