/* hello_driver.c — 最小限のカーネルモジュール */
#include <linux/module.h>    /* MODULE_LICENSE, module_init/exit */
#include <linux/kernel.h>    /* printk, KERN_INFO */
#include <linux/init.h>      /* __init, __exit マクロ */
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Example Author");
MODULE_DESCRIPTION("Minimal kernel module example");
MODULE_VERSION("1.0");
 
/*
 * モジュールロード時に呼ばれる初期化関数
 * __init マクロ: 初期化完了後にこの関数のメモリを解放してよいことを示す
 * 戻り値: 0 = 成功、負の値 = エラー（errno値の符号反転）
 */
static int __init hello_init(void)
{
    pr_info("hello_driver: module loaded\n");
    pr_info("hello_driver: kernel version = %s\n", UTS_RELEASE);
 
    /*
     * ここでデバイスの初期化処理を行う:
     *   - デバイス番号の割り当て (alloc_chrdev_region)
     *   - cdev構造体の初期化と登録 (cdev_init, cdev_add)
     *   - デバイスクラスの作成 (class_create)
     *   - デバイスノードの作成 (device_create)
     *   - ハードウェアの初期化 (レジスタ設定等)
     */
 
    return 0;  /* 成功 */
}
 
/*
 * モジュールアンロード時に呼ばれる終了関数
 * __exit マクロ: モジュールが組み込みの場合、この関数を省略できることを示す
 */
static void __exit hello_exit(void)
{
    pr_info("hello_driver: module unloaded\n");
 
    /*
     * ここで後始末処理を行う（init の逆順）:
     *   - device_destroy
     *   - class_destroy
     *   - cdev_del
     *   - unregister_chrdev_region
     */
}
 
/* カーネルにエントリポイントを登録 */
module_init(hello_init);
module_exit(hello_exit);

# Makefile for hello_driver kernel module
obj-m += hello_driver.o
 
# KDIR: カーネルソースツリーのパス（通常はヘッダのみで十分）
KDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
 
all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules
 
clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean
 
# モジュールのロード/アンロード（テスト用）
load:
	sudo insmod hello_driver.ko
 
unload:
	sudo rmmod hello_driver
 
# カーネルログの確認
log:
	dmesg | tail -20

# ロード済みモジュールの一覧と参照カウント
$ lsmod | head -10
Module                  Size  Used by
nvidia_drm             77824  10
nvidia_modeset       1236992  18 nvidia_drm
nvidia              56467456  656 nvidia_modeset
snd_hda_intel          57344  4
 
# モジュールの詳細情報を確認
$ modinfo e1000e
filename:       /lib/modules/6.1.0/kernel/drivers/net/ethernet/intel/e1000e/e1000e.ko
version:        3.2.6-k
license:        GPL v2
description:    Intel(R) PRO/1000 Network Driver
author:         Intel Corporation
depends:
retpoline:      Y
 
# 依存関係を自動解決してロード
$ sudo modprobe snd_hda_intel
 
# パラメータを指定してロード
$ sudo modprobe usbcore autosuspend=-1
 
# モジュールパラメータの確認
$ cat /sys/module/usbcore/parameters/autosuspend
 
# 依存モジュールごとアンロード
$ sudo modprobe -r snd_hda_intel

# /etc/udev/rules.d/99-usb-serial.rules
# USB-シリアル変換器に固定デバイス名を割り当てるルール
 
# ベンダーID=0403（FTDI）, プロダクトID=6001 のデバイスに
# /dev/ttyFTDI というシンボリックリンクを作成し、
# グループ dialout に所属させ、パーミッション 0666 を設定
SUBSYSTEM=="tty", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", \
    SYMLINK+="ttyFTDI", GROUP="dialout", MODE="0666"
 
# 特定のシリアル番号を持つデバイスに一意の名前を割り当て
SUBSYSTEM=="tty", ATTRS{serial}=="A50285BI", SYMLINK+="sensor_gps"
SUBSYSTEM=="tty", ATTRS{serial}=="FTXYZ123", SYMLINK+="sensor_imu"

/*
 * ポーリング方式の擬似コード
 * シリアルポートからの1バイト受信を例にする
 */
#define UART_LSR    0x3FD   /* Line Status Register */
#define UART_RBR    0x3F8   /* Receiver Buffer Register */
#define LSR_DR      0x01    /* Data Ready ビット */
 
