Commit 364e8dd9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'configfs-for-linus' of git://git.infradead.org/users/hch/configfs 

Pull configfs updates from Christoph Hellwig:

 - A large patch from me to simplify setting up the list of default
   groups by actually implementing it as a list instead of an array.

 - a small Y2083 prep patch from Deepa Dinamani.  Probably doesn't
   matter on it's own, but it seems like he is trying to get rid of all
   CURRENT_TIME uses in file systems, which is a worthwhile goal.

* tag 'configfs-for-linus' of git://git.infradead.org/users/hch/configfs:
  configfs: switch ->default groups to a linked list
  configfs: Replace CURRENT_TIME by current_fs_time()
parents 48d10bda 1ae1602d

Documentation/filesystems/configfs/configfs.txt

+6 −5
Original line number Diff line number Diff line
@@ -250,7 +250,8 @@ child item. 
		struct config_item		cg_item;

		struct list_head		cg_children;

		struct configfs_subsystem 	*cg_subsys;

		struct config_group		**default_groups;

		struct list_head		default_groups;

		struct list_head		group_entry;

	};



	void config_group_init(struct config_group *group);
@@ -420,15 +421,15 @@ These automatic subgroups, or default groups, do not preclude other 
children of the parent group.  If ct_group_ops->make_group() exists,

other child groups can be created on the parent group directly.



A configfs subsystem specifies default groups by filling in the

NULL-terminated array default_groups on the config_group structure.

Each group in that array is populated in the configfs tree at the same

A configfs subsystem specifies default groups by adding them using the

configfs_add_default_group() function to the parent config_group

structure.  Each added group is populated in the configfs tree at the same

time as the parent group.  Similarly, they are removed at the same time

as the parent.  No extra notification is provided.  When a ->drop_item()

method call notifies the subsystem the parent group is going away, it

also means every default group child associated with that parent group.



As a consequence of this, default_groups cannot be removed directly via

As a consequence of this, default groups cannot be removed directly via

rmdir(2).  They also are not considered when rmdir(2) on the parent

group is checking for children.

drivers/infiniband/core/cma_configfs.c

+9 −22
Original line number Diff line number Diff line
@@ -49,8 +49,6 @@ struct cma_dev_group { 
	char				name[IB_DEVICE_NAME_MAX];

	struct config_group		device_group;

	struct config_group		ports_group;

	struct config_group		*default_dev_group[2];

	struct config_group		**default_ports_group;

	struct cma_dev_port_group	*ports;

};
@@ -158,7 +156,6 @@ static int make_cma_ports(struct cma_dev_group *cma_dev_group, 
	unsigned int i;

	unsigned int ports_num;

	struct cma_dev_port_group *ports;

	struct config_group **ports_group;

	int err;



	ibdev = cma_get_ib_dev(cma_dev);
@@ -169,9 +166,8 @@ static int make_cma_ports(struct cma_dev_group *cma_dev_group, 
	ports_num = ibdev->phys_port_cnt;

	ports = kcalloc(ports_num, sizeof(*cma_dev_group->ports),

			GFP_KERNEL);

	ports_group = kcalloc(ports_num + 1, sizeof(*ports_group), GFP_KERNEL);



	if (!ports || !ports_group) {

	if (!ports) {

		err = -ENOMEM;

		goto free;

	}
@@ -185,18 +181,16 @@ static int make_cma_ports(struct cma_dev_group *cma_dev_group, 
		config_group_init_type_name(&ports[i].group,

					    port_str,

					    &cma_port_group_type);

		ports_group[i] = &ports[i].group;

		configfs_add_default_group(&ports[i].group,

				&cma_dev_group->ports_group);



	}

	ports_group[i] = NULL;

	cma_dev_group->default_ports_group = ports_group;

	cma_dev_group->ports = ports;



	return 0;

free:

	kfree(ports);

	kfree(ports_group);

	cma_dev_group->ports = NULL;

	cma_dev_group->default_ports_group = NULL;

	return err;

}
@@ -220,9 +214,7 @@ static void release_cma_ports_group(struct config_item *item) 
							   ports_group);



	kfree(cma_dev_group->ports);

	kfree(cma_dev_group->default_ports_group);

	cma_dev_group->ports = NULL;

	cma_dev_group->default_ports_group = NULL;

};



