inode.c 38.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *  linux/fs/isofs/inode.c
 *
 *  (C) 1991  Linus Torvalds - minix filesystem
 *      1992, 1993, 1994  Eric Youngdale Modified for ISO 9660 filesystem.
6
 *      1994  Eberhard Mönkeberg - multi session handling.
L
Linus Torvalds 已提交
7 8 9 10 11 12 13
 *      1995  Mark Dobie - allow mounting of some weird VideoCDs and PhotoCDs.
 *	1997  Gordon Chaffee - Joliet CDs
 *	1998  Eric Lammerts - ISO 9660 Level 3
 *	2004  Paul Serice - Inode Support pushed out from 4GB to 128GB
 *	2004  Paul Serice - NFS Export Operations
 */

14
#include <linux/init.h>
L
Linus Torvalds 已提交
15 16 17
#include <linux/module.h>

#include <linux/slab.h>
18
#include <linux/cred.h>
L
Linus Torvalds 已提交
19 20
#include <linux/nls.h>
#include <linux/ctype.h>
21 22
#include <linux/statfs.h>
#include <linux/cdrom.h>
L
Linus Torvalds 已提交
23
#include <linux/parser.h>
24
#include <linux/mpage.h>
25
#include <linux/user_namespace.h>
L
Linus Torvalds 已提交
26

27
#include "isofs.h"
L
Linus Torvalds 已提交
28 29 30 31
#include "zisofs.h"

#define BEQUIET

32
static int isofs_hashi(const struct dentry *parent, struct qstr *qstr);
33
static int isofs_dentry_cmpi(const struct dentry *dentry,
34
		unsigned int len, const char *str, const struct qstr *name);
L
Linus Torvalds 已提交
35 36

#ifdef CONFIG_JOLIET
37 38
static int isofs_hashi_ms(const struct dentry *parent, struct qstr *qstr);
static int isofs_hash_ms(const struct dentry *parent, struct qstr *qstr);
39
static int isofs_dentry_cmpi_ms(const struct dentry *dentry,
40
		unsigned int len, const char *str, const struct qstr *name);
41
static int isofs_dentry_cmp_ms(const struct dentry *dentry,
42
		unsigned int len, const char *str, const struct qstr *name);
L
Linus Torvalds 已提交
43 44 45 46 47
#endif

static void isofs_put_super(struct super_block *sb)
{
	struct isofs_sb_info *sbi = ISOFS_SB(sb);
48

L
Linus Torvalds 已提交
49
#ifdef CONFIG_JOLIET
50
	unload_nls(sbi->s_nls_iocharset);
L
Linus Torvalds 已提交
51 52 53 54 55 56 57
#endif

	kfree(sbi);
	sb->s_fs_info = NULL;
	return;
}

58
static int isofs_read_inode(struct inode *, int relocated);
59
static int isofs_statfs (struct dentry *, struct kstatfs *);
L
Linus Torvalds 已提交
60

61
static struct kmem_cache *isofs_inode_cachep;
L
Linus Torvalds 已提交
62 63 64 65

static struct inode *isofs_alloc_inode(struct super_block *sb)
{
	struct iso_inode_info *ei;
66
	ei = kmem_cache_alloc(isofs_inode_cachep, GFP_KERNEL);
L
Linus Torvalds 已提交
67 68 69 70 71
	if (!ei)
		return NULL;
	return &ei->vfs_inode;
}

N
Nick Piggin 已提交
72
static void isofs_i_callback(struct rcu_head *head)
L
Linus Torvalds 已提交
73
{
N
Nick Piggin 已提交
74
	struct inode *inode = container_of(head, struct inode, i_rcu);
L
Linus Torvalds 已提交
75 76 77
	kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
}

N
Nick Piggin 已提交
78 79 80 81 82
static void isofs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, isofs_i_callback);
}

83
static void init_once(void *foo)
L
Linus Torvalds 已提交
84
{
85
	struct iso_inode_info *ei = foo;
L
Linus Torvalds 已提交
86

87
	inode_init_once(&ei->vfs_inode);
L
Linus Torvalds 已提交
88
}
D
Dave Jones 已提交
89

90
static int __init init_inodecache(void)
L
Linus Torvalds 已提交
91 92
{
	isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
D
Dave Jones 已提交
93 94
					sizeof(struct iso_inode_info),
					0, (SLAB_RECLAIM_ACCOUNT|
95
					SLAB_MEM_SPREAD|SLAB_ACCOUNT),
96
					init_once);
L
Linus Torvalds 已提交
97 98 99 100 101 102 103
	if (isofs_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
104 105 106 107 108
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
109
	kmem_cache_destroy(isofs_inode_cachep);
L
Linus Torvalds 已提交
110 111 112 113
}

static int isofs_remount(struct super_block *sb, int *flags, char *data)
{
114
	sync_filesystem(sb);
115 116
	if (!(*flags & MS_RDONLY))
		return -EROFS;
L
Linus Torvalds 已提交
117 118 119
	return 0;
}

120
static const struct super_operations isofs_sops = {
L
Linus Torvalds 已提交
121 122 123 124 125
	.alloc_inode	= isofs_alloc_inode,
	.destroy_inode	= isofs_destroy_inode,
	.put_super	= isofs_put_super,
	.statfs		= isofs_statfs,
	.remount_fs	= isofs_remount,
M
Miklos Szeredi 已提交
126
	.show_options	= generic_show_options,
L
Linus Torvalds 已提交
127 128 129
};


130
static const struct dentry_operations isofs_dentry_ops[] = {
L
Linus Torvalds 已提交
131 132 133 134 135 136 137 138 139 140 141 142
	{
		.d_hash		= isofs_hashi,
		.d_compare	= isofs_dentry_cmpi,
	},
#ifdef CONFIG_JOLIET
	{
		.d_hash		= isofs_hash_ms,
		.d_compare	= isofs_dentry_cmp_ms,
	},
	{
		.d_hash		= isofs_hashi_ms,
		.d_compare	= isofs_dentry_cmpi_ms,
143
	},
L
Linus Torvalds 已提交
144 145 146 147
#endif
};

struct iso9660_options{
148
	unsigned int rock:1;
149
	unsigned int joliet:1;
150 151 152 153 154 155 156 157 158
	unsigned int cruft:1;
	unsigned int hide:1;
	unsigned int showassoc:1;
	unsigned int nocompress:1;
	unsigned int overriderockperm:1;
	unsigned int uid_set:1;
	unsigned int gid_set:1;
	unsigned int utf8:1;
	unsigned char map;
L
Linus Torvalds 已提交
159 160
	unsigned char check;
	unsigned int blocksize;
A
Al Viro 已提交
161 162
	umode_t fmode;
	umode_t dmode;
163 164
	kgid_t gid;
	kuid_t uid;
L
Linus Torvalds 已提交
165
	char *iocharset;
D
Dave Jones 已提交
166 167 168
	/* LVE */
	s32 session;
	s32 sbsector;
L
Linus Torvalds 已提交
169 170 171 172 173 174
};

/*
 * Compute the hash for the isofs name corresponding to the dentry.
 */
static int
175
isofs_hashi_common(const struct dentry *dentry, struct qstr *qstr, int ms)
L
Linus Torvalds 已提交
176 177 178 179 180 181 182 183 184 185 186 187 188
{
	const char *name;
	int len;
	char c;
	unsigned long hash;

	len = qstr->len;
	name = qstr->name;
	if (ms) {
		while (len && name[len-1] == '.')
			len--;
	}

189
	hash = init_name_hash(dentry);
L
Linus Torvalds 已提交
190 191
	while (len--) {
		c = tolower(*name++);
192
		hash = partial_name_hash(c, hash);
L
Linus Torvalds 已提交
193 194 195 196 197 198 199
	}
	qstr->hash = end_name_hash(hash);

	return 0;
}

