inode.c 40.4 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
 */

A
Al Viro 已提交
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>
A
Al Viro 已提交
21 22
#include <linux/statfs.h>
#include <linux/cdrom.h>
L
Linus Torvalds 已提交
23
#include <linux/parser.h>
N
Namjae Jeon 已提交
24
#include <linux/mpage.h>
25
#include <linux/user_namespace.h>
D
David Howells 已提交
26
#include <linux/seq_file.h>
L
Linus Torvalds 已提交
27

A
Al Viro 已提交
28
#include "isofs.h"
L
Linus Torvalds 已提交
29 30 31 32
#include "zisofs.h"

#define BEQUIET

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

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

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

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

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

59
static int isofs_read_inode(struct inode *, int relocated);
60
static int isofs_statfs (struct dentry *, struct kstatfs *);
D
David Howells 已提交
61
static int isofs_show_options(struct seq_file *, struct dentry *);
L
Linus Torvalds 已提交
62

63
static struct kmem_cache *isofs_inode_cachep;
L
Linus Torvalds 已提交
64 65 66 67

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

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

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

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

C
Christoph Lameter 已提交
89
	inode_init_once(&ei->vfs_inode);
L
Linus Torvalds 已提交
90
}
D
Dave Jones 已提交
91

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

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

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

122
static const struct super_operations isofs_sops = {
L
Linus Torvalds 已提交
123 124 125 126 127
	.alloc_inode	= isofs_alloc_inode,
	.destroy_inode	= isofs_destroy_inode,
	.put_super	= isofs_put_super,
	.statfs		= isofs_statfs,
	.remount_fs	= isofs_remount,
D
David Howells 已提交
128
	.show_options	= isofs_show_options,
L
Linus Torvalds 已提交
129 130 131
};


132
static const struct dentry_operations isofs_dentry_ops[] = {
L
Linus Torvalds 已提交
133 134 135 136 137 138 139 140 141 142 143 144
	{
		.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,
145
	},
L
Linus Torvalds 已提交
146 147 148 149
#endif
};

struct iso9660_options{
150
	unsigned int rock:1;
151
	unsigned int joliet:1;
152 153 154 155 156 157 158 159 160
	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 已提交
161 162
	unsigned char check;
	unsigned int blocksize;
A
Al Viro 已提交
163 164
	umode_t fmode;
	umode_t dmode;
165 166
	kgid_t gid;
	kuid_t uid;
L
Linus Torvalds 已提交
167
	char *iocharset;
D
Dave Jones 已提交
168 169 170
	/* LVE */
	s32 session;
	s32 sbsector;
L
Linus Torvalds 已提交
171 172 173 174 175 176
};

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

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

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

	return 0;
}

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

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

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

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

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

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

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

	return 0;
}

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

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

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

static int
286
isofs_dentry_cmpi_ms(const struct dentry *dentry,
N
Nick Piggin 已提交
287
		unsigned int len, const char *str, const struct qstr *name)
L
Linus Torvalds 已提交
288
{
N
Nick Piggin 已提交
289
	return isofs_dentry_cmp_common(len, str, name, 1, 1);
L
Linus Torvalds 已提交
290 291 292 293 294 295 296
}
#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,
297
	Opt_nocompress, Opt_hide, Opt_showassoc, Opt_dmode, Opt_overriderockperm,
L
Linus Torvalds 已提交
298 299
};

