Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw (33f1de69) · Commits · 戴 / test

Documentation/filesystems/gfs2-uevents.txt

0 → 100644

+100 −0

Original line number	Diff line number	Diff line
		uevents and GFS2
		==================

		During the lifetime of a GFS2 mount, a number of uevents are generated.
		This document explains what the events are and what they are used
		for (by gfs_controld in gfs2-utils).

		A list of GFS2 uevents
		-----------------------

		1. ADD

		The ADD event occurs at mount time. It will always be the first
		uevent generated by the newly created filesystem. If the mount
		is successful, an ONLINE uevent will follow. If it is not successful
		then a REMOVE uevent will follow.

		The ADD uevent has two environment variables: SPECTATOR=[0\|1]
		and RDONLY=[0\|1] that specify the spectator status (a read-only mount
		with no journal assigned), and read-only (with journal assigned) status
		of the filesystem respectively.

		2. ONLINE

		The ONLINE uevent is generated after a successful mount or remount. It
		has the same environment variables as the ADD uevent. The ONLINE
		uevent, along with the two environment variables for spectator and
		RDONLY are a relatively recent addition (2.6.32-rc+) and will not
		be generated by older kernels.

		3. CHANGE

		The CHANGE uevent is used in two places. One is when reporting the
		successful mount of the filesystem by the first node (FIRSTMOUNT=Done).
		This is used as a signal by gfs_controld that it is then ok for other
		nodes in the cluster to mount the filesystem.

		The other CHANGE uevent is used to inform of the completion
		of journal recovery for one of the filesystems journals. It has
		two environment variables, JID= which specifies the journal id which
		has just been recovered, and RECOVERY=[Done\|Failed] to indicate the
		success (or otherwise) of the operation. These uevents are generated
		for every journal recovered, whether it is during the initial mount
		process or as the result of gfs_controld requesting a specific journal
		recovery via the /sys/fs/gfs2/<fsname>/lock_module/recovery file.

		Because the CHANGE uevent was used (in early versions of gfs_controld)
		without checking the environment variables to discover the state, we
		cannot add any more functions to it without running the risk of
		someone using an older version of the user tools and breaking their
		cluster. For this reason the ONLINE uevent was used when adding a new
		uevent for a successful mount or remount.

		4. OFFLINE

		The OFFLINE uevent is only generated due to filesystem errors and is used
		as part of the "withdraw" mechanism. Currently this doesn't give any
		information about what the error is, which is something that needs to
		be fixed.

		5. REMOVE

		The REMOVE uevent is generated at the end of an unsuccessful mount
		or at the end of a umount of the filesystem. All REMOVE uevents will
		have been preceeded by at least an ADD uevent for the same fileystem,
		and unlike the other uevents is generated automatically by the kernel's
		kobject subsystem.


		Information common to all GFS2 uevents (uevent environment variables)
		----------------------------------------------------------------------

		1. LOCKTABLE=

		The LOCKTABLE is a string, as supplied on the mount command
		line (locktable=) or via fstab. It is used as a filesystem label
		as well as providing the information for a lock_dlm mount to be
		able to join the cluster.

		2. LOCKPROTO=

		The LOCKPROTO is a string, and its value depends on what is set
		on the mount command line, or via fstab. It will be either
		lock_nolock or lock_dlm. In the future other lock managers
		may be supported.

		3. JOURNALID=

		If a journal is in use by the filesystem (journals are not
		assigned for spectator mounts) then this will give the
		numeric journal id in all GFS2 uevents.

		4. UUID=

		With recent versions of gfs2-utils, mkfs.gfs2 writes a UUID
		into the filesystem superblock. If it exists, this will
		be included in every uevent relating to the filesystem.

fs/gfs2/Makefile

+1 −1

Original line number	Diff line number	Diff line
		EXTRA_CFLAGS := -I$(src)
		obj-$(CONFIG_GFS2_FS) += gfs2.o
		gfs2-y := acl.o bmap.o dir.o eaops.o eattr.o glock.o \
		gfs2-y := acl.o bmap.o dir.o xattr.o glock.o \
		glops.o inode.o log.o lops.o main.o meta_io.o \
		aops.o dentry.o export.o file.o \
		ops_fstype.o ops_inode.o quota.o \

fs/gfs2/acl.c

+46 −60