static struct configfs_item_operations cma_ports_item_ops = {
@@ -263,22 +255,17 @@ static struct config_group *make_cma_dev(struct config_group *group, 


	strncpy(cma_dev_group->name, name, sizeof(cma_dev_group->name));



	err = make_cma_ports(cma_dev_group, cma_dev);

	if (err)

		goto fail;



	cma_dev_group->ports_group.default_groups =

		cma_dev_group->default_ports_group;

	config_group_init_type_name(&cma_dev_group->ports_group, "ports",

				    &cma_ports_group_type);



	cma_dev_group->device_group.default_groups

		= cma_dev_group->default_dev_group;

	cma_dev_group->default_dev_group[0] = &cma_dev_group->ports_group;

	cma_dev_group->default_dev_group[1] = NULL;

	err = make_cma_ports(cma_dev_group, cma_dev);

	if (err)

		goto fail;



	config_group_init_type_name(&cma_dev_group->device_group, name,

				    &cma_device_group_type);

	configfs_add_default_group(&cma_dev_group->ports_group,

			&cma_dev_group->device_group);



	cma_deref_dev(cma_dev);

	return &cma_dev_group->device_group;

drivers/target/iscsi/iscsi_target_configfs.c

+21 −54
Original line number Diff line number Diff line
@@ -771,21 +771,11 @@ static int lio_target_init_nodeacl(struct se_node_acl *se_nacl, 
{

	struct iscsi_node_acl *acl =

		container_of(se_nacl, struct iscsi_node_acl, se_node_acl);

	struct config_group *stats_cg = &se_nacl->acl_fabric_stat_group;



	stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,

				GFP_KERNEL);

	if (!stats_cg->default_groups) {

		pr_err("Unable to allocate memory for"

				" stats_cg->default_groups\n");

		return -ENOMEM;

	}



	stats_cg->default_groups[0] = &acl->node_stat_grps.iscsi_sess_stats_group;

	stats_cg->default_groups[1] = NULL;

	config_group_init_type_name(&acl->node_stat_grps.iscsi_sess_stats_group,

			"iscsi_sess_stats", &iscsi_stat_sess_cit);



	configfs_add_default_group(&acl->node_stat_grps.iscsi_sess_stats_group,

			&se_nacl->acl_fabric_stat_group);

	return 0;

}
@@ -793,17 +783,8 @@ static void lio_target_cleanup_nodeacl( struct se_node_acl *se_nacl) 
{

	struct iscsi_node_acl *acl = container_of(se_nacl,

			struct iscsi_node_acl, se_node_acl);

	struct config_item *df_item;

	struct config_group *stats_cg;

	int i;



	stats_cg = &acl->se_node_acl.acl_fabric_stat_group;

	for (i = 0; stats_cg->default_groups[i]; i++) {

		df_item = &stats_cg->default_groups[i]->cg_item;

		stats_cg->default_groups[i] = NULL;

		config_item_put(df_item);

	}

	kfree(stats_cg->default_groups);

	configfs_remove_default_groups(&acl->se_node_acl.acl_fabric_stat_group);

}



/* End items for lio_target_acl_cit */
@@ -1260,42 +1241,37 @@ static struct se_wwn *lio_target_call_coreaddtiqn( 
	struct config_group *group,

	const char *name)

{

	struct config_group *stats_cg;

	struct iscsi_tiqn *tiqn;



	tiqn = iscsit_add_tiqn((unsigned char *)name);

	if (IS_ERR(tiqn))

		return ERR_CAST(tiqn);

	/*

	 * Setup struct iscsi_wwn_stat_grps for se_wwn->fabric_stat_group.

	 */

	stats_cg = &tiqn->tiqn_wwn.fabric_stat_group;



	stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 6,

				GFP_KERNEL);

	if (!stats_cg->default_groups) {

		pr_err("Unable to allocate memory for"

				" stats_cg->default_groups\n");

		iscsit_del_tiqn(tiqn);

		return ERR_PTR(-ENOMEM);

	}



	stats_cg->default_groups[0] = &tiqn->tiqn_stat_grps.iscsi_instance_group;

	stats_cg->default_groups[1] = &tiqn->tiqn_stat_grps.iscsi_sess_err_group;

	stats_cg->default_groups[2] = &tiqn->tiqn_stat_grps.iscsi_tgt_attr_group;

	stats_cg->default_groups[3] = &tiqn->tiqn_stat_grps.iscsi_login_stats_group;

	stats_cg->default_groups[4] = &tiqn->tiqn_stat_grps.iscsi_logout_stats_group;

	stats_cg->default_groups[5] = NULL;

	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_instance_group,

			"iscsi_instance", &iscsi_stat_instance_cit);

	configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_instance_group,

			&tiqn->tiqn_wwn.fabric_stat_group);



	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_sess_err_group,

			"iscsi_sess_err", &iscsi_stat_sess_err_cit);

	configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_sess_err_group,

			&tiqn->tiqn_wwn.fabric_stat_group);



	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_tgt_attr_group,

			"iscsi_tgt_attr", &iscsi_stat_tgt_attr_cit);

	configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_tgt_attr_group,

			&tiqn->tiqn_wwn.fabric_stat_group);



	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_login_stats_group,

			"iscsi_login_stats", &iscsi_stat_login_cit);

	configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_login_stats_group,

			&tiqn->tiqn_wwn.fabric_stat_group);



	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_logout_stats_group,

			"iscsi_logout_stats", &iscsi_stat_logout_cit);

	configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_logout_stats_group,

			&tiqn->tiqn_wwn.fabric_stat_group);





	pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);

	pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:"
@@ -1307,17 +1283,8 @@ static void lio_target_call_coredeltiqn( 
	struct se_wwn *wwn)

{

	struct iscsi_tiqn *tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);

	struct config_item *df_item;

	struct config_group *stats_cg;

	int i;



	stats_cg = &tiqn->tiqn_wwn.fabric_stat_group;

	for (i = 0; stats_cg->default_groups[i]; i++) {

		df_item = &stats_cg->default_groups[i]->cg_item;

		stats_cg->default_groups[i] = NULL;

		config_item_put(df_item);

	}

	kfree(stats_cg->default_groups);

	configfs_remove_default_groups(&tiqn->tiqn_wwn.fabric_stat_group);



	pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s\n",

			tiqn->tiqn);

drivers/target/target_core_configfs.c

+40 −163
Original line number Diff line number Diff line
@@ -194,13 +194,11 @@ static struct config_group *target_core_register_fabric( 
	pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n",

			&tf->tf_wwn_cit);



	tf->tf_group.default_groups = tf->tf_default_groups;

	tf->tf_group.default_groups[0] = &tf->tf_disc_group;

	tf->tf_group.default_groups[1] = NULL;



	config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit);



	config_group_init_type_name(&tf->tf_disc_group, "discovery_auth",

			&tf->tf_discovery_cit);

	configfs_add_default_group(&tf->tf_disc_group, &tf->tf_group);



	pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric:"

			" %s\n", tf->tf_group.cg_item.ci_name);
