/* Destroy an IDA with a single entry at @base */ static void ida_check_destroy_1(struct ida *ida, unsigned int base) { IDA_BUG_ON(ida, ida_alloc_min(ida, base, GFP_KERNEL) != base); IDA_BUG_ON(ida, ida_is_empty(ida)); ida_destroy(ida); IDA_BUG_ON(ida, !ida_is_empty(ida)); }
void tb_domain_exit(void) { bus_unregister(&tb_bus_type); ida_destroy(&tb_domain_ida); tb_switch_exit(); tb_xdomain_exit(); }
void mlx5_cleanup_reserved_gids(struct mlx5_core_dev *dev) { WARN_ON(!ida_is_empty(&dev->roce.reserved_gids.ida)); dev->roce.reserved_gids.start = 0; dev->roce.reserved_gids.count = 0; ida_destroy(&dev->roce.reserved_gids.ida); }
/*! 2017. 1.07 study -ing */ struct kernfs_root *kernfs_create_root(struct kernfs_dir_ops *kdops, void *priv) { struct kernfs_root *root; struct kernfs_node *kn; root = kzalloc(sizeof(*root), GFP_KERNEL); if (!root) return ERR_PTR(-ENOMEM); ida_init(&root->ino_ida); kn = __kernfs_new_node(root, "", S_IFDIR | S_IRUGO | S_IXUGO, KERNFS_DIR); if (!kn) { ida_destroy(&root->ino_ida); kfree(root); return ERR_PTR(-ENOMEM); } /*! 초기값 대입 */ kn->flags &= ~KERNFS_REMOVED; kn->priv = priv; kn->dir.root = root; root->dir_ops = kdops; root->kn = kn; return root; }
/** * kernfs_create_root - create a new kernfs hierarchy * @scops: optional syscall operations for the hierarchy * @flags: KERNFS_ROOT_* flags * @priv: opaque data associated with the new directory * * Returns the root of the new hierarchy on success, ERR_PTR() value on * failure. */ struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags, void *priv) { struct kernfs_root *root; struct kernfs_node *kn; root = kzalloc(sizeof(*root), GFP_KERNEL); if (!root) return ERR_PTR(-ENOMEM); ida_init(&root->ino_ida); INIT_LIST_HEAD(&root->supers); kn = __kernfs_new_node(root, "", S_IFDIR | S_IRUGO | S_IXUGO, KERNFS_DIR); if (!kn) { ida_destroy(&root->ino_ida); kfree(root); return ERR_PTR(-ENOMEM); } kn->priv = priv; kn->dir.root = root; root->syscall_ops = scops; root->flags = flags; root->kn = kn; init_waitqueue_head(&root->deactivate_waitq); if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED)) kernfs_activate(kn); return root; }
static void devpts_kill_sb(struct super_block *sb) { struct pts_fs_info *fsi = DEVPTS_SB(sb); ida_destroy(&fsi->allocated_ptys); kfree(fsi); kill_litter_super(sb); }
static void __exit bus1_exit(void) { WARN_ON(!idr_is_empty(&bus1_user_ida.idr)); WARN_ON(!idr_is_empty(&bus1_user_idr)); misc_deregister(&bus1_misc); ida_destroy(&bus1_user_ida); idr_destroy(&bus1_user_idr); }
static void free_hd(struct kref *kref) { struct greybus_host_device *hd; hd = container_of(kref, struct greybus_host_device, kref); ida_destroy(&hd->cport_id_map); kfree(hd); mutex_unlock(&hd_mutex); }
static void gb_hd_release(struct device *dev) { struct gb_host_device *hd = to_gb_host_device(dev); if (hd->svc) gb_svc_put(hd->svc); ida_simple_remove(&gb_hd_bus_id_map, hd->bus_id); ida_destroy(&hd->cport_id_map); kfree(hd); }
static int vmw_gmrid_man_takedown(struct ttm_mem_type_manager *man) { struct vmwgfx_gmrid_man *gman = (struct vmwgfx_gmrid_man *)man->priv; if (gman) { ida_destroy(&gman->gmr_ida); kfree(gman); } return 0; }
/* Check that ida_destroy and ida_is_empty work */ static void ida_check_destroy(struct ida *ida) { /* Destroy an already-empty IDA */ IDA_BUG_ON(ida, !ida_is_empty(ida)); ida_destroy(ida); IDA_BUG_ON(ida, !ida_is_empty(ida)); ida_check_destroy_1(ida, 0); ida_check_destroy_1(ida, 1); ida_check_destroy_1(ida, 1023); ida_check_destroy_1(ida, 1024); ida_check_destroy_1(ida, 12345678); }
/* * Check allocations up to and slightly above the maximum allowed (2^31-1) ID. * Allocating up to 2^31-1 should succeed, and then allocating the next one * should fail. */ static void ida_check_max(struct ida *ida) { unsigned long i, j; for (j = 1; j < 65537; j *= 2) { unsigned long base = (1UL << 31) - j; for (i = 0; i < j; i++) { IDA_BUG_ON(ida, ida_alloc_min(ida, base, GFP_KERNEL) != base + i); } IDA_BUG_ON(ida, ida_alloc_min(ida, base, GFP_KERNEL) != -ENOSPC); ida_destroy(ida); IDA_BUG_ON(ida, !ida_is_empty(ida)); } }
/* * Check what happens when we fill a leaf and then delete it. This may * discover mishandling of IDR_FREE. */ static void ida_check_leaf(struct ida *ida, unsigned int base) { unsigned long i; for (i = 0; i < IDA_BITMAP_BITS; i++) { IDA_BUG_ON(ida, ida_alloc_min(ida, base, GFP_KERNEL) != base + i); } ida_destroy(ida); IDA_BUG_ON(ida, !ida_is_empty(ida)); IDA_BUG_ON(ida, ida_alloc(ida, GFP_KERNEL) != 0); IDA_BUG_ON(ida, ida_is_empty(ida)); ida_free(ida, 0); IDA_BUG_ON(ida, !ida_is_empty(ida)); }
/** * kernfs_put - put a reference count on a kernfs_node * @kn: the target kernfs_node * * Put a reference count of @kn and destroy it if it reached zero. */ void kernfs_put(struct kernfs_node *kn) { struct kernfs_node *parent; struct kernfs_root *root; if (!kn || !atomic_dec_and_test(&kn->count)) return; root = kernfs_root(kn); repeat: /* * Moving/renaming is always done while holding reference. * kn->parent won't change beneath us. */ parent = kn->parent; WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS, "kernfs_put: %s/%s: released with incorrect active_ref %d\n", parent ? parent->name : "", kn->name, atomic_read(&kn->active)); if (kernfs_type(kn) == KERNFS_LINK) kernfs_put(kn->symlink.target_kn); kfree_const(kn->name); if (kn->iattr) { if (kn->iattr->ia_secdata) security_release_secctx(kn->iattr->ia_secdata, kn->iattr->ia_secdata_len); simple_xattrs_free(&kn->iattr->xattrs); } kfree(kn->iattr); ida_simple_remove(&root->ino_ida, kn->ino); kmem_cache_free(kernfs_node_cache, kn); kn = parent; if (kn) { if (atomic_dec_and_test(&kn->count)) goto repeat; } else { /* just released the root kn, free @root too */ ida_destroy(&root->ino_ida); kfree(root); } }
int henry_drv_remove(struct see_client *clnt) { struct henry_drv *drv = dev_get_drvdata(&clnt->dev); henry_sysfs_remove(drv); henry_dbgfs_remove(drv); mutex_destroy(&drv->mutex); ida_destroy(&drv->sess_ida); unregister_chrdev_region(drv->dev_num, 1); device_destroy(drv->dev_class, drv->dev_num); cdev_del(&drv->cdev); class_destroy(drv->dev_class); kfree(drv); dev_info(&clnt->dev, "HENRY driver removed\n"); return 0; }
/*! 2017. 3.18 study -ing */ void kernfs_put(struct kernfs_node *kn) { struct kernfs_node *parent; struct kernfs_root *root; if (!kn || !atomic_dec_and_test(&kn->count)) return; root = kernfs_root(kn); repeat: /* Moving/renaming is always done while holding reference. * kn->parent won't change beneath us. */ parent = kn->parent; WARN(!(kn->flags & KERNFS_REMOVED), "kernfs: free using entry: %s/%s\n", parent ? parent->name : "", kn->name); if (kernfs_type(kn) == KERNFS_LINK) kernfs_put(kn->symlink.target_kn); if (!(kn->flags & KERNFS_STATIC_NAME)) kfree(kn->name); if (kn->iattr) { if (kn->iattr->ia_secdata) /*! Do Nothing */ security_release_secctx(kn->iattr->ia_secdata, kn->iattr->ia_secdata_len); simple_xattrs_free(&kn->iattr->xattrs); } kfree(kn->iattr); ida_simple_remove(&root->ino_ida, kn->ino); kmem_cache_free(kernfs_node_cache, kn); kn = parent; if (kn) { if (atomic_dec_and_test(&kn->count)) goto repeat; } else { /* just released the root kn, free @root too */ ida_destroy(&root->ino_ida); kfree(root); } }
/* * Straightforward checks that allocating and freeing IDs work. */ static void ida_check_alloc(struct ida *ida) { int i, id; for (i = 0; i < 10000; i++) IDA_BUG_ON(ida, ida_alloc(ida, GFP_KERNEL) != i); ida_free(ida, 20); ida_free(ida, 21); for (i = 0; i < 3; i++) { id = ida_alloc(ida, GFP_KERNEL); IDA_BUG_ON(ida, id < 0); if (i == 2) IDA_BUG_ON(ida, id != 10000); } for (i = 0; i < 5000; i++) ida_free(ida, i); IDA_BUG_ON(ida, ida_alloc_min(ida, 5000, GFP_KERNEL) != 10001); ida_destroy(ida); IDA_BUG_ON(ida, !ida_is_empty(ida)); }
void __exit nvdimm_devs_exit(void) { ida_destroy(&dimm_ida); }
static __exit void gb_vibrator_exit(void) { greybus_deregister(&gb_vibrator_driver); class_unregister(&vibrator_class); ida_destroy(&minors); }
static void __exit ptp_exit(void) { class_destroy(ptp_class); unregister_chrdev_region(ptp_devt, MINORMASK + 1); ida_destroy(&ptp_clocks_map); }
static void __exit virtio_exit(void) { bus_unregister(&virtio_bus); ida_destroy(&virtio_index_ida); }
void nouveau_backlight_dtor(void) { ida_destroy(&bl_ida); }
void gb_hd_exit(void) { ida_destroy(&gb_hd_bus_id_map); }
static void __exit ipack_exit(void) { bus_unregister(&ipack_bus_type); ida_destroy(&ipack_ida); }
static void __exit kp2000_pcie_exit(void) { pci_unregister_driver(&kp2000_driver_inst); class_destroy(kpc_uio_class); ida_destroy(&card_num_ida); }
static void __exit watchdog_exit(void) { watchdog_dev_exit(); class_destroy(watchdog_class); ida_destroy(&watchdog_ida); }
static void __exit w1_ds2760_exit(void) { w1_unregister_family(&w1_ds2760_family); ida_destroy(&bat_ida); }
static void mcb_exit(void) { ida_destroy(&mcb_ida); bus_unregister(&mcb_bus_type); }