uint8_t uart_read_polling(void)
{
    /* ステータスレジスタを繰り返しチェック（ビジーウェイト） */
    while (!(inb(UART_LSR) & LSR_DR)) {
        /* CPUはここでスピンし続ける
         * 他のタスクを実行できない
         * デバイスが応答しない場合、永久にループする危険がある
         */
        cpu_relax();  /* スピンループ用ヒント命令 */
    }
 
    /* データレディになったらデータレジスタを読み取る */
    return inb(UART_RBR);
}

/*
 * 割り込み駆動I/Oの擬似コード
 * シリアルポートの割り込みハンドラを例にする
 */
#include <linux/interrupt.h>
 
/* 受信バッファ（循環バッファ） */
static DECLARE_KFIFO(rx_fifo, unsigned char, 1024);
static DECLARE_WAIT_QUEUE_HEAD(rx_waitq);
 
/*
 * 割り込みハンドラ（トップハーフ）
 * IRQ発生時にカーネルから呼ばれる
 * 注意: 割り込みコンテキストではスリープ不可
 */
static irqreturn_t uart_irq_handler(int irq, void *dev_id)
{
    uint8_t status = inb(UART_LSR);
 
    if (!(status & LSR_DR))
        return IRQ_NONE;  /* この割り込みは自分のデバイスではない */
 
    /* データを読み取り、FIFOに格納 */
    while (status & LSR_DR) {
        uint8_t data = inb(UART_RBR);
        kfifo_put(&rx_fifo, data);
        status = inb(UART_LSR);
    }
 
    /* 待機中のプロセスを起床 */
    wake_up_interruptible(&rx_waitq);
 
    return IRQ_HANDLED;  /* 割り込みを処理した */
}
 
/* ドライバ初期化時にIRQハンドラを登録 */
static int uart_probe(struct platform_device *pdev)
{
    int ret;
 
    ret = request_irq(IRQ_UART, uart_irq_handler,
                      IRQF_SHARED,       /* 共有IRQ対応 */
                      "my_uart",          /* /proc/interrupts での表示名 */
                      pdev);              /* dev_id: ハンドラに渡される */
    if (ret) {
        dev_err(&pdev->dev, "Failed to request IRQ %d\n", IRQ_UART);
        return ret;
    }
 
    return 0;
}

/*
 * DMA転送の擬似コード
 * ブロックデバイスからのデータ読み取りを例にする
 */
#include <linux/dma-mapping.h>
 
static int setup_dma_transfer(struct device *dev, void *buffer, size_t len)
{
    dma_addr_t dma_handle;
 
    /*
     * DMAマッピングの作成
     * CPUの仮想アドレスをデバイスがアクセス可能なバスアドレスに変換
     * IOMMUが存在する場合、IOMMU経由のアドレス変換が行われる
     */
    dma_handle = dma_map_single(dev, buffer, len, DMA_FROM_DEVICE);
    if (dma_mapping_error(dev, dma_handle)) {
        dev_err(dev, "DMA mapping failed\n");
        return -ENOMEM;
    }
 
    /*
     * デバイスにDMA転送を指示
     * - 転送元/先のバスアドレス
     * - 転送サイズ
     * - 転送方向
     * デバイス固有のレジスタに書き込む
     */
    writel(dma_handle, dev_regs + DMA_ADDR_REG);
    writel(len, dev_regs + DMA_LEN_REG);
    writel(DMA_START | DMA_DIR_READ, dev_regs + DMA_CTRL_REG);
 
    /* CPUは転送完了を待たず他の処理を行える
     * 転送完了は割り込みで通知される */
    return 0;
}
 
/* DMA完了割り込みハンドラ */
static irqreturn_t dma_complete_handler(int irq, void *dev_id)
{
    struct device *dev = dev_id;
 
    /* DMAマッピングを解除（キャッシュ同期も行われる） */
    dma_unmap_single(dev, dma_handle, len, DMA_FROM_DEVICE);
 
    /* 転送完了を上位層に通知 */
    complete(&dma_completion);
 
    return IRQ_HANDLED;
}

/*
 * simplechar.c — 教育用キャラクタデバイスドライバの完全実装
 * メモリバッファをデバイスとして公開する
 */
#include <linux/module.h>
#include <linux/fs.h>         /* file_operations, register_chrdev_region */
#include <linux/cdev.h>       /* cdev 構造体 */
#include <linux/device.h>     /* device_create, class_create */
#include <linux/uaccess.h>    /* copy_to_user, copy_from_user */
#include <linux/mutex.h>
 