@@ -216,9 +214,6 @@ static void target_core_deregister_fabric( 
{

	struct target_fabric_configfs *tf = container_of(

		to_config_group(item), struct target_fabric_configfs, tf_group);

	struct config_group *tf_group;

	struct config_item *df_item;

	int i;



	pr_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in"

		" tf list\n", config_item_name(item));
@@ -230,12 +225,7 @@ static void target_core_deregister_fabric( 
	pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"

			" %s\n", config_item_name(item));



	tf_group = &tf->tf_group;

	for (i = 0; tf_group->default_groups[i]; i++) {

		df_item = &tf_group->default_groups[i]->cg_item;

		tf_group->default_groups[i] = NULL;

		config_item_put(df_item);

	}

	configfs_remove_default_groups(&tf->tf_group);

	config_item_put(item);

}
@@ -2151,7 +2141,6 @@ static void target_core_dev_release(struct config_item *item) 
	struct se_device *dev =

		container_of(dev_cg, struct se_device, dev_group);



	kfree(dev_cg->default_groups);

	target_free_device(dev);

}
@@ -2819,8 +2808,6 @@ static struct config_group *target_core_make_subdev( 
	struct se_hba *hba = item_to_hba(hba_ci);

	struct target_backend *tb = hba->backend;

	struct se_device *dev;

	struct config_group *dev_cg = NULL, *tg_pt_gp_cg = NULL;

	struct config_group *dev_stat_grp = NULL;

	int errno = -ENOMEM, ret;



	ret = mutex_lock_interruptible(&hba->hba_access_mutex);
@@ -2831,73 +2818,52 @@ static struct config_group *target_core_make_subdev( 
	if (!dev)

		goto out_unlock;



	dev_cg = &dev->dev_group;

	config_group_init_type_name(&dev->dev_group, name, &tb->tb_dev_cit);



	dev_cg->default_groups = kmalloc(sizeof(struct config_group *) * 6,

			GFP_KERNEL);

	if (!dev_cg->default_groups)

		goto out_free_device;



	config_group_init_type_name(dev_cg, name, &tb->tb_dev_cit);

	config_group_init_type_name(&dev->dev_attrib.da_group, "attrib",

			&tb->tb_dev_attrib_cit);

	configfs_add_default_group(&dev->dev_attrib.da_group, &dev->dev_group);



	config_group_init_type_name(&dev->dev_pr_group, "pr",

			&tb->tb_dev_pr_cit);

	configfs_add_default_group(&dev->dev_pr_group, &dev->dev_group);



	config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn",

			&tb->tb_dev_wwn_cit);

	configfs_add_default_group(&dev->t10_wwn.t10_wwn_group,

			&dev->dev_group);



	config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group,

			"alua", &tb->tb_dev_alua_tg_pt_gps_cit);

	configfs_add_default_group(&dev->t10_alua.alua_tg_pt_gps_group,

			&dev->dev_group);



	config_group_init_type_name(&dev->dev_stat_grps.stat_group,

			"statistics", &tb->tb_dev_stat_cit);

	configfs_add_default_group(&dev->dev_stat_grps.stat_group,

			&dev->dev_group);



	dev_cg->default_groups[0] = &dev->dev_attrib.da_group;

	dev_cg->default_groups[1] = &dev->dev_pr_group;

	dev_cg->default_groups[2] = &dev->t10_wwn.t10_wwn_group;

	dev_cg->default_groups[3] = &dev->t10_alua.alua_tg_pt_gps_group;

	dev_cg->default_groups[4] = &dev->dev_stat_grps.stat_group;

	dev_cg->default_groups[5] = NULL;

	/*

	 * Add core/$HBA/$DEV/alua/default_tg_pt_gp

	 */

	tg_pt_gp = core_alua_allocate_tg_pt_gp(dev, "default_tg_pt_gp", 1);

	if (!tg_pt_gp)

		goto out_free_dev_cg_default_groups;

		goto out_free_device;

	dev->t10_alua.default_tg_pt_gp = tg_pt_gp;



	tg_pt_gp_cg = &dev->t10_alua.alua_tg_pt_gps_group;

	tg_pt_gp_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,

				GFP_KERNEL);

	if (!tg_pt_gp_cg->default_groups) {

		pr_err("Unable to allocate tg_pt_gp_cg->"

				"default_groups\n");

		goto out_free_tg_pt_gp;

	}



	config_group_init_type_name(&tg_pt_gp->tg_pt_gp_group,

			"default_tg_pt_gp", &target_core_alua_tg_pt_gp_cit);

	tg_pt_gp_cg->default_groups[0] = &tg_pt_gp->tg_pt_gp_group;

	tg_pt_gp_cg->default_groups[1] = NULL;

	configfs_add_default_group(&tg_pt_gp->tg_pt_gp_group,

			&dev->t10_alua.alua_tg_pt_gps_group);



	/*

	 * Add core/$HBA/$DEV/statistics/ default groups

	 */

	dev_stat_grp = &dev->dev_stat_grps.stat_group;

	dev_stat_grp->default_groups = kmalloc(sizeof(struct config_group *) * 4,

				GFP_KERNEL);

	if (!dev_stat_grp->default_groups) {

		pr_err("Unable to allocate dev_stat_grp->default_groups\n");

		goto out_free_tg_pt_gp_cg_default_groups;

	}

	target_stat_setup_dev_default_groups(dev);



	mutex_unlock(&hba->hba_access_mutex);

	return dev_cg;

	return &dev->dev_group;



out_free_tg_pt_gp_cg_default_groups:

	kfree(tg_pt_gp_cg->default_groups);

