void diagmem_init(struct diagchar_dev *driver)
{
mutex_init(&driver->diagmem_mutex);
if (driver->count == 0)
driver->diagpool = mempool_create_kmalloc_pool(
driver->poolsize, driver->itemsize);
if (driver->count_hdlc_pool == 0)
driver->diag_hdlc_pool = mempool_create_kmalloc_pool(
driver->poolsize_hdlc, driver->itemsize_hdlc);
if (driver->count_write_struct_pool == 0)
driver->diag_write_struct_pool = mempool_create_kmalloc_pool(
driver->poolsize_write_struct, driver->itemsize_write_struct);
if (!driver->diagpool)
printk(KERN_INFO "Cannot allocate diag mempool¥n");
if (!driver->diag_hdlc_pool)
printk(KERN_INFO "Cannot allocate diag HDLC mempool¥n");
if (!driver->diag_write_struct_pool)
printk(KERN_INFO "Cannot allocate diag USB struct mempool¥n");
}
void diagmem_init(struct diagchar_dev *driver)
{
mutex_init(&driver->diagmem_mutex);
if (driver->count == 0)
driver->diagpool = mempool_create_kmalloc_pool(
driver->poolsize, driver->itemsize);
if (driver->count_hdlc_pool == 0)
driver->diag_hdlc_pool = mempool_create_kmalloc_pool(
driver->poolsize_hdlc, driver->itemsize_hdlc);
if (driver->count_user_pool == 0)
driver->diag_user_pool = mempool_create_kmalloc_pool(
driver->poolsize_user, driver->itemsize_user);
if (driver->count_write_struct_pool == 0)
driver->diag_write_struct_pool = mempool_create_kmalloc_pool(
driver->poolsize_write_struct, driver->itemsize_write_struct);
if (!driver->diagpool)
pr_err("diag: Cannot allocate diag mempool\n");
if (!driver->diag_hdlc_pool)
pr_err("diag: Cannot allocate diag HDLC mempool\n");
if (!driver->diag_user_pool)
pr_err("diag: Cannot allocate diag USER mempool\n");
if (!driver->diag_write_struct_pool)
pr_err("diag: Cannot allocate diag USB struct mempool\n");
}
void diagmem_hsic_init(int index)
{
if (index < 0 || index >= MAX_HSIC_CH) {
pr_err("diag: Invalid hsic index in %s\n", __func__);
return;
}
if (diag_hsic[index].count_hsic_pool == 0) {
diag_hsic[index].diag_hsic_pool = mempool_create_kmalloc_pool(
diag_hsic[index].poolsize_hsic,
diag_hsic[index].itemsize_hsic);
diag_pools_array[POOL_HSIC_IDX + index] =
diag_hsic[index].diag_hsic_pool;
}
if (diag_hsic[index].count_hsic_write_pool == 0) {
diag_hsic[index].diag_hsic_write_pool =
mempool_create_kmalloc_pool(
diag_hsic[index].poolsize_hsic_write,
diag_hsic[index].itemsize_hsic_write);
diag_pools_array[POOL_HSIC_WRITE_IDX + index] =
diag_hsic[index].diag_hsic_write_pool;
}
if (!diag_hsic[index].diag_hsic_pool)
pr_err("Cannot allocate diag HSIC mempool for ch %d\n", index);
if (!diag_hsic[index].diag_hsic_write_pool)
pr_err("Cannot allocate diag HSIC struct mempool for ch %d\n",
index);
}
void diagmem_init(struct diagchar_dev *driver)
{
mutex_init(&driver->diagmem_mutex);
driver->diagpool = mempool_create_kmalloc_pool(driver->poolsize,
driver->itemsize);
driver->diag_hdlc_pool = mempool_create_kmalloc_pool(
driver->poolsize_hdlc, driver->itemsize_hdlc);
if (!driver->diagpool)
printk(KERN_INFO "Cannot allocate diag mempool\n");
if (!driver->diag_hdlc_pool)
printk(KERN_INFO "Cannot allocate diag HDLC mempool\n");
}
/*
* Create/destroy dm memory cache client resources.
*/
struct dm_mem_cache_client *
dm_mem_cache_client_create(unsigned objects, unsigned chunks,
unsigned pages_per_chunk)
{
unsigned total_pages = objects * chunks * pages_per_chunk;
struct dm_mem_cache_client *client;
BUG_ON(!total_pages);
client = kzalloc(sizeof(*client), GFP_KERNEL);
if (!client)
return ERR_PTR(-ENOMEM);
client->objs_pool = mempool_create_kmalloc_pool(objects,
chunks * sizeof(struct dm_mem_cache_object));
if (!client->objs_pool)
goto err;
client->free_list = alloc_cache_pages(total_pages);
if (!client->free_list)
goto err1;
spin_lock_init(&client->lock);
client->objects = objects;
client->chunks = chunks;
client->pages_per_chunk = pages_per_chunk;
client->free_pages = client->total_pages = total_pages;
return client;
err1:
mempool_destroy(client->objs_pool);
err:
kfree(client);
return ERR_PTR(-ENOMEM);
}
void diagmem_init(struct diagchar_dev *driver, int index)
{
struct diag_mempool_t *mempool = NULL;
if (!driver)
return;
if (index < 0 || index >= NUM_MEMORY_POOLS) {
pr_err("diag: In %s, Invalid index %d\n", __func__, index);
return;
}
mempool = &diag_mempools[index];
if (mempool->pool) {
pr_debug("diag: mempool %s is already initialized\n",
mempool->name);
return;
}
if (mempool->itemsize <= 0 || mempool->poolsize <= 0) {
pr_err("diag: Unable to initialize %s mempool, itemsize: %d poolsize: %d\n",
mempool->name, mempool->itemsize,
mempool->poolsize);
return;
}
mempool->pool = mempool_create_kmalloc_pool(mempool->poolsize,
mempool->itemsize);
if (!mempool->pool)
pr_err("diag: cannot allocate %s mempool\n", mempool->name);
else
kmemleak_not_leak(mempool->pool);
spin_lock_init(&mempool->lock);
}
static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
{
/* must only be called with zfcp_data.config_mutex taken */
adapter->pool.erp_req =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.erp_req)
return -ENOMEM;
adapter->pool.gid_pn_req =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.gid_pn_req)
return -ENOMEM;
adapter->pool.scsi_req =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.scsi_req)
return -ENOMEM;
adapter->pool.scsi_abort =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.scsi_abort)
return -ENOMEM;
adapter->pool.status_read_req =
mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM,
sizeof(struct zfcp_fsf_req));
if (!adapter->pool.status_read_req)
return -ENOMEM;
adapter->pool.qtcb_pool =
mempool_create_slab_pool(4, zfcp_data.qtcb_cache);
if (!adapter->pool.qtcb_pool)
return -ENOMEM;
adapter->pool.status_read_data =
mempool_create_slab_pool(FSF_STATUS_READS_RECOM,
zfcp_data.sr_buffer_cache);
if (!adapter->pool.status_read_data)
return -ENOMEM;
adapter->pool.gid_pn_data =
mempool_create_slab_pool(1, zfcp_data.gid_pn_cache);
if (!adapter->pool.gid_pn_data)
return -ENOMEM;
return 0;
}
static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
{
adapter->pool.erp_req =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.erp_req)
return -ENOMEM;
adapter->pool.gid_pn_req =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.gid_pn_req)
return -ENOMEM;
adapter->pool.scsi_req =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.scsi_req)
return -ENOMEM;
adapter->pool.scsi_abort =
mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
if (!adapter->pool.scsi_abort)
return -ENOMEM;
adapter->pool.status_read_req =
mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM,
sizeof(struct zfcp_fsf_req));
if (!adapter->pool.status_read_req)
return -ENOMEM;
adapter->pool.qtcb_pool =
mempool_create_slab_pool(4, zfcp_fsf_qtcb_cache);
if (!adapter->pool.qtcb_pool)
return -ENOMEM;
BUILD_BUG_ON(sizeof(struct fsf_status_read_buffer) > PAGE_SIZE);
adapter->pool.sr_data =
mempool_create_page_pool(FSF_STATUS_READS_RECOM, 0);
if (!adapter->pool.sr_data)
return -ENOMEM;
adapter->pool.gid_pn =
mempool_create_slab_pool(1, zfcp_fc_req_cache);
if (!adapter->pool.gid_pn)
return -ENOMEM;
return 0;
}
void diagmem_init(struct diagchar_dev *driver)
{
spin_lock_init(&driver->diag_mem_lock);
if (driver->count == 0) {
driver->diagpool = mempool_create_kmalloc_pool(
driver->poolsize, driver->itemsize);
diag_pools_array[POOL_COPY_IDX] = driver->diagpool;
}
if (driver->count_hdlc_pool == 0) {
driver->diag_hdlc_pool = mempool_create_kmalloc_pool(
driver->poolsize_hdlc, driver->itemsize_hdlc);
diag_pools_array[POOL_HDLC_IDX] = driver->diag_hdlc_pool;
}
if (driver->count_user_pool == 0) {
driver->diag_user_pool = mempool_create_kmalloc_pool(
driver->poolsize_user, driver->itemsize_user);
diag_pools_array[POOL_USER_IDX] = driver->diag_user_pool;
}
if (driver->count_write_struct_pool == 0) {
driver->diag_write_struct_pool = mempool_create_kmalloc_pool(
driver->poolsize_write_struct, driver->itemsize_write_struct);
diag_pools_array[POOL_WRITE_STRUCT_IDX] =
driver->diag_write_struct_pool;
}
if (!driver->diagpool)
pr_err("diag: Cannot allocate diag mempool\n");
if (!driver->diag_hdlc_pool)
pr_err("diag: Cannot allocate diag HDLC mempool\n");
if (!driver->diag_user_pool)
pr_err("diag: Cannot allocate diag USER mempool\n");
if (!driver->diag_write_struct_pool)
pr_err("diag: Cannot allocate diag USB struct mempool\n");
}
void diagmem_hsic_init(int index)
{
if (diag_hsic[index].count_hsic_pool == 0)
diag_hsic[index].diag_hsic_pool = mempool_create_kmalloc_pool(
diag_hsic[index].poolsize_hsic,
diag_hsic[index].itemsize_hsic);
if (diag_hsic[index].count_hsic_write_pool == 0)
diag_hsic[index].diag_hsic_write_pool =
mempool_create_kmalloc_pool(
diag_hsic[index].poolsize_hsic_write,
diag_hsic[index].itemsize_hsic_write);
if (!diag_hsic[index].diag_hsic_pool)
pr_err("Cannot allocate diag HSIC mempool for ch %d\n", index);
if (!diag_hsic[index].diag_hsic_write_pool)
pr_err("Cannot allocate diag HSIC struct mempool for ch %d\n",
index);
}
mempool_t *pool_create( void ) {
switch( mode ) {
case 0:
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
cache = kmem_cache_create( SLABNAME, size, 0, SLAB_HWCACHE_ALIGN, NULL, NULL );
#else
cache = kmem_cache_create( SLABNAME, size, 0, SLAB_HWCACHE_ALIGN, NULL );
#endif
if( !cache ) {
printk( KERN_ERR "cache create error\n" );
return NULL;
}
return mempool_create_slab_pool( POOL_MINIMUM, cache );
case 1:
return mempool_create_kmalloc_pool( POOL_MINIMUM, size );
}
return NULL;
}
static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
{
/* must only be called with zfcp_data.config_sema taken */
adapter->pool.fsf_req_erp =
mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache);
if (!adapter->pool.fsf_req_erp)
return -ENOMEM;
adapter->pool.fsf_req_scsi =
mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache);
if (!adapter->pool.fsf_req_scsi)
return -ENOMEM;
adapter->pool.fsf_req_abort =
mempool_create_slab_pool(1, zfcp_data.fsf_req_qtcb_cache);
if (!adapter->pool.fsf_req_abort)
return -ENOMEM;
adapter->pool.fsf_req_status_read =
mempool_create_kmalloc_pool(FSF_STATUS_READS_RECOM,
sizeof(struct zfcp_fsf_req));
if (!adapter->pool.fsf_req_status_read)
return -ENOMEM;
adapter->pool.data_status_read =
mempool_create_slab_pool(FSF_STATUS_READS_RECOM,
zfcp_data.sr_buffer_cache);
if (!adapter->pool.data_status_read)
return -ENOMEM;
adapter->pool.data_gid_pn =
mempool_create_slab_pool(1, zfcp_data.gid_pn_cache);
if (!adapter->pool.data_gid_pn)
return -ENOMEM;
return 0;
}
int __init rpc_init_authunix(void)
{
unix_pool = mempool_create_kmalloc_pool(16, sizeof(struct rpc_cred));
return unix_pool ? 0 : -ENOMEM;
}
