デバイスドライバと割り込み処理

					2022年01月21日
情報科学類 オペレーティングシステム II

                                       筑波大学 システム情報系 
                                       新城 靖
                                       <yas@cs.tsukuba.ac.jp>

このページは、次の URL にあります。
http://www.coins.tsukuba.ac.jp/~yas/coins/os2-2021/2022-01-21
あるいは、次のページから手繰っていくこともできます。
http://www.coins.tsukuba.ac.jp/~yas/
http://www.cs.tsukuba.ac.jp/~yas/

■今日の大事な話

ブロック型デバイスと非ブロック型(文字型)デバイス
file_operations 構造体
copy_from_user()とcopy_to_user()
inb() と outb()

割り込みコントローラ(ハードウェア)
IRQ
割り込みの前半部分と後半部分

■デバイス・ドライバ

デバイス・ドライバとは、オペレーティング・システム・カーネル内で動作するモジュールで、ディスクやキーボード等のデバイス（周辺装置）を管理し、入出力を制御する。

オペレーティング・システム・カーネルは、直接ハードウェアを操作するのではなく、デバイス・ドライバを通じて間接的に操作する。
デバイス・ドライバの外部仕様は、オペレーティング・システムごとに決めてある。その仕様に従ったデバイス・ドライバが用意されていれば、そのハードウェアが利用可能になる。
デバイス・ドライバは、ハードウェアを提供する会社がハードウェアとともに提供することが一般的。
デバイス・ドライバの実体は、数個のインタフェースが決められた関数の並び。

「オブジェクト指向」よりも、デバイスドライバの考え方が古い。

◆Unix系OSのデバイス・ドライバの種類

ブロック型。その名の通り、ブロック単位で入出力を行う。ハードディスク、SSD等、ファイル・システムを作るためのもの。
文字(character)型。今となっては、「文字」にはそれほどの意味はない。文字(バイト単位)で入出力できるものもあるが、そうではないものもある。
ネットワーク・インタフェース・カード用。
グラフィックス・カード用。
タイマ用。

◆メジャー番号とマイナー番号

ブロック型と文字型のデバイス・ドライバは、メジャー番号とマイナー番号の 2つの番号で区別される。利用者プログラムからそれらをアクセスする時には、 /dev 以下のファイルをアクセスする。

$ df / 
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda2            232431456  13088380 207345736   6% /
$ ls -l /dev/sda2 
brw-r----- 1 root disk 8, 2 Jan 24 12:00 /dev/sda2
$

ls -l で見ると、ブロック型は、b、文字型は、c で始まる。メジャー番号は、デバイスの種類、マイナー番号は、同じ種類で、細かい違い（上の例では、パーティション）等を意味する。

メジャー番号は、静的に決めうちにすることもあるが、 alloc_chrdev_region() を呼び、動的に割り当てられることもできる。使われているメジャー番号は、/proc/devices に現れる。 /dev/ の下にあるブロック型と文字型のファイルは、mknod コマンド (make node) で作ることができる。

# mknod b /dev/ファイル名 メジャー番号 マイナー番号 
# mknod c /dev/ファイル名 メジャー番号 マイナー番号

最近の Linux では、起動時に自動的に mknod が行われるので、手で mknod コマンドを打つ必要性はあまりない。

文字型デバイスの登録

まず、struct file_operations 構造体とその内部の関数群を定義する。その構造体を、struct cdev に設定する。最後に、struct cdev を、cdev_add() で登録する。

struct file_operations my_fops = { .... };
struct cdev *my_cdevp = cdev_alloc();
my_cdev->ops = &my_fops; 
my_cdev->owner = THIS_MODULE;

struct file_operations my_fops = { .... };
struct cdev my_cdev ;
cdev_init(&my_cdev,&my_fops);
cdev_add(&my_cdev,num, count)

register_chrdev() という関数で登録することもできる。以前はこの方法が主。

int register_chrdev(unsigned int major, const char *name,
    struct file_operations *fops);

cdev_device_add() でも良い。device_add() すると、/sys の sysfs からもアクセス可能になる。

linux-5.15.12/fs/char_dev.c
 537:	int cdev_device_add(struct cdev *cdev, struct device *dev)
 538:	{
...
 544:	                rc = cdev_add(cdev, dev->devt, 1);
...
 549:	        rc = device_add(dev);
..
 553:	        return rc;
 554:	}

◆file_operations構造体

file_operations構造体は、文字型でバイスのデバイス・ドライバのインタフェースを定めている構造体。インタフェースは、関数の集合として定義されている。

linux-5.15.12/include/linux/fs.h
2071:	struct file_operations {
2072:	        struct module *owner;
2073:	        loff_t (*llseek) (struct file *, loff_t, int);
2074:	        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
2075:	        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
2076:	        ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
2077:	        ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
2078:	        int (*iopoll)(struct kiocb *kiocb, bool spin);
2079:	        int (*iterate) (struct file *, struct dir_context *);
2080:	        int (*iterate_shared) (struct file *, struct dir_context *);
2081:	        __poll_t (*poll) (struct file *, struct poll_table_struct *);
2082:	        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
2083:	        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
2084:	        int (*mmap) (struct file *, struct vm_area_struct *);
2085:	        unsigned long mmap_supported_flags;
2086:	        int (*open) (struct inode *, struct file *);
2087:	        int (*flush) (struct file *, fl_owner_t id);
2088:	        int (*release) (struct inode *, struct file *);
2089:	        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
2090:	        int (*fasync) (int, struct file *, int);
2091:	        int (*lock) (struct file *, int, struct file_lock *);
2092:	        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
2093:	        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
2094:	        int (*check_flags)(int);
2095:	        int (*flock) (struct file *, int, struct file_lock *);
2096:	        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
2097:	        ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
2098:	        int (*setlease)(struct file *, long, struct file_lock **, void **);
2099:	        long (*fallocate)(struct file *file, int mode, loff_t offset,
2100:	                          loff_t len);
2101:	        void (*show_fdinfo)(struct seq_file *m, struct file *f);
2102:	#ifndef CONFIG_MMU
2103:	        unsigned (*mmap_capabilities)(struct file *);
2104:	#endif
2105:	        ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
2106:	                        loff_t, size_t, unsigned int);
2107:	        loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
2108:	                                   struct file *file_out, loff_t pos_out,
2109:	                                   loff_t len, unsigned int remap_flags);
2110:	        int (*fadvise)(struct file *, loff_t, loff_t, int);
2111:	} __randomize_layout;

主な手続きの意味

owner: モジュールの所有者。THIS_MODULE で初期化するのが普通。
open(): デバイス・ファイルが open() された時に実行したい関数を登録する。open() 時の処理が不要なら、NULL にする。NULL なら open() は成功する。
release(): close() システム・コールが呼ばれた時に実行される関数。
read(), read_iter(): デバイスからデータを読み出す。
write(), write_iter(): デバイスに対してデータを書き込む。
unlocked_ioctl(): システム・コール ioctl() が呼ばれた時の処理を書く。
flush(): ファイルを閉じる時に呼び出される。
llseek(): ファイル中の読み出し／書き込み位置を変更する。

◆inode 構造体

Linux カーネル内で、１つのファイルを表現する構造体。

デバイス・ファイルでは、open() 等で自分のメジャー番号とマイナー番号を取り出すために使われることがある。

◆file構造体

開いたファイルを表現するために使われる。

    int fd1 = open("file1");
    int fd2 = open("file1");

ファイル名 "file1" で表現されるファイルの inode 構造体は、1 個でも、 file 構造体は、2 個割り当てられる。

◆ioctl()システム・コール

デバイスには、それぞれ特殊な操作方法がある。read(), write() には合わないものがある。

例

CDを取り出す
シリアル回線の通信速度を変更する

このような特殊な操作は、システム・コールを増やすのではなく、全部 ioctl() システム・コールという特殊なシステム・コールを用いる。

int ioctl(int d, int request, ...);

第1引数: ファイル記述子。open() システム・コールで得られたもの。
第2引数: コマンド
第3引数: 引数や結果を保持するための構造体の先頭番地
結果: 成功すると 0。失敗すると、-1で、errnoにエラー番号が入る。

コマンドは、デバイス・ドライバごとにことなる。第3引数は、コマンドにより使われないことともある。

◆alloc_chrdev_region()

デバイスドライバで動的にメジャー番号とマイナー番号を割り割り当てるには、 alloc_chrdev_region() が使える。

◆device_create()

デバイスドライバで、mknod コマンドをを使わず/dev/ の下にデバイス・ファイルを作成するには、device_create() が使える。(/dev の他に、/sys 以下にもディレクトリが作られる。)

■x86 CMOS Real-Time Clock

CMOS RTC (Real-Time Clock) とは、バッテリ・バックアップされた時計。 CMOS や Real Time という名前が紛らわしいので、固有名詞と思うと良い。次の2つの機能がある。

TOD (time of day) clock: 時刻を、year/month/day hour:minute:second という形式で持つ。秒以下は読めない。 PCの主電源を切っていても、この時計はマザーボード上のバッテリで進み続ける。設定された日時に割り込みを起こす機能がある(alarm)。
定期的な割込み用: 2Hz から 8192Hz の範囲で、2 の冪乗の周期で定期的な割込み(periodic interrupt)を起こせる。

Linux は、起動時に TOD clock を読んで、自身が管理する時計を初期化する。以後、普段はこのハードウェアを読むことはしない。 Linuxが管理する時計は、ソフトウェア的に変更できる(date コマンド、 settimeofday() システム・コール)。 Linux では、1秒間に1回、内部的な時刻をこのハードウェアに保存している。

ハードウェアの内容は、hwclock コマンドで参照できる。

# hwclock --show 
Fri Jan 14 20:38:37 2022  -0.834124 seconds
# date 
Fri Jan 14 20:38:38 JST 2022
#

◆rtc-read-time.c

/dev/rtc は、CMOS RTC に対応した文字型デバイスのファイルである。これを開いて ioctl() でアクセスすると、CMOS RTC の内容が読める。

   1:	
   2:	/*
   3:	        ~yas/syspro/time/rtc-read-time.c -- Read CMOS Realtime Clock in Linux
   4:	        Created on: 2011/01/28 17:12:36
   5:	*/
   6:	
   7:	
   8:	#include <sys/types.h>  /* open() */
   9:	#include <sys/stat.h>   /* open() */
  10:	#include <fcntl.h>      /* open() */
  11:	#include <sys/ioctl.h>  /* ioctl() */
  12:	#include <unistd.h>     /* close() */
  13:	#include <stdio.h>      /* printf() */
  14:	#include <stdlib.h>     /* exit() */
  15:	#include <linux/rtc.h>  /*  RTC_RD_TIME */
  16:	
  17:	#define RTC_DEVICE_FILE "/dev/rtc"
  18:	
  19:	main()
  20:	{
  21:	    int fd;
  22:	    struct rtc_time t1 ;
  23:	        if( (fd = open( RTC_DEVICE_FILE, O_RDONLY ))< 0 )
  24:	        {
  25:	            perror("open");
  26:	            exit( 1 );
  27:	        }
  28:	        if( ioctl( fd, RTC_RD_TIME, &t1 ) < 0 )
  29:	        {
  30:	            perror("ioctl(RTC_RD_TIME)");
  31:	            exit( 2 );
  32:	        }
  33:	        printf("%04d-%02d-%02d %02d:%02d:%02d\n",
  34:	                t1.tm_year+1900, t1.tm_mon+1, t1.tm_mday,
  35:	                t1.tm_hour, t1.tm_min, t1.tm_sec );
  36:	        close( fd );
  37:	}

以下で説明する /dev/rtc のメジャー番号は、252、マイナー番号は、0。

$ ls -l /dev/rtc 
lrwxrwxrwx 1 root root 4 Oct 26 09:53 /dev/rtc -> rtc0
$ ls -l /dev/rtc0 
crw------- 1 root root 252, 0 Oct 26 09:53 /dev/rtc0
$ ls -lL /dev/rtc 
crw------- 1 root root 252, 0 Oct 26 09:53 /dev/rtc
$

open() システム・コールで、/dev/rtc を開いている。
ioctl() システム・コールを実行している。第2引数で RTC_RD_TIME を指定すると、RTC の内容を read (RD) できる。その結果は、第3引数に番地を指定した構造体 struct rtc_time に保存される。
printf() で得られた構造体 struct rtc_time の内容表示している。年には、1900 を加えている。月には、1 を加えている。

実行例

$ make rtc-read-time 
cc     rtc-read-time.c   -o rtc-read-time
$ su 
Password: 
# ./rtc-read-time 
2022-01-14 11:54:19
# ./rtc-read-time ; hwclock --show; date 
2022-01-14 11:54:21
Fri Jan 14 20:54:22 2022  -0.833925 seconds
Fri Jan 14 20:54:22 JST 2022
# ./rtc-read-time ; hwclock --show; date 
2022-01-14 11:54:23
Fri Jan 14 20:54:24 2022  -0.454304 seconds
Fri Jan 14 20:54:24 JST 2022
#

RTC_RD_TIME を含めて、/dev/rtc に対する ioctl() では、次のようなコマンドが使える。詳しくは、man rtc を参照。

/dev/rtc に対する ioctl() のコマンド
コマンド	説明
RTC_RD_TIME	RTCのTODを読む(read)
RTC_SET_TIME	RTCのTODに値をセットする
RTC_ALM_READ,RTC_ALM_SET	RTCのalarmを読む/セットする
RTC_IRQP_READ	alarmによる定期的な割り込みの(periodic interrupt)の周波数を読む/セットする
RTC_AIE_ON, RTC_AIE_OFF	alarmの割り込みを許可する/禁止する
RTC_UIE_ON, RTC_UIE_OFF	clockの更新後との割り込みを許可する/禁止する
RTC_PIE_ON, RTC_PIE_OFF	定期的な割り込みを許可する/禁止する
RTC_EPOCH_READ, RTC_EPOCH_SET	RTCのepoch (起点となる年月日) を読む/書く

◆drivers/rtc/{class.c,dev.c}

CMOS RTC のデバイスドライバは、drivers/rtc/{class.c,dev.c} 等にある。

linux-5.15.12/include/linux/types.h
  13:	typedef u32 __kernel_dev_t;
...
  16:	typedef __kernel_dev_t          dev_t;

linux-5.15.12/include/linux/kdev_t.h
   7:	#define MINORBITS       20
   8:	#define MINORMASK       ((1U << MINORBITS) - 1)
   9:	
  10:	#define MAJOR(dev)      ((unsigned int) ((dev) >> MINORBITS))
  11:	#define MINOR(dev)      ((unsigned int) ((dev) & MINORMASK))
  12:	#define MKDEV(ma,mi)    (((ma) << MINORBITS) | (mi))

linux-5.15.12/drivers/rtc/dev.c
  19:	static dev_t rtc_devt;

linux-5.15.12/drivers/rtc/dev.c
 459:	static const struct file_operations rtc_dev_fops = {
 460:	        .owner          = THIS_MODULE,
 461:	        .llseek         = no_llseek,
 462:	        .read           = rtc_dev_read,
 463:	        .poll           = rtc_dev_poll,
 464:	        .unlocked_ioctl = rtc_dev_ioctl,
 465:	#ifdef CONFIG_COMPAT
 466:	        .compat_ioctl   = rtc_dev_compat_ioctl,
 467:	#endif
 468:	        .open           = rtc_dev_open,
 469:	        .release        = rtc_dev_release,
 470:	        .fasync         = rtc_dev_fasync,
 471:	};

linux-5.15.12/drivers/rtc/dev.c
 496:	void __init rtc_dev_init(void)
 497:	{
...
 500:	        err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
 503:	}

linux-5.15.12/drivers/rtc/class.c
 376:	int __devm_rtc_register_device(struct module *owner, struct rtc_device *rtc)
 377:	{
...
 397:	        rtc_dev_prepare(rtc);
 398:	
 399:	        err = cdev_device_add(&rtc->char_dev, &rtc->dev);
...
 419:	}

linux-5.15.12/drivers/rtc/dev.c
 475:	void rtc_dev_prepare(struct rtc_device *rtc)
 476:	{
...
 485:	        rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
...
 492:	        cdev_init(&rtc->char_dev, &rtc_dev_fops);
 493:	        rtc->char_dev.owner = rtc->owner;
 494:	}

alloc_chrdev_region() 等で、メジャー番号とマイナー番号を割り当てる。上の ls -Ll /dev/rtc0 の例では、メジャー番号は 252、マイナー番号は、0。
cdev_init() と cdev_add() で、文字型デバイスとして登録する。
struct file_operations 構造体のインスタンス rtc_dev_fops には、owner, llseek(), read(), poll(), unlocked_ioctl(), open(), release(), fasync() というフィールドが初期化されている。その他は、NULLで初期化されている。

◆rtc_dev_open()

linux-5.15.12/drivers/rtc/dev.c
  23:	static int rtc_dev_open(struct inode *inode, struct file *file)
  24:	{
  25:	        struct rtc_device *rtc = container_of(inode->i_cdev,
  26:	                                        struct rtc_device, char_dev);
  27:	
  28:	        if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
  29:	                return -EBUSY;
  30:	
  31:	        file->private_data = rtc;
...
  37:	        return 0;
  38:	}

test_and_set_bit_lock() は、相互排除の仕組み。 test_and_set は、test することと set することを atomic にやる。
まず変数 &rtc->flagsの RTC_DEV_BUSY ビットをテストする。それがセットされていれば、どれかのプロセスにより open("/dev/rtc",) がされていて、 close() はされていない状態である。その場合は、EBUSY というエラーにして open() が失敗する。
変数 &rtc->flagsの RTC_DEV_BUSY ビットは、 test_and_set の結果、自動的にセットされる。
成功の意味の 0 を返す。

◆rtc_dev_release()

linux-5.15.12/drivers/rtc/dev.c
 437:	static int rtc_dev_release(struct inode *inode, struct file *file)
 438:	{
 439:	        struct rtc_device *rtc = file->private_data;
...
 455:	        clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
 456:	        return 0;
 457:	}

rtc_dev_open() でセットした変数 &rtc->flagsの RTC_DEV_BUSY ビットは、close() システム・コールで呼ばれる rtc_dev_release() ( struct file_operations rtc_fops の.release) で、クリアされる。

◆rtc_dev_ioctl()

linux-5.15.12/drivers/rtc/dev.c
 203:	static long rtc_dev_ioctl(struct file *file,
 204:	                          unsigned int cmd, unsigned long arg)
 205:	{
 206:	        int err = 0;
 207:	        struct rtc_device *rtc = file->private_data;
 208:	        const struct rtc_class_ops *ops = rtc->ops;
 209:	        struct rtc_time tm;
...
 254:	        switch (cmd) {
...
 255:	        case RTC_ALM_READ:
...
 266:	        case RTC_ALM_SET:
...
 318:	        case RTC_RD_TIME:
...
 321:	                err = rtc_read_time(rtc, &tm);
 322:	                if (err < 0)
 323:	                        return err;
 324:	
 325:	                if (copy_to_user(uarg, &tm, sizeof(tm)))
 326:	                        err = -EFAULT;
 327:	                return err;
 328:	
 329:	        case RTC_SET_TIME:
...
 332:	                if (copy_from_user(&tm, uarg, sizeof(tm)))
 333:	                        return -EFAULT;
 334:	
 335:	                return rtc_set_time(rtc, &tm);
 336:	
 395:	        }
...
 400:	}

ioctl() の処理をする関数には、switch 文があるのが普通。それで、コマンドごとに処理を振り分ける。
コマンド cmd が RTC_RD_TIME なら、rtc_read_time() を呼び、デバイスから時刻のデータを取得する。結果は、tm に返される。tm の内容を copy_to_user() で結果をユーザ空間にコピーする。
cmd が RTC_SET_TIME なら、copy_from_user() でユーザ空間からセットすべき値を取得する。関数 rtc_set_time() でデバイスに時刻のデータをセットする。

◆copy_from_user()とcopy_to_user()

デバイス・ドライバが動作するカーネル空間とユーザ空間では、「基本的に」異なるアドレス空間を持っている。たとえば、同じ 1000 番地でも、別の内容が含まれていることがある。

カーネル空間とユーザ空間でデータをコピーする時には、次のような特殊な関数を使う必要がある。

unsigned long
copy_to_user(void __user *to, const void *from, unsigned long n)

第1引数: ユーザ空間の番地(destination、コピー先)
第2引数: カーネル空間の番地(source、コピー元)
第3引数: コピーするバイト数
結果: 成功すると 0。失敗すると、コピーできなかったバイト数。

unsigned long
copy_from_user(void *to, const void __user *from, unsigned long n)

第1引数: カーネル空間の番地(destination、コピー先)
第2引数: ユーザ空間の番地(source、コピー元)
第3引数: コピーするバイト数
結果: 成功すると 0。失敗すると、コピーできなかったバイト数。

これらの関数は、コピーの途中でページフォールトが発生した時にもうまくコピーできる（ページインの処理でプロセスがスリープすることがある）。また、引数の番地が有効かどうかをチェックする。

Linux x86 アーキテクチャでは、カーネル空間とユーザ空間が一部重なっていることがある。この場合、カーネルでmemcpy() を使ったり、直接ポインタを操作してもユーザ空間がアクセスできてしまうが、それは誤りである。

◆rtc_read_time()

linux-5.15.12/drivers/rtc/interface.c
 110:	int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
 111:	{
...
 118:	        err = __rtc_read_time(rtc, tm);
...
 123:	}

  84:	static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
  85:	{
  86:	        int err;
...
  93:	                memset(tm, 0, sizeof(struct rtc_time));
  94:	                err = rtc->ops->read_time(rtc->dev.parent, tm);
...
 101:	                rtc_add_offset(rtc, tm);
...
 103:	                err = rtc_valid_tm(tm);
 107:	        return err;
 108:	}

linux-5.15.12/drivers/rtc/rtc-cmos.c
 562:	static const struct rtc_class_ops cmos_rtc_ops = {
 563:	        .read_time              = cmos_read_time,
 564:	        .set_time               = cmos_set_time,
 565:	        .read_alarm             = cmos_read_alarm,
 566:	        .set_alarm              = cmos_set_alarm,
 567:	        .proc                   = cmos_procfs,
 568:	        .alarm_irq_enable       = cmos_alarm_irq_enable,
 569:	};

 223:	static int cmos_read_time(struct device *dev, struct rtc_time *t)
 224:	{
...
 232:	        mc146818_get_time(t);
 233:	        return 0;
 234:	}

linux-5.15.12/drivers/rtc/rtc-mc146818-lib.c
  11:	unsigned int mc146818_get_time(struct rtc_time *time)
  12:	{
...
  23:	        spin_lock_irqsave(&rtc_lock, flags);
...
  40:	        time->tm_sec = CMOS_READ(RTC_SECONDS);
...
  60:	        time->tm_min = CMOS_READ(RTC_MINUTES);
  61:	        time->tm_hour = CMOS_READ(RTC_HOURS);
  62:	        time->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
  63:	        time->tm_mon = CMOS_READ(RTC_MONTH);
  64:	        time->tm_year = CMOS_READ(RTC_YEAR);
...
  87:	        spin_unlock_irqrestore(&rtc_lock, flags);
...
 114:	        if (time->tm_year <= 69)
 115:	                time->tm_year += 100;
 116:	
 117:	        time->tm_mon--;
...
 120:	}

CMOS_READ() というマクロを使って、ハードウェアをたたいている(入出力を行っている)
複数のプログラムでハードウェアを同時にたたかないようにロックを行っている。

◆入出力の方法

CPU が持つ入出力命令を使うもの。どのデバイスをアクセスするかは、ポート番号で指定する。
通常のメモリアクセスの命令を使うもの(memory mapped I/O)。どのデバイスをアクセスするかは、番地で指定する。

x86 CMOS RTC は、前者。

◆outb()とinb()

Linux における入出力命令を使った入出力は、inb() と outb() で行われる。

void outb(unsigned char value, unsigned short port)
  ポート番号 port に 1 バイトの value を出力する

unsigned char inb(unsigned short port)
  ポート番号 port から 1 バイトの value を入力してその値を返す

1 バイト 8 ビットではなくて 2 バイト 16 ビット単位のもの (inw(), outw()) や4 バイト 32 ビット単位のもの( inl(), outl() ) もある。

◆CMOS RTCの入出力ポート

x86 CMOS RTC は、ポート番号 0x70 と 0x71 の入出力ポートを使う。

0x70: インデックス用ポート。out のみ
0x71: データ用ポート。in と out

データを読む方法

インデックス用ポートに読みたい日付やデータのインデックス (RTC_SECONDS, RTC_MINUTES, RTC_HOURS, RTC_DAY_OF_MONTH, RTC_MONTH, RTC_YEAR)を out する。
直後にデータ用ポートらか in する

データを書く方法

インデックス用ポートに読みたい日付やデータのインデックスを out する。
直後にデータ用ポートにデータを out する

◆rtc_cmos_read()

linux-5.15.12/arch/x86/include/asm/mc146818rtc.h
  11:	#ifndef RTC_PORT
  12:	#define RTC_PORT(x)     (0x70 + (x))
...
  93:	#define CMOS_READ(addr) rtc_cmos_read(addr)
  94:	#define CMOS_WRITE(val, addr) rtc_cmos_write(val, addr)

linux-5.15.12/arch/x86/kernel/rtc.c
 126:	unsigned char rtc_cmos_read(unsigned char addr)
 127:	{
 128:	        unsigned char val;
 129:	
 130:	        lock_cmos_prefix(addr);
 131:	        outb(addr, RTC_PORT(0));
 132:	        val = inb(RTC_PORT(1));
 133:	        lock_cmos_suffix(addr);
 134:	
 135:	        return val;
 136:	}
...
 139:	void rtc_cmos_write(unsigned char val, unsigned char addr)
 140:	{
 141:	        lock_cmos_prefix(addr);
 142:	        outb(addr, RTC_PORT(0));
 143:	        outb(val, RTC_PORT(1));
 144:	        lock_cmos_suffix(addr);
 145:	}

linux-5.15.12/include/linux/mc146818rtc.h
  50:	#define RTC_SECONDS             0
  51:	#define RTC_SECONDS_ALARM       1
  52:	#define RTC_MINUTES             2
  53:	#define RTC_MINUTES_ALARM       3
  54:	#define RTC_HOURS               4
  55:	#define RTC_HOURS_ALARM         5
...
  59:	#define RTC_DAY_OF_WEEK         6
  60:	#define RTC_DAY_OF_MONTH        7
  61:	#define RTC_MONTH               8
  62:	#define RTC_YEAR                9

CMOS_READ() は、rtc_cmos_read() のマクロ
rtc_cmos_read() では、outb() と inb() でハードウェアをたたいている。
rtc_cmos_read() では、outb() と inb() をアトミックに行うために lock_cmos_prefix()と lock_cmos_suffix()でロックを行っている。
RTC のハードウェア、ポート番号 0x70 (RTC_PORT(0))と 0x71 (RTC_PORT(1))に見えている。

◆outb()とinb()の実装(インライン関数)

次のファイルにある定義は、読みやすい。

linux-5.15.12/arch/x86/boot/boot.h
  39:	static inline void outb(u8 v, u16 port)
  40:	{
  41:	        asm volatile("outb %0,%1" : : "a" (v), "dN" (port));
  42:	}
  43:	static inline u8 inb(u16 port)
  44:	{
  45:	        u8 v;
  46:	        asm volatile("inb %1,%0" : "=a" (v) : "dN" (port));
  47:	        return v;
  48:	}

u8 は、unsigned の 8 ビットの整数(unsigned char)
u16 は、unsigned の 16 ビットの整数(unsigned short)
volatile をつけると、コンパイラによる最適化（命令の順番の入れ替え等）を抑止できる。

◆asm()文

C言語のプログラムの中にアセンブリ言語のプログラムを混ぜて書く方法。

asm ( "アセンブラの命令列"
 : 出力オペランド(省略可)
 : 入力オペランド(省略可)
 : 破壊するレジスタ(省略可) )

オペランドの形式: 「"制約"(Cの値)」
制約で、使えるレジスタ(a,b,c,d等)が書ける。 "アセンブラの命令列" の所で、%0, %1, %2 等で参照できる。
制約で = があると、書き込み専用になる。
制約で "N" は、0以上、256以下の数。
オペランドは、「,」で区切って複数書ける

◆outb()とinb()の実装(マクロ)

次の定義を使うこともある。C言語のプリプロセッサで次のように組み立てられるinline 関数として定義されている。

linux-5.15.12/arch/x86/include/asm/io.h
 274:	#define BUILDIO(bwl, bw, type)                                          \
 275:	static inline void out##bwl(unsigned type value, int port)              \
 276:	{                                                                       \
 277:	        asm volatile("out" #bwl " %" #bw "0, %w1"                       \
 278:	                     : : "a"(value), "Nd"(port));                       \
 279:	}                                                                       \
 280:	                                                                        \
 281:	static inline unsigned type in##bwl(int port)                           \
 282:	{                                                                       \
 283:	        unsigned type value;                                            \
 284:	        asm volatile("in" #bwl " %w1, %" #bw "0"                        \
 285:	                     : "=a"(value) : "Nd"(port));                       \
 286:	        return value;                                                   \
 287:	}                                                                       \
...
 334:	BUILDIO(b, b, char)
 335:	BUILDIO(w, w, short)
 336:	BUILDIO(l, , int)

Cプリプロセッサで、「id1##id2」は、識別子(関数名、変数名等)の結合を意味する。たとえば、マクロ定義の引数 bwl が値 b を持っていれば、out##bwl は、outb となる。 (「#」がなければ、「out bwl」は、「out b」と間に空白が残る)。
Cプリプロセッサで、「#var」は、文字列化。たとえば、マクロ定義の引数 bwl が値 b を持っていれば、#bwl は、"b" となる。 (「#」がなければ、bwl は、b )。
C言語の機能で、文字列を並べると、結合される。たとえば、「"out" "b" 」は、「"outb"」となる。
inb(), outb() は、BUILDIO(b,b,char)で作られる。
inb() は、inb 命令に展開される。
outb() は、outb 命令に展開される。
%0, %1, ..., は、0 番目、1番目、...の引数。
%w0, %w1, ..., は、0 番目、1番目、...の引数。16ビット。
%b0, %b1, ..., は、0 番目、1番目、...の引数。8ビット。
%%a, %%b, ..., は、%eax レジスタ、%ebx レジスタ, ...。

Cプリプロセッサを通し、文字列の結合を行うと、次のようになる。

static inline unsigned char inb(int port) {
    unsigned char value;
    asm volatile("inb %w1, %b0" : "=a"(value) : "Nd"(port));
    return value;
}

static inline void outb(unsigned char value, int port) {
    asm volatile("outb %b0, %w1" : : "a"(value), "Nd"(port));
}

◆/proc/ioports

/proc/ioports を見ると、使われている入出力ポートがわかる。

$ cat /proc/ioports 
0000-0cf7 : PCI Bus 0000:00
  0000-001f : dma1
  0020-0021 : PNP0001:00
    0020-0021 : pic1
  0040-0043 : timer0
  0050-0053 : timer1
  0060-0060 : keyboard
  0061-0061 : PNP0800:00
  0064-0064 : keyboard
  0070-0073 : rtc0
  0080-008f : dma page reg
...
0d00-feff : PCI Bus 0000:00
...
  e000-efff : PCI Bus 0000:19
$

■割り込み

◆割り込みの必要性

デバイス(ディスク、ネットワーク、キーボード、マウス、・・・)は、 CPU と比較すると遅い。
デバイスに要求を出して、応答を待っていると、CPU の無駄になる。
CPUを無駄にしない方法
- ポーリング(polling): 定期的にカーネルがデバイスの状態をチェックする。チェックする間隔が短いと、無駄が多くなる。間隔が長いと、応答が遅くなる。
- 割り込み(interrupt): デバイスがカーネルに処理が必要なことを通知する仕組みを作る。

◆割り込みとは

入出力デバイスから「何かが起きた」というイベントを通知してもらう仕組み。
通信の一種とも考えられるが、それだけでは「タイミング」しかわからないので、 1ビットのデータも送受信されない。
割り込みは、次のような時に使われる。
- 入力データが到着した（利用者がキーボードやマウスを操作した、ネットワークからパケットが到着した、ディスクらかの入力が完了した）。
- 出力が完了した＝＝出力バッファが空になった＝＝次の出力が可能になった
CPUは、割り込み信号を受けとると現在実行中のプログラムを一時中断して、「割り込みハンドラ」や「割り込みサービスルーチン」と呼ばれるプログラムに制御を移す。
割り込みハンドラでは、入力処理や次の出力処理を行う。
割り込みハンドラの処理が終了すると、一時中断していたプログラムの実行を再開する。

システム・コールやページフォールトは、入出力デバイスではなく CPU 内部から発生する。これを、例外(exception)という。例外は、割り込みの一種として扱われることが多い。

◆x86の割り込みコントローラ

Intel 8259 Programmable Interrupt Controller(PIC)
Intel Advanced Programmable Interrupt Controller (APIC)

◆Intel 8259 PIC

8259、8259、CPU
図? x86 の Intel 8259

15 個の割り込み要求線 (Interrupt Request (IRQ) Lines) がある。
割り込みが生じると、INT 線を上げる。
CPU が割り込みを受け付けると、INTA (Interrupt Acknowledge) を上げる。
8259 は、CPU に割り込みベクタと呼ばれる番号を出力する。 IRQ の番号(0から15)と割り込みベクタの対応関係は、変えられる。 x86 Linux では、IRQ0 ならば、0x30, IRQ1 は、0x31, ...., IRQ15 なら 0x3F を使う。
CPU は、割り込みベクタに対応した割り込みハンドラを実行する。
x86 では、8259 を 2 個カスケードしている。
2段目の 8259 の INT 線は、1段目の 2 番に入っている。

◆APIC

Local APIC、Core、I/O APIC
図? x86 の APIC

APIC は、次のような割り込み信号を受け取る。

プロセッサのピン(L_INT0, L_INT1)
内部のタイマ
内部のパフォーマンス・モニタ
内部の温度センサ
内部のAPICエラー
他のプロセッサ(プロセッサ間割り込み)
外部の I/O APIC。普通、24個の割り込みを受付可能。

◆例外

例外(exceptions) とは、ハードウェア・デバイスとは無関係に、 CPU の命令実行の途中で生じる。

例:

0 による割り算
ページ・フォールト
例外を生じるCPU命令の実行(x86 int 命令)

多くの CPU アーキテクチャでは、例外を割り込みと同じように扱う。 x86 では、システム・コールの処理も、割り込みと同じように扱う。

◆割り込みハンドラ

割り込みハンドラ(interrupt handlers)とは、割り込みが生じた時にそれに応答するために実行される関数。割り込みサービスルーチン(interrupt service routine, ISR)とも呼ばれる。

例:

キーボード用
タイマ用
ハードディスク用

Linux では、割り込みハンドラは、C言語の関数。普通の関数との違い。

割り込みに関する情報が渡される
「割り込みコンテキスト」や「アトミック・コンテキスト」という、制約がきつい状態で呼ばれる。
割り込みは、いつ生じるか予測不能なので、割り込みハンドラは、いつ呼ばれるか予測不能。

◆割り込み記述子テーブル

割り込みハンドラは、割り込み記述子テーブル(interrupt descriptor tables)や割り込みベクタテーブル(interrupt vector table)と呼ばれる表に登録されている。(CPUの違い、同じCPU x86でもモードの違いで、テーブルの名前が異なる。)

割り込み番号、割り込み記述子テーブル、割り込みハンドラ
図? 割り込み記述子テーブルと割り込みハンドラ

割り込み記述子テーブルは、意味としては、関数へのポインタの配列。
```
typedef void (*funcp_t)(void);
funcp_t idt[256];
```
CPU は、ハードウェアから割り込みがなされると、実行中のプログラムを中断する。後に再開できるように、プログラムカウンタ、実行モード等を含むフラグを保存する。
```
  old_pc    = pc;
  old_flags = flags;
```
CPU は、ハードウェアが出力する割り込みベクタを使って、割り込み記述子テーブルのエントリを選択する。
```
   n = 割り込みベクタ;
   handler = idt[n];
```
選択したエントリを実行する（プログラム・カウンタにセットする）。
```
   push old_pc;
   push old_flags;
   pc = handler;     // (*handler)();
```
ただし、単純な call 命令とは違い、スタック上にプログラムカウンタの他に、プロセッサの状態を示すフラグ等も積む。
各割り込みハンドラは、最後に通常のリターン命令 ret ではなく割り込みから復帰するための命令 iret (x86) を実行する。すると、CPU は、割り込み前に実行していたコードに戻る。

◆割り込みの前半部分と後半部分

次の２つを両立させたい

割り込みハンドラは、できるだけ速く実行して、元の処理に制御を返す必要がある。割り込み禁止の時間を短くしたい。デバイスからしても、処理が速やかに行われることを期待している。
割り込みハンドラの処理は、時に複雑で時間がかかる処理を行いたい。例：ネットワークからのパケットの受信。TCP/IPのプロトコルを処理したい。

Linux では、これを両立するために、割り込みの処理を2つに分ける。

前半(top half)。割り込み後、即座に実行する。時間制約のあるものだけを実行する。例：ハードウェアに対する通知。
後半(bottom half)。割り込みの後、都合のよい時期にやる。その後の割り込みを許可した状態で行う。

例: ネットワークカードによるメッセージの受信

前半で、ハードウェアへの通知と、データのメモリへのコピー。（ハードウェアのバッファを開放する）
後半で、TCP/IP の処理。

◆割り込み番号の共有

割り込み信号線が足りない時に、1つの割り込み番号を、複数のデバイスで共有することがある。

デバイス5個、OR回路、PIC、CPU
図? PICの線が不足した時の対応

割り込みが生じた時には、どのデバイスのものかすぐには分からない。
割り込みが生じると、可能性がある全てのデバイスの割り込みハンドラを次々と呼び出す。

■Linuxにおける割り込みハンドラの登録

Linux で、割り込みの前半部を登録するには、request_irq() を使う。登録を解除するには、free_irq() を使う。

◆request_irq()

CPUアーキテクチャに独立した形で割り込みハンドラを登録するには、 request_irq() を用いる。

include/linux/interrupt.h

typedef irqreturn_t (*irq_handler_t)(int, void *);

request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
            const char *name, void *dev)

irq: 割り込み番号。
handler: 割り込みハンドラ。
flags: フラグ。後述。
name: 名前。/proc/interrupts や /proc/irq に現れる。
dev: デバイス。割り込みが複数のデバイスで共有される時に、どのデバイスかを区別するために使われる。普通は、構造体へのポインタ。割り込みハンドラ irq_handler_t handler が呼ばれた時にも、この値が引数で渡される。 free_irq() で割り込みハンドラを削除する時には、この値が cookie として働く。
結果: 成功すると 0を返し、失敗すると 0 以外を返す。たとえば、-EBUSY だと割り込み番号が使われている。

主なフラグ

IRQF_DISABLED: 割り込みハンドラの実行中、「全ての」割り込みを禁止する。このフラグがセットされていなければ、自分自身だけ禁止され、他の割り込みは許可された状態で動作する。
IRQF_SAMPLE_RANDOM: 乱数生成器のために割り込みを利用してもよい。
IRQF_TIMER: システム・タイマのために利用する。
IRQF_SHARED: 複数のデバイスで同じ割り込み番号を共有できる。

◆free_irq()

割り込みハンドラが不要になった時には、free_irq() で取り除く。

void free_irq(unsigned int, void *dev)

irq: 割り込み番号。
dev: request_irq() で指定したデバイス。

◆irq_handler_t handler

割り込みハンドラは、次のような関数である。

irqreturn_t handler(int irq, void *dev)

irq: 割り込み番号。
dev: request_irq() で指定したデバイス。
結果: 結果は、irqreturn_t 。

IRQ_NONE: 割り込みは、自分自身のものではなかった。
IRQ_HANDLED: 割り込みをきちんと処理した。

全割り込みハンドラが IRQ_NONE を返せば、なんらかのトラブルを意味する。複数の割り込みハンドラが IRQ_HANDLED を返すことは正常。

◆/proc/interrupts

/proc/interrupts は、割り込みの回数を保持している。

$ cat /proc/interrupts  
           CPU0       CPU1       
  0:    4208761      38584    IO-APIC-edge  timer
  1:          0          3    IO-APIC-edge  i8042
  7:          0          0    IO-APIC-edge  parport0
  8:          1          2    IO-APIC-edge  rtc
  9:          0          0   IO-APIC-level  acpi
 12:          3          1    IO-APIC-edge  i8042
 50:       5380      86508         PCI-MSI  ahci
 74:        346          0         PCI-MSI  HDA Intel
 98:        294      28232         PCI-MSI  eth1
169:        130      57006   IO-APIC-level  uhci_hcd:usb3
177:          0          0   IO-APIC-level  uhci_hcd:usb4, uhci_hcd:usb7
217:        358     149530   IO-APIC-level  ehci_hcd:usb1, uhci_hcd:usb5
225:          0          0   IO-APIC-level  ehci_hcd:usb2, uhci_hcd:usb6
233:          0          0   IO-APIC-level  uhci_hcd:usb8
NMI:          0          0 
LOC:    4246864    4246863 
ERR:          0
MIS:          0
$

CPU が 2 個ある。
CPU ごとに割り込みの回数が異なる。
IRQ 0 にシステム・タイマ timer が見える。
IRQ 8 に x86 CMOS RTC が見える。
LOC (Local timer interrupts) も CPU 毎のタイマ。

◆x86 CMOS Real-Time Clock rtc_interrupt()

x86 CMOS Real-Time Clock での割り込みハンドラの例。

linux-5.15.12/arch/x86/include/asm/mc146818rtc.h
 101:	#define RTC_IRQ 8

linux-5.15.12/drivers/rtc/rtc-cmos.c
  73:	struct cmos_rtc {
  74:	        struct rtc_device       *rtc;
  75:	        struct device           *dev;
  76:	        int                     irq;
....
  92:	};

 636:	static struct cmos_rtc  cmos_rtc;

 693:	static int INITSECTION
 694:	cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 695:	{
...
 785:	        cmos_rtc.rtc = devm_rtc_allocate_device(dev);
...
 846:	                        rtc_cmos_int_handler = cmos_interrupt;
...
 848:	                retval = request_irq(rtc_irq, rtc_cmos_int_handler,
 849:	                                0, dev_name(&cmos_rtc.rtc->dev),
 850:	                                cmos_rtc.rtc);
...
 861:	        retval = devm_rtc_register_device(cmos_rtc.rtc);
...
 894:	}

 638:	static irqreturn_t cmos_interrupt(int irq, void *p)
 639:	{
 640:	        u8              irqstat;
...
 652:	        irqstat = CMOS_READ(RTC_INTR_FLAGS);
...
 679:	        if (is_intr(irqstat)) {
 680:	                rtc_update_irq(p, 1, irqstat);
 681:	                return IRQ_HANDLED;
 682:	        } else
 683:	                return IRQ_NONE;
 684:	}

x86 CMOS Real-Time Clock では、3種類の割り込み(alarmの時刻になった、更新が完了した、定期的な割り込み) がある。どの割り込みでも、割り込みハンドラ cmos_interrupt() が呼ばれる。
irqstat は、unsigned char で、その回の割り込みのフラグを CMOS_READ() でデバイスから読み出して保存する。
rtc_update_irq()、schedule_work()、rtc_timer_do_work()で、何か timer->func が登録されていれば、それを実行する。 schedule_work() は、割り込みの後半の処理仕組み。説明は、後日行う。

■Linuxにおける割り込みハンドラの実行

ハードウェア依存のコードからハードウェア独立のコードを呼び出す。

◆x86 Interrupt Descriptor Table (IDT)

x86 IDT は、ハードウェア・レベルの割り込みハンドラの一覧表を保持する。その先頭番地は、IDTR レジスタに保存される。

linux-5.15.12/arch/x86/kernel/traps.c
1190:	void __init trap_init(void)
1191:	{
...
1201:	        idt_setup_traps();
...
1203:	}

linux-5.15.12/arch/x86/include/asm/trapnr.h
   7:	#define X86_TRAP_DE              0      /* Divide-by-zero */
   8:	#define X86_TRAP_DB              1      /* Debug */
   9:	#define X86_TRAP_NMI             2      /* Non-maskable Interrupt */
  10:	#define X86_TRAP_BP              3      /* Breakpoint */
  11:	#define X86_TRAP_OF              4      /* Overflow */
  12:	#define X86_TRAP_BR              5      /* Bound Range Exceeded */
  13:	#define X86_TRAP_UD              6      /* Invalid Opcode */
  14:	#define X86_TRAP_NM              7      /* Device Not Available */

linux-5.15.12/arch/x86/include/asm/irq_vectors.h
  45:	#define IA32_SYSCALL_VECTOR             0x80
...
 109:	#define NR_VECTORS                       256

linux-5.15.12/arch/x86/kernel/idt.c
 159:	static gate_desc idt_table[IDT_ENTRIES] __page_aligned_bss;

  79:	static const __initconst struct idt_data def_idts[] = {
  80:	        INTG(X86_TRAP_DE,               asm_exc_divide_error),
  81:	        ISTG(X86_TRAP_NMI,              asm_exc_nmi, IST_INDEX_NMI),
  82:	        INTG(X86_TRAP_BR,               asm_exc_bounds),
  83:	        INTG(X86_TRAP_UD,               asm_exc_invalid_op),
  84:	        INTG(X86_TRAP_NM,               asm_exc_device_not_available),
...
 114:	        SYSG(IA32_SYSCALL_VECTOR,       entry_INT80_32),
...
 116:	};

 218:	void __init idt_setup_traps(void)
 219:	{
 220:	        idt_setup_from_table(idt_table, def_idts, ARRAY_SIZE(def_idts), true);
 221:	}

linux-5.15.12/arch/x86/include/asm/idtentry.h
  29:	#define DECLARE_IDTENTRY(vector, func)                                  \
  30:	        asmlinkage void asm_##func(void);                               \
  31:	        asmlinkage void xen_asm_##func(void);                           \
  32:	        __visible void func(struct pt_regs *regs)

 546:	DECLARE_IDTENTRY(X86_TRAP_DE,           exc_divide_error);
 547:	DECLARE_IDTENTRY(X86_TRAP_OF,           exc_overflow);
 548:	DECLARE_IDTENTRY(X86_TRAP_BR,           exc_bounds);
 549:	DECLARE_IDTENTRY(X86_TRAP_NM,           exc_device_not_available);

linux-5.15.12/arch/x86/kernel/traps.c
 201:	DEFINE_IDTENTRY(exc_divide_error)
 202:	{
 203:	        do_error_trap(regs, 0, "divide error", X86_TRAP_DE, SIGFPE,
 204:	                      FPE_INTDIV, error_get_trap_addr(regs));
 205:	}

 969:	SYM_FUNC_START(entry_INT80_32)
...
 971:	        pushl   %eax                    /* pt_regs->orig_ax */
 972:	
 973:	        SAVE_ALL pt_regs_ax=$-ENOSYS switch_stacks=1    /* save rest */
 974:	
 975:	        movl    %esp, %eax
 976:	        call    do_int80_syscall_32
...
 997:	        iret

linux-5.15.12/arch/x86/entry/common.c
 118:	/* Handles int $0x80 */
 119:	__visible noinstr void do_int80_syscall_32(struct pt_regs *regs)
 120:	{
...
 132:	        do_syscall_32_irqs_on(regs, nr);
...
 136:	}

linux-5.15.12/arch/x86/entry/common.c
 102:	static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs, int nr)
 103:	{
 108:	        unsigned int unr = nr;
...
 112:	                regs->ax = ia32_sys_call_table[unr](regs);
 116:	}

trap_init() は、idt_setup_traps() を呼び、IDT idt_table[] を初期化する。 idt_setup_traps() は、def_idts[] の内容を idt_table[] へコピーしている。
ITD のインデックスは、割り込みベクタ。
割り込みベクタは、0 から 0xff まである。0 から 0x1f は、Intel により使い方が決められている。
- X86_TRAP_DE は、0 番。ゼロによる割り算。
- X86_TRAP_NMI は、2 番。non-maskable interrupt。割り込み禁止にできない割り込み。
- X86_TRAP_BP は、3 番。1バイトの命令の実行。デバッガがブレーク・ポイントを設定するのに使う。
asm_exc_divide_error() は、アセンブリ言語のマクロ idtentry で asm_ がつかないC 言語の関数exc_divide_error() を呼ぶ。これは、 do_error_trap()を呼び、プロセス実行中ならそのプロセスにシグナルが送られる。
割り込みベクタ 0x80 で、entry_INT80_32() という、アセンブリ言語で書かれた関数(arch/x86/entry/entry_32.S)が登録されている。
entry_INT80_32() は、C 言語の関数、do_int80_syscall_32() を呼び、それは、do_syscall_32_irqs_on() を呼ぶ。それは、sys_call_table[] の、システムコール番号の関数を呼ぶ。
sys_call_table[] については、システム・コールの表 sys_call_table 参照。

◆irq_entries_start()

x86 Linux では、デバイスからの割り込みが発生すると Interrupt Descriptor Table に従い、 irq_entries_start() が呼ばれる。
それは、common_interrupt() 、handle_irq()、__handle_irq() を経由して generic_handle_irq_desc() を呼ぶ。
generic_handle_irq_desc() 以降は、アーキテクチャから独立した処理が行われる。

◆__handle_irq_event_percp()

linux-5.15.12/kernel/irq/handle.c
 137:	irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
 138:	{
 139:	        irqreturn_t retval = IRQ_NONE;
 140:	        unsigned int irq = desc->irq_data.irq;
 141:	        struct irqaction *action;
...
 145:	        for_each_action_of_desc(desc, action) {
 146:	                irqreturn_t res;
...
 156:	                res = action->handler(irq, action->dev_id);
..
 163:	                switch (res) {
...
 177:	                case IRQ_HANDLED:
 178:	                        *flags |= action->flags;
 179:	                        break;
 180:	
 181:	                default:
 182:	                        break;
 183:	                }
 184:	
 185:	                retval |= res;
 186:	        }
 187:	
 188:	        return retval;
 189:	}

linux-5.15.12/kernel/irq/internals.h
 161:	#define for_each_action_of_desc(desc, act)                      \
 162:	        for (act = desc->action; act; act = act->next)

struct irqaction *action は、 action->next でリスト構造を作っている。
各構造体に含まれている action->handler() を順に呼び出す。 handlerは、request_irq() で登録された関数。
handler は、IRQ_HANDLED か IRQ_NONE を返す。複数の handler のうち１つでも IRQ_HANDLED を返せば OK。

■割り込みハンドラのプログラミングの注意点

◆割り込みコンテキスト(アトミック・コンテキスト)

割り込みハンドラが実行されるのは、「割り込みコンテキスト(アトミック・コンテキスト)」。普通のシステム・コールの処理が実行される「プロセス・コンテキスト」とは異なる。

プロセス・コンテキストでできること。

current により、現在実行中のプロセスの task 構造体がアクセスできる。
sleep できる。
スケジューラを呼んで、他のプロセスへ切替えることができる。

割り込みコンテキストでは、このうようなことはできない。速やかに終了すべきである。busy loop はできるが、あまりやらない方がよい。他の割り込みは、実行される可能性もある。

◆割り込みの許可・禁止

マクロをつかって割り込みを禁止したり、許可したり(以前の状態に戻したり)する。

unsigned long flags;

local_irq_save(flags); /* 割り込み禁止。マクロ。 */
...
local_irq_restore(flags); /* 割り込み許可 (save の時の状態にもどる) */

単一CPUの x86 では、cli() と sti() で割り込みの禁止と許可を設定する方法があった。それそれ同名の CPU の命令を実行して、全ての割り込みを禁止/許可する。マルチプロセッサ(マルチコア含む)では、1つのCPU で割り込みを禁止しても、他の CPU では許可されていることがあるので、cli()/sti() の方法は使えない。

特定の割り込み番号の割り込みを禁止する方法もある。

void disable_irq(unsigned ing irq);
    // 全CPUの割り込みを禁止する

void disable_irq_nosync(unsigned ing irq);
    // 同上。ただし、割り込みハンドラの終了を待たない。

void enable_irq(unsigned ing irq);
    // 割り込みを許可する。

void synchronize_irq(unsigned ing irq);
    // 割り込みハンドラの終了を待つ。

■課題3 デバイスドライバと割り込み処理

授業時間中に Manaba の小テストに回答しなさい。

なるべく授業時間中に次の問題を解き、Manaba の「レポート」で回答しなさい。

★問題(301) x86 CMOS RTCからの月データの入力

次のプログラムは、x86 CMOS RTC ハードウェアから月(month)データを読み出し変数 month に入れるプログラムの一部である。/*空欄(a)*/と/*空欄(b)*/を埋めて完成させなさい。

    unsigned char month;
    outb( /*空欄(a)*/, 0x70 );
    month = inb( /*空欄(b)*/ );

★問題(302) 割り込みコンテキスト

割り込みハンドラが実行されるのは、割り込みコンテキスト、または、アトミック・コンテキストと呼ばれる特殊なコンテキストである。一方、システム・コールの処理の処理が行われるのは、プロセス・コンテキストと呼ばれる。

drivers/rtc/{class.c,dev.c,rtc-cmos.c} で定義されて、このページで説明している関数のうち、次のものを１つ上げなさい。

割り込みコンテキストで実行されると思われるもの:
プロセスコンテキストで実行されると思われるもの:

Last updated: 2022/01/31 21:55:23

Yasushi Shinjo / <yas@cs.tsukuba.ac.jp>