out_free_tg_pt_gp:

	core_alua_free_tg_pt_gp(tg_pt_gp);

out_free_dev_cg_default_groups:

	kfree(dev_cg->default_groups);

out_free_device:

	target_free_device(dev);

out_unlock:
@@ -2913,40 +2879,22 @@ static void target_core_drop_subdev( 
	struct se_device *dev =

		container_of(dev_cg, struct se_device, dev_group);

	struct se_hba *hba;

	struct config_item *df_item;

	struct config_group *tg_pt_gp_cg, *dev_stat_grp;

	int i;



	hba = item_to_hba(&dev->se_hba->hba_group.cg_item);



	mutex_lock(&hba->hba_access_mutex);



	dev_stat_grp = &dev->dev_stat_grps.stat_group;

	for (i = 0; dev_stat_grp->default_groups[i]; i++) {

		df_item = &dev_stat_grp->default_groups[i]->cg_item;

		dev_stat_grp->default_groups[i] = NULL;

		config_item_put(df_item);

	}

	kfree(dev_stat_grp->default_groups);

	configfs_remove_default_groups(&dev->dev_stat_grps.stat_group);

	configfs_remove_default_groups(&dev->t10_alua.alua_tg_pt_gps_group);



	tg_pt_gp_cg = &dev->t10_alua.alua_tg_pt_gps_group;

	for (i = 0; tg_pt_gp_cg->default_groups[i]; i++) {

		df_item = &tg_pt_gp_cg->default_groups[i]->cg_item;

		tg_pt_gp_cg->default_groups[i] = NULL;

		config_item_put(df_item);

	}

	kfree(tg_pt_gp_cg->default_groups);

	/*

	 * core_alua_free_tg_pt_gp() is called from ->default_tg_pt_gp

	 * directly from target_core_alua_tg_pt_gp_release().

	 */

	dev->t10_alua.default_tg_pt_gp = NULL;



	for (i = 0; dev_cg->default_groups[i]; i++) {

		df_item = &dev_cg->default_groups[i]->cg_item;

		dev_cg->default_groups[i] = NULL;

		config_item_put(df_item);

	}

	configfs_remove_default_groups(dev_cg);



	/*

	 * se_dev is released from target_core_dev_item_ops->release()

	 */
@@ -3141,8 +3089,6 @@ void target_setup_backend_cits(struct target_backend *tb) 


static int __init target_core_init_configfs(void)

{

	struct config_group *target_cg, *hba_cg = NULL, *alua_cg = NULL;

	struct config_group *lu_gp_cg = NULL;

	struct configfs_subsystem *subsys = &target_core_fabrics;

	struct t10_alua_lu_gp *lu_gp;

	int ret;
@@ -3161,51 +3107,24 @@ static int __init target_core_init_configfs(void) 
	 * Create $CONFIGFS/target/core default group for HBA <-> Storage Object

	 * and ALUA Logical Unit Group and Target Port Group infrastructure.

	 */

	target_cg = &subsys->su_group;

	target_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,

				GFP_KERNEL);

	if (!target_cg->default_groups) {

		pr_err("Unable to allocate target_cg->default_groups\n");

		ret = -ENOMEM;

		goto out_global;

	}

	config_group_init_type_name(&target_core_hbagroup, "core",

			&target_core_cit);

	configfs_add_default_group(&target_core_hbagroup, &subsys->su_group);



	config_group_init_type_name(&target_core_hbagroup,

			"core", &target_core_cit);

	target_cg->default_groups[0] = &target_core_hbagroup;

	target_cg->default_groups[1] = NULL;

	/*

	 * Create ALUA infrastructure under /sys/kernel/config/target/core/alua/

	 */

	hba_cg = &target_core_hbagroup;

	hba_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,

				GFP_KERNEL);

	if (!hba_cg->default_groups) {

		pr_err("Unable to allocate hba_cg->default_groups\n");

		ret = -ENOMEM;

		goto out_global;

	}

	config_group_init_type_name(&alua_group,

			"alua", &target_core_alua_cit);

	hba_cg->default_groups[0] = &alua_group;

	hba_cg->default_groups[1] = NULL;

	config_group_init_type_name(&alua_group, "alua", &target_core_alua_cit);

	configfs_add_default_group(&alua_group, &target_core_hbagroup);



	/*

	 * Add ALUA Logical Unit Group and Target Port Group ConfigFS

	 * groups under /sys/kernel/config/target/core/alua/

	 */

	alua_cg = &alua_group;

	alua_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,

			GFP_KERNEL);

	if (!alua_cg->default_groups) {

		pr_err("Unable to allocate alua_cg->default_groups\n");

		ret = -ENOMEM;

		goto out_global;

	}

	config_group_init_type_name(&alua_lu_gps_group, "lu_gps",

			&target_core_alua_lu_gps_cit);

	configfs_add_default_group(&alua_lu_gps_group, &alua_group);



	config_group_init_type_name(&alua_lu_gps_group,

			"lu_gps", &target_core_alua_lu_gps_cit);

	alua_cg->default_groups[0] = &alua_lu_gps_group;

	alua_cg->default_groups[1] = NULL;

	/*

	 * Add core/alua/lu_gps/default_lu_gp

	 */
