V6 unix vol.2 in okinawa

Rev.1.0
2012/12/15
2012/3/24 1

厚い本出ます

2012/3/24 2

ファイルシステムとは何か
 計算機の基本的な機能
 処理対象→処理→処理結果
 メインフレームはこの処理に特化
 処理対象と処理出力は永続性が必要
 電源を切っても、情報が保存され続ける事
 古典的な記憶装置を利用する
 DISK
○ 効果・高速・ランダムアクセス
 TAPE
○ 安価・低速・シーケンシャルアクセス
2012/3/24 3

磁気DISKの動作原理
 円盤上の媒体に磁性体を塗布
 DISKを回転させる
 ヘッド（コイル）
 電磁誘導で発生した電流を読む
 電流を流して磁場を発生させて円盤の一部を磁化/
消磁する

2012/3/24 5

磁気DISKの特性
 物理的なアドレス
 トラック/セクタ
 論理的なアドレス
 ブロック番号
 シーク待ち
 トラック間のピックアップ(コイル)の移動待ち
 回転待ち
 ピックアップの下を指定ブロックが通過するまで
の時間

2012/3/24 6

周辺機器との転送
 完了イベントの検出方式
 ポーリング
○ ステータスをCPUサイクルで検査（ルックイン）
 割り込み
○ 完了時に周辺機器のコントローラが割り込みを発生

 データの転送方式
 プログラムIO
○ CPUサイクルでメモリを読み書き
 Direct Memory Access
○ 周辺機器のコントローラがメモリを読み書き
2012/3/24 7

PDP-11の標準磁気DISK装置

2012/3/24 8

PDP-11の標準磁気DISK RK-11
 一台のコントローラに複数のDISKがつながる
 DISKはアドレスを持ちコントローラが指定
 SCSIに似ているw

2012/3/24 9

RK11 の制御レジスタ
 メモリ空間から制御レジスタを読み書き

2012/3/24 10

RK-11の仕様
 512バイト/セクタ（1word = 2byte)
 約2.5Mバイト/ドライブ

2012/3/24 11

RKDA – DISK ADDRESS REGISTER

5420: rkaddr(bp)
5421: struct buf *bp;
5422: {
5423: register struct buf *p;
5424: register int b;
5425: int d, m;
5426:
5427: p = bp;
5428: b = p->b_blkno;
5431: d = p->b_dev.d_minor;
5436: return(d<<13 | (b/12)<<4 | b%12);
5437: }

2012/3/24 12

RKCS – CONTROL STATUS REGISTER

5092: #define IENABLE 0100 IDE
5093: #define WCOM 02 FUNCTION
5094: #define RCOM 04 FUNCION
5095: #define GO 01 GO
2012/3/24 13

GO - RKCS

 操作する人が書き込む
 Function の３ビットの機能を制御する
 指定した処理が開始されるまで値はそのまま

2012/3/24 14

IDE - RKCS

 1をセットすると完了時に220ベクタの割り込
みを発生する

2012/3/24 15

rk.c - definitions
5363: #define RKADDR 0177400
5364: #define NRK 4
5365: #define NRKBLK 4872
5366:
5367: #define RESET 0
5368: #define GO 01
5369: #define DRESET 014
5370: #define IENABLE 0100
5371: #define DRY 0200
5372: #define ARDY 0100
5373: #define WLO 020000
5374: #define CTLRDY 0200
5375:
5376: struct {
5377: int rkds;
5378: int rker;
5379: int rkcs;
5380: int rkwc;
5381: int rkba;
5382: int rkda;
5383: };

2012/3/24 16

rk.c - kstart
5440: rkstart()
5441: {
5442: register struct buf *bp;
5443:
5444: if ((bp = rktab.d_actf) == 0)
5445: return;
5446: rktab.d_active++;
5447: devstart(bp, &RKADDR->rkda, rkaddr(bp), 0);
5448: }

2012/3/24 17

bio.c - devstart
5096: devstart(bp, devloc, devblk, hbcom) 5092: #define IENABLE 0100
5097: struct buf *bp; 5093: #define WCOM 02
5098: int *devloc; 5094: #define RCOM 04
5099: { 5095: #define GO 01
5100: register int *dp;
5101: register struct buf *rbp;
5102: register int com;
5103:
5104: dp = devloc;
5105: rbp = bp;
5106: *dp = devblk; /* block address */
5107: *--dp = rbp->b_addr; /* buffer address */
5108: *--dp = rbp->b_wcount; /* word count */
5109: com = (hbcom<<8) | IENABLE | GO |
5110: ((rbp->b_xmem & 03) << 4);
5111: if (rbp->b_flags&B_READ) /* command + x-mem */
5112: com =| RCOM;
5113: else
5114: com =| WCOM;
5115:
2012/3/24
*--dp = com; 18

RKADDRの操作
5363: RKADDR 0177400
5100: register int *dp;
5447: devloc = &RKADDR->rkda
5104: dp = devloc;
5105: rbp = bp;
5106: *dp = devblk; /* block address */
5107: *--dp = rbp->b_addr; /* buffer address */
5108: *--dp = rbp->b_wcount; /* word count */
5109: com = (hbcom<<8) | IENABLE | GO | ((rbp->b_xmem & 03) << 4);
5112: com =| RCOM; // readの場合
5115: *--dp = com;

0177400 rkds
rker
rkcs 5115: *--dp = com;

rkwc 5108: *--dp = rbp->b_wcount; /* word count */
rkba 5107: *--dp = rbp->b_addr; /* buffer address */
rkda 5106: *dp = devblk
2012/3/24 19

割り込みベクタ

2012/3/24 20

525 low.s
0525: . = 60^. Vector device entry
0526: klin; br4
0527: klou; br4 060 Teletype input klin
0528:
0529: . = 70^. 064 Teletype output klou
0530: pcin; br4
0531: pcou; br4
070 Paper tape input pcin
0532: 074 Paper tape output pcou
0533: . = 100^.
0534: 0576:
kwlp; br6 .globl _rkintr Line clock
100 kwlp
0535: 0577:
kwlp; br6 rkio: jsr r0,call; _rkintr
0539:
104 Programmable clock kwlp
0540: . = 200^.
0541: lpou; br4 200 Line printer lpou
0542:
0543: . = 220^. 220 RK disk driver rkio
0544: rkio; br5
2012/3/24 21

rk.c - rkintr
5451: rkintr()
5452: {
5454:
5455: if (rktab.d_active == 0)
5456: return;
5457: bp = rktab.d_actf;
5458: rktab.d_active = 0;

5469: rktab.d_errcnt = 0;
5470: rktab.d_actf = bp->av_forw;
5471: iodone(bp);
5472: rkstart();
5473: }

2012/3/24 22

ファイルシステムなしでDISKを使うと
 情報を格納したブロックアドレスをメモ
 ブロックアドレスを書き留める
 複数のブロックの集合を書き留めてグループ化
 ブロックの途中まで書き込んでいたら、位置をメ
モ
 利用状況/の管理
 複数の利用者がいたら？
○ ブロックはフラットな１次元配列
○ 上書きの危険
 何時データを保存したのかなど属性はすべてメモ
書き
2012/3/24 23

ソースを読む前に仕様を理解

2012/3/24 24

open(2)
open(name, mode)
char *name;

 ファイルのopen
 name はNULLで終端したpath name
 ファイルディスクリプタを返す
 modeは0:read, 1:write, 2:read and write

2012/3/24 25

write(2)
write(fildes, buffer, nbytes)
char *buffer

 fildesはopen,creat,dup,pipeで生成したファイ
ルディスクリプタ
 プログラムのアドレスbufferからnbyteを書き
込む
 復帰値は書き込まれたバイト数
 ファイルの512バイト境界に512xNバイトをか
くと性能が良い
2012/3/24 26

read(2)
read(fildes, buffer, nbytes)
char *buffer;

 Fildesからプログラムアドレスbufferへnbyte
読み込む
 復帰値が０の場合はend-of-file

2012/3/24 27

seek(2)
seek(fildes, offset, ptrname)

 Fildesのファイルポインタをoffsetにセットする
 Ptrnameの値と設定するファイルポインタの関係
は以下
0: offsetを指定 (絶対位置指定)
1: 現在のファイルポインタ+offsetに (相対位置指定）
2: ファイルの最後+offsetに
3,4,5 は1,2,3の0,1,2のoffsetの単位を512に

2012/3/24 28

fork(2)
fork()

 プロセスを生成する唯一のもの
 呼び出たプロセスと、生成されたプロセスに
それぞれ復帰する
暗示的な仕様が多数
・プロセス空間を複写
・異なるのはpipとppid
・Open中ファイルの引継ぎ
親がopenしたファイルディスクリプタは子も利用できる
この仕様に依存した機能が多数ある

2012/3/24 29

exec(2)
execl(name, arg0, arg1, ..., argn, 0)
char *name, *arg0, *arg1, ..., *argn;

 プロセス空間をnameで指定したa.outで上書
き
 成功したexecを発行したプロセスには復帰し
ない
 プロセスのIDが変更になる場合がある
SUID/SGID
2012/3/24 30

pipe(2)
pipe(fildes)
int fildes[2];
 2つのファイルディスクリプタを返す
 fildes[1]の先には4096バイトのバッファがあ
り、バッファがフルにならない範囲で書き込
む事ができる
 fildes[0]の先に同じバッファがあり、ここから
読む事ができる
 バッファの読み書きはブロッキングによるフ
ロー制御が行われる
2012/3/24 31

dup(2)
dup(fildes)
int fildes;
 ファイルディスクリプタを複写して、新しい
ディスクリプタを返す
 複写先のディスクリプタは0から順に空き
ディスクリプタを探して最初に見つかったも
のを選択

2012/3/24 32

chdir(2)
chdir(dirname)
char *dirname;

 current working directoryを変更する

2012/3/24 33

mknod(2)
mknod(name, mode, addr)
char *name;

 Nemaで指定された新しいディレクトリまた
は特殊ファイルを作成する
 作られるファイルのmodeがファイルのモード
として指定される
 Addrは特殊ファイルでのみ使われる
 Rootのみが実行可能
2012/3/24 34

link(2)
link(name1, name2)
char *name1, *name2;

 name1にname2をリンクする
 リンクカウントは１増える

2012/3/24 35

unlink(2)
unlink(name)
char *name;

 Nameで指定したファイルをディレクトリか
ら取り除いてリンクカウントを１つ減らす
 取り除いたけっか0だったらファイルを破棄
する
 ただし、そのファイルをプロセスが利用して
いたら、破棄はプロセスが利用をやめるまで
待って、遅れて行われる
2012/3/24 36

確認思い出してね
 current working directory
 SUID/SGID
 一般ファイル、ディレクトファイル、特殊
ファイル
 shell (資料では触れていない）
 パイプ・リダイレクト
 標準入力、標準出力、エラー出力
 cd, cwd
 相対パス、絶対パス

2012/3/24 37

ソースを読む前に仕様を理解

2012/3/24 38

Path name - パス名
 パス名はカーネル・システムコールが理解す
るファイルシステム上の名前空間
 ファイル名を’/’で連結
 ファイル名は最大14文字
 一番右側にのみ一般ファイル、特殊ファイル
を指定できる。ディレクトリファイルはどこ
にでも指定できる
 パス名が’/’で始まると絶対パス、それ以外は
相対パス
 相対パスの起点がcurrent working directory

2012/3/24 39

ファイルディスクリプタ
 open, creat, dup, pipeで獲得
 Closeで解放
 小さな整数
 標準の環境でログインすると
0: 標準入力
1: 標準出力
2: 標準エラー出力
 0-14の最大15個を獲得可能
 fork/execで子に引き継ぐ

2012/3/24 40

一般ファイルのread/write/seek
 バイト単位で操作可能
 writeで必要な媒体を自動割り当て
 操作毎にファイルポインタを更新
 操作開始位置を毎回指定する必要なし

2012/3/24 41

処理を読む前にデータ構造を理解する

2012/3/24 42

Inode – ino.h (DISK inode)
5605: struct inode
5606: { 5619: /* modes */
5607: int i_mode; 5620: #define IALLOC 0100000
5608: char i_nlink; 5621: #define IFMT 060000
5609: char i_uid; 5622: #define IFDIR 040000
5610: char i_gid; 5623: #define IFCHR 020000
5611: char i_size0; 5624: #define IFBLK 060000
5612: char *i_size1; 5625: #define ILARG 010000
5613: int i_addr[8]; 5626: #define ISUID 04000
5614: int i_atime[2]; 5627: #define ISGID 02000
5615: int i_mtime[2]; 5628: #define ISVTX 01000
5616: }; 5629: #define IREAD 0400
5617: /* --------------------------- 5630: #define IWRITE 0200
*/ 5631: #define IEXEC 0100

ファイルの実態 DISK上では配列として格納しインデックがi番号

2012/3/24 43

filsys - filsys.h
5561: struct filsys
5562: {
5563: int s_isize; /* size in blocks of I list */
5564: int s_fsize; /* size in blocks of entire volume */
5565: int s_nfree; /* number of in core free blocks (0-100) */
5567: int s_free[100]; /* in core free blocks */
5568: int s_ninode; /* number of in core I nodes (0-100) */
5569: int s_inode[100]; /* in core free I nodes */
5570: char s_flock; /* lock during free list manipulation */
5571: char s_ilock; /* lock during I list manipulation */
5572: char s_fmod; /* super block modified flag */
5573: char s_ronly; /* mounted read-only flag */
5574: int s_time[2]; /* current date of last update */
5575: int pad[50];
5576: };

2012/3/24 44

dir – param.h user.h
param.h
0106: #define ROOTINO 1 /* i number of all roots */
0107: #define DIRSIZ 14 /* max characters per directory
*/

user.h
0431: struct { /* current directory entry */
0432: int u_ino;
0433: char u_name[DIRSIZ];
0434: } u_dent

u_ino 14文字固定長

2012/3/24 45

媒体上のレイアウト
 mkfs(1)でフォーマット
Boot block
 先頭にbook block
Super block
struct file
 Boot device以外は空

Inode blocks
 Super block
Struct inode[]  媒体全体を管理する構造
 Inode blocks
 Inodeの配列を格納
data blocks
 インデックをi番号(i-no)と
呼ぶ

2012/3/24 46

データブロックの利用
 一般ファイルのデータ部分
 メタデータはinodeが管理
 ディレクトリファイル
 一般ファイルのモードがIFDIR (040000)
 i番号とファイル名の構造が配列として格納
 間接ブロック
 Inodeのiaddrから直接参照できないブロックを関節
参照する

2012/3/24 47


2012/3/24 48

Inode inode.c (incore inode) 1/2
5659: struct inode
5660: {
5661: char i_flag;
5662: char i_count; /* reference count */
5663: int i_dev; /* device where inode resides */
5664: int i_number; /* i number, 1-to-1 with device address */
5665:
5666: int i_mode;
5667: char i_nlink; /* directory entries */
5668: char i_uid; /* owner */
5669: char i_gid; /* group of owner */
5670: char i_size0; /* most significant of size */
5671: char *i_size1; /* least sig */
5672: int i_addr[8]; /* device addresses constituting file */
5673: int i_lastr; /* last logical block read (for read-ahead) */
5674:
5675: } inode[NINODE];

0131: #define NINODE 100 /* number of in core inodes */
2012/3/24 49

Inode inode.c (incore inode) 2/2
5678: /* flags */
5679: #define ILOCK 01 /* inode is locked */
5680: #define IUPD 02 /* inode has been modified */
5681: #define IACC 04 /* inode access time to be updated */
5682: #define IMOUNT 010 /* inode is mounted on */
5683: #define IWANT 020 /* some process waiting on lock */
5684: #define ITEXT 040 /* inode is pure text prototype */
5685:
5686: /* modes */
5687: #define IALLOC 0100000 /* file is used */
5688: #define IFMT 060000 /* type of file */
5689: #define IFDIR 040000 /* directory */
5690: #define IFCHR 020000 /* character special */
5691: #define IFBLK 060000 /* block special, 0 is regular */
5692: #define ILARG 010000 /* large addressing algorithm */
5693: #define ISUID 04000 /* set user id on execution */
5694: #define ISGID 02000 /* set group id on execution */
5695: #define ISVTX 01000 /* save swapped text even after use */
5696: #define IREAD 0400 /* read, write, execute permissions */
5697: #define IWRITE 0200
5698: #define IEXEC 0100

2012/3/24 50

file – file.h
5507: struct file
5508: {
5509: char f_flag;
5510: char f_count; /* reference count */
5511: int f_inode; /* pointer to inode structure */
5512: char *f_offset[2]; /* read/write character pointer */
5513: } file[NFILE];
5514: /* --------------------------- */
5515:
5516: /* flags */
5517: #define FREAD 01
5518: #define FWRITE 02
5519: #define FPIPE 04

0132: #define NFILE 100 /* number of in core file structures */

2012/3/24 51


2012/3/24 52

proc – proc.h
0358: struct proc
0359: {
0360: char p_stat;
0361: char p_flag;
0362: char p_pri; /* priority, negative is high */
0363: char p_sig; /* signal number sent to this process */
0364: char p_uid; /* user id, used to direct tty signals */
0365: char p_time; /* resident time for scheduling */
0366: char p_cpu; /* cpu usage for scheduling */
0367: char p_nice; /* nice for scheduling */
0368: int p_ttyp; /* controlling tty */
0369: int p_pid; /* unique process id */
0370: int p_ppid; /* process id of parent */
0371: int p_addr; /* address of swappable image */
0372: int p_size; /* size of swappable image (*64 bytes) */
0373: int p_wchan; /* event process is awaiting */
0374: int *p_textp; /* pointer to text structure */
0375:
0376: } proc[NPROC];

2012/3/24 53

user – user.h
0413: struct user
0414: {
0418: char u_segflg; /* flag for IO; user or kernel space */
0419: char u_error; /* return error code */
0420: char u_uid; /* effective user id */
0421: char u_gid; /* effective group id */
0422: char u_ruid; /* real user id */
0423: char u_rgid; /* real group id */
0424: int u_procp; /* pointer to proc structure */
0425: char *u_base; /* base address for IO */
0426: char *u_count; /* bytes remaining for IO */
0427: char *u_offset[2]; /* offset in file for IO */
0428: int *u_cdir; /* pointer to inode of current directory */
0429: char u_dbuf[DIRSIZ]; /* current pathname component */
0430: char *u_dirp; /* current pointer to inode */
0431: struct { /* current directory entry */
0432: int u_ino;
0433: char u_name[DIRSIZ];
0434: } u_dent;
0435: int *u_pdir; /* inode of parent directory of dirp */
0438: int u_ofile[NOFILE]; /* pointers to file structures of open files */

0139: #define NOFILE 15 /* max open files per process */

2012/3/24 54

空間構造
PSW PC

text
data
bss

user user user user
kstack kstack kstack kstack
IOレジスタ

text text text text
data data data data
bss bss bss bss

stack stack stack stack

2012/3/24 55

ここまで理解すれば、処理はスルスル読めるかな？

2012/3/24 56

ファイルシステムの構造 fd視点
proc file[NFILE] inode[NINODE]
プロセス

fd = open() Boot block
user
u_ofile[NOFILE]
Super block
i_number
i_number
15個 Inode blocks
Struct inode[]

data blocks

キャッシュバッファ

2012/3/24 57

ファイルシステムの構造 fd視点
 fdはu_ofile[]のインデックス
 u_ofile[fd]はfileをポイントする
 fileは複数のu_ofile[]から参照可能で参照カウ
ンタ(f_count)をもつ
 媒体上のinodeは媒体上のインデックスをi番
号とする
 メモリ上にinodeを展開する場合にはインコア
inodeのi_numberにi番号を格納する

2012/3/24 58

ファイルシステムの構造プロセス視点
rootdev
proc inode[NINODE]

プロセス p_textp x_iptr
Boot block
user
i_number
Super block
u_cdir
u_dirp
Inode blocks
u_pdir Struct inode[]

data blocks

キャッシュバッファ

2012/3/24 59

ファイルシステムの構造プロセス視点
 procはtextセグメントを共用する場合にx_iprt
でtext構造をポイント
 text構造は共用するa.outファイルのinodeをポイン
ト
 userはu_cdirでcurrent working directoryを管
理
 Userはu_dirpで作業用のinodeを管理
 Userはu_pdirで親ディレクトのinodeを管理

2012/3/24 60

ファイルシステムの構造ファイル視点
rootdev

f_inode 5659: struct inode
5660: {
x_iptr 5661: char i_flag;
5662: char i_count; Boot block
u_cdir 5663: int i_dev;
5664: int i_number;
u_dirp 5665: Super block
5666: int i_mode;
u_pdir 5667: char i_nlink; i_size
5668: char i_uid; Inode blocks
5669: char i_gid;
5670: char i_size0; Struct inode[]
5671: char *i_size1;
5672: int i_addr[0];
[1]
[2]
[3]
[4]
[5]
:
:
5673: int i_lastr;
5674:
data blocks
5675: }

2012/3/24 61

ファイルシステムの構造ファイル視点
 procはtextセグメントを共用する場合にx_iprt
でtext構造をポイント
 text構造は共用するa.outファイルのinodeをポイン
ト
 userはu_cdirでcurrent working directoryを管
理
 Userはu_dirpで作業用のinodeを管理
 Userはu_pdirで親ディレクトのinodeを管理

2012/3/24 62

ファイルシステムの処理

2012/3/24 63

名前空間 – 処理概要
 絶対パスの場合
 /のi番号は固定1、rootディバスは変数rootdev
 パス名を順にi番号に変換
 相対パスの場合
 userのu_cdirから順にi番号に変換
 /名前/の検索
 ディレクトファイルを名前で検索
 ヒットしたらその名前の左隣2バイトがi番号

2012/3/24 64

名前空間 – namei namei.c
7507: /* 7525:
7508: * Convert a pathname into a pointer to 7526: /*
7509: * an inode. Note that the inode is locked. 7527: * If name starts with '/' start from
7510: * 7528: * root; otherwise start from current dir.
7511: * func = function called to get next char of 7529: */
name 7530:
7512: * &uchar if name is in user space 7531: dp = u.u_cdir;
7513: * &schar if name is in system space 7532: if((c=(*func)()) == '/')
7514: * flag = 0 if name is sought 7533: dp = rootdir;
7515: * 1 if name is to be created 7534: iget(dp->i_dev, dp->i_number);
7516: * 2 if name is to be deleted 7535: while(c == '/')
7517: */ 7536: c = (*func)();
7518: namei(func, flag) 7537: if(c == '¥0' && flag != 0) {
7519: int (*func)(); 7538: u.u_error = ENOENT;
7520: { 7539: goto out;
7521: register struct inode *dp; 7540: }
7522: register c;
7523: register char *cp;
7524: int eo, *bp;

2012/3/24 65

7542: cloop: 7576: while(cp < &u.u_dbuf[DIRSIZ])
7548: if(u.u_error) 7577: *cp++ = '¥0';
7549: goto out; 7578: while(c == '/')
7550: if(c == '¥0') 7579: c = (*func)();
7551: return(dp); 7580: if(u.u_error)
7558: 7581: goto out;
7559: if((dp->i_mode&IFMT) != IFDIR) { 7585: u.u_offset[1] = 0;
7560: u.u_error = ENOTDIR; 7586: u.u_offset[0] = 0;
7561: goto out; 7587: u.u_segflg = 1;
7562: } 7588: eo = 0;
7563: if(access(dp, IEXEC)) 7589: u.u_count = ldiv(dp->i_size1, DIRSIZ+2);
7564: goto out; 7590: bp = NULL;
7565:
7570: cp = &u.u_dbuf[0];
7571: while(c!='/' && c!='¥0' && u.u_error==0) {
7572: if(cp < &u.u_dbuf[DIRSIZ])
7573: *cp++ = c;
7574: c = (*func)();
7575: }
2012/3/24 66

7638: u.u_offset[1] =+ DIRSIZ+2; 7661: }
7639: u.u_count--; 7662: bp = dp->i_dev;
7640: if(u.u_dent.u_ino == 0) { 7663: iput(dp);
7641: if(eo == 0) 7664: dp = iget(bp, u.u_dent.u_ino);
7642: eo = u.u_offset[1]; 7665: if(dp == NULL)
7643: goto eloop; 7666: return(NULL);
7644: } 7667: goto cloop;
7645: for(cp = &u.u_dbuf[0]; cp < 7668:
&u.u_dbuf[DIRSIZ]; cp++) 7669: out:
7646: if(*cp != cp[u.u_dent.u_name - 7670: iput(dp);
u.u_dbuf]) 7671: return(NULL);
7647: goto eloop; 7672: }
7648:
7655: if(bp != NULL)
7656: brelse(bp);
7657: if(flag==2 && c=='¥0') {
7658: if(access(dp, IWRITE))
7659: goto out;
7660: return(dp);

2012/3/24 67

7592: eloop: 7624: brelse(bp);
7600: if(u.u_count == 0) { 7625: bp = bread(dp->i_dev,
7601: if(bp != NULL) 7626: bmap(dp, ldiv(u.u_offset[1],
7602: brelse(bp); 512)));
7603: if(flag==1 && c=='¥0') { 7627: }
7604: if(access(dp, IWRITE)) 7636: bcopy(bp->b_addr+(u.u_offset[1]&0777),
7605: goto out; &u.u_dent, (DIRSIZ+2)/2);
7606: u.u_pdir = dp; 7637:
7607: if(eo)
7608: u.u_offset[1] = eo-DIRSIZ-2;
else
7609: dp->i_flag =| IUPD;
7610: return(NULL);
7611: }
7612: u.u_error = ENOENT;
7613: goto out;
7614: }
7622: if((u.u_offset[1]&0777) == 0) {
7623: if(bp != NULL)

2012/3/24 68

検索論理
 /fileA/fileB/fileC
Boot block
Super block

Inode blocks
Struct inode[]

data blocks

2012/3/24 69

名前空間
 UNIXのファイル識別は内部的にはi番号
 i番号は1DISK装置内でユニーク
 mountで複数のDISKを使うのでdev+i番号で１
システム中のファイルは完全にユニーク

2012/3/24 70

Inodeとfdを関連付ける

2012/3/24 71

open – sys2.c
5765: open()
5766: {
5767: register *ip;
5768: extern uchar;
5769:
5770: ip = namei(&uchar, 0);
5771: if(ip == NULL)
5772: return;
5773: u.u_arg[1]++;
5774: open1(ip, u.u_arg[1], 0);
5775: }

2012/3/24 72

open1 – open.c
5804: open1(ip, mode, trf) 5821: }
5805: int *ip; 5822: if(u.u_error)
5806: { 5823: goto out;
5807: register struct file *fp; 5824: if(trf)
5808: register *rip, m; 5825: itrunc(rip);
5809: int i; 5826: prele(rip);
5810: 5827: if ((fp = falloc()) == NULL)
5811: rip = ip; 5828: goto out;
5812: m = mode; 5829: fp->f_flag = m&(FREAD|FWRITE);
5813: if(trf != 2) { 5830: fp->f_inode = rip;
5814: if(m&FREAD) 5831: i = u.u_ar0[R0];
5815: access(rip, 5832: openi(rip, m&FWRITE);
IREAD); 5833: if(u.u_error == 0)
5816: if(m&FWRITE) { 5834: return;
5817: access(rip, 5835: u.u_ofile[i] = NULL;
IWRITE); 5836: fp->f_count--;
5818: if((rip- 5837:
>i_mode&IFMT) == IFDIR)
5838: out:
5819:
u.u_error = EISDIR; 5839: iput(rip);
5820:
2012/3/24 } 5840: } 73

falloc – fio.c
6847: falloc()
6848: {
6849: register struct file *fp;
6850: register i;
6851:
6852: if ((i = ufalloc()) < 0)
6853: return(NULL);
6854: for (fp = &file[0]; fp < &file[NFILE]; fp++)
6855: if (fp->f_count==0) {
6856: u.u_ofile[i] = fp;
6857: fp->f_count++;
6858: fp->f_offset[0] = 0;
6859: fp->f_offset[1] = 0;
6860: return(fp);
6861: }
6862: printf("no file¥n");
6863: u.u_error = ENFILE;
6864: return(NULL);

2012/3/24 74

fd->file->inode->baddrの流れ

2012/3/24 75

read, write – sys2.c
5708: /*
5709: * read system call
5710: */
5711: read()
5712: {
5713: rdwr(FREAD);
5714: }
5715: /* --------------------------- */
5716:
5717: /*
5718: * write system call
5719: */
5720: write()
5721: {
5722: rdwr(FWRITE);
5723: }

2012/3/24 76

rdwr – sys2.c
5731: rdwr(mode)
5732: {
5733: register *fp, m;
5734:
5735: m = mode;
5736: fp = getf(u.u_ar0[R0]);
5737: if(fp == NULL)
5738: return;
5739: if((fp->f_flag&m) == 0) {
5740: u.u_error = EBADF;
5741: return;
5742: }
5743: u.u_base = u.u_arg[0];
5744: u.u_count = u.u_arg[1];
5745: u.u_segflg = 0;
5746: if(fp->f_flag&FPIPE) {

2012/3/24 77

rdwr – sys2.c
5746: if(fp->f_flag&FPIPE) {
5747: if(m==FREAD)
5748: readp(fp); else
5749: writep(fp);
5750: } else {
5751: u.u_offset[1] = fp->f_offset[1];
5752: u.u_offset[0] = fp->f_offset[0];
5753: if(m==FREAD)
5754: readi(fp->f_inode); else
5755: writei(fp->f_inode);
5756: dpadd(fp->f_offset, u.u_arg[1]-u.u_count);
5757: }
5758: u.u_ar0[R0] = u.u_arg[1]-u.u_count;
5759: }

2012/3/24 78

readi – sys2.c
6216: * u_base core address for destination
6217: * u_offset byte offset in file
6218: * u_count number of bytes to read
6219: * u_segflg read to kernel/user
6220: */
6221: readi(aip)
6222: struct inode *aip;
6223: {
6224: int *bp;
6225: int lbn, bn, on;
6226: register dn, n;
6227: register struct inode *ip;
6228:
6229: ip = aip;
6230: if(u.u_count == 0)
6231: return;

2012/3/24 79

readi – sys2.c
6232: ip->i_flag =| IACC;
6238: do {
6239: lbn = bn = lshift(u.u_offset, -9);
6240: on = u.u_offset[1] & 0777;
6241: n = min(512-on, u.u_count);
6242: if((ip->i_mode&IFMT) != IFBLK) {
6243: dn = dpcmp(ip->i_size0&0377, ip->i_size1,
6244: u.u_offset[0], u.u_offset[1]);
6245: if(dn <= 0)
6246: return;
6247: n = min(n, dn);
6248: if ((bn = bmap(ip, lbn)) == 0)
6249: return;
6250: dn = ip->i_dev;
6251: } else {
6252: dn = ip->i_addr[0];
6253: rablock = bn+1;
2012/3/24
6254: } 80

readi – sys2.c
6255: if (ip->i_lastr+1 == lbn)
6256: bp = breada(dn, bn, rablock);
6257: else
6258: bp = bread(dn, bn);
6259: ip->i_lastr = lbn;
6260: iomove(bp, on, n, B_READ);
6261: brelse(bp);
6262: } while(u.u_error==0 && u.u_count!=0);
6263: }

2012/3/24 81

writei – rdwri.c
6271: * u_base core address for source
6272: * u_offset byte offset in file
6273: * u_count number of bytes to write
6274: * u_segflg write to kernel/user
6275: */
6276: writei(aip)
6277: struct inode *aip;
6278: {
6279: int *bp;
6280: int n, on;
6281: register dn, bn;
6282: register struct inode *ip;
6283:
6284: ip = aip;
6285: ip->i_flag =| IACC|IUPD;
6286: if((ip->i_mode&IFMT) == IFCHR) {
6287: (*cdevsw[ip->i_addr[0].d_major].d_write)(ip->i_addr[0]);
6288: return;
6289: }
2012/3/24 82

writei – rdwri.c
6290: if (u.u_count == 0)
6291: return;
6292:
6293: do {
6294: bn = lshift(u.u_offset, -9);
6295: on = u.u_offset[1] & 0777;
6296: n = min(512-on, u.u_count);
6297: if((ip->i_mode&IFMT) != IFBLK) {
6298: if ((bn = bmap(ip, bn)) == 0)
6299: return;
6300: dn = ip->i_dev;
6301: } else
6302: dn = ip->i_addr[0];
6303: if(n == 512)
6304: bp = getblk(dn, bn); else
6305: bp = bread(dn, bn);
6306: iomove(bp, on, n, B_WRITE);

2012/3/24 83

writei – rdwri.c
6307: if(u.u_error != 0)
6308: brelse(bp); else
6309: if ((u.u_offset[1]&0777)==0)
6310: bawrite(bp); else
6311: bdwrite(bp);
6312: if(dpcmp(ip->i_size0&0377, ip->i_size1,
6313: u.u_offset[0], u.u_offset[1]) < 0 &&
6314: (ip->i_mode&(IFBLK&IFCHR)) == 0) {
6315: ip->i_size0 = u.u_offset[0];
6316: ip->i_size1 = u.u_offset[1];
6317: }
6318: ip->i_flag =| IUPD;
6319: } while(u.u_error==0 && u.u_count!=0);
6320: }

2012/3/24 84

UNIXの最大の発明

2012/3/24 85

pipe – pipe.c
7723: pipe() 7739: rf->f_count = 0;
7724: { 7740: u.u_ofile[r] = NULL;
7725: register *ip, *rf, *wf; 7741: iput(ip);
7726: int r; 7742: return;
7727: 7743: }
7728: ip = ialloc(rootdev); 7744: u.u_ar0[R1] = u.u_ar0[R0];
7729: if(ip == NULL) 7745: u.u_ar0[R0] = r;
7730: return; 7746: wf->f_flag = FWRITE|FPIPE;
7731: rf = falloc(); 7747: wf->f_inode = ip;
7732: if(rf == NULL) { 7748: rf->f_flag = FREAD|FPIPE;
7733: iput(ip); 7749: rf->f_inode = ip;
7734: return; 7750: ip->i_count = 2;
7735: } 7751: ip->i_flag = IACC|IUPD;
7736: r = u.u_ar0[R0]; 7752: ip->i_mode = IALLOC;
7737: wf = falloc(); 7753: }
7738: if(wf == NULL) {

2012/3/24 86

実は強力な

2012/3/24 87

dup – sys3.c
6069: dup()
6070: {
6071: register i, *fp;
6072:
6073: fp = getf(u.u_ar0[R0]);
6074: if(fp == NULL)
6075: return;
6076: if ((i = ufalloc()) < 0)
6077: return;
6078: u.u_ofile[i] = fp;
6079: fp->f_count++;
6080: }

2012/3/24 88

パイプとリダイレクト

2012/3/24 89

リダイレクト
1 “> out”でoutをopen fd:3
“out”

2 標準出力fd:1をclose
“out”

3 “out”のfd:3をdup →fd:1 “out”

5 “out”のfdをclose “out”

2012/3/24 90

パイプ
1 pipeを呼ぶ

2 forkする

3 親のread fdをclose

4 子のwrite fdをclose

5 必要ならcloseとdupで0,1に繋ぎかえ

2012/3/24 91

DISKとメモリを繋ぐ

2012/3/24 92

buf - buf.h
4520: struct buf
4521: {
4522: int b_flags; /* see defines below */
4523: struct buf *b_forw; /* headed by devtab of b_dev */
4524: struct buf *b_back; /* " */
4525: struct buf *av_forw; /* position on free list, */
4526: struct buf *av_back; /* if not BUSY*/
4527: int b_dev; /* major+minor device name */
4528: int b_wcount; /* transfer count (usu. words) */
4529: char *b_addr; /* low order core address */
4530: char *b_xmem; /* high order core address */
4531: char *b_blkno; /* block # on device */
4532: char b_error; /* returned after I/O */
4533: char *b_resid; /* words not transferred after error */
4534:
4535: } buf[NBUF];

0130: #define NBUF 15 /* size of buffer cache */

2012/3/24 93

buf - buf.h
4566: struct buf bfreelist;
4567:
4571: #define B_WRITE 0 /* non-read pseudo-flag */
4572: #define B_READ 01 /* read when I/O occurs */
4573: #define B_DONE 02 /* transaction finished */
4574: #define B_ERROR 04 /* transaction aborted */
4575: #define B_BUSY 010 /* not on av_forw/back list */
4576: #define B_PHYS 020 /* Physical IO potentially using UNIBUS map */
4577:
4578: #define B_MAP 040 /* This block has the UNIBUS map allocated */
4579:
4580: #define B_WANTED 0100 /* issue wakeup when BUSY goes off */
4581:
4582: #define B_RELOC 0200 /* no longer used */
4583: #define B_ASYNC 0400 /* don't wait for I/O completion */
4584:
4585: #define B_DELWRI 01000 /* don't write till block leaves available list */

2012/3/24 94

devtab – buf.h
4551: struct devtab
4552: {
4553: char d_active; /* busy flag */
4554: char d_errcnt; /* error count (for recovery) */
4555: struct buf *b_forw; /* first buffer for this dev */
4556: struct buf *b_back; /* last buffer for this dev */
4557: struct buf *d_actf; /* head of I/O queue */
4558: struct buf *d_actl; /* tail of I/O queue */
4559: };

2012/3/24 95

buf - buf.h
devtab
b_forw
b_back
d_actf
d_actl

b_forw
av_forw
av_back
b_back

512byte

2012/3/24 96

buf - buf.h

b_blkno

b_dev 512byte
b_blkno
b_addr

514byte

2012/3/24 97

bufの役割
 1つのbuf構造が512バイトのキャッシュを管理
 DISKドライバの非同期処理の管理を兼ねる
 キャッシュの識別はb_dev(maj:min)とb_blkno
 512バイト単位のDISKアクセスとバイト単位の
メモリアクセスの緩衝器の役割も兼ねる
 例：
○ inodeは16バイト、DISKから512バイト(inode
を32個)読みだしてbufで管理
○ ディレクトエントリは16バイト、DISKから32個読みだ
して、各エントリを操作
2012/3/24 98

bufの操作
 獲得
 getblk DISKから読まずにbufを獲得
 bread DISKから読んでbufを獲得 - 同期
 breada DISKから読んでbufを獲得 - 非同期
 解放
 Bwrite DISKへ書いてbufを解放
 Bdwrite DISKへ書いてbufを解放
 Bawrite DISKへか
 Brelse DISKへ書かずにbufを解放

2012/3/24 99

binit – bio.c
5055: binit() 5073: brelse(bp);
5056: { 5074: }
5057: register struct buf *bp; 5075: i = 0;
5058: register struct devtab *dp; 5076: for (bdp = bdevsw;
5059: register int i; bdp->d_open; bdp++) {
5060: struct bdevsw *bdp; 5077: dp = bdp->d_tab;
5061: 5078: if(dp) {
5062: bfreelist.b_forw = bfreelist.b_back = 5079: dp->b_forw = dp;
5063: bfreelist.av_forw = bfreelist.av_back = 5080: dp->b_back = dp;
&bfreelist; 5081: }
5064: for (i=0; i<NBUF; i++) { 5082: i++;
5065: bp = &buf[i]; 5083: }
5066: bp->b_dev = -1; 5084: nblkdev = i;
5067: bp->b_addr = buffers[i]; 5085: }
5068: bp->b_back = &bfreelist;
5069: bp->b_forw = bfreelist.b_forw;
5070: bfreelist.b_forw->b_back = bp;
5071: bfreelist.b_forw = bp;
5072: bp->b_flags = B_BUSY;
2012/3/24 100

getblk – bio.c
4921: getblk(dev, blkno) 4951: }
4922: { 4952: spl6();
4923: register struct buf *bp; 4953: if (bfreelist.av_forw == &bfreelist) {
4924: register struct devtab *dp; 4954: bfreelist.b_flags =| B_WANTED;
4925: extern lbolt; 4955: sleep(&bfreelist, PRIBIO);
4930: loop: 4956: spl0();
4931: if (dev < 0) 4957: goto loop;
4932: dp = &bfreelist; 4958: }
4933: else { 4959: spl0();
4934: dp = bdevsw[dev.d_major].d_tab; 4960: notavail(bp = bfreelist.av_forw);
4935: if(dp == NULL) 4961: if (bp->b_flags & B_DELWRI) {
4936: panic("devtab"); 4962: bp->b_flags =| B_ASYNC;
4937: for (bp=dp->b_forw; bp != dp; bp = bp->b_forw) { 4963: bwrite(bp);
4938: if (bp->b_blkno!=blkno || bp->b_dev!=dev) 4964: goto loop;
4939: continue; 4965: }
4940: spl6(); 4966: bp->b_flags = B_BUSY | B_RELOC;
4941: if (bp->b_flags&B_BUSY) { 4967: bp->b_back->b_forw = bp->b_forw;
4942: bp->b_flags =| B_WANTED; 4968: bp->b_forw->b_back = bp->b_back;
4943: sleep(bp, PRIBIO); 4969: bp->b_forw = dp->b_forw;
4944: spl0(); 4970: bp->b_back = dp;
4945: goto loop; 4971: dp->b_forw->b_back = bp;
4946: } 4972: dp->b_forw = bp;
4947: spl0(); 4973: bp->b_dev = dev;
4948: notavail(bp); 4974: bp->b_blkno = blkno;
4949: return(bp); 4975: return(bp);
2012/3/24
4950: } 4976: } 101

incore – bio.c
4896: /* See if the block is associated with some buffer
4897: * (mainly to avoid getting hung up on a wait in breada)
4898: */
4899: incore(adev, blkno)
4900: {
4901: register int dev;
4903: register struct devtab *dp;
4904:
4905: dev = adev;
4906: dp = bdevsw[adev.d_major].d_tab;
4907: for (bp=dp->b_forw; bp != dp; bp = bp->b_forw)
4908: if (bp->b_blkno==blkno && bp->b_dev==dev)
4909: return(bp);
4910: return(0);
4911: }

2012/3/24 102

bread – bio.c
4754: bread(dev, blkno)
4755: {
4757:
4758: rbp = getblk(dev, blkno);
4759: if (rbp->b_flags&B_DONE)
4760: return(rbp);
4761: rbp->b_flags =| B_READ;
4762: rbp->b_wcount = -256;
4763: (*bdevsw[dev.d_major].d_strategy)(rbp);
4764: iowait(rbp);
4765: return(rbp);
4766: }

2012/3/24 103

breada – bio.c
4773: breada(adev, blkno, rablkno) 4792: else {
4774: { 4793: rabp->b_flags =|
4775: register struct buf *rbp, *rabp; B_READ|B_ASYNC;
4776: register int dev; 4794: rabp->b_wcount = -256;
4777: 4795:
4778: dev = adev; (*bdevsw[adev.d_major].d_strategy)(rabp);
4779: rbp = 0; 4796: }
4780: if (!incore(dev, blkno)) { 4797: }
4781: rbp = getblk(dev, blkno); 4798: if (rbp==0)
4782: if ((rbp->b_flags&B_DONE) == 0) { 4799: return(bread(dev, blkno));
4783: rbp->b_flags =| B_READ; 4800: iowait(rbp);
4784: rbp->b_wcount = -256; 4801: return(rbp);
4785: (*bdevsw[adev.d_major].d_strategy)(rbp); 4802: }
4786: }
4787: }
4788: if (rablkno && !incore(dev, rablkno)) {
4789: rabp = getblk(dev, rablkno);
4790: if (rabp->b_flags & B_DONE)
4791: brelse(rabp);
2012/3/24 104

bwrite – bio.c
4809: bwrite(bp)
4811: {
4813: register flag;
4814:
4815: rbp = bp;
4816: flag = rbp->b_flags;
4817: rbp->b_flags =& ~(B_READ | B_DONE | B_ERROR | B_DELWRI);
4818: rbp->b_wcount = -256;
4819: (*bdevsw[rbp->b_dev.d_major].d_strategy)(rbp);
4820: if ((flag&B_ASYNC) == 0) {
4821: iowait(rbp);
4822: brelse(rbp);
4823: } else if ((flag&B_DELWRI)==0)
4824: geterror(rbp);
4825: }

2012/3/24 105

brelese – bio.c
4869: brelse(bp)
4871: {
4872: register struct buf *rbp, **backp;
4873: register int sps;
4874:
4875: rbp = bp;
4876: if (rbp->b_flags&B_WANTED)
4877: wakeup(rbp);
4878: if (bfreelist.b_flags&B_WANTED) {
4879: bfreelist.b_flags =& ~B_WANTED;
4880: wakeup(&bfreelist);
4881: }
4882: if (rbp->b_flags&B_ERROR)
4883: rbp->b_dev.d_minor = -1; /* no assoc. on error */
4884: backp = &bfreelist.av_back;
4885: sps = PS->integ;
4886: spl6();
4887: rbp->b_flags =& ~(B_WANTED|B_BUSY|B_ASYNC);
4888: (*backp)->av_forw = rbp;
4889: rbp->av_back = *backp;
4890: *backp = rbp;
4891: rbp->av_forw = &bfreelist;
4892: PS->integ = sps;
4893: }
2012/3/24 106

iowait – bio.c
4982: iowait(bp)
4984: {
4986:
4987: rbp = bp;
4988: spl6();
4989: while ((rbp->b_flags&B_DONE)==0)
4990: sleep(rbp, PRIBIO);
4991: spl0();
4992: geterror(rbp);
4993: }

2012/3/24 107

参考資料
 RK11-D and RK11-E moving head disk drive
controller manual

 UNIX v6 マニュアル
 http://wwwlehre.dhbw-
stuttgart.de/~helbig/os/v6/doc/index.html

2012/3/24 108

V6 unix vol.2 in okinawa

More Related Content

What's hot (20)

Similar to V6 unix vol.2 in okinawa (20)

More from magoroku Yamamoto (20)

V6 unix vol.2 in okinawa