#define DEVICE_NAME   "simplechar"
#define CLASS_NAME    "simple"
#define BUFFER_SIZE   4096
 
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Educational character device driver");
 
/* ドライバのプライベートデータ */
struct simplechar_dev {
    struct cdev    cdev;          /* カーネル内cdev構造体 */
    struct class   *class;        /* デバイスクラス */
    struct device  *device;       /* デバイス */
    dev_t          devno;         /* デバイス番号(major:minor) */
    struct mutex   lock;          /* 排他制御用ミューテックス */
    char           buffer[BUFFER_SIZE];  /* データバッファ */
    size_t         data_len;      /* バッファ内の有効データ長 */
    int            open_count;    /* オープン参照カウント */
};
 
static struct simplechar_dev *sc_dev;
 
/* --- file_operations コールバック実装 --- */
 
static int sc_open(struct inode *inode, struct file *filp)
{
    struct simplechar_dev *dev;
 
    /* container_of でinode内のcdevからデバイス構造体を取得 */
    dev = container_of(inode->i_cdev, struct simplechar_dev, cdev);
    filp->private_data = dev;  /* 以降のread/write/releaseで使用 */
 
    mutex_lock(&dev->lock);
    dev->open_count++;
    pr_info("%s: opened (count=%d)\n", DEVICE_NAME, dev->open_count);
    mutex_unlock(&dev->lock);
 
    return 0;
}
 
static ssize_t sc_read(struct file *filp, char __user *ubuf,
                        size_t count, loff_t *f_pos)
{
    struct simplechar_dev *dev = filp->private_data;
    ssize_t retval;
 
    mutex_lock(&dev->lock);
 
    /* ファイルオフセットがデータ長を超えている場合はEOF */
    if (*f_pos >= dev->data_len) {
        retval = 0;  /* EOF */
        goto out;
    }
 
    /* 読み取り量をデータ残量に制限 */
    if (*f_pos + count > dev->data_len)
        count = dev->data_len - *f_pos;
 
    /*
     * copy_to_user: カーネル空間 → ユーザ空間へのコピー
     * ユーザ空間ポインタの検証も内部で行われる
     * 戻り値: コピーできなかったバイト数（0 = 成功）
     */
    if (copy_to_user(ubuf, dev->buffer + *f_pos, count)) {
        retval = -EFAULT;  /* 不正なユーザ空間アドレス */
        goto out;
    }
 
    *f_pos += count;  /* ファイルオフセットを更新 */
    retval = count;
    pr_info("%s: read %zu bytes from offset %lld\n",
            DEVICE_NAME, count, *f_pos - count);
 
out:
    mutex_unlock(&dev->lock);
    return retval;
}
 
static ssize_t sc_write(struct file *filp, const char __user *ubuf,
                         size_t count, loff_t *f_pos)
{
    struct simplechar_dev *dev = filp->private_data;
    ssize_t retval;
 
    mutex_lock(&dev->lock);
 
    /* バッファオーバーフロー防止 */
    if (*f_pos + count > BUFFER_SIZE)
        count = BUFFER_SIZE - *f_pos;
 
    if (count == 0) {
        retval = -ENOSPC;  /* No space left on device */
        goto out;
    }
 
    if (copy_from_user(dev->buffer + *f_pos, ubuf, count)) {
        retval = -EFAULT;
        goto out;
    }
 
    *f_pos += count;
    if (*f_pos > dev->data_len)
        dev->data_len = *f_pos;
 
    retval = count;
    pr_info("%s: wrote %zu bytes at offset %lld\n",
            DEVICE_NAME, count, *f_pos - count);
 
out:
    mutex_unlock(&dev->lock);
    return retval;
}
 
static int sc_release(struct inode *inode, struct file *filp)
{
    struct simplechar_dev *dev = filp->private_data;
 
    mutex_lock(&dev->lock);
    dev->open_count--;
    pr_info("%s: released (count=%d)\n", DEVICE_NAME, dev->open_count);
    mutex_unlock(&dev->lock);
 
    return 0;
}
 
/*
 * file_operations 構造体 — VFSとドライバの接続点
 * ここで定義されていない操作は、VFSのデフォルト動作になる
 */