300
static const match_table_t tokens = {
L
Linus Torvalds 已提交
301 302 303
	{Opt_norock, "norock"},
	{Opt_nojoliet, "nojoliet"},
	{Opt_unhide, "unhide"},
304 305
	{Opt_hide, "hide"},
	{Opt_showassoc, "showassoc"},
L
Linus Torvalds 已提交
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
	{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 已提交
324
	{Opt_dmode, "dmode=%u"},
325
	{Opt_overriderockperm, "overriderockperm"},
L
Linus Torvalds 已提交
326 327 328 329 330 331 332 333 334 335 336 337 338
	{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}
};

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

	popt->map = 'n';
345 346 347 348 349
	popt->rock = 1;
	popt->joliet = 1;
	popt->cruft = 0;
	popt->hide = 0;
	popt->showassoc = 0;
L
Linus Torvalds 已提交
350 351 352
	popt->check = 'u';		/* unset */
	popt->nocompress = 0;
	popt->blocksize = 1024;
353
	popt->fmode = popt->dmode = ISOFS_INVALID_MODE;
354 355
	popt->uid_set = 0;
	popt->gid_set = 0;
356 357
	popt->gid = GLOBAL_ROOT_GID;
	popt->uid = GLOBAL_ROOT_UID;
L
Linus Torvalds 已提交
358 359
	popt->iocharset = NULL;
	popt->utf8 = 0;
360
	popt->overriderockperm = 0;
L
Linus Torvalds 已提交
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
	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:
377
			popt->rock = 0;
L
Linus Torvalds 已提交
378 379
			break;
		case Opt_nojoliet:
380
			popt->joliet = 0;
L
Linus Torvalds 已提交
381
			break;
382
		case Opt_hide:
383
			popt->hide = 1;
384
			break;
L
Linus Torvalds 已提交
385
		case Opt_unhide:
386
		case Opt_showassoc:
387
			popt->showassoc = 1;
L
Linus Torvalds 已提交
388 389
			break;
		case Opt_cruft:
390
			popt->cruft = 1;
L
Linus Torvalds 已提交
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 431 432
			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;
433 434 435
			popt->uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(popt->uid))
				return 0;
436
			popt->uid_set = 1;
L
Linus Torvalds 已提交
437 438 439 440
			break;
		case Opt_gid:
			if (match_int(&args[0], &option))
				return 0;
441 442 443
			popt->gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(popt->gid))
				return 0;
444
			popt->gid_set = 1;
L
Linus Torvalds 已提交
445 446 447 448
			break;
		case Opt_mode:
			if (match_int(&args[0], &option))
				return 0;
J
Jan Kara 已提交
449 450 451 452 453 454
			popt->fmode = option;
			break;
		case Opt_dmode:
			if (match_int(&args[0], &option))
				return 0;
			popt->dmode = option;
L
Linus Torvalds 已提交
455
			break;
456 457 458
		case Opt_overriderockperm:
			popt->overriderockperm = 1;
			break;
L
Linus Torvalds 已提交
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
		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;
}

D
David Howells 已提交
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
/*
 * Display the mount options in /proc/mounts.
 */
static int isofs_show_options(struct seq_file *m, struct dentry *root)
{
	struct isofs_sb_info *sbi = ISOFS_SB(root->d_sb);

	if (!sbi->s_rock)		seq_puts(m, ",norock");
	else if (!sbi->s_joliet_level)	seq_puts(m, ",nojoliet");
	if (sbi->s_cruft)		seq_puts(m, ",cruft");
	if (sbi->s_hide)		seq_puts(m, ",hide");
	if (sbi->s_nocompress)		seq_puts(m, ",nocompress");
	if (sbi->s_overriderockperm)	seq_puts(m, ",overriderockperm");
	if (sbi->s_showassoc)		seq_puts(m, ",showassoc");
	if (sbi->s_utf8)		seq_puts(m, ",utf8");

	if (sbi->s_check)		seq_printf(m, ",check=%c", sbi->s_check);
	if (sbi->s_mapping)		seq_printf(m, ",map=%c", sbi->s_mapping);
D
David Howells 已提交
495
	if (sbi->s_session != 255)	seq_printf(m, ",session=%u", sbi->s_session - 1);
D
David Howells 已提交
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
	if (sbi->s_sbsector != -1)	seq_printf(m, ",sbsector=%u", sbi->s_sbsector);

	if (root->d_sb->s_blocksize != 1024)
		seq_printf(m, ",blocksize=%lu", root->d_sb->s_blocksize);

	if (sbi->s_uid_set)
		seq_printf(m, ",uid=%u",
			   from_kuid_munged(&init_user_ns, sbi->s_uid));
	if (sbi->s_gid_set)
		seq_printf(m, ",gid=%u",
			   from_kgid_munged(&init_user_ns, sbi->s_gid));

	if (sbi->s_dmode != ISOFS_INVALID_MODE)
		seq_printf(m, ",dmode=%o", sbi->s_dmode);
	if (sbi->s_fmode != ISOFS_INVALID_MODE)
		seq_printf(m, ",fmode=%o", sbi->s_fmode);

	if (sbi->s_nls_iocharset &&
	    strcmp(sbi->s_nls_iocharset->charset, CONFIG_NLS_DEFAULT) != 0)
		seq_printf(m, ",iocharset=%s", sbi->s_nls_iocharset->charset);
	return 0;
}

