デバイスドライバと割り込み処理、inb()とoutb()

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

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

このページは、次の URL にあります。
http://www.coins.tsukuba.ac.jp/~yas/coins/os2-2019/2020-01-24
あるいは、次のページから手繰っていくこともできます。
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 = &my_fops;

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);

◆file_operations構造体

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

linux-5.4.7/include/linux/fs.h
1821:	struct file_operations {
1822:	        struct module *owner;
1823:	        loff_t (*llseek) (struct file *, loff_t, int);
1824:	        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
1825:	        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
1826:	        ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
1827:	        ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
1828:	        int (*iopoll)(struct kiocb *kiocb, bool spin);
1829:	        int (*iterate) (struct file *, struct dir_context *);
1830:	        int (*iterate_shared) (struct file *, struct dir_context *);
1831:	        __poll_t (*poll) (struct file *, struct poll_table_struct *);
1832:	        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
1833:	        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
1834:	        int (*mmap) (struct file *, struct vm_area_struct *);
1835:	        unsigned long mmap_supported_flags;
1836:	        int (*open) (struct inode *, struct file *);
1837:	        int (*flush) (struct file *, fl_owner_t id);
1838:	        int (*release) (struct inode *, struct file *);
1839:	        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1840:	        int (*fasync) (int, struct file *, int);
1841:	        int (*lock) (struct file *, int, struct file_lock *);
1842:	        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
1843:	        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
1844:	        int (*check_flags)(int);
1845:	        int (*flock) (struct file *, int, struct file_lock *);
1846:	        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
1847:	        ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
1848:	        int (*setlease)(struct file *, long, struct file_lock **, void **);
1849:	        long (*fallocate)(struct file *file, int mode, loff_t offset,
1850:	                          loff_t len);
1851:	        void (*show_fdinfo)(struct seq_file *m, struct file *f);
1852:	#ifndef CONFIG_MMU
1853:	        unsigned (*mmap_capabilities)(struct file *);
1854:	#endif
1855:	        ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
1856:	                        loff_t, size_t, unsigned int);
1857:	        loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
1858:	                                   struct file *file_out, loff_t pos_out,
1859:	                                   loff_t len, unsigned int remap_flags);
1860:	        int (*fadvise)(struct file *, loff_t, loff_t, int);
1861:	} __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 
2020-01-19 12:28:36.404807+0900
# date 
2020年  1月 19日 日曜日 12:28:38 JST
#

◆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 のメジャー番号は、10、マイナー番号は、135。
```
$ ls -l /dev/rtc  
crw-r--r-- 1 root root 10, 135 Oct 29 18:22 /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 
2020-01-19 03:31:21
# ./rtc-read-time; hwclock --show; date 
2020-01-19 03:31:27
2020-01-19 12:31:27.811063+0900
2020年  1月 19日 日曜日 12:31:28 JST
# ./rtc-read-time; hwclock --show; date 
2020-01-19 03:31:29
2020-01-19 12:31:29.545443+0900
2020年  1月 19日 日曜日 12:31:30 JST
#

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/char/rtc.c

CMOS RTC のデバイスドライバは、drivers/char/rtc.c にある。カーネルの起動時に rtc_init() という関数が呼ばれる。

linux-5.4.7/drivers/char/rtc.c
 799:	static const struct file_operations rtc_fops = {
 800:	        .owner          = THIS_MODULE,
 801:	        .llseek         = no_llseek,
 802:	        .read           = rtc_read,
 803:	#ifdef RTC_IRQ
 804:	        .poll           = rtc_poll,
 805:	#endif
 806:	        .unlocked_ioctl = rtc_ioctl,
 807:	        .open           = rtc_open,
 808:	        .release        = rtc_release,
 809:	        .fasync         = rtc_fasync,
 810:	};
 811:	
 812:	static struct miscdevice rtc_dev = {
 813:	        .minor          = RTC_MINOR,
 814:	        .name           = "rtc",
 815:	        .fops           = &rtc_fops,
 816:	};

 843:	static int __init rtc_init(void)
 844:	{
...
 947:	        if (misc_register(&rtc_dev)) {
..
 953:	                rtc_release_region();
 954:	                return -ENODEV;
 955:	        }
...
1021:	        (void) init_sysctl();
1022:	
1023:	        printk(KERN_INFO "Real Time Clock Driver v" RTC_VERSION "\n");
1024:	
1025:	        return 0;
1026:	}

linux-5.4.7/include/uapi/linux/major.h
  10:	#define UNNAMED_MAJOR           0
  11:	#define MEM_MAJOR               1
  12:	#define RAMDISK_MAJOR           1
  13:	#define FLOPPY_MAJOR            2
  14:	#define PTY_MASTER_MAJOR        2
  15:	#define IDE0_MAJOR              3
  16:	#define HD_MAJOR                IDE0_MAJOR
  17:	#define PTY_SLAVE_MAJOR         3
  18:	#define TTY_MAJOR               4
  19:	#define TTYAUX_MAJOR            5
  20:	#define LP_MAJOR                6
  21:	#define VCS_MAJOR               7
  22:	#define LOOP_MAJOR              7
  23:	#define SCSI_DISK0_MAJOR        8
  24:	#define SCSI_TAPE_MAJOR         9
  25:	#define MD_MAJOR                9
  26:	#define MISC_MAJOR              10

linux-5.4.7/include/linux/miscdevice.h
  15:	#define PSMOUSE_MINOR           1
  16:	#define MS_BUSMOUSE_MINOR       2       /* unused */
...
  27:	#define RTC_MINOR               135
...
  60:	#define RFKILL_MINOR            242
  61:	#define MISC_DYNAMIC_MINOR      255

ここで説明している /dev/rtc のメジャー番号は 10、マイナー番号は、 135 (RTC_MINOR)。misc_register() で登録される。
misc_register() は、次のようなことを行う。
- alloc_chrdev_region() 等で、メジャー番号とマイナー番号を割り当てる。
- device_create() で、/dev と /sys の下のノードを作る。
- cdev_init() と cdev_add() で、文字型デバイスとして登録する。
struct file_operations 構造体のインスタンス rtc_fops には、owner, llseek(), read(), poll(), unlocked_ioctl(), open(), release(), fasync() というフィールドが初期化されている。その他は、NULLで初期化されている。
printk() は、カーネル内で使える printf()。

dmesg コマンドを使うと、printk() の結果を画面に表示してくれる。

$ dmesg | grep Real 
Real Time Clock Driver v1.12ac
$

dmesg コマンドの古いものは、(syslogd の働きで) /var/log/messages* 等のファイルに保存される。

# grep Real /var/log/messages.2  
...
Jan 24 12:00:40 windell50 kernel: Real Time Clock Driver v1.12ac
#

2020年 coins で動いている Linux では、別のドライバが動いている。ソースは、drivers/rtc/rtc-cmos.c にある。

$ uname -a 
Linux aloe39 4.15.0-72-generic #81-Ubuntu SMP Tue Nov 26 12:20:02 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux
$ dmesg | grep Real 
$ dmesg | grep cmos 
[   10.595681] rtc_cmos 00:01: RTC can wake from S4
[   10.596432] rtc_cmos 00:01: rtc core: registered rtc_cmos as rtc0
[   10.596573] rtc_cmos 00:01: alarms up to one month, y3k, 242 bytes nvram, hpet irqs
[   10.955369] rtc_cmos 00:01: setting system clock to 2020-01-17 08:19:16 UTC (1579249156)
$

◆rtc_open()

linux-5.4.7/drivers/char/rtc.c
 187:	static unsigned long rtc_status;        /* bitmapped status byte.       */

 713:	static int rtc_open(struct inode *inode, struct file *file)
 714:	{
 715:	        spin_lock_irq(&rtc_lock);
 716:	
 717:	        if (rtc_status & RTC_IS_OPEN)
 718:	                goto out_busy;
 719:	
 720:	        rtc_status |= RTC_IS_OPEN;
...
 723:	        spin_unlock_irq(&rtc_lock);
 724:	        return 0;
 725:	
 726:	out_busy:
 727:	        spin_unlock_irq(&rtc_lock);
 728:	        return -EBUSY;
 729:	}

spin_lock_irq() と spin_unlock_irq() は、カーネル内の相互排除の仕組み。たとえこの関数 rtc_open() 自身が複数同時に実行されたとしても、一度に１つのプロセス（スレッド）だけが実行されるようにする。
変数 rtc_status の RTC_IS_OPEN ビットが on なら、どれかのプロセスにより open("/dev/rtc",) がされていて、 close() はされていない状態である。その場合は、EBUSY というエラーにして open() が失敗する。
rtc_status の RTC_IS_OPEN ビットをオンにする。
成功の意味の 0 を返す。

◆rtc_release()

linux-5.4.7/drivers/char/rtc.c
 736:	static int rtc_release(struct inode *inode, struct file *file)
 737:	{
...
 766:	
 767:	        spin_lock_irq(&rtc_lock);
...
 769:	        rtc_status &= ~RTC_IS_OPEN;
 770:	        spin_unlock_irq(&rtc_lock);
 771:	
 772:	        return 0;
 773:	}

rtc_open() で立てた rtc_status の RTC_IS_OPEN ビットは、close() システム・コールで呼ばれる rtc_release() ( struct file_operations rtc_fops の .release) で、落とされる。

◆rtc_ioctl()とrtc_do_ioctl()

linux-5.4.7/drivers/char/rtc.c
 701:	static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 702:	{
 703:	        long ret;
 704:	        ret = rtc_do_ioctl(cmd, arg, 0);
 705:	        return ret;
 706:	}

 381:	static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
 382:	{
 383:	        struct rtc_time wtime;
...
 401:	        switch (cmd) {
...
 463:	        case RTC_ALM_READ:      /* Read the present alarm time */
...
 474:	        case RTC_ALM_SET:       /* Store a time into the alarm */
...
 523:	        case RTC_RD_TIME:       /* Read the time/date from RTC  */
 524:	        {
 525:	                memset(&wtime, 0, sizeof(struct rtc_time));
 526:	                rtc_get_rtc_time(&wtime);
 527:	                break;
 528:	        }
 529:	        case RTC_SET_TIME:      /* Set the RTC */
 530:	        {
 531:	                struct rtc_time rtc_tm;
 532:	                unsigned char mon, day, hrs, min, sec, leap_yr;
 533:	                unsigned char save_control, save_freq_select;
 534:	                unsigned int yrs;
...
 542:	                if (copy_from_user(&rtc_tm, (struct rtc_time __user *)arg,
 543:	                                   sizeof(struct rtc_time)))
 544:	                        return -EFAULT;
 545:	
 546:	                yrs = rtc_tm.tm_year + 1900;
 547:	                mon = rtc_tm.tm_mon + 1;   /* tm_mon starts at zero */
 548:	                day = rtc_tm.tm_mday;
 549:	                hrs = rtc_tm.tm_hour;
 550:	                min = rtc_tm.tm_min;
 551:	                sec = rtc_tm.tm_sec;
 552:	
 553:	                if (yrs < 1970)
 554:	                        return -EINVAL;
 555:	
 556:	                leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
 557:	
 558:	                if ((mon > 12) || (day == 0))
 559:	                        return -EINVAL;
 560:	
 561:	                if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
 562:	                        return -EINVAL;
 563:	
 564:	                if ((hrs >= 24) || (min >= 60) || (sec >= 60))
 565:	                        return -EINVAL;
 566:	
 567:	                yrs -= epoch;
 568:	                if (yrs > 255)          /* They are unsigned */
 569:	                        return -EINVAL;
 570:	
 571:	                spin_lock_irq(&rtc_lock);
...
 614:	                CMOS_WRITE(yrs, RTC_YEAR);
 615:	                CMOS_WRITE(mon, RTC_MONTH);
 616:	                CMOS_WRITE(day, RTC_DAY_OF_MONTH);
 617:	                CMOS_WRITE(hrs, RTC_HOURS);
 618:	                CMOS_WRITE(min, RTC_MINUTES);
 619:	                CMOS_WRITE(sec, RTC_SECONDS);
...
 624:	                spin_unlock_irq(&rtc_lock);
 625:	                return 0;
 626:	        }
...
 694:	        default:
 695:	                return -ENOTTY;
 696:	        }
 697:	        return copy_to_user((void __user *)arg,
 698:	                            &wtime, sizeof wtime) ? -EFAULT : 0;
 699:	}

ioctl() の処理をする関数には、switch 文があるのが普通。それで、コマンドごとに処理を振り分ける。
コマンド cmd が RTC_RD_TIME なら、rtc_get_rtc_time() を呼ぶ。そのまま break で下に落ちる。
最後に、cmd が RTC_RD_TIME なら、copy_to_user() で結果をユーザ空間に書く。
cmd が RTC_SET_TIME なら、copy_from_user() でユーザ空間からセットすべき値を取得し、CMOS_WRITE() でデバイスにセットする。

◆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_get_rtc_time()

linux-5.4.7/drivers/char/rtc.c
1178:	static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
1179:	{
...
1206:	        spin_lock_irqsave(&rtc_lock, flags);
1207:	        rtc_tm->tm_sec = CMOS_READ(RTC_SECONDS);
1208:	        rtc_tm->tm_min = CMOS_READ(RTC_MINUTES);
1209:	        rtc_tm->tm_hour = CMOS_READ(RTC_HOURS);
1210:	        rtc_tm->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
1211:	        rtc_tm->tm_mon = CMOS_READ(RTC_MONTH);
1212:	        rtc_tm->tm_year = CMOS_READ(RTC_YEAR);
1213:	        /* Only set from 2.6.16 onwards */
1214:	        rtc_tm->tm_wday = CMOS_READ(RTC_DAY_OF_WEEK);
...
1220:	        spin_unlock_irqrestore(&rtc_lock, flags);
...
1240:	        rtc_tm->tm_year += epoch - 1900;
1241:	        if (rtc_tm->tm_year <= 69)
1242:	                rtc_tm->tm_year += 100;
1243:	
1244:	        rtc_tm->tm_mon--;
1245:	}

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.4.7/arch/x86/include/asm/mc146818rtc.h
  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.4.7/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.4.7/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
...
  66:	#define RTC_REG_A               10
  67:	#define RTC_REG_B               11
  68:	#define RTC_REG_C               12
...
 104:	#define RTC_INTR_FLAGS  RTC_REG_C

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.4.7/arch/x86/boot/boot.h
  43:	static inline void outb(u8 v, u16 port)
  44:	{
  45:	        asm volatile("outb %0,%1" : : "a" (v), "dN" (port));
  46:	}
  47:	static inline u8 inb(u16 port)
  48:	{
  49:	        u8 v;
  50:	        asm volatile("inb %1,%0" : "=a" (v) : "dN" (port));
  51:	        return v;
  52:	}

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.4.7/arch/x86/include/asm/io.h
 279:	#define BUILDIO(bwl, bw, type)                                          \
 280:	static inline void out##bwl(unsigned type value, int port)              \
 281:	{                                                                       \
 282:	        asm volatile("out" #bwl " %" #bw "0, %w1"                       \
 283:	                     : : "a"(value), "Nd"(port));                       \
 284:	}                                                                       \
 285:	                                                                        \
 286:	static inline unsigned type in##bwl(int port)                           \
 287:	{                                                                       \
 288:	        unsigned type value;                                            \
 289:	        asm volatile("in" #bwl " %w1, %" #bw "0"                        \
 290:	                     : "=a"(value) : "Nd"(port));                       \
 291:	        return value;                                                   \
 292:	}                                                                       \

 339:	BUILDIO(b, b, char)
 340:	BUILDIO(w, w, short)
 341:	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-001f : dma1
0020-0021 : pic1
0040-0043 : timer0
0050-0053 : timer1
0060-0060 : keyboard
0064-0064 : keyboard
0070-0077 : rtc
0080-008f : dma page reg
...
ff80-ff9f : 0000:00:1d.0
  ff80-ff9f : uhci_hcd
$

■割り込み

◆割り込みの必要性

デバイス(ディスク、ネットワーク、キーボード、マウス、・・・)は、 CPU と比較すると遅い。
デバイスに要求を出して、応答を待っていると、CPU の無駄になるので、デバイスが要求に対する処理を完了した後で、CPU (OS、ソフトウェア)が処理をする。
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.4.7/drivers/char/rtc.c
 101:	static int rtc_has_irq = 1;

 131:	static DECLARE_WAIT_QUEUE_HEAD(rtc_wait);

 843:	static int __init rtc_init(void)
 844:	{
...
 858:	        irq_handler_t rtc_int_handler_ptr;
...
 930:	                rtc_int_handler_ptr = rtc_interrupt;
...
 933:	        if (request_irq(RTC_IRQ, rtc_int_handler_ptr, 0, "rtc", NULL)) {
 934:	                /* Yeah right, seeing as irq 8 doesn't even hit the bus. */
 935:	                rtc_has_irq = 0;
 936:	                printk(KERN_ERR "rtc: IRQ %d is not free.\n", RTC_IRQ);
 937:	                rtc_release_region();
 938:	
 939:	                return -EIO;
 940:	        }
...
1025:	        return 0;
1026:	}

 227:	static irqreturn_t rtc_interrupt(int irq, void *dev_id)
 228:	{
 236:	        spin_lock(&rtc_lock);
 237:	        rtc_irq_data += 0x100;
 238:	        rtc_irq_data &= ~0xff;
...
 247:	                rtc_irq_data |= (CMOS_READ(RTC_INTR_FLAGS) & 0xF0);
...
 253:	        spin_unlock(&rtc_lock);
 254:	
 255:	        wake_up_interruptible(&rtc_wait);
...
 259:	        return IRQ_HANDLED;
 260:	}

x86 CMOS Real-Time Clock では、3種類の割り込み( alarmの時刻になった、更新が完了した、定期的な割り込み) がある。どの割り込みでも、rtc_init() で設定した同じ割り込みハンドラ rtc_interrupt() が呼ばれる。
spin_lock_irq() と spin_unlock_irq() は、カーネル内の相互排除の仕組み。たとえこの関数 rtc_open() 自身が複数同時に実行されたとしても、一度に１つのプロセス（スレッド）だけが実行されるようにする。
rtc_irq_data は、unsigned long で、その回の割り込みのフラグを CMOS_READ() でデバイスから読み出して保存する。
wake_up_interruptible()で、誰かがイベントを待っていれば、起す。

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

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

◆x86 Interrupt Descriptor Table (IDT)

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

linux-5.4.7/arch/x86/kernel/traps.c
 925:	void __init trap_init(void)
 926:	{
..
 930:	        idt_setup_traps();
...
 951:	}

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

linux-5.4.7/arch/x86/kernel/idt.c
 169:	gate_desc idt_table[IDT_ENTRIES] __page_aligned_bss;

  72:	static const __initconst struct idt_data def_idts[] = {
  73:	        INTG(X86_TRAP_DE,               divide_error),
  74:	        INTG(X86_TRAP_NMI,              nmi),
  75:	        INTG(X86_TRAP_BR,               bounds),
  76:	        INTG(X86_TRAP_UD,               invalid_op),
  77:	        INTG(X86_TRAP_NM,               device_not_available),
...
 103:	        SYSG(IA32_SYSCALL_VECTOR,       entry_INT80_32),
 105:	};

 263:	void __init idt_setup_traps(void)
 264:	{
 265:	        idt_setup_from_table(idt_table, def_idts, ARRAY_SIZE(def_idts), true);
 266:	}

linux-5.4.7/arch/x86/entry/entry_32.S
1352:	ENTRY(divide_error)
1353:	        ASM_CLAC
1354:	        pushl   $0                              # no error code
1355:	        pushl   $do_divide_error
1356:	        jmp     common_exception
1357:	END(divide_error)

1541:	ENTRY(nmi)
...
1570:	        call    do_nmi
...
 909:	ENTRY(entry_SYSENTER_32)
...
 965:	        call    do_fast_syscall_32
...
1104:	        INTERRUPT_RETURN

linux-5.4.7/arch/x86/include/asm/irqflags.h
 155:	#define INTERRUPT_RETURN                iret

linux-5.4.7/arch/x86/entry/common.c
 352:	__visible void do_int80_syscall_32(struct pt_regs *regs)
 353:	{
...
 356:	        do_syscall_32_irqs_on(regs);
 357:	}

 311:	static __always_inline void do_syscall_32_irqs_on(struct pt_regs *regs)
 312:	{
...
 314:	        unsigned int nr = (unsigned int)regs->orig_ax;
...
 330:	        if (likely(nr < IA32_NR_syscalls)) {
 331:	                nr = array_index_nospec(nr, IA32_NR_syscalls);
...
 341:	                regs->ax = ia32_sys_call_table[nr](
 342:	                        (unsigned int)regs->bx, (unsigned int)regs->cx,
 343:	                        (unsigned int)regs->dx, (unsigned int)regs->si,
 344:	                        (unsigned int)regs->di, (unsigned int)regs->bp);
...
 346:	        }
...
 349:	}

linux-5.4.7/arch/x86/include/asm/syscall.h
  27:	extern const sys_call_ptr_t sys_call_table[];
...
  30:	#define ia32_sys_call_table sys_call_table

trap_init() は、idt_setup_traps() を呼び、IDT idt_table[] を初期化する。 idt_setup_traps() は、def_idts[] の内容を idt_table[] へコピーしている。
ITD のインデックスは、割り込みベクタ。
割り込みベクタは、0 から 0xff まである。0 から 0x1f は、Intel により使い方が決められている。
割り込みベクタ 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 参照。

◆x86 do_IRQ

x86 Linux では、Interrupt Descriptor Table に従い、 irq_entries_start() が呼ばれる。それは、common_interrupt を経由して、 do_IRQ() を呼ぶ。

引数には、x86 のレジスタを表現した構造体へのポインタが渡される。これにより、割り込みが発生した時のレジスタの値がわかる。割り込みハンドラが有効で、割り込み番号に登録されていれば、最終的には、handle_IRQ_event()　という、CPU とは独立の割り込みハンドラが呼ばれる。

◆handle_IRQ_event()

linux-5.4.7/kernel/irq/handle.c
 198:	irqreturn_t handle_irq_event(struct irq_desc *desc)
 199:	{
 200:	        irqreturn_t ret;
...
 206:	        ret = handle_irq_event_percpu(desc);
...
 211:	}

 184:	irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
 185:	{
 186:	        irqreturn_t retval;
...
 189:	        retval = __handle_irq_event_percpu(desc, &flags);
...
 195:	        return retval;
 196:	}

 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;
...
 149:	                res = action->handler(irq, action->dev_id);
...
 156:	                switch (res) {
...
 170:	                case IRQ_HANDLED:
 171:	                        *flags |= action->flags;
 172:	                        break;
 173:	
 174:	                default:
 175:	                        break;
 176:	                }
 177:	
 178:	                retval |= res;
 179:	        }
 180:	
 181:	        return retval;
 182:	}

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

struct irqaction *action は、 action->next でリスト構造を作っている。
各構造体に含まれている action->handler() を順に呼び出す。

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

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

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

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

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 デバイスドライバと割り込み処理、inb()とoutb()

★問題(301) CMOS RTC のデバイスドライバ

rtc-read-time.cのプログラムでシステム・コールが実行されると、CMOS RTC のデバイス・ドライバに含まれる関数が実行される。次のシステム・コールが実行された時に、どんな関数が実行されるかを答えなさい。 drivers/char/rtc.c に含まれる関数の名前で答えなさい。

open() システム・コール(23行目):
ioctl() システム・コール(28行目):
close() システム・コール(36行目):

★問題(302) copy_to_user()とmemcpy()

関数 rtc_do_ioctl() は、copy_to_user() を呼び出している。これは正しいプログラムであるが、もしも　copy_to_user() を memcpy() やポインタを操作して直接ユーザ空間のメモリにアクセスすると問題がある。 701 行目から 702 行目 697 行目から 698 行目 を、memcpy() を使って「間違ったプログラム」に書き換えなさい。ただし、copy_to_user() は必ず成功するものとして、エラー処理を省略しなさい。以下の「/*空欄*/」を埋めなさい。

     memcpy( /*空欄(a)*/,/*空欄(b)*/,/*空欄(c)*/ );
     return 0;

なお、memcpy() のインタフェースは、次のようになっている。

void * memcpy(void *destination, const void *source, size_t len);

sourceは、コピー元、destination は、コピー先、len は長さ(バイト数)である。結果として destination を返す。

C言語の 3 項演算子(?と:)は、次のような意味である。

    条件 ? 式1 : 式2

「条件」が成り立つ(非0)なら、「式1」の値、成り立たなければ、「式2」の値になる。この課題では、「間違ったプログラム」を書く課題であり、return 0;と常に 0 (成功) を返すようにしている。

なお、__user は、ユーザ空間のアドレスを意味し、エラー・チェックに使われる、Cプリプロセッサで空の文字列に展開されることもある。この問題では空の文字列に展開されると考えなさい。

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

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

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

★問題(304) 割り込みの利用

キーボード、マウス、ネットワーク・カード等のデバイスからの入力では割り込みが多く使われている。割り込みを使う方法と割り込みを使わない方法を対比して、割り込みを使う方法の利点を説明しなさい。

★問題(305) x86 CMOS Real-Time Clock の割り込みハンドラ

x86 CMOS Real-Time Clock の割り込みハンドラを関数名で答えなさい。その関数の引数と結果を、簡単に説明しなさい。

Last updated: 2020/01/29 16:43:29

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