Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 838bee9e authored by Jan Kara's avatar Jan Kara
Browse files

Merge udf, isofs, quota, ext2 changes for 4.15-rc1.

parents ac3d7939 88d8ff97

Documentation/filesystems/udf.txt

+2 −6
Original line number Diff line number Diff line 
*

* Documentation/filesystems/udf.txt

*

UDF Filesystem version 0.9.8.1



If you encounter problems with reading UDF discs using this driver,

please report them to linux_udf@hpesjro.fc.hp.com, which is the

developer's list.

please report them according to MAINTAINERS file.



Write support requires a block driver which supports writing.  Currently

dvd+rw drives and media support true random sector writes, and so a udf
@@ -73,10 +71,8 @@ The following expect a offset from the partition root. 




For the latest version and toolset see:

	http://linux-udf.sourceforge.net/

	https://github.com/pali/udftools



Documentation on UDF and ECMA 167 is available FREE from:

	http://www.osta.org/

	http://www.ecma-international.org/
 


Ben Fennema <bfennema@falcon.csc.calpoly.edu>

fs/ext2/super.c

+78 −83
Original line number Diff line number Diff line
@@ -479,10 +479,10 @@ static const match_table_t tokens = { 
	{Opt_err, NULL}

};



static int parse_options(char *options, struct super_block *sb)

static int parse_options(char *options, struct super_block *sb,

			 struct ext2_mount_options *opts)

{

	char *p;

	struct ext2_sb_info *sbi = EXT2_SB(sb);

	substring_t args[MAX_OPT_ARGS];

	int option;

	kuid_t uid;
@@ -499,16 +499,16 @@ static int parse_options(char *options, struct super_block *sb) 
		token = match_token(p, tokens, args);

		switch (token) {

		case Opt_bsd_df:

			clear_opt (sbi->s_mount_opt, MINIX_DF);

			clear_opt (opts->s_mount_opt, MINIX_DF);

			break;

		case Opt_minix_df:

			set_opt (sbi->s_mount_opt, MINIX_DF);

			set_opt (opts->s_mount_opt, MINIX_DF);

			break;

		case Opt_grpid:

			set_opt (sbi->s_mount_opt, GRPID);

			set_opt (opts->s_mount_opt, GRPID);

			break;

		case Opt_nogrpid:

			clear_opt (sbi->s_mount_opt, GRPID);

			clear_opt (opts->s_mount_opt, GRPID);

			break;

		case Opt_resuid:

			if (match_int(&args[0], &option))
@@ -519,7 +519,7 @@ static int parse_options(char *options, struct super_block *sb) 
				return 0;



			}

			sbi->s_resuid = uid;

			opts->s_resuid = uid;

			break;

		case Opt_resgid:

			if (match_int(&args[0], &option))
@@ -529,51 +529,51 @@ static int parse_options(char *options, struct super_block *sb) 
				ext2_msg(sb, KERN_ERR, "Invalid gid value %d", option);

