archives/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-03-08 01:24:47 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

treewide: Replace kmalloc with kmalloc_obj for non-scalar types

Browse source 
This is the result of running the Coccinelle script from
scripts/coccinelle/api/kmalloc_objs.cocci. The script is designed to
avoid scalar types (which need careful case-by-case checking), and
instead replace kmalloc-family calls that allocate struct or union
object instances:

Single allocations:	kmalloc(sizeof(TYPE), ...)
are replaced with:	kmalloc_obj(TYPE, ...)

Array allocations:	kmalloc_array(COUNT, sizeof(TYPE), ...)
are replaced with:	kmalloc_objs(TYPE, COUNT, ...)

Flex array allocations:	kmalloc(struct_size(PTR, FAM, COUNT), ...)
are replaced with:	kmalloc_flex(*PTR, FAM, COUNT, ...)

(where TYPE may also be *VAR)

The resulting allocations no longer return "void *", instead returning
"TYPE *".

Signed-off-by: Kees Cook <kees@kernel.org>
This commit is contained in:
Kees Cook 2026-02-20 23:49:23 -08:00
parent d39a1d7486
commit 69050f8d6d
8016 changed files with 20055 additions and 20913 deletions
Download patch file Download diff file Expand all files Collapse all files

3
virt/kvm/coalesced_mmio.c
View file

@ -128,8 +128,7 @@ int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm,
if (zone->pio != 1 && zone->pio != 0)
return -EINVAL;
dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev),
GFP_KERNEL_ACCOUNT);
dev = kzalloc_obj(struct kvm_coalesced_mmio_dev, GFP_KERNEL_ACCOUNT);
if (!dev)
return -ENOMEM;

7
virt/kvm/eventfd.c
View file

@ -382,7 +382,7 @@ kvm_irqfd_assign(struct kvm *kvm, struct kvm_irqfd *args)
if (!kvm_arch_irqfd_allowed(kvm, args))
return -EINVAL;
irqfd = kzalloc(sizeof(*irqfd), GFP_KERNEL_ACCOUNT);
irqfd = kzalloc_obj(*irqfd, GFP_KERNEL_ACCOUNT);
if (!irqfd)
return -ENOMEM;
@ -430,8 +430,7 @@ kvm_irqfd_assign(struct kvm *kvm, struct kvm_irqfd *args)
}
if (!irqfd->resampler) {
resampler = kzalloc(sizeof(*resampler),
GFP_KERNEL_ACCOUNT);
resampler = kzalloc_obj(*resampler, GFP_KERNEL_ACCOUNT);
if (!resampler) {
ret = -ENOMEM;
mutex_unlock(&kvm->irqfds.resampler_lock);
@ -874,7 +873,7 @@ static int kvm_assign_ioeventfd_idx(struct kvm *kvm,
if (IS_ERR(eventfd))
return PTR_ERR(eventfd);
p = kzalloc(sizeof(*p), GFP_KERNEL_ACCOUNT);
p = kzalloc_obj(*p, GFP_KERNEL_ACCOUNT);
if (!p) {
ret = -ENOMEM;
goto fail;

2
virt/kvm/guest_memfd.c
View file

@ -568,7 +568,7 @@ static int __kvm_gmem_create(struct kvm *kvm, loff_t size, u64 flags)
if (fd < 0)
return fd;
f = kzalloc(sizeof(*f), GFP_KERNEL);
f = kzalloc_obj(*f, GFP_KERNEL);
if (!f) {
err = -ENOMEM;
goto err_fd;

6
virt/kvm/irqchip.c
View file

@ -183,7 +183,7 @@ int kvm_set_irq_routing(struct kvm *kvm,
nr_rt_entries += 1;
new = kzalloc(struct_size(new, map, nr_rt_entries), GFP_KERNEL_ACCOUNT);
new = kzalloc_flex(*new, map, nr_rt_entries, GFP_KERNEL_ACCOUNT);
if (!new)
return -ENOMEM;
@ -194,7 +194,7 @@ int kvm_set_irq_routing(struct kvm *kvm,
for (i = 0; i < nr; ++i) {
r = -ENOMEM;
e = kzalloc(sizeof(*e), GFP_KERNEL_ACCOUNT);
e = kzalloc_obj(*e, GFP_KERNEL_ACCOUNT);
if (!e)
goto out;
@ -246,7 +246,7 @@ int kvm_init_irq_routing(struct kvm *kvm)
struct kvm_irq_routing_table *new;
int chip_size;
new = kzalloc(struct_size(new, map, 1), GFP_KERNEL_ACCOUNT);
new = kzalloc_flex(*new, map, 1, GFP_KERNEL_ACCOUNT);
if (!new)
return -ENOMEM;

34
virt/kvm/kvm_main.c
View file

@ -1043,15 +1043,15 @@ static int kvm_create_vm_debugfs(struct kvm *kvm, const char *fdname)
return 0;
kvm->debugfs_dentry = dent;
kvm->debugfs_stat_data = kcalloc(kvm_debugfs_num_entries,
sizeof(*kvm->debugfs_stat_data),
GFP_KERNEL_ACCOUNT);
kvm->debugfs_stat_data = kzalloc_objs(*kvm->debugfs_stat_data,
kvm_debugfs_num_entries,
GFP_KERNEL_ACCOUNT);
if (!kvm->debugfs_stat_data)
goto out_err;
for (i = 0; i < kvm_vm_stats_header.num_desc; ++i) {
pdesc = &kvm_vm_stats_desc[i];
stat_data = kzalloc(sizeof(*stat_data), GFP_KERNEL_ACCOUNT);
stat_data = kzalloc_obj(*stat_data, GFP_KERNEL_ACCOUNT);
if (!stat_data)
goto out_err;
@ -1066,7 +1066,7 @@ static int kvm_create_vm_debugfs(struct kvm *kvm, const char *fdname)
for (i = 0; i < kvm_vcpu_stats_header.num_desc; ++i) {
pdesc = &kvm_vcpu_stats_desc[i];
stat_data = kzalloc(sizeof(*stat_data), GFP_KERNEL_ACCOUNT);
stat_data = kzalloc_obj(*stat_data, GFP_KERNEL_ACCOUNT);
if (!stat_data)
goto out_err;
@ -1185,7 +1185,7 @@ static struct kvm *kvm_create_vm(unsigned long type, const char *fdname)
r = -ENOMEM;
for (i = 0; i < KVM_NR_BUSES; i++) {
rcu_assign_pointer(kvm->buses[i],
kzalloc(sizeof(struct kvm_io_bus), GFP_KERNEL_ACCOUNT));
kzalloc_obj(struct kvm_io_bus, GFP_KERNEL_ACCOUNT));
if (!kvm->buses[i])
goto out_err_no_arch_destroy_vm;
}
@ -1944,7 +1944,7 @@ static int kvm_set_memslot(struct kvm *kvm,
* invalidation needs to be reverted.
*/
if (change == KVM_MR_DELETE || change == KVM_MR_MOVE) {
invalid_slot = kzalloc(sizeof(*invalid_slot), GFP_KERNEL_ACCOUNT);
invalid_slot = kzalloc_obj(*invalid_slot, GFP_KERNEL_ACCOUNT);
if (!invalid_slot) {
mutex_unlock(&kvm->slots_arch_lock);
return -ENOMEM;
@ -2117,7 +2117,7 @@ static int kvm_set_memory_region(struct kvm *kvm,
return -EEXIST;
/* Allocate a slot that will persist in the memslot. */
new = kzalloc(sizeof(*new), GFP_KERNEL_ACCOUNT);
new = kzalloc_obj(*new, GFP_KERNEL_ACCOUNT);
if (!new)
return -ENOMEM;
@ -4505,7 +4505,7 @@ static long kvm_vcpu_ioctl(struct file *filp,
struct kvm_regs *kvm_regs;
r = -ENOMEM;
kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL);
kvm_regs = kzalloc_obj(struct kvm_regs, GFP_KERNEL);
if (!kvm_regs)
goto out;
r = kvm_arch_vcpu_ioctl_get_regs(vcpu, kvm_regs);
@ -4532,7 +4532,7 @@ out_free1:
break;
}
case KVM_GET_SREGS: {
kvm_sregs = kzalloc(sizeof(struct kvm_sregs), GFP_KERNEL);
kvm_sregs = kzalloc_obj(struct kvm_sregs, GFP_KERNEL);
r = -ENOMEM;
if (!kvm_sregs)
goto out;
@ -4624,7 +4624,7 @@ out_free1:
break;
}
case KVM_GET_FPU: {
fpu = kzalloc(sizeof(struct kvm_fpu), GFP_KERNEL);
fpu = kzalloc_obj(struct kvm_fpu, GFP_KERNEL);
r = -ENOMEM;
if (!fpu)
goto out;
@ -4844,7 +4844,7 @@ static int kvm_ioctl_create_device(struct kvm *kvm,
if (test)
return 0;
dev = kzalloc(sizeof(*dev), GFP_KERNEL_ACCOUNT);
dev = kzalloc_obj(*dev, GFP_KERNEL_ACCOUNT);
if (!dev)
return -ENOMEM;
@ -6006,8 +6006,8 @@ int kvm_io_bus_register_dev(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
if (bus->dev_count - bus->ioeventfd_count > NR_IOBUS_DEVS - 1)
return -ENOSPC;
new_bus = kmalloc(struct_size(bus, range, bus->dev_count + 1),
GFP_KERNEL_ACCOUNT);
new_bus = kmalloc_flex(*bus, range, bus->dev_count + 1,
GFP_KERNEL_ACCOUNT);
if (!new_bus)
return -ENOMEM;
@ -6053,8 +6053,8 @@ int kvm_io_bus_unregister_dev(struct kvm *kvm, enum kvm_bus bus_idx,
if (i == bus->dev_count)
return 0;
new_bus = kmalloc(struct_size(bus, range, bus->dev_count - 1),
GFP_KERNEL_ACCOUNT);
new_bus = kmalloc_flex(*bus, range, bus->dev_count - 1,
GFP_KERNEL_ACCOUNT);
if (new_bus) {
memcpy(new_bus, bus, struct_size(bus, range, i));
new_bus->dev_count--;
@ -6326,7 +6326,7 @@ static void kvm_uevent_notify_change(unsigned int type, struct kvm *kvm)
active = kvm_active_vms;
mutex_unlock(&kvm_lock);
env = kzalloc(sizeof(*env), GFP_KERNEL);
env = kzalloc_obj(*env, GFP_KERNEL);
if (!env)
return;

4
virt/kvm/vfio.c
View file

@ -166,7 +166,7 @@ static int kvm_vfio_file_add(struct kvm_device *dev, unsigned int fd)
}
}
kvf = kzalloc(sizeof(*kvf), GFP_KERNEL_ACCOUNT);
kvf = kzalloc_obj(*kvf, GFP_KERNEL_ACCOUNT);
if (!kvf) {
ret = -ENOMEM;
goto out_unlock;
@ -364,7 +364,7 @@ static int kvm_vfio_create(struct kvm_device *dev, u32 type)
if (tmp->ops == &kvm_vfio_ops)
return -EBUSY;
kv = kzalloc(sizeof(*kv), GFP_KERNEL_ACCOUNT);
kv = kzalloc_obj(*kv, GFP_KERNEL_ACCOUNT);
if (!kv)
return -ENOMEM;