L
Linus Torvalds 已提交
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
/*
 * 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

537
static unsigned int isofs_get_last_session(struct super_block *sb, s32 session)
L
Linus Torvalds 已提交
538 539 540 541 542 543 544 545 546 547 548 549 550 551
{
	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 已提交
552 553 554
			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 已提交
555 556 557
			if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
				return Te.cdte_addr.lba;
		}
D
Dave Jones 已提交
558 559

		printk(KERN_ERR "ISOFS: Invalid session number or type of track\n");
L
Linus Torvalds 已提交
560 561
	}
	i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
562
	if (session > 0)
D
Dave Jones 已提交
563
		printk(KERN_ERR "ISOFS: Invalid session number\n");
L
Linus Torvalds 已提交
564
#if 0
D
Dave Jones 已提交
565
	printk(KERN_DEBUG "isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
L
Linus Torvalds 已提交
566
	if (i==0) {
D
Dave Jones 已提交
567 568
		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 已提交
569 570 571 572
	}
#endif
	if (i==0)
#if WE_OBEY_THE_WRITTEN_STANDARDS
D
Dave Jones 已提交
573
		if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
L
Linus Torvalds 已提交
574
#endif
D
Dave Jones 已提交
575
			vol_desc_start=ms_info.addr.lba;
L
Linus Torvalds 已提交
576 577 578
	return vol_desc_start;
}

579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
/*
 * 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 已提交
607 608 609 610 611 612 613 614
/*
 * 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 已提交
615 616 617
	struct buffer_head *bh = NULL, *pri_bh = NULL;
	struct hs_primary_descriptor *h_pri = NULL;
	struct iso_primary_descriptor *pri = NULL;
L
Linus Torvalds 已提交
618
	struct iso_supplementary_descriptor *sec = NULL;
D
Dave Jones 已提交
619 620 621 622 623 624 625 626
	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;
627
	int table, error = -EINVAL;
D
Dave Jones 已提交
628
	unsigned int vol_desc_start;
L
Linus Torvalds 已提交
629

630
	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
A
Arnd Bergmann 已提交
631
	if (!sbi)
L
Linus Torvalds 已提交
632 633 634
		return -ENOMEM;
	s->s_fs_info = sbi;

635
	if (!parse_options((char *)data, &opt))
L
Linus Torvalds 已提交
636 637 638 639 640 641 642 643 644 645 646 647 648 649
		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 */
D
David Howells 已提交
650 651
	sbi->s_session = opt.session;
	sbi->s_sbsector = opt.sbsector;
L
Linus Torvalds 已提交
652 653 654 655

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

D
Dave Jones 已提交
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
	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 已提交
684
#ifdef CONFIG_JOLIET
D
Dave Jones 已提交
685 686 687
			else if (isonum_711(vdp->type) == ISO_VD_SUPPLEMENTARY) {
				sec = (struct iso_supplementary_descriptor *)vdp;
				if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
688
					if (opt.joliet) {
D
Dave Jones 已提交
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
						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 已提交
705 706
			}
#endif
D
Dave Jones 已提交
707 708 709 710 711 712
		} 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;
713
				opt.rock = 0;
D
Dave Jones 已提交
714 715 716
				h_pri = (struct hs_primary_descriptor *)vdp;
				goto root_found;
			}
L
Linus Torvalds 已提交
717 718
		}

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

D
Dave Jones 已提交
721 722
		brelse(bh);
		bh = NULL;