/*
200
 * Compare of two isofs names.
L
Linus Torvalds 已提交
201
 */
202 203 204
static int isofs_dentry_cmp_common(
		unsigned int len, const char *str,
		const struct qstr *name, int ms, int ci)
L
Linus Torvalds 已提交
205 206 207 208
{
	int alen, blen;

	/* A filename cannot end in '.' or we treat it like it has none */
209 210
	alen = name->len;
	blen = len;
L
Linus Torvalds 已提交
211
	if (ms) {
212
		while (alen && name->name[alen-1] == '.')
L
Linus Torvalds 已提交
213
			alen--;
214
		while (blen && str[blen-1] == '.')
L
Linus Torvalds 已提交
215 216 217
			blen--;
	}
	if (alen == blen) {
218
		if (ci) {
219
			if (strncasecmp(name->name, str, alen) == 0)
220 221 222 223 224
				return 0;
		} else {
			if (strncmp(name->name, str, alen) == 0)
				return 0;
		}
L
Linus Torvalds 已提交
225 226 227 228 229
	}
	return 1;
}

static int
230
isofs_hashi(const struct dentry *dentry, struct qstr *qstr)
L
Linus Torvalds 已提交
231
{
232
	return isofs_hashi_common(dentry, qstr, 0);
L
Linus Torvalds 已提交
233 234 235
}

static int
236
isofs_dentry_cmpi(const struct dentry *dentry,
237
		unsigned int len, const char *str, const struct qstr *name)
L
Linus Torvalds 已提交
238
{
239
	return isofs_dentry_cmp_common(len, str, name, 0, 1);
L
Linus Torvalds 已提交
240 241 242
}

#ifdef CONFIG_JOLIET
243 244 245 246
/*
 * Compute the hash for the isofs name corresponding to the dentry.
 */
static int
247
isofs_hash_common(const struct dentry *dentry, struct qstr *qstr, int ms)
248 249 250 251 252 253 254 255 256 257 258
{
	const char *name;
	int len;

	len = qstr->len;
	name = qstr->name;
	if (ms) {
		while (len && name[len-1] == '.')
			len--;
	}

259
	qstr->hash = full_name_hash(dentry, name, len);
260 261 262 263

	return 0;
}

L
Linus Torvalds 已提交
264
static int
265
isofs_hash_ms(const struct dentry *dentry, struct qstr *qstr)
L
Linus Torvalds 已提交
266
{
267
	return isofs_hash_common(dentry, qstr, 1);
L
Linus Torvalds 已提交
268 269 270
}

static int
271
isofs_hashi_ms(const struct dentry *dentry, struct qstr *qstr)
L
Linus Torvalds 已提交
272
{
273
	return isofs_hashi_common(dentry, qstr, 1);
L
Linus Torvalds 已提交
274 275 276
}

static int
277
isofs_dentry_cmp_ms(const struct dentry *dentry,
278
		unsigned int len, const char *str, const struct qstr *name)
L
Linus Torvalds 已提交
279
{
280
	return isofs_dentry_cmp_common(len, str, name, 1, 0);
L
Linus Torvalds 已提交
281 282 283
}

static int
284
isofs_dentry_cmpi_ms(const struct dentry *dentry,
285
		unsigned int len, const char *str, const struct qstr *name)
L
Linus Torvalds 已提交
286
{
287
	return isofs_dentry_cmp_common(len, str, name, 1, 1);
L
Linus Torvalds 已提交
288 289 290 291 292 293 294
}
#endif

enum {
	Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
	Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
	Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
295
	Opt_nocompress, Opt_hide, Opt_showassoc, Opt_dmode, Opt_overriderockperm,
L
Linus Torvalds 已提交
296 297
};

298
static const match_table_t tokens = {
L
Linus Torvalds 已提交
299 300 301
	{Opt_norock, "norock"},
	{Opt_nojoliet, "nojoliet"},
	{Opt_unhide, "unhide"},
302 303
	{Opt_hide, "hide"},
	{Opt_showassoc, "showassoc"},
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
	{Opt_cruft, "cruft"},
	{Opt_utf8, "utf8"},
	{Opt_iocharset, "iocharset=%s"},
	{Opt_map_a, "map=acorn"},
	{Opt_map_a, "map=a"},
	{Opt_map_n, "map=normal"},
	{Opt_map_n, "map=n"},
	{Opt_map_o, "map=off"},
	{Opt_map_o, "map=o"},
	{Opt_session, "session=%u"},
	{Opt_sb, "sbsector=%u"},
	{Opt_check_r, "check=relaxed"},
	{Opt_check_r, "check=r"},
	{Opt_check_s, "check=strict"},
	{Opt_check_s, "check=s"},
	{Opt_uid, "uid=%u"},
	{Opt_gid, "gid=%u"},
	{Opt_mode, "mode=%u"},
J
Jan Kara 已提交
322
	{Opt_dmode, "dmode=%u"},
323
	{Opt_overriderockperm, "overriderockperm"},
L
Linus Torvalds 已提交
324 325 326 327 328 329 330 331 332 333 334 335 336
	{Opt_block, "block=%u"},
	{Opt_ignore, "conv=binary"},
	{Opt_ignore, "conv=b"},
	{Opt_ignore, "conv=text"},
	{Opt_ignore, "conv=t"},
	{Opt_ignore, "conv=mtext"},
	{Opt_ignore, "conv=m"},
	{Opt_ignore, "conv=auto"},
	{Opt_ignore, "conv=a"},
	{Opt_nocompress, "nocompress"},
	{Opt_err, NULL}
};

337
static int parse_options(char *options, struct iso9660_options *popt)
L
Linus Torvalds 已提交
338 339 340 341 342
{
	char *p;
	int option;

	popt->map = 'n';
343 344 345 346 347
	popt->rock = 1;
	popt->joliet = 1;
	popt->cruft = 0;
	popt->hide = 0;
	popt->showassoc = 0;
L
Linus Torvalds 已提交
348 349 350
	popt->check = 'u';		/* unset */
	popt->nocompress = 0;
	popt->blocksize = 1024;
351
	popt->fmode = popt->dmode = ISOFS_INVALID_MODE;
352 353
	popt->uid_set = 0;
	popt->gid_set = 0;
354 355
	popt->gid = GLOBAL_ROOT_GID;
	popt->uid = GLOBAL_ROOT_UID;
L
Linus Torvalds 已提交
356 357
	popt->iocharset = NULL;
	popt->utf8 = 0;
358
	popt->overriderockperm = 0;
L
Linus Torvalds 已提交
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
	popt->session=-1;
	popt->sbsector=-1;
	if (!options)
		return 1;

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		substring_t args[MAX_OPT_ARGS];
		unsigned n;

		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_norock:
375
			popt->rock = 0;
L
Linus Torvalds 已提交
376 377
			break;
		case Opt_nojoliet:
378
			popt->joliet = 0;
L
Linus Torvalds 已提交
379
			break;
380
		case Opt_hide:
381
			popt->hide = 1;
382
			break;
L
Linus Torvalds 已提交
383
		case Opt_unhide:
384
		case Opt_showassoc:
385
			popt->showassoc = 1;
L
Linus Torvalds 已提交
386 387
			break;
		case Opt_cruft:
388
			popt->cruft = 1;
L
Linus Torvalds 已提交
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
			break;
		case Opt_utf8:
			popt->utf8 = 1;
			break;
#ifdef CONFIG_JOLIET
		case Opt_iocharset:
			popt->iocharset = match_strdup(&args[0]);
			break;
#endif
		case Opt_map_a:
			popt->map = 'a';
			break;
		case Opt_map_o:
			popt->map = 'o';
			break;
		case Opt_map_n:
			popt->map = 'n';
			break;
		case Opt_session:
			if (match_int(&args[0], &option))
				return 0;
			n = option;
			if (n > 99)
				return 0;
			popt->session = n + 1;
			break;
		case Opt_sb:
			if (match_int(&args[0], &option))
				return 0;
			popt->sbsector = option;
			break;
		case Opt_check_r:
			popt->check = 'r';
			break;
		case Opt_check_s:
			popt->check = 's';
			break;
		case Opt_ignore:
			break;
		case Opt_uid:
			if (match_int(&args[0], &option))
				return 0;
431 432 433
			popt->uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(popt->uid))
				return 0;
