[Ocfs2-commits] jlbec commits r2087 - in trunk/fs: configfs ocfs2/cluster

svn-commits at oss.oracle.com svn-commits at oss.oracle.com
Wed Mar 30 15:08:41 CST 2005


Author: jlbec
Signed-off-by: manish
Date: 2005-03-30 15:08:40 -0600 (Wed, 30 Mar 2005)
New Revision: 2087

Modified:
   trunk/fs/configfs/bobtest.c
   trunk/fs/configfs/configfs.h
   trunk/fs/configfs/dir.c
   trunk/fs/configfs/item.c
   trunk/fs/configfs/mount.c
   trunk/fs/ocfs2/cluster/heartbeat.c
   trunk/fs/ocfs2/cluster/heartbeat.h
   trunk/fs/ocfs2/cluster/nodemanager.c
Log:

o Rename struct uset to struct config_group.

Signed-off-by: manish



Modified: trunk/fs/configfs/bobtest.c
===================================================================
--- trunk/fs/configfs/bobtest.c	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/configfs/bobtest.c	2005-03-30 21:08:40 UTC (rev 2087)
@@ -35,7 +35,7 @@
  * Bobs - default_set as part of subsystem.
  */
 struct robert {
-	struct uset uset;
+	struct config_group group;
 };
 
 struct robert_attribute {
@@ -46,7 +46,7 @@
 static inline struct robert *to_robert(struct config_item *item)
 {
 	return item ?
-		container_of(to_uset(item), struct robert, uset) :
+		container_of(to_config_group(item), struct robert, group) :
 		NULL;
 }
 
@@ -101,7 +101,7 @@
 };
 
 static struct robert robert = {
-	.uset = {
+	.group = {
 		.item = {
 			.name = "robert",
 			.ktype = &uktype_robert,
@@ -233,10 +233,10 @@
 	ssize_t (*show)(struct bobset *, char *);
 };
 
-static inline struct bobset *to_bobset(struct uset *uset)
+static inline struct bobset *to_bobset(struct config_group *group)
 {
-	return uset ?
-		container_of(to_configfs_subsystem(uset), struct bobset, subsys) :
+	return group ?
+		container_of(to_configfs_subsystem(group), struct bobset, subsys) :
 		NULL;
 }
 
@@ -244,7 +244,7 @@
 			       struct configfs_attribute *attr,
 			       char *page)
 {
-	struct bobset *bobset = to_bobset(to_uset(item));
+	struct bobset *bobset = to_bobset(to_config_group(item));
 	struct bobset_attribute *bobset_attr =
 		container_of(attr, struct bobset_attribute, attr);
 	ssize_t ret = 0;
@@ -270,14 +270,14 @@
 	NULL,
 };
 
-static struct uset *bobset_sets[] = {
-	&robert.uset,
+static struct config_group *bobset_sets[] = {
+	&robert.group,
 	NULL,
 };
 
-static struct config_item *make_bob(struct uset *uset, const char *name)
+static struct config_item *make_bob(struct config_group *group, const char *name)
 {
-	struct bobset *bobset = to_bobset(uset);
+	struct bobset *bobset = to_bobset(group);
 	struct bob *bob;
 
 	bob = kmalloc(sizeof(struct bob), GFP_KERNEL);
@@ -297,9 +297,9 @@
 	return &bob->item;
 }
 
-static void drop_bob(struct uset *uset, struct config_item *item)
+static void drop_bob(struct config_group *group, struct config_item *item)
 {
-	struct bobset *bobset = to_bobset(uset);
+	struct bobset *bobset = to_bobset(group);
 
 	bobset->n_bobs--;
 	config_item_put(item);
@@ -309,25 +309,25 @@
 	.show_attribute	= bobset_attr_show,
 };
 
-static struct configfs_set_operations bobset_set_ops = {
+static struct configfs_group_operations bobset_group_ops = {
 	.make_item	= make_bob,
 	.drop_item	= drop_bob,
 };
 
 static struct config_item_type uktype_bobset = {
 	.item_ops	= &bobset_item_ops,
-	.set_ops	= &bobset_set_ops,
+	.group_ops	= &bobset_group_ops,
 	.attrs		= bobset_attrs,
 };
 
 static struct bobset bobset = {
 	.subsys = {
-		.su_set = {
+		.su_group = {
 			.item = {
 				.name = "bobset",
 				.ktype = &uktype_bobset,
 			},
-			.default_sets = bobset_sets,
+			.default_groups = bobset_sets,
 		},
 	},
 	.n_bobs = 0,
@@ -337,7 +337,7 @@
  * Toms - default_set as part of a created set.
  */
 struct jerry {
-	struct uset uset;
+	struct config_group group;
 	int showme;
 	int storeme;
 };
@@ -351,7 +351,7 @@
 static inline struct jerry *to_jerry(struct config_item *item)
 {
 	return item ?
-		container_of(to_uset(item), struct jerry, uset) :
+		container_of(to_config_group(item), struct jerry, group) :
 		NULL;
 }
 
@@ -461,7 +461,7 @@
 };
 
 struct tom {
-	struct uset uset;
+	struct config_group group;
 	int showme;
 	int storeme;
 };
@@ -475,7 +475,7 @@
 static inline struct tom *to_tom(struct config_item *item)
 {
 	return item ?
-		container_of(to_uset(item), struct tom, uset) :
+		container_of(to_config_group(item), struct tom, group) :
 			NULL;
 }
 
@@ -561,7 +561,7 @@
 	struct tom *tom = to_tom(item);
 
 	printk("Oooh, that's gonna leave a mark!\n");
-	kfree(tom->uset.default_sets);
+	kfree(tom->group.default_groups);
 	kfree(tom);
 }
 
@@ -588,10 +588,10 @@
 	ssize_t (*show)(struct tomset *, char *);
 };
 
-static inline struct tomset *to_tomset(struct uset *uset)
+static inline struct tomset *to_tomset(struct config_group *group)
 {
-	return uset ?
-		container_of(to_configfs_subsystem(uset), struct tomset, subsys) :
+	return group ?
+		container_of(to_configfs_subsystem(group), struct tomset, subsys) :
 		NULL;
 }
 
@@ -599,7 +599,7 @@
 			       struct configfs_attribute *attr,
 			       char *page)
 {
-	struct tomset *tomset = to_tomset(to_uset(item));
+	struct tomset *tomset = to_tomset(to_config_group(item));
 	struct tomset_attribute *tomset_attr =
 		container_of(attr, struct tomset_attribute, attr);
 	ssize_t ret = 0;
@@ -625,9 +625,9 @@
 	NULL,
 };
 
-static struct uset *make_tom(struct uset *uset, const char *name)
+static struct config_group *make_tom(struct config_group *group, const char *name)
 {
-	struct tomset *tomset = to_tomset(uset);
+	struct tomset *tomset = to_tomset(group);
 	struct tom *tom;
 	struct jerry *jerry;
 
@@ -636,46 +636,46 @@
 		return NULL;
 
 	memset(tom, 0, sizeof(struct tom));
-	tom->uset.default_sets = kmalloc(sizeof(struct uset *) * 2,
+	tom->group.default_groups = kmalloc(sizeof(struct config_group *) * 2,
 		       			  GFP_KERNEL);
-	if (!tom->uset.default_sets) {
+	if (!tom->group.default_groups) {
 		kfree(tom);
 		return NULL;
 	}
 
 	jerry = kmalloc(sizeof(struct jerry), GFP_KERNEL);
 	if (!jerry) {
-		kfree(tom->uset.default_sets);
+		kfree(tom->group.default_groups);
 		kfree(tom);
 		return NULL;
 	}
 
 	memset(jerry, 0, sizeof(struct jerry));
 
-	config_item_set_name(&tom->uset.item, name);
-	tom->uset.item.ktype = &uktype_tom;
-	uset_init(&tom->uset);
+	config_item_set_name(&tom->group.item, name);
+	tom->group.item.ktype = &uktype_tom;
+	config_group_init(&tom->group);
 
 	tom->showme = 0;
 	tom->storeme = 0;
 	tomset->n_toms++;
 
-	config_item_set_name(&jerry->uset.item, "jer");
-	jerry->uset.item.ktype = &uktype_jerry;
-	uset_init(&jerry->uset);
+	config_item_set_name(&jerry->group.item, "jer");
+	jerry->group.item.ktype = &uktype_jerry;
+	config_group_init(&jerry->group);
 
-	tom->uset.default_sets[0] = &jerry->uset;
-	tom->uset.default_sets[1] = NULL;
+	tom->group.default_groups[0] = &jerry->group;
+	tom->group.default_groups[1] = NULL;
 
-	return &tom->uset;
+	return &tom->group;
 }
 
-static void drop_tom(struct uset *uset, struct config_item *item)
+static void drop_tom(struct config_group *group, struct config_item *item)
 {
-	struct tomset *tomset = to_tomset(uset);
+	struct tomset *tomset = to_tomset(group);
 	struct tom *tom = to_tom(item);
 
-	config_item_put(&tom->uset.default_sets[0]->item);
+	config_item_put(&tom->group.default_groups[0]->item);
 
 	tomset->n_toms--;
 	config_item_put(item);
@@ -685,20 +685,20 @@
 	.show_attribute	= tomset_attr_show,
 };
 
-static struct configfs_set_operations tomset_set_ops = {
-	.make_set	= make_tom,
+static struct configfs_group_operations tomset_group_ops = {
+	.make_group	= make_tom,
 	.drop_item	= drop_tom,
 };
 
 static struct config_item_type uktype_tomset = {
 	.item_ops	= &tomset_item_ops,
-	.set_ops	= &tomset_set_ops,
+	.group_ops	= &tomset_group_ops,
 	.attrs		= tomset_attrs,
 };
 
 static struct tomset tomset = {
 	.subsys = {
-		.su_set = {
+		.su_group = {
 			.item = {
 				.name = "tomset",
 				.ktype = &uktype_tomset,
@@ -712,10 +712,10 @@
 {
 	int ret;
 
-	uset_init(&bobset.subsys.su_set);
+	config_group_init(&bobset.subsys.su_group);
 	init_MUTEX(&bobset.subsys.su_sem);
-	uset_init(&robert.uset);
-	uset_init(&tomset.subsys.su_set);
+	config_group_init(&robert.group);
+	config_group_init(&tomset.subsys.su_group);
 	init_MUTEX(&tomset.subsys.su_sem);
 	ret = configfs_register_subsystem(&bobset.subsys);
 	if (!ret)

Modified: trunk/fs/configfs/configfs.h
===================================================================
--- trunk/fs/configfs/configfs.h	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/configfs/configfs.h	2005-03-30 21:08:40 UTC (rev 2087)
@@ -49,7 +49,7 @@
 struct module;
 
 struct configfs_item_operations;
-struct configfs_set_operations;
+struct configfs_group_operations;
 struct configfs_attribute;
 struct configfs_subsystem;
 
@@ -59,7 +59,7 @@
 	struct kref		kref;
 	struct list_head	entry;
 	struct config_item	*parent;
-	struct uset		*uset;
+	struct config_group	*group;
 	struct config_item_type	*ktype;
 	struct dentry		*dentry;
 };
@@ -80,45 +80,45 @@
 struct config_item_type {
 	struct module *owner;
 	struct configfs_item_operations	*item_ops;
-	struct configfs_set_operations		*set_ops;
+	struct configfs_group_operations		*group_ops;
 	struct configfs_attribute		**attrs;
 };
 
 
 /**
- *	uset - a set of config_items of a specific type, belonging
+ *	group - a group of config_items of a specific type, belonging
  *	to a specific subsystem.
  */
 
-struct uset {
+struct config_group {
 	struct config_item	item;
 	struct list_head	list;
 	struct configfs_subsystem *subsys;
-	struct uset		**default_sets;
+	struct config_group		**default_groups;
 };
 
 
-extern void uset_init(struct uset *set);
-extern void uset_init_type_name(struct uset *uset, const char *name,
+extern void config_group_init(struct config_group *group);
+extern void config_group_init_type_name(struct config_group *group, const char *name,
 				struct config_item_type *ktype);
 
 
-static inline struct uset *to_uset(struct config_item *item)
+static inline struct config_group *to_config_group(struct config_item *item)
 {
-	return item ? container_of(item,struct uset,item) : NULL;
+	return item ? container_of(item,struct config_group,item) : NULL;
 }
 
-static inline struct uset *uset_get(struct uset *set)
+static inline struct config_group *config_group_get(struct config_group *group)
 {
-	return set ? to_uset(config_item_get(&set->item)) : NULL;
+	return group ? to_config_group(config_item_get(&group->item)) : NULL;
 }
 
-static inline void uset_put(struct uset *set)
+static inline void config_group_put(struct config_group *group)
 {
-	config_item_put(&set->item);
+	config_item_put(&group->item);
 }
 
-extern struct config_item *uset_find_obj(struct uset *, const char *);
+extern struct config_item *config_group_find_obj(struct config_group *, const char *);
 
 
 struct configfs_attribute {
@@ -129,17 +129,17 @@
 
 
 /*
- * If allow_link() exists, the object can symlink(2) out to other
- * objects.  If the object is a uset, it may support mkdir(2).  Uset
- * objects supply one of make_set() and make_item().  If the
- * object supports make_set(), one can create uset children.  If it
+ * If allow_link() exists, the item can symlink(2) out to other
+ * items.  If the item is a group, it may support mkdir(2).  
+ * Groups supply one of make_group() and make_item().  If the
+ * group supports make_group(), one can create group children.  If it
  * supports make_item(), one can create config_item children.  If it has
- * default_sets on uset->default_sets, it has automatically created
- * uset children.  default_sets may coexist alongsize make_set() or
- * make_item(), but if the uset wishes to have only default_sets 
+ * default_groups on group->default_groups, it has automatically created
+ * group children.  default_groups may coexist alongsize make_group() or
+ * make_item(), but if the group wishes to have only default_groups 
  * children (disallowing mkdir(2)), it need not provide either function.
- * If the uset has commit(), it supports pending and commited (active)
- * objects.
+ * If the group has commit(), it supports pending and commited (active)
+ * items.
  */
 struct configfs_item_operations {
 	void (*release)(struct config_item *);
@@ -149,11 +149,11 @@
 	int (*drop_link)(struct config_item *src, struct config_item *target);
 };
 
-struct configfs_set_operations {
-	struct config_item *(*make_item)(struct uset *uset, const char *name);
-	struct uset *(*make_set)(struct uset *uset, const char *name);
+struct configfs_group_operations {
+	struct config_item *(*make_item)(struct config_group *group, const char *name);
+	struct config_group *(*make_group)(struct config_group *group, const char *name);
 	int (*commit_item)(struct config_item *item);
-	void (*drop_item)(struct uset *uset, struct config_item *item);
+	void (*drop_item)(struct config_group *group, struct config_item *item);
 };
 
 
@@ -180,14 +180,14 @@
 
 
 struct configfs_subsystem {
-	struct uset		su_set;
+	struct config_group		su_group;
 	struct semaphore	su_sem;
 };
 
-static inline struct configfs_subsystem *to_configfs_subsystem(struct uset *uset)
+static inline struct configfs_subsystem *to_configfs_subsystem(struct config_group *group)
 {
-	return uset ?
-		container_of(uset, struct configfs_subsystem, su_set) :
+	return group ?
+		container_of(group, struct configfs_subsystem, su_group) :
 		NULL;
 }
 

Modified: trunk/fs/configfs/dir.c
===================================================================
--- trunk/fs/configfs/dir.c	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/configfs/dir.c	2005-03-30 21:08:40 UTC (rev 2087)
@@ -53,7 +53,7 @@
 
 /*
  * We _must_ delete our dentries on last dput, as the chain-to-parent
- * behavior is required to clear the parents of default_sets.
+ * behavior is required to clear the parents of default_groups.
  */
 static int configfs_d_delete(struct dentry *dentry)
 {
@@ -292,7 +292,7 @@
  * Only subdirectories count here.  Files (CONFIGFS_NOT_PINNED) are
  * attributes and are removed by rmdir().  We recurse, taking i_sem
  * on all children that are candidates for default detach.  If the
- * result is clean, then configfs_detach_set() will handle dropping
+ * result is clean, then configfs_detach_group() will handle dropping
  * i_sem.  If there is an error, the caller will clean up the i_sem
  * holders via configfs_detach_rollback().
  */
@@ -398,14 +398,14 @@
 	return error;
 }
 
-static int configfs_attach_set(struct config_item *parent_item,
-			       struct config_item *item,
-			       struct dentry *dentry);
-static void configfs_detach_set(struct config_item *item);
+static int configfs_attach_group(struct config_item *parent_item,
+				 struct config_item *item,
+				 struct dentry *dentry);
+static void configfs_detach_group(struct config_item *item);
 
-static void detach_sets(struct uset *uset)
+static void detach_groups(struct config_group *group)
 {
-	struct dentry * dentry = dget(uset->item.dentry);
+	struct dentry * dentry = dget(group->item.dentry);
 	struct dentry *child;
 	struct configfs_dirent *parent_sd;
 	struct configfs_dirent *sd, *tmp;
@@ -421,7 +421,7 @@
 
 		child = sd->s_dentry;
 
-		configfs_detach_set(sd->s_element);
+		configfs_detach_group(sd->s_element);
 		child->d_inode->i_flags |= S_DEAD;
 		
 		/*
@@ -443,25 +443,25 @@
 }
 
 /*
- * This fakes mkdir(2) on a default_sets[] entry.  It
+ * This fakes mkdir(2) on a default_groups[] entry.  It
  * creates a dentry, attachs it, and then does fixup
  * on the sd->s_type.
  * 
  * We could, perhaps, tweak our parent's ->mkdir for a minute and
  * try using vfs_mkdir.  Just a thought.
  */
-static int create_default_set(struct uset *parent_uset,
-			      struct uset *uset)
+static int create_default_group(struct config_group *parent_group,
+				struct config_group *group)
 {
 	int ret;
 	struct qstr name;
 	struct configfs_dirent *sd;
 	/* We trust the caller holds a reference to parent */
-	struct dentry *child, *parent = parent_uset->item.dentry;
+	struct dentry *child, *parent = parent_group->item.dentry;
 
-	if (!uset->item.k_name)
-		uset->item.k_name = uset->item.name;
-	name.name = uset->item.k_name;
+	if (!group->item.k_name)
+		group->item.k_name = group->item.name;
+	name.name = group->item.k_name;
 	name.len = strlen(name.name);
 	name.hash = full_name_hash(name.name, name.len);
 
@@ -470,8 +470,8 @@
 	if (child) {
 		d_add(child, NULL);
 
-		ret = configfs_attach_set(&parent_uset->item,
-					  &uset->item, child);
+		ret = configfs_attach_group(&parent_group->item,
+					    &group->item, child);
 		if (!ret) {
 			sd = child->d_fsdata;
 			sd->s_type |= CONFIGFS_USET_DEFAULT;
@@ -484,14 +484,14 @@
 	return ret;
 }
 
-static int populate_sets(struct uset *uset)
+static int populate_groups(struct config_group *group)
 {
-	struct uset *new_set;
-	struct dentry *dentry = uset->item.dentry;
+	struct config_group *new_group;
+	struct dentry *dentry = group->item.dentry;
 	int ret = 0;
 	int i;
 
-	if (uset && uset->default_sets) {
+	if (group && group->default_groups) {
 		/* FYI, we're faking mkdir here
 		 * I'm not sure we need this semaphore, as we're called
 		 * from our parent's mkdir.  That holds our parent's
@@ -501,10 +501,10 @@
 		 * emulation, and shouldn't hurt. */
 		down(&dentry->d_inode->i_sem);
 
-		for (i = 0; uset->default_sets[i]; i++) {
-			new_set = uset->default_sets[i];
+		for (i = 0; group->default_groups[i]; i++) {
+			new_group = group->default_groups[i];
 
-			ret = create_default_set(uset, new_set);
+			ret = create_default_group(group, new_group);
 			if (ret)
 				break;
 		}
@@ -513,86 +513,86 @@
 	}
 
 	if (ret)
-		detach_sets(uset);
+		detach_groups(group);
 
 	return ret;
 }
 
 /*
- * All of link_obj/unlink_obj/link_set/unlink_set require that
+ * All of link_obj/unlink_obj/link_group/unlink_group require that
  * subsys->su_sem is held.
  */
 
 static void unlink_obj(struct config_item *item)
 {
-	struct uset *set;
+	struct config_group *group;
 
-	set = item->uset;
-	if (set) {
+	group = item->group;
+	if (group) {
 		list_del_init(&item->entry);
 
-		item->uset = NULL;
+		item->group = NULL;
 		item->parent = NULL;
 		config_item_put(item);
 
-		uset_put(set);
+		config_group_put(group);
 	}
 }
 
 static void link_obj(struct config_item *parent_item, struct config_item *item)
 {
-	/* Parent seems redundant with set, but it makes certain
+	/* Parent seems redundant with group, but it makes certain
 	 * traversals much nicer. */
 	item->parent = parent_item;
-	item->uset = uset_get(to_uset(parent_item));
-	list_add_tail(&item->entry, &item->uset->list);
+	item->group = config_group_get(to_config_group(parent_item));
+	list_add_tail(&item->entry, &item->group->list);
 
 	config_item_get(item);
 }
 
-static void unlink_set(struct uset *uset)
+static void unlink_group(struct config_group *group)
 {
 	int i;
-	struct uset *new_set;
+	struct config_group *new_group;
 
-	if (uset->default_sets) {
-		for (i = 0; uset->default_sets[i]; i++) {
-			new_set = uset->default_sets[i];
-			unlink_set(new_set);
+	if (group->default_groups) {
+		for (i = 0; group->default_groups[i]; i++) {
+			new_group = group->default_groups[i];
+			unlink_group(new_group);
 		}
 	}
 
-	uset->subsys = NULL;
-	unlink_obj(&uset->item);
+	group->subsys = NULL;
+	unlink_obj(&group->item);
 }
 
-static void link_set(struct uset *parent_uset, struct uset *uset)
+static void link_group(struct config_group *parent_group, struct config_group *group)
 {
 	int i;
-	struct uset *new_set;
+	struct config_group *new_group;
 	struct configfs_subsystem *subsys = NULL; /* gcc is a turd */
 
-	link_obj(&parent_uset->item, &uset->item);
+	link_obj(&parent_group->item, &group->item);
 
-	if (parent_uset->subsys)
-		subsys = parent_uset->subsys;
-	else if (configfs_is_root(&parent_uset->item))
-		subsys = to_configfs_subsystem(uset);
+	if (parent_group->subsys)
+		subsys = parent_group->subsys;
+	else if (configfs_is_root(&parent_group->item))
+		subsys = to_configfs_subsystem(group);
 	else
 		BUG();
-	uset->subsys = subsys;
+	group->subsys = subsys;
 
-	if (uset->default_sets) {
-		for (i = 0; uset->default_sets[i]; i++) {
-			new_set = uset->default_sets[i];
-			link_set(uset, new_set);
+	if (group->default_groups) {
+		for (i = 0; group->default_groups[i]; i++) {
+			new_group = group->default_groups[i];
+			link_group(group, new_group);
 		}
 	}
 }
 
 /*
  * The goal is that configfs_attach_item() (and
- * configfs_attach_set()) can be called from either the VFS or this
+ * configfs_attach_group()) can be called from either the VFS or this
  * module.  That is, they assume that the items have been created,
  * the dentry allocated, and the dcache is all ready to go.
  * 
@@ -600,7 +600,7 @@
  * had never been called.  The caller (VFS or local function) will
  * handle cleaning up the dcache bits.
  *
- * configfs_detach_set() and configfs_detach_item() behave similarly on
+ * configfs_detach_group() and configfs_detach_item() behave similarly on
  * the way out.  They assume that the proper semaphores are held, they
  * clean up the configfs items, and they expect their callers will
  * handle the dcache bits.
@@ -629,9 +629,9 @@
 	configfs_remove_dir(item);
 }
 
-static int configfs_attach_set(struct config_item *parent_item,
-			       struct config_item *item,
-			       struct dentry *dentry)
+static int configfs_attach_group(struct config_item *parent_item,
+				 struct config_item *item,
+				 struct dentry *dentry)
 {
 	int ret;
 	struct configfs_dirent *sd;
@@ -641,7 +641,7 @@
 		sd = dentry->d_fsdata;
 		sd->s_type |= CONFIGFS_USET_DIR;
 
-		ret = populate_sets(to_uset(item));
+		ret = populate_groups(to_config_group(item));
 		if (ret) {
 			configfs_detach_item(item);
 			d_delete(dentry);
@@ -651,14 +651,14 @@
 	return ret;
 }
 
-static void configfs_detach_set(struct config_item *item)
+static void configfs_detach_group(struct config_item *item)
 {
-	detach_sets(to_uset(item));
+	detach_groups(to_config_group(item));
 	configfs_detach_item(item);
 }
 
 /*
- * Drop the initial reference from make_item()/make_set()
+ * Drop the initial reference from make_item()/make_group()
  * This function assumes that reference is held on item
  * and that item holds a valid reference to the parent.  Also, it
  * assumes the caller has validated uktype.
@@ -671,8 +671,8 @@
 	uktype = parent_item->ktype;
 	BUG_ON(!uktype);
 
-	if (uktype->set_ops && uktype->set_ops->drop_item)
-		uktype->set_ops->drop_item(to_uset(parent_item),
+	if (uktype->group_ops && uktype->group_ops->drop_item)
+		uktype->group_ops->drop_item(to_config_group(parent_item),
 					     item);
 	else 
 		config_item_put(item);
@@ -682,7 +682,7 @@
 static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
 	int ret;
-	struct uset *uset;
+	struct config_group *group;
 	struct config_item *item;
 	struct config_item *parent_item;
 	struct configfs_subsystem *subsys;
@@ -700,12 +700,12 @@
 
 	parent_item = configfs_get_config_item(dentry->d_parent);
 	uktype = parent_item->ktype;
-	subsys = to_uset(parent_item)->subsys;
+	subsys = to_config_group(parent_item)->subsys;
 	BUG_ON(!subsys);
 
-	if (!uktype || !uktype->set_ops ||
-	    (!uktype->set_ops->make_set &&
-	     !uktype->set_ops->make_item)) {
+	if (!uktype || !uktype->group_ops ||
+	    (!uktype->group_ops->make_group &&
+	     !uktype->group_ops->make_item)) {
 		config_item_put(parent_item);
 		return -EPERM;  /* What lack-of-mkdir returns */
 	}
@@ -718,17 +718,17 @@
 	snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name);
 
 	down(&subsys->su_sem);
-	uset = NULL;
+	group = NULL;
 	item = NULL;
-	if (uktype->set_ops->make_set) {
-		uset = uktype->set_ops->make_set(to_uset(parent_item),
+	if (uktype->group_ops->make_group) {
+		group = uktype->group_ops->make_group(to_config_group(parent_item),
 						 name);
-		if (uset) {
-			link_set(to_uset(parent_item), uset);
-			item = &uset->item;
+		if (group) {
+			link_group(to_config_group(parent_item), group);
+			item = &group->item;
 		}
 	} else {
-		item = uktype->set_ops->make_item(to_uset(parent_item), name);
+		item = uktype->group_ops->make_item(to_config_group(parent_item), name);
 		if (item)
 			link_obj(parent_item, item);
 	}
@@ -745,10 +745,10 @@
 	if (uktype) {
 		owner = uktype->owner;
 		if (try_module_get(owner)) {
-			if (uset) {
-				ret = configfs_attach_set(parent_item,
-							  item,
-							  dentry);
+			if (group) {
+				ret = configfs_attach_group(parent_item,
+							    item,
+							    dentry);
 			} else {
 				ret = configfs_attach_item(parent_item,
 							   item,
@@ -757,8 +757,8 @@
 
 			if (ret) {
 				down(&subsys->su_sem);
-				if (uset)
-					unlink_set(uset);
+				if (group)
+					unlink_group(group);
 				else
 					unlink_obj(item);
 				client_drop_item(parent_item, item);
@@ -790,7 +790,7 @@
 		return -EPERM;
 
 	parent_item = configfs_get_config_item(dentry->d_parent);
-	subsys = to_uset(parent_item)->subsys;
+	subsys = to_config_group(parent_item)->subsys;
 	BUG_ON(!subsys);
 
 	if (!parent_item->ktype) {
@@ -814,10 +814,10 @@
 		owner = item->ktype->owner;
 
 	if (sd->s_type & CONFIGFS_USET_DIR) {
-		configfs_detach_set(item);
+		configfs_detach_group(item);
 
 		down(&subsys->su_sem);
-		unlink_set(to_uset(item));
+		unlink_group(to_config_group(item));
 	} else {
 		configfs_detach_item(item);
 
@@ -1036,7 +1036,7 @@
 int configfs_register_subsystem(struct configfs_subsystem *subsys)
 {
 	int err;
-	struct uset *set = &subsys->su_set;
+	struct config_group *group = &subsys->su_group;
 	struct qstr name;
 	struct dentry *dentry;
 	struct configfs_dirent *sd;
@@ -1045,15 +1045,15 @@
 	if (err)
 		return err;
 
-	if (!set->item.k_name)
-		set->item.k_name = set->item.name;
+	if (!group->item.k_name)
+		group->item.k_name = group->item.name;
 
 	sd = configfs_sb->s_root->d_fsdata;
-	link_set(to_uset(sd->s_element), set);
+	link_group(to_config_group(sd->s_element), group);
 
 	down(&configfs_sb->s_root->d_inode->i_sem);
 
-	name.name = set->item.k_name;
+	name.name = group->item.k_name;
 	name.len = strlen(name.name);
 	name.hash = full_name_hash(name.name, name.len);
 
@@ -1064,7 +1064,8 @@
 	
 	d_add(dentry, NULL);
 
-	err = configfs_attach_set(sd->s_element, &set->item, dentry);
+	err = configfs_attach_group(sd->s_element, &group->item,
+				    dentry);
 	if (!err)
 		dentry = NULL;
 	else
@@ -1075,7 +1076,7 @@
 	if (dentry) {
 	    dput(dentry);
 out_release:
-	    unlink_set(set);
+	    unlink_group(group);
 	    configfs_release_fs();
 	}
 
@@ -1084,8 +1085,8 @@
 
 void configfs_unregister_subsystem(struct configfs_subsystem *subsys)
 {
-	struct uset *set = &subsys->su_set;
-	struct dentry *dentry = set->item.dentry;
+	struct config_group *group = &subsys->su_group;
+	struct dentry *dentry = group->item.dentry;
 
 	if (dentry->d_parent != configfs_sb->s_root) {
 		printk(KERN_ERR "configfs: Tried to unregister non-subsystem!\n");
@@ -1097,7 +1098,7 @@
 	if (configfs_detach_prep(dentry)) {
 		printk(KERN_ERR "configfs: Tried to unregister non-empty subsystem!\n");
 	}
-	configfs_detach_set(&set->item);
+	configfs_detach_group(&group->item);
 	dentry->d_inode->i_flags |= S_DEAD;
 	up(&dentry->d_inode->i_sem);
 
@@ -1107,7 +1108,7 @@
 
 	dput(dentry);
 
-	unlink_set(set);
+	unlink_group(group);
 	configfs_release_fs();
 }
 

Modified: trunk/fs/configfs/item.c
===================================================================
--- trunk/fs/configfs/item.c	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/configfs/item.c	2005-03-30 21:08:40 UTC (rev 2087)
@@ -128,7 +128,7 @@
 void config_item_cleanup(struct config_item * item)
 {
 	struct config_item_type * t = item->ktype;
-	struct uset * s = item->uset;
+	struct config_group * s = item->group;
 	struct config_item * parent = item->parent;
 
 	pr_debug("config_item %s: cleaning up\n",config_item_name(item));
@@ -138,7 +138,7 @@
 	if (t && t->item_ops && t->item_ops->release)
 		t->item_ops->release(item);
 	if (s)
-		uset_put(s);
+		config_group_put(s);
 	if (parent)
 		config_item_put(parent);
 }
@@ -162,34 +162,34 @@
 
 
 /**
- *	uset_init - initialize a uset for use
- *	@k:	uset 
+ *	config_group_init - initialize a group for use
+ *	@k:	group 
  */
 
-void uset_init(struct uset *set)
+void config_group_init(struct config_group *group)
 {
-	config_item_init(&set->item);
-	INIT_LIST_HEAD(&set->list);
+	config_item_init(&group->item);
+	INIT_LIST_HEAD(&group->list);
 }
 
 
 /**
- *	uset_find_obj - search for item in uset.
- *	@uset:	uset we're looking in.
+ *	config_group_find_obj - search for item in group.
+ *	@group:	group we're looking in.
  *	@name:	item's name.
  *
- *	Lock uset via @uset->subsys, and iterate over @uset->list,
+ *	Lock group via @group->subsys, and iterate over @group->list,
  *	looking for a matching config_item. If matching item is found
  *	take a reference and return the item.
  */
 
-struct config_item * uset_find_obj(struct uset * uset, const char * name)
+struct config_item * config_group_find_obj(struct config_group * group, const char * name)
 {
 	struct list_head * entry;
 	struct config_item * ret = NULL;
 
         /* XXX LOCKING! */
-	list_for_each(entry,&uset->list) {
+	list_for_each(entry,&group->list) {
 		struct config_item * item = to_item(entry);
 		if (config_item_name(item) &&
                     !strcmp(config_item_name(item), name)) {
@@ -202,7 +202,7 @@
 
 
 EXPORT_SYMBOL(config_item_init);
-EXPORT_SYMBOL(uset_init);
+EXPORT_SYMBOL(config_group_init);
 EXPORT_SYMBOL(config_item_get);
 EXPORT_SYMBOL(config_item_put);
 

Modified: trunk/fs/configfs/mount.c
===================================================================
--- trunk/fs/configfs/mount.c	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/configfs/mount.c	2005-03-30 21:08:40 UTC (rev 2087)
@@ -51,33 +51,33 @@
 #endif
 };
 
-static struct uset configfs_root_set = {
+static struct config_group configfs_root_group = {
 	.item = {
 		.name	= "root",
-		.k_name	= configfs_root_set.item.name,
+		.k_name	= configfs_root_group.item.name,
 	},
 };
 
 int configfs_is_root(struct config_item *item)
 {
-	return item == &configfs_root_set.item;
+	return item == &configfs_root_group.item;
 }
 
 static struct configfs_dirent configfs_root = {
 	.s_sibling	= LIST_HEAD_INIT(configfs_root.s_sibling),
 	.s_children	= LIST_HEAD_INIT(configfs_root.s_children),
-	.s_element	= &configfs_root_set.item,
+	.s_element	= &configfs_root_group.item,
 	.s_type		= CONFIGFS_ROOT,
 };
 
-void uset_init_type_name(struct uset *uset, const char *name,
+void config_group_init_type_name(struct config_group *group, const char *name,
 			 struct config_item_type *ktype)
 {
-	config_item_set_name(&uset->item, name);
-	uset->item.ktype = ktype;
-	uset_init(uset);
+	config_item_set_name(&group->item, name);
+	group->item.ktype = ktype;
+	config_group_init(group);
 }
-EXPORT_SYMBOL(uset_init_type_name);
+EXPORT_SYMBOL(config_group_init_type_name);
 
 static int configfs_fill_super(struct super_block *sb, void *data, int silent)
 {
@@ -107,8 +107,8 @@
 		iput(inode);
 		return -ENOMEM;
 	}
-	uset_init(&configfs_root_set);
-	configfs_root_set.item.dentry = root;
+	config_group_init(&configfs_root_group);
+	configfs_root_group.item.dentry = root;
 	root->d_fsdata = &configfs_root;
 	sb->s_root = root;
 	return 0;

Modified: trunk/fs/ocfs2/cluster/heartbeat.c
===================================================================
--- trunk/fs/ocfs2/cluster/heartbeat.c	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/ocfs2/cluster/heartbeat.c	2005-03-30 21:08:40 UTC (rev 2087)
@@ -95,7 +95,7 @@
 
 #ifndef ENABLE_HBPRINTK
 #define hbprintk(x, arg...)    
-#define hbprintk0(x)           
+#define hbprintk0(x)
 #else
 #define hbprintk(x, arg...)    printk("(hb:%d) " x, current->pid, ##arg)
 #define hbprintk0(x)           printk("(hb:%d) " x, current->pid)
@@ -708,20 +708,20 @@
 
 /* heartbeat set */
 
-struct hb_heartbeat_set {
-	struct uset hs_uset;
+struct hb_heartbeat_group {
+	struct config_group hs_group;
 	/* some stuff? */
 };
 
-static struct hb_heartbeat_set *to_hb_heartbeat_set(struct uset *uset)
+static struct hb_heartbeat_group *to_hb_heartbeat_group(struct config_group *group)
 {
-	return uset ?
-		container_of(uset, struct hb_heartbeat_set, hs_uset)
+	return group ?
+		container_of(group, struct hb_heartbeat_group, hs_group)
 		: NULL;
 }
 
-static struct config_item *hb_heartbeat_set_make_item(struct uset *uset,
-                                                      const char *name)
+static struct config_item *hb_heartbeat_group_make_item(struct config_group *group,
+							const char *name)
 {
 	struct hb_region *reg = NULL;
 	struct config_item *ret = NULL;
@@ -746,8 +746,8 @@
 	return ret;
 }
 
-static void hb_heartbeat_set_drop_item(struct uset *uset,
-                                       struct config_item *item)
+static void hb_heartbeat_group_drop_item(struct config_group *group,
+					 struct config_item *item)
 {
 	struct hb_region *reg = to_hb_region(item);
 
@@ -765,40 +765,40 @@
 	config_item_put(item);
 }
 
-static struct configfs_set_operations hb_heartbeat_set_set_ops = {
-	.make_item	= hb_heartbeat_set_make_item,
-	.drop_item	= hb_heartbeat_set_drop_item,
+static struct configfs_group_operations hb_heartbeat_group_group_ops = {
+	.make_item	= hb_heartbeat_group_make_item,
+	.drop_item	= hb_heartbeat_group_drop_item,
 };
 
-struct config_item_type hb_heartbeat_set_type = {
-	.set_ops	= &hb_heartbeat_set_set_ops,
+struct config_item_type hb_heartbeat_group_type = {
+	.group_ops	= &hb_heartbeat_group_group_ops,
 	.owner		= THIS_MODULE,
 };
 
-/* this is just here to avoid touching uset in heartbeat.h which the
+/* this is just here to avoid touching group in heartbeat.h which the
  * entire damn world #includes */
-struct uset *hb_alloc_hb_set(void)
+struct config_group *hb_alloc_hb_set(void)
 {
-	struct hb_heartbeat_set *hs = NULL;
-	struct uset *ret = NULL;
+	struct hb_heartbeat_group *hs = NULL;
+	struct config_group *ret = NULL;
 
-	hs = kcalloc(1, sizeof(struct hb_heartbeat_set), GFP_KERNEL);
+	hs = kcalloc(1, sizeof(struct hb_heartbeat_group), GFP_KERNEL);
 	if (hs == NULL)
 		goto out;
 
-	uset_init_type_name(&hs->hs_uset, "heartbeat",
-			    &hb_heartbeat_set_type);
+	config_group_init_type_name(&hs->hs_group, "heartbeat",
+				    &hb_heartbeat_group_type);
 
-	ret = &hs->hs_uset;
+	ret = &hs->hs_group;
 out:
 	if (ret == NULL)
 		kfree(hs);
 	return ret;
 }
 
-void hb_free_hb_set(struct uset *uset)
+void hb_free_hb_set(struct config_group *group)
 {
-	struct hb_heartbeat_set *hs = to_hb_heartbeat_set(uset);
+	struct hb_heartbeat_group *hs = to_hb_heartbeat_group(group);
 	kfree(hs);
 }
 

Modified: trunk/fs/ocfs2/cluster/heartbeat.h
===================================================================
--- trunk/fs/ocfs2/cluster/heartbeat.h	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/ocfs2/cluster/heartbeat.h	2005-03-30 21:08:40 UTC (rev 2087)
@@ -52,8 +52,8 @@
 /* number of missed changes to be seen as dead */ 
 #define HB_DEAD_THRESHOLD	   30
 
-struct uset *hb_alloc_hb_set(void);
-void hb_free_hb_set(struct uset *uset);
+struct config_group *hb_alloc_hb_set(void);
+void hb_free_hb_set(struct config_group *group);
 
 void hb_setup_callback(struct hb_callback_func *hc, int type, hb_cb_func *func,
 		      void *data, int priority);

Modified: trunk/fs/ocfs2/cluster/nodemanager.c
===================================================================
--- trunk/fs/ocfs2/cluster/nodemanager.c	2005-03-30 21:01:30 UTC (rev 2086)
+++ trunk/fs/ocfs2/cluster/nodemanager.c	2005-03-30 21:08:40 UTC (rev 2087)
@@ -83,12 +83,12 @@
 #endif
 
 struct nm_cluster {
-	struct uset	cl_uset;
-	unsigned	cl_has_local:1;
-	u8		cl_local_node;
-	rwlock_t	cl_nodes_lock;
-	struct nm_node  *cl_nodes[NM_MAX_NODES];
-	struct rb_root	cl_node_ip_tree;
+	struct config_group	cl_group;
+	unsigned		cl_has_local:1;
+	u8			cl_local_node;
+	rwlock_t		cl_nodes_lock;
+	struct nm_node  	*cl_nodes[NM_MAX_NODES];
+	struct rb_root		cl_node_ip_tree;
 	/* this bitmap is part of a hack for disk bitmap.. will go eventually. - zab */
 	unsigned long	cl_nodes_bitmap[BITS_TO_LONGS(NM_MAX_NODES)];
 };
@@ -199,8 +199,8 @@
 static struct nm_cluster *to_nm_cluster(struct config_item *item)
 {
 	return item ?
-		container_of(to_uset(item), struct nm_cluster,
-			     cl_uset)
+		container_of(to_config_group(item), struct nm_cluster,
+			     cl_group)
 		: NULL;
 }
 
@@ -223,7 +223,7 @@
 struct nm_cluster *to_nm_cluster_from_node(struct nm_node *node)
 {
 	/* through the first node_set .parent
-	 * mycluster/nodes/mynode == nm_cluster->nm_node_set->nm_node */
+	 * mycluster/nodes/mynode == nm_cluster->nm_node_group->nm_node */
 	return to_nm_cluster(node->nd_item.parent->parent);
 }
 
@@ -493,22 +493,22 @@
 
 /* node set */
 
-struct nm_node_set {
-	struct uset ns_uset;
+struct nm_node_group {
+	struct config_group ns_group;
 	/* some stuff? */
 };
 
 #if 0
-static struct nm_node_set *to_nm_node_set(struct uset *uset)
+static struct nm_node_group *to_nm_node_group(struct config_group *group)
 {
-	return uset ? 
-		container_of(uset, struct nm_node_set, ns_uset) 
+	return group ? 
+		container_of(group, struct nm_node_group, ns_group) 
 		: NULL;
 }
 #endif
 
-static struct config_item *nm_node_set_make_item(struct uset *uset,
-					      const char *name)
+static struct config_item *nm_node_group_make_item(struct config_group *group,
+						   const char *name)
 {
 	struct nm_node *node = NULL;
 	struct config_item *ret = NULL;
@@ -549,10 +549,10 @@
 	return ret;
 }
 
-static void nm_node_set_drop_item(struct uset *uset, struct config_item *item)
+static void nm_node_group_drop_item(struct config_group *group, struct config_item *item)
 {
 	struct nm_node *node = to_nm_node(item);
-	struct nm_cluster *cluster = to_nm_cluster(uset->item.parent);
+	struct nm_cluster *cluster = to_nm_cluster(group->item.parent);
 
 	net_stop_node_sock(node);
 
@@ -581,13 +581,13 @@
 	config_item_put(item);
 }
 
-static struct configfs_set_operations nm_node_set_set_ops = {
-	.make_item	= nm_node_set_make_item,
-	.drop_item	= nm_node_set_drop_item,
+static struct configfs_group_operations nm_node_group_group_ops = {
+	.make_item	= nm_node_group_make_item,
+	.drop_item	= nm_node_group_drop_item,
 };
 
-static struct config_item_type nm_node_set_type = {
-	.set_ops	= &nm_node_set_set_ops,
+static struct config_item_type nm_node_group_type = {
+	.group_ops	= &nm_node_group_group_ops,
 	.owner		= THIS_MODULE,
 };
 
@@ -597,7 +597,7 @@
 {
 	struct nm_cluster *cluster = to_nm_cluster(item);
 
-	kfree(cluster->cl_uset.default_sets);
+	kfree(cluster->cl_group.default_groups);
 	kfree(cluster);
 }
 
@@ -612,26 +612,26 @@
 
 /* cluster set */
 
-struct nm_cluster_set {
+struct nm_cluster_group {
 	struct configfs_subsystem cs_subsys;
 	/* some stuff? */
 };
 
 #if 0
-static struct nm_cluster_set *to_nm_cluster_set(struct uset *uset)
+static struct nm_cluster_group *to_nm_cluster_group(struct config_group *group)
 {
-	return uset ?
-		container_of(to_configfs_subsystem(uset), struct nm_cluster_set, cs_subsys)
+	return group ?
+		container_of(to_configfs_subsystem(group), struct nm_cluster_group, cs_subsys)
 	       : NULL;
 }
 #endif
 
-static struct uset *nm_cluster_set_make_set(struct uset *uset,
-					    const char *name)
+static struct config_group *nm_cluster_group_make_group(struct config_group *group,
+							const char *name)
 {
 	struct nm_cluster *cluster = NULL;
-	struct nm_node_set *ns = NULL;
-	struct uset *hb_uset = NULL, *ret = NULL;
+	struct nm_node_group *ns = NULL;
+	struct config_group *hb_group = NULL, *ret = NULL;
 	void *defs = NULL;
 
 	/* this runs under the parent dir's i_sem; there can be only
@@ -640,37 +640,37 @@
 		goto out; /* ENOSPC */
 
 	cluster = kcalloc(1, sizeof(struct nm_cluster), GFP_KERNEL);
-	ns = kcalloc(1, sizeof(struct nm_node_set), GFP_KERNEL);
-	defs = kcalloc(3, sizeof(struct uset *), GFP_KERNEL);
-	hb_uset = hb_alloc_hb_set();
-	if (cluster == NULL || ns == NULL || hb_uset == NULL || defs == NULL)
+	ns = kcalloc(1, sizeof(struct nm_node_group), GFP_KERNEL);
+	defs = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
+	hb_group = hb_alloc_hb_set();
+	if (cluster == NULL || ns == NULL || hb_group == NULL || defs == NULL)
 		goto out;
 
-	uset_init_type_name(&cluster->cl_uset, name, &nm_cluster_type);
-	uset_init_type_name(&ns->ns_uset, "node", &nm_node_set_type);
+	config_group_init_type_name(&cluster->cl_group, name, &nm_cluster_type);
+	config_group_init_type_name(&ns->ns_group, "node", &nm_node_group_type);
 
-	cluster->cl_uset.default_sets = defs;
-	cluster->cl_uset.default_sets[0] = &ns->ns_uset;
-	cluster->cl_uset.default_sets[1] = hb_uset;
-	cluster->cl_uset.default_sets[2] = NULL;
+	cluster->cl_group.default_groups = defs;
+	cluster->cl_group.default_groups[0] = &ns->ns_group;
+	cluster->cl_group.default_groups[1] = hb_group;
+	cluster->cl_group.default_groups[2] = NULL;
 	rwlock_init(&cluster->cl_nodes_lock);
 	cluster->cl_node_ip_tree = RB_ROOT;
 
-	ret = &cluster->cl_uset;
+	ret = &cluster->cl_group;
 	nm_single_cluster = cluster;
 
 out:
 	if (ret == NULL) {
 		kfree(cluster);
 		kfree(ns);
-		hb_free_hb_set(hb_uset);
+		hb_free_hb_set(hb_group);
 		kfree(defs);
 	}
 
 	return ret;
 }
 
-static void nm_cluster_set_drop_item(struct uset *uset, struct config_item *item)
+static void nm_cluster_group_drop_item(struct config_group *group, struct config_item *item)
 {
 	struct nm_cluster *cluster = to_nm_cluster(item);
 	int i;
@@ -679,31 +679,31 @@
 	BUG_ON(nm_single_cluster != cluster);
 	nm_single_cluster = NULL;
 
-	for (i = 0; cluster->cl_uset.default_sets[i]; i++) {
-		killme = &cluster->cl_uset.default_sets[i]->item;
-		cluster->cl_uset.default_sets[i] = NULL;
+	for (i = 0; cluster->cl_group.default_groups[i]; i++) {
+		killme = &cluster->cl_group.default_groups[i]->item;
+		cluster->cl_group.default_groups[i] = NULL;
 		config_item_put(killme);
 	}
 
 	config_item_put(item);
 }
 
-static struct configfs_set_operations nm_cluster_set_set_ops = {
-	.make_set	= nm_cluster_set_make_set,
-	.drop_item	= nm_cluster_set_drop_item,
+static struct configfs_group_operations nm_cluster_group_group_ops = {
+	.make_group	= nm_cluster_group_make_group,
+	.drop_item	= nm_cluster_group_drop_item,
 };
 
-static struct config_item_type nm_cluster_set_type = {
-	.set_ops	= &nm_cluster_set_set_ops,
+static struct config_item_type nm_cluster_group_type = {
+	.group_ops	= &nm_cluster_group_group_ops,
 	.owner	= THIS_MODULE,
 };
 
-static struct nm_cluster_set nm_cluster_set = {
+static struct nm_cluster_group nm_cluster_group = {
 	.cs_subsys = {
-		.su_set = {
+		.su_group = {
 			.item = {
 				.name = "cluster",
-				.ktype = &nm_cluster_set_type,
+				.ktype = &nm_cluster_group_type,
 			},
 		},
 	},
@@ -714,7 +714,7 @@
 	nmprintk("unloading nm module\n");
 	/* XXX sync with hb callbacks and shut down hb? */
 	net_unregister_hb_callbacks();
-	configfs_unregister_subsystem(&nm_cluster_set.cs_subsys);
+	configfs_unregister_subsystem(&nm_cluster_group.cs_subsys);
 }
 
 static int __init init_nm(void)
@@ -724,9 +724,9 @@
 	hb_init();
 	ret = net_register_hb_callbacks();
 	if (!ret) {
-		uset_init(&nm_cluster_set.cs_subsys.su_set);
-		init_MUTEX(&nm_cluster_set.cs_subsys.su_sem);
-		ret = configfs_register_subsystem(&nm_cluster_set.cs_subsys);
+		config_group_init(&nm_cluster_group.cs_subsys.su_group);
+		init_MUTEX(&nm_cluster_group.cs_subsys.su_sem);
+		ret = configfs_register_subsystem(&nm_cluster_group.cs_subsys);
 		if (ret) {
 			printk(KERN_ERR "nodemanager: Registration returned %d\n", ret);
 			net_unregister_hb_callbacks();



More information about the Ocfs2-commits mailing list