L
Linus Torvalds 已提交
723 724 725 726 727 728 729 730 731 732 733 734
	}
	/*
	 * 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:
735 736 737 738 739
	/* We don't support read-write mounts */
	if (!(s->s_flags & MS_RDONLY)) {
		error = -EACCES;
		goto out_freebh;
	}
L
Linus Torvalds 已提交
740

741
	if (joliet_level && (pri == NULL || !opt.rock)) {
D
Dave Jones 已提交
742 743 744 745
		/* 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 已提交
746 747 748
	}

	if(sbi->s_high_sierra){
D
Dave Jones 已提交
749 750 751 752
		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 已提交
753
	} else {
D
Dave Jones 已提交
754 755 756 757 758 759
		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 已提交
760 761 762 763 764 765 766 767 768 769 770 771
	}

	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 已提交
772
	if (orig_zonesize < opt.blocksize)
L
Linus Torvalds 已提交
773 774 775
		goto out_bad_size;

	/* RDE: convert log zone size to bit shift */
D
Dave Jones 已提交
776 777 778 779
	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 已提交
780

D
Dave Jones 已提交
781
	default:
L
Linus Torvalds 已提交
782
		goto out_bad_zone_size;
D
Dave Jones 已提交
783
	}
L
Linus Torvalds 已提交
784 785

	s->s_magic = ISOFS_SUPER_MAGIC;
786 787 788 789 790 791

	/*
	 * 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 已提交
792 793 794

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

	first_data_zone = isonum_733(rootp->extent) +
			  isonum_711(rootp->ext_attr_length);
L
Linus Torvalds 已提交
798 799
	sbi->s_firstdatazone = first_data_zone;
#ifndef BEQUIET
D
Dave Jones 已提交
800 801 802
	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 已提交
803
	if(sbi->s_high_sierra)
D
Dave Jones 已提交
804
		printk(KERN_DEBUG "ISOFS: Disc in High Sierra format.\n");
L
Linus Torvalds 已提交
805 806 807 808 809 810 811 812 813 814 815 816 817 818
#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 已提交
819 820
		first_data_zone = isonum_733(rootp->extent) +
				isonum_711(rootp->ext_attr_length);
L
Linus Torvalds 已提交
821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852
	}

	/*
	 * 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 已提交
853
		char *p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
L
Linus Torvalds 已提交
854 855 856 857 858 859 860 861 862 863 864 865
		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;
866
	sbi->s_rock = (opt.rock ? 2 : 0);
L
Linus Torvalds 已提交
867 868
	sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
	sbi->s_cruft = opt.cruft;
869 870
	sbi->s_hide = opt.hide;
	sbi->s_showassoc = opt.showassoc;
L
Linus Torvalds 已提交
871 872
	sbi->s_uid = opt.uid;
	sbi->s_gid = opt.gid;
873 874
	sbi->s_uid_set = opt.uid_set;
	sbi->s_gid_set = opt.gid_set;
L
Linus Torvalds 已提交
875 876
	sbi->s_utf8 = opt.utf8;
	sbi->s_nocompress = opt.nocompress;
877
	sbi->s_overriderockperm = opt.overriderockperm;
L
Linus Torvalds 已提交
878 879 880 881 882
	/*
	 * 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.
	 */
883 884 885 886 887 888 889 890
	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 已提交
891 892 893 894 895 896 897

	/*
	 * 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);
898 899
	if (IS_ERR(inode))
		goto out_no_root;
L
Linus Torvalds 已提交
900

901 902 903 904 905 906 907 908 909 910 911 912
	/*
	 * 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 已提交
913 914 915 916 917 918 919 920 921 922 923 924 925 926
	/*
	 * 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 已提交
927
			printk(KERN_DEBUG
L
Linus Torvalds 已提交
928 929 930
				"ISOFS: changing to secondary root\n");
			iput(inode);
			inode = isofs_iget(s, sbi->s_firstdatazone, 0);
931 932
			if (IS_ERR(inode))
				goto out_no_root;
L
Linus Torvalds 已提交
933 934 935 936 937
		}
	}

	if (opt.check == 'u') {
		/* Only Joliet is case insensitive by default */
