static void target_fabric_drop_lun( struct config_group *group, struct config_item *item) { struct se_lun *lun = container_of(to_config_group(item), struct se_lun, lun_group); struct config_item *df_item; struct config_group *lun_cg, *port_stat_grp; int i; port_stat_grp = &lun->port_stat_grps.stat_group; for (i = 0; port_stat_grp->default_groups[i]; i++) { df_item = &port_stat_grp->default_groups[i]->cg_item; port_stat_grp->default_groups[i] = NULL; config_item_put(df_item); } kfree(port_stat_grp->default_groups); lun_cg = &lun->lun_group; for (i = 0; lun_cg->default_groups[i]; i++) { df_item = &lun_cg->default_groups[i]->cg_item; lun_cg->default_groups[i] = NULL; config_item_put(df_item); } kfree(lun_cg->default_groups); config_item_put(item); }
static void target_fabric_drop_mappedlun( struct config_group *group, struct config_item *item) { struct se_lun_acl *lacl = container_of(to_config_group(item), struct se_lun_acl, se_lun_group); struct config_item *df_item; struct config_group *lacl_cg = NULL, *ml_stat_grp = NULL; int i; ml_stat_grp = &lacl->ml_stat_grps.stat_group; for (i = 0; ml_stat_grp->default_groups[i]; i++) { df_item = &ml_stat_grp->default_groups[i]->cg_item; ml_stat_grp->default_groups[i] = NULL; config_item_put(df_item); } kfree(ml_stat_grp->default_groups); lacl_cg = &lacl->se_lun_group; for (i = 0; lacl_cg->default_groups[i]; i++) { df_item = &lacl_cg->default_groups[i]->cg_item; lacl_cg->default_groups[i] = NULL; config_item_put(df_item); } kfree(lacl_cg->default_groups); config_item_put(item); }
int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { int ret; struct path path; struct configfs_dirent *sd; struct config_item *parent_item; struct config_item *target_item = NULL; struct config_item_type *type; ret = -EPERM; /* What lack-of-symlink returns */ if (dentry->d_parent == configfs_sb->s_root) goto out; sd = dentry->d_parent->d_fsdata; /* * Fake invisibility if dir belongs to a group/default groups hierarchy * being attached */ ret = -ENOENT; if (!configfs_dirent_is_ready(sd)) goto out; parent_item = configfs_get_config_item(dentry->d_parent); type = parent_item->ci_type; ret = -EPERM; if (!type || !type->ct_item_ops || !type->ct_item_ops->allow_link) goto out_put; ret = get_target(symname, &path, &target_item); if (ret) goto out_put; ret = type->ct_item_ops->allow_link(parent_item, target_item); if (!ret) { mutex_lock(&configfs_symlink_mutex); ret = create_link(parent_item, target_item, dentry); mutex_unlock(&configfs_symlink_mutex); if (ret && type->ct_item_ops->drop_link) type->ct_item_ops->drop_link(parent_item, target_item); } config_item_put(target_item); path_put(&path); out_put: config_item_put(parent_item); out: return ret; }
int configfs_unlink(struct inode *dir, struct dentry *dentry) { struct configfs_dirent *sd = dentry->d_fsdata; struct configfs_symlink *sl; struct config_item *parent_item; struct config_item_type *type; int ret; ret = -EPERM; /* What lack-of-symlink returns */ if (!(sd->s_type & CONFIGFS_ITEM_LINK)) goto out; BUG_ON(dentry->d_parent == configfs_sb->s_root); sl = sd->s_element; parent_item = configfs_get_config_item(dentry->d_parent); type = parent_item->ci_type; spin_lock(&configfs_dirent_lock); list_del_init(&sd->s_sibling); spin_unlock(&configfs_dirent_lock); configfs_drop_dentry(sd, dentry->d_parent); dput(dentry); configfs_put(sd); /* * drop_link() must be called before * list_del_init(&sl->sl_list), so that the order of * drop_link(this, target) and drop_item(target) is preserved. */ if (type && type->ct_item_ops && type->ct_item_ops->drop_link) type->ct_item_ops->drop_link(parent_item, sl->sl_target); spin_lock(&configfs_dirent_lock); list_del_init(&sl->sl_list); spin_unlock(&configfs_dirent_lock); /* Put reference from create_link() */ config_item_put(sl->sl_target); kfree(sl); config_item_put(parent_item); ret = 0; out: return ret; }
int configfs_unlink(struct inode *dir, struct dentry *dentry) { struct configfs_dirent *sd = dentry->d_fsdata; struct configfs_symlink *sl; struct config_item *parent_item; struct config_item_type *type; int ret; ret = -EPERM; /* */ if (!(sd->s_type & CONFIGFS_ITEM_LINK)) goto out; sl = sd->s_element; parent_item = configfs_get_config_item(dentry->d_parent); type = parent_item->ci_type; spin_lock(&configfs_dirent_lock); list_del_init(&sd->s_sibling); spin_unlock(&configfs_dirent_lock); configfs_drop_dentry(sd, dentry->d_parent); dput(dentry); configfs_put(sd); /* */ if (type && type->ct_item_ops && type->ct_item_ops->drop_link) type->ct_item_ops->drop_link(parent_item, sl->sl_target); spin_lock(&configfs_dirent_lock); list_del_init(&sl->sl_list); spin_unlock(&configfs_dirent_lock); /* */ config_item_put(sl->sl_target); kfree(sl); config_item_put(parent_item); ret = 0; out: return ret; }
int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { int ret; struct path path; struct configfs_dirent *sd; struct config_item *parent_item; struct config_item *target_item = NULL; struct config_item_type *type; sd = dentry->d_parent->d_fsdata; /* */ ret = -ENOENT; if (!configfs_dirent_is_ready(sd)) goto out; parent_item = configfs_get_config_item(dentry->d_parent); type = parent_item->ci_type; ret = -EPERM; if (!type || !type->ct_item_ops || !type->ct_item_ops->allow_link) goto out_put; ret = get_target(symname, &path, &target_item, dentry->d_sb); if (ret) goto out_put; ret = type->ct_item_ops->allow_link(parent_item, target_item); if (!ret) { mutex_lock(&configfs_symlink_mutex); ret = create_link(parent_item, target_item, dentry); mutex_unlock(&configfs_symlink_mutex); if (ret && type->ct_item_ops->drop_link) type->ct_item_ops->drop_link(parent_item, target_item); } config_item_put(target_item); path_put(&path); out_put: config_item_put(parent_item); out: return ret; }
static void device_drop_group(struct config_group *group, struct config_item *item) { iio_dummy_remove(item->ci_name); printk(KERN_ALERT "device drop group called\n"); config_item_put(item); }
static int create_link(struct config_item *parent_item, struct config_item *item, struct dentry *dentry) { struct configfs_dirent *target_sd = item->ci_dentry->d_fsdata; struct configfs_symlink *sl; int ret; ret = -ENOMEM; sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL); if (sl) { sl->sl_target = config_item_get(item); /* FIXME: needs a lock, I'd bet */ list_add(&sl->sl_list, &target_sd->s_links); ret = configfs_create_link(sl, parent_item->ci_dentry, dentry); if (ret) { list_del_init(&sl->sl_list); config_item_put(item); kfree(sl); } } return ret; }
/** * dtbocfg_overlay_group_drop_item() - Drop Device Tree Overlay Group Item * @group: Pointer to Configuration Group * @item : Pointer to Device Tree Overlay Group Item */ static void dtbocfg_overlay_group_drop_item(struct config_group *group, struct config_item *item) { struct dtbocfg_overlay_item *overlay = container_of_dtbocfg_overlay_item(item); pr_debug("%s\n", __func__); config_item_put(&overlay->item); }
static void device_drop_group(struct config_group *group, struct config_item *item) { struct iio_sw_device *d = to_iio_sw_device(item); iio_sw_device_destroy(d); config_item_put(item); }
static void target_fabric_drop_tpg( struct config_group *group, struct config_item *item) { struct se_portal_group *se_tpg = container_of(to_config_group(item), struct se_portal_group, tpg_group); struct config_group *tpg_cg = &se_tpg->tpg_group; struct config_item *df_item; int i; for (i = 0; tpg_cg->default_groups[i]; i++) { df_item = &tpg_cg->default_groups[i]->cg_item; tpg_cg->default_groups[i] = NULL; config_item_put(df_item); } config_item_put(item); }
static void target_fabric_drop_wwn( struct config_group *group, struct config_item *item) { struct se_wwn *wwn = container_of(to_config_group(item), struct se_wwn, wwn_group); struct config_item *df_item; struct config_group *cg = &wwn->wwn_group; int i; for (i = 0; cg->default_groups[i]; i++) { df_item = &cg->default_groups[i]->cg_item; cg->default_groups[i] = NULL; config_item_put(df_item); } config_item_put(item); }
static void target_fabric_drop_np( struct config_group *group, struct config_item *item) { /* * struct se_tpg_np is released via target_fabric_np_base_release() */ config_item_put(item); }
static void trigger_drop_group(struct config_group *group, struct config_item *item) { struct iio_sw_trigger *t = to_iio_sw_trigger(item); printk(KERN_ALERT "Called drop_group"); iio_sw_trigger_destroy(t); config_item_put(item); }
static void target_fabric_drop_nodeacl( struct config_group *group, struct config_item *item) { struct se_node_acl *se_nacl = container_of(to_config_group(item), struct se_node_acl, acl_group); struct config_item *df_item; struct config_group *nacl_cg; int i; nacl_cg = &se_nacl->acl_group; for (i = 0; nacl_cg->default_groups[i]; i++) { df_item = &nacl_cg->default_groups[i]->cg_item; nacl_cg->default_groups[i] = NULL; config_item_put(df_item); } config_item_put(item); }
static void target_fabric_drop_tpg( struct config_group *group, struct config_item *item) { struct se_portal_group *se_tpg = container_of(to_config_group(item), struct se_portal_group, tpg_group); struct config_group *tpg_cg = &se_tpg->tpg_group; struct config_item *df_item; int i; /* * Release default groups, but do not release tpg_cg->default_groups * memory as it is statically allocated at se_tpg->tpg_default_groups. */ for (i = 0; tpg_cg->default_groups[i]; i++) { df_item = &tpg_cg->default_groups[i]->cg_item; tpg_cg->default_groups[i] = NULL; config_item_put(df_item); } config_item_put(item); }
static int create_link(struct config_item *parent_item, struct config_item *item, struct dentry *dentry) { struct configfs_dirent *target_sd = item->ci_dentry->d_fsdata; struct configfs_symlink *sl; int ret; ret = -ENOENT; if (!configfs_dirent_is_ready(target_sd)) goto out; ret = -ENOMEM; sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL); if (sl) { sl->sl_target = config_item_get(item); spin_lock(&configfs_dirent_lock); if (target_sd->s_type & CONFIGFS_USET_DROPPING) { spin_unlock(&configfs_dirent_lock); config_item_put(item); kfree(sl); return -ENOENT; } list_add(&sl->sl_list, &target_sd->s_links); spin_unlock(&configfs_dirent_lock); ret = configfs_create_link(sl, parent_item->ci_dentry, dentry); if (ret) { spin_lock(&configfs_dirent_lock); list_del_init(&sl->sl_list); spin_unlock(&configfs_dirent_lock); config_item_put(item); kfree(sl); } } out: return ret; }
int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { int ret; struct nameidata nd; struct config_item *parent_item; struct config_item *target_item; struct config_item_type *type; ret = -EPERM; /* What lack-of-symlink returns */ if (dentry->d_parent == configfs_sb->s_root) goto out; parent_item = configfs_get_config_item(dentry->d_parent); type = parent_item->ci_type; if (!type || !type->ct_item_ops || !type->ct_item_ops->allow_link) goto out_put; ret = get_target(symname, &nd, &target_item); if (ret) goto out_put; ret = type->ct_item_ops->allow_link(parent_item, target_item); if (!ret) ret = create_link(parent_item, target_item, dentry); config_item_put(target_item); path_put(&nd.path); out_put: config_item_put(parent_item); out: return ret; }
static int configfs_getlink(struct dentry *dentry, char * path) { struct config_item *item, *target_item; int error = 0; item = configfs_get_config_item(dentry->d_parent); if (!item) return -EINVAL; target_item = configfs_get_config_item(dentry); if (!target_item) { config_item_put(item); return -EINVAL; } down_read(&configfs_rename_sem); error = configfs_get_target_path(item, target_item, path); up_read(&configfs_rename_sem); config_item_put(item); config_item_put(target_item); return error; }
static int configfs_release(struct inode * inode, struct file * filp) { struct config_item * item = to_item(filp->f_dentry->d_parent); struct configfs_attribute * attr = to_attr(filp->f_dentry); struct module * owner = attr->ca_owner; struct configfs_buffer * buffer = filp->private_data; if (item) config_item_put(item); /* After this point, attr should not be accessed. */ module_put(owner); if (buffer) { if (buffer->page) free_page((unsigned long)buffer->page); kfree(buffer); } return 0; }
static int do_release(struct inode *inode, struct file *filp, struct config_item *item, struct configfs_attribute *attr, int type) { struct module *owner = attr->ca_owner; struct configfs_buffer *buffer = filp->private_data; if (item) config_item_put(item); /* After this point, attr should not be accessed. */ module_put(owner); if (buffer) { if (buffer->page) free_page((unsigned long)buffer->page); mutex_destroy(&buffer->mutex); kfree(buffer); } return 0; }
static void netconsole_target_put(struct netconsole_target *nt) { if (config_item_name(&nt->item)) config_item_put(&nt->item); }
static void target_fabric_drop_wwn( struct config_group *group, struct config_item *item) { config_item_put(item); }
void o2nm_node_put(struct o2nm_node *node) { config_item_put(&node->nd_item); }
static int check_perm(struct inode * inode, struct file * file) { struct config_item *item = configfs_get_config_item(file->f_path.dentry->d_parent); struct configfs_attribute * attr = to_attr(file->f_path.dentry); struct configfs_buffer * buffer; struct configfs_item_operations * ops = NULL; int error = 0; if (!item || !attr) goto Einval; /* Grab the module reference for this attribute if we have one */ if (!try_module_get(attr->ca_owner)) { error = -ENODEV; goto Done; } if (item->ci_type) ops = item->ci_type->ct_item_ops; else goto Eaccess; /* File needs write support. * The inode's perms must say it's ok, * and we must have a store method. */ if (file->f_mode & FMODE_WRITE) { if (!(inode->i_mode & S_IWUGO) || !ops->store_attribute) goto Eaccess; } /* File needs read support. * The inode's perms must say it's ok, and we there * must be a show method for it. */ if (file->f_mode & FMODE_READ) { if (!(inode->i_mode & S_IRUGO) || !ops->show_attribute) goto Eaccess; } /* No error? Great, allocate a buffer for the file, and store it * it in file->private_data for easy access. */ buffer = kzalloc(sizeof(struct configfs_buffer),GFP_KERNEL); if (!buffer) { error = -ENOMEM; goto Enomem; } mutex_init(&buffer->mutex); buffer->needs_read_fill = 1; buffer->ops = ops; file->private_data = buffer; goto Done; Einval: error = -EINVAL; goto Done; Eaccess: error = -EACCES; Enomem: module_put(attr->ca_owner); Done: if (error && item) config_item_put(item); return error; }