static const struct file_operations sc_fops = {
    .owner   = THIS_MODULE,    /* モジュール参照カウント管理 */
    .open    = sc_open,
    .read    = sc_read,
    .write   = sc_write,
    .release = sc_release,
    /* .llseek, .unlocked_ioctl, .poll, .mmap 等も定義可能 */
};
 
/* --- モジュール初期化・終了 --- */
 
static int __init sc_init(void)
{
    int ret;
 
    /* デバイス構造体の割り当て */
    sc_dev = kzalloc(sizeof(*sc_dev), GFP_KERNEL);
    if (!sc_dev)
        return -ENOMEM;
 
    mutex_init(&sc_dev->lock);
 
    /* Step 1: デバイス番号の動的割り当て */
    ret = alloc_chrdev_region(&sc_dev->devno, 0, 1, DEVICE_NAME);
    if (ret < 0) {
        pr_err("%s: alloc_chrdev_region failed\n", DEVICE_NAME);
        goto err_alloc_region;
    }
    pr_info("%s: registered with major=%d, minor=%d\n",
            DEVICE_NAME, MAJOR(sc_dev->devno), MINOR(sc_dev->devno));
 
    /* Step 2: cdev構造体の初期化と登録 */
    cdev_init(&sc_dev->cdev, &sc_fops);
    sc_dev->cdev.owner = THIS_MODULE;
    ret = cdev_add(&sc_dev->cdev, sc_dev->devno, 1);
    if (ret < 0) {
        pr_err("%s: cdev_add failed\n", DEVICE_NAME);
        goto err_cdev_add;
    }
 
    /* Step 3: デバイスクラスの作成（/sys/class/simple/） */
    sc_dev->class = class_create(CLASS_NAME);
    if (IS_ERR(sc_dev->class)) {
        ret = PTR_ERR(sc_dev->class);
        goto err_class;
    }
 
    /* Step 4: デバイスノードの作成（/dev/simplechar） */
    sc_dev->device = device_create(sc_dev->class, NULL,
                                    sc_dev->devno, NULL, DEVICE_NAME);
    if (IS_ERR(sc_dev->device)) {
        ret = PTR_ERR(sc_dev->device);
        goto err_device;
    }
 
    pr_info("%s: driver initialized successfully\n", DEVICE_NAME);
    return 0;
 
/* エラー時の後始末（初期化の逆順） */
err_device:
    class_destroy(sc_dev->class);
err_class:
    cdev_del(&sc_dev->cdev);
err_cdev_add:
    unregister_chrdev_region(sc_dev->devno, 1);
err_alloc_region:
    kfree(sc_dev);
    return ret;
}
 
static void __exit sc_exit(void)
{
    /* 初期化の逆順で後始末 */
    device_destroy(sc_dev->class, sc_dev->devno);
    class_destroy(sc_dev->class);
    cdev_del(&sc_dev->cdev);
    unregister_chrdev_region(sc_dev->devno, 1);
    kfree(sc_dev);
    pr_info("%s: driver removed\n", DEVICE_NAME);
}
 
module_init(sc_init);
module_exit(sc_exit);

# デバイスツリーソース (.dts) をバイナリ (.dtb) にコンパイル
$ dtc -I dts -O dtb -o board.dtb board.dts
 
# 既存の .dtb を逆コンパイルして内容を確認
$ dtc -I dtb -O dts -o decompiled.dts /boot/dtbs/board.dtb
 
# 実行中のシステムのデバイスツリーを確認
$ ls /proc/device-tree/
$ cat /proc/device-tree/model
 
# デバイスツリーオーバーレイ（既存DTBに差分を適用）
$ dtc -I dts -O dtb -o overlay.dtbo overlay.dts
$ sudo dtoverlay overlay.dtbo

# ACPIテーブルの確認
$ sudo acpidump | head -30
$ sudo acpidump -b     # バイナリ形式でダンプ
$ iasl -d DSDT.aml     # AMLを逆アセンブル
 
# ACPIデバイスの一覧
$ ls /sys/bus/acpi/devices/
 
# 電源管理状態の確認
$ cat /sys/bus/acpi/devices/*/power_state

/*
 * UIOユーザ空間ドライバの例
 * /dev/uio0 を通じてデバイスレジスタにアクセスする
 */
#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdint.h>
#include <unistd.h>
 
