drivers/char/ipmi/ipmi_msghandler.c

File Facts

System

Linux kernel

Corpus path

drivers/char/ipmi/ipmi_msghandler.c

Extension

.c

Size

148156 bytes

Lines

5700

Domain

Driver Families

Bucket

drivers/char

Inferred role

Driver Families: operation-table or driver-model contract

Status

pattern implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

• Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.
• Defines an operation table; this is where Linux turns generic core objects into subsystem-specific behavior.
• Uses kernel synchronization; read lock ordering, sleepability, and interrupt context assumptions before translating.
• Allocates kernel memory; connect allocation flags and lifetime to context constraints.
• Defines or uses C structs; map object ownership, embedded links, reference counts, and lock ownership.

Dependency Surface

• linux/module.h
• linux/errno.h
• linux/panic_notifier.h
• linux/poll.h
• linux/sched.h
• linux/seq_file.h
• linux/spinlock.h
• linux/mutex.h
• linux/slab.h
• linux/ipmi.h
• linux/ipmi_smi.h
• linux/notifier.h
• linux/init.h
• linux/rcupdate.h
• linux/interrupt.h
• linux/moduleparam.h
• linux/workqueue.h
• linux/uuid.h
• linux/nospec.h
• linux/vmalloc.h
• linux/delay.h

Detected Declarations

• struct ipmi_user
• struct cmd_rcvr
• struct seq_table
• struct ipmi_channel
• struct ipmi_channel_set
• struct ipmi_my_addrinfo
• struct bmc_device
• struct ipmi_smi
• struct prod_dev_id
• enum ipmi_panic_event_op
• enum ipmi_stat_indexes
• function panic_op_write_handler
• function panic_op_read_handler
• function ipmi_lock_xmit_msgs
• function ipmi_unlock_xmit_msgs
• function free_ipmi_user
• function release_ipmi_user
• function is_lan_addr
• function is_ipmb_addr
• function is_ipmb_bcast_addr
• function is_ipmb_direct_addr
• function free_recv_msg_list
• function list_for_each_entry_safe
• function free_smi_msg_list
• function list_for_each_entry_safe
• function intf_free
• function ipmi_smi_watcher_register
• function list_for_each_entry
• function ipmi_smi_watcher_unregister
• function call_smi_watchers
• function list_for_each_entry
• function ipmi_addr_equal
• function ipmi_validate_addr
• function ipmi_addr_length
• function deliver_response
• function deliver_local_response
• function deliver_err_response
• function smi_add_watch
• function smi_remove_watch
• function intf_next_seq
• function correctly
• function intf_start_seq_timer
• function intf_err_seq
• function ipmi_create_user
• function ipmi_get_smi_info
• function _ipmi_destroy_user
• function lockdep_is_held
• function ipmi_destroy_user

Annotated Snippet

static struct bmc_device *ipmi_find_bmc_guid(struct device_driver *drv,
					     guid_t *guid)
{
	struct device *dev;
	struct bmc_device *bmc = NULL;

	dev = driver_find_device(drv, NULL, guid, __find_bmc_guid);
	if (dev) {
		bmc = to_bmc_device(dev);
		put_device(dev);
	}
	return bmc;
}

struct prod_dev_id {
	unsigned int  product_id;
	unsigned char device_id;
};

static int __find_bmc_prod_dev_id(struct device *dev, const void *data)
{
	const struct prod_dev_id *cid = data;
	struct bmc_device *bmc;
	int rv;

	if (dev->type != &bmc_device_type)
		return 0;

	bmc = to_bmc_device(dev);
	rv = (bmc->id.product_id == cid->product_id
	      && bmc->id.device_id == cid->device_id);
	if (rv)
		rv = kref_get_unless_zero(&bmc->usecount);
	return rv;
}

/*
 * Returns with the bmc's usecount incremented, if it is non-NULL.
 */
static struct bmc_device *ipmi_find_bmc_prod_dev_id(
	struct device_driver *drv,
	unsigned int product_id, unsigned char device_id)
{
	struct prod_dev_id id = {
		.product_id = product_id,
		.device_id = device_id,
	};
	struct device *dev;
	struct bmc_device *bmc = NULL;

	dev = driver_find_device(drv, NULL, &id, __find_bmc_prod_dev_id);
	if (dev) {
		bmc = to_bmc_device(dev);
		put_device(dev);
	}
	return bmc;
}

static DEFINE_IDA(ipmi_bmc_ida);

static void
release_bmc_device(struct device *dev)
{
	kfree(to_bmc_device(dev));
}

static void cleanup_bmc_work(struct work_struct *work)
{
	struct bmc_device *bmc = container_of(work, struct bmc_device,
					      remove_work);
	int id = bmc->pdev.id; /* Unregister overwrites id */

	platform_device_unregister(&bmc->pdev);
	ida_free(&ipmi_bmc_ida, id);
}

static void
cleanup_bmc_device(struct kref *ref)
{
	struct bmc_device *bmc = container_of(ref, struct bmc_device, usecount);

	/*
	 * Remove the platform device in a work queue to avoid issues
	 * with removing the device attributes while reading a device
	 * attribute.
	 */
	queue_work(bmc_remove_work_wq, &bmc->remove_work);
}

/*

Annotation

• Immediate include surface: `linux/module.h`, `linux/errno.h`, `linux/panic_notifier.h`, `linux/poll.h`, `linux/sched.h`, `linux/seq_file.h`, `linux/spinlock.h`, `linux/mutex.h`.
• Detected declarations: `struct ipmi_user`, `struct cmd_rcvr`, `struct seq_table`, `struct ipmi_channel`, `struct ipmi_channel_set`, `struct ipmi_my_addrinfo`, `struct bmc_device`, `struct ipmi_smi`, `struct prod_dev_id`, `enum ipmi_panic_event_op`.
• Atlas domain: Driver Families / drivers/char.
• Implementation status: pattern implementation candidate.
• Synchronization appears in or near this file; preserve lock ordering, sleepability, and interrupt-context constraints.

Implementation Notes

• This generated page is the file-by-file coverage layer; curated subsystem chapters should link here when they synthesize a multi-file control flow.
• Core OS pages should be promoted from atlas-only to deep-reviewed when they explain data structures, invariants, locking, lifecycle, and C implementation snippets.
• Driver-family pages are intentionally pattern-oriented unless they are part of the selected PCIe/NVMe representative device path.