D
Dave Jones 已提交
938 939 940 941
		if (joliet_level)
			opt.check = 'r';
		else
			opt.check = 's';
L
Linus Torvalds 已提交
942 943 944
	}
	sbi->s_joliet_level = joliet_level;

945 946 947 948 949 950 951 952
	/* 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 已提交
953
	table = 0;
D
Dave Jones 已提交
954 955 956 957
	if (joliet_level)
		table += 2;
	if (opt.check == 'r')
		table++;
D
David Howells 已提交
958
	sbi->s_check = opt.check;
A
Al Viro 已提交
959

960 961
	if (table)
		s->s_d_op = &isofs_dentry_ops[table - 1];
A
Al Viro 已提交
962 963

	/* get the root dentry */
964
	s->s_root = d_make_root(inode);
A
Al Viro 已提交
965 966 967 968
	if (!(s->s_root)) {
		error = -ENOMEM;
		goto out_no_inode;
	}
L
Linus Torvalds 已提交
969

J
Jesper Juhl 已提交
970
	kfree(opt.iocharset);
L
Linus Torvalds 已提交
971 972 973 974 975 976 977 978

	return 0;

	/*
	 * Display error messages and free resources.
	 */
out_iput:
	iput(inode);
979 980 981 982 983 984
	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 已提交
985
#ifdef CONFIG_JOLIET
986
	unload_nls(sbi->s_nls_iocharset);
L
Linus Torvalds 已提交
987 988 989
#endif
	goto out_freesbi;
out_no_read:
D
Dave Jones 已提交
990 991
	printk(KERN_WARNING "%s: bread failed, dev=%s, iso_blknum=%d, block=%d\n",
		__func__, s->s_id, iso_blknum, block);
992
	goto out_freebh;
L
Linus Torvalds 已提交
993
out_bad_zone_size:
D
Dave Jones 已提交
994
	printk(KERN_WARNING "ISOFS: Bad logical zone size %ld\n",
L
Linus Torvalds 已提交
995 996 997
		sbi->s_log_zone_size);
	goto out_freebh;
out_bad_size:
D
Dave Jones 已提交
998
	printk(KERN_WARNING "ISOFS: Logical zone size(%d) < hardware blocksize(%u)\n",
L
Linus Torvalds 已提交
999 1000 1001 1002
		orig_zonesize, opt.blocksize);
	goto out_freebh;
out_unknown_format:
	if (!silent)
D
Dave Jones 已提交
1003
		printk(KERN_WARNING "ISOFS: Unable to identify CD-ROM format.\n");
L
Linus Torvalds 已提交
1004 1005 1006

out_freebh:
	brelse(bh);
1007
	brelse(pri_bh);
L
Linus Torvalds 已提交
1008
out_freesbi:
J
Jesper Juhl 已提交
1009
	kfree(opt.iocharset);
L
Linus Torvalds 已提交
1010 1011
	kfree(sbi);
	s->s_fs_info = NULL;
1012
	return error;
L
Linus Torvalds 已提交
1013 1014
}