int main(void)
{
    int fd;
    volatile uint32_t *regs;
    uint32_t irq_count;
 
    /* UIOデバイスをオープン */
    fd = open("/dev/uio0", O_RDWR);
    if (fd < 0) {
        perror("open /dev/uio0");
        return 1;
    }
 
    /*
     * デバイスレジスタをユーザ空間にマッピング
     * offset 0 = BAR0（PCI）またはレジスタ領域
     * mmapにより物理レジスタに直接アクセス可能になる
     */
    regs = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
                MAP_SHARED, fd, 0);
    if (regs == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }
 
    /* レジスタへの読み書き（デバイス固有の操作） */
    printf("Device ID: 0x%08x\n", regs[0]);  /* レジスタ0を読み取り */
    regs[1] = 0x00000001;                     /* レジスタ1に書き込み */
 
    /*
     * 割り込み待ち
     * read() でブロックし、割り込み発生時に返る
     * 戻り値は割り込み発生回数
     */
    while (1) {
        ssize_t n = read(fd, &irq_count, sizeof(irq_count));
        if (n != sizeof(irq_count)) {
            perror("read (IRQ wait)");
            break;
        }
        printf("Interrupt #%u received\n", irq_count);
 
        /* 割り込み処理（ユーザ空間で自由にロジックを記述） */
        uint32_t status = regs[2];  /* ステータスレジスタ読み取り */
        regs[3] = status;           /* 割り込みクリア */
    }
 
    munmap((void *)regs, 4096);
    close(fd);
    return 0;
}

/*
 * スレッド化割り込みの実装例
 */
static irqreturn_t sensor_hard_irq(int irq, void *dev_id)
{
    struct sensor_dev *sdev = dev_id;
 
    /*
     * ハードIRQハンドラ（トップハーフ）
     * 最小限の処理のみ行う
     */
    sdev->irq_status = readl(sdev->regs + IRQ_STATUS_REG);
 
    if (!(sdev->irq_status & IRQ_PENDING))
        return IRQ_NONE;  /* このデバイスの割り込みではない */
 
    /* 割り込みをマスク（スレッドハンドラ完了まで抑制） */
    writel(0, sdev->regs + IRQ_ENABLE_REG);
 
    return IRQ_WAKE_THREAD;  /* スレッドハンドラを起床 */
}
 
static irqreturn_t sensor_thread_fn(int irq, void *dev_id)
{
    struct sensor_dev *sdev = dev_id;
    int ret;
 
    /*
     * スレッドハンドラ（ボトムハーフ）
     * プロセスコンテキストで動作 → スリープ可能
     */
 
    /* I2C経由でセンサデータを読み取り（スリープを伴う） */
    mutex_lock(&sdev->lock);
    ret = i2c_smbus_read_word_data(sdev->i2c_client, DATA_REG);
    if (ret >= 0) {
        sdev->last_value = ret;
        sysfs_notify(&sdev->dev->kobj, NULL, "value");
    }
    mutex_unlock(&sdev->lock);
 
    /* 割り込みを再度有効化 */
    writel(IRQ_ENABLE, sdev->regs + IRQ_ENABLE_REG);
 
    return IRQ_HANDLED;
}
 
/* ドライバ初期化時 */
static int sensor_probe(struct platform_device *pdev)
{
    int ret;
 
    ret = request_threaded_irq(
        sdev->irq,
        sensor_hard_irq,     /* ハードIRQハンドラ（トップハーフ） */
        sensor_thread_fn,     /* スレッドハンドラ（ボトムハーフ） */
        IRQF_ONESHOT,         /* スレッド完了まで割り込みをマスク */
        "sensor_drv",
        sdev
    );
 
    return ret;
}

/*
 * ランタイム電源管理の実装例
 */
#include <linux/pm_runtime.h>
 
static int mydev_probe(struct platform_device *pdev)
{
    struct mydev *dev = platform_get_drvdata(pdev);
 
    /* ランタイムPMの有効化 */
    pm_runtime_set_active(&pdev->dev);
    pm_runtime_enable(&pdev->dev);
 
    /*
     * 自動サスペンドの設定
     * 最後の操作から2秒後に自動的にサスペンドする
     */
    pm_runtime_set_autosuspend_delay(&pdev->dev, 2000);
    pm_runtime_use_autosuspend(&pdev->dev);
 
    return 0;
}
 