434
			popt->uid_set = 1;
L
Linus Torvalds 已提交
435 436 437 438
			break;
		case Opt_gid:
			if (match_int(&args[0], &option))
				return 0;
439 440 441
			popt->gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(popt->gid))
				return 0;
442
			popt->gid_set = 1;
L
Linus Torvalds 已提交
443 444 445 446
			break;
		case Opt_mode:
			if (match_int(&args[0], &option))
				return 0;
J
Jan Kara 已提交
447 448 449 450 451 452
			popt->fmode = option;
			break;
		case Opt_dmode:
			if (match_int(&args[0], &option))
				return 0;
			popt->dmode = option;
L
Linus Torvalds 已提交
453
			break;
454 455 456
		case Opt_overriderockperm:
			popt->overriderockperm = 1;
			break;
L
Linus Torvalds 已提交
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
		case Opt_block:
			if (match_int(&args[0], &option))
				return 0;
			n = option;
			if (n != 512 && n != 1024 && n != 2048)
				return 0;
			popt->blocksize = n;
			break;
		case Opt_nocompress:
			popt->nocompress = 1;
			break;
		default:
			return 0;
		}
	}
	return 1;
}

/*
 * look if the driver can tell the multi session redirection value
 *
 * don't change this if you don't know what you do, please!
 * Multisession is legal only with XA disks.
 * A non-XA disk with more than one volume descriptor may do it right, but
 * usually is written in a nowhere standardized "multi-partition" manner.
 * Multisession uses absolute addressing (solely the first frame of the whole
 * track is #0), multi-partition uses relative addressing (each first frame of
 * each track is #0), and a track is not a session.
 *
 * A broken CDwriter software or drive firmware does not set new standards,
 * at least not if conflicting with the existing ones.
 *
 * emoenke@gwdg.de
 */
#define WE_OBEY_THE_WRITTEN_STANDARDS 1

