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