1015
static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
L
Linus Torvalds 已提交
1016
{
1017
	struct super_block *sb = dentry->d_sb;
C
Coly Li 已提交
1018
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1019

L
Linus Torvalds 已提交
1020 1021 1022
	buf->f_type = ISOFS_SUPER_MAGIC;
	buf->f_bsize = sb->s_blocksize;
	buf->f_blocks = (ISOFS_SB(sb)->s_nzones
D
Dave Jones 已提交
1023
		<< (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
L
Linus Torvalds 已提交
1024 1025 1026 1027
	buf->f_bfree = 0;
	buf->f_bavail = 0;
	buf->f_files = ISOFS_SB(sb)->s_ninodes;
	buf->f_ffree = 0;
C
Coly Li 已提交
1028 1029
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);
L
Linus Torvalds 已提交
1030 1031 1032 1033 1034 1035 1036
	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
1037
 * (-ve == error.)
L
Linus Torvalds 已提交
1038
 */
1039
int isofs_get_blocks(struct inode *inode, sector_t iblock,
L
Linus Torvalds 已提交
1040 1041
		     struct buffer_head **bh, unsigned long nblocks)
{
1042
	unsigned long b_off = iblock;
L
Linus Torvalds 已提交
1043 1044 1045
	unsigned offset, sect_size;
	unsigned int firstext;
	unsigned long nextblk, nextoff;
1046
	int section, rv, error;
L
Linus Torvalds 已提交
1047 1048
	struct iso_inode_info *ei = ISOFS_I(inode);

1049
	error = -EIO;
L
Linus Torvalds 已提交
1050
	rv = 0;
1051
	if (iblock != b_off) {
D
Dave Jones 已提交
1052
		printk(KERN_DEBUG "%s: block number too large\n", __func__);
L
Linus Torvalds 已提交
1053 1054 1055
		goto abort;
	}

D
Dave Jones 已提交
1056 1057 1058

	offset = 0;
	firstext = ei->i_first_extent;
L
Linus Torvalds 已提交
1059
	sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
D
Dave Jones 已提交
1060 1061 1062
	nextblk = ei->i_next_section_block;
	nextoff = ei->i_next_section_offset;
	section = 0;
L
Linus Torvalds 已提交
1063

D
Dave Jones 已提交
1064
	while (nblocks) {
L
Linus Torvalds 已提交
1065 1066 1067 1068 1069 1070 1071
		/* 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.
		 */
1072
		if (b_off > ((inode->i_size + PAGE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
1073 1074 1075
			printk(KERN_DEBUG "%s: block >= EOF (%lu, %llu)\n",
				__func__, b_off,
				(unsigned long long)inode->i_size);
L
Linus Torvalds 已提交
1076 1077
			goto abort;
		}
D
Dave Jones 已提交
1078

1079 1080 1081 1082 1083 1084 1085 1086 1087
		/* 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);
1088 1089
			if (IS_ERR(ninode)) {
				error = PTR_ERR(ninode);
1090
				goto abort;
1091
			}
1092 1093 1094 1095 1096 1097 1098
			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 已提交
1099 1100
				printk(KERN_DEBUG "%s: More than 100 file sections ?!?"
					" aborting...\n", __func__);
1101
				printk(KERN_DEBUG "%s: block=%lu firstext=%u sect_size=%u "
D
Dave Jones 已提交
1102
					"nextblk=%lu nextoff=%lu\n", __func__,
1103
					b_off, firstext, (unsigned) sect_size,
D
Dave Jones 已提交
1104
					nextblk, nextoff);
1105
				goto abort;
L
Linus Torvalds 已提交
1106 1107
			}
		}
D
Dave Jones 已提交
1108 1109

		if (*bh) {
L
Linus Torvalds 已提交
1110 1111 1112
			map_bh(*bh, inode->i_sb, firstext + b_off - offset);
		} else {
			*bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
D
Dave Jones 已提交
1113
			if (!*bh)
L
Linus Torvalds 已提交
1114 1115 1116 1117 1118 1119 1120 1121
				goto abort;
		}
		bh++;	/* Next buffer head */
		b_off++;	/* Next buffer offset */
		nblocks--;
		rv++;
	}

1122
	error = 0;
L
Linus Torvalds 已提交
1123
abort:
1124
	return rv != 0 ? rv : error;
L
Linus Torvalds 已提交
1125 1126 1127 1128 1129 1130 1131 1132
}

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

1135
	if (create) {
D
Dave Jones 已提交
1136
		printk(KERN_DEBUG "%s: Kernel tries to allocate a block\n", __func__);
L
Linus Torvalds 已提交
1137 1138 1139
		return -EROFS;
	}

1140 1141
	ret = isofs_get_blocks(inode, iblock, &bh_result, 1);
	return ret < 0 ? ret : 0;
L
Linus Torvalds 已提交
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
}

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)
{
N
Namjae Jeon 已提交
1167 1168 1169 1170 1171 1172 1173
	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 已提交
1174 1175 1176 1177 1178 1179 1180
}

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

1181
static const struct address_space_operations isofs_aops = {
L
Linus Torvalds 已提交
1182
	.readpage = isofs_readpage,
N
Namjae Jeon 已提交
1183
	.readpages = isofs_readpages,
L
Linus Torvalds 已提交
1184 1185 1186
	.bmap = _isofs_bmap
};

1187
static int isofs_read_level3_size(struct inode *inode)
L
Linus Torvalds 已提交
1188 1189 1190
{
	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
	int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
D
Dave Jones 已提交
1191
	struct buffer_head *bh = NULL;
L
Linus Torvalds 已提交
1192 1193 1194
	unsigned long block, offset, block_saved, offset_saved;
	int i = 0;
	int more_entries = 0;
D
Dave Jones 已提交
1195
	struct iso_directory_record *tmpde = NULL;
L
Linus Torvalds 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
	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 已提交
1210
		struct iso_directory_record *de;
L
Linus Torvalds 已提交
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
		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;
1250
				memcpy((void *)tmpde+slop, bh->b_data, offset);
L
Linus Torvalds 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
			}
			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++;
1264
		if (i > 100)
L
Linus Torvalds 已提交
1265
			goto out_toomany;
1266
	} while (more_entries);
L
Linus Torvalds 已提交
1267
out:
1268
	kfree(tmpde);
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
	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 已提交
1280
	kfree(tmpde);
L
Linus Torvalds 已提交
1281 1282 1283
	return -EIO;

out_toomany:
D
Dave Jones 已提交
1284 1285 1286
	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 已提交
1287 1288 1289
	goto out;
}

