/*
*函数名称：public_destroy
*函数功能：public module destroy
*输入参数：none
*输出参数：none
*返回值： none
*/
void public_destroy()
{
INFO_PRINT("\n----->Public模块释放..........\n");
log_destroy();
mempool_destroy();
//计数器
global_shared.retain_count --;
}
static void fscrypt_destroy(void)
{
struct fscrypt_ctx *pos, *n;
list_for_each_entry_safe(pos, n, &fscrypt_free_ctxs, free_list)
kmem_cache_free(fscrypt_ctx_cachep, pos);
INIT_LIST_HEAD(&fscrypt_free_ctxs);
mempool_destroy(fscrypt_bounce_page_pool);
fscrypt_bounce_page_pool = NULL;
}
void regfree(regex_t *rx)
{
struct RegexInt *rxi;
if (rx) {
rxi = rx->internal;
if (rxi)
mempool_destroy(&rxi->pool);
memset(rx, 0, sizeof(*rx));
}
}
void cleanup_mod(void)
{
printk("\n Module removed");
mempool_free(ptr,mem);
mempool_destroy(mem);
//kmem_cache_free(cache_ptr,ret);
kmem_cache_destroy(cache_ptr);
//mempool_free(ptr,mem);
}
void server_do()
{
recvbuf_pool = mempool_create("RECVBUF", recvbuf_size, 0);
if(network_tcp_register(&sa, onaccept_proc, NULL)!=ERR_NOERROR) {
printf("Failed to network_tcp_register.\n");
exit(0);
}
getchar();
network_tcp_unregister(&sa);
mempool_destroy(recvbuf_pool);
}
static void deadline_exit_queue(elevator_t *e)
{
struct deadline_data *dd = e->elevator_data;
BUG_ON(!list_empty(&dd->fifo_list[READ]));
BUG_ON(!list_empty(&dd->fifo_list[WRITE]));
mempool_destroy(dd->drq_pool);
kfree(dd->hash);
kfree(dd);
}
void diagmem_exit(struct diagchar_dev *driver)
{
if (driver->diagpool) {
if (driver->count == 0 && driver->ref_count == 0) {
mempool_destroy(driver->diagpool);
driver->diagpool = NULL;
}
} else
printk(KERN_ALERT "\n Attempt to free up"
"non existing COPY pool");
if (driver->diag_hdlc_pool) {
if (driver->count_hdlc_pool == 0 && driver->ref_count == 0) {
mempool_destroy(driver->diag_hdlc_pool);
driver->diag_hdlc_pool = NULL;
}
} else
printk(KERN_ALERT "\n Attempt to free up"
"non existing HDLC pool");
}
void Stream5CleanUdp(void)
{
if ( udp_lws_cache )
s5stats.udp_prunes = udp_lws_cache->prunes;
/* Clean up hash table -- delete all sessions */
DeleteLWSessionCache(udp_lws_cache);
udp_lws_cache = NULL;
mempool_destroy(&udp_session_mempool);
}
void Stream5CleanIcmp(void)
{
if ( icmp_lws_cache )
s5stats.icmp_prunes = icmp_lws_cache->prunes;
/* Clean up hash table -- delete all sessions */
DeleteLWSessionCache(icmp_lws_cache);
icmp_lws_cache = NULL;
mempool_destroy(&icmp_session_mempool);
}
/* alloc_disk and add_disk can sleep */
void
aoeblk_gdalloc(void *vp)
{
struct aoedev *d = vp;
struct gendisk *gd;
ulong flags;
gd = alloc_disk(AOE_PARTITIONS);
if (gd == NULL) {
printk(KERN_ERR
"aoe: cannot allocate disk structure for %ld.%d\n",
d->aoemajor, d->aoeminor);
goto err;
}
d->bufpool = mempool_create_slab_pool(MIN_BUFS, buf_pool_cache);
if (d->bufpool == NULL) {
printk(KERN_ERR "aoe: cannot allocate bufpool for %ld.%d\n",
d->aoemajor, d->aoeminor);
goto err_disk;
}
blk_queue_make_request(&d->blkq, aoeblk_make_request);
if (bdi_init(&d->blkq.backing_dev_info))
goto err_mempool;
spin_lock_irqsave(&d->lock, flags);
gd->major = AOE_MAJOR;
gd->first_minor = d->sysminor * AOE_PARTITIONS;
gd->fops = &aoe_bdops;
gd->private_data = d;
gd->capacity = d->ssize;
snprintf(gd->disk_name, sizeof gd->disk_name, "etherd/e%ld.%d",
d->aoemajor, d->aoeminor);
gd->queue = &d->blkq;
d->gd = gd;
d->flags &= ~DEVFL_GDALLOC;
d->flags |= DEVFL_UP;
spin_unlock_irqrestore(&d->lock, flags);
add_disk(gd);
aoedisk_add_sysfs(d);
return;
err_mempool:
mempool_destroy(d->bufpool);
err_disk:
put_disk(gd);
err:
spin_lock_irqsave(&d->lock, flags);
d->flags &= ~DEVFL_GDALLOC;
spin_unlock_irqrestore(&d->lock, flags);
}
static void
cifs_destroy_mids(void)
{
mempool_destroy(cifs_mid_poolp);
if (kmem_cache_destroy(cifs_mid_cachep))
printk(KERN_WARNING
"cifs_destroy_mids: error not all structures were freed\n");
if (kmem_cache_destroy(cifs_oplock_cachep))
printk(KERN_WARNING
"error not all oplock structures were freed\n");
}
static void free_dev(struct mapped_device *md)
{
int minor = md->disk->first_minor;
if (md->suspended_bdev) {
thaw_bdev(md->suspended_bdev, NULL);
bdput(md->suspended_bdev);
}
mempool_destroy(md->tio_pool);
mempool_destroy(md->io_pool);
del_gendisk(md->disk);
free_minor(minor);
spin_lock(&_minor_lock);
md->disk->private_data = NULL;
spin_unlock(&_minor_lock);
put_disk(md->disk);
blk_cleanup_queue(md->queue);
module_put(THIS_MODULE);
kfree(md);
}
static void
aoedev_freedev(struct aoedev *d)
{
if (d->gd) {
aoedisk_rm_sysfs(d);
del_gendisk(d->gd);
put_disk(d->gd);
}
kfree(d->frames);
if (d->bufpool)
mempool_destroy(d->bufpool);
kfree(d);
}
void __exit mempool_kzalloc_exit(void)
{
if( element )
{
mempool_kfree(element, pool_data); //释放内存元素空间
printk("<0>mempool_kfree scessfully!\n");
}
if( pool )
{
mempool_destroy(pool); //销毁创建的内存池
printk("<0>mempool_destroy scessfully!\n");
}
printk("<0>exit!\n");
}
void __exit mempool_create_exit(void)
{
if(pool != NULL)
{
mempool_destroy(pool); //销毁创建的内存池
printk("<0>mempool_destroy succeed!\n");
}
if(kmem != NULL)
{
kmem_cache_destroy(kmem); //销毁创建的slab缓存
printk("<0>kmem_cache_destroy succeed!\n");
}
printk("<0>exit!\n");
}
static void DNP3CleanExit(int signal, void *data)
{
if (dnp3_context_id != NULL)
{
DNP3FreeConfig(dnp3_context_id);
dnp3_context_id = NULL;
}
if ((dnp3_mempool) && (mempool_destroy(dnp3_mempool) == 0))
{
free(dnp3_mempool);
dnp3_mempool = 0;
}
}
static int resize_pool(unsigned int new_ios)
{
int r = 0;
if (_io_pool) {
if (new_ios == 0) {
/* free off the pool */
mempool_destroy(_io_pool);
_io_pool = NULL;
bioset_free(_bios);
_bios = NULL;
} else {
/* resize the pool */
r = mempool_resize(_io_pool, new_ios, GFP_KERNEL);
}
} else {
/* create new pool */
_io_pool = mempool_create(new_ios, alloc_io, free_io, NULL);
if (!_io_pool)
return -ENOMEM;
_bios = bioset_create(16, 16, 4);
if (!_bios) {
mempool_destroy(_io_pool);
_io_pool = NULL;
return -ENOMEM;
}
}
if (!r)
_num_ios = new_ios;
return r;
}
mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
mempool_free_t *free_fn, void *pool_data,
int node_id)
{
mempool_t *pool;
pool = __mempool_create(min_nr, alloc_fn, free_fn, pool_data, node_id,
sizeof(*pool));
/* Pre-allocate the guaranteed number of buffers */
if (mempool_fill(pool, GFP_KERNEL)) {
mempool_destroy(pool);
return NULL;
}
return pool;
}
static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
{
if (adapter->pool.erp_req)
mempool_destroy(adapter->pool.erp_req);
if (adapter->pool.scsi_req)
mempool_destroy(adapter->pool.scsi_req);
if (adapter->pool.scsi_abort)
mempool_destroy(adapter->pool.scsi_abort);
if (adapter->pool.qtcb_pool)
mempool_destroy(adapter->pool.qtcb_pool);
if (adapter->pool.status_read_req)
mempool_destroy(adapter->pool.status_read_req);
if (adapter->pool.sr_data)
mempool_destroy(adapter->pool.sr_data);
if (adapter->pool.gid_pn)
mempool_destroy(adapter->pool.gid_pn);
}
/**
* blk_cleanup_queue: - release a &struct request_queue when it is no longer needed
* @kobj: the kobj belonging of the request queue to be released
*
* Description:
* blk_cleanup_queue is the pair to blk_init_queue() or
* blk_queue_make_request(). It should be called when a request queue is
* being released; typically when a block device is being de-registered.
* Currently, its primary task it to free all the &struct request
* structures that were allocated to the queue and the queue itself.
*
* Caveat:
* Hopefully the low level driver will have finished any
* outstanding requests first...
**/
static void blk_release_queue(struct kobject *kobj)
{
struct request_queue *q =
container_of(kobj, struct request_queue, kobj);
struct request_list *rl = &q->rq;
blk_sync_queue(q);
if (rl->rq_pool)
mempool_destroy(rl->rq_pool);
if (q->queue_tags)
__blk_queue_free_tags(q);
blk_trace_shutdown(q);
bdi_destroy(&q->backing_dev_info);
kmem_cache_free(blk_requestq_cachep, q);
}
int DAL_MessageRelease(void)
{
dal_msg_control_t* p_control = &g_dal_msg_contaol;
int iret = 0;
if( !(p_control->init) )
{
DAL_ERROR(("not init\n"));
return -1;
}
iret = mempool_destroy( &(p_control->msg_pool));
if( 0 != iret)
{
DAL_ERROR(("mempool_destroy failed\n"));
return -1;
}
p_control->init = FALSE;
return 0;
}
static void
aoedev_freedev(struct aoedev *d)
{
struct aoetgt **t, **e;
if (d->gd) {
aoedisk_rm_sysfs(d);
del_gendisk(d->gd);
put_disk(d->gd);
}
t = d->targets;
e = t + NTARGETS;
for (; t < e && *t; t++)
freetgt(d, *t);
if (d->bufpool)
mempool_destroy(d->bufpool);
skbpoolfree(d);
kfree(d);
}
static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
{
/* zfcp_data.config_mutex must be held */
if (adapter->pool.erp_req)
mempool_destroy(adapter->pool.erp_req);
if (adapter->pool.scsi_req)
mempool_destroy(adapter->pool.scsi_req);
if (adapter->pool.scsi_abort)
mempool_destroy(adapter->pool.scsi_abort);
if (adapter->pool.qtcb_pool)
mempool_destroy(adapter->pool.qtcb_pool);
if (adapter->pool.status_read_req)
mempool_destroy(adapter->pool.status_read_req);
if (adapter->pool.status_read_data)
mempool_destroy(adapter->pool.status_read_data);
if (adapter->pool.gid_pn_data)
mempool_destroy(adapter->pool.gid_pn_data);
}
/**
* ext4_exit_crypto() - Shutdown the ext4 encryption system
*/
void ext4_exit_crypto(void)
{
struct ext4_crypto_ctx *pos, *n;
list_for_each_entry_safe(pos, n, &ext4_free_crypto_ctxs, free_list)
kmem_cache_free(ext4_crypto_ctx_cachep, pos);
INIT_LIST_HEAD(&ext4_free_crypto_ctxs);
if (ext4_bounce_page_pool)
mempool_destroy(ext4_bounce_page_pool);
ext4_bounce_page_pool = NULL;
if (ext4_read_workqueue)
destroy_workqueue(ext4_read_workqueue);
ext4_read_workqueue = NULL;
if (ext4_crypto_ctx_cachep)
kmem_cache_destroy(ext4_crypto_ctx_cachep);
ext4_crypto_ctx_cachep = NULL;
if (ext4_crypt_info_cachep)
kmem_cache_destroy(ext4_crypt_info_cachep);
ext4_crypt_info_cachep = NULL;
}
void
mempool_basic()
{
int i;
header();
mempool_create(&pool, &cache, objsize);
for (i = 0; i < ITERATIONS_MAX; i++) {
basic_alloc_streak();
allocating = ! allocating;
#if 0
printf("%zu %zu\n", mempool_used(&pool),
mempool_total(&pool));
#endif
}
mempool_destroy(&pool);
footer();
}
main ()
{
mempool_t *pool;
char *test;
int i;
pool = mempool_create(NULL, 10, 10);
printf("Testing mempool\n");
for (i = 0; i < 10000000; i++) {
test = (char *)mempool_get_chunk(pool);
mempool_free_chunk(pool, test);
}
mempool_destroy(pool);
printf("Testing malloc\n");
for (i = 0; i < 10000000; i++) {
test = (char *)malloc(10);
free(test);
}
return(0);
}
static void
aoedev_freedev(struct aoedev *d)
{
struct aoetgt **t, **e;
cancel_work_sync(&d->work);
if (d->gd) {
aoedisk_rm_sysfs(d);
del_gendisk(d->gd);
put_disk(d->gd);
}
t = d->targets;
e = t + NTARGETS;
for (; t < e && *t; t++)
freetgt(d, *t);
if (d->bufpool)
mempool_destroy(d->bufpool);
skbpoolfree(d);
blk_cleanup_queue(d->blkq);
kfree(d);
}
static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
{
/* zfcp_data.config_sema must be held */
if (adapter->pool.fsf_req_erp)
mempool_destroy(adapter->pool.fsf_req_erp);
if (adapter->pool.fsf_req_scsi)
mempool_destroy(adapter->pool.fsf_req_scsi);
if (adapter->pool.fsf_req_abort)
mempool_destroy(adapter->pool.fsf_req_abort);
if (adapter->pool.fsf_req_status_read)
mempool_destroy(adapter->pool.fsf_req_status_read);
if (adapter->pool.data_status_read)
mempool_destroy(adapter->pool.data_status_read);
if (adapter->pool.data_gid_pn)
mempool_destroy(adapter->pool.data_gid_pn);
}
static void __exit exit_gfs2_fs(void)
{
unregister_shrinker(&qd_shrinker);
gfs2_glock_exit();
gfs2_unregister_debugfs();
unregister_filesystem(&gfs2_fs_type);
unregister_filesystem(&gfs2meta_fs_type);
destroy_workqueue(gfs_recovery_wq);
destroy_workqueue(gfs2_control_wq);
rcu_barrier();
mempool_destroy(gfs2_bh_pool);
kmem_cache_destroy(gfs2_quotad_cachep);
kmem_cache_destroy(gfs2_rgrpd_cachep);
kmem_cache_destroy(gfs2_bufdata_cachep);
kmem_cache_destroy(gfs2_inode_cachep);
kmem_cache_destroy(gfs2_glock_aspace_cachep);
kmem_cache_destroy(gfs2_glock_cachep);
gfs2_sys_uninit();
}
static void
freedev(struct aoedev *d)
{
struct aoetgt **t, **e;
int freeing = 0;
unsigned long flags;
spin_lock_irqsave(&d->lock, flags);
if (d->flags & DEVFL_TKILL
&& !(d->flags & DEVFL_FREEING)) {
d->flags |= DEVFL_FREEING;
freeing = 1;
}
spin_unlock_irqrestore(&d->lock, flags);
if (!freeing)
return;
del_timer_sync(&d->timer);
aoedbg_undbg(d);
if (d->gd) {
aoedisk_rm_debugfs(d);
aoedisk_rm_sysfs(d);
del_gendisk(d->gd);
put_disk(d->gd);
blk_cleanup_queue(d->blkq);
}
t = d->targets;
e = t + d->ntargets;
for (; t < e && *t; t++)
freetgt(d, *t);
if (d->bufpool)
mempool_destroy(d->bufpool);
skbpoolfree(d);
minor_free(d->sysminor);
spin_lock_irqsave(&d->lock, flags);
d->flags |= DEVFL_FREED;
spin_unlock_irqrestore(&d->lock, flags);
}