				return 0;

			}

			sbi->s_resgid = gid;

			opts->s_resgid = gid;

			break;

		case Opt_sb:

			/* handled by get_sb_block() instead of here */

			/* *sb_block = match_int(&args[0]); */

			break;

		case Opt_err_panic:

			clear_opt (sbi->s_mount_opt, ERRORS_CONT);

			clear_opt (sbi->s_mount_opt, ERRORS_RO);

			set_opt (sbi->s_mount_opt, ERRORS_PANIC);

			clear_opt (opts->s_mount_opt, ERRORS_CONT);

			clear_opt (opts->s_mount_opt, ERRORS_RO);

			set_opt (opts->s_mount_opt, ERRORS_PANIC);

			break;

		case Opt_err_ro:

			clear_opt (sbi->s_mount_opt, ERRORS_CONT);

			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);

			set_opt (sbi->s_mount_opt, ERRORS_RO);

			clear_opt (opts->s_mount_opt, ERRORS_CONT);

			clear_opt (opts->s_mount_opt, ERRORS_PANIC);

			set_opt (opts->s_mount_opt, ERRORS_RO);

			break;

		case Opt_err_cont:

			clear_opt (sbi->s_mount_opt, ERRORS_RO);

			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);

			set_opt (sbi->s_mount_opt, ERRORS_CONT);

			clear_opt (opts->s_mount_opt, ERRORS_RO);

			clear_opt (opts->s_mount_opt, ERRORS_PANIC);

			set_opt (opts->s_mount_opt, ERRORS_CONT);

			break;

		case Opt_nouid32:

			set_opt (sbi->s_mount_opt, NO_UID32);

			set_opt (opts->s_mount_opt, NO_UID32);

			break;

		case Opt_nocheck:

			clear_opt (sbi->s_mount_opt, CHECK);

			clear_opt (opts->s_mount_opt, CHECK);

			break;

		case Opt_debug:

			set_opt (sbi->s_mount_opt, DEBUG);

			set_opt (opts->s_mount_opt, DEBUG);

			break;

		case Opt_oldalloc:

			set_opt (sbi->s_mount_opt, OLDALLOC);

			set_opt (opts->s_mount_opt, OLDALLOC);

			break;

		case Opt_orlov:

			clear_opt (sbi->s_mount_opt, OLDALLOC);

			clear_opt (opts->s_mount_opt, OLDALLOC);

			break;

		case Opt_nobh:

			set_opt (sbi->s_mount_opt, NOBH);

			set_opt (opts->s_mount_opt, NOBH);

			break;

#ifdef CONFIG_EXT2_FS_XATTR

		case Opt_user_xattr:

			set_opt (sbi->s_mount_opt, XATTR_USER);

			set_opt (opts->s_mount_opt, XATTR_USER);

			break;

		case Opt_nouser_xattr:

			clear_opt (sbi->s_mount_opt, XATTR_USER);

			clear_opt (opts->s_mount_opt, XATTR_USER);

			break;

#else

		case Opt_user_xattr:
@@ -584,10 +584,10 @@ static int parse_options(char *options, struct super_block *sb) 
#endif

#ifdef CONFIG_EXT2_FS_POSIX_ACL

		case Opt_acl:

			set_opt(sbi->s_mount_opt, POSIX_ACL);

			set_opt(opts->s_mount_opt, POSIX_ACL);

			break;

		case Opt_noacl:

			clear_opt(sbi->s_mount_opt, POSIX_ACL);

			clear_opt(opts->s_mount_opt, POSIX_ACL);

			break;

#else

		case Opt_acl:
@@ -598,13 +598,13 @@ static int parse_options(char *options, struct super_block *sb) 
#endif

		case Opt_xip:

			ext2_msg(sb, KERN_INFO, "use dax instead of xip");

			set_opt(sbi->s_mount_opt, XIP);

			set_opt(opts->s_mount_opt, XIP);

			/* Fall through */

		case Opt_dax:

#ifdef CONFIG_FS_DAX

			ext2_msg(sb, KERN_WARNING,

		"DAX enabled. Warning: EXPERIMENTAL, use at your own risk");

			set_opt(sbi->s_mount_opt, DAX);

			set_opt(opts->s_mount_opt, DAX);

#else

			ext2_msg(sb, KERN_INFO, "dax option not supported");

#endif
@@ -613,11 +613,11 @@ static int parse_options(char *options, struct super_block *sb) 
#if defined(CONFIG_QUOTA)

		case Opt_quota:

		case Opt_usrquota:

			set_opt(sbi->s_mount_opt, USRQUOTA);

			set_opt(opts->s_mount_opt, USRQUOTA);

			break;



		case Opt_grpquota:

			set_opt(sbi->s_mount_opt, GRPQUOTA);

			set_opt(opts->s_mount_opt, GRPQUOTA);

			break;