1290
static int isofs_read_inode(struct inode *inode, int relocated)
L
Linus Torvalds 已提交
1291 1292 1293 1294 1295 1296
{
	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 已提交
1297 1298 1299
	struct buffer_head *bh = NULL;
	struct iso_directory_record *de;
	struct iso_directory_record *tmpde = NULL;
L
Linus Torvalds 已提交
1300 1301 1302
	unsigned int de_len;
	unsigned long offset;
	struct iso_inode_info *ei = ISOFS_I(inode);
1303
	int ret = -EIO;
L
Linus Torvalds 已提交
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319

	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 已提交
1320
			printk(KERN_INFO "%s: out of memory\n", __func__);
1321
			ret = -ENOMEM;
L
Linus Torvalds 已提交
1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
			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 已提交
1334 1335
					ei->i_iget5_offset,
					ISOFS_BUFFER_BITS(inode));
L
Linus Torvalds 已提交
1336 1337 1338 1339 1340

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

	if (de->flags[-high_sierra] & 2) {
1341 1342 1343 1344
		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;
M
Miklos Szeredi 已提交
1345
		set_nlink(inode, 1);	/*
D
Dave Jones 已提交
1346 1347 1348 1349 1350 1351
					 * 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 已提交
1352
	} else {
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
		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;
		}
M
Miklos Szeredi 已提交
1363
		set_nlink(inode, 1);
L
Linus Torvalds 已提交
1364 1365 1366
	}
	inode->i_uid = sbi->s_uid;
	inode->i_gid = sbi->s_gid;
1367
	inode->i_blocks = 0;
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372

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

D
Dave Jones 已提交
1373
	ei->i_section_size = isonum_733(de->size);
1374
	if (de->flags[-high_sierra] & 0x80) {
1375 1376
		ret = isofs_read_level3_size(inode);
		if (ret < 0)
D
Dave Jones 已提交
1377
			goto fail;
1378
		ret = -EIO;
L
Linus Torvalds 已提交
1379 1380 1381
	} else {
		ei->i_next_section_block = 0;
		ei->i_next_section_offset = 0;
D
Dave Jones 已提交
1382
		inode->i_size = isonum_733(de->size);
L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388 1389 1390
	}

	/*
	 * 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.
	 */

1391
	if (sbi->s_cruft)
L
Linus Torvalds 已提交
1392 1393 1394
		inode->i_size &= 0x00ffffff;

	if (de->interleave[0]) {
D
Dave Jones 已提交
1395
		printk(KERN_DEBUG "ISOFS: Interleaved files not (yet) supported.\n");
L
Linus Torvalds 已提交
1396 1397 1398 1399 1400 1401
		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 已提交
1402 1403
		printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%ld).\n",
			inode->i_ino);
