home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / hpfslinx.zip / hpfs-lnx.pat < prev    next >
Text File  |  1993-10-11  |  64KB  |  2,006 lines
  1. diff -rc2N linux-dist/config.in linux/config.in
  2. *** linux-dist/config.in    Fri Sep 17 14:00:40 1993
  3. --- linux/config.in    Sun Oct 10 12:17:35 1993
  4. ***************
  5. *** 79,82 ****
  6. --- 79,83 ----
  7.   bool 'NFS filesystem support' CONFIG_NFS_FS y
  8.   bool 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS n
  9. + bool 'OS/2 HPFS filesystem support' CONFIG_HPFS_FS n
  10.   *
  11.   *  character devices
  12. diff -rc2N linux-dist/fs/Makefile linux/fs/Makefile
  13. *** linux-dist/fs/Makefile    Fri Aug 20 08:59:30 1993
  14. --- linux/fs/Makefile    Sun Oct 10 12:17:35 1993
  15. ***************
  16. *** 8,12 ****
  17.   # Note 2! The CFLAGS definitions are now in the main makefile...
  18.   
  19. ! SUBDIRS = minix ext ext2 msdos proc isofs nfs xiafs
  20.   
  21.   ifdef CONFIG_MINIX_FS
  22. --- 8,12 ----
  23.   # Note 2! The CFLAGS definitions are now in the main makefile...
  24.   
  25. ! SUBDIRS = minix ext ext2 msdos proc isofs nfs xiafs hpfs
  26.   
  27.   ifdef CONFIG_MINIX_FS
  28. ***************
  29. *** 33,36 ****
  30. --- 33,39 ----
  31.   ifdef CONFIG_XIA_FS
  32.   FS_SUBDIRS := $(FS_SUBDIRS) xiafs
  33. + endif
  34. + ifdef CONFIG_HPFS_FS
  35. + FS_SUBDIRS := $(FS_SUBDIRS) hpfs
  36.   endif
  37.   
  38. diff -rc2N linux-dist/fs/filesystems.c linux/fs/filesystems.c
  39. *** linux-dist/fs/filesystems.c    Sun Apr  4 07:08:51 1993
  40. --- linux/fs/filesystems.c    Sun Oct 10 12:17:35 1993
  41. ***************
  42. *** 33,36 ****
  43. --- 33,39 ----
  44.   #include <linux/iso_fs.h>
  45.   #endif
  46. + #ifdef CONFIG_HPFS_FS
  47. + #include <linux/hpfs_fs.h>
  48. + #endif
  49.   
  50.   struct file_system_type file_systems[] = {
  51. ***************
  52. *** 58,61 ****
  53. --- 61,67 ----
  54.   #ifdef CONFIG_ISO9660_FS
  55.       {isofs_read_super,    "iso9660",    1},
  56. + #endif
  57. + #ifdef CONFIG_HPFS_FS
  58. +     {hpfs_read_super,    "hpfs",        1},
  59.   #endif
  60.       {NULL,            NULL,        0}
  61. diff -rc2N linux-dist/fs/hpfs/Makefile linux/fs/hpfs/Makefile
  62. *** linux-dist/fs/hpfs/Makefile
  63. --- linux/fs/hpfs/Makefile    Sun Oct 10 12:18:35 1993
  64. ***************
  65. *** 0 ****
  66. --- 1,33 ----
  67. + #
  68. + # Makefile for the linux HPFS filesystem routines.
  69. + #
  70. + # Note! Dependencies are done automagically by 'make dep', which also
  71. + # removes any old dependencies. DON'T put your own dependencies here
  72. + # unless it's something special (ie not a .c file).
  73. + #
  74. + # Note 2! The CFLAGS definitions are now in the main makefile...
  75. + 
  76. + .c.s:
  77. +     $(CC) $(CFLAGS) -S $<
  78. + .c.o:
  79. +     $(CC) $(CFLAGS) -c $<
  80. + .s.o:
  81. +     $(AS) -o $*.o $<
  82. + 
  83. + OBJS=    hpfs_fs.o
  84. + 
  85. + hpfs.o: $(OBJS)
  86. +     ln -f hpfs_fs.o hpfs.o
  87. + 
  88. + clean:
  89. +     rm -f core *.o *.a *.s
  90. + 
  91. + dep:
  92. +     $(CPP) -M *.c > .depend
  93. + 
  94. + #
  95. + # include a dependency file if one exists
  96. + #
  97. + ifeq (.depend,$(wildcard .depend))
  98. + include .depend
  99. + endif
  100. diff -rc2N linux-dist/fs/hpfs/hpfs.h linux/fs/hpfs/hpfs.h
  101. *** linux-dist/fs/hpfs/hpfs.h
  102. --- linux/fs/hpfs/hpfs.h    Sun Oct 10 12:17:36 1993
  103. ***************
  104. *** 0 ****
  105. --- 1,383 ----
  106. + /* The article
  107. + 
  108. +      Duncan, Roy
  109. +      Design goals and implementation of the new High Performance File System
  110. +      Microsoft Systems Journal  Sept 1989  v4 n5 p1(13)
  111. + 
  112. +    describes what HPFS looked like when it was new, and it is the source
  113. +    of most of the information given here.  The rest is conjecture.
  114. + 
  115. +    For definitive information on the Duncan article, see it, not this file.
  116. +    For definitive information on HPFS, ask somebody else -- this is guesswork.
  117. +    There are certain to be many mistakes. */
  118. + 
  119. + /* Notation */
  120. + 
  121. + typedef unsigned secno;            /* sector number, partition relative */
  122. + 
  123. + typedef secno dnode_secno;        /* sector number of a dnode */
  124. + typedef secno fnode_secno;        /* sector number of an fnode */
  125. + typedef secno anode_secno;        /* sector number of an anode */
  126. + 
  127. + 
  128. + /* sector 0 */
  129. + 
  130. + /* The boot block is very like a FAT boot block, except that the
  131. +    29h signature byte is 28h instead, and the sig string is "HPFS". */
  132. + 
  133. + struct hpfs_boot_block
  134. + {
  135. +   unsigned char jmp[3];
  136. +   unsigned char oem_id[8];
  137. +   unsigned char bytes_per_sector[2];    /* 512 */
  138. +   unsigned char sectors_per_cluster;
  139. +   unsigned char n_reserved_sectors[2];
  140. +   unsigned char n_fats;
  141. +   unsigned char n_rootdir_entries[2];
  142. +   unsigned char n_sectors_s[2];
  143. +   unsigned char media_byte;
  144. +   unsigned short sectors_per_fat;
  145. +   unsigned short sectors_per_track;
  146. +   unsigned short heads_per_cyl;
  147. +   unsigned int n_hidden_sectors;
  148. +   unsigned int n_sectors_l;        /* size of partition */
  149. +   unsigned char drive_number;
  150. +   unsigned char mbz;
  151. +   unsigned char sig_28h;        /* 28h */
  152. +   unsigned char vol_serno[4];
  153. +   unsigned char vol_label[11];
  154. +   unsigned char sig_hpfs[8];        /* "HPFS    " */
  155. +   unsigned char pad[450];
  156. + };
  157. + 
  158. + 
  159. + /* sector 10h */
  160. + 
  161. + /* The super block has the pointer to the root directory. */
  162. + 
  163. + #define SB_MAGIC 0xf995e849
  164. + 
  165. + struct hpfs_super_block
  166. + {
  167. +   unsigned magic;            /* f995 e849 */
  168. +   unsigned magic1;            /* fa53 e9c5, more magic? */
  169. +   unsigned huh202;            /* 202 ?? version number(s)?
  170. +                           sector size again?
  171. +                              dnode multiplier?
  172. +                           n_spare_dnodes? */
  173. +   fnode_secno root;            /* fnode of root directory */
  174. +   secno n_sectors;            /* size of filesystem */
  175. +   unsigned zero1;            /* 0 */
  176. +   secno huh4;                /* 14  ?? 4 sectors long, has pointer
  177. +                              to band0 free space bitmap
  178. +                           and many zeros */
  179. +   unsigned zero2;            /* 0 */
  180. +   secno huh6;                /* 1c  ?? 4 sectors long, all zeros.
  181. +                               bad block list? */
  182. +   unsigned zero3;            /* 0 */
  183. +   time_t last_chkdsk;            /* date last checked, 0 if never */
  184. +   unsigned zero4;            /* 0 */
  185. +   secno n_dir_band;            /* number of sectors in dir band */
  186. +   secno dir_band_start;            /* first sector in dir band */
  187. +   secno dir_band_end;            /* last sector in dir band */
  188. +   secno dir_band_bitmap;        /* free space map, 1 dnode per bit */
  189. +   unsigned zero5[8];            /* 0 */
  190. +   secno spare_dnodes;            /* ?? 8 preallocated sectors near dir
  191. +                        band.  the node splitting spares? */
  192. +   unsigned pad[103];            /* 0 */
  193. + };
  194. + 
  195. + 
  196. + /* sector 11h */
  197. + 
  198. + /* The spare block has pointers to spare sectors.  The following
  199. +    struct is more than usually conjectural, since my disks hide the
  200. +    existence of bad blocks.  */
  201. + 
  202. + #define SP_MAGIC 0xf9911849
  203. + 
  204. + struct hpfs_spare_block
  205. + {
  206. +   unsigned magic;            /* f991 1849 */
  207. +   unsigned magic1;            /* fa52 29c5, more magic? */
  208. +   unsigned dirty;            /* 0 clean, 1 "improperly stopped" */
  209. + 
  210. +   secno hotfix_map;            /* 20  ?? 4 sectors long, looks like
  211. +                                  secno from[n_spares];
  212. +                              secno to[n_spares];
  213. +                            the from array is all 0's,
  214. +                            the to array is initialized
  215. +                            to point to n_spares
  216. +                            preallocated empties */
  217. + 
  218. +   unsigned n_spares_used;        /* 0   ??? used spare count? */
  219. +   unsigned n_spares;            /* 64  ?? unused spare count?
  220. +                               total spare count? */
  221. +   unsigned n_dnode_spares_1;        /* 14  ??? 20 decimal */
  222. +   unsigned n_dnode_spares_2;        /* 14  ??? 20 decimal */
  223. +                     /*     the above 2 words are probably
  224. +                            the number of dnode spares and
  225. +                            the number of free ones. */
  226. + 
  227. +   secno weirdblock;            /* 88  ?? first of 2 peculiar blocks */
  228. +   unsigned n_weird;            /* 2   ?? number of peculiar blocks */
  229. +   unsigned hash1, hash2;        /*     ?? checksums of something? */
  230. + 
  231. +   unsigned zero1[19];            /* 0 */
  232. +   
  233. +   dnode_secno spares[20];        /* ?? spare dnodes? */
  234. +   unsigned zero3[20];            /* ?? other half of hotfix map? */
  235. +   unsigned zero2[57];            /* 0 */
  236. + };
  237. + 
  238. + /* The two peculiar blocks pointed to by the spare block stump me completely.
  239. +    They start with what look like magic numbers: */
  240. + 
  241. + #define BIZZ1_MAGIC 0x494521f7
  242. + #define BIZZ2_MAGIC 0x894521f7
  243. + 
  244. + /* They have many other numbers, equally magic.  The location of these
  245. +    blocks varies with the size of the filesystem, their contents
  246. +    doesn't.  The first block is constant except for a couple of
  247. +    pointers to the second block.  It is mostly zero.  The second block
  248. +    is constant, period.  It is fond of byte sequences like
  249. + 
  250. +        cfcecdcc cbcac9c8 c7c7c5c4 c3c2c1c0  060  ........ ........
  251. + 
  252. +    with some like
  253. + 
  254. +        9f9e9d9c 9d9a9959 ebeae399 e2929290  030  ........ Y.......
  255. +        
  256. +    but it isn't, e.g., a permutation of the low-numbered blocks in the
  257. +    partition.  It isn't a permutation at all.  It looks like two words
  258. +    followed by 200h bytes, the bytes being a variation on x[i] = i but
  259. +    with what may be word values stuck in here and there.  Heaven knows
  260. +    what it means, I just hope it's not important. */
  261. +        
  262. + 
  263. + /* Free space bitmaps are 4 sectors long, which is 16384 bits.
  264. +    16384 sectors is 8 meg, and each 8 meg band has a 4-sector bitmap.
  265. +    Bit order in the maps is little-endian.  0 means taken, 1 means free.
  266. + 
  267. +    Bit map sectors are marked allocated in the bit maps, and so are sectors 
  268. +    off the end of the partition.
  269. + 
  270. +    Band 0 is sectors 0-3fff, its map is in sectors 18-1b.
  271. +    Band 1 is 4000-7fff, its map is in 7ffc-7fff.
  272. +    Band 2 is 8000-ffff, its map is in 8000-8003.
  273. +    The remaining bands have maps in their first (even) or last (odd) 4 sectors
  274. +      -- if the last, partial, band is odd its map is in its last 4 sectors.
  275. +    What happens if the last band is < 4 sectors long I don't know.
  276. + 
  277. +    The band-0 bitmap at 18 is pointed to by the first word of sector 14,
  278. +    which is pointed to by the super block.  The remaining words of
  279. +    sector 14 don't point to the other bitmaps, though.  On a wild guess,
  280. +    the 4 sectors from 14-17 can point to alternate bitmap locations for
  281. +    bands 0-511.  Or maybe it's a table of offsets.
  282. + 
  283. +    The "directory band" is a bunch of sectors preallocated for dnodes.
  284. +    It has a 4-sector free space bitmap of its own.  Each bit in the map
  285. +    corresponds to one 4-sector dnode, bit 0 of the map corresponding to
  286. +    the first 4 sectors of the directory band.  The entire band is marked
  287. +    allocated in the main bitmap.   The super block gives the locations
  288. +    of the directory band and its bitmap.  ("band" doesn't mean it is
  289. +    8 meg long; it isn't.)  */
  290. + 
  291. + 
  292. + /* dnode: directory.  4 sectors long */
  293. + 
  294. + /* A directory is a tree of dnodes.  There is one pointer to the root of
  295. +    the tree, in the fnode for the directory.  Every dnode in the tree
  296. +    points up to this fnode, and the parent directory points down to it.
  297. +    The fnode never moves, the dnodes do the B-tree thing, splitting
  298. +    and merging as files are added and removed.  */
  299. + 
  300. + #define DNODE_MAGIC   0x77e40aae
  301. + 
  302. + struct dnode {
  303. +   unsigned magic;            /* 77e4 0aae */
  304. +   unsigned first_free;            /* offset to first free dirent */
  305. +   unsigned increment_me;        /* some kind of activity counter?
  306. +                        Neither HPFS.IFS nor CHKDSK cares
  307. +                        if you change this word */
  308. +   fnode_secno up;            /* fnode that points to directory's
  309. +                        root dnode */
  310. +   dnode_secno self;            /* pointer to this dnode */
  311. +   unsigned char dirent[2028];        /* one or more dirents */
  312. + };
  313. + 
  314. + struct hpfs_dirent {
  315. +   unsigned short length;        /* offset to next dirent */
  316. +   unsigned first: 1;            /* set on phony ^A^A (".") entry */
  317. +   unsigned flag1: 1;
  318. +   unsigned down: 1;            /* down pointer present (after name) */
  319. +   unsigned last: 1;            /* set on phony \377 entry */
  320. +   unsigned flag4: 1;
  321. +   unsigned flag5: 1;
  322. +   unsigned flag6: 1;
  323. +   unsigned flag7: 1;
  324. +   unsigned read_only: 1;        /* dos attrib */
  325. +   unsigned hidden: 1;            /* dos attrib */
  326. +   unsigned system: 1;            /* dos attrib */
  327. +   unsigned flag11: 1;            /* would be volume label dos attrib */
  328. +   unsigned directory: 1;        /* dos attrib */
  329. +   unsigned archive: 1;            /* dos attrib */
  330. +   unsigned not_8x3: 1;            /* name is not 8.3 */
  331. +   unsigned flag15: 1;
  332. +   fnode_secno fnode;            /* fnode giving allocation info */
  333. +   time_t creation_date;            /* ctime */
  334. +   unsigned file_size;            /* file length, bytes */
  335. +   time_t read_date;            /* atime */
  336. +   time_t write_date;            /* mtime */
  337. +   unsigned ea_size;            /* total EA length, bytes */
  338. +   unsigned char zero1;
  339. +   unsigned char locality;        /* ?? 0=unk 1=seq 2=random 3=both */
  340. +   unsigned char namelen, name[1];    /* file name */
  341. +   /* dnode_secno down;      btree down pointer, if present,
  342. +                    follows name on next word boundary, or maybe it's
  343. +               precedes next dirent, which is on a word boundary. */
  344. + };
  345. + 
  346. + 
  347. + /* B+ tree: allocation info in fnodes and anodes */
  348. + 
  349. + /* dnodes point to fnodes which are responsible for listing the sectors
  350. +    assigned to the file.  This is done with trees of (length,address)
  351. +    pairs.  (Triples, actually, of (length, file-address, disk-address)
  352. +    which can represent holes.  Find out if HPFS does that.)
  353. +    At any rate, fnodes contain a small tree; if subtrees are needed
  354. +    they occupy essentially a full block in anodes.  A leaf-level tree node
  355. +    has 3-word entries giving sector runs, a non-leaf node has 2-word
  356. +    entries giving subtree pointers.  A flag in the header says which. */
  357. + 
  358. + struct bplus_header
  359. + {
  360. +   unsigned flag0: 1;
  361. +   unsigned flag1: 1;
  362. +   unsigned flag2: 1;
  363. +   unsigned flag3: 1;
  364. +   unsigned flag4: 1;
  365. +   unsigned fnode_parent: 1;        /* ?? parent is an fnode?
  366. +                           A particularly silly flag, but
  367. +                           that seems to be it */
  368. +   unsigned flag6: 1;
  369. +   unsigned internal: 1;            /* 1 -> (internal) tree of anodes
  370. +                        0 -> (leaf) list of extents */
  371. +   unsigned char fill[3];
  372. +   unsigned char n_free_nodes;        /* free nodes in following array */
  373. +   unsigned char n_used_nodes;        /* used nodes in following array */
  374. +   unsigned short first_free;        /* offset from start of header to
  375. +                        first free node in array */
  376. +   /* union { internal[], leaf[] }; follows here */
  377. + };
  378. + 
  379. + struct bplus_internal_node
  380. + {
  381. +   unsigned file_secno;            /* subtree maps sectors < this  */
  382. +   anode_secno down;            /* pointer to subtree */
  383. + };
  384. + 
  385. + struct bplus_leaf_node
  386. + {
  387. +   unsigned file_secno;            /* first file sector in extent */
  388. +   unsigned length;            /* length, sectors */
  389. +   secno disk_secno;            /* first corresponding disk sector */
  390. + };
  391. + 
  392. + 
  393. + /* fnode: root of allocation b+ tree, and EA's */
  394. + 
  395. + /* Every file and every directory has one fnode, pointed to by the directory
  396. +    entry and pointing to the file's sectors or directory's root dnode.  EA's
  397. +    are also stored here, and there are said to be ACL's somewhere here too. */
  398. + 
  399. + #define FNODE_MAGIC 0xf7e40aae
  400. + 
  401. + struct fnode
  402. + {
  403. +   unsigned magic;            /* f7e4 0aae */
  404. +   unsigned zero1[2];
  405. +   unsigned char len, name[15];        /* true length, truncated name */
  406. +   fnode_secno up;            /* pointer to file's directory fnode */
  407. +   unsigned zero2[5];
  408. +   unsigned short ea_size;        /* length of fnode-resident ea's */
  409. +   unsigned char zero3;
  410. +   unsigned char dirflag;        /* 1 -> directory */
  411. +                     /* if set, first & only extent 
  412. +                        points to dnode. */
  413. + 
  414. +   struct bplus_header btree;        /* b+ tree, 8 extents or 12 subtrees */
  415. +   union {
  416. +     struct bplus_leaf_node external[8];
  417. +     struct bplus_internal_node internal[12];
  418. +   } u;
  419. + 
  420. +   unsigned file_size;            /* file length, bytes */
  421. +   unsigned zero4[5];
  422. +   unsigned huhc4;            /* c4  [ea's start at c4] */
  423. +   unsigned zero5[2];
  424. +   unsigned char ea[280];        /* zero or more EA's, packed on
  425. +                        byte boundaries */
  426. +                        
  427. +   unsigned zero6[9];
  428. + };
  429. + 
  430. + 
  431. + /* anode: 99.44% pure allocation tree */
  432. + 
  433. + #define ANODE_MAGIC 0x37e40aae
  434. + 
  435. + struct anode
  436. + {
  437. +   unsigned magic;            /* 37e4 0aae */
  438. +   anode_secno self;            /* pointer to this anode */
  439. +   secno up;                /* parent anode or fnode */
  440. + 
  441. +   struct bplus_header btree;        /* b+tree, 40 extents or 60 subtrees */
  442. +   union {
  443. +     struct bplus_leaf_node external[40];
  444. +     struct bplus_internal_node internal[60];
  445. +   } u;
  446. + 
  447. +   unsigned fill[2];            /* unused */
  448. + };
  449. + 
  450. + 
  451. + /* extended attribute in fnode */
  452. + 
  453. + struct fnode_ea {
  454. +   unsigned indirect: 1;            /* 1 -> value gives sector number
  455. +                        where real value starts */
  456. +   unsigned flag1: 1;            /* user flag, I think */
  457. +   unsigned flag2: 1;            /* user flag, I think */
  458. +   unsigned flag3: 1;            /* user flag, I think */
  459. +   unsigned flag4: 1;            /* user flag, I think */
  460. +   unsigned flag5: 1;            /* user flag, I think */
  461. +   unsigned flag6: 1;            /* user flag, I think */
  462. +   unsigned flag7: 1;            /* user flag, I think */
  463. +   unsigned char namelen;        /* length of name, bytes */
  464. +   unsigned short valuelen;        /* length of value, bytes */
  465. +   /*
  466. +     unsigned char name[namelen];    ascii attrib name
  467. +     unsigned char nul;            terminating '\0', not counted
  468. +     unsigned char value[valuelen];    value, arbitrary
  469. +     if this.indirect, valuelen is 8 and the value is
  470. +       unsigned length;            real length of value, bytes
  471. +       secno secno;            sector address where it starts
  472. +   */
  473. + };
  474. + 
  475. + /* Large values are handled by the indirect mechanism.  I think one
  476. +    contiguous sector run is required to hold the value.  (?)
  477. + 
  478. +    When too many EA's are defined, what seems to happen is that an EA
  479. +    named .ASSOCTABLE appears whose value is a set of EA's.  Another EA
  480. +    named .CHECKSUM always seems to accompany it.  ASSOCTABLE always has
  481. +    a large value, CHECKSUM always doesn't.  I don't know whether
  482. +    this is an HPFS hack or a library hack. */
  483. + 
  484. + /*
  485. +    Local Variables:
  486. +    comment-column: 40
  487. +    End:
  488. + */
  489. diff -rc2N linux-dist/fs/hpfs/hpfs_fs.c linux/fs/hpfs/hpfs_fs.c
  490. *** linux-dist/fs/hpfs/hpfs_fs.c
  491. --- linux/fs/hpfs/hpfs_fs.c    Sun Oct 10 12:18:53 1993
  492. ***************
  493. *** 0 ****
  494. --- 1,1391 ----
  495. + /*
  496. +  *  linux/fs/hpfs/hhpfs_fs.c
  497. +  *
  498. +  *  Sources & references:
  499. +  *   Duncan, _Design ... of HPFS_, MSSJ 4(5)   (C) 1989 Microsoft Corp
  500. +  *   linux/fs/minix  Copyright (C) 1991, 1992, 1993  Linus Torvalds
  501. +  *   linux/fs/msdos  Written 1992, 1993 by Werner Almesberger
  502. +  *   linux/fs/isofs  Copyright (C) 1991  Eric Youngdale
  503. +  */
  504. + 
  505. + /* read-only HPFS */
  506. + 
  507. + /* HPFS is a mixture of 512-byte blocks and 2048-byte blocks.  The 2k blocks
  508. +    are used for directories (dnodes) and bitmaps.  They are always aligned
  509. +    and never aliased with 512-byte blocks, so it's no big deal keeping them
  510. +    straight.  However, Linux currently does not mix block sizes, so we run
  511. +    the whole file system with 2k blocks.
  512. + 
  513. +    However, I want du/df and friends to work right, so everything is reported
  514. +    to the user as if the blocksize were 512 bytes.
  515. + 
  516. +    For a file's i-number we use the sector number of its fnode, coded.
  517. +    (Directory ino's are even, file ino's are odd, and ino >> 1 is the
  518. +    sector address of the fnode.  This is a hack to allow lookup() to
  519. +    tell read_inode() whether it is efficient to read the fnode.)
  520. + 
  521. +    The map_xxx routines all read something into a buffer and return a
  522. +    pointer somewhere in the buffer.  The caller must do the brelse.
  523. +    The other routines are balanced. */
  524. + 
  525. + #include <stddef.h>
  526. + #include <linux/fs.h>
  527. + #include <linux/hpfs_fs.h>
  528. + #include <linux/errno.h>
  529. + #include <linux/sched.h>
  530. + #include <linux/locks.h>
  531. + #include <linux/stat.h>
  532. + #include <linux/string.h>
  533. + #include <asm/bitops.h>
  534. + #include <asm/segment.h>
  535. + 
  536. + #include "hpfs.h"
  537. + 
  538. + /* For details on the data structures see hpfs.h and the Duncan article.
  539. + 
  540. +    Overview
  541. + 
  542. +    [ The names of these data structures, except fnode, are not IBM's or
  543. +    Microsoft's.  I don't know what names they use.  The semantics
  544. +    described here are those of this implementation, and any coincidence
  545. +    between it and real HPFS is to be hoped for but not guaranteed by me,
  546. +    and certainly not guaranteed by IBM or MS.  Who know nothing about this. ]
  547. + 
  548. +    [ Also, the following will make little sense if you haven't read the
  549. +    Duncan article, which is excellent. ]
  550. + 
  551. +    HPFS is a tree.  There are 3 kinds of nodes.  A directory is a tree
  552. +    of dnodes, and a file's allocation info is a tree of sector lists
  553. +    stored in fnodes and anodes.
  554. + 
  555. +    The top pointer is in the super block, it points to the fnode of the
  556. +    root directory.
  557. +    
  558. +    The root directory -- all directories -- gives file names, dates &c,
  559. +    and fnode addresses.  If the directory fits in one dnode, that's it,
  560. +    otherwise the top dnode points to other dnodes, forming a tree.  A
  561. +    directory tree might look like
  562. + 
  563. +        ((a b c) d (e f g) h (i j) k l (m n o p))
  564. + 
  565. +    The subtrees appear between the files.  Each dir entry contains, along
  566. +    with the name and fnode, a dnode pointer to the subtree that precedes it
  567. +    (if there is one; a flag tells that).  The first entry in every directory
  568. +    is ^A^A, the entry for the directory itself.  The last entry in every
  569. +    dnode is \377, a fake entry whose only valid fields are the bit marking
  570. +    it last and the down pointer to the subtree preceding it, if any.
  571. + 
  572. +    The "value" field of directory entries is an fnode address.  The fnode
  573. +    tells where the sectors of the file are.  The fnode for a subdirectory
  574. +    contains one pointer, to the root dnode of the subdirectory.  The fnode
  575. +    for a data file contains, in effect, a tiny anode.  (Most of the space
  576. +    in fnodes is for extended attributes.)
  577. + 
  578. +    anodes and the anode part of fnodes are trees of extent lists.  An extent
  579. +    is a (length, disk address) pair, labeled with the file address being
  580. +    mapped.  E.g.,
  581. + 
  582. +        (0: 3@1000  3: 1@2000  4: 2@10)
  583. + 
  584. +    means the file:disk sector map (0:1000 1:1001 2:1002 3:2000 4:10 5:11).
  585. + 
  586. +    There is space for 8 file:len@disk triples in an fnode, or for 40 in an
  587. +    anode.  If this is insufficient, subtrees are used, as in
  588. + 
  589. +     (6: (0: 3@1000  3: 1@2000  4: 2@10)  12: (6: 3@8000  9: 1@9000  10: 2@20))
  590. + 
  591. +    The label on a subtree is the first address *after* that tree.  The
  592. +    subtrees are always anodes.  The label:subtree pairs require only
  593. +    two words each, so non-leaf subtrees have a different format; there
  594. +    is room for 12 label:subtree pairs in an fnode, or 60 in an anode.
  595. + 
  596. +    There is only one pointer to any dnode.  If it is the root dnode of its
  597. +    directory, the pointer is in the directory's fnode.  If it is not the
  598. +    root, the pointer is in the parent dnode.
  599. + 
  600. +    The only real upward pointer around is in fnodes, which point to the
  601. +    directory containing them (to its fnode).  (So, in a directory's fnode,
  602. +    this pointer is "..".)  There are several pointers that seem to be for
  603. +    consistency checks -- all dnodes point to the directory's fnode, and
  604. +    several nodes contain pointers to themselves.
  605. +    
  606. +    On the disk, dnodes are all together in the center of the partition, and
  607. +    HPFS even manages to put all the dnodes for a single directory together,
  608. +    generally.   fnodes are out with the data.  anodes are pretty much not
  609. +    seen -- in fact noncontiguous files are pretty much not seen.  I think
  610. +    this is partly the open() call that lets programs specify the length of
  611. +    an output file when they know it, and partly because HPFS.IFS really is
  612. +    very good at avoiding fragmentation. */
  613. + 
  614. + /* notation */
  615. + 
  616. + #define little_ushort(x) (*(unsigned short *) &(x))
  617. + typedef void nonconst;
  618. + 
  619. + /* super block ops */
  620. + 
  621. + static void hpfs_read_inode (struct inode *);
  622. + static int hpfs_notify_change (int flags, struct inode *);
  623. + static void hpfs_write_inode (struct inode *);
  624. + static void hpfs_put_inode (struct inode *);
  625. + static void hpfs_put_super (struct super_block *);
  626. + static void hpfs_write_super (struct super_block *);
  627. + static void hpfs_statfs (struct super_block *, struct statfs *);
  628. + static int hpfs_remount_fs (struct super_block *, int *);
  629. + 
  630. + static const struct super_operations hpfs_sops =
  631. + {
  632. +   hpfs_read_inode,
  633. +   hpfs_notify_change,
  634. +   hpfs_write_inode,
  635. +   hpfs_put_inode,
  636. +   hpfs_put_super,
  637. +   hpfs_write_super,
  638. +   hpfs_statfs,
  639. +   hpfs_remount_fs,
  640. + };
  641. + 
  642. + /* file ops */
  643. + 
  644. + static int hpfs_file_read (struct inode *, struct file *, char *, int);
  645. + static int hpfs_file_write (struct inode *, struct file *, char *, int);
  646. + static void hpfs_truncate (struct inode *);
  647. + 
  648. + static const struct file_operations hpfs_file_ops = 
  649. + {
  650. +   NULL,                    /* lseek - default */
  651. +   hpfs_file_read,            /* read */
  652. +   hpfs_file_write,            /* write */
  653. +   NULL,                    /* readdir - bad */
  654. +   NULL,                    /* select - default */
  655. +   NULL,                    /* ioctl - default */
  656. +   NULL,                    /* mmap */
  657. +   NULL,                    /* no special open is needed */
  658. +   NULL,                    /* release */
  659. +   file_fsync,                /* fsync */
  660. + };
  661. + 
  662. + static const struct inode_operations hpfs_file_iops = 
  663. + {
  664. +   (nonconst *) &hpfs_file_ops,        /* default file operations */
  665. +   NULL,                    /* create */
  666. +   NULL,                    /* lookup */
  667. +   NULL,                    /* link */
  668. +   NULL,                    /* unlink */
  669. +   NULL,                    /* symlink */
  670. +   NULL,                    /* mkdir */
  671. +   NULL,                    /* rmdir */
  672. +   NULL,                    /* mknod */
  673. +   NULL,                    /* rename */
  674. +   NULL,                    /* readlink */
  675. +   NULL,                    /* follow_link */
  676. +   NULL,                    /* bmap */
  677. +   hpfs_truncate,            /* truncate */
  678. +   NULL,                    /* permission */
  679. + };
  680. + 
  681. + 
  682. + static int hpfs_dir_read (struct inode * inode, struct file *filp,
  683. +                char *buf, int count);
  684. + static int hpfs_readdir (struct inode *inode, struct file *filp,
  685. +              struct dirent *dirent, int count);
  686. + static int hpfs_create (struct inode *,const char *,int,int,struct inode **);
  687. + static int hpfs_lookup (struct inode *,const char *,int,struct inode **);
  688. + static int hpfs_unlink (struct inode *,const char *,int);
  689. + static int hpfs_mkdir (struct inode *,const char *,int,int);
  690. + static int hpfs_rmdir (struct inode *,const char *,int);
  691. + static int hpfs_rename (struct inode *,const char *,int,struct inode *,const char *,int);
  692. + 
  693. + static const struct file_operations hpfs_dir_ops = 
  694. + {
  695. +   NULL,                    /* lseek - default */
  696. +   hpfs_dir_read,            /* read */
  697. +   NULL,                    /* write - bad */
  698. +   hpfs_readdir,                /* readdir */
  699. +   NULL,                    /* select - default */
  700. +   NULL,                    /* ioctl - default */
  701. +   NULL,                    /* mmap */
  702. +   NULL,                    /* no special open code */
  703. +   NULL,                    /* no special release code */
  704. +   file_fsync,                /* fsync */
  705. + };
  706. + 
  707. + static const struct inode_operations hpfs_dir_iops =
  708. + {
  709. +   (nonconst *) &hpfs_dir_ops,        /* default directory file ops */
  710. +   hpfs_create,                /* create */
  711. +   hpfs_lookup,                /* lookup */
  712. +   NULL,                    /* link */
  713. +   hpfs_unlink,                /* unlink */
  714. +   NULL,                    /* symlink */
  715. +   hpfs_mkdir,                /* mkdir */
  716. +   hpfs_rmdir,                /* rmdir */
  717. +   NULL,                    /* mknod */
  718. +   hpfs_rename,                /* rename */
  719. +   NULL,                    /* readlink */
  720. +   NULL,                    /* follow_link */
  721. +   NULL,                    /* bmap */
  722. +   NULL,                    /* truncate */
  723. +   NULL,                    /* permission */
  724. + };
  725. + 
  726. + static int parse_opts (char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
  727. +                int *lowercase, int *conv);
  728. + static void count_dnodes (struct inode *inode, dnode_secno dno,
  729. +               unsigned *n_dnodes, unsigned *n_subdirs);
  730. + static unsigned count_bitmap (struct super_block *s);
  731. + static unsigned count_one_bitmap (dev_t dev, secno secno);
  732. + static secno file_disk_secno (struct inode *inode, unsigned file_secno);
  733. + static secno bplus_lookup (struct inode *inode, struct bplus_header *b,
  734. +                secno file_secno, struct buffer_head **bhp);
  735. + static struct hpfs_dirent *map_dirent (struct inode *inode, dnode_secno dno,
  736. +                        const char *name, unsigned len,
  737. +                        struct buffer_head **bhp);
  738. + static struct hpfs_dirent *map_pos_dirent (struct inode *inode, off_t *posp,
  739. +                        struct buffer_head **bhp);
  740. + static void write_one_dirent (struct dirent *dirent, const unsigned char *name,
  741. +                   unsigned namelen, ino_t ino, int lowercase);
  742. + static dnode_secno dir_subdno (struct inode *inode, unsigned pos);
  743. + static struct hpfs_dirent *map_nth_dirent (dev_t dev, dnode_secno dno,
  744. +                        int n, struct buffer_head **bhp);
  745. + static dnode_secno fnode_dno (dev_t dev, ino_t ino);
  746. + static void *map_fnode (dev_t dev, ino_t ino, struct buffer_head **bhp);
  747. + static void *map_anode (dev_t dev, unsigned secno, struct buffer_head **bhp);
  748. + static void *map_dnode (dev_t dev, unsigned secno, struct buffer_head **bhp);
  749. + static void *map_sector (dev_t dev, unsigned secno, struct buffer_head **bhp);
  750. + static void *map_4sectors (dev_t dev, unsigned secno,struct buffer_head **bhp);
  751. + static unsigned choose_conv (unsigned char *p, unsigned len);
  752. + static unsigned convcpy_tofs (unsigned char *out, unsigned char *in,
  753. +                   unsigned len);
  754. + 
  755. + 
  756. + /* make inode number for a file */
  757. + 
  758. + static ino_t file_ino (fnode_secno secno)
  759. + {
  760. +   return secno << 1 | 1;
  761. + }
  762. + 
  763. + /* make inode number for a directory */
  764. + 
  765. + static ino_t dir_ino (fnode_secno secno)
  766. + {
  767. +   return secno << 1;
  768. + }
  769. + 
  770. + /* get fnode address from an inode number */
  771. + 
  772. + static fnode_secno ino_secno (ino_t ino)
  773. + {
  774. +   return ino >> 1;
  775. + }
  776. + 
  777. + /* test for directory's inode number */
  778. + 
  779. + static int ino_is_dir (ino_t ino)
  780. + {
  781. +   return (ino & 1) == 0;
  782. + }
  783. + 
  784. + /* conv= options */
  785. + 
  786. + #define CONV_BINARY 0        /* no conversion */
  787. + #define CONV_TEXT 1        /* crlf->newline */
  788. + #define CONV_AUTO 2        /* decide based on file contents */
  789. + 
  790. + /* super block ops */
  791. + 
  792. + /* mount.  This gets one thing, the root directory inode.  It does a
  793. +    bunch of guessed-at consistency checks.  */
  794. + 
  795. + struct super_block *hpfs_read_super (struct super_block *s,
  796. +                      void *options, int silent)
  797. + {
  798. +   struct hpfs_boot_block *bootblock;
  799. +   struct hpfs_super_block *superblock;
  800. +   struct hpfs_spare_block *spareblock;
  801. +   struct hpfs_dirent *de;
  802. +   struct buffer_head *bh0, *bh1, *bh2;
  803. +   dev_t dev; 
  804. +   uid_t uid;
  805. +   gid_t gid;
  806. +   umode_t umask;
  807. +   int lowercase;
  808. +   int conv;
  809. + 
  810. +   /* Get the mount options */
  811. + 
  812. +   if (! parse_opts (options, &uid, &gid, &umask, &lowercase, &conv)) {
  813. +     printk ("HPFS: syntax error in mount options.  Not mounted.\n");
  814. +     s->s_dev = 0; return 0;
  815. +   }
  816. + 
  817. +   /* Fill in the super block struct */
  818. + 
  819. +   lock_super (s);
  820. +   dev = s->s_dev;
  821. +   set_blocksize (dev, 2048);
  822. + 
  823. +   /* fetch sectors 0, 16, 17 */
  824. + 
  825. +   bootblock = map_sector (dev, 0, &bh0);
  826. +   if (! bootblock)
  827. +     { s->s_dev = 0; unlock_super (s); return 0; }
  828. + 
  829. +   superblock = map_sector (dev, 16, &bh1);
  830. +   if (! superblock)
  831. +     { brelse (bh0); s->s_dev = 0; unlock_super (s); return 0; }
  832. + 
  833. +   spareblock = map_sector (dev, 17, &bh2);
  834. +   if (! spareblock)
  835. +     { brelse (bh1); brelse (bh0); s->s_dev = 0; unlock_super (s); return 0; }
  836. + 
  837. +   /* Check that this fs matches the ones I examined. 
  838. +      Probably some of these checks are unneeded, but the clueless do well
  839. +      to be timid. */
  840. + 
  841. +   if (little_ushort (bootblock->bytes_per_sector) != 512
  842. +       || bootblock->sig_28h != 0x28
  843. +       || memcmp (&bootblock->sig_hpfs, "HPFS    ", 8)
  844. +       || superblock->magic != SB_MAGIC
  845. +       || superblock->huh202 != 0x202
  846. +       || superblock->n_sectors != bootblock->n_sectors_l
  847. +       || (superblock->n_sectors % 4) != 0
  848. +       || spareblock->magic != SP_MAGIC
  849. +       || spareblock->dirty != 0
  850. +       || spareblock->n_spares_used != 0
  851. +       || spareblock->n_dnode_spares_1 != spareblock->n_dnode_spares_2
  852. +       || superblock->huh4 != 0x14
  853. +       || superblock->huh6 != 0x1c
  854. +       || superblock->zero1 || superblock->zero2
  855. +       || superblock->zero3 || superblock->zero4) {
  856. +     printk ("HPFS: hpfs_read_super: Not HPFS\n");
  857. +     brelse (bh2); brelse (bh1); brelse (bh0);
  858. +     s->s_dev = 0; unlock_super (s); return 0;
  859. +   }
  860. + 
  861. +   /* set fs read only */
  862. + 
  863. +   s->s_flags |= MS_RDONLY;
  864. + 
  865. +   /* fill in standard stuff */
  866. + 
  867. +   s->s_magic = HPFS_SUPER_MAGIC;
  868. +   s->s_blocksize = 2048;
  869. +   s->s_blocksize_bits = 11;
  870. +   s->s_op = (struct super_operations *) &hpfs_sops;
  871. + 
  872. +   /* fill in hpfs stuff */
  873. + 
  874. +   s->s_hpfs_root = dir_ino (superblock->root);
  875. +   s->s_hpfs_fs_size = superblock->n_sectors;
  876. +   s->s_hpfs_dirband_size = superblock->n_dir_band / 4;
  877. +   s->s_hpfs_dmap = superblock->dir_band_bitmap;
  878. +   s->s_hpfs_uid = uid;
  879. +   s->s_hpfs_gid = gid;
  880. +   s->s_hpfs_mode = 0777 & ~umask;
  881. +   s->s_hpfs_n_free = -1;
  882. +   s->s_hpfs_n_free_dnodes = -1;
  883. +   s->s_hpfs_lowercase = lowercase;
  884. +   s->s_hpfs_conv = conv;
  885. + 
  886. +   /* done with the low blocks */
  887. + 
  888. +   brelse (bh2); brelse (bh1); brelse (bh0);
  889. + 
  890. +   /* all set.  try it out. */
  891. + 
  892. +   s->s_mounted = iget (s, s->s_hpfs_root);
  893. +   unlock_super (s);
  894. + 
  895. +   if (! s->s_mounted) {
  896. +     printk ("HPFS: hpfs_read_super: inode get failed\n");
  897. +     s->s_dev = 0;
  898. +     return 0;
  899. +   } 
  900. + 
  901. +   /* find the root directory's . pointer & finish filling in the inode */
  902. + 
  903. +   de = map_dirent (s->s_mounted, fnode_dno (dev, s->s_hpfs_root),
  904. +            "\001\001", 2, &bh0);
  905. +   if (! de) {
  906. +     printk ("HPFS: hpfs_read_super: root dir isn't in the root dir\n");
  907. +     s->s_dev = 0;
  908. +     return 0;
  909. +   }
  910. + 
  911. +   s->s_mounted->i_atime = de->read_date;
  912. +   s->s_mounted->i_mtime = de->write_date;
  913. +   s->s_mounted->i_ctime = de->creation_date;
  914. + 
  915. +   brelse (bh0);
  916. +   return s;
  917. + }
  918. + 
  919. + /* A tiny parser for option strings, stolen from dosfs. */
  920. + 
  921. + static int parse_opts (char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
  922. +                int *lowercase, int *conv)
  923. + {
  924. +   char *p, *rhs;
  925. + 
  926. +   *uid = current->uid;
  927. +   *gid = current->gid;
  928. +   *umask = current->umask;
  929. +   *lowercase = 1;
  930. +   *conv = CONV_BINARY;
  931. + 
  932. +   if (! opts) return 1;
  933. + 
  934. +   for (p = strtok (opts, ","); p != 0; p = strtok (0, ",")) {
  935. +     if ((rhs = strchr (p, '=')) != 0)
  936. +       *rhs++ = '\0';
  937. +     if (! strcmp (p, "uid")) {
  938. +       if (!rhs || !*rhs) return 0;
  939. +       *uid = simple_strtoul (rhs, &rhs, 0);
  940. +       if (*rhs) return 0;
  941. +     } else if (! strcmp (p, "gid")) {
  942. +       if (!rhs || !*rhs) return 0;
  943. +       *gid = simple_strtoul (rhs, &rhs, 0);
  944. +       if (*rhs) return 0;
  945. +     } else if (! strcmp (p, "umask")) {
  946. +       if (!rhs || !*rhs) return 0;
  947. +       *umask = simple_strtoul (rhs,&rhs,8);
  948. +       if  (*rhs) return 0;
  949. +     } else if (! strcmp (p, "case")) {
  950. +       if (! strcmp (rhs, "lower")) *lowercase = 1;
  951. +       else if (! strcmp (rhs, "asis")) *lowercase = 0;
  952. +       else return 0;
  953. +     } else if (! strcmp (p, "conv")) {
  954. +       if (! strcmp (rhs, "binary")) *conv = CONV_BINARY;
  955. +       else if (! strcmp (rhs, "text")) *conv = CONV_TEXT;
  956. +       else if (! strcmp (rhs, "auto")) *conv = CONV_AUTO;
  957. +       else return 0;
  958. +     } else
  959. +       return 0;
  960. +   }
  961. + 
  962. +   return 1;
  963. + }
  964. + 
  965. + /* read_inode.  This is called with exclusive access to a new inode that
  966. +    has only (i_dev,i_ino) set.  It is responsible for filling in the rest.
  967. +    We evilly leave the dates blank, for lookup() to fill in later.  
  968. + 
  969. +    (It really is evil, but consider the alternative: read the
  970. +    fnode, find the dir pointer in it, read that fnode to get the dnode
  971. +    pointer, search through that whole directory for the ino we're
  972. +    reading, and get the dates.  It works, but ls sounds like fsck.)
  973. + 
  974. +    (This will break someday if iget sleeps between calling us and
  975. +    returning to lookup.  Or if someone other than lookup calls iget.
  976. +    That's not too big a danger since lookup is the only source of
  977. +    i-numbers.  Neither is a problem right now, 0.99.13.)
  978. + 
  979. +    (An alternative would be to clone iget in this file so we can add
  980. +    args to it.  That's even more evil.) */
  981. + 
  982. + static void hpfs_read_inode (struct inode *inode)
  983. + {
  984. +   struct super_block *s = inode->i_sb;
  985. + 
  986. +   /* be ready to bail out */
  987. + 
  988. +   inode->i_op = 0;
  989. +   inode->i_mode = 0;
  990. + 
  991. +   if (inode->i_ino == 0
  992. +       || ino_secno (inode->i_ino) >= inode->i_sb->s_hpfs_fs_size)
  993. +     { printk ("HPFS: read_inode: bad ino\n"); return; }
  994. + 
  995. +   /* canned stuff */
  996. + 
  997. +   inode->i_uid = s->s_hpfs_uid;
  998. +   inode->i_gid = s->s_hpfs_gid;
  999. +   inode->i_mode = s->s_hpfs_mode;
  1000. +   inode->i_hpfs_conv = s->s_hpfs_conv;
  1001. + 
  1002. +   inode->i_hpfs_dno = 0;
  1003. +   inode->i_hpfs_n_secs = 0;
  1004. +   inode->i_hpfs_file_sec = 0;
  1005. +   inode->i_hpfs_disk_sec = 0;
  1006. +   inode->i_hpfs_dpos = 0;
  1007. +   inode->i_hpfs_dsubdno = 0;
  1008. + 
  1009. +   /* figure out whether we are looking at a directory or a file */
  1010. + 
  1011. +   if (ino_is_dir (inode->i_ino))
  1012. +     inode->i_mode |= S_IFDIR;
  1013. +   else {
  1014. +     inode->i_mode |= S_IFREG;
  1015. +     inode->i_mode &= ~0111;
  1016. +   }
  1017. + 
  1018. +   /* these fields must be filled in from the dir entry, which we don't have
  1019. +      but lookup does.  It will fill them in before letting the inode
  1020. +      out of its grasp. */
  1021. + 
  1022. +   inode->i_atime = 0;
  1023. +   inode->i_mtime = 0;
  1024. +   inode->i_ctime = 0;
  1025. +   inode->i_size = 0;
  1026. + 
  1027. +   /* fill in the rest */
  1028. + 
  1029. +   if (S_ISREG (inode->i_mode)) {
  1030. + 
  1031. +     inode->i_op = (struct inode_operations *) &hpfs_file_iops;
  1032. +     inode->i_nlink = 1;
  1033. +     inode->i_blksize = 512;
  1034. + 
  1035. +   } else {
  1036. + 
  1037. +     unsigned n_dnodes, n_subdirs;
  1038. +     struct buffer_head *bh0;
  1039. +     struct fnode *fnode = map_fnode (inode->i_dev, inode->i_ino, &bh0);
  1040. + 
  1041. +     if (! fnode)
  1042. +       { printk ("HPFS: read_inode: no fnode\n"); inode->i_mode = 0; return; }
  1043. + 
  1044. +     inode->i_hpfs_parent_dir = dir_ino (fnode->up);
  1045. +     inode->i_hpfs_dno = fnode->u.external[0].disk_secno;
  1046. + 
  1047. +     brelse (bh0);
  1048. + 
  1049. +     n_dnodes = n_subdirs = 0;
  1050. +     count_dnodes (inode, inode->i_hpfs_dno, &n_dnodes, &n_subdirs);
  1051. + 
  1052. +     inode->i_op = (struct inode_operations *) &hpfs_dir_iops;
  1053. +     inode->i_blksize = 512;        /* 2048 here confuses ls & du & ...*/
  1054. +     inode->i_blocks = 4 * n_dnodes;
  1055. +     inode->i_size = 512 * inode->i_blocks;
  1056. +     inode->i_nlink = 2 + n_subdirs;
  1057. +   }
  1058. + }
  1059. + 
  1060. + static int hpfs_notify_change (int flags, struct inode *inode)
  1061. + {
  1062. +   return -EROFS;
  1063. + }
  1064. + 
  1065. + static void hpfs_write_inode (struct inode *inode)
  1066. + {
  1067. + }
  1068. + 
  1069. + static void hpfs_put_inode (struct inode *inode)
  1070. + {
  1071. + }
  1072. + 
  1073. + static void hpfs_put_super (struct super_block *s)
  1074. + {
  1075. +   lock_super (s);
  1076. +   s->s_dev = 0;
  1077. +   unlock_super (s);
  1078. + }
  1079. + 
  1080. + static void hpfs_write_super (struct super_block *s)
  1081. + {
  1082. + }
  1083. + 
  1084. + /* statfs.  We report results in 512-byte sectors, not our 2k buffer size.
  1085. +    For inode counts we report the count of dnodes in the directory band --
  1086. +    this is inaccurate because a dnode holds more than 1 file, and also
  1087. +    because when the directory band fills up HPFS just puts dnodes elsewhere.
  1088. +    But it's more interesting than zeros. */
  1089. + 
  1090. + static void hpfs_statfs (struct super_block *s, struct statfs *buf)
  1091. + {
  1092. +   if (s->s_hpfs_n_free == -1) {
  1093. +     s->s_hpfs_n_free_dnodes = count_one_bitmap (s->s_dev, s->s_hpfs_dmap);
  1094. +     s->s_hpfs_n_free = count_bitmap (s);
  1095. +   }
  1096. + 
  1097. +   put_fs_long (s->s_magic, &buf->f_type);
  1098. +   put_fs_long (512, &buf->f_bsize);
  1099. +   put_fs_long (s->s_hpfs_fs_size, &buf->f_blocks);
  1100. +   put_fs_long (s->s_hpfs_n_free, &buf->f_bfree);
  1101. +   put_fs_long (s->s_hpfs_n_free, &buf->f_bavail);
  1102. +   put_fs_long (s->s_hpfs_dirband_size, &buf->f_files);
  1103. +   put_fs_long (s->s_hpfs_n_free_dnodes, &buf->f_ffree);
  1104. +   put_fs_long (255, &buf->f_namelen);
  1105. + }
  1106. + 
  1107. + static int hpfs_remount_fs (struct super_block *s, int *flags)
  1108. + {
  1109. +   if (! (*flags & MS_RDONLY))
  1110. +     return -EINVAL;
  1111. +   return 0;
  1112. + }
  1113. + 
  1114. + /* count the dnodes in a directory, and the subdirs */
  1115. + 
  1116. + static void count_dnodes (struct inode *inode, dnode_secno dno,
  1117. +               unsigned *n_dnodes, unsigned *n_subdirs)
  1118. + {
  1119. +   struct buffer_head *bh;
  1120. +   struct dnode *dnode;
  1121. +   struct hpfs_dirent *de;
  1122. +   struct hpfs_dirent *de_end;
  1123. + 
  1124. +   dnode = map_dnode (inode->i_dev, dno, &bh);
  1125. +   if (! dnode) return;
  1126. +   de = (void *) dnode->dirent;
  1127. +   de_end = (void *) de + dnode->first_free;
  1128. + 
  1129. +   (*n_dnodes)++;
  1130. + 
  1131. +   for ( ; de < de_end; de = (void *) de + de->length) {
  1132. +     if (de->down)
  1133. +       count_dnodes (inode, *(dnode_secno *) ((void *) de + de->length - 4),
  1134. +             n_dnodes, n_subdirs);
  1135. +     if (de->directory && ! de->first)
  1136. +       (*n_subdirs)++;
  1137. +     if (de->last || de->length == 0)
  1138. +       break;
  1139. +   }
  1140. + 
  1141. +   brelse (bh);
  1142. + }
  1143. + 
  1144. + /* count the bits in the free space bit maps */
  1145. + 
  1146. + static unsigned count_bitmap (struct super_block *s)
  1147. + {
  1148. +   unsigned n, fs_size = s->s_hpfs_fs_size;
  1149. +   unsigned count;
  1150. + 
  1151. +   /* band 0 bitmap is in 18-1b */
  1152. + 
  1153. +   count = count_one_bitmap (s->s_dev, 0x18);
  1154. + 
  1155. +   /* remaining bitmaps are in the first or last 4 sectors of band */
  1156. + 
  1157. +   for (n = 0x4000; n < fs_size; n += 0x4000)
  1158. +     if (n & 0x4000) {
  1159. +       unsigned t = n | 0x3ffc;
  1160. +       if (t > fs_size - 4) t = fs_size - 4;
  1161. +       count += count_one_bitmap (s->s_dev, t);
  1162. +     } else
  1163. +       count += count_one_bitmap (s->s_dev, n);
  1164. + 
  1165. +   return count;
  1166. + }
  1167. + 
  1168. + /* Read in one bit map, count the bits, return the count. */
  1169. + 
  1170. + static unsigned count_one_bitmap (dev_t dev, secno secno)
  1171. + {
  1172. +   struct buffer_head *bh;
  1173. +   char *bits; 
  1174. +   unsigned i, count;
  1175. + 
  1176. +   bits = map_4sectors (dev, secno, &bh);
  1177. +   if (! bits) return 0;
  1178. + 
  1179. +   count = 0;
  1180. + 
  1181. +   for (i = 0; i < 8 * 2048; i++)
  1182. +     count += (test_bit (i, bits) != 0);
  1183. +   brelse (bh);
  1184. + 
  1185. +   return count;
  1186. + }
  1187. + 
  1188. + /* file ops */
  1189. + 
  1190. + /* read().  Read the bytes, put them in buf, return the count. */
  1191. + 
  1192. + static int hpfs_file_read (struct inode *inode, struct file *filp,
  1193. +                char *buf, int count)
  1194. + {
  1195. +   unsigned q, r, n, n0;
  1196. +   struct buffer_head *bh;
  1197. +   char *block;
  1198. +   char *start;
  1199. + 
  1200. +   if (inode == 0 || ! S_ISREG (inode->i_mode))
  1201. +     return -EINVAL;
  1202. + 
  1203. +   /* truncate count at EOF */
  1204. +   if (count > inode->i_size - filp->f_pos)
  1205. +     count = inode->i_size - filp->f_pos;
  1206. +   
  1207. +   start = buf;
  1208. +   while (count > 0) {
  1209. + 
  1210. +     /* get file sector number, offset in sector, length to end of sector */
  1211. +     q = filp->f_pos >> 9;
  1212. +     r = filp->f_pos & 511;
  1213. +     n = 512 - r;
  1214. + 
  1215. +     /* get length to copy to user buffer */
  1216. +     if (n > count)
  1217. +       n = count;
  1218. + 
  1219. +     /* read the sector, copy to user */
  1220. +     block = map_sector (inode->i_dev, file_disk_secno (inode, q), &bh);
  1221. +     if (! block) return -EIO;
  1222. + 
  1223. +     /* but first decide if it has \r\n, if the user asked for that */ 
  1224. +     if (inode->i_hpfs_conv == CONV_AUTO)
  1225. +       inode->i_hpfs_conv = choose_conv (block + r, n);
  1226. + 
  1227. +     if (inode->i_hpfs_conv == CONV_BINARY) {
  1228. +       /* regular copy, output length is same as input length */
  1229. +       memcpy_tofs (buf, block + r, n);
  1230. +       n0 = n;
  1231. +     } else {
  1232. +       /* squeeze out \r, output length varies */
  1233. +       n0 = convcpy_tofs (buf, block + r, n);
  1234. +       if (count > inode->i_size - filp->f_pos - n + n0)
  1235. +     count = inode->i_size - filp->f_pos - n + n0;
  1236. +     }
  1237. + 
  1238. +     brelse (bh);
  1239. + 
  1240. +     /* advance input n bytes, output n0 bytes */
  1241. +     filp->f_pos += n;
  1242. +     buf += n0;
  1243. +     count -= n0;
  1244. +   }
  1245. + 
  1246. +   return buf - start;
  1247. + }
  1248. + 
  1249. + /* This routine implements conv=auto.  Return CONV_BINARY or CONV_TEXT. */
  1250. + 
  1251. + static unsigned choose_conv (unsigned char *p, unsigned len)
  1252. + {
  1253. +   unsigned tvote, bvote;
  1254. +   unsigned c;
  1255. + 
  1256. +   tvote = bvote = 0;
  1257. + 
  1258. +   while (len--) {
  1259. +     c = *p++;
  1260. +     if (c < ' ')
  1261. +       if (c == '\r' && len && *p == '\n') tvote += 10;
  1262. +       else if (c == '\t' || c == '\n') ;
  1263. +       else bvote += 5;
  1264. +     else if (c < '\177')
  1265. +       tvote++;
  1266. +     else
  1267. +       bvote += 5;
  1268. +   }
  1269. + 
  1270. +   if (tvote > bvote)
  1271. +     return CONV_TEXT;
  1272. +   else
  1273. +     return CONV_BINARY;
  1274. + }
  1275. + 
  1276. + /* This routine implements conv=text.  :s/crlf/nl/  */
  1277. + 
  1278. + static unsigned convcpy_tofs (unsigned char *out, unsigned char *in,
  1279. +                   unsigned len)
  1280. + {
  1281. +   unsigned char *start = out;
  1282. + 
  1283. +   while (len--) {
  1284. +     unsigned c = *in++;
  1285. +     if (c == '\r' && (len == 0 || *in == '\n'))
  1286. +       ;
  1287. +     else
  1288. +       put_fs_byte (c, out++);
  1289. +   }
  1290. + 
  1291. +   return out - start;
  1292. + }
  1293. + 
  1294. + static int hpfs_file_write (struct inode *inode, struct file *filp,
  1295. +                 char *buf, int count)
  1296. + {
  1297. +   return -EROFS;
  1298. + }
  1299. + 
  1300. + static void hpfs_truncate (struct inode *inode)
  1301. + {
  1302. + }
  1303. + 
  1304. + /* Return the disk sector number containing a file sector. */
  1305. + 
  1306. + static secno file_disk_secno (struct inode *inode, unsigned file_secno)
  1307. + {
  1308. +   unsigned n, disk_secno;
  1309. +   struct fnode *fnode;
  1310. +   struct buffer_head *bh;
  1311. + 
  1312. +   /* There is one sector run cached in the inode.
  1313. +      See if the sector is in it. */
  1314. + 
  1315. +   n = file_secno - inode->i_hpfs_file_sec;
  1316. +   if (n < inode->i_hpfs_n_secs)
  1317. +     return inode->i_hpfs_disk_sec + n;
  1318. + 
  1319. +   /* No, read the fnode and go find the sector. */
  1320. + 
  1321. +   else {
  1322. +     fnode = map_fnode (inode->i_dev, inode->i_ino, &bh);
  1323. +     if (! fnode) return 0;
  1324. +     disk_secno = bplus_lookup (inode, &fnode->btree, file_secno, &bh);
  1325. +     brelse (bh);
  1326. +     return disk_secno;
  1327. +   }
  1328. + }
  1329. + 
  1330. + /* Search allocation tree *b for the given file sector number and return
  1331. +    the disk sector number.  Buffer *bhp has the tree in it, and can be
  1332. +    reused for subtrees when access to *b is no longer needed.
  1333. +    *bhp is busy on entry and exit. */
  1334. + 
  1335. + static secno bplus_lookup (struct inode *inode, struct bplus_header *b,
  1336. +                secno file_secno, struct buffer_head **bhp)
  1337. + {
  1338. +   int i;
  1339. + 
  1340. +   /* A leaf-level tree gives a list of sector runs.  Find the one
  1341. +      containing the file sector we want, cache the map info in the inode
  1342. +      for later, and return the corresponding disk sector. */
  1343. + 
  1344. +   if (! b->internal) {
  1345. +     struct bplus_leaf_node *n = (void *) b + sizeof *b;
  1346. +     for (i = 0; i < b->n_used_nodes; i++) {
  1347. +       unsigned t = file_secno - n[i].file_secno;
  1348. +       if (t < n[i].length) {
  1349. +     inode->i_hpfs_file_sec = n[i].file_secno;
  1350. +     inode->i_hpfs_disk_sec = n[i].disk_secno;
  1351. +     inode->i_hpfs_n_secs = n[i].length;
  1352. +     return n[i].disk_secno + t;
  1353. +       }
  1354. +     }
  1355. +   }
  1356. + 
  1357. +   /* A non-leaf tree gives a list of subtrees.  Find the one containing
  1358. +      the file sector we want, read it in, and recurse to search it. */
  1359. + 
  1360. +   else {
  1361. +     struct bplus_internal_node *n = (void *) b + sizeof *b;
  1362. +     for (i = 0; i < b->n_used_nodes; i++) {
  1363. +       if (file_secno < n[i].file_secno) {
  1364. +     struct anode *anode;
  1365. +     anode_secno ano = n[i].down;
  1366. +     brelse (*bhp);
  1367. +     anode = map_anode (inode->i_dev, ano, bhp);
  1368. +     if (! anode) break;
  1369. +     return bplus_lookup (inode, &anode->btree, file_secno, bhp);
  1370. +       }
  1371. +     }
  1372. +   }
  1373. + 
  1374. +   /* If we get here there was a hole in the file.  As far as I know
  1375. +      we never do get here, but falling off the end would be indelicate.
  1376. +      So return a pointer to a handy all-zero sector.  This is not a
  1377. +      reasonable way to handle files with holes if they really do happen. */
  1378. + 
  1379. +   printk ("HPFS: bplus_lookup: sector not found\n");
  1380. +   return 15;
  1381. + }
  1382. + 
  1383. + /* directory ops */
  1384. + 
  1385. + /* lookup.  Search the directory tree for the specified name, set
  1386. +    *result to the corresponding inode.
  1387. + 
  1388. +    lookup uses a secret code to tell read_inode whether it is reading
  1389. +    the inode of a directory or a file -- file ino's are odd, directory
  1390. +    ino's are even.  read_inode avoids i/o for file inodes; everything
  1391. +    needed is up here in the directory.  And file fnodes are out in
  1392. +    the boondocks. */
  1393. + 
  1394. + static int hpfs_lookup (struct inode *dir, const char *name, int len,
  1395. +             struct inode **result)
  1396. + {
  1397. +   struct buffer_head *bh;
  1398. +   struct hpfs_dirent *de;
  1399. +   struct inode *inode;
  1400. +   ino_t ino;
  1401. + 
  1402. +   /* In case of madness */
  1403. + 
  1404. +   *result = 0;
  1405. +   if (dir == 0)
  1406. +     return -ENOENT;
  1407. +   if (! S_ISDIR (dir->i_mode))
  1408. +     goto bail;
  1409. +   
  1410. +   /* Read in the directory entry.
  1411. +      "." is there under the name ^A^A .
  1412. +      Always read the dir even for . and .. in case we need the dates. */
  1413. + 
  1414. +   if (name[0] == '.' && len == 1)
  1415. +     de = map_dirent (dir, dir->i_hpfs_dno, "\001\001", 2, &bh);
  1416. +   else if (name[0] == '.' && name[1] == '.' && len == 2)
  1417. +     de = map_dirent (dir, fnode_dno (dir->i_dev, dir->i_hpfs_parent_dir),
  1418. +              "\001\001", 2, &bh);
  1419. +   else
  1420. +     de = map_dirent (dir, dir->i_hpfs_dno, name, len, &bh);
  1421. + 
  1422. +   /* This is not really a bailout, just means file not found. */
  1423. + 
  1424. +   if (! de) goto bail;
  1425. + 
  1426. +   /* Get inode number, what we're after. */
  1427. + 
  1428. +   if (de->directory)
  1429. +     ino = dir_ino (de->fnode);
  1430. +   else
  1431. +     ino = file_ino (de->fnode);
  1432. + 
  1433. +   /* Go build an inode. */
  1434. + 
  1435. +   if (! (inode = iget (dir->i_sb, ino)))
  1436. +     goto bail1;
  1437. + 
  1438. +   /* Stuff in the info from the directory if this is a newly created inode. */
  1439. + 
  1440. +   if (! inode->i_atime) {
  1441. +     inode->i_atime = de->read_date;
  1442. +     inode->i_mtime = de->write_date;
  1443. +     inode->i_ctime = de->creation_date;
  1444. +     if (! de->directory) {
  1445. +       inode->i_size = de->file_size;
  1446. +       inode->i_blocks = 1 + ((inode->i_size + 511) >> 9);
  1447. +     }
  1448. +   }
  1449. + 
  1450. +   brelse (bh);
  1451. + 
  1452. +   /* Made it. */
  1453. + 
  1454. +   *result = inode;
  1455. +   iput (dir);
  1456. +   return 0;
  1457. + 
  1458. +   /* Didn't. */
  1459. +  bail1:
  1460. +   brelse (bh);
  1461. +  bail:
  1462. +   iput (dir);
  1463. +   return -ENOENT;
  1464. + }
  1465. + 
  1466. + /* Compare two counted strings ignoring case.
  1467. +    OS/2 directory order sorts letters as if they're upper case. */
  1468. + 
  1469. + static inline int memcasecmp (unsigned char *s1, unsigned char *s2, unsigned n)
  1470. + {
  1471. +   int t;
  1472. + 
  1473. +   if (n != 0)
  1474. +     do {
  1475. +       unsigned c1 = *s1++;
  1476. +       unsigned c2 = *s2++;
  1477. +       if (c1 - 'a' < 26) c1 -= 040;
  1478. +       if (c2 - 'a' < 26) c2 -= 040;
  1479. +       if ((t = c1 - c2) != 0)
  1480. +     return t;
  1481. +     } while (--n != 0);
  1482. + 
  1483. +   return 0;
  1484. + }
  1485. + 
  1486. + /* Search a directory for the given name, return a pointer to its dir entry
  1487. +    and a pointer to the buffer containing it. */
  1488. + 
  1489. + static struct hpfs_dirent *map_dirent (struct inode *inode, dnode_secno dno,
  1490. +                        const char *name, unsigned len,
  1491. +                        struct buffer_head **bhp)
  1492. + {
  1493. +   struct dnode *dnode;
  1494. +   struct hpfs_dirent *de;
  1495. +   struct hpfs_dirent *de_end;
  1496. +   int t, l;
  1497. + 
  1498. +   /* read the dnode at the root of our subtree */
  1499. +   dnode = map_dnode (inode->i_dev, dno, bhp);
  1500. +   if (! dnode) return 0;
  1501. + 
  1502. +   /* get pointers to start and end+1 of dir entries */
  1503. +   de = (void *) dnode->dirent;
  1504. +   de_end = (void *) de + dnode->first_free;
  1505. + 
  1506. +   /* look through the entries for the name we're after */
  1507. +   for ( ; de < de_end; de = (void *) de + de->length) {
  1508. + 
  1509. +     /* compare names */
  1510. +     l = len < de->namelen ? len : de->namelen;
  1511. +     t = memcasecmp (name, de->name, l);
  1512. + 
  1513. +     /* initial substring matches, compare lengths */
  1514. +     if (t == 0) {
  1515. +       t = len - de->namelen;
  1516. +       /* bingo */
  1517. +       if (t == 0)
  1518. +     return de;
  1519. +     }
  1520. +       
  1521. +     /* wanted name < dir name -> not present. */
  1522. +     if (t < 0) {
  1523. +       /* if there is a subtree, search it. */
  1524. +       if (de->down) {
  1525. +     dnode_secno sub_dno = *(secno *) ((void *) de + de->length - 4);
  1526. +     brelse (*bhp);
  1527. +     return map_dirent (inode, sub_dno, name, len, bhp);
  1528. +       } else
  1529. +     break;
  1530. +     }
  1531. + 
  1532. +     /* de->last is set on the last name in the dnode (it's always a "\377"
  1533. +        pseudo entry).  de->length == 0 means we're about to infinite loop.
  1534. +        This test does nothing in a well-formed dnode. */
  1535. +     if (de->last || de->length == 0)
  1536. +       break;
  1537. +   }
  1538. + 
  1539. +   /* name not found. */
  1540. + 
  1541. +   return 0;
  1542. + }
  1543. + 
  1544. + /* readdir.  Return exactly 1 dirent.  (I tried and tried, but the code
  1545. +    between libc and here is *far* too hosed to permit anything more.
  1546. +    If it ever gets fixed, throw this out and just walk the tree and
  1547. +    write records into the user buffer.)
  1548. + 
  1549. +    We keep track of our position in the dnode tree with a sort of
  1550. +    dewey-decimal record of subtree locations.  Like so:
  1551. + 
  1552. +    (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)
  1553. + 
  1554. +    Subtrees appear after their file, out of lexical order,
  1555. +    which would be before their file.  It's easier.
  1556. + 
  1557. +    A directory can't hold more than 56 files, so 6 bits are used for
  1558. +    position numbers.  If the tree is so deep that the position encoding
  1559. +    doesn't fit, I'm sure something absolutely fascinating happens.
  1560. + 
  1561. +    The actual sequence of f_pos values is
  1562. +        0 -> .   -1 -> ..   1 1.1 ... 8.9 9 -> files  -2 -> eof
  1563. + 
  1564. +    The directory inode caches one position-to-dnode correspondence so
  1565. +    we won't have to repeatedly scan the top levels of the tree. */
  1566. + 
  1567. + static int hpfs_readdir (struct inode *inode, struct file *filp,
  1568. +              struct dirent *dirent, int likely_story)
  1569. + {
  1570. +   struct buffer_head *bh;
  1571. +   struct hpfs_dirent *de;
  1572. +   int namelen, lc;
  1573. +   ino_t ino;
  1574. + 
  1575. +   if (inode == 0
  1576. +       || inode->i_sb == 0
  1577. +       || ! S_ISDIR (inode->i_mode))
  1578. +     return -EBADF;
  1579. + 
  1580. +   lc = inode->i_sb->s_hpfs_lowercase;
  1581. + 
  1582. +   switch (filp->f_pos) {
  1583. +   case 0:
  1584. +     write_one_dirent (dirent, ".", 1, inode->i_ino, lc);
  1585. +     filp->f_pos = -1;
  1586. +     return 1;
  1587. + 
  1588. +   case -1:
  1589. +     write_one_dirent (dirent, "..", 2, inode->i_hpfs_parent_dir, lc);
  1590. +     filp->f_pos = 1;
  1591. +     return 2;
  1592. +     
  1593. +   case -2:
  1594. +     return 0;
  1595. + 
  1596. +   default:
  1597. + 
  1598. +     de = map_pos_dirent (inode, &filp->f_pos, &bh);
  1599. +     if (! de) {
  1600. +       filp->f_pos = -2;
  1601. +       return 0;
  1602. +     }
  1603. + 
  1604. +     namelen = de->namelen;
  1605. +     if (de->directory)
  1606. +       ino = dir_ino (de->fnode);
  1607. +     else
  1608. +       ino = file_ino (de->fnode);
  1609. +     write_one_dirent (dirent, de->name, namelen, ino, lc);
  1610. +     brelse (bh);
  1611. + 
  1612. +     return namelen;
  1613. +   }
  1614. + } 
  1615. + 
  1616. + /* Send the given name and ino off to the user dirent struct at *dirent.
  1617. +    Blam it to lowercase if the mount option said to.
  1618. + 
  1619. +    Note that Linux d_reclen is the length of the file name, and has nothing
  1620. +    to do with the length of the dirent record.  Why is that, do you ask?
  1621. +    I sure do.  Jeez. */
  1622. + 
  1623. + static void write_one_dirent (struct dirent *dirent, const unsigned char *name,
  1624. +                   unsigned namelen, ino_t ino, int lowercase)
  1625. + {
  1626. +   unsigned n;
  1627. + 
  1628. +   put_fs_long (ino, &dirent->d_ino);
  1629. +   put_fs_word (namelen, &dirent->d_reclen);
  1630. + 
  1631. +   if (lowercase)
  1632. +     for (n = namelen; n != 0; ) {
  1633. +       unsigned t = name[--n];
  1634. +       if (t - 'A' < 26) t += 040;
  1635. +       put_fs_byte (t, &dirent->d_name[n]);
  1636. +     }
  1637. +   else
  1638. +     memcpy_tofs (dirent->d_name, name, namelen);
  1639. + 
  1640. +   put_fs_byte (0, &dirent->d_name[namelen]);
  1641. + }
  1642. + 
  1643. + /* Map the dir entry at subtree coordinates given by *posp, and
  1644. +    increment *posp to point to the following dir entry. */
  1645. + 
  1646. + static struct hpfs_dirent *map_pos_dirent (struct inode *inode, off_t *posp,
  1647. +                        struct buffer_head **bhp)
  1648. + {
  1649. +   unsigned pos, q, r;
  1650. +   dnode_secno dno;
  1651. +   struct hpfs_dirent *de;
  1652. + 
  1653. +   /* Get the position code and split off the rightmost index */
  1654. + 
  1655. +   pos = *posp;
  1656. +   q = pos >> 6;
  1657. +   r = pos & 077;
  1658. + 
  1659. +   /* Get the sector address of the dnode pointed to by the leading part */
  1660. + 
  1661. +   dno = dir_subdno (inode, q);
  1662. +   if (! dno) return 0;
  1663. + 
  1664. +   /* Get the entry at index r in dnode q */
  1665. + 
  1666. +   de = map_nth_dirent (inode->i_dev, dno, r, bhp);
  1667. + 
  1668. +   /* If none, we're out of files at this level.  Ascend. */
  1669. + 
  1670. +   if (! de) {
  1671. +     if (q == 0) return 0;
  1672. +     *posp = q + 1;
  1673. +     return map_pos_dirent (inode, posp, bhp);
  1674. +   }
  1675. + 
  1676. +   /* If a subtree is here, descend. */
  1677. + 
  1678. +   if (de->down)
  1679. +     *posp = pos << 6 | 1;
  1680. +   else
  1681. +     *posp = pos + 1;
  1682. + 
  1683. +   /* Don't return the ^A^A and \377 entries. */
  1684. + 
  1685. +   if (de->first || de->last) {
  1686. +     brelse (*bhp);
  1687. +     return map_pos_dirent (inode, posp, bhp);
  1688. +   } else
  1689. +     return de;
  1690. + }
  1691. + 
  1692. + /* Return the address of the dnode with subtree coordinates given by pos. */
  1693. + 
  1694. + static dnode_secno dir_subdno (struct inode *inode, unsigned pos)
  1695. + {
  1696. +   struct hpfs_dirent *de;
  1697. +   struct buffer_head *bh;
  1698. + 
  1699. +   /* 0 is the root dnode */
  1700. + 
  1701. +   if (pos == 0)
  1702. +     return inode->i_hpfs_dno;
  1703. + 
  1704. +   /* we have one pos->dnode translation cached in the inode */
  1705. + 
  1706. +   else if (pos == inode->i_hpfs_dpos)
  1707. +     return inode->i_hpfs_dsubdno;
  1708. + 
  1709. +   /* otherwise go look */
  1710. + 
  1711. +   else {
  1712. +     unsigned q = pos >> 6;
  1713. +     unsigned r = pos & 077;
  1714. +     dnode_secno dno;
  1715. + 
  1716. +     /* dnode at position q */
  1717. +     dno = dir_subdno (inode, q);
  1718. +     if (dno == 0) return 0;
  1719. + 
  1720. +     /* entry at index r */
  1721. +     de = map_nth_dirent (inode->i_dev, dno, r, &bh);
  1722. +     if (! de || ! de->down) return 0;
  1723. + 
  1724. +     /* get the dnode down pointer */
  1725. +     dno = *(dnode_secno *) ((void *) de + de->length - 4);
  1726. +     brelse (bh);
  1727. + 
  1728. +     /* cache it for next time */
  1729. +     inode->i_hpfs_dpos = pos;
  1730. +     inode->i_hpfs_dsubdno = dno;
  1731. +     return dno;
  1732. +   }
  1733. + }
  1734. + 
  1735. + /* Return the dir entry at index n in dnode dno, or 0 if there isn't one */
  1736. + 
  1737. + static struct hpfs_dirent *map_nth_dirent (dev_t dev, dnode_secno dno,
  1738. +                        int n, struct buffer_head **bhp)
  1739. + {
  1740. +   int i;
  1741. +   struct hpfs_dirent *de, *de_end;
  1742. +   struct dnode *dnode = map_dnode (dev, dno, bhp);
  1743. + 
  1744. +   de = (void *) dnode->dirent;
  1745. +   de_end = (void *) de + dnode->first_free;
  1746. + 
  1747. +   for (i = 1; de < de_end; i++, de = (void *) de + de->length) {
  1748. +     if (i == n)
  1749. +       return de;
  1750. +     if (de->last || de->length == 0)
  1751. +       break;
  1752. +   }
  1753. + 
  1754. +   brelse (*bhp);
  1755. +   return 0;
  1756. + }
  1757. + 
  1758. + static int hpfs_dir_read (struct inode *inode, struct file *filp,
  1759. +               char *buf, int count)
  1760. + {
  1761. +   return -EISDIR;
  1762. + }
  1763. + 
  1764. + static int hpfs_create (struct inode * dir, const char *name, int len,
  1765. +             int mode, struct inode **result)
  1766. + {
  1767. +   return -EROFS;
  1768. + }
  1769. + 
  1770. + static int hpfs_unlink (struct inode *dir, const char *name, int len)
  1771. + {
  1772. +   return -EROFS;
  1773. + }
  1774. + 
  1775. + static int hpfs_mkdir (struct inode *dir, const char *name, int len, int mode)
  1776. + {
  1777. +   return -EROFS;
  1778. + }
  1779. + 
  1780. + static int hpfs_rmdir (struct inode *dir, const char *name, int len)
  1781. + {
  1782. +   return -EROFS;
  1783. + }
  1784. + 
  1785. + static int hpfs_rename
  1786. +     (struct inode *old_dir, const char *old_name, int old_len,
  1787. +      struct inode *new_dir, const char *new_name, int new_len)
  1788. + {
  1789. +   return -EROFS;
  1790. + }
  1791. + 
  1792. + /* Return the dnode pointer in a directory fnode */
  1793. + 
  1794. + static dnode_secno fnode_dno (dev_t dev, ino_t ino)
  1795. + {
  1796. +   struct buffer_head *bh;
  1797. +   struct fnode *fnode;
  1798. +   dnode_secno dno; 
  1799. + 
  1800. +   fnode = map_fnode (dev, ino, &bh);
  1801. +   if (! fnode) return 0;
  1802. + 
  1803. +   dno = fnode->u.external[0].disk_secno;
  1804. +   brelse (bh);
  1805. +   return dno;
  1806. + }
  1807. + 
  1808. + /* Map an fnode into a buffer and return pointers to it and to the buffer. */
  1809. + 
  1810. + static void *map_fnode (dev_t dev, ino_t ino, struct buffer_head **bhp)
  1811. + {
  1812. +   struct fnode *fnode;
  1813. + 
  1814. +   if (ino == 0)
  1815. +     { printk ("HPFS: missing fnode\n"); return 0; }
  1816. + 
  1817. +   fnode = map_sector (dev, ino_secno (ino), bhp);
  1818. +   if (fnode)
  1819. +     if (fnode->magic != FNODE_MAGIC || fnode->huhc4 != 0xc4)
  1820. +       { printk ("HPFS: map_fnode: in the weeds\n"); brelse (*bhp); return 0; }
  1821. +   return fnode;
  1822. + }
  1823. + 
  1824. + /* Map an anode into a buffer and return pointers to it and to the buffer. */
  1825. + 
  1826. + static void *map_anode (dev_t dev, unsigned secno, struct buffer_head **bhp)
  1827. + {
  1828. +   struct anode *anode;
  1829. + 
  1830. +   if (secno == 0)
  1831. +     { printk ("HPFS: missing anode\n"); return 0; }
  1832. + 
  1833. +   anode = map_sector (dev, secno, bhp);
  1834. +   if (anode)
  1835. +     if (anode->magic != ANODE_MAGIC || anode->self != secno)
  1836. +       { printk ("HPFS: map_anode: in the weeds\n"); brelse (*bhp); return 0; }
  1837. +   return anode;
  1838. + }
  1839. + 
  1840. + /* Map a dnode into a buffer and return pointers to it and to the buffer. */
  1841. + 
  1842. + static void *map_dnode (dev_t dev, unsigned secno, struct buffer_head **bhp)
  1843. + {
  1844. +   struct dnode *dnode; 
  1845. + 
  1846. +   if (secno == 0)
  1847. +     { printk ("HPFS: missing dnode\n"); return 0; }
  1848. + 
  1849. +   dnode = map_4sectors (dev, secno, bhp);
  1850. +   if (dnode)
  1851. +     if (dnode->magic != DNODE_MAGIC || dnode->self != secno)
  1852. +       { printk ("HPFS: map_dnode: in the weeds\n"); brelse (*bhp); return 0; }
  1853. +   return dnode;
  1854. + }
  1855. + 
  1856. + /* Map a sector into a buffer and return pointers to it and to the buffer. */
  1857. + 
  1858. + static void *map_sector (dev_t dev, unsigned secno, struct buffer_head **bhp)
  1859. + {
  1860. +   unsigned q, r;
  1861. +   struct buffer_head *bh;
  1862. + 
  1863. +   q = secno >> 2;
  1864. +   r = (secno & 3) << 9;
  1865. + 
  1866. +   if ((*bhp = bh = bread (dev, q, 2048)) != 0)
  1867. +     return bh->b_data + r;
  1868. +   else
  1869. +     { printk ("HPFS: map_sector: read error\n"); return 0; }
  1870. + }
  1871. + 
  1872. + /* Map 4 sectors into a buffer and return pointers to it and to the buffer. */
  1873. + 
  1874. + static void *map_4sectors (dev_t dev, unsigned secno, struct buffer_head **bhp)
  1875. + {
  1876. +   struct buffer_head *bh;
  1877. + 
  1878. +   if (secno & 3)
  1879. +     { printk ("HPFS: map_4sectors: unaligned read\n"); return 0; }
  1880. + 
  1881. +   if ((*bhp = bh = bread (dev, secno >> 2, 2048)) != 0)
  1882. +     return bh->b_data;
  1883. +   else 
  1884. +     { printk ("HPFS: map_4sectors: read error\n"); return 0; }
  1885. + }
  1886. diff -rc2N linux-dist/include/linux/fs.h linux/include/linux/fs.h
  1887. *** linux-dist/include/linux/fs.h    Sun Sep 19 13:53:23 1993
  1888. --- linux/include/linux/fs.h    Sun Oct 10 12:17:36 1993
  1889. ***************
  1890. *** 169,172 ****
  1891. --- 169,173 ----
  1892.   #include <linux/ext_fs_i.h>
  1893.   #include <linux/ext2_fs_i.h>
  1894. + #include <linux/hpfs_fs_i.h>
  1895.   #include <linux/msdos_fs_i.h>
  1896.   #include <linux/iso_fs_i.h>
  1897. ***************
  1898. *** 209,212 ****
  1899. --- 210,214 ----
  1900.           struct ext_inode_info ext_i;
  1901.           struct ext2_inode_info ext2_i;
  1902. +         struct hpfs_inode_info hpfs_i;
  1903.           struct msdos_inode_info msdos_i;
  1904.           struct iso_inode_info isofs_i;
  1905. ***************
  1906. *** 242,245 ****
  1907. --- 244,248 ----
  1908.   #include <linux/ext_fs_sb.h>
  1909.   #include <linux/ext2_fs_sb.h>
  1910. + #include <linux/hpfs_fs_sb.h>
  1911.   #include <linux/msdos_fs_sb.h>
  1912.   #include <linux/iso_fs_sb.h>
  1913. ***************
  1914. *** 265,268 ****
  1915. --- 268,272 ----
  1916.           struct ext_sb_info ext_sb;
  1917.           struct ext2_sb_info ext2_sb;
  1918. +         struct hpfs_sb_info hpfs_sb;
  1919.           struct msdos_sb_info msdos_sb;
  1920.           struct isofs_sb_info isofs_sb;
  1921. diff -rc2N linux-dist/include/linux/hpfs_fs.h linux/include/linux/hpfs_fs.h
  1922. *** linux-dist/include/linux/hpfs_fs.h
  1923. --- linux/include/linux/hpfs_fs.h    Sun Oct 10 12:17:36 1993
  1924. ***************
  1925. *** 0 ****
  1926. --- 1,12 ----
  1927. + #ifndef _LINUX_HPFS_FS_H
  1928. + #define _LINUX_HPFS_FS_H
  1929. + 
  1930. + /* HPFS magic number (the real thing, word 0 of block 16) */
  1931. + 
  1932. + #define HPFS_SUPER_MAGIC 0xf995e849
  1933. + 
  1934. + /* The entry point for a VFS */
  1935. + 
  1936. + extern struct super_block *hpfs_read_super (struct super_block *, void *, int);
  1937. + 
  1938. + #endif
  1939. diff -rc2N linux-dist/include/linux/hpfs_fs_i.h linux/include/linux/hpfs_fs_i.h
  1940. *** linux-dist/include/linux/hpfs_fs_i.h
  1941. --- linux/include/linux/hpfs_fs_i.h    Sun Oct 10 12:17:36 1993
  1942. ***************
  1943. *** 0 ****
  1944. --- 1,24 ----
  1945. + #ifndef _HPFS_FS_I
  1946. + #define _HPFS_FS_I
  1947. + 
  1948. + struct hpfs_inode_info {
  1949. +   ino_t i_parent_dir;        /* (directories) gives fnode of parent dir */
  1950. +   unsigned i_dno;        /* (directories) root dnode */
  1951. +   unsigned i_dpos;        /* (directories) temp for readdir */
  1952. +   unsigned i_dsubdno;        /* (directories) temp for readdir */
  1953. +   unsigned i_file_sec;        /* (files) minimalist cache of alloc info */
  1954. +   unsigned i_disk_sec;        /* (files) minimalist cache of alloc info */
  1955. +   unsigned i_n_secs;        /* (files) minimalist cache of alloc info */
  1956. +   unsigned i_conv : 2;        /* (files) crlf->newline hackery */
  1957. + };
  1958. + 
  1959. + #define i_hpfs_dno u.hpfs_i.i_dno
  1960. + #define i_hpfs_parent_dir u.hpfs_i.i_parent_dir
  1961. + #define i_hpfs_n_secs u.hpfs_i.i_n_secs
  1962. + #define i_hpfs_file_sec u.hpfs_i.i_file_sec
  1963. + #define i_hpfs_disk_sec u.hpfs_i.i_disk_sec
  1964. + #define i_hpfs_dpos u.hpfs_i.i_dpos
  1965. + #define i_hpfs_dsubdno u.hpfs_i.i_dsubdno
  1966. + #define i_hpfs_conv u.hpfs_i.i_conv
  1967. + 
  1968. + #endif
  1969. diff -rc2N linux-dist/include/linux/hpfs_fs_sb.h linux/include/linux/hpfs_fs_sb.h
  1970. *** linux-dist/include/linux/hpfs_fs_sb.h
  1971. --- linux/include/linux/hpfs_fs_sb.h    Sun Oct 10 12:17:37 1993
  1972. ***************
  1973. *** 0 ****
  1974. --- 1,31 ----
  1975. + #ifndef _HPFS_FS_SB
  1976. + #define _HPFS_FS_SB
  1977. + 
  1978. + struct hpfs_sb_info
  1979. + {
  1980. +   ino_t sb_root;        /* inode number of root dir */
  1981. +   unsigned sb_fs_size;        /* file system size, sectors */
  1982. +   unsigned sb_dirband_size;    /* directory band size, dnodes */
  1983. +   unsigned sb_dmap;        /* sector number of dnode bit map */
  1984. +   unsigned sb_n_free;        /* free blocks for statfs, or -1 */
  1985. +   unsigned sb_n_free_dnodes;    /* free dnodes for statfs, or -1 */
  1986. +   uid_t sb_uid;            /* uid from mount options */
  1987. +   gid_t sb_gid;            /* gid from mount options */
  1988. +   umode_t sb_mode;        /* mode from mount options */
  1989. +   unsigned sb_lowercase : 1;    /* downcase filenames hackery */
  1990. +   unsigned sb_conv : 2;        /* crlf->newline hackery */
  1991. + };
  1992. + 
  1993. + #define s_hpfs_root u.hpfs_sb.sb_root
  1994. + #define s_hpfs_fs_size u.hpfs_sb.sb_fs_size
  1995. + #define s_hpfs_dirband_size u.hpfs_sb.sb_dirband_size
  1996. + #define s_hpfs_dmap u.hpfs_sb.sb_dmap
  1997. + #define s_hpfs_uid u.hpfs_sb.sb_uid
  1998. + #define s_hpfs_gid u.hpfs_sb.sb_gid
  1999. + #define s_hpfs_mode u.hpfs_sb.sb_mode
  2000. + #define s_hpfs_n_free u.hpfs_sb.sb_n_free
  2001. + #define s_hpfs_n_free_dnodes u.hpfs_sb.sb_n_free_dnodes
  2002. + #define s_hpfs_lowercase u.hpfs_sb.sb_lowercase
  2003. + #define s_hpfs_conv u.hpfs_sb.sb_conv
  2004. + 
  2005. + #endif
  2006.