#else

		case Opt_quota:
@@ -629,11 +629,11 @@ static int parse_options(char *options, struct super_block *sb) 
#endif



		case Opt_reservation:

			set_opt(sbi->s_mount_opt, RESERVATION);

			set_opt(opts->s_mount_opt, RESERVATION);

			ext2_msg(sb, KERN_INFO, "reservations ON");

			break;

		case Opt_noreservation:

			clear_opt(sbi->s_mount_opt, RESERVATION);

			clear_opt(opts->s_mount_opt, RESERVATION);

			ext2_msg(sb, KERN_INFO, "reservations OFF");

			break;

		case Opt_ignore:
@@ -830,6 +830,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) 
	int i, j;

	__le32 features;

	int err;

	struct ext2_mount_options opts;



	err = -ENOMEM;

	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
@@ -890,35 +891,39 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) 
	/* Set defaults before we parse the mount options */

	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);

	if (def_mount_opts & EXT2_DEFM_DEBUG)

		set_opt(sbi->s_mount_opt, DEBUG);

		set_opt(opts.s_mount_opt, DEBUG);

	if (def_mount_opts & EXT2_DEFM_BSDGROUPS)

		set_opt(sbi->s_mount_opt, GRPID);

		set_opt(opts.s_mount_opt, GRPID);

	if (def_mount_opts & EXT2_DEFM_UID16)

		set_opt(sbi->s_mount_opt, NO_UID32);

		set_opt(opts.s_mount_opt, NO_UID32);

#ifdef CONFIG_EXT2_FS_XATTR

	if (def_mount_opts & EXT2_DEFM_XATTR_USER)

		set_opt(sbi->s_mount_opt, XATTR_USER);

		set_opt(opts.s_mount_opt, XATTR_USER);

#endif

#ifdef CONFIG_EXT2_FS_POSIX_ACL

	if (def_mount_opts & EXT2_DEFM_ACL)

		set_opt(sbi->s_mount_opt, POSIX_ACL);

		set_opt(opts.s_mount_opt, POSIX_ACL);

