selinux: rewrite selinux_sb_eat_lsm_opts()

	superblock_free_security(sb);

	superblock_free_security(sb);

}

}

static inline int match_prefix(char *prefix, int plen, char *option, int olen)

static inline int opt_len(const char *s)

{

{

	if (plen > olen)

	bool open_quote = false;

		return 0;

	int len;

	char c;

	return !memcmp(prefix, option, plen);

	for (len = 0; (c = s[len]) != '\0'; len++) {

		if (c == '"')

			open_quote = !open_quote;

		if (c == ',' && !open_quote)

			break;

	}

	}

	return len;

static inline int selinux_option(char *option, int len)

{

	return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) ||

		match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) ||

		match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) ||

		match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) ||

		match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len));

}

}

static inline void take_option(char **to, char *from, int *first, int len)

static int selinux_sb_eat_lsm_opts(char *options, void **mnt_opts)

{

{

	if (!*first) {

	char *from = options;

		**to = ',';

	char *to = options;

		*to += 1;

	bool first = true;

	} else

		*first = 0;

	memcpy(*to, from, len);

	*to += len;

}

static inline void take_selinux_option(char **to, char *from, int *first,

	while (1) {

				       int len)

		int len = opt_len(from);

{

		int token, rc;

	int current_size = 0;

		char *arg = NULL;

	if (!*first) {

		token = match_opt_prefix(from, len, &arg);

		**to = '|';

		*to += 1;

		if (token != Opt_error) {

	} else

			char *p, *q;

		*first = 0;

	while (current_size < len) {

			/* strip quotes */

		if (*from != '"') {

			if (arg) {

			**to = *from;

				for (p = q = arg; p < from + len; p++) {

			*to += 1;

					char c = *p;

					if (c != '"')

						*q++ = c;

				}

				}

		from += 1;

				arg = kmemdup_nul(arg, q - arg, GFP_KERNEL);

		current_size += 1;

			}

			}

			rc = selinux_add_opt(token, arg, mnt_opts);

			if (unlikely(rc)) {

				kfree(arg);

				if (*mnt_opts) {

					selinux_free_mnt_opts(*mnt_opts);

					*mnt_opts = NULL;

				}

				}

				return rc;

static int selinux_sb_copy_data(char *orig, char *copy)

{

	int fnosec, fsec, rc = 0;

	char *in_save, *in_curr, *in_end;

	char *sec_curr, *nosec_save, *nosec;

	int open_quote = 0;

	in_curr = orig;

	sec_curr = copy;

	nosec = (char *)get_zeroed_page(GFP_KERNEL);

	if (!nosec) {

		rc = -ENOMEM;

		goto out;

			}

			}

		} else {

	nosec_save = nosec;

			if (!first) {	// copy with preceding comma

	fnosec = fsec = 1;

				from--;

	in_save = in_end = orig;

				len++;

	do {

		if (*in_end == '"')

			open_quote = !open_quote;

		if ((*in_end == ',' && open_quote == 0) ||

				*in_end == '\0') {

			int len = in_end - in_curr;

			if (selinux_option(in_curr, len))

				take_selinux_option(&sec_curr, in_curr, &fsec, len);

			else

				take_option(&nosec, in_curr, &fnosec, len);

			in_curr = in_end + 1;

			}

			}

	} while (*in_end++);

			if (to != from)

				memmove(to, from, len);

	strcpy(in_save, nosec_save);

			to += len;

	free_page((unsigned long)nosec_save);

			first = false;

out:

	return rc;

		}

		}

		if (!from[len])

static int selinux_sb_eat_lsm_opts(char *options, void **mnt_opts)

			break;

{

		from += len + 1;

	char *s = (char *)get_zeroed_page(GFP_KERNEL);

	}

	int err;

	*to = '\0';

	return 0;

	if (!s)

		return -ENOMEM;

	err = selinux_sb_copy_data(options, s);

	if (!err)

		err = selinux_parse_opts_str(s, mnt_opts);

	free_page((unsigned long)s);

	return err;

}

}

static int selinux_sb_remount(struct super_block *sb, void *mnt_opts)

static int selinux_sb_remount(struct super_block *sb, void *mnt_opts)