493
static unsigned int isofs_get_last_session(struct super_block *sb, s32 session)
L
Linus Torvalds 已提交
494 495 496 497 498 499 500 501 502 503 504 505 506 507
{
	struct cdrom_multisession ms_info;
	unsigned int vol_desc_start;
	struct block_device *bdev = sb->s_bdev;
	int i;

	vol_desc_start=0;
	ms_info.addr_format=CDROM_LBA;
	if(session >= 0 && session <= 99) {
		struct cdrom_tocentry Te;
		Te.cdte_track=session;
		Te.cdte_format=CDROM_LBA;
		i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
		if (!i) {
D
Dave Jones 已提交
508 509 510
			printk(KERN_DEBUG "ISOFS: Session %d start %d type %d\n",
				session, Te.cdte_addr.lba,
				Te.cdte_ctrl&CDROM_DATA_TRACK);
L
Linus Torvalds 已提交
511 512 513
			if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
				return Te.cdte_addr.lba;
		}
D
Dave Jones 已提交
514 515

		printk(KERN_ERR "ISOFS: Invalid session number or type of track\n");
L
Linus Torvalds 已提交
516 517
	}
	i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
518
	if (session > 0)
D
Dave Jones 已提交
519
		printk(KERN_ERR "ISOFS: Invalid session number\n");
L
Linus Torvalds 已提交
520
#if 0
D
Dave Jones 已提交
521
	printk(KERN_DEBUG "isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
L
Linus Torvalds 已提交
522
	if (i==0) {
D
Dave Jones 已提交
523 524
		printk(KERN_DEBUG "isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
		printk(KERN_DEBUG "isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
L
Linus Torvalds 已提交
525 526 527 528
	}
#endif
	if (i==0)
#if WE_OBEY_THE_WRITTEN_STANDARDS
D
Dave Jones 已提交
529
		if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
L
Linus Torvalds 已提交
530
#endif
D
Dave Jones 已提交
531
			vol_desc_start=ms_info.addr.lba;
L
Linus Torvalds 已提交
532 533 534
	return vol_desc_start;
}

535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
/*
 * Check if root directory is empty (has less than 3 files).
 *
 * Used to detect broken CDs where ISO root directory is empty but Joliet root
 * directory is OK. If such CD has Rock Ridge extensions, they will be disabled
 * (and Joliet used instead) or else no files would be visible.
 */
static bool rootdir_empty(struct super_block *sb, unsigned long block)
{
	int offset = 0, files = 0, de_len;
	struct iso_directory_record *de;
	struct buffer_head *bh;

	bh = sb_bread(sb, block);
	if (!bh)
		return true;
	while (files < 3) {
		de = (struct iso_directory_record *) (bh->b_data + offset);
		de_len = *(unsigned char *) de;
		if (de_len == 0)
			break;
		files++;
		offset += de_len;
	}
	brelse(bh);
	return files < 3;
}

L
Linus Torvalds 已提交
563 564 565 566 567 568 569 570
/*
 * Initialize the superblock and read the root inode.
 *
 * Note: a check_disk_change() has been done immediately prior
 * to this call, so we don't need to check again.
 */
static int isofs_fill_super(struct super_block *s, void *data, int silent)
{
D
Dave Jones 已提交
571 572 573
	struct buffer_head *bh = NULL, *pri_bh = NULL;
	struct hs_primary_descriptor *h_pri = NULL;
	struct iso_primary_descriptor *pri = NULL;
L
Linus Torvalds 已提交
574
	struct iso_supplementary_descriptor *sec = NULL;
D
Dave Jones 已提交
575 576 577 578 579 580 581 582
	struct iso_directory_record *rootp;
	struct inode *inode;
	struct iso9660_options opt;
	struct isofs_sb_info *sbi;
	unsigned long first_data_zone;
	int joliet_level = 0;
	int iso_blknum, block;
	int orig_zonesize;
583
	int table, error = -EINVAL;
D
Dave Jones 已提交
584
	unsigned int vol_desc_start;
L
Linus Torvalds 已提交
585

M
Miklos Szeredi 已提交
586 587
	save_mount_options(s, data);

588
	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
589
	if (!sbi)
L
Linus Torvalds 已提交
590 591 592
		return -ENOMEM;
	s->s_fs_info = sbi;

593
	if (!parse_options((char *)data, &opt))
L
Linus Torvalds 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
		goto out_freesbi;

	/*
	 * First of all, get the hardware blocksize for this device.
	 * If we don't know what it is, or the hardware blocksize is
	 * larger than the blocksize the user specified, then use
	 * that value.
	 */
	/*
	 * What if bugger tells us to go beyond page size?
	 */
	opt.blocksize = sb_min_blocksize(s, opt.blocksize);

	sbi->s_high_sierra = 0; /* default is iso9660 */

	vol_desc_start = (opt.sbsector != -1) ?
		opt.sbsector : isofs_get_last_session(s,opt.session);

D
Dave Jones 已提交
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
	for (iso_blknum = vol_desc_start+16;
		iso_blknum < vol_desc_start+100; iso_blknum++) {
		struct hs_volume_descriptor *hdp;
		struct iso_volume_descriptor  *vdp;

		block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
		if (!(bh = sb_bread(s, block)))
			goto out_no_read;

		vdp = (struct iso_volume_descriptor *)bh->b_data;
		hdp = (struct hs_volume_descriptor *)bh->b_data;

		/*
		 * Due to the overlapping physical location of the descriptors,
		 * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
		 * proper identification in this case, we first check for ISO.
		 */
		if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
			if (isonum_711(vdp->type) == ISO_VD_END)
				break;
			if (isonum_711(vdp->type) == ISO_VD_PRIMARY) {
				if (pri == NULL) {
					pri = (struct iso_primary_descriptor *)vdp;
					/* Save the buffer in case we need it ... */
					pri_bh = bh;
					bh = NULL;
				}
			}
L
Linus Torvalds 已提交
640
#ifdef CONFIG_JOLIET
D
Dave Jones 已提交
641 642 643
			else if (isonum_711(vdp->type) == ISO_VD_SUPPLEMENTARY) {
				sec = (struct iso_supplementary_descriptor *)vdp;
				if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
644
					if (opt.joliet) {
D
Dave Jones 已提交
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
						if (sec->escape[2] == 0x40)
							joliet_level = 1;
						else if (sec->escape[2] == 0x43)
							joliet_level = 2;
						else if (sec->escape[2] == 0x45)
							joliet_level = 3;

						printk(KERN_DEBUG "ISO 9660 Extensions: "
							"Microsoft Joliet Level %d\n",
							joliet_level);
					}
					goto root_found;
				} else {
				/* Unknown supplementary volume descriptor */
				sec = NULL;
				}
L
Linus Torvalds 已提交
661 662
			}
#endif
D
Dave Jones 已提交
663 664 665 666 667 668
		} else {
			if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
				if (isonum_711(hdp->type) != ISO_VD_PRIMARY)
					goto out_freebh;

				sbi->s_high_sierra = 1;
669
				opt.rock = 0;
D
Dave Jones 已提交
670 671 672
				h_pri = (struct hs_primary_descriptor *)vdp;
				goto root_found;
			}
L
Linus Torvalds 已提交
673 674
		}

D
Dave Jones 已提交
675
		/* Just skip any volume descriptors we don't recognize */
L
Linus Torvalds 已提交
676

D
Dave Jones 已提交
677 678
		brelse(bh);
		bh = NULL;
L
Linus Torvalds 已提交
679 680 681 682 683 684 685 686 687 688 689 690
	}
	/*
	 * If we fall through, either no volume descriptor was found,
	 * or else we passed a primary descriptor looking for others.
	 */
	if (!pri)
		goto out_unknown_format;
	brelse(bh);
	bh = pri_bh;
	pri_bh = NULL;

root_found:
691 692 693 694 695
	/* We don't support read-write mounts */
	if (!(s->s_flags & MS_RDONLY)) {
		error = -EACCES;
		goto out_freebh;
	}
L
Linus Torvalds 已提交
696

697
	if (joliet_level && (pri == NULL || !opt.rock)) {
D
Dave Jones 已提交
698 699 700 701
		/* This is the case of Joliet with the norock mount flag.
		 * A disc with both Joliet and Rock Ridge is handled later
		 */
		pri = (struct iso_primary_descriptor *) sec;
L
Linus Torvalds 已提交
702 703 704
	}

	if(sbi->s_high_sierra){
D
Dave Jones 已提交
705 706 707 708
		rootp = (struct iso_directory_record *) h_pri->root_directory_record;
		sbi->s_nzones = isonum_733(h_pri->volume_space_size);
		sbi->s_log_zone_size = isonum_723(h_pri->logical_block_size);
		sbi->s_max_size = isonum_733(h_pri->volume_space_size);
L
Linus Torvalds 已提交
709
	} else {
D
Dave Jones 已提交
710 711 712 713 714 715
		if (!pri)
			goto out_freebh;
		rootp = (struct iso_directory_record *) pri->root_directory_record;
		sbi->s_nzones = isonum_733(pri->volume_space_size);
		sbi->s_log_zone_size = isonum_723(pri->logical_block_size);
		sbi->s_max_size = isonum_733(pri->volume_space_size);
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724 725 726 727
	}

	sbi->s_ninodes = 0; /* No way to figure this out easily */

	orig_zonesize = sbi->s_log_zone_size;
	/*
	 * If the zone size is smaller than the hardware sector size,
	 * this is a fatal error.  This would occur if the disc drive
	 * had sectors that were 2048 bytes, but the filesystem had
	 * blocks that were 512 bytes (which should only very rarely
	 * happen.)
	 */
D
Dave Jones 已提交
728
	if (orig_zonesize < opt.blocksize)
L
Linus Torvalds 已提交
729 730 731
		goto out_bad_size;

	/* RDE: convert log zone size to bit shift */
D
Dave Jones 已提交
732 733 734 735
	switch (sbi->s_log_zone_size) {
	case  512: sbi->s_log_zone_size =  9; break;
	case 1024: sbi->s_log_zone_size = 10; break;
	case 2048: sbi->s_log_zone_size = 11; break;
L
Linus Torvalds 已提交
736

D
Dave Jones 已提交
737
	default:
L
Linus Torvalds 已提交
738
		goto out_bad_zone_size;
D
Dave Jones 已提交
739
	}
L
Linus Torvalds 已提交
740 741

	s->s_magic = ISOFS_SUPER_MAGIC;
742 743 744 745 746 747

	/*
	 * With multi-extent files, file size is only limited by the maximum
	 * size of a file system, which is 8 TB.
	 */
	s->s_maxbytes = 0x80000000000LL;
L
Linus Torvalds 已提交
748 749 750

	/* Set this for reference. Its not currently used except on write
	   which we don't have .. */
D
Dave Jones 已提交
751 752 753

	first_data_zone = isonum_733(rootp->extent) +
			  isonum_711(rootp->ext_attr_length);
L
Linus Torvalds 已提交
754 755
	sbi->s_firstdatazone = first_data_zone;
#ifndef BEQUIET
D
Dave Jones 已提交
756 757 758
	printk(KERN_DEBUG "ISOFS: Max size:%ld   Log zone size:%ld\n",
		sbi->s_max_size, 1UL << sbi->s_log_zone_size);
	printk(KERN_DEBUG "ISOFS: First datazone:%ld\n", sbi->s_firstdatazone);
L
Linus Torvalds 已提交
759
	if(sbi->s_high_sierra)
D
Dave Jones 已提交
760
		printk(KERN_DEBUG "ISOFS: Disc in High Sierra format.\n");
L
Linus Torvalds 已提交
761 762 763 764 765 766 767 768 769 770 771 772 773 774
#endif

	/*
	 * If the Joliet level is set, we _may_ decide to use the
	 * secondary descriptor, but can't be sure until after we
	 * read the root inode. But before reading the root inode
	 * we may need to change the device blocksize, and would
	 * rather release the old buffer first. So, we cache the
	 * first_data_zone value from the secondary descriptor.
	 */
	if (joliet_level) {
		pri = (struct iso_primary_descriptor *) sec;
		rootp = (struct iso_directory_record *)
			pri->root_directory_record;
D
Dave Jones 已提交
775 776
		first_data_zone = isonum_733(rootp->extent) +
				isonum_711(rootp->ext_attr_length);
L
Linus Torvalds 已提交
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
	}

	/*
	 * We're all done using the volume descriptor, and may need
	 * to change the device blocksize, so release the buffer now.
	 */
	brelse(pri_bh);
	brelse(bh);

	/*
	 * Force the blocksize to 512 for 512 byte sectors.  The file
	 * read primitives really get it wrong in a bad way if we don't
	 * do this.
	 *
	 * Note - we should never be setting the blocksize to something
	 * less than the hardware sector size for the device.  If we
	 * do, we would end up having to read larger buffers and split
	 * out portions to satisfy requests.
	 *
	 * Note2- the idea here is that we want to deal with the optimal
	 * zonesize in the filesystem.  If we have it set to something less,
	 * then we have horrible problems with trying to piece together
	 * bits of adjacent blocks in order to properly read directory
	 * entries.  By forcing the blocksize in this way, we ensure
	 * that we will never be required to do this.
	 */
	sb_set_blocksize(s, orig_zonesize);

	sbi->s_nls_iocharset = NULL;

#ifdef CONFIG_JOLIET
	if (joliet_level && opt.utf8 == 0) {
D
Dave Jones 已提交
809
		char *p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817 818 819 820 821
		sbi->s_nls_iocharset = load_nls(p);
		if (! sbi->s_nls_iocharset) {
			/* Fail only if explicit charset specified */
			if (opt.iocharset)
				goto out_freesbi;
			sbi->s_nls_iocharset = load_nls_default();
		}
	}
#endif
	s->s_op = &isofs_sops;
	s->s_export_op = &isofs_export_ops;
	sbi->s_mapping = opt.map;
822
	sbi->s_rock = (opt.rock ? 2 : 0);
L
Linus Torvalds 已提交
823 824
	sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
	sbi->s_cruft = opt.cruft;
825 826
	sbi->s_hide = opt.hide;
	sbi->s_showassoc = opt.showassoc;
L
Linus Torvalds 已提交
827 828
	sbi->s_uid = opt.uid;
	sbi->s_gid = opt.gid;
829 830
	sbi->s_uid_set = opt.uid_set;
	sbi->s_gid_set = opt.gid_set;
L
Linus Torvalds 已提交
831 832
	sbi->s_utf8 = opt.utf8;
	sbi->s_nocompress = opt.nocompress;
833
	sbi->s_overriderockperm = opt.overriderockperm;
L
Linus Torvalds 已提交
834 835 836 837 838
	/*
	 * It would be incredibly stupid to allow people to mark every file
	 * on the disk as suid, so we merely allow them to set the default
	 * permissions.
	 */
839 840 841 842 843 844 845 846
	if (opt.fmode != ISOFS_INVALID_MODE)
		sbi->s_fmode = opt.fmode & 0777;
	else
		sbi->s_fmode = ISOFS_INVALID_MODE;
	if (opt.dmode != ISOFS_INVALID_MODE)
		sbi->s_dmode = opt.dmode & 0777;
	else
		sbi->s_dmode = ISOFS_INVALID_MODE;
L
Linus Torvalds 已提交
847 848 849 850 851 852 853

	/*
	 * Read the root inode, which _may_ result in changing
	 * the s_rock flag. Once we have the final s_rock value,
	 * we then decide whether to use the Joliet descriptor.
	 */
	inode = isofs_iget(s, sbi->s_firstdatazone, 0);
854 855
	if (IS_ERR(inode))
		goto out_no_root;
L
Linus Torvalds 已提交
856

857 858 859 860 861 862 863 864 865 866 867 868
	/*
	 * Fix for broken CDs with Rock Ridge and empty ISO root directory but
	 * correct Joliet root directory.
	 */
	if (sbi->s_rock == 1 && joliet_level &&
				rootdir_empty(s, sbi->s_firstdatazone)) {
		printk(KERN_NOTICE
			"ISOFS: primary root directory is empty. "
			"Disabling Rock Ridge and switching to Joliet.");
		sbi->s_rock = 0;
	}

L
Linus Torvalds 已提交
869 870 871 872 873 874 875 876 877 878 879 880 881 882
	/*
	 * If this disk has both Rock Ridge and Joliet on it, then we
	 * want to use Rock Ridge by default.  This can be overridden
	 * by using the norock mount option.  There is still one other
	 * possibility that is not taken into account: a Rock Ridge
	 * CD with Unicode names.  Until someone sees such a beast, it
	 * will not be supported.
	 */
	if (sbi->s_rock == 1) {
		joliet_level = 0;
	} else if (joliet_level) {
		sbi->s_rock = 0;
		if (sbi->s_firstdatazone != first_data_zone) {
			sbi->s_firstdatazone = first_data_zone;
D
Dave Jones 已提交
883
			printk(KERN_DEBUG
L
Linus Torvalds 已提交
884 885 886
				"ISOFS: changing to secondary root\n");
			iput(inode);
			inode = isofs_iget(s, sbi->s_firstdatazone, 0);
887 888
			if (IS_ERR(inode))
				goto out_no_root;
L
Linus Torvalds 已提交
889 890 891 892 893
		}
	}

	if (opt.check == 'u') {
		/* Only Joliet is case insensitive by default */
D
Dave Jones 已提交
894 895 896 897
		if (joliet_level)
			opt.check = 'r';
		else
			opt.check = 's';
L
Linus Torvalds 已提交
898 899 900
	}
	sbi->s_joliet_level = joliet_level;

901 902 903 904 905 906 907 908
	/* Make sure the root inode is a directory */
	if (!S_ISDIR(inode->i_mode)) {
		printk(KERN_WARNING
			"isofs_fill_super: root inode is not a directory. "
			"Corrupted media?\n");
		goto out_iput;
	}

L
Linus Torvalds 已提交
909
	table = 0;
D
Dave Jones 已提交
910 911 912 913
	if (joliet_level)
		table += 2;
	if (opt.check == 'r')
		table++;
A
Al Viro 已提交
914

915 916
	if (table)
		s->s_d_op = &isofs_dentry_ops[table - 1];
A
Al Viro 已提交
917 918

	/* get the root dentry */
919
	s->s_root = d_make_root(inode);
920 921 922 923
	if (!(s->s_root)) {
		error = -ENOMEM;
		goto out_no_inode;
	}
L
Linus Torvalds 已提交
924

J
Jesper Juhl 已提交
925
	kfree(opt.iocharset);
L
Linus Torvalds 已提交
926 927 928 929 930 931 932 933

	return 0;

	/*
	 * Display error messages and free resources.
	 */
out_iput:
	iput(inode);
934 935 936 937 938 939
	goto out_no_inode;
out_no_root:
	error = PTR_ERR(inode);
	if (error != -ENOMEM)
		printk(KERN_WARNING "%s: get root inode failed\n", __func__);
out_no_inode:
L
Linus Torvalds 已提交
940
#ifdef CONFIG_JOLIET
941
	unload_nls(sbi->s_nls_iocharset);
L
Linus Torvalds 已提交
942 943 944
#endif
	goto out_freesbi;
out_no_read:
D
Dave Jones 已提交
945 946
	printk(KERN_WARNING "%s: bread failed, dev=%s, iso_blknum=%d, block=%d\n",
		__func__, s->s_id, iso_blknum, block);
947
	goto out_freebh;
L
Linus Torvalds 已提交
948
out_bad_zone_size:
D
Dave Jones 已提交
949
	printk(KERN_WARNING "ISOFS: Bad logical zone size %ld\n",
L
Linus Torvalds 已提交
950 951 952
		sbi->s_log_zone_size);
	goto out_freebh;
out_bad_size:
D
Dave Jones 已提交
953
	printk(KERN_WARNING "ISOFS: Logical zone size(%d) < hardware blocksize(%u)\n",
L
Linus Torvalds 已提交
954 955 956 957
		orig_zonesize, opt.blocksize);
	goto out_freebh;
out_unknown_format:
	if (!silent)
D
Dave Jones 已提交
958
		printk(KERN_WARNING "ISOFS: Unable to identify CD-ROM format.\n");
L
Linus Torvalds 已提交
959 960 961

out_freebh:
	brelse(bh);
962
	brelse(pri_bh);
L
Linus Torvalds 已提交
963
out_freesbi:
J
Jesper Juhl 已提交
964
	kfree(opt.iocharset);
L
Linus Torvalds 已提交
965 966
	kfree(sbi);
	s->s_fs_info = NULL;
967
	return error;
L
Linus Torvalds 已提交
968 969
}