#endif

	

	if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)

		set_opt(sbi->s_mount_opt, ERRORS_PANIC);

		set_opt(opts.s_mount_opt, ERRORS_PANIC);

	else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_CONTINUE)

		set_opt(sbi->s_mount_opt, ERRORS_CONT);

		set_opt(opts.s_mount_opt, ERRORS_CONT);

	else

		set_opt(sbi->s_mount_opt, ERRORS_RO);

		set_opt(opts.s_mount_opt, ERRORS_RO);



	sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));

	sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));

	opts.s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));

	opts.s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));

	

	set_opt(sbi->s_mount_opt, RESERVATION);

	set_opt(opts.s_mount_opt, RESERVATION);



	if (!parse_options((char *) data, sb))

	if (!parse_options((char *) data, sb, &opts))

		goto failed_mount;



	sbi->s_mount_opt = opts.s_mount_opt;

	sbi->s_resuid = opts.s_resuid;

	sbi->s_resgid = opts.s_resgid;



	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |

		((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?

		 MS_POSIXACL : 0);
@@ -1312,46 +1317,36 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) 
{

	struct ext2_sb_info * sbi = EXT2_SB(sb);

	struct ext2_super_block * es;

	struct ext2_mount_options old_opts;

	unsigned long old_sb_flags;

	struct ext2_mount_options new_opts;

	int err;



	sync_filesystem(sb);

	spin_lock(&sbi->s_lock);



	/* Store the old options */

	old_sb_flags = sb->s_flags;

	old_opts.s_mount_opt = sbi->s_mount_opt;

	old_opts.s_resuid = sbi->s_resuid;

	old_opts.s_resgid = sbi->s_resgid;

	spin_lock(&sbi->s_lock);

	new_opts.s_mount_opt = sbi->s_mount_opt;

	new_opts.s_resuid = sbi->s_resuid;

	new_opts.s_resgid = sbi->s_resgid;

	spin_unlock(&sbi->s_lock);



	/*

	 * Allow the "check" option to be passed as a remount option.

	 */

	if (!parse_options(data, sb)) {

		err = -EINVAL;

		goto restore_opts;

	}



	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |

		((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);

	if (!parse_options(data, sb, &new_opts))

		return -EINVAL;



	spin_lock(&sbi->s_lock);

	es = sbi->s_es;

	if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT2_MOUNT_DAX) {

	if ((sbi->s_mount_opt ^ new_opts.s_mount_opt) & EXT2_MOUNT_DAX) {

		ext2_msg(sb, KERN_WARNING, "warning: refusing change of "

			 "dax flag with busy inodes while remounting");

		sbi->s_mount_opt ^= EXT2_MOUNT_DAX;

	}

	if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb)) {

		spin_unlock(&sbi->s_lock);

		return 0;

		new_opts.s_mount_opt ^= EXT2_MOUNT_DAX;

	}

	if ((bool)(*flags & MS_RDONLY) == sb_rdonly(sb))

		goto out_set;

	if (*flags & MS_RDONLY) {

		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||

		    !(sbi->s_mount_state & EXT2_VALID_FS)) {

			spin_unlock(&sbi->s_lock);

			return 0;

		}

		    !(sbi->s_mount_state & EXT2_VALID_FS))

			goto out_set;



		/*

		 * OK, we are remounting a valid rw partition rdonly, so set
@@ -1362,22 +1357,20 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) 
		spin_unlock(&sbi->s_lock);



		err = dquot_suspend(sb, -1);

		if (err < 0) {

			spin_lock(&sbi->s_lock);

			goto restore_opts;

		}

		if (err < 0)

			return err;



		ext2_sync_super(sb, es, 1);

	} else {

		__le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,

					       ~EXT2_FEATURE_RO_COMPAT_SUPP);

		if (ret) {

			spin_unlock(&sbi->s_lock);

			ext2_msg(sb, KERN_WARNING,

				"warning: couldn't remount RDWR because of "

				"unsupported optional features (%x).",

				le32_to_cpu(ret));

			err = -EROFS;

			goto restore_opts;

			return -EROFS;

		}

		/*

		 * Mounting a RDONLY partition read-write, so reread and
@@ -1394,14 +1387,16 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data) 
		dquot_resume(sb, -1);

	}



	return 0;

restore_opts:

	sbi->s_mount_opt = old_opts.s_mount_opt;

	sbi->s_resuid = old_opts.s_resuid;

	sbi->s_resgid = old_opts.s_resgid;

	sb->s_flags = old_sb_flags;

	spin_lock(&sbi->s_lock);

out_set:

	sbi->s_mount_opt = new_opts.s_mount_opt;

	sbi->s_resuid = new_opts.s_resuid;

	sbi->s_resgid = new_opts.s_resgid;

	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |

		((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);

	spin_unlock(&sbi->s_lock);

	return err;



	return 0;

}



static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)

fs/isofs/isofs.h

+11 −11
Original line number Diff line number Diff line
@@ -72,41 +72,41 @@ static inline struct iso_inode_info *ISOFS_I(struct inode *inode) 
	return container_of(inode, struct iso_inode_info, vfs_inode);

}



static inline int isonum_711(char *p)

static inline int isonum_711(u8 *p)

{

	return *(u8 *)p;

	return *p;

}

static inline int isonum_712(char *p)

static inline int isonum_712(s8 *p)

{

	return *(s8 *)p;

	return *p;

}

static inline unsigned int isonum_721(char *p)

static inline unsigned int isonum_721(u8 *p)

{

	return get_unaligned_le16(p);

}

static inline unsigned int isonum_722(char *p)

static inline unsigned int isonum_722(u8 *p)

{

	return get_unaligned_be16(p);

}

static inline unsigned int isonum_723(char *p)

static inline unsigned int isonum_723(u8 *p)

{

	/* Ignore bigendian datum due to broken mastering programs */

	return get_unaligned_le16(p);

}