Original line number	Diff line number	Diff line
		@@ -19,8 +19,7 @@
		#include "gfs2.h"
		#include "incore.h"
		#include "acl.h"
		#include "eaops.h"
		#include "eattr.h"
		#include "xattr.h"
		#include "glock.h"
		#include "inode.h"
		#include "meta_io.h"
		@@ -31,8 +30,7 @@
		#define ACL_DEFAULT 0

		int gfs2_acl_validate_set(struct gfs2_inode *ip, int access,
		struct gfs2_ea_request *er,
		int remove, mode_t mode)
		struct gfs2_ea_request er, int remove, mode_t *mode)
		{
		struct posix_acl *acl;
		int error;
		@@ -83,30 +81,20 @@ int gfs2_acl_validate_remove(struct gfs2_inode *ip, int access)
		return 0;
		}

		static int acl_get(struct gfs2_inode ip, int access, struct posix_acl *acl,
		struct gfs2_ea_location el, char data, unsigned int len)
		static int acl_get(struct gfs2_inode ip, const char name,
		struct posix_acl *acl, struct gfs2_ea_location el,
		char *datap, unsigned int lenp)
		{
		struct gfs2_ea_request er;
		struct gfs2_ea_location el_this;
		char *data;
		unsigned int len;
		int error;

		el->el_bh = NULL;

		if (!ip->i_eattr)
		return 0;

		memset(&er, 0, sizeof(struct gfs2_ea_request));
		if (access) {
		er.er_name = GFS2_POSIX_ACL_ACCESS;
		er.er_name_len = GFS2_POSIX_ACL_ACCESS_LEN;
		} else {
		er.er_name = GFS2_POSIX_ACL_DEFAULT;
		er.er_name_len = GFS2_POSIX_ACL_DEFAULT_LEN;
		}
		er.er_type = GFS2_EATYPE_SYS;

		if (!el)
		el = &el_this;

		error = gfs2_ea_find(ip, &er, el);
		error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, name, el);
		if (error)
		return error;
		if (!el->el_ea)
		@@ -114,32 +102,31 @@ static int acl_get(struct gfs2_inode ip, int access, struct posix_acl *acl,
		if (!GFS2_EA_DATA_LEN(el->el_ea))
		goto out;

		er.er_data_len = GFS2_EA_DATA_LEN(el->el_ea);
		er.er_data = kmalloc(er.er_data_len, GFP_NOFS);
		len = GFS2_EA_DATA_LEN(el->el_ea);
		data = kmalloc(len, GFP_NOFS);
		error = -ENOMEM;
		if (!er.er_data)
		if (!data)
		goto out;

		error = gfs2_ea_get_copy(ip, el, er.er_data);
		if (error)
		error = gfs2_ea_get_copy(ip, el, data, len);
		if (error < 0)
		goto out_kfree;
		error = 0;

		if (acl) {
		*acl = posix_acl_from_xattr(er.er_data, er.er_data_len);
		*acl = posix_acl_from_xattr(data, len);
		if (IS_ERR(*acl))
		error = PTR_ERR(*acl);
		}

		out_kfree:
		if (error \|\| !data)
		kfree(er.er_data);
		else {
		*data = er.er_data;
		*len = er.er_data_len;
		if (error \|\| !datap) {
		kfree(data);
		} else {
		*datap = data;
		*lenp = len;
		}
		out:
		if (error \|\| el == &el_this)
		brelse(el->el_bh);
		return error;
		}

		@@ -153,10 +140,12 @@ out:

		int gfs2_check_acl(struct inode *inode, int mask)
		{
		struct gfs2_ea_location el;
		struct posix_acl *acl = NULL;
		int error;

		error = acl_get(GFS2_I(inode), ACL_ACCESS, &acl, NULL, NULL, NULL);
		error = acl_get(GFS2_I(inode), GFS2_POSIX_ACL_ACCESS, &acl, &el, NULL, NULL);
		brelse(el.el_bh);
		if (error)
		return error;

		@@ -196,10 +185,12 @@ static int munge_mode(struct gfs2_inode *ip, mode_t mode)

		int gfs2_acl_create(struct gfs2_inode dip, struct gfs2_inode ip)
		{
		struct gfs2_ea_location el;
		struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
		struct posix_acl acl = NULL, clone;
		struct gfs2_ea_request er;
		mode_t mode = ip->i_inode.i_mode;
		char *data = NULL;
		unsigned int len;
		int error;

		if (!sdp->sd_args.ar_posix_acl)
		@@ -207,11 +198,8 @@ int gfs2_acl_create(struct gfs2_inode dip, struct gfs2_inode ip)
		if (S_ISLNK(ip->i_inode.i_mode))
		return 0;

		memset(&er, 0, sizeof(struct gfs2_ea_request));
		er.er_type = GFS2_EATYPE_SYS;

		error = acl_get(dip, ACL_DEFAULT, &acl, NULL,
		&er.er_data, &er.er_data_len);
		error = acl_get(dip, GFS2_POSIX_ACL_DEFAULT, &acl, &el, &data, &len);
		brelse(el.el_bh);
		if (error)
		return error;
		if (!acl) {
		@@ -229,9 +217,8 @@ int gfs2_acl_create(struct gfs2_inode dip, struct gfs2_inode ip)
		acl = clone;

		if (S_ISDIR(ip->i_inode.i_mode)) {
		er.er_name = GFS2_POSIX_ACL_DEFAULT;
		er.er_name_len = GFS2_POSIX_ACL_DEFAULT_LEN;
		error = gfs2_system_eaops.eo_set(ip, &er);
		error = gfs2_xattr_set(&ip->i_inode, GFS2_EATYPE_SYS,
		GFS2_POSIX_ACL_DEFAULT, data, len, 0);
		if (error)
		goto out;
		}
		@@ -239,21 +226,19 @@ int gfs2_acl_create(struct gfs2_inode dip, struct gfs2_inode ip)
		error = posix_acl_create_masq(acl, &mode);
		if (error < 0)
		goto out;
		if (error > 0) {
		er.er_name = GFS2_POSIX_ACL_ACCESS;
		er.er_name_len = GFS2_POSIX_ACL_ACCESS_LEN;
		posix_acl_to_xattr(acl, er.er_data, er.er_data_len);
		er.er_mode = mode;
		er.er_flags = GFS2_ERF_MODE;
		error = gfs2_system_eaops.eo_set(ip, &er);
		if (error == 0)
		goto munge;

		posix_acl_to_xattr(acl, data, len);
		error = gfs2_xattr_set(&ip->i_inode, GFS2_EATYPE_SYS,
		GFS2_POSIX_ACL_ACCESS, data, len, 0);
		if (error)
		goto out;
		} else
		munge_mode(ip, mode);

		munge:
		error = munge_mode(ip, mode);
		out:
		posix_acl_release(acl);
		kfree(er.er_data);
		kfree(data);
		return error;
		}

		@@ -265,9 +250,9 @@ int gfs2_acl_chmod(struct gfs2_inode ip, struct iattr attr)
		unsigned int len;
		int error;

		error = acl_get(ip, ACL_ACCESS, &acl, &el, &data, &len);
		error = acl_get(ip, GFS2_POSIX_ACL_ACCESS, &acl, &el, &data, &len);
		if (error)
		return error;
		goto out_brelse;
		if (!acl)
		return gfs2_setattr_simple(ip, attr);

		@@ -286,8 +271,9 @@ int gfs2_acl_chmod(struct gfs2_inode ip, struct iattr attr)

		out:
		posix_acl_release(acl);
		brelse(el.el_bh);
		kfree(data);
		out_brelse:
		brelse(el.el_bh);
		return error;
		}

fs/gfs2/dentry.c

+18 −0

Original line number	Diff line number	Diff line
		@@ -107,8 +107,26 @@ static int gfs2_dhash(struct dentry dentry, struct qstr str)
		return 0;
		}

		static int gfs2_dentry_delete(struct dentry *dentry)
		{
		struct gfs2_inode *ginode;

		if (!dentry->d_inode)
		return 0;

		ginode = GFS2_I(dentry->d_inode);
		if (!ginode->i_iopen_gh.gh_gl)
		return 0;

		if (test_bit(GLF_DEMOTE, &ginode->i_iopen_gh.gh_gl->gl_flags))
		return 1;

		return 0;
		}

		const struct dentry_operations gfs2_dops = {
		.d_revalidate = gfs2_drevalidate,
		.d_hash = gfs2_dhash,
		.d_delete = gfs2_dentry_delete,
		};

fs/gfs2/eaops.c

deleted100644 → 0

+0 −157

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
		* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
		*
		* This copyrighted material is made available to anyone wishing to use,
		* modify, copy, or redistribute it subject to the terms and conditions
		* of the GNU General Public License version 2.
		*/

		#include <linux/slab.h>
		#include <linux/spinlock.h>
		#include <linux/completion.h>
		#include <linux/buffer_head.h>
		#include <linux/capability.h>
		#include <linux/xattr.h>
		#include <linux/gfs2_ondisk.h>
		#include <asm/uaccess.h>

		#include "gfs2.h"
		#include "incore.h"
		#include "acl.h"
		#include "eaops.h"
		#include "eattr.h"
		#include "util.h"

		/**
		* gfs2_ea_name2type - get the type of the ea, and truncate type from the name
		* @namep: ea name, possibly with type appended
		*
		* Returns: GFS2_EATYPE_XXX
		*/

		unsigned int gfs2_ea_name2type(const char name, const char *truncated_name)
		{
		unsigned int type;

		if (strncmp(name, "system.", 7) == 0) {
		type = GFS2_EATYPE_SYS;
		if (truncated_name)
		*truncated_name = name + sizeof("system.") - 1;
		} else if (strncmp(name, "user.", 5) == 0) {
		type = GFS2_EATYPE_USR;
		if (truncated_name)
		*truncated_name = name + sizeof("user.") - 1;
		} else if (strncmp(name, "security.", 9) == 0) {
		type = GFS2_EATYPE_SECURITY;
		if (truncated_name)
		*truncated_name = name + sizeof("security.") - 1;
		} else {
		type = GFS2_EATYPE_UNUSED;
		if (truncated_name)
		*truncated_name = NULL;
		}

		return type;
		}

		static int system_eo_get(struct gfs2_inode ip, struct gfs2_ea_request er)
		{
		if (!GFS2_ACL_IS_ACCESS(er->er_name, er->er_name_len) &&
		!GFS2_ACL_IS_DEFAULT(er->er_name, er->er_name_len) &&
		!capable(CAP_SYS_ADMIN))
		return -EPERM;

		if (GFS2_SB(&ip->i_inode)->sd_args.ar_posix_acl == 0 &&
		(GFS2_ACL_IS_ACCESS(er->er_name, er->er_name_len) \|\|
		GFS2_ACL_IS_DEFAULT(er->er_name, er->er_name_len)))
		return -EOPNOTSUPP;

		return gfs2_ea_get_i(ip, er);
		}

		static int system_eo_set(struct gfs2_inode ip, struct gfs2_ea_request er)
		{
		int remove = 0;
		int error;

		if (GFS2_ACL_IS_ACCESS(er->er_name, er->er_name_len)) {
		if (!(er->er_flags & GFS2_ERF_MODE)) {
		er->er_mode = ip->i_inode.i_mode;
		er->er_flags \|= GFS2_ERF_MODE;
		}
		error = gfs2_acl_validate_set(ip, 1, er,
		&remove, &er->er_mode);
		if (error)
		return error;
		error = gfs2_ea_set_i(ip, er);
		if (error)
		return error;
		if (remove)
		gfs2_ea_remove_i(ip, er);
		return 0;

		} else if (GFS2_ACL_IS_DEFAULT(er->er_name, er->er_name_len)) {
		error = gfs2_acl_validate_set(ip, 0, er,
		&remove, NULL);
		if (error)
		return error;
		if (!remove)
		error = gfs2_ea_set_i(ip, er);
		else {
		error = gfs2_ea_remove_i(ip, er);
		if (error == -ENODATA)
		error = 0;
		}
		return error;
		}

		return -EPERM;
		}

		static int system_eo_remove(struct gfs2_inode ip, struct gfs2_ea_request er)
		{
		if (GFS2_ACL_IS_ACCESS(er->er_name, er->er_name_len)) {
		int error = gfs2_acl_validate_remove(ip, 1);
		if (error)
		return error;

		} else if (GFS2_ACL_IS_DEFAULT(er->er_name, er->er_name_len)) {
		int error = gfs2_acl_validate_remove(ip, 0);
		if (error)
		return error;

		} else
		return -EPERM;

		return gfs2_ea_remove_i(ip, er);
		}

		static const struct gfs2_eattr_operations gfs2_user_eaops = {
		.eo_get = gfs2_ea_get_i,
		.eo_set = gfs2_ea_set_i,
		.eo_remove = gfs2_ea_remove_i,
		.eo_name = "user",
		};

		const struct gfs2_eattr_operations gfs2_system_eaops = {
		.eo_get = system_eo_get,
		.eo_set = system_eo_set,
		.eo_remove = system_eo_remove,
		.eo_name = "system",
		};

		static const struct gfs2_eattr_operations gfs2_security_eaops = {
		.eo_get = gfs2_ea_get_i,
		.eo_set = gfs2_ea_set_i,
		.eo_remove = gfs2_ea_remove_i,
		.eo_name = "security",
		};

		const struct gfs2_eattr_operations *gfs2_ea_ops[] = {
		NULL,
		&gfs2_user_eaops,
		&gfs2_system_eaops,
		&gfs2_security_eaops,
		};

Admin message