void klist_init(struct klist * k, void (*get)(struct klist_node *),
void (*put)(struct klist_node *))
{
#if defined(__VMKLNX__)
VMK_ASSERT(vmk_PreemptionIsEnabled() == VMK_FALSE);
#endif
INIT_LIST_HEAD(&k->k_list);
spin_lock_init(&k->k_lock);
#if defined(__VMKLNX__)
k->module_id = vmk_ModuleStackTop();
#endif
k->get = get;
k->put = put;
}
void mempool_kfree(void *element, void *pool_data)
{
#if defined(__VMKLNX__)
vmk_ModuleID moduleID;
vmk_HeapID heapID;
VMK_ASSERT(vmk_PreemptionIsEnabled() == VMK_FALSE);
moduleID = vmk_ModuleStackTop();
VMK_ASSERT(moduleID != VMK_VMKERNEL_MODULE_ID);
VMK_ASSERT(moduleID != vmklinuxModID);
heapID = vmk_ModuleGetHeapID(moduleID);
VMK_ASSERT(heapID != VMK_INVALID_HEAP_ID);
vmklnx_kfree(heapID, element);
#else /* !defined(__VMKLNX__) */
kfree(element);
#endif /* defined(__VMKLNX__) */
}
void *mempool_kzalloc(gfp_t gfp_mask, void *pool_data)
{
size_t size = (size_t) pool_data;
#if defined(__VMKLNX__)
vmk_ModuleID moduleID;
vmk_HeapID heapID;
moduleID = vmk_ModuleStackTop();
VMK_ASSERT(moduleID != VMK_VMKERNEL_MODULE_ID);
VMK_ASSERT(moduleID != vmklinuxModID);
heapID = vmk_ModuleGetHeapID(moduleID);
VMK_ASSERT(heapID != VMK_INVALID_HEAP_ID);
return vmklnx_kzmalloc(heapID, size, gfp_mask);
#else /* !defined(__VMKLNX__) */
return kzalloc(size, gfp_mask);
#endif /* defined(__VMKLNX__) */
}
/* _VMKLNX_CODECHECK_: bus_register */
int bus_register(struct bus_type * bus)
{
int retval;
#if defined(__VMKLNX__)
VMK_ReturnStatus status;
bus->bus_notifier.head = NULL;
status = vmk_SemaCreate(&bus->bus_notifier.rwsem,
vmk_ModuleStackTop(), bus->name, 1);
if (status != VMK_OK) {
retval = -EINVAL;
goto out;
}
#else
BLOCKING_INIT_NOTIFIER_HEAD(&bus->bus_notifier);
#endif
retval = kobject_set_name(&bus->subsys.kobj, "%s", bus->name);
if (retval)
goto out;
bus->subsys.kobj.kset = &bus_subsys;
retval = subsystem_register(&bus->subsys);
if (retval)
goto out;
retval = bus_create_file(bus, &bus_attr_uevent);
if (retval)
goto bus_uevent_fail;
kobject_set_name(&bus->devices.kobj, "devices");
bus->devices.kobj.parent = &bus->subsys.kobj;
retval = kset_register(&bus->devices);
if (retval)
goto bus_devices_fail;
kobject_set_name(&bus->drivers.kobj, "drivers");
bus->drivers.kobj.parent = &bus->subsys.kobj;
bus->drivers.ktype = &driver_ktype;
retval = kset_register(&bus->drivers);
if (retval)
goto bus_drivers_fail;
klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&bus->klist_drivers, NULL, NULL);
bus->drivers_autoprobe = 1;
retval = add_probe_files(bus);
if (retval)
goto bus_probe_files_fail;
retval = bus_add_attrs(bus);
if (retval)
goto bus_attrs_fail;
pr_debug("bus type '%s' registered\n", bus->name);
return 0;
bus_attrs_fail:
remove_probe_files(bus);
bus_probe_files_fail:
kset_unregister(&bus->drivers);
bus_drivers_fail:
kset_unregister(&bus->devices);
bus_devices_fail:
bus_remove_file(bus, &bus_attr_uevent);
bus_uevent_fail:
subsystem_unregister(&bus->subsys);
out:
return retval;
}
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;
#if defined(__VMKLNX__)
vmk_ModuleID moduleID;
vmk_HeapID heapID;
VMK_ASSERT(vmk_PreemptionIsEnabled() == VMK_FALSE);
moduleID = vmk_ModuleStackTop();
heapID = vmk_ModuleGetHeapID(moduleID);
VMK_ASSERT(heapID != VMK_INVALID_HEAP_ID);
pool = vmklnx_kmalloc(heapID,
sizeof(*pool),
GFP_KERNEL,
NULL);
#else /* !defined(__VMKLNX__) */
pool = kmalloc_node(sizeof(*pool), GFP_KERNEL, node_id);
#endif /* defined(__VMKLNX__) */
if (!pool)
return NULL;
memset(pool, 0, sizeof(*pool));
#if defined(__VMKLNX__)
pool->elements = vmklnx_kmalloc(heapID,
min_nr * sizeof(void *),
GFP_KERNEL,
NULL);
#else /* !defined(__VMKLNX__) */
pool->elements = kmalloc_node(min_nr * sizeof(void *),
GFP_KERNEL, node_id);
#endif /* defined(__VMKLNX__) */
if (!pool->elements) {
kfree(pool);
return NULL;
}
spin_lock_init(&pool->lock);
pool->min_nr = min_nr;
pool->pool_data = pool_data;
init_waitqueue_head(&pool->wait);
pool->alloc = alloc_fn;
pool->free = free_fn;
#if defined(__VMKLNX__)
pool->module_id = moduleID;
#endif /* defined(__VMKLNX__) */
/*
* First pre-allocate the guaranteed number of buffers.
*/
while (pool->curr_nr < pool->min_nr) {
void *element;
#if defined(__VMKLNX__)
VMKAPI_MODULE_CALL(pool->module_id, element, pool->alloc,
GFP_KERNEL, pool->pool_data);
#else /* !defined(__VMKLNX__) */
element = pool->alloc(GFP_KERNEL, pool->pool_data);
#endif /* defined(__VMKLNX__) */
if (unlikely(!element)) {
free_pool(pool);
return NULL;
}
add_element(pool, element);
}
return pool;
}