static inline unsigned int isonum_731(char *p)

static inline unsigned int isonum_731(u8 *p)

{

	return get_unaligned_le32(p);

}

static inline unsigned int isonum_732(char *p)

static inline unsigned int isonum_732(u8 *p)

{

	return get_unaligned_be32(p);

}

static inline unsigned int isonum_733(char *p)

static inline unsigned int isonum_733(u8 *p)

{

	/* Ignore bigendian datum due to broken mastering programs */

	return get_unaligned_le32(p);

}

extern int iso_date(char *, int);

extern int iso_date(u8 *, int);



struct inode;		/* To make gcc happy */

fs/isofs/rock.h

+32 −32
Original line number Diff line number Diff line
@@ -6,78 +6,78 @@ 
 */



struct SU_SP_s {

	unsigned char magic[2];

	unsigned char skip;

	__u8 magic[2];

	__u8 skip;

} __attribute__ ((packed));



struct SU_CE_s {

	char extent[8];

	char offset[8];

	char size[8];

	__u8 extent[8];

	__u8 offset[8];

	__u8 size[8];

};



struct SU_ER_s {

	unsigned char len_id;

	unsigned char len_des;

	unsigned char len_src;

	unsigned char ext_ver;

	char data[0];

	__u8 len_id;

	__u8 len_des;

	__u8 len_src;

	__u8 ext_ver;

	__u8 data[0];

} __attribute__ ((packed));



struct RR_RR_s {

	char flags[1];

	__u8 flags[1];

} __attribute__ ((packed));



struct RR_PX_s {

	char mode[8];

	char n_links[8];

	char uid[8];

	char gid[8];

	__u8 mode[8];

	__u8 n_links[8];

	__u8 uid[8];

	__u8 gid[8];

};



struct RR_PN_s {

	char dev_high[8];

	char dev_low[8];

	__u8 dev_high[8];

	__u8 dev_low[8];

};



struct SL_component {

	unsigned char flags;

	unsigned char len;

	char text[0];

	__u8 flags;

	__u8 len;

	__u8 text[0];

} __attribute__ ((packed));



struct RR_SL_s {

	unsigned char flags;

	__u8 flags;

	struct SL_component link;

} __attribute__ ((packed));



struct RR_NM_s {

	unsigned char flags;

	__u8 flags;

	char name[0];

} __attribute__ ((packed));



struct RR_CL_s {

	char location[8];

	__u8 location[8];

};



struct RR_PL_s {

	char location[8];

	__u8 location[8];

};



struct stamp {

	char time[7];

	__u8 time[7];		/* actually 6 unsigned, 1 signed */

} __attribute__ ((packed));



struct RR_TF_s {

	char flags;

	__u8 flags;

	struct stamp times[0];	/* Variable number of these beasts */

} __attribute__ ((packed));



/* Linux-specific extension for transparent decompression */

struct RR_ZF_s {

	char algorithm[2];

	char parms[2];

	char real_size[8];

	__u8 algorithm[2];

	__u8 parms[2];

	__u8 real_size[8];

};



/*
@@ -93,9 +93,9 @@ struct RR_ZF_s { 
#define TF_LONG_FORM 128



struct rock_ridge {

	char signature[2];

	unsigned char len;

	unsigned char version;

	__u8 signature[2];

	__u8 len;

	__u8 version;

	union {

		struct SU_SP_s SP;

		struct SU_CE_s CE;

fs/isofs/util.c

+1 −1
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ 
 * to GMT.  Thus  we should always be correct.

 */



int iso_date(char * p, int flag)

int iso_date(u8 *p, int flag)

{

	int year, month, day, hour, minute, second, tz;

	int crtime;