/* デバイスを使用する前に呼ぶ */
static int mydev_do_io(struct mydev *dev)
{
    int ret;
 
    /* デバイスをアクティブ状態に遷移（必要なら電源ON） */
    ret = pm_runtime_get_sync(dev->dev);
    if (ret < 0) {
        pm_runtime_put_noidle(dev->dev);
        return ret;
    }
 
    /* デバイスI/O操作 */
    writel(cmd, dev->regs + CMD_REG);
 
    /* 使用完了を通知（自動サスペンドタイマー開始） */
    pm_runtime_mark_last_busy(dev->dev);
    pm_runtime_put_autosuspend(dev->dev);
 
    return 0;
}
 
/* ランタイムサスペンド・レジュームコールバック */
static int mydev_runtime_suspend(struct device *dev)
{
    struct mydev *mdev = dev_get_drvdata(dev);
 
    /* デバイスのクロックを停止 */
    clk_disable_unprepare(mdev->clk);
    /* レギュレータをOFF */
    regulator_disable(mdev->supply);
 
    return 0;
}
 
static int mydev_runtime_resume(struct device *dev)
{
    struct mydev *mdev = dev_get_drvdata(dev);
    int ret;
 
    /* レギュレータをON */
    ret = regulator_enable(mdev->supply);
    if (ret)
        return ret;
    /* クロックを再開 */
    ret = clk_prepare_enable(mdev->clk);
    if (ret) {
        regulator_disable(mdev->supply);
        return ret;
    }
 
    /* デバイスの再初期化（レジスタの復元等） */
    mydev_hw_init(mdev);
 
    return 0;
}
 
static const struct dev_pm_ops mydev_pm_ops = {
    SET_RUNTIME_PM_OPS(mydev_runtime_suspend,
                       mydev_runtime_resume, NULL)
    SET_SYSTEM_SLEEP_PM_OPS(mydev_system_suspend,
                            mydev_system_resume)
};

# sysfsの構造を確認する例
$ ls /sys/class/net/eth0/
address  carrier  device  duplex  mtu  operstate  speed  statistics  ...
 
$ cat /sys/class/net/eth0/mtu
1500
 
$ cat /sys/class/net/eth0/address
00:1a:2b:3c:4d:5e
 
# ブロックデバイスのI/Oスケジューラ確認・変更
$ cat /sys/block/sda/queue/scheduler
[mq-deadline] kyber bfq none
 
$ echo "bfq" | sudo tee /sys/block/sda/queue/scheduler
 
# デバイスの電源状態を確認
$ cat /sys/devices/pci0000:00/0000:00:1f.0/power/runtime_status
active

/*
 * sysfs属性の実装例
 * /sys/class/simple/simplechar/debug_level として公開
 */
 
static int debug_level = 0;
 
/* read: cat /sys/.../debug_level */
static ssize_t debug_level_show(struct device *dev,
                                 struct device_attribute *attr,
                                 char *buf)
{
    return sysfs_emit(buf, "%d\n", debug_level);
}
 
/* write: echo 3 > /sys/.../debug_level */
static ssize_t debug_level_store(struct device *dev,
                                  struct device_attribute *attr,
                                  const char *buf, size_t count)
{
    int val;
    int ret;
 
    ret = kstrtoint(buf, 10, &val);
    if (ret)
        return ret;
 
    if (val < 0 || val > 5)
        return -EINVAL;
 
    debug_level = val;
    pr_info("debug_level set to %d\n", debug_level);
 
    return count;
}
 
/* DEVICE_ATTR_RW マクロで show/store を登録 */
static DEVICE_ATTR_RW(debug_level);
 
/* 複数属性をグループ化 */
static struct attribute *mydev_attrs[] = {
    &dev_attr_debug_level.attr,
    NULL,
};
ATTRIBUTE_GROUPS(mydev);
 
/* probe() でデバイス作成時に属性グループを指定 */
/* class->dev_groups = mydev_groups; */

# 動的デバッグの有効化
# 特定のファイル内の全デバッグメッセージを有効化
$ echo "file mydriver.c +p" | sudo tee /sys/kernel/debug/dynamic_debug/control
 
# 特定の関数のデバッグメッセージを有効化
$ echo "func mydev_probe +p" | sudo tee /sys/kernel/debug/dynamic_debug/control
 
# 特定モジュールの全デバッグメッセージを有効化
$ echo "module mydriver +p" | sudo tee /sys/kernel/debug/dynamic_debug/control
 