L
Linus Torvalds 已提交
1404 1405 1406 1407 1408 1409
	}

	/* 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 已提交
1410 1411 1412
		printk(KERN_DEBUG "ISOFS: Unusual flag settings for ISO file "
				"(%ld %x).\n",
			inode->i_ino, de->flags[-high_sierra]);
L
Linus Torvalds 已提交
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
	}
#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 已提交
1423 1424
	ei->i_first_extent = (isonum_733(de->extent) +
			isonum_711(de->ext_attr_length));
L
Linus Torvalds 已提交
1425 1426

	/* Set the number of blocks for stat() - should be done before RR */
D
Dave Jones 已提交
1427
	inode->i_blocks = (inode->i_size + 511) >> 9;
L
Linus Torvalds 已提交
1428 1429 1430 1431 1432 1433 1434

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

	if (!high_sierra) {
1435
		parse_rock_ridge_inode(de, inode, relocated);
L
Linus Torvalds 已提交
1436
		/* if we want uid/gid set, override the rock ridge setting */
1437 1438 1439 1440
		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 已提交
1441
	}
1442 1443 1444 1445 1446 1447 1448
	/* 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 已提交
1449 1450 1451 1452

	/* Install the inode operations vector */
	if (S_ISREG(inode->i_mode)) {
		inode->i_fop = &generic_ro_fops;
D
Dave Jones 已提交
1453
		switch (ei->i_file_format) {
L
Linus Torvalds 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
#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;
1468
		inode_nohighmem(inode);
L
Linus Torvalds 已提交
1469 1470 1471 1472 1473
		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);

1474
	ret = 0;
1475
out:
J
Jesper Juhl 已提交
1476
	kfree(tmpde);
L
Linus Torvalds 已提交
1477 1478
	if (bh)
		brelse(bh);
1479
	return ret;
L
Linus Torvalds 已提交
1480

1481
out_badread:
L
Linus Torvalds 已提交
1482
	printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1483
fail:
L
Linus Torvalds 已提交
1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
	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 已提交
1498
		&& (i->i_iget5_offset == d->offset);
L
Linus Torvalds 已提交
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
}

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 */
1515 1516 1517 1518
struct inode *__isofs_iget(struct super_block *sb,
			   unsigned long block,
			   unsigned long offset,
			   int relocated)
L
Linus Torvalds 已提交
1519 1520 1521 1522
{
	unsigned long hashval;
	struct inode *inode;
	struct isofs_iget5_callback_data data;
1523
	long ret;
L
Linus Torvalds 已提交
1524 1525

	if (offset >= 1ul << sb->s_blocksize_bits)
1526
		return ERR_PTR(-EINVAL);
L
Linus Torvalds 已提交
1527 1528 1529 1530 1531 1532

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

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

1533
	inode = iget5_locked(sb, hashval, &isofs_iget5_test,
D
Dave Jones 已提交
1534
				&isofs_iget5_set, &data);
L
Linus Torvalds 已提交
1535

1536 1537 1538 1539
	if (!inode)
		return ERR_PTR(-ENOMEM);

	if (inode->i_state & I_NEW) {
1540
		ret = isofs_read_inode(inode, relocated);
1541 1542 1543 1544 1545 1546
		if (ret < 0) {
			iget_failed(inode);
			inode = ERR_PTR(ret);
		} else {
			unlock_new_inode(inode);
		}
L
Linus Torvalds 已提交
1547 1548 1549 1550 1551
	}

	return inode;
}

A
Al Viro 已提交
1552 1553
static struct dentry *isofs_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
L
Linus Torvalds 已提交
1554
{
A
Al Viro 已提交
1555
	return mount_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
L
Linus Torvalds 已提交
1556 1557 1558 1559 1560
}

static struct file_system_type iso9660_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "iso9660",
A
Al Viro 已提交
1561
	.mount		= isofs_mount,
L
Linus Torvalds 已提交
1562 1563 1564
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
1565
MODULE_ALIAS_FS("iso9660");
1566
MODULE_ALIAS("iso9660");
L
Linus Torvalds 已提交
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603

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");