970
static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
971
{
972
	struct super_block *sb = dentry->d_sb;
973
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
974

L
Linus Torvalds 已提交
975 976 977
	buf->f_type = ISOFS_SUPER_MAGIC;
	buf->f_bsize = sb->s_blocksize;
	buf->f_blocks = (ISOFS_SB(sb)->s_nzones
D
Dave Jones 已提交
978
		<< (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
L
Linus Torvalds 已提交
979 980 981 982
	buf->f_bfree = 0;
	buf->f_bavail = 0;
	buf->f_files = ISOFS_SB(sb)->s_ninodes;
	buf->f_ffree = 0;
983 984
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);
L
Linus Torvalds 已提交
985 986 987 988 989 990 991
	buf->f_namelen = NAME_MAX;
	return 0;
}

/*
 * Get a set of blocks; filling in buffer_heads if already allocated
 * or getblk() if they are not.  Returns the number of blocks inserted
992
 * (-ve == error.)
L
Linus Torvalds 已提交
993
 */
994
int isofs_get_blocks(struct inode *inode, sector_t iblock,
L
Linus Torvalds 已提交
995 996
		     struct buffer_head **bh, unsigned long nblocks)
{
997
	unsigned long b_off = iblock;
L
Linus Torvalds 已提交
998 999 1000
	unsigned offset, sect_size;
	unsigned int firstext;
	unsigned long nextblk, nextoff;
1001
	int section, rv, error;
L
Linus Torvalds 已提交
1002 1003
	struct iso_inode_info *ei = ISOFS_I(inode);

1004
	error = -EIO;
L
Linus Torvalds 已提交
1005
	rv = 0;
1006
	if (iblock != b_off) {
D
Dave Jones 已提交
1007
		printk(KERN_DEBUG "%s: block number too large\n", __func__);
L
Linus Torvalds 已提交
1008 1009 1010
		goto abort;
	}

D
Dave Jones 已提交
1011 1012 1013

	offset = 0;
	firstext = ei->i_first_extent;
L
Linus Torvalds 已提交
1014
	sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
D
Dave Jones 已提交
1015 1016 1017
	nextblk = ei->i_next_section_block;
	nextoff = ei->i_next_section_offset;
	section = 0;
L
Linus Torvalds 已提交
1018

D
Dave Jones 已提交
1019
	while (nblocks) {
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026
		/* If we are *way* beyond the end of the file, print a message.
		 * Access beyond the end of the file up to the next page boundary
		 * is normal, however because of the way the page cache works.
		 * In this case, we just return 0 so that we can properly fill
		 * the page with useless information without generating any
		 * I/O errors.
		 */
1027
		if (b_off > ((inode->i_size + PAGE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
1028 1029 1030
			printk(KERN_DEBUG "%s: block >= EOF (%lu, %llu)\n",
				__func__, b_off,
				(unsigned long long)inode->i_size);
L
Linus Torvalds 已提交
1031 1032
			goto abort;
		}
D
Dave Jones 已提交
1033

1034 1035 1036 1037 1038 1039 1040 1041 1042
		/* On the last section, nextblk == 0, section size is likely to
		 * exceed sect_size by a partial block, and access beyond the
		 * end of the file will reach beyond the section size, too.
		 */
		while (nextblk && (b_off >= (offset + sect_size))) {
			struct inode *ninode;

			offset += sect_size;
			ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
1043 1044
			if (IS_ERR(ninode)) {
				error = PTR_ERR(ninode);
1045
				goto abort;
1046
			}
1047 1048 1049 1050 1051 1052 1053
			firstext  = ISOFS_I(ninode)->i_first_extent;
			sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
			nextblk   = ISOFS_I(ninode)->i_next_section_block;
			nextoff   = ISOFS_I(ninode)->i_next_section_offset;
			iput(ninode);

			if (++section > 100) {
D
Dave Jones 已提交
1054 1055
				printk(KERN_DEBUG "%s: More than 100 file sections ?!?"
					" aborting...\n", __func__);
1056
				printk(KERN_DEBUG "%s: block=%lu firstext=%u sect_size=%u "
D
Dave Jones 已提交
1057
					"nextblk=%lu nextoff=%lu\n", __func__,
1058
					b_off, firstext, (unsigned) sect_size,
D
Dave Jones 已提交
1059
					nextblk, nextoff);
1060
				goto abort;
L
Linus Torvalds 已提交
1061 1062
			}
		}
D
Dave Jones 已提交
1063 1064

		if (*bh) {
L
Linus Torvalds 已提交
1065 1066 1067
			map_bh(*bh, inode->i_sb, firstext + b_off - offset);
		} else {
			*bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
D
Dave Jones 已提交
1068
			if (!*bh)
L
Linus Torvalds 已提交
1069 1070 1071 1072 1073 1074 1075 1076
				goto abort;
		}
		bh++;	/* Next buffer head */
		b_off++;	/* Next buffer offset */
		nblocks--;
		rv++;
	}

1077
	error = 0;
L
Linus Torvalds 已提交
1078
abort:
1079
	return rv != 0 ? rv : error;
L
Linus Torvalds 已提交
1080 1081 1082 1083 1084 1085 1086 1087
}

/*
 * Used by the standard interfaces.
 */
static int isofs_get_block(struct inode *inode, sector_t iblock,
		    struct buffer_head *bh_result, int create)
{
1088 1089
	int ret;

1090
	if (create) {
D
Dave Jones 已提交
1091
		printk(KERN_DEBUG "%s: Kernel tries to allocate a block\n", __func__);
L
Linus Torvalds 已提交
1092 1093 1094
		return -EROFS;
	}

1095 1096
	ret = isofs_get_blocks(inode, iblock, &bh_result, 1);
	return ret < 0 ? ret : 0;
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
}

static int isofs_bmap(struct inode *inode, sector_t block)
{
	struct buffer_head dummy;
	int error;

	dummy.b_state = 0;
	dummy.b_blocknr = -1000;
	error = isofs_get_block(inode, block, &dummy, 0);
	if (!error)
		return dummy.b_blocknr;
	return 0;
}

struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
{
	sector_t blknr = isofs_bmap(inode, block);
	if (!blknr)
		return NULL;
	return sb_bread(inode->i_sb, blknr);
}

static int isofs_readpage(struct file *file, struct page *page)
{
1122 1123 1124 1125 1126 1127 1128
	return mpage_readpage(page, isofs_get_block);
}

static int isofs_readpages(struct file *file, struct address_space *mapping,
			struct list_head *pages, unsigned nr_pages)
{
	return mpage_readpages(mapping, pages, nr_pages, isofs_get_block);
L
Linus Torvalds 已提交
1129 1130 1131 1132 1133 1134 1135
}

static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
{
	return generic_block_bmap(mapping,block,isofs_get_block);
}

1136
static const struct address_space_operations isofs_aops = {
L
Linus Torvalds 已提交
1137
	.readpage = isofs_readpage,
1138
	.readpages = isofs_readpages,
L
Linus Torvalds 已提交
1139 1140 1141
	.bmap = _isofs_bmap
};

1142
static int isofs_read_level3_size(struct inode *inode)
L
Linus Torvalds 已提交
1143 1144 1145
{
	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
	int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
D
Dave Jones 已提交
1146
	struct buffer_head *bh = NULL;
L
Linus Torvalds 已提交
1147 1148 1149
	unsigned long block, offset, block_saved, offset_saved;
	int i = 0;
	int more_entries = 0;
D
Dave Jones 已提交
1150
	struct iso_directory_record *tmpde = NULL;
L
Linus Torvalds 已提交
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
	struct iso_inode_info *ei = ISOFS_I(inode);

	inode->i_size = 0;

	/* The first 16 blocks are reserved as the System Area.  Thus,
	 * no inodes can appear in block 0.  We use this to flag that
	 * this is the last section. */
	ei->i_next_section_block = 0;
	ei->i_next_section_offset = 0;

	block = ei->i_iget5_block;
	offset = ei->i_iget5_offset;

	do {
D
Dave Jones 已提交
1165
		struct iso_directory_record *de;
L
Linus Torvalds 已提交
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
		unsigned int de_len;

		if (!bh) {
			bh = sb_bread(inode->i_sb, block);
			if (!bh)
				goto out_noread;
		}
		de = (struct iso_directory_record *) (bh->b_data + offset);
		de_len = *(unsigned char *) de;

		if (de_len == 0) {
			brelse(bh);
			bh = NULL;
			++block;
			offset = 0;
			continue;
		}

		block_saved = block;
		offset_saved = offset;
		offset += de_len;

		/* Make sure we have a full directory entry */
		if (offset >= bufsize) {
			int slop = bufsize - offset + de_len;
			if (!tmpde) {
				tmpde = kmalloc(256, GFP_KERNEL);
				if (!tmpde)
					goto out_nomem;
			}
			memcpy(tmpde, de, slop);
			offset &= bufsize - 1;
			block++;
			brelse(bh);
			bh = NULL;
			if (offset) {
				bh = sb_bread(inode->i_sb, block);
				if (!bh)
					goto out_noread;
1205
				memcpy((void *)tmpde+slop, bh->b_data, offset);
L
Linus Torvalds 已提交
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
			}
			de = tmpde;
		}

		inode->i_size += isonum_733(de->size);
		if (i == 1) {
			ei->i_next_section_block = block_saved;
			ei->i_next_section_offset = offset_saved;
		}

		more_entries = de->flags[-high_sierra] & 0x80;

		i++;
1219
		if (i > 100)
L
Linus Torvalds 已提交
1220
			goto out_toomany;
1221
	} while (more_entries);
L
Linus Torvalds 已提交
1222
out:
1223
	kfree(tmpde);
L
Linus Torvalds 已提交
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
	if (bh)
		brelse(bh);
	return 0;

out_nomem:
	if (bh)
		brelse(bh);
	return -ENOMEM;

out_noread:
	printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
J
Jesper Juhl 已提交
1235
	kfree(tmpde);
L
Linus Torvalds 已提交
1236 1237 1238
	return -EIO;

out_toomany:
D
Dave Jones 已提交
1239 1240 1241
	printk(KERN_INFO "%s: More than 100 file sections ?!?, aborting...\n"
		"isofs_read_level3_size: inode=%lu\n",
		__func__, inode->i_ino);
L
Linus Torvalds 已提交
1242 1243 1244
	goto out;
}

1245
static int isofs_read_inode(struct inode *inode, int relocated)
L
Linus Torvalds 已提交
1246 1247 1248 1249 1250 1251
{
	struct super_block *sb = inode->i_sb;
	struct isofs_sb_info *sbi = ISOFS_SB(sb);
	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
	unsigned long block;
	int high_sierra = sbi->s_high_sierra;
D
Dave Jones 已提交
1252 1253 1254
	struct buffer_head *bh = NULL;
	struct iso_directory_record *de;
	struct iso_directory_record *tmpde = NULL;
L
Linus Torvalds 已提交
1255 1256 1257
	unsigned int de_len;
	unsigned long offset;
	struct iso_inode_info *ei = ISOFS_I(inode);
1258
	int ret = -EIO;
L
Linus Torvalds 已提交
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274

	block = ei->i_iget5_block;
	bh = sb_bread(inode->i_sb, block);
	if (!bh)
		goto out_badread;

	offset = ei->i_iget5_offset;

	de = (struct iso_directory_record *) (bh->b_data + offset);
	de_len = *(unsigned char *) de;

	if (offset + de_len > bufsize) {
		int frag1 = bufsize - offset;

		tmpde = kmalloc(de_len, GFP_KERNEL);
		if (tmpde == NULL) {
D
Dave Jones 已提交
1275
			printk(KERN_INFO "%s: out of memory\n", __func__);
1276
			ret = -ENOMEM;
L
Linus Torvalds 已提交
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
			goto fail;
		}
		memcpy(tmpde, bh->b_data + offset, frag1);
		brelse(bh);
		bh = sb_bread(inode->i_sb, ++block);
		if (!bh)
			goto out_badread;
		memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
		de = tmpde;
	}

	inode->i_ino = isofs_get_ino(ei->i_iget5_block,
D
Dave Jones 已提交
1289 1290
					ei->i_iget5_offset,
					ISOFS_BUFFER_BITS(inode));
L
Linus Torvalds 已提交
1291 1292 1293 1294 1295

	/* Assume it is a normal-format file unless told otherwise */
	ei->i_file_format = isofs_file_normal;

	if (de->flags[-high_sierra] & 2) {
1296 1297 1298 1299
		if (sbi->s_dmode != ISOFS_INVALID_MODE)
			inode->i_mode = S_IFDIR | sbi->s_dmode;
		else
			inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
1300
		set_nlink(inode, 1);	/*
D
Dave Jones 已提交
1301 1302 1303 1304 1305 1306
					 * Set to 1.  We know there are 2, but
					 * the find utility tries to optimize
					 * if it is 2, and it screws up.  It is
					 * easier to give 1 which tells find to
					 * do it the hard way.
					 */
L
Linus Torvalds 已提交
1307
	} else {
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
		if (sbi->s_fmode != ISOFS_INVALID_MODE) {
			inode->i_mode = S_IFREG | sbi->s_fmode;
		} else {
			/*
			 * Set default permissions: r-x for all.  The disc
			 * could be shared with DOS machines so virtually
			 * anything could be a valid executable.
			 */
			inode->i_mode = S_IFREG | S_IRUGO | S_IXUGO;
		}
1318
		set_nlink(inode, 1);
L
Linus Torvalds 已提交
1319 1320 1321
	}
	inode->i_uid = sbi->s_uid;
	inode->i_gid = sbi->s_gid;
1322
	inode->i_blocks = 0;
L
Linus Torvalds 已提交
1323 1324 1325 1326 1327

	ei->i_format_parm[0] = 0;
	ei->i_format_parm[1] = 0;
	ei->i_format_parm[2] = 0;

D
Dave Jones 已提交
1328
	ei->i_section_size = isonum_733(de->size);
1329
	if (de->flags[-high_sierra] & 0x80) {
1330 1331
		ret = isofs_read_level3_size(inode);
		if (ret < 0)
D
Dave Jones 已提交
1332
			goto fail;
1333
		ret = -EIO;
L
Linus Torvalds 已提交
1334 1335 1336
	} else {
		ei->i_next_section_block = 0;
		ei->i_next_section_offset = 0;
D
Dave Jones 已提交
1337
		inode->i_size = isonum_733(de->size);
L
Linus Torvalds 已提交
1338 1339 1340 1341 1342 1343 1344 1345
	}

	/*
	 * Some dipshit decided to store some other bit of information
	 * in the high byte of the file length.  Truncate size in case
	 * this CDROM was mounted with the cruft option.
	 */

1346
	if (sbi->s_cruft)
L
Linus Torvalds 已提交
1347 1348 1349
		inode->i_size &= 0x00ffffff;

	if (de->interleave[0]) {
D
Dave Jones 已提交
1350
		printk(KERN_DEBUG "ISOFS: Interleaved files not (yet) supported.\n");
L
Linus Torvalds 已提交
1351 1352 1353 1354 1355 1356
		inode->i_size = 0;
	}

	/* I have no idea what file_unit_size is used for, so
	   we will flag it for now */
	if (de->file_unit_size[0] != 0) {
D
Dave Jones 已提交
1357 1358
		printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%ld).\n",
			inode->i_ino);
L
Linus Torvalds 已提交
1359 1360 1361 1362 1363 1364
	}

	/* I have no idea what other flag bits are used for, so
	   we will flag it for now */
#ifdef DEBUG
	if((de->flags[-high_sierra] & ~2)!= 0){
D
Dave Jones 已提交
1365 1366 1367
		printk(KERN_DEBUG "ISOFS: Unusual flag settings for ISO file "
				"(%ld %x).\n",
			inode->i_ino, de->flags[-high_sierra]);
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
	}
#endif

	inode->i_mtime.tv_sec =
	inode->i_atime.tv_sec =
	inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
	inode->i_mtime.tv_nsec =
	inode->i_atime.tv_nsec =
	inode->i_ctime.tv_nsec = 0;

D
Dave Jones 已提交
1378 1379
	ei->i_first_extent = (isonum_733(de->extent) +
			isonum_711(de->ext_attr_length));
L
Linus Torvalds 已提交
1380 1381

	/* Set the number of blocks for stat() - should be done before RR */
D
Dave Jones 已提交
1382
	inode->i_blocks = (inode->i_size + 511) >> 9;
L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388 1389

	/*
	 * Now test for possible Rock Ridge extensions which will override
	 * some of these numbers in the inode structure.
	 */

	if (!high_sierra) {
1390
		parse_rock_ridge_inode(de, inode, relocated);
L
Linus Torvalds 已提交
1391
		/* if we want uid/gid set, override the rock ridge setting */
1392 1393 1394 1395
		if (sbi->s_uid_set)
			inode->i_uid = sbi->s_uid;
		if (sbi->s_gid_set)
			inode->i_gid = sbi->s_gid;
L
Linus Torvalds 已提交
1396
	}
1397 1398 1399 1400 1401 1402 1403
	/* Now set final access rights if overriding rock ridge setting */
	if (S_ISDIR(inode->i_mode) && sbi->s_overriderockperm &&
	    sbi->s_dmode != ISOFS_INVALID_MODE)
		inode->i_mode = S_IFDIR | sbi->s_dmode;
	if (S_ISREG(inode->i_mode) && sbi->s_overriderockperm &&
	    sbi->s_fmode != ISOFS_INVALID_MODE)
		inode->i_mode = S_IFREG | sbi->s_fmode;
L
Linus Torvalds 已提交
1404 1405 1406 1407

	/* Install the inode operations vector */
	if (S_ISREG(inode->i_mode)) {
		inode->i_fop = &generic_ro_fops;
D
Dave Jones 已提交
1408
		switch (ei->i_file_format) {
L
Linus Torvalds 已提交
1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
#ifdef CONFIG_ZISOFS
		case isofs_file_compressed:
			inode->i_data.a_ops = &zisofs_aops;
			break;
#endif
		default:
			inode->i_data.a_ops = &isofs_aops;
			break;
		}
	} else if (S_ISDIR(inode->i_mode)) {
		inode->i_op = &isofs_dir_inode_operations;
		inode->i_fop = &isofs_dir_operations;
	} else if (S_ISLNK(inode->i_mode)) {
		inode->i_op = &page_symlink_inode_operations;
1423
		inode_nohighmem(inode);
L
Linus Torvalds 已提交
1424 1425 1426 1427 1428
		inode->i_data.a_ops = &isofs_symlink_aops;
	} else
		/* XXX - parse_rock_ridge_inode() had already set i_rdev. */
		init_special_inode(inode, inode->i_mode, inode->i_rdev);

1429
	ret = 0;
1430
out:
J
Jesper Juhl 已提交
1431
	kfree(tmpde);
L
Linus Torvalds 已提交
1432 1433
	if (bh)
		brelse(bh);
1434
	return ret;
L
Linus Torvalds 已提交
1435

1436
out_badread:
L
Linus Torvalds 已提交
1437
	printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1438
fail:
L
Linus Torvalds 已提交
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
	goto out;
}

struct isofs_iget5_callback_data {
	unsigned long block;
	unsigned long offset;
};

static int isofs_iget5_test(struct inode *ino, void *data)
{
	struct iso_inode_info *i = ISOFS_I(ino);
	struct isofs_iget5_callback_data *d =
		(struct isofs_iget5_callback_data*)data;
	return (i->i_iget5_block == d->block)
D
Dave Jones 已提交
1453
		&& (i->i_iget5_offset == d->offset);
L
Linus Torvalds 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
}

static int isofs_iget5_set(struct inode *ino, void *data)
{
	struct iso_inode_info *i = ISOFS_I(ino);
	struct isofs_iget5_callback_data *d =
		(struct isofs_iget5_callback_data*)data;
	i->i_iget5_block = d->block;
	i->i_iget5_offset = d->offset;
	return 0;
}

/* Store, in the inode's containing structure, the block and block
 * offset that point to the underlying meta-data for the inode.  The
 * code below is otherwise similar to the iget() code in
 * include/linux/fs.h */
1470 1471 1472 1473
struct inode *__isofs_iget(struct super_block *sb,
			   unsigned long block,
			   unsigned long offset,
			   int relocated)
L
Linus Torvalds 已提交
1474 1475 1476 1477
{
	unsigned long hashval;
	struct inode *inode;
	struct isofs_iget5_callback_data data;
1478
	long ret;
L
Linus Torvalds 已提交
1479 1480

	if (offset >= 1ul << sb->s_blocksize_bits)
1481
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
1482 1483 1484 1485 1486 1487

	data.block = block;
	data.offset = offset;

	hashval = (block << sb->s_blocksize_bits) | offset;

1488
	inode = iget5_locked(sb, hashval, &isofs_iget5_test,
D
Dave Jones 已提交
1489
				&isofs_iget5_set, &data);
L
Linus Torvalds 已提交
1490

1491 1492 1493 1494
	if (!inode)
		return ERR_PTR(-ENOMEM);

	if (inode->i_state & I_NEW) {
1495
		ret = isofs_read_inode(inode, relocated);
1496 1497 1498 1499 1500 1501
		if (ret < 0) {
			iget_failed(inode);
			inode = ERR_PTR(ret);
		} else {
			unlock_new_inode(inode);
		}
L
Linus Torvalds 已提交
1502 1503 1504 1505 1506
	}

	return inode;
}

A
Al Viro 已提交
1507 1508
static struct dentry *isofs_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
1509
{
A
Al Viro 已提交
1510
	return mount_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
L
Linus Torvalds 已提交
1511 1512 1513 1514 1515
}

static struct file_system_type iso9660_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "iso9660",
A
Al Viro 已提交
1516
	.mount		= isofs_mount,
L
Linus Torvalds 已提交
1517 1518 1519
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
1520
MODULE_ALIAS_FS("iso9660");
1521
MODULE_ALIAS("iso9660");
L
Linus Torvalds 已提交
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558

static int __init init_iso9660_fs(void)
{
	int err = init_inodecache();
	if (err)
		goto out;
#ifdef CONFIG_ZISOFS
	err = zisofs_init();
	if (err)
		goto out1;
#endif
	err = register_filesystem(&iso9660_fs_type);
	if (err)
		goto out2;
	return 0;
out2:
#ifdef CONFIG_ZISOFS
	zisofs_cleanup();
out1:
#endif
	destroy_inodecache();
out:
	return err;
}

static void __exit exit_iso9660_fs(void)
{
        unregister_filesystem(&iso9660_fs_type);
#ifdef CONFIG_ZISOFS
	zisofs_cleanup();
#endif
	destroy_inodecache();
}

module_init(init_iso9660_fs)
module_exit(exit_iso9660_fs)
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部