# 現在有効なデバッグポイントの確認
$ cat /sys/kernel/debug/dynamic_debug/control | grep mydriver
 
# ftraceによる関数トレース
$ echo function > /sys/kernel/debug/tracing/current_tracer
$ echo mydev_* > /sys/kernel/debug/tracing/set_ftrace_filter
$ echo 1 > /sys/kernel/debug/tracing/tracing_on
$ cat /sys/kernel/debug/tracing/trace

/* NG: 割り込みハンドラ内でのスリープ（絶対にやってはいけない） */
static irqreturn_t bad_irq_handler(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;
    void *buf;
 
    /*
     * NG: GFP_KERNEL はスリープ可能な割り当て
     * 割り込みコンテキストではスリープ不可のため、
     * カーネルがBUGメッセージを出力しクラッシュする可能性がある
     */
    buf = kmalloc(4096, GFP_KERNEL);  /* NG! */
 
    /*
     * NG: mutex_lock はスリープ可能
     * 別のコンテキストがロックを保持している場合、
     * 割り込みハンドラがスリープしてデッドロックに至る
     */
    mutex_lock(&dev->lock);           /* NG! */
 
    /* NG: copy_to_user はページフォルトを起こす可能性がある */
    copy_to_user(ubuf, data, len);    /* NG! */
 
    mutex_unlock(&dev->lock);
    kfree(buf);
    return IRQ_HANDLED;
}
 
/* OK: 正しい実装 — スレッド化割り込みまたはworkqueueを使用 */
static irqreturn_t good_hard_irq(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;
 
    /* 最小限の処理: ステータス読み取りと割り込みクリア */
    dev->irq_status = readl(dev->regs + STATUS_REG);
    writel(dev->irq_status, dev->regs + IRQ_ACK_REG);
 
    return IRQ_WAKE_THREAD;  /* スレッドハンドラに委譲 */
}
 
static irqreturn_t good_thread_fn(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;
    void *buf;
 
    /* OK: プロセスコンテキストではGFP_KERNELが使える */
    buf = kmalloc(4096, GFP_KERNEL);
 
    /* OK: mutex_lockも使用可能 */
    mutex_lock(&dev->lock);
    /* データ処理 */
    mutex_unlock(&dev->lock);
 
    kfree(buf);
    return IRQ_HANDLED;
}

/* NG: リソースリークのあるエラーハンドリング */
static int bad_probe(struct platform_device *pdev)
{
    struct my_dev *dev;
    int ret;
 
    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;
 
    dev->clk = clk_get(&pdev->dev, "main_clk");
    if (IS_ERR(dev->clk))
        return PTR_ERR(dev->clk);    /* NG: dev のメモリが解放されていない */
 
    ret = clk_prepare_enable(dev->clk);
    if (ret)
        return ret;                   /* NG: clk と dev が解放されていない */
 
    dev->regs = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(dev->regs))
        return PTR_ERR(dev->regs);    /* NG: clk が有効なまま、dev が未解放 */
 
    /* ... */
    return 0;
}
 
/* OK: 正しいエラーハンドリング — gotoチェーンパターン */
static int good_probe(struct platform_device *pdev)
{
    struct my_dev *dev;
    int ret;
 
    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;
 
    dev->clk = clk_get(&pdev->dev, "main_clk");
    if (IS_ERR(dev->clk)) {
        ret = PTR_ERR(dev->clk);
        goto err_free_dev;            /* dev を解放 */
    }
 
    ret = clk_prepare_enable(dev->clk);
    if (ret)
        goto err_put_clk;             /* clk を put し、dev を解放 */
 
    dev->regs = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(dev->regs)) {
        ret = PTR_ERR(dev->regs);
        goto err_disable_clk;         /* clk を disable/put し、dev を解放 */
    }
 
    return 0;
 
err_disable_clk:
    clk_disable_unprepare(dev->clk);
err_put_clk:
    clk_put(dev->clk);
err_free_dev:
    kfree(dev);
    return ret;
}
 
/*
 * さらに良い方法: devm_* (device-managed) APIを使用
 * devm_ 系APIで確保したリソースはドライバのremove時に自動解放される
 */
