ctor
new = kmem_cache_create(name, table_size, align, 0, ctor(shift));
void (*ctor)(void *) = get_dtl_cache_ctor();
DISPATCH_LOG_BYTES, 0, 0, DISPATCH_LOG_BYTES, ctor);
int (*ctor)(struct nvkm_device *, enum nvkm_subdev_type, int inst, data **); \
int (*ctor)(struct nvkm_device *, const struct nvkm_oclass *,
int (*ctor)(const struct nvkm_oclass *, void *data, u32 size,
int (*ctor)(const struct nvkm_oclass *, void *data, u32 size,
return client->gsp->rm->api->device->ctor(client, device);
return rm->api->device->event.ctor(device, handle, id, func, event);
.ctor = nvkm_uclient_new,
return oclass->base.ctor(oclass, data, size, pobject);
oclass->ctor = nvkm_client_child_new;
ret = oclass.ctor(&oclass, data, size, &object);
oclass->ctor = nvkm_uevent_new;
ret = device->chip->ptr.ctor(device, (type), -1, &device->ptr); \
ret = device->chip->ptr.ctor(device, (type), (j), &device->ptr[j]); \
.ctor = nvkm_control_new,
return sclass->ctor(udev->device, oclass, data, size, pobject);
oclass->ctor = nvkm_udevice_child_new;
.ctor = nvkm_udevice_new,
.ctor = nvkm_disp_class_new,
sclass->ctor = nvkm_disp_chan_child_new;
for (i = 0; disp->func->user[i].ctor; i++) {
ret = sclass->ctor(device, oclass, argv, argc, &object->oproxy.object);
int (*ctor)(const struct nvkm_oclass *, void *argv, u32 argc,
sclass->ctor = nvkm_uconn_new;
sclass->ctor = nvkm_uoutp_new;
sclass->ctor = nvkm_uhead_new;
if (disp->func->user[index].ctor) {
sclass->ctor = disp->func->user[index].ctor;
.ctor = nvkm_dma_oclass_new,
.ctor = nvkm_fifo_class_new,
if (ret == 0 && engn->func->ctor)
ret = engn->func->ctor(engn, vctx);
.ctor = gk104_ectx_ctor,
.ctor = gv100_ectx_ce_ctor,
.ctor = gf100_ectx_ctor,
.ctor = gk104_ectx_ctor,
.ctor = gk104_ectx_ctor,
.ctor = gv100_ectx_ce_ctor,
int (*ctor)(struct nvkm_engn *, struct nvkm_vctx *);
oclass->ctor = nvkm_ucgrp_chan_new;
ret = oclass->base.ctor(&(const struct nvkm_oclass) {
if (!oclass->base.ctor)
oclass->base.ctor = nvkm_object_new;
oclass->ctor = nvkm_uchan_object_new;
if (!oclass->base.ctor)
oclass->base.ctor = nvkm_object_new;
oclass->ctor = nvkm_uchan_object_new;
sclass->ctor = gf100_gr_object_new;
return sclass->ctor(chan, oclass, data, size, pobject);
while (sw->func->sclass[c].ctor) {
oclass->base.ctor = nvkm_sw_oclass_new;
int (*ctor)(struct nvkm_sw_chan *, const struct nvkm_oclass *,
fault->user.ctor = nvkm_ufault_new;
.booter.ctor = ga102_gsp_booter_ctor,
.fwsec_sb.ctor = tu102_gsp_fwsec_sb_ctor,
.booter.ctor = tu102_gsp_booter_ctor,
.fwsec_sb.ctor = tu102_gsp_fwsec_sb_ctor,
.booter.ctor = ga102_gsp_booter_ctor,
.fwsec_sb.ctor = tu102_gsp_fwsec_sb_ctor,
if (gsp->func->fwsec_sb.ctor)
return gsp->func->fwsec_sb.ctor(gsp);
int (*ctor)(struct nvkm_gsp *, const char *name, const struct firmware *,
int (*ctor)(struct nvkm_gsp *);
ret = gsp->rm->api->client->ctor(client, NVKM_RM_CLIENT(id));
func->sclass[i].ctor = nvkm_rm_engine_obj_ctor;
func->sclass[i].ctor = nvkm_rm_gr_obj_ctor;
.ctor = r535_gsp_client_ctor,
.ctor = r535_gsp_device_ctor,
.event.ctor = r535_gsp_device_event_ctor,
rm->user[0].ctor = gv100_disp_caps_new;
rm->user[1].ctor = nvkm_disp_core_new;
rm->user[2].ctor = nvkm_disp_wndw_new;
rm->user[3].ctor = nvkm_disp_wndw_new;
rm->user[4].ctor = nvkm_disp_chan_new;
.ctor = r570_gsp_client_ctor,
int (*ctor)(struct nvkm_gsp_client *, u32 handle);
int (*ctor)(struct nvkm_gsp_client *, struct nvkm_gsp_device *);
int (*ctor)(struct nvkm_gsp_device *, u32 handle, u32 id,
ret = gsp->func->booter.ctor(gsp, "booter-load", gsp->fws.booter.load,
ret = gsp->func->booter.ctor(gsp, "booter-unload", gsp->fws.booter.unload,
.booter.ctor = tu102_gsp_booter_ctor,
.fwsec_sb.ctor = tu102_gsp_fwsec_sb_ctor,
.booter.ctor = tu102_gsp_booter_ctor,
.fwsec_sb.ctor = tu102_gsp_fwsec_sb_ctor,
mmu->user.ctor = nvkm_ummu_new;
int (*ctor)(struct nvkm_mmu *, bool managed, u64 addr, u64 size,
oclass->ctor = nvkm_umem_new;
oclass->ctor = nvkm_uvmm_new;
ret = mmu->func->vmm.ctor(mmu, managed || raw, addr, size,
ret = mmu->func->vmm.ctor(mmu, false, addr, size, argv, argc,
vfn->user.ctor = nvkm_uvfn_new;
void (*ctor)(void *obj);
.ctor = inode_info_init_once,
SLAB_HWCACHE_ALIGN | info->flags, info->ctor);
.ctor = init_once,
klp_shadow_ctor_t ctor, void *ctor_data);
klp_shadow_ctor_t ctor, void *ctor_data);
void (*ctor)(void *);
slab_flags_t flags, void (*ctor)(void *))
.ctor = ctor,
void (*ctor)(void *))
.ctor = ctor,
void (*ctor)(void *));
klp_shadow_ctor_t ctor, void *ctor_data,
if (ctor) {
err = ctor(obj, new_shadow->data, ctor_data);
klp_shadow_ctor_t ctor, void *ctor_data)
ctor, ctor_data, true);
klp_shadow_ctor_t ctor, void *ctor_data)
ctor, ctor_data, false);
bool ctor, rcu, zero;
ctor = flags & 1;
if (ctor & zero)
num_tests += do_kmem_cache_size(size, ctor, rcu, zero,
if (!cache->ctor && !(cache->flags & SLAB_TYPESAFE_BY_RCU))
if ((cache->flags & SLAB_TYPESAFE_BY_RCU) || cache->ctor ||
if (cache->ctor)
cache->ctor(addr);
void (*ctor)(void *))
kunit_info(test, "%s: size=%zu, ctor=%ps\n", __func__, size, ctor);
test_cache = kmem_cache_create("test", size, 1, flags, ctor);
if (s->ctor || (s->flags & SLAB_TYPESAFE_BY_RCU))
if (s->ctor)
VM_BUG_ON(mem->ctor);
void (*ctor)(void *object); /* Object constructor */
if (c->ctor)
return !(c->ctor ||
if (s->ctor)
if (args->ctor)
(!(flags & SLAB_TYPESAFE_BY_RCU) && !args->ctor) ||
void (*ctor)(void *))
cache_usersize, ctor);
if (unlikely(s->ctor)) {
s->ctor(object);
WARN_ON_ONCE(s->ctor && (flags & __GFP_ZERO));
!s->ctor)
(s->ctor && !args->use_freeptr_offset) ||
} else if (((flags & SLAB_TYPESAFE_BY_RCU) || s->ctor) &&
s->ctor = args->ctor;
if (!s->ctor)
return sysfs_emit(buf, "%pS\n", s->ctor);
SLAB_ATTR_RO(ctor);
void (*ctor)(void *);
unsigned int flags, void (*ctor)(void *))
.ctor = ctor,
void (*ctor)(void *);
gfp_t gfp_flags, klp_shadow_ctor_t ctor,
sv = klp_shadow_alloc(obj, id, size, gfp_flags, ctor, var);
__func__, ptr_id(obj), id, size, &gfp_flags, ptr_id(ctor),
gfp_t gfp_flags, klp_shadow_ctor_t ctor,
sv = klp_shadow_get_or_alloc(obj, id, size, gfp_flags, ctor, var);
__func__, ptr_id(obj), id, size, &gfp_flags, ptr_id(ctor),
if (cachep->ctor)
cachep->ctor(p[i]);
ret->ctor = args->ctor;
if (cachep->ctor)
cachep->ctor(p);
.ctor = kvm_gmem_init_inode_once,