xref: /openbmc/linux/fs/hpfs/super.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *  linux/fs/hpfs/super.c
3  *
4  *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
5  *
6  *  mounting, unmounting, error handling
7  */
8 
9 #include "hpfs_fn.h"
10 #include <linux/module.h>
11 #include <linux/parser.h>
12 #include <linux/init.h>
13 #include <linux/statfs.h>
14 
15 /* Mark the filesystem dirty, so that chkdsk checks it when os/2 booted */
16 
17 static void mark_dirty(struct super_block *s)
18 {
19 	if (hpfs_sb(s)->sb_chkdsk && !(s->s_flags & MS_RDONLY)) {
20 		struct buffer_head *bh;
21 		struct hpfs_spare_block *sb;
22 		if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
23 			sb->dirty = 1;
24 			sb->old_wrote = 0;
25 			mark_buffer_dirty(bh);
26 			brelse(bh);
27 		}
28 	}
29 }
30 
31 /* Mark the filesystem clean (mark it dirty for chkdsk if chkdsk==2 or if there
32    were errors) */
33 
34 static void unmark_dirty(struct super_block *s)
35 {
36 	struct buffer_head *bh;
37 	struct hpfs_spare_block *sb;
38 	if (s->s_flags & MS_RDONLY) return;
39 	if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
40 		sb->dirty = hpfs_sb(s)->sb_chkdsk > 1 - hpfs_sb(s)->sb_was_error;
41 		sb->old_wrote = hpfs_sb(s)->sb_chkdsk >= 2 && !hpfs_sb(s)->sb_was_error;
42 		mark_buffer_dirty(bh);
43 		brelse(bh);
44 	}
45 }
46 
47 /* Filesystem error... */
48 
49 #define ERR_BUF_SIZE 1024
50 
51 void hpfs_error(struct super_block *s, char *m,...)
52 {
53 	char *buf;
54 	va_list l;
55 	va_start(l, m);
56 	if (!(buf = kmalloc(ERR_BUF_SIZE, GFP_KERNEL)))
57 		printk("HPFS: No memory for error message '%s'\n",m);
58 	else if (vsprintf(buf, m, l) >= ERR_BUF_SIZE)
59 		printk("HPFS: Grrrr... Kernel memory corrupted ... going on, but it'll crash very soon :-(\n");
60 	printk("HPFS: filesystem error: ");
61 	if (buf) printk("%s", buf);
62 	else printk("%s\n",m);
63 	if (!hpfs_sb(s)->sb_was_error) {
64 		if (hpfs_sb(s)->sb_err == 2) {
65 			printk("; crashing the system because you wanted it\n");
66 			mark_dirty(s);
67 			panic("HPFS panic");
68 		} else if (hpfs_sb(s)->sb_err == 1) {
69 			if (s->s_flags & MS_RDONLY) printk("; already mounted read-only\n");
70 			else {
71 				printk("; remounting read-only\n");
72 				mark_dirty(s);
73 				s->s_flags |= MS_RDONLY;
74 			}
75 		} else if (s->s_flags & MS_RDONLY) printk("; going on - but anything won't be destroyed because it's read-only\n");
76 		else printk("; corrupted filesystem mounted read/write - your computer will explode within 20 seconds ... but you wanted it so!\n");
77 	} else printk("\n");
78 	if (buf) kfree(buf);
79 	hpfs_sb(s)->sb_was_error = 1;
80 }
81 
82 /*
83  * A little trick to detect cycles in many hpfs structures and don't let the
84  * kernel crash on corrupted filesystem. When first called, set c2 to 0.
85  *
86  * BTW. chkdsk doesn't detect cycles correctly. When I had 2 lost directories
87  * nested each in other, chkdsk locked up happilly.
88  */
89 
90 int hpfs_stop_cycles(struct super_block *s, int key, int *c1, int *c2,
91 		char *msg)
92 {
93 	if (*c2 && *c1 == key) {
94 		hpfs_error(s, "cycle detected on key %08x in %s", key, msg);
95 		return 1;
96 	}
97 	(*c2)++;
98 	if (!((*c2 - 1) & *c2)) *c1 = key;
99 	return 0;
100 }
101 
102 static void hpfs_put_super(struct super_block *s)
103 {
104 	struct hpfs_sb_info *sbi = hpfs_sb(s);
105 	if (sbi->sb_cp_table) kfree(sbi->sb_cp_table);
106 	if (sbi->sb_bmp_dir) kfree(sbi->sb_bmp_dir);
107 	unmark_dirty(s);
108 	s->s_fs_info = NULL;
109 	kfree(sbi);
110 }
111 
112 unsigned hpfs_count_one_bitmap(struct super_block *s, secno secno)
113 {
114 	struct quad_buffer_head qbh;
115 	unsigned *bits;
116 	unsigned i, count;
117 	if (!(bits = hpfs_map_4sectors(s, secno, &qbh, 4))) return 0;
118 	count = 0;
119 	for (i = 0; i < 2048 / sizeof(unsigned); i++) {
120 		unsigned b;
121 		if (!bits[i]) continue;
122 		for (b = bits[i]; b; b>>=1) count += b & 1;
123 	}
124 	hpfs_brelse4(&qbh);
125 	return count;
126 }
127 
128 static unsigned count_bitmaps(struct super_block *s)
129 {
130 	unsigned n, count, n_bands;
131 	n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14;
132 	count = 0;
133 	for (n = 0; n < n_bands; n++)
134 		count += hpfs_count_one_bitmap(s, hpfs_sb(s)->sb_bmp_dir[n]);
135 	return count;
136 }
137 
138 static int hpfs_statfs(struct super_block *s, struct kstatfs *buf)
139 {
140 	struct hpfs_sb_info *sbi = hpfs_sb(s);
141 	lock_kernel();
142 
143 	/*if (sbi->sb_n_free == -1) {*/
144 		sbi->sb_n_free = count_bitmaps(s);
145 		sbi->sb_n_free_dnodes = hpfs_count_one_bitmap(s, sbi->sb_dmap);
146 	/*}*/
147 	buf->f_type = s->s_magic;
148 	buf->f_bsize = 512;
149 	buf->f_blocks = sbi->sb_fs_size;
150 	buf->f_bfree = sbi->sb_n_free;
151 	buf->f_bavail = sbi->sb_n_free;
152 	buf->f_files = sbi->sb_dirband_size / 4;
153 	buf->f_ffree = sbi->sb_n_free_dnodes;
154 	buf->f_namelen = 254;
155 
156 	unlock_kernel();
157 
158 	return 0;
159 }
160 
161 static kmem_cache_t * hpfs_inode_cachep;
162 
163 static struct inode *hpfs_alloc_inode(struct super_block *sb)
164 {
165 	struct hpfs_inode_info *ei;
166 	ei = (struct hpfs_inode_info *)kmem_cache_alloc(hpfs_inode_cachep, SLAB_NOFS);
167 	if (!ei)
168 		return NULL;
169 	ei->vfs_inode.i_version = 1;
170 	return &ei->vfs_inode;
171 }
172 
173 static void hpfs_destroy_inode(struct inode *inode)
174 {
175 	kmem_cache_free(hpfs_inode_cachep, hpfs_i(inode));
176 }
177 
178 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
179 {
180 	struct hpfs_inode_info *ei = (struct hpfs_inode_info *) foo;
181 
182 	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
183 	    SLAB_CTOR_CONSTRUCTOR) {
184 		init_MUTEX(&ei->i_sem);
185 		init_MUTEX(&ei->i_parent);
186 		inode_init_once(&ei->vfs_inode);
187 	}
188 }
189 
190 static int init_inodecache(void)
191 {
192 	hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache",
193 					     sizeof(struct hpfs_inode_info),
194 					     0, SLAB_RECLAIM_ACCOUNT,
195 					     init_once, NULL);
196 	if (hpfs_inode_cachep == NULL)
197 		return -ENOMEM;
198 	return 0;
199 }
200 
201 static void destroy_inodecache(void)
202 {
203 	if (kmem_cache_destroy(hpfs_inode_cachep))
204 		printk(KERN_INFO "hpfs_inode_cache: not all structures were freed\n");
205 }
206 
207 /*
208  * A tiny parser for option strings, stolen from dosfs.
209  * Stolen again from read-only hpfs.
210  * And updated for table-driven option parsing.
211  */
212 
213 enum {
214 	Opt_help, Opt_uid, Opt_gid, Opt_umask, Opt_case_lower, Opt_case_asis,
215 	Opt_conv_binary, Opt_conv_text, Opt_conv_auto,
216 	Opt_check_none, Opt_check_normal, Opt_check_strict,
217 	Opt_err_cont, Opt_err_ro, Opt_err_panic,
218 	Opt_eas_no, Opt_eas_ro, Opt_eas_rw,
219 	Opt_chkdsk_no, Opt_chkdsk_errors, Opt_chkdsk_always,
220 	Opt_timeshift, Opt_err,
221 };
222 
223 static match_table_t tokens = {
224 	{Opt_help, "help"},
225 	{Opt_uid, "uid=%u"},
226 	{Opt_gid, "gid=%u"},
227 	{Opt_umask, "umask=%o"},
228 	{Opt_case_lower, "case=lower"},
229 	{Opt_case_asis, "case=asis"},
230 	{Opt_conv_binary, "conv=binary"},
231 	{Opt_conv_text, "conv=text"},
232 	{Opt_conv_auto, "conv=auto"},
233 	{Opt_check_none, "check=none"},
234 	{Opt_check_normal, "check=normal"},
235 	{Opt_check_strict, "check=strict"},
236 	{Opt_err_cont, "errors=continue"},
237 	{Opt_err_ro, "errors=remount-ro"},
238 	{Opt_err_panic, "errors=panic"},
239 	{Opt_eas_no, "eas=no"},
240 	{Opt_eas_ro, "eas=ro"},
241 	{Opt_eas_rw, "eas=rw"},
242 	{Opt_chkdsk_no, "chkdsk=no"},
243 	{Opt_chkdsk_errors, "chkdsk=errors"},
244 	{Opt_chkdsk_always, "chkdsk=always"},
245 	{Opt_timeshift, "timeshift=%d"},
246 	{Opt_err, NULL},
247 };
248 
249 static int parse_opts(char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
250 		      int *lowercase, int *conv, int *eas, int *chk, int *errs,
251 		      int *chkdsk, int *timeshift)
252 {
253 	char *p;
254 	int option;
255 
256 	if (!opts)
257 		return 1;
258 
259 	/*printk("Parsing opts: '%s'\n",opts);*/
260 
261 	while ((p = strsep(&opts, ",")) != NULL) {
262 		substring_t args[MAX_OPT_ARGS];
263 		int token;
264 		if (!*p)
265 			continue;
266 
267 		token = match_token(p, tokens, args);
268 		switch (token) {
269 		case Opt_help:
270 			return 2;
271 		case Opt_uid:
272 			if (match_int(args, &option))
273 				return 0;
274 			*uid = option;
275 			break;
276 		case Opt_gid:
277 			if (match_int(args, &option))
278 				return 0;
279 			*gid = option;
280 			break;
281 		case Opt_umask:
282 			if (match_octal(args, &option))
283 				return 0;
284 			*umask = option;
285 			break;
286 		case Opt_case_lower:
287 			*lowercase = 1;
288 			break;
289 		case Opt_case_asis:
290 			*lowercase = 0;
291 			break;
292 		case Opt_conv_binary:
293 			*conv = CONV_BINARY;
294 			break;
295 		case Opt_conv_text:
296 			*conv = CONV_TEXT;
297 			break;
298 		case Opt_conv_auto:
299 			*conv = CONV_AUTO;
300 			break;
301 		case Opt_check_none:
302 			*chk = 0;
303 			break;
304 		case Opt_check_normal:
305 			*chk = 1;
306 			break;
307 		case Opt_check_strict:
308 			*chk = 2;
309 			break;
310 		case Opt_err_cont:
311 			*errs = 0;
312 			break;
313 		case Opt_err_ro:
314 			*errs = 1;
315 			break;
316 		case Opt_err_panic:
317 			*errs = 2;
318 			break;
319 		case Opt_eas_no:
320 			*eas = 0;
321 			break;
322 		case Opt_eas_ro:
323 			*eas = 1;
324 			break;
325 		case Opt_eas_rw:
326 			*eas = 2;
327 			break;
328 		case Opt_chkdsk_no:
329 			*chkdsk = 0;
330 			break;
331 		case Opt_chkdsk_errors:
332 			*chkdsk = 1;
333 			break;
334 		case Opt_chkdsk_always:
335 			*chkdsk = 2;
336 			break;
337 		case Opt_timeshift:
338 		{
339 			int m = 1;
340 			char *rhs = args[0].from;
341 			if (!rhs || !*rhs)
342 				return 0;
343 			if (*rhs == '-') m = -1;
344 			if (*rhs == '+' || *rhs == '-') rhs++;
345 			*timeshift = simple_strtoul(rhs, &rhs, 0) * m;
346 			if (*rhs)
347 				return 0;
348 			break;
349 		}
350 		default:
351 			return 0;
352 		}
353 	}
354 	return 1;
355 }
356 
357 static inline void hpfs_help(void)
358 {
359 	printk("\n\
360 HPFS filesystem options:\n\
361       help              do not mount and display this text\n\
362       uid=xxx           set uid of files that don't have uid specified in eas\n\
363       gid=xxx           set gid of files that don't have gid specified in eas\n\
364       umask=xxx         set mode of files that don't have mode specified in eas\n\
365       case=lower        lowercase all files\n\
366       case=asis         do not lowercase files (default)\n\
367       conv=binary       do not convert CR/LF -> LF (default)\n\
368       conv=auto         convert only files with known text extensions\n\
369       conv=text         convert all files\n\
370       check=none        no fs checks - kernel may crash on corrupted filesystem\n\
371       check=normal      do some checks - it should not crash (default)\n\
372       check=strict      do extra time-consuming checks, used for debugging\n\
373       errors=continue   continue on errors\n\
374       errors=remount-ro remount read-only if errors found (default)\n\
375       errors=panic      panic on errors\n\
376       chkdsk=no         do not mark fs for chkdsking even if there were errors\n\
377       chkdsk=errors     mark fs dirty if errors found (default)\n\
378       chkdsk=always     always mark fs dirty - used for debugging\n\
379       eas=no            ignore extended attributes\n\
380       eas=ro            read but do not write extended attributes\n\
381       eas=rw            r/w eas => enables chmod, chown, mknod, ln -s (default)\n\
382       timeshift=nnn	add nnn seconds to file times\n\
383 \n");
384 }
385 
386 static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
387 {
388 	uid_t uid;
389 	gid_t gid;
390 	umode_t umask;
391 	int lowercase, conv, eas, chk, errs, chkdsk, timeshift;
392 	int o;
393 	struct hpfs_sb_info *sbi = hpfs_sb(s);
394 
395 	*flags |= MS_NOATIME;
396 
397 	uid = sbi->sb_uid; gid = sbi->sb_gid;
398 	umask = 0777 & ~sbi->sb_mode;
399 	lowercase = sbi->sb_lowercase; conv = sbi->sb_conv;
400 	eas = sbi->sb_eas; chk = sbi->sb_chk; chkdsk = sbi->sb_chkdsk;
401 	errs = sbi->sb_err; timeshift = sbi->sb_timeshift;
402 
403 	if (!(o = parse_opts(data, &uid, &gid, &umask, &lowercase, &conv,
404 	    &eas, &chk, &errs, &chkdsk, &timeshift))) {
405 		printk("HPFS: bad mount options.\n");
406 	    	return 1;
407 	}
408 	if (o == 2) {
409 		hpfs_help();
410 		return 1;
411 	}
412 	if (timeshift != sbi->sb_timeshift) {
413 		printk("HPFS: timeshift can't be changed using remount.\n");
414 		return 1;
415 	}
416 
417 	unmark_dirty(s);
418 
419 	sbi->sb_uid = uid; sbi->sb_gid = gid;
420 	sbi->sb_mode = 0777 & ~umask;
421 	sbi->sb_lowercase = lowercase; sbi->sb_conv = conv;
422 	sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk;
423 	sbi->sb_err = errs; sbi->sb_timeshift = timeshift;
424 
425 	if (!(*flags & MS_RDONLY)) mark_dirty(s);
426 
427 	return 0;
428 }
429 
430 /* Super operations */
431 
432 static struct super_operations hpfs_sops =
433 {
434 	.alloc_inode	= hpfs_alloc_inode,
435 	.destroy_inode	= hpfs_destroy_inode,
436 	.delete_inode	= hpfs_delete_inode,
437 	.put_super	= hpfs_put_super,
438 	.statfs		= hpfs_statfs,
439 	.remount_fs	= hpfs_remount_fs,
440 };
441 
442 static int hpfs_fill_super(struct super_block *s, void *options, int silent)
443 {
444 	struct buffer_head *bh0, *bh1, *bh2;
445 	struct hpfs_boot_block *bootblock;
446 	struct hpfs_super_block *superblock;
447 	struct hpfs_spare_block *spareblock;
448 	struct hpfs_sb_info *sbi;
449 	struct inode *root;
450 
451 	uid_t uid;
452 	gid_t gid;
453 	umode_t umask;
454 	int lowercase, conv, eas, chk, errs, chkdsk, timeshift;
455 
456 	dnode_secno root_dno;
457 	struct hpfs_dirent *de = NULL;
458 	struct quad_buffer_head qbh;
459 
460 	int o;
461 
462 	sbi = kmalloc(sizeof(*sbi), GFP_KERNEL);
463 	if (!sbi)
464 		return -ENOMEM;
465 	s->s_fs_info = sbi;
466 	memset(sbi, 0, sizeof(*sbi));
467 
468 	sbi->sb_bmp_dir = NULL;
469 	sbi->sb_cp_table = NULL;
470 
471 	init_MUTEX(&sbi->hpfs_creation_de);
472 
473 	uid = current->uid;
474 	gid = current->gid;
475 	umask = current->fs->umask;
476 	lowercase = 0;
477 	conv = CONV_BINARY;
478 	eas = 2;
479 	chk = 1;
480 	errs = 1;
481 	chkdsk = 1;
482 	timeshift = 0;
483 
484 	if (!(o = parse_opts(options, &uid, &gid, &umask, &lowercase, &conv,
485 	    &eas, &chk, &errs, &chkdsk, &timeshift))) {
486 		printk("HPFS: bad mount options.\n");
487 		goto bail0;
488 	}
489 	if (o==2) {
490 		hpfs_help();
491 		goto bail0;
492 	}
493 
494 	/*sbi->sb_mounting = 1;*/
495 	sb_set_blocksize(s, 512);
496 	sbi->sb_fs_size = -1;
497 	if (!(bootblock = hpfs_map_sector(s, 0, &bh0, 0))) goto bail1;
498 	if (!(superblock = hpfs_map_sector(s, 16, &bh1, 1))) goto bail2;
499 	if (!(spareblock = hpfs_map_sector(s, 17, &bh2, 0))) goto bail3;
500 
501 	/* Check magics */
502 	if (/*bootblock->magic != BB_MAGIC
503 	    ||*/ superblock->magic != SB_MAGIC
504 	    || spareblock->magic != SP_MAGIC) {
505 		if (!silent) printk("HPFS: Bad magic ... probably not HPFS\n");
506 		goto bail4;
507 	}
508 
509 	/* Check version */
510 	if (!(s->s_flags & MS_RDONLY) &&
511 	      superblock->funcversion != 2 && superblock->funcversion != 3) {
512 		printk("HPFS: Bad version %d,%d. Mount readonly to go around\n",
513 			(int)superblock->version, (int)superblock->funcversion);
514 		printk("HPFS: please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - mikulas@artax.karlin.mff.cuni.cz\n");
515 		goto bail4;
516 	}
517 
518 	s->s_flags |= MS_NOATIME;
519 
520 	/* Fill superblock stuff */
521 	s->s_magic = HPFS_SUPER_MAGIC;
522 	s->s_op = &hpfs_sops;
523 
524 	sbi->sb_root = superblock->root;
525 	sbi->sb_fs_size = superblock->n_sectors;
526 	sbi->sb_bitmaps = superblock->bitmaps;
527 	sbi->sb_dirband_start = superblock->dir_band_start;
528 	sbi->sb_dirband_size = superblock->n_dir_band;
529 	sbi->sb_dmap = superblock->dir_band_bitmap;
530 	sbi->sb_uid = uid;
531 	sbi->sb_gid = gid;
532 	sbi->sb_mode = 0777 & ~umask;
533 	sbi->sb_n_free = -1;
534 	sbi->sb_n_free_dnodes = -1;
535 	sbi->sb_lowercase = lowercase;
536 	sbi->sb_conv = conv;
537 	sbi->sb_eas = eas;
538 	sbi->sb_chk = chk;
539 	sbi->sb_chkdsk = chkdsk;
540 	sbi->sb_err = errs;
541 	sbi->sb_timeshift = timeshift;
542 	sbi->sb_was_error = 0;
543 	sbi->sb_cp_table = NULL;
544 	sbi->sb_c_bitmap = -1;
545 	sbi->sb_max_fwd_alloc = 0xffffff;
546 
547 	/* Load bitmap directory */
548 	if (!(sbi->sb_bmp_dir = hpfs_load_bitmap_directory(s, superblock->bitmaps)))
549 		goto bail4;
550 
551 	/* Check for general fs errors*/
552 	if (spareblock->dirty && !spareblock->old_wrote) {
553 		if (errs == 2) {
554 			printk("HPFS: Improperly stopped, not mounted\n");
555 			goto bail4;
556 		}
557 		hpfs_error(s, "improperly stopped");
558 	}
559 
560 	if (!(s->s_flags & MS_RDONLY)) {
561 		spareblock->dirty = 1;
562 		spareblock->old_wrote = 0;
563 		mark_buffer_dirty(bh2);
564 	}
565 
566 	if (spareblock->hotfixes_used || spareblock->n_spares_used) {
567 		if (errs >= 2) {
568 			printk("HPFS: Hotfixes not supported here, try chkdsk\n");
569 			mark_dirty(s);
570 			goto bail4;
571 		}
572 		hpfs_error(s, "hotfixes not supported here, try chkdsk");
573 		if (errs == 0) printk("HPFS: Proceeding, but your filesystem will be probably corrupted by this driver...\n");
574 		else printk("HPFS: This driver may read bad files or crash when operating on disk with hotfixes.\n");
575 	}
576 	if (spareblock->n_dnode_spares != spareblock->n_dnode_spares_free) {
577 		if (errs >= 2) {
578 			printk("HPFS: Spare dnodes used, try chkdsk\n");
579 			mark_dirty(s);
580 			goto bail4;
581 		}
582 		hpfs_error(s, "warning: spare dnodes used, try chkdsk");
583 		if (errs == 0) printk("HPFS: Proceeding, but your filesystem could be corrupted if you delete files or directories\n");
584 	}
585 	if (chk) {
586 		unsigned a;
587 		if (superblock->dir_band_end - superblock->dir_band_start + 1 != superblock->n_dir_band ||
588 		    superblock->dir_band_end < superblock->dir_band_start || superblock->n_dir_band > 0x4000) {
589 			hpfs_error(s, "dir band size mismatch: dir_band_start==%08x, dir_band_end==%08x, n_dir_band==%08x",
590 				superblock->dir_band_start, superblock->dir_band_end, superblock->n_dir_band);
591 			goto bail4;
592 		}
593 		a = sbi->sb_dirband_size;
594 		sbi->sb_dirband_size = 0;
595 		if (hpfs_chk_sectors(s, superblock->dir_band_start, superblock->n_dir_band, "dir_band") ||
596 		    hpfs_chk_sectors(s, superblock->dir_band_bitmap, 4, "dir_band_bitmap") ||
597 		    hpfs_chk_sectors(s, superblock->bitmaps, 4, "bitmaps")) {
598 			mark_dirty(s);
599 			goto bail4;
600 		}
601 		sbi->sb_dirband_size = a;
602 	} else printk("HPFS: You really don't want any checks? You are crazy...\n");
603 
604 	/* Load code page table */
605 	if (spareblock->n_code_pages)
606 		if (!(sbi->sb_cp_table = hpfs_load_code_page(s, spareblock->code_page_dir)))
607 			printk("HPFS: Warning: code page support is disabled\n");
608 
609 	brelse(bh2);
610 	brelse(bh1);
611 	brelse(bh0);
612 
613 	root = iget_locked(s, sbi->sb_root);
614 	if (!root)
615 		goto bail0;
616 	hpfs_init_inode(root);
617 	hpfs_read_inode(root);
618 	unlock_new_inode(root);
619 	s->s_root = d_alloc_root(root);
620 	if (!s->s_root) {
621 		iput(root);
622 		goto bail0;
623 	}
624 	hpfs_set_dentry_operations(s->s_root);
625 
626 	/*
627 	 * find the root directory's . pointer & finish filling in the inode
628 	 */
629 
630 	root_dno = hpfs_fnode_dno(s, sbi->sb_root);
631 	if (root_dno)
632 		de = map_dirent(root, root_dno, "\001\001", 2, NULL, &qbh);
633 	if (!de)
634 		hpfs_error(s, "unable to find root dir");
635 	else {
636 		root->i_atime.tv_sec = local_to_gmt(s, de->read_date);
637 		root->i_atime.tv_nsec = 0;
638 		root->i_mtime.tv_sec = local_to_gmt(s, de->write_date);
639 		root->i_mtime.tv_nsec = 0;
640 		root->i_ctime.tv_sec = local_to_gmt(s, de->creation_date);
641 		root->i_ctime.tv_nsec = 0;
642 		hpfs_i(root)->i_ea_size = de->ea_size;
643 		hpfs_i(root)->i_parent_dir = root->i_ino;
644 		if (root->i_size == -1)
645 			root->i_size = 2048;
646 		if (root->i_blocks == -1)
647 			root->i_blocks = 5;
648 		hpfs_brelse4(&qbh);
649 	}
650 	return 0;
651 
652 bail4:	brelse(bh2);
653 bail3:	brelse(bh1);
654 bail2:	brelse(bh0);
655 bail1:
656 bail0:
657 	if (sbi->sb_bmp_dir) kfree(sbi->sb_bmp_dir);
658 	if (sbi->sb_cp_table) kfree(sbi->sb_cp_table);
659 	s->s_fs_info = NULL;
660 	kfree(sbi);
661 	return -EINVAL;
662 }
663 
664 static struct super_block *hpfs_get_sb(struct file_system_type *fs_type,
665 	int flags, const char *dev_name, void *data)
666 {
667 	return get_sb_bdev(fs_type, flags, dev_name, data, hpfs_fill_super);
668 }
669 
670 static struct file_system_type hpfs_fs_type = {
671 	.owner		= THIS_MODULE,
672 	.name		= "hpfs",
673 	.get_sb		= hpfs_get_sb,
674 	.kill_sb	= kill_block_super,
675 	.fs_flags	= FS_REQUIRES_DEV,
676 };
677 
678 static int __init init_hpfs_fs(void)
679 {
680 	int err = init_inodecache();
681 	if (err)
682 		goto out1;
683 	err = register_filesystem(&hpfs_fs_type);
684 	if (err)
685 		goto out;
686 	return 0;
687 out:
688 	destroy_inodecache();
689 out1:
690 	return err;
691 }
692 
693 static void __exit exit_hpfs_fs(void)
694 {
695 	unregister_filesystem(&hpfs_fs_type);
696 	destroy_inodecache();
697 }
698 
699 module_init(init_hpfs_fs)
700 module_exit(exit_hpfs_fs)
701 MODULE_LICENSE("GPL");
702