static int best_probe(struct platform_device *pdev)
{
    struct my_dev *dev;
 
    /* devm_kzalloc: デバイスのライフサイクルに紐付けたメモリ確保 */
    dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;
 
    /* devm_clk_get: 自動解放されるクロック取得 */
    dev->clk = devm_clk_get(&pdev->dev, "main_clk");
    if (IS_ERR(dev->clk))
        return PTR_ERR(dev->clk);  /* devm_kzalloc分は自動解放 */
 
    /* devm_ioremap_resource: 自動解放されるI/Oメモリマッピング */
    dev->regs = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(dev->regs))
        return PTR_ERR(dev->regs);  /* 上記リソースすべて自動解放 */
 
    return 0;
    /* remove時: devm_* で確保した全リソースが逆順に自動解放 */
}

# === Step 1: デバイスファイルの種類を確認 ===
# 'b' = ブロック、'c' = キャラクタ
ls -la /dev/sda /dev/null /dev/tty0 /dev/random 2>/dev/null
 
# メジャー番号・マイナー番号の読み方
# crw-rw-rw- 1 root root 1, 3 ... /dev/null
#                         ^  ^
#                    major=1 minor=3
 
# === Step 2: ブロックデバイスの階層構造 ===
lsblk -o NAME,TYPE,SIZE,FSTYPE,MOUNTPOINT,MODEL
 
# === Step 3: PCIデバイスとドライバのマッピング ===
lspci -v | head -40
# "Kernel driver in use:" でどのドライバが使われているか確認
 
# === Step 4: ロード済みカーネルモジュールの調査 ===
lsmod | sort -k3 -rn | head -20
# 3列目(Used by)でソート → 依存関係が多いモジュールが上位に
 
# === Step 5: 割り込みの分布を確認 ===
cat /proc/interrupts | head -20
# 各CPU (CPU0, CPU1, ...) ごとの割り込み回数が表示される
 
# === Step 6: カーネルメッセージからドライバの動作を追跡 ===
dmesg | grep -i "driver\|probe\|loaded" | tail -20

# === Step 1: ヘッダパッケージの確認 ===
ls /lib/modules/$(uname -r)/build/
# Makefile, include/ 等が存在すれば OK
 
# === Step 2: モジュールソースの作成 ===
mkdir -p ~/driver_lab && cd ~/driver_lab
 
# hello_driver.c を作成（本章 2.2 のコードを使用）
# Makefile を作成（本章 2.2 のMakefileを使用）
 
# === Step 3: ビルド ===
make
# 成功すると hello_driver.ko が生成される
 
# === Step 4: モジュール情報の確認 ===
modinfo hello_driver.ko
 
# === Step 5: ロードとログ確認 ===
sudo insmod hello_driver.ko
dmesg | tail -5
lsmod | grep hello
 
# === Step 6: アンロードとログ確認 ===
sudo rmmod hello_driver
dmesg | tail -5
 
# === Step 7: パラメータ付きモジュールに拡張 ===
# hello_driver.c に以下を追加してみよう:
#   static int repeat = 1;
#   module_param(repeat, int, 0644);
#   MODULE_PARM_DESC(repeat, "Number of greeting repetitions");
# init関数内で repeat 回ループして pr_info を出力する

# === Step 1: ドライバのビルドとロード ===
cd ~/driver_lab
# simplechar.c を作成（本章 4.1 のコードを使用）
# Makefile の obj-m 行を修正: obj-m += simplechar.o
make
sudo insmod simplechar.ko
 
# === Step 2: デバイスノードの確認 ===
ls -la /dev/simplechar
# crw------- 1 root root 240, 0 ... /dev/simplechar
# (メジャー番号は動的に割り当てられるため異なる場合がある)
 
# パーミッション変更（テスト用）
sudo chmod 666 /dev/simplechar
 
# === Step 3: 書き込みテスト ===
echo "Hello, kernel driver!" > /dev/simplechar
dmesg | tail -3
 
# === Step 4: 読み取りテスト ===
cat /dev/simplechar
# "Hello, kernel driver!" が表示されるはず
 
# === Step 5: ddコマンドによるオフセット付き読み取り ===
dd if=/dev/simplechar bs=1 skip=7 count=6 2>/dev/null
# "kernel" が表示される
 
# === Step 6: 複数プロセスからの同時アクセステスト ===
# ターミナル1:
while true; do echo "Writer1: $(date)" > /dev/simplechar; done &
# ターミナル2:
while true; do cat /dev/simplechar; done &
# mutexによる排他制御が正しく機能していることを確認
 
# === Step 7: クリーンアップ ===
sudo rmmod simplechar
dmesg | tail -5