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