---
title: Device Model
url: https://doc.liz6.com/en/linux-kernel/10-drivers-and-device-model/01-device-model
locale: en
area: linux-kernel
tags:
- linux-kernel
- drivers-and-device-model
date: 2026-06-30
modified: 2026-07-16
description: 'Coverage: kobject/kset → device/driver/bus/class → sysfs binding → probe lifecycle → udev → device tree (DT) → ACPI → platform device Kernel versions: 2.6 ~ 6.x'
---
# Device Model
> Coverage: kobject/kset → device/driver/bus/class → sysfs binding → probe lifecycle → udev → device tree (DT) → ACPI → platform device
> Kernel versions: 2.6 ~ 6.x
## Overview
The Linux device model is an internal kernel framework that provides a unified representation and lifecycle management for all devices, drivers, and buses. Its core value lies not in "how devices work," but in "how devices and drivers find each other"—namely, **device-driver binding**.
## kobject: The Basic Building Block
```c
// include/linux/kobject.h
struct kobject {
const char *name; // Name displayed in sysfs
struct kobject *parent; // Parent node → sysfs directory hierarchy
struct kset *kset; // Belonging kset (collection)
struct kernfs_node *sd; // dentry in sysfs (kernfs)
struct kref kref; // Reference count
unsigned int state_initialized:1;
};
// kobject itself does not manage devices — it provides:
// 1. Directory/file representation in sysfs
// 2. Reference counting → automatic release
// 3. Parent-child hierarchical relationships
```
### kset: A Collection of kobjects
```c
struct kset {
struct list_head list; // List of all member kobjects
struct kobject kobj; // Embedded kobject (the collection itself in sysfs)
const struct kobj_type *ktype; // Type operations
};
// Example: /sys/devices/ → devices_kset
// /sys/bus/ → bus_kset
```
---
## Device / Driver / Bus
### struct device
```c
// include/linux/device.h
struct device {
struct kobject kobj; // sysfs representation
struct device *parent; // Parent device (e.g., PCI bridge)
const char *init_name;
struct bus_type *bus; // Bus it belongs to
struct device_driver *driver; // Bound driver
void *driver_data; // Driver-specific private data
struct device_node *of_node; // DT node
u64 *dma_mask; // DMA addressing range
const struct attribute_group **groups; // sysfs attribute groups
void (*release)(struct device *dev); // Mandatory! (release callback)
};
```
### struct device_driver
```c
struct device_driver {
const char *name;
struct bus_type *bus;
int (*probe)(struct device *dev); // Probe: driver binds to device
void (*remove)(struct device *dev); // Remove: unbind
void (*shutdown)(struct device *dev);
const struct of_device_id *of_match_table; // DT matching
const struct acpi_device_id *acpi_match_table;
const struct attribute_group **groups;
};
```
### struct bus_type
```c
struct bus_type {
const char *name; // PCI, USB, platform, ...
int (*match)(struct device *dev, struct device_driver *drv);
int (*probe)(struct device *dev); // Bus-level probe
struct subsys_private *p; // Device list + driver list
};
```
### Binding Flow
```c
// drivers/base/dd.c
// Device registration:
device_register(dev)
→ device_add(dev)
→ bus_add_device(dev) // Attach to bus->p->klist_devices
→ bus_probe_device(dev)
→ device_initial_probe(dev)
→ __device_attach(dev, true)
→ bus_for_each_drv(dev->bus, ...) // Iterate through all registered drivers
→ driver_match_device(drv, dev) // bus->match() or of_match/acpi_match
→ device_driver_attach(drv, dev)
→ driver_probe_device(drv, dev)
→ really_probe(dev, drv)
→ call_driver_probe(dev, drv) → drv->probe(dev)
```
**Key Point**: Binding is bidirectional—when a new device arrives, it iterates through drivers; when a new driver registers, it iterates through devices. Regardless of who registers first, the match will occur.
---
## sysfs and Attributes
```c
// Each directory under /sys = one kobject
// Attribute files = struct device_attribute
struct device_attribute {
struct attribute attr;
ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf);
ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
};
// Macros: DEVICE_ATTR_RO(name) → generates read-only attribute
// DEVICE_ATTR_WO(name) → write-only
// DEVICE_ATTR_RW(name) → read-write
```
---
## Device Tree vs ACPI
## udev
## References
- **Source Code**: `drivers/base/core.c`, `drivers/base/bus.c`, `drivers/base/dd.c`, `include/linux/device.h`
- **Kernel Documentation**: `Documentation/driver-api/driver-model/`
*Keywords: kobject, device, driver, bus, probe, sysfs, device tree, ACPI, udev, modalias*