@@ -3215,20 +3134,12 @@ static int __init target_core_init_configfs(void) 
		goto out_global;

	}



	lu_gp_cg = &alua_lu_gps_group;

	lu_gp_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,

			GFP_KERNEL);

	if (!lu_gp_cg->default_groups) {

		pr_err("Unable to allocate lu_gp_cg->default_groups\n");

		ret = -ENOMEM;

		goto out_global;

	}



	config_group_init_type_name(&lu_gp->lu_gp_group, "default_lu_gp",

				&target_core_alua_lu_gp_cit);

	lu_gp_cg->default_groups[0] = &lu_gp->lu_gp_group;

	lu_gp_cg->default_groups[1] = NULL;

	configfs_add_default_group(&lu_gp->lu_gp_group, &alua_lu_gps_group);



	default_lu_gp = lu_gp;



	/*

	 * Register the target_core_mod subsystem with configfs.

	 */
@@ -3267,55 +3178,21 @@ out_global: 
		core_alua_free_lu_gp(default_lu_gp);

		default_lu_gp = NULL;

	}

	if (lu_gp_cg)

		kfree(lu_gp_cg->default_groups);

	if (alua_cg)

		kfree(alua_cg->default_groups);

	if (hba_cg)

		kfree(hba_cg->default_groups);

	kfree(target_cg->default_groups);

	release_se_kmem_caches();

	return ret;

}



static void __exit target_core_exit_configfs(void)

{

	struct config_group *hba_cg, *alua_cg, *lu_gp_cg;

	struct config_item *item;

	int i;



	lu_gp_cg = &alua_lu_gps_group;

	for (i = 0; lu_gp_cg->default_groups[i]; i++) {

		item = &lu_gp_cg->default_groups[i]->cg_item;

		lu_gp_cg->default_groups[i] = NULL;

		config_item_put(item);

	}

	kfree(lu_gp_cg->default_groups);

	lu_gp_cg->default_groups = NULL;

	configfs_remove_default_groups(&alua_lu_gps_group);

	configfs_remove_default_groups(&alua_group);

	configfs_remove_default_groups(&target_core_hbagroup);



	alua_cg = &alua_group;

	for (i = 0; alua_cg->default_groups[i]; i++) {

		item = &alua_cg->default_groups[i]->cg_item;

		alua_cg->default_groups[i] = NULL;

		config_item_put(item);

	}

	kfree(alua_cg->default_groups);

	alua_cg->default_groups = NULL;



	hba_cg = &target_core_hbagroup;

	for (i = 0; hba_cg->default_groups[i]; i++) {

		item = &hba_cg->default_groups[i]->cg_item;

		hba_cg->default_groups[i] = NULL;

		config_item_put(item);

	}

	kfree(hba_cg->default_groups);

	hba_cg->default_groups = NULL;

	/*

	 * We expect subsys->su_group.default_groups to be released

	 * by configfs subsystem provider logic..

	 */

	configfs_unregister_subsystem(&target_core_fabrics);

	kfree(target_core_fabrics.su_group.default_groups);



	core_alua_free_lu_gp(default_lu_gp);

	default_lu_gp = NULL;

drivers/target/target_core_fabric_configfs.c

+49 −145

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE