Why `kzalloc()` Over `kmalloc()` in the Linux Kernel

Overview

In the Linux kernel, both kmalloc() and kzalloc() are used for dynamic memory allocation, but they serve slightly different purposes. The choice between them depends on the need for zero-initialization.

Key Differences

Function

Behavior

Typical Use Case

kmalloc()

Allocates uninitialized: memory (garbage values).

When you need raw memory and

will initialize fields manually.

kzalloc()

Allocates zero-initialized memory (all bytes set to 0).

When you want clean slate: (e.g., structs, arrays).

Why `kzalloc()` Was Used in the Example

Safer Defaults:
- Zero-initialization ensures: - Pointers → NULL. - Booleans → false. - Integers → 0.
- Prevents uninitialized memory bugs (e.g., leaking kernel data).

Struct Initialization:

In the JSON struct example, person_alloc() uses kzalloc() to avoid:

struct person *p = kzalloc(sizeof(struct person), GFP_KERNEL);
// p->age = 0, p->name = "", p->hobbies_count = 0, etc.

Idiomatic Kernel Style:
- The kernel prefers kzalloc() for new data structures unless:
  - Performance is critical (avoid zeroing overhead).
  - Explicit manual initialization is planned.

When to Use `kmalloc()`

Performance-Sensitive Paths:
- If memory will be fully overwritten immediately, kmalloc() avoids redundant zeroing.
- Example:
```
void *buf = kmalloc(size, GFP_KERNEL);
memcpy(buf, source_data, size); // No need for prior zeroing.
```
Specialized Allocators:
- Slab caches (kmem_cache) often handle initialization separately.

Performance Consideration

kzalloc() adds a tiny overhead (zeroing memory).
Modern kernels optimize this, so prefer kzalloc() unless profiling shows a bottleneck.

Example Tradeoff

// Option 1: kzalloc() + minimal assignment
struct person *p = kzalloc(sizeof(*p), GFP_KERNEL);
p->age = 30; // Only set non-zero fields.

// Option 2: kmalloc() + full initialization
struct person *p = kmalloc(sizeof(*p), GFP_KERNEL);
memset(&p->addr, 0, sizeof(p->addr)); // Manual zeroing if needed.
p->age = 30;
p->is_student = false;

The first option (kzalloc()) is cleaner and less error-prone.

Conclusion

Default to kzalloc() for safety.
Use kmalloc() only when zeroing is provably redundant.

Why kzalloc() Over kmalloc() in the Linux Kernel