Deprecated: The each() function is deprecated. This message will be suppressed on further calls in /home/zhenxiangba/zhenxiangba.com/public_html/phproxy-improved-master/index.php on line 456
システムプログラム（2011年度1学期前半）

システムプログラム（2011年度1学期前半）

コンピュータサイエンス専攻
追川 修一

理解を深めるために

授業中は，話の途中でも，わからないことが出てきたら，手を上げて質問しましょう．
実習中は，教員，ＴＡ，周りの席の人を活用しましょう．

第1週

講義システムプログラムの目的

ソフトウェアの構成とシステムプログラム

プログラムの実行環境

プログラムの開発環境

プログラミングとデバッグ

ポインタ（１）

第2週

文字，文字列のデータ表現

標準入出力

文字，文字列操作ライブラリ

ポインタ（２）

第3週

ファイルアクセス

ファイルアクセス（応用）

ポインタ（３）

バッファオーバーフロー

第4週

プロセスの概念と機能

プロセスの操作：プロセス作成，プログラム実行，プロセス終了

リダイレクション，パイプ

その他のプロセス操作のためのシステムコール，ライブラリ関数

第5週

シグナル

講義システムプログラムの目的

システムプログラムでは，ユーザの立場から計算機システムやオペレーティングシステムをより深く理解し，活用できるようになるためのプログラミングスキルの習得を目的とする．

オペレーティングシステム（OS: Operating System）とは

OSはハードウェアの違いを隠蔽し，ユーザがプログラムを実行するための使いやすい環境を提供する．例えば，PC，ラップトップ，サーバのハードウェア構成（プロセッサの種類や数，メモリの量，入出力デバイスなど）の違いによって，プログラムの変更が必要だとすると，プログラミングが大変である． OSは，ハードウェアを抽象化した概念（アブストラクション）を提供することで，いろいろなコンピュータで共通に使用できる実行環境を提供する．

OSの提供する主な抽象概念としては以下のものがある．

抽象概念ハードウェア機能

プロセスプロセッサ，メモリ

ファイル，ディレクトリストレージ

プロセス間通信コンピュータ間の通信

シグナル割り込み

アクセス制御コンピュータ共有時の保護

基本的な抽象概念の考え方はめったに変わることはない．実際，上記の抽象概念は30年以上変わっていない．

OSの「内部の仕組み」については2学期の「オペレーティング・システム I」という講義で扱われる．また，3学期の「オペレーティング・システム II 」や「分散システム」では，より高度な話題が扱われる．内部の仕組みの前に，外から見た場合のOSの考え方，使い方を理解することがシステムプログラムの目的である．

API（Application Program Interface）を用いたプログラミング

OSの提供する抽象概念の集合が，ユーザから見た場合のコンピュータになる．その抽象的なコンピュータを操作するためのインタフェースとしてAPI（Application Program Interface）が提供されている． APIを用いることにより，抽象化されたコンピュータを操作することができるようになる． APIを通して，プログラムという実体のないものが，OS，OSの管理するデバイスを通して，外の世界とつながり，プログラムと人間のインタラクションが可能になる．

APIは一般に

OSカーネルが提供するシステムコール
システムコールを便利に使えるようするための，また多くのプログラムで利用できる部品としてのライブラリやマクロ

により提供される． APIを使いこなすことにより，プログラムの生産性，信頼性，安全性，移植性を上げることができる．プログラミング言語を自然言語と対比してみると，プログラミング言語自体は文法，APIは語彙に相当すると考えられる． APIを覚えることにより，わかりやすく簡潔な表現が可能になる．

この講義ではUNIX (Mac OS X) を用いて，POSIX (Portable Operating System Interface for UNIX) APIを利用してプログラムを作成する．

参考：UNIXが使われているところ

ソフトウェアの構成とシステムプログラム

プログラムの種類

システムプログラムでは，ライブラリやシステムコールを通してUNIXカーネルを直接的に利用する．

UNIX OSの構成要素

OSという言葉は様々な意味で使われる．様々なプログラムから構成されるOS環境を意味する場合もあるし，OSカーネルを意味する場合もある．以下の図は一般的なUNIX環境を構成するプログラムを示している． Mac OS XのネイティブウィンドウシステムはQuartz，またGUIはAquaと呼ばれるものであるが，基本的な全体構成は同じである．

以下，ユーザの目に触れる部分から構成要素について概説する．

シェル

UNIXユーザのユーザインタフェースとして最もよく使われるプログラムがシェル（shell）である．シェルは，ユーザの視点からOSを見た場合，OSを操作するためにOSを取り囲んでいる殻という意味である．一般的なシェルには，BSH（Bourne Shell），BASH（Bourne Again Shell），CSH（C Shell），TCSH（Tenex-like C Shell）などがある．

シェルはCLI（Command Line Interface）を通して，ユーザからのコマンドを受け付け，解釈，実行し，その結果を出力する機能を提供する．シェルは，コマンドの入出力を，ファイルや別のコマンドにするリダイレクションやパイプといった機能を提供する．この機能により，複数の比較的単純な機能を持つコマンドを組み合わせて使用することが可能になる．実行するコマンドを記述した簡易プログラムとしてシェルスクリプトを作ることもでき，この機能と合わせて，プログラミングの素養を持つユーザには非常に強力なインタフェースを提供している．

情報システム実験 I，IIのシステムプログラムでは，シェルを実際に作成してみる．シェルはUNIXの基本となるプログラムであり，UNIXの基本的な抽象概念の操作が必要であるため，システムプログラムの基本を学習するための題材として最適である．

XウィンドウシステムとGUI（Graphical User Interface）

現在のユーザが直接使用するコンピュータのほとんどはGUIを提供している． Mac OS XやWindowsなどではGUIは完全にOSの一部となってしまっている．

その他の一般的なUNIXではXウィンドウシステムとウィンドウマネージャという独立したプログラムとして提供されている． Xウィンドウシステムは，ビットマップディスプレイ上にウィンドウを表示するための基本的な機能を提供するだけである．ユーザがウィンドウを操作するためのGUIは，GNOMEやKDEといったプログラム群（デスクトップ環境とも呼ばれる）により提供される．

コマンド，アプリケーション

コマンドとは，ユーザが（シェルを通して）コンピュータに与える命令である． UNIXは，シェルから使用することのできる非常に多くのコマンドを提供している．コマンドはシェルとは別のプログラムである場合（外部コマンド）もあるし，シェルに組み込まれている場合（組み込みコマンド）もある． cd, set, umask, exitといったシェル自身の状態を変更するコマンドや，historyなどのシェルが持つ情報を表示するコマンドは組み込みコマンドである．そうでないコマンドは，通常外部コマンドである．

コマンドと呼ぶ場合とアプリケーションと呼ぶ場合に明確な違いがあるわけではない． Officeやビデオ再生プログラムのような，それだけで必要な機能を提供する自己完結的なプログラムをアプリケーションと呼ぶ場合が多い．

サーバ，デーモン

UNIXでは，バックグラウンドで動作し様々なサービスを提供する裏方で働くプログラムのことをデーモン（daemon）と呼んでいたが，最近ではサーバと呼ぶことも多い．デーモンには，メイルの配信をするプログラム，プリンタへの出力要求を仲介するプログラム，リモートログインやリモートファイルコピーなどのネットワーク機能を提供するプログラムなどがある．

システムコール，ライブラリ，ミドルウェア

UNIXでプログラミングをする場合，システムコール，ライブラリ，ミドルウェアを使用してプログラムを作成する．システムコールは，OSカーネルの機能を直接呼び出すためのインタフェースである． UNIXのシステムコールは，できるだけシンプルになるように設計されている．ライブラリとミドルウェアはプログラムの部品となる関数の集合である．ライブラリとミドルウェアの違いは，ライブラリは様々な目的のプログラムで共通の機能を提供するものであるのに対し，ミドルウェアはライブラリより特定のプログラム（例えばGUI）の共通部品となるものである．これらをうまく使うことで，開発効率，信頼性，安全性，移植性が上がり，また出来上がったプログラムも読みやすくなり，実行効率（又は見栄え）も良くなる．

システムコールもライブラリも，Cプログラムから呼び出す場合はどちらも関数呼び出しの形態で使用できるため，同じに見える． UNIXのマニュアルでは，システムコールは2章，ライブラリは3章に分類されており，ヘッダ部分に「READ(2)」のように「(2)」と付いていれば2章の意味でシステムコールであり，「FREAD(3)」のように「(3)」と付いていれば3章の意味でライブラリである．

プログラムとの関係については，プログラム，ライブラリ，システムコールの関係でより詳しく述べる．

UNIXカーネル

UNIXカーネルは，プロセッサの特権モードというハードウェアの全てを制御することのできる動作モードで動作し，直接ハードウェアを制御するプログラムである． UNIXカーネルは，プロセッサの機能を使うことで，複数プログラムの同時実行を可能にし，それぞれのプログラム（又はユーザ）がコンピュータを占有しているかのような幻想を与える． UNIX環境で特権モードで動作するプログラムはカーネルだけである．その他のプログラムは，ユーザモードというハードウェアへのアクセスは制御された環境で動作する．

UNIXカーネルは，大まかに言ってプロセス管理，ファイルシステム，メモリ管理，ネットワーク，プロセッサ依存部，デバイスドライバからなる．ファイルシステム，ネットワークは比較的部品化されているが，全体的にお互いが関係しあって動作する大きなプログラムである．

プログラム，ライブラリ関数，システムコールの関係

ライブラリ関数とシステムコールは，入出力機能やその他にもいろいろ便利な機能を提供してくれるという点で，プログラマから見ると似ているところがある．しかし，ライブラリ関数とシステムコールには，いくつか大きな違いがある．

実行時に，ライブラリ関数はそれを使用するプログラムの一部となるが，カーネルは完全に独立したプログラムとして存在する：
プログラムは，プロセスというものの中で実行される（プロセスについては次節で詳しく述べる）．プログラムとライブラリは同じプロセスの中（プロセス空間）にある．しかし，カーネルは別の所（カーネル空間）にあり，プロセスからはアクセスできないところで実行されている．プロセスは，システムコールを通してのみ，カーネルの機能を使うことができる．
プログラムからの入出力は結局はシステムコールを通して実現される：
例えば open, read, write, close といったシステムコールに対し，fopen, fread, fwrite, fclose という良く似たライブラリ関数が用意されている． f{open,read,write,close}は，誰でも様々なプログラムで効率よく入出力を行えるような工夫（バッファリング）がされている．しかし，外の世界（入出力機器）とつながっているのはカーネルだけなので，fopen は open, fread は read と，最終的にはシステムコールを呼ばないと入出力は行えない．
ライブラリだけで実現される機能もある：
文字数を数えたり，文字列を比較したりといった，入出力を伴わない，しかしプログラムでよく使われる部品となるような機能を，ライブラリはいろいろ提供している．ライブラリをうまく使うことで，効率よくプログラミングができるようになる．

上の例では，read はシステムコールなので直接カーネルを呼び出している． strcmp はライブラリだけで機能が実現されているライブラリ関数である． printf はライブラリ関数であるが，標準出力に文字出力を行うために，write システムコールを使用している．

プログラムの実行環境

プログラムとプロセスの関係

一言で言えば，プログラムを実行中のものがプロセスである．別の言い方をすると，プログラムはプロセスにより実行される．プログラムとそれを実行中のプロセスは別のものである．従って，1つのプログラムを複数実行する（同じプロセスを実行しているプロセスを複数作る）ことができる．

プログラムは，CPUが実行できる機械語命令とそれにより処理されるデータの集合（実行形式，ロードモジュール）がファイルに格納されたものである．つまり，プログラムには何かをするためにCPUで処理を開始するための情報が入っている．
一方，プロセスには実行中の情報が入っている．実行が進めばデータは書き換えられたり，追加されたりする（機械語命令は通常変わらない）．プログラムには含まれていない，実行中の履歴を格納するためのデータ（スタック）も必要である．

プログラムの実行は通常シェルから行う．シェルのプロンプトにプログラムのファイル名を打ち込むと，そのプログラムを実行するためのプロセスが作られ，実行される．プロセスは誰か（そのプロセス自信でもよい）が終了させないと，いつまでも動いている．終了させるためには，そのための手順を踏む必要がある（システムコールを呼ぶか強制的に終了させる）．

上の例は，HDD (Hard Disk Drive) に格納されている2つのプログラムemacsとfirefoxを異なる二人のユーザが実行している例である． emacs，firefoxのプログラムはそれぞれ1つであるが，同じプログラムを実行して複数のプロセスを作ることができるため，ユーザ毎に別々のプロセスになっている．

プロセスの観察

UNIXにはプロセスを観察するためのコマンドがいくつか用意されている． psコマンドはプロセスの状態を得るための最も標準的なコマンドであり，全てのUNIXで使用できる． pstree，topコマンドは，用意されていないUNIXシステムもあるかもしれない．

psコマンドはオプションにより様々な情報を表示することができる．

% ps 
% top
% man システムコール名 
% man 3 printf 
% man 2 intro

インデンテーション

プログラム作成時に気をつけて欲しいことの一つにインデンテーションがある．

エディタとしてEmacsを使用している場合，デフォルトのインデンテーション（字下げ，段付け）のスタイルはあまり一般的ではないものになっているため，.emacs に以下の行を追加する．（追加直後は，変更を有効にするために，emacsを一旦終了後，再び起動する．）

(setq c-default-style "linux")

TABキーを叩くことで，設定された値だけ右にインデント（字下げ）される． TABキーを叩くのは行頭である必要はない．

デフォルトでは以下のようなスタイルになる．

1 void sort(int data[], int count){ 2 int i, sw=0, last=1, n=count-1; 3 while(sw!=n){ 4 sw = n; 5 for(i=n; i>=last; i--) 6 if(data[i]<data[i-1]){ 7 swap_array(data, i, i-1); 8 sw=i; 9 } 10 last=sw+1; 11 } 12 }

変更後は以下のようなスタイルになる．また，変数名や予約語，演算子の前後にスペースを入れ，単語が詰まらないようにした．そして，変数宣言部と実行部分間に空行を入れ，分離している．

1 void 2 sort(int data[], int count) 3 { 4 int i; 5 int sw = 0; 6 int last = 1; 7 int n = count - 1; 8 9 while (sw != n) { 10 sw = n; 11 for (i = n; i >= last; i--) 12 if (data[i] < data[i - 1]) { 13 swap_array(data, i, i - 1); 14 sw = i; 15 } 16 last = sw + 1; 17 } 18 }

タブが8文字と字下げ量が多くなり，ブロックが明確になる．また，空白や空行を使うことで，プログラム内の構造がわかりやすくなる．

また，以下のような点にも注意し，読みやすい見た目にも綺麗なプログラムを書くことを心がける．

書式に一貫性を持たせる．（書式を整えることにすら気を遣わないプログラマは信頼されない．）

1行をあまり長くしすぎることがないようにし，90文字程度に抑え，同じ文であっても改行する．

入り組んだ構文の結果，インデントが深くなりすぎないように，順番を入れ換えたり，関数にするなどの工夫をする．

※注意※

エディタとしてEmacsを使用しているか否かに関わらず，前半（第1～5週）のレポート課題では，上記のように8文字分のタブを字下げに使用したインデンテーションスタイルを使用し，また上記の注意点にも気をつけてプログラムを作成し，提出すること．インデンテーションスタイルが異なっていたり，読みにくい場合は，再提出にします．

コンパイルとリンク

コンパイル・実行・修正

以下は，sum.c という1から10までの総和を求める簡単なプログラムをコンパイル実行した例である．

% nl -ba sum.c % man 3 printf 1 #include <stdio.h> 2 3 #define MAX 10 4 5 main() 6 { 7 int i, total; 8 9 total = 0; 10 for (i = 1; i <= MAX; i++) 11 total += i; 12 13 printf("total = %d\n", total); 14 }

ccにより起動されるプログラム

cc コマンド自体は実はコンパイルといった処理をしない．コンパイルに必要な処理をしてくれるコマンドを呼び出すだけである．

cc に -v オプションを追加すると，cc から起動されるプログラムの様子がわかる． -v オプションは，cc から起動されるプログラムに指定される引数も全て表示される．そのため，例えばプリプロセッサの引数で指定されるマクロや，リンカに指定されるライブラリなどを知ることもできる．

% cc -v sum.c % cc -E sum.c | nl -ba
リンク

cc に -c オプションを追加すると，アセンブラまでが実行され，オブジェクトプログラムが作られる．オブジェクトプログラムのファイル名は，元のCプログラムのファイル名のサフィックス（接尾辞）を o に変えたものになる．即ち，Cプログラムが sum.c というファイル名の場合は sum.o というファイル名になる．

オブジェクトプログラムを cc の引数に指定すると，cc はサフィックスから引数のファイルがオブジェクトプロプログラムであることを判定し，リンカを起動する．

% cc -c sum.c % /usr/libexec/gcc/i686-apple-darwin10/4.2.1/collect2 -v -dynamic -arch x86_64 -macosx_version_min 10.6.3 -weak_reference_mismatches non-weak -o a.out -lcrt1.10.6.o -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64 -L/usr/lib/i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.. sum.o -lSystem -lgcc -lSystem collect2 version 4.2.1 (Apple Inc. build 5646) (dot 1) (i686 Darwin) /usr/bin/ld -v -dynamic -arch x86_64 -macosx_version_min 10.6.3 -weak_reference_mismatches non-weak -o a.out -lcrt1.10.6.o -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64 -L/usr/lib/i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../../i686-apple-darwin10/4.2.1 -L/usr/lib/gcc/i686-apple-darwin10/4.2.1/../../.. sum.o -lSystem -lgcc -lSystem @(#)PROGRAM:ld PROJECT:ld64-95.2.12 Library search paths: /usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64 /usr/lib/gcc/i686-apple-darwin10/4.2.1/x86_64 /usr/lib/i686-apple-darwin10/4.2.1 /usr/lib/gcc/i686-apple-darwin10/4.2.1 /usr/lib/gcc/i686-apple-darwin10/4.2.1 /usr/lib/i686-apple-darwin10/4.2.1 /usr/lib /usr/lib /usr/local/lib Framework search paths: /Library/Frameworks/ /System/Library/Frameworks/ %

動的リンクと静的リンク

リンクの方法には，動的（ダイナミック）リンクと静的（スタティック）リンクがある．動的リンクとはライブラリを実行時にリンクする方法である．一方，静的リンクでは，リンク時に全てのライブラリをリンクした実行形式を作成する．動的リンクをした実行形式は，（ダイナミックリンク可能な）ライブラリを含まないため，静的リンクされた実行形式よりも小さくなる．また，動的リンクされるライブラリで使用されるメモリ領域は，実行形式間で共有することができるため，メモリ使用量が少ない．しかし，実行時にリンク（未解決シンボルの解消）を行うので，わずかに実行が遅くなる．

動的リンクされた実行形式が使用するライブラリは otool コマンドに -L オプションを付けて実行することで知ることができる．（Linuxでは ldd コマンドを用いる．）

% otool -L a.out

このようなコンパイル手順を自動化してくれるのが make コマンドである． make コマンドは，カレントディレクトリにある makefile 又は Makefile を読み込み，そこに書かれているルールに従ってコンパイルを行う（ルールに従って処理をするだけで，処理がコンパイルである必要性は全くない）．カレントディレクトリに makefile と Makefile の両方があった場合は，makefile が優先される．以下は，上の図のコンパイル手順を Makefile として記述したものである．

a.out: file-1.o file-2.o cc file-1.o file-2.o file-1.o: file-1.c cc -c file-1.c file-2.o: file-2.c cc -c file-2.c

ルールの書き方の基本的なところは単純で，作成したいターゲットの作成方法を以下のように記述する．依存ファイルがまた別の依存ファイルから作成される場合（例えば file1.o が file1.cから作成される場合）は，そのためのルールを書く．依存ファイルがない場合は，必ず処理が実行される．

ターゲット: 依存するファイル <TAB>ターゲット作成のための処理1 <TAB>ターゲット作成のための処理2 ... <TAB>ターゲット作成のための処理n

実際に make コマンドを実行してみると，以下のようになる．

% make http://www.coins.tsukuba.ac.jp/~syspro/gdb-5.0-doc/

ソースコードを参照しながらデバッガを用いたい場合は cc に -g オプションを付けてコンパイルする必要がある． -g オプションを付けていない場合でも，デバッガを用いることはでき，バックトレース（関数の呼び出し履歴）やアセンブリ言語でどの命令で問題が発生したかはわかる．（stripコマンドでシンボル情報が削除されてしまうと，関数名などグローバルシンボルも表示されなくなる．） -g オプションを付けてコンパイルした場合は，ソースコードの何行目に問題が発生したのかがわかり，また変数名を指定してその値を調べることもできる．

良くあるバグにセグメンテーションフォルト（segmentation fault）やバスエラー（bus error）がある．これらは，アクセスが許可されていない番地などにアクセスすると発生する．非常に典型的な例としてNULLポインタアクセスがある． 0番地は通常アクセスが許可されていないため，NULLポインタにアクセスするとセグメンテーションフォルトやバスエラーが発生する． Mac OS XではNULLポインタアクセスはバスエラーを起こす．以下はNULLポインタアクセスによりセグメンテーションフォルトを起こすプログラムを，デバッガから実行した例である．

% cc segfault.c 1 #include <stdio.h> 2 3 #define SAMPLE_COUNT 6 4 int sample[SAMPLE_COUNT] = {8, 12, 3, 15, 7, 4}; 5 6 void 7 print_data(int a[], int count) 8 { 9 int i; 10 11 for (i = 0; i < count; i++) 12 printf("%2d ", a[i]); 13 printf("\n"); 14 } 15 16 void 17 swap_array(int a[], int i, int j) 18 { 19 int tmp; 20 21 tmp = a[i]; 22 a[i] = a[j]; 23 a[j] = tmp; 24 } 25 26 void 27 sort(int data[], int count) 28 { .... omitted .... 35 } 36 37 main() 38 { 39 sort(sample, SAMPLE_COUNT); 40 print_data(sample, SAMPLE_COUNT); 41 }

デバッグ

プログラミングにはデバッグ（バグ取り）が付きものである．書いたプログラムがそのまま正しく動作することは希であり，何らかの問題により正しく思った通りに動作しないのが普通である．そのため，正しく動作しない原因（バグ）を究明し，取り除く（デバッグ）する必要がある．

多くのオペレーティングシステムではデバッガが用意されているが，最も基本的なデバッグ方法はprintfを用いる方法である． printfを用いることで

制御の流れの確認

変数の値の確認

をすることができる． printfデバッグは，プログラムがどのようなパスで実行され，その時変数がどのような値を持っているのかを出力させる．これによりプログラム実行の経過を把握することができるため，プログラム内容の把握にも役立つ．

上記のバブル整列法のプログラムに以下のsort関数を入れ，

26 void 27 sort(int data[], int count) 28 { 29 int i, j; 30 31 for (i = 0; i < count; i++) 32 for (j = i; j < count; j++) 33 if (data[j] > data[j + 1]) 34 swap_array(data, j, j + 1); 35 }

コンパイル実行すると，以下のおかしな結果が出力される．

% ./a.out 26 void 27 sort(int data[], int count) 28 { 29 int i, j; 30 31 for (i = 0; i < count; i++) { 32 printf("%d: ", i); 33 print_data(data, count); 34 35 for (j = i; j < count; j++) 36 if (data[j] > data[j + 1]) 37 swap_array(data, j, j + 1); 38 } 39 }

コンパイル実行すると，以下ような結果になる．

% ./a.out 26 void 27 sort(int data[], int count) 28 { 29 int i, j; 30 31 for (i = 0; i < count; i++) { 32 printf("%d: ", i); 33 print_data(data, count); 34 35 for (j = i; j < count; j++) { 36 printf("\t[%d]=%d > [%d]=%d", 37 j, data[j], j + 1, data[j + 1]); 38 39 if (data[j] > data[j + 1]) { 40 printf(" ... swap!!"); 41 42 swap_array(data, j, j + 1); 43 } 44 45 printf("\n"); 46 } 47 } 48 }

コンパイル実行すると，以下ような結果になり，要素数を超えて配列にアクセスしていたことがわかる．

% ./a.out 26 void 27 sort(int data[], int count) 28 { 29 int i, j; 30 int n = count - 1; 31 32 for (i = 0; i < n; i++) { 33 printf("%d: ", i); 34 print_data(data, count); 35 36 for (j = i; j < n; j++) { 37 printf("\t[%d]=%d > [%d]=%d", 38 j, data[j], j + 1, data[j + 1]); 39 40 if (data[j] > data[j + 1]) { 41 printf(" ... swap!!"); 42 43 swap_array(data, j, j + 1); 44 } 45 46 printf("\n"); 47 } 48 } 49 }

コンパイル実行すると，以下ような結果になる．配列要素の添字は配列の大きさの範囲内におさまっているが，整列されていない．

% ./a.out % ./a.out 26 void 27 sort(int data[], int count) 28 { 29 int i, j; 30 int n = count - 1; 31 32 for (i = 0; i < n; i++) { 33 printf("%d: ", i); 34 print_data(data, count); 35 36 for (j = 0; j < n - i; j++) { 37 // printf("\t[%d]=%d > [%d]=%d", 38 // j, data[j], j + 1, data[j + 1]); 39 40 if (data[j] > data[j + 1]) { 41 // printf(" ... swap!!"); 42 43 swap_array(data, j, j + 1); 44 } 45 46 // printf("\n"); 47 } 48 } 49 }

コンパイル実行すると，以下ような結果になり，正しく整列できるようになったことがわかる．

% ./a.out ポインタ（１）
システムプログラムで用いるライブラリ関数やシステムコールにはポインタが必須である．関数を呼び出し，まとまったデータをやり取りするためにはポインタを使う必要があるからである．

例えば下図のように，あるプログラムがライブラリ又はカーネルを呼び出し，データを読み込もうとしているとする．プログラムは，データを読み込むデータ領域を予め確保し，そこにデータを読み込みたい．そのデータを読み込ませたいデータ領域の先頭を，ライブラリ又はカーネルに知らせる方法がポインタである．ポインタの実態はアドレス（番地）である．ライブラリ又はカーネルはアドレスを受け取り，そこからデータを書き込みはじめる．

他に文字列操作にもポインタは不可欠であるため，ポインタをよく理解しておく必要がある．

& と * の関係

アドレス演算子 & をすでに宣言されている変数の前に付けることで，その変数の値を格納するために割り当てられた領域のアドレスが得られる．このアドレスのことをポインタ値という．

間接参照演算子 * は，ポインタ値が指す領域の値を取り出す．領域に付けられた名前（変数名）ではなく，ポインタ値を用いて参照するので間接参照という．

下図ではint型の変数 i, j と，intへのポインタ型変数 p, q が宣言されている． i, j, p, q はそれぞれ別の変数であり，それぞれ別の領域が割り当てられる．

i は1000番地に置かれているものとすると，&i の値は 1000 となり，p に &i を代入すると 1000 が入る． i には 5 が代入されたとすると，*p の値は 5 になる．図中にはないが，p に &i が代入された状態のまま，*p に 50 を代入すると i の値は 50 になる．

ポインタを使うとできること

ポインタ値はある変数（領域）を参照する値である．値であるので，別の関数にポインタ値を渡すことができる．渡された方の関数は，ポインタ値により参照される変数の値を変更することができる．

下図は，関数 func のローカル変数 i を引数として別の関数 func2 を呼び出している． func2 では引数 i に 5 を代入しているが，func の i と func2 の i は別の変数であるので，func2 で代入した値は func の i には反映されない．従って，func2 呼び出し後に i の値を出力した結果は 0 のままである．

一方，下図では，関数 func のローカル変数 i のポインタ値を引数として別の関数 func2 を呼び出している． func2 では引数に間接参照演算子を付けた *i に 5 を代入している．この場合，func2 における *i は func の i を参照しているため，func2 で代入した値は func の i には反映される．従って，func2 呼び出し後に i の値を出力した結果は 5 になる．

ポインタを使う時に気をつけること

関数間でのポインタ値の受け渡し

関数間でポインタ値を受け渡しをする時には，ポインタ値が参照する変数がどこで宣言（領域確保）されているのか，注意する必要がある．大域変数やヒープ領域（mallocして確保した領域）は，プログラム中どこでも有効であるので問題はない．しかし，ローカル変数については注意が必要である．ローカル変数は，それを宣言した関数から return する前までの間だけ有効である．そのため，ローカル変数へのポインタ値を戻り値にしてはいけない．

以下のプログラムでは，main関数は関数 badfunc を呼び出しポインタ値を戻り値として受け取っている．ポインタ値を戻り値として受け取ること自体には全く問題はない．しかし，badfunc で返しているポインタ値の参照先が badfunc のローカル変数なのが大きな問題である．

1 #include <stdio.h> 2 3 int * 4 badfunc() 5 { 6 int i = 5; 7 8 return &i; 9 } 10 11 main() 12 { 13 int *i = badfunc(); 14 15 printf("1: %d\n", *i); 16 printf("2: %d\n", *i); 17 }

コンパイル実行すると，以下ような結果になる． badfunc を呼び出した後の関数呼び出し（以下のプログラムではprintfの呼び出し）により，badfunc のローカル変数の値は破壊されてしまっていることがわかる．コンパイラは，ローカル変数を戻り値としていることに warning を出している．コンパイラの warning を無視すべきではなく，その原因を究明し，コンパイル時に warning が出ないように修正すべきである．

% cc pointer-4.c ポインタ（２）で詳述．）しかし，ヒープ領域に確保する malloc（およびその派生関数であるcalloc, valloc）を使用する場合は，確保した領域が不要になった時に必ず free する必要がある． free せずに確保した領域のポインタ値を失ってしまうと，メモリリークという問題が発生する．

4 int * 5 goodfunc() 6 { 7 int *i = malloc(sizeof(int)); 8 9 *i = 5; 10 11 return i; 12 }

その他よくある間違い

ポインタ型変数を複数宣言するときには，それぞれの変数名の前に * を付ける．

1 func() 2 { 3 int *p, *q;

また，ポインタ変数に値（ポインタ値）を入れずに参照してはいけない．

1 func() 2 { 3 int *p; 4 5 *p = 5;

間違ったアドレスに書いてしまう又は書こうとするといろいろ問題が発生する．書き込めないアドレスに書こうとすると，セグメンテーションフォルトが発生し，プログラムは異常終了する．この場合は，異常終了により間違ったことが起きていることがすぐにわかるので，まだましな場合である．

書き込めるデータ領域だが，意図とは違う間違ったアドレスに書き込まれてしまうと，書き込み自体は成功してしまい，プログラムの実行が進んでから問題が起こる．すると，どうしてここに変なデータが書き込まれているのかと悩むことになる．

これをうまく使ったのがバッファオーバフローである．外部からスタック上に確保されているバッファよりも多くのデータ（プログラム）を読み込ませることにより，プログラムの実行を乗っ取ってしまう．バッファオーバフローについては第3回目の講義でもう少し詳しく説明する．

ポインタは非常に便利でありシステムプログラミングには欠かせないが，細心の注意をもって使用しないといけない．

文字，文字列のデータ表現

文字コード

コンピュータは2進数しか扱えないので，文字も数として表す必要がある．ある数値がどの文字にあたるかの対応の決まりを文字コードと呼ぶ．文字コードには唯一絶対というようなものはなく，場合によって使い分けられている．欧米では必要となる文字数が少ないため，文字コードも標準的なものがあるが，それ以外（特に日本）は大変複雑になってしまっている．

ASCII（アメリカで作られたアルファベット，数字，記号を表す文字コード）
Latin-1（ISO 8859-1規格により規定されている西欧諸国用文字コード）
ISO-2022-JP（JIS規格によって規定されている日本語文字コード）
シフトJISコード（Microsoftによって作られた日本語文字コード，SJISコードとも呼ばれる）
EUC-JP（AT&Tによって作られた各国語用コードのうち日本語の文字コード）
UTF-8（国際的に統一的に使えるようにと策定された文字コードフォーマット）

ASCIIコード

UNIXで標準的に使われてきたのがASCII（アスキー）コードである． ASCII は American Standard Code for Information Interchange の略であり，その名のとおりアメリカで使うために作られたものである． 7ビットで表現され，ローマ字，数字，記号，制御コードからなる．数値との対応は以下の通り：

上位3ビット→
↓下位4ビット 0 1 2 3 4 5 6 7

0 NUL DLE SP 0 @ P ` p

1 SOH DC1 ! 1 A Q a q

2 STX DC2 " 2 B R b r

3 ETX DC3 # 3 C S c s

4 EOT DC4 $ 4 D T d t

5 ENQ NAC % 5 E U e u

6 ACK SYN & 6 F V f v

7 BEL ETB ' 7 G W g w

8 BS CAN ( 8 H X h x

9 HT EM ) 9 I Y i y

A LF/NL SUB * : J Z j z

B VT ESC + ; K [ k {

C FF FS , < L ＼ l |

D CR GS - = M ] m }

E SO RS . > N ^ n ~

F SI US / ? O _ o DEL

制御符号の意味
EUC-JP

EUC は Extended UNIX Code の略であるように，EUC-JPはUNIXでは広く使われている日本語文字コードである．基本的には漢字1文字を2バイトで表すが，3バイトで表される補助漢字もある．

1バイト目：B0
下位4ビット→
↓上位4ビット 0 1 2 3 4 5 6 7 8 9 A B C D E F

A0 亜唖娃阿哀愛挨姶逢葵茜穐悪握渥

B0 旭葦芦鯵梓圧斡扱宛姐虻飴絢綾鮎或

C0 粟袷安庵按暗案闇鞍杏以伊位依偉囲

D0 夷委威尉惟意慰易椅為畏異移維緯胃

E0 萎衣謂違遺医井亥域育郁磯一壱溢逸

F0 稲茨芋鰯允印咽員因姻引飲淫胤蔭

上記の表の最初にある「亜」という漢字は1バイト目が B0，2バイト目が A1となる． EUC-JPでは，漢字は1バイト目，2バイト目共に8ビット目が立っている（1である）．そのため，ある任意の1バイトを見ただけで漢字であるかどうか判別できるという利点がある．しかし，それが漢字の1バイト目なのか2バイト目なのかはわからない．

バックスラッシュ「＼」と円マーク「\」

以下のバックスラッシュ「＼」についての記述は，Mac OS X にはあてはまりません． Mac OS X を使っている場合は，半角バックスラッシュ「\」は正しく表示されます．

日本語の文字コードでは，ASCIIコードに相当するアルファベット及び記号部分のバックスラッシュ「＼」（このバックスラッシュは全角の文字）が円マーク「\」にあてられてしまっている．そのため，文字コード（数値）としては同じ値であるが，目に見える文字としては違うというややこしいことになっている．例えば以下の簡単なプログラムのように，Cプログラム中に円マーク「\」が出てきたら，バックスラッシュと同じとみなしましょう．

#include <stdio.h> main() { printf("hello world!\n"); }

さらに詳しい解説

新城先生が書かれた解説を参照してください．
http://www.hlla.is.tsukuba.ac.jp/~yas/classes/ipe/nitiniti2-enshu-1996/1996-11-18/kanji-code.html

C言語における文字と文字列

日本語文字コードの取り扱いは煩雑で難しい．そのためシステムプログラムでは，ASCIIコードだけを取り扱うことにする．

文字はシングルクォーテーション「'」で囲まれており，文字列はダブルクォーテーション「"」で囲まれている． 'A' は文字であり，"A" は文字列である．見た目の差はわずかかもしれないが，両者は似て非なるものである．

文字

シングルクォーテーション「'」で囲まれた文字は char 型の定数であり，値はASCII コードにおける文字に対応した値になる．下の (1) と (2) は同じ値を変数 c に代入しており，プログラムの読みやすさ以外，意味的にも何ら変わりはない．

char c; c = 'A'; /* (1) */ c = 0x41; /* (2) */

文字は数値であるため，演算や比較の対象になる．下のプログラムでは，char 型の変数 c を ++ でインクリメント（7行目）したり，<= で文字定数と比較（6行目）している．

1 #include <stdio.h> 2 3 main() 4 { 5 char c = 'a'; 6 while (c <= 'z') 7 putchar(c++); 8 putchar('\n'); 9 }

文字列

文字は1つの数値であるため，文字の並びである文字列は配列として表される．文字列の終端を表すために，文字列の最後には 0 が置かれる．文字列には終端の 0 が含まれるため，文字列の長さは表示される文字数よりも 1 大きくなる．下の図は "A" および "Hello" という文字列がどのように格納されるか図示したものである．

配列の0番目の要素から順番に文字が入れられ，最後に文字列の終端を表す 0 が入っている．終端が \0 と書いてあるのは，値が 0 の文字は '\0' と表記するからである．

以下のプログラムは，文字を配列に格納したものが文字列になることを確かめるものである．

1 #include <stdio.h> 2 3 char s[] = {'H', 'e', 'l', 'l', 'o', 0}; 4 5 main() 6 { 7 int i = 0; 8 9 printf("%s\n", s); 10 11 while (s[i]) { 12 printf("[%d] = %c\n", i, s[i]); 13 i++; 14 } 15 }

3行目では，文字型配列 s に順番に Hello と入るように初期化している． 9行目の printf では変換文字に %s を用いて，文字列を出力している．これで文字型配列 s が文字列となっていることがわかる． 11～14行目では，文字型配列 s の各要素の文字を出力している． 12行目の printf では変換文字に %c を用いて，文字を出力している．これをコンパイル実行すると以下のような結果が得られる．

% ./a.out 3 char s[] = "Hello";

しかしながら，以下のプログラムのように書くと，意味が異なってくる． 3行目では，char ポインタ型の変数 ps に文字列が代入されて初期化されている．上記の文字型配列 s は，初期値となる文字列と終端文字 '\0' がぴったり入る大きさの配列となる．配列の中の個々の文字は変更できるが，s 自体は同じメモリ位置を指し変更できない．一方，char ポインタ型の変数 ps は文字列定数を指すように初期化されたポインタである．従って，プログラム中でこのポインタを他の場所を指すように変更することができる．逆に，文字列定数の内容の変更の結果は（言語仕様上は）不定である． Mac OS X ではバスエラー，Linuxではセグメンテーションフォルトが発生し，プログラムは異常終了してしまうが，できてしまうOSもある．

1 #include <stdio.h> 2 3 char *ps = "Hello"; 4 5 main() 6 { 7 int i = 0; 8 9 printf("%s\n", ps); 10 11 while (*ps) { 12 printf("[%d] = %c\n", i, *ps); 13 i++; 14 ps++; 15 } 16 }

上記プログラム14行目ではポインタをインクリメントすることにより，次の要素を指すようにしている．

上記プログラム11～15行目の while 文は以下のように書くこともできる．いかにもCらしいプログラムになるが，while 中に繰り返す文を追加する場合に，間違いが入りやすいという欠点もある（このように書くべきではないという意味ではない）．

11 while (*ps) 12 printf("[%d] = %c\n", i++, *ps++);

標準入出力

C言語では標準入出力を用いることで，基本的な入出力を行うことができる．通常，標準入力はキーボードであり，標準出力は端末画面（ウィンドウ）である． Cプログラムを実行したプロセスは，キーボードからの入力を標準入力から受け取ることができ，また標準出力への出力は端末画面（ウィンドウ）に表示される． UNIXのシェルは，標準入出力をリダイレクションやパイプによってファイルや他のプログラムに切り替えることができる．この機能により，ファイルアクセスなしに様々な入出力が可能になっている．

標準入力から，文字，行，書式付の入力を行うライブラリ関数として以下のものがある．

int getchar(void); char * gets(char *s); int scanf(const char *format, ...);

また標準出力に対し，文字，行，書式付の出力を行うライブラリ関数として以下のものがある．

int putchar(int c); int puts(const char *s); int printf(const char *format, ...);

これらのうち gets は，後の講義で述べるバッファオーバーフローの原因となる脆弱性を持つため，使用するべきではない． gets の代わりには，入力バッファの大きさを指定できる fgets を使用すべきである．
scanf も，%s のような書式指定を用いると，バッファオーバーフローに対する脆弱性を持つ．

fgetsに対応する文字，行，書式付きの入出力を行うライブラリ関数には以下のものがある．

int fgetc(FILE *stream); char * fgets(char *s, int size, FILE *stream); int fscanf(FILE *stream, const char *format, ...); int fputc(int c, FILE *stream); int fputs(const char *s, FILE *stream); int fprintf(FILE *stream, const char *format, ...);

stream に stdin と書くと標準入力になり，stdout と書くと標準出力になる．つまり fgetc, fgets では stdin，fputc, fputs, fprintf では stdout を指定する．

標準入出力には，標準出力である stdout の他に，標準エラー出力と呼ばれるもう一つ出力の口がある．標準エラー出力は stream に stderr と書くことで指定できる．標準エラー出力は，エラーメッセージや警告のメッセージなど例外的な処理に関するメッセージを出力するために使用される．

以下は getchar により標準入力から1文字読み込み，putchar により標準出力へ1文字書き出すプログラムである．

1 #include <stdio.h> 2 3 main() 4 { 5 int c; 6 7 while ((c = getchar()) != EOF) 8 putchar(c); 9 }

これをコンパイル実行すると以下のような結果が得られる．

% ./a.out プログラムのようになる．結果は，getchar, putchar を使用した場合と，全く同じになる．

1 #include <stdio.h> 2 3 main() 4 { 5 int c; 6 7 while ((c = fgetc(stdin)) != EOF) 8 fputc(c, stdout); 9 }

以下は fgets により標準入力から1行読み込み，puts により標準出力へ1行書き出すプログラムである．

1 #include <stdio.h> 2 3 #define LINE_LEN 80 4 5 main() 6 { 7 char line_buf[LINE_LEN]; 8 9 while (fgets(line_buf, LINE_LEN, stdin) != NULL) 10 puts(line_buf); 11 }

これをコンパイル実行すると以下のような結果が得られる．

% ./a.out プログラムように puts の代わりに fputs を使用すると，fputs は単にバッファ内の文字列を書き出すだけの仕様のため，上記の問題はなくなる．

1 #include <stdio.h> 2 3 #define LINE_LEN 5 4 5 main() 6 { 7 char line_buf[LINE_LEN]; 8 9 while (fgets(line_buf, LINE_LEN, stdin) != NULL) 10 fputs(line_buf, stdout); 11 }

文字，文字列操作ライブラリ

文字操作

文字操作のライブラリ関数には，以下の大文字又は小文字へ変換する関数と，

int toupper (int c); /* 大文字へ変換 */ int tolower (int c); /* 小文字へ変換 */

以下の文字の種類を判別する関数がある．

int isalnum (int c); /* 英字又は数字？ */ int isalpha (int c); /* アルファベット？ */ int isascii (int c); /* アスキー文字？ */ int isblank (int c); /* 空白文字（スペース又はタブ）？ */ int iscntrl (int c); /* 制御文字？ */ int isdigit (int c); /* 数字？ */ int isgraph (int c); /* 表示可能？（スペースは含まれない） */ int islower (int c); /* 小文字？ */ int isprint (int c); /* 表示可能？（スペースを含む） */ int ispunct (int c); /* 表示可能？（スペースと英数字を除く） */ int isspace (int c); /* 空白文字？（スペース，タブ，改行文字など） */ int isupper (int c); /* 大文字？ */ int isxdigit (int c); /* 16進数での数字？（0～9, a～f, A～F） */

以下のプログラムは小文字を大文字へ，大文字は小文字へ変換する．

1 #include <stdio.h> 2 #include <ctype.h> 3 4 main() 5 { 6 int c; 7 8 while ((c = getchar()) != EOF) { 9 if (islower(c)) 10 c = toupper(c); 11 else if (isupper(c)) 12 c = tolower(c); 13 putchar(c); 14 } 15 }

これをコンパイル実行すると以下のような結果が得られる．

% ./a.out #include <string.h>

とでている．同じことは，個別の関数のマニュアルページにもでている．これは，これらの関数を使用する時には string.h をインクルードしなさいという意味である．指定されたヘッダファイルをインクルードしないと，エラーによりコンパイルできない場合，又は関数が正常に動作しない場合がある．

文字列の長さ

size_t strlen(const char *s);

strlen は文字列の長さを戻り値として返す．文字列の終端文字 0 は，文字列の長さには含まれない．そのため，strlen("abc") は 3 を返す．

以下のプログラムは， getchar, putchar を用いた小文字を大文字へ，大文字は小文字へ変換するプログラムを，fgets, fputs を用いて行ごとの入出力にすると，文字列に対し，大文字，小文字の変換をするようになる．文字列に含まれる文字を先頭から見ていくためには，文字列の長さが必要になるため，strlen を使用する．

1 #include <stdio.h> 2 #include <ctype.h> 3 #include <string.h> 4 5 #define LINE_LEN 80 6 7 main() 8 { 9 int i, len; 10 char line_buf[LINE_LEN]; 11 char *p; 12 13 while (fgets(line_buf, LINE_LEN, stdin) != NULL) { 14 len = strlen(line_buf); 15 p = line_buf; 16 for (i = 0; i < len; i++, p++) { 17 if (islower(*p)) 18 *p = toupper(*p); 19 else if (isupper(*p)) 20 *p = tolower(*p); 21 } 22 fputs(line_buf, stdout); 23 } 24 }

実際は，終端文字であるかどうか検査しながら文字の変換をした方がプログラムとしては速い．

文字列の比較

int strcmp(const char *s1, const char *s2); int strncmp(const char *s1, const char *s2, size_t n); int strcasecmp(const char *s1, const char *s2); int strncasecmp(const char *s1, const char *s2, size_t n);

これらは2つの文字列 s1 と s2 を比較し，

条件　戻り値

s1 < s2 　0より小さい数

s1 == s2 　0

s1 > s2 　0より大きい数

という結果を返す．文字の大小関係はASCIIコードでの大小である．

strncmp, strncasecmp は s1 の先頭 n 文字についてのみ，比較を行う．

strcasecmp, strncasecmp は大文字，小文字を区別せずに（例えば A と a は同じとみなして）比較する．

文字や文字列の検索

char * strchr(const char *s, int c); char * strrchr(const char *s, int c); char * index(const char *s, int c); char * rindex(const char *s, int c); char * strstr(const char *haystack, const char *needle);

strchr, index は，文字列 s を先頭から探して最初に c の文字が現れたところへのポインタを返す．

strrchr, rindex は，文字列 s を最後尾から探して最初に c の文字が現れたところへのポインタを返す．

strstr は，文字列 haystack を先頭から探して，最初に needle が見つかったところへのポインタを返す．

どれも，見つからなかった場合は NULL が戻り値になる．

以下のプログラムは，ファイルへのパスの構成要素を切り出して出力する．

1 #include <stdio.h> 2 #include <string.h> 3 #include <sys/param.h> 4 5 main() 6 { 7 int i; 8 char line_buf[MAXPATHLEN]; 9 char *p, *np; 10 11 while (fgets(line_buf, MAXPATHLEN, stdin) != NULL) { 12 i = 0; 13 p = line_buf; 14 while ((np = index(p, '/')) != NULL) { 15 *np = '\0'; 16 printf("%d: %s\n", i++, p); 17 p = np + 1; 18 } 19 printf("%d: %s\n", i, p); 20 } 21 }

8行目の MAXPATHLEN は，システムで定義されているパス名の最大長である． MAXPATHLEN は sys/param.h で定義されている．これをコンパイル実行すると以下のような結果が得られる．

% ./a.out $[�眈鹿眈��錫鞘蜥渥粡魃�蜥億粡魍�蛹綣蜊�齟秉∵�頌痕�蒹銹蛛鈑矚�闕�蒡鳫�㊨逅鳫�筬轣齡纈�鈔纔�蒡髄助艸礇柿ゲ謄夏裴螫鞨�罧艷蔕蓖隨鉋�礇夏�趾竇皀夏屋臼ゲ謎��夏鞨煇矚燗�鱠ゲ謎鞳鴪甅纈艾縺��瘡��眈鹿眈��虻�粡魄��浦�粡魃��穏�粡魏��該�粡魍��敢�肅跂��守辯�齟秉∵�頌痕�蒹銹蛛鈑矚�闕�蒡鳫�㊨逅鳫�筬轣齡纈�鈔纔�蒡髄助艸礇柿ゲ謄夏裴螫鞨�罧艷蔕蓖隨鉋�礇夏�趾竇皀夏屋臼ゲ謎��夏鞨煇矚燗�鱠ゲ鳶艱丨儁竅槇�瘡��鱈紬⊂鹿眈��鹿頏緇��腫��このプログラムは1つの文字列中に含まれる '/' をindexを用いて検索し，見つかったら，その文字を '\0' に置き換える．文字列とは終端文字 '\0' までの文字配列であるため，'/' を '\0' に置き換えることで，1つの文字列を複数の文字列に分割している． </p> <p> 下図では配列の [4] に格納されている '/' を '\0' に置き換えることにより，[0] から指定される文字列は$

このように文字列をコピーすることなく，文字列の一部を切り出すことができる．

文字列のコピー，連結（１）

size_t strlcpy(char *dst, const char *src, size_t size); size_t strlcat(char *dst, const char *src, size_t size);

strlcpy は src の文字列を dst にコピーする． strlcat は src の文字列を dst の文字列の後ろに（dst の終端文字のところから）コピーする． size はコピー先 dst のサイズを表す． strlcpy の場合 dst はコピー先のバッファのサイズであるが， strlcat の場合 dst はすでに入っている文字列の長さも含んだバッファのサイズである．

strlcpy, strlcat は，src の文字列を全てコピーできたかどうかに関わらず，dst の文字列に終端の 0 を付ける．従って，strlcpy は最大 size - 1 文字コピーし，strlcat は最大 size - strlen(dst) - 1 文字コピーする．

strlcpy, strlcat は，それらが作成しようとした文字列の長さを戻り値として返す．即ち，strlcpy の場合，それは src の長さ（strlen(src)）であり，strlcatの場合 dst と src の長さの和である．

以下は strlcpy, strlcat を使用して文字列のコピーを行う例である．コピー先のバッファの大きさは sizeof 演算子により取得している．（sizeof(配列)の値は配列のサイズであるが，sizeof(ポインタ)はポインタの大きさになってしまうため，バッファの大きさを得るためには使えないことに注意．）

1 #include <stdio.h> 2 #include <string.h> 3 4 main() 5 { 6 char buf5[5]; 7 char buf20[20]; 8 char *d = "01234567890"; 9 char *s = "abcdefghijklmnopqrstuvwxyz"; 10 int i; 11 12 i = strlcpy(buf5, d, sizeof(buf5)); 13 printf("cpy 5: src(%s) len(%d) dst(%s) len(%d)\n", 14 d, i, buf5, strlen(buf5)); 15 16 i = strlcpy(buf20, d, sizeof(buf20)); 17 printf("cpy 20: src(%s) len(%d) dst(%s) len(%d)\n", 18 d, i, buf20, strlen(buf20)); 19 20 i = strlcat(buf20, s, sizeof(buf20)); 21 printf("cat 20: dst(%s) len(%d)\n", buf20, strlen(buf20)); 22 }

これをコンパイル実行すると以下のような結果が得られる．

% ./a.out char * strncpy(char *dst, const char *src, size_t n); char * strncat(char *dst, const char *src, size_t n); char * strcpy(char *dst, const char *src); char * strcat(char *dst, const char *src);

strncpy は src の文字列を終端文字 0 も含めて dst に最大 n 文字コピーする． strncat は，src の文字列を dst の文字列の後に（dst の終端文字のところから）終端文字 0 も含めて最大 n 文字コピーする． strncpy，strncat は，コピーした n 文字に終端文字 0 が含まれるかどうかはチェックしない．しかし，src の文字列が n 文字よりも短かった場合，dst の残りの部分は 0 で埋める．

strcpy は src の文字列を終端文字 0 も含めて dst にコピーする． strcat は src の文字列を dst の文字列の後に（dst の終端文字のところから）コピーし，最後に終端文字 0 を追加する．

strncpy, strncat, strcpy, strcat の戻り値は単に dst である． strlcpy, strlcat と異なり，全ての src の文字列がコピーできたのかどうかは，戻り値からは不明である．

strcat, strcpy は，コピー先の大きさを指定できないため，バッファオーバーフローに対する脆弱性を持つため，使用すべきではない．

文字列のコピー，連結（２）

printf の仲間の関数である snprintf を用いることでも文字列のコピー，連結を行うことができる．

int snprintf(char *dst, size_t size, const char *format, ...);

snprintf は printf とほぼ同じように使用できるが，結果は dst に文字列として格納される． size はバッファ dst のサイズである．終端文字 0 が末尾に追加されるため，最大 size - 1 文字が dst に出力される．

snprintf 戻り値は，もし出力バッファが無限大であった場合に何文字出力されたか（終端文字 0 は含まない）である．即ち，戻り値と size を比較することにより，十分な大きさのバッファを提供しているかどうかがわかる．

上記の strlcpy, strlcat を使用したプログラムを snprintf を用いて書き直すと以下のようになる． 20行目の文字列の結合が，もとになる文字列からコピーしているところだけが異なる．

1 #include <stdio.h> 2 #include <string.h> 3 4 main() 5 { 6 char buf5[5]; 7 char buf20[20]; 8 char *d = "01234567890"; 9 char *s = "abcdefghijklmnopqrstuvwxyz"; 10 int i; 11 12 i = snprintf(buf5, sizeof(buf5), "%s", d); 13 printf("cpy 5: src(%s) len(%d) dst(%s) len(%d)\n", 14 d, i, buf5, strlen(buf5)); 15 16 i = snprintf(buf20, sizeof(buf20), "%s", d); 17 printf("cpy 20: src(%s) len(%d) dst(%s) len(%d)\n", 18 d, i, buf20, strlen(buf20)); 19 20 i = snprintf(buf20, sizeof(buf20), "%s%s", d, s); 21 printf("cat 20: dst(%s) len(%d)\n", buf20, strlen(buf20)); 22 }

これをコンパイル実行すると以下のように同じ結果が得られる．

% ./a.out char * strdup(const char *s); /* 文字列の複製 */ char * strfry(char *string); /* 文字列のランダム化 */ char * strsep(char **stringp, const char *delim); /* トークンの切り出し */ char * strtok(char *s, const char *delim); /* トークンへの分解 */ size_t strcspn(const char *s, const char *reject); /* 文字セットに含まれない文字数 */ char * strpbrk(const char *s, const char *accept); /* 文字セットに含まれる文字の検索 */ size_t strspn(const char *s, const char *accept); /* 文字セットに含まれる文字数 */ int strcoll(const char *s1, const char *s2); /* ロケールに基づく文字列比較 */ size_t strxfrm(char *dst, const char *src, size_t n); /* ロケールに基づいた文字列変換 */

文字列と数値の変換

getcharやfgetsで数字を入力として受け取っても，それは文字または文字列としての入力である． '1' は文字定数であり，その値は 0x31 であり 1 ではない． "123" という文字列は 0x31, 0x32, 0x33 という文字の並びであり，123 という数値とは異なる．表示通りの数値の値で計算するためには，そのように変換する必要がある．また 123 という数値はそのままでは表示することができず，表示するためには '1', '2', '3' という文字の並び，又は "123" という文字列に変換する必要がある．

以下は文字列を数値に変換してくれるライブラリ関数である． sscanf は scanf と同じバッファオーバーフローに対する脆弱性を持つので，使用には注意が必要である．

long int strtol(const char *nptr, char **endptr, int base); unsigned long int strtoul(const char *nptr, char **endptr, int base); double strtod(const char *nptr, char **endptr); long atol(const char *nptr); int atoi(const char *nptr); double atof(const char *nptr); int sscanf(const char *str, const char *format, ...);

数値を文字列に変換するライブラリ関数として sprintf, snprintf が使用できる． sprintf は，非常に注意深く使用しなければ，バッファオーバーフローを起こす危険がある． snprintf は書き出す最大文字数を指定できるので，sprintf に代わって常に snprintf を使用すべきである．しかし snprintf も snprintf は sprintf を呼び出しているだけのことがあり，安全ではないことがあるので注意が必要である．

int sprintf(char *str, const char *format, ...); int snprintf(char *str, size_t size, const char *format, ...);

ポインタ（２）

動的メモリ確保
malloc により，実行時動的にメモリ確保した場合，その領域にアクセスするには，ポインタを使用する必要がある．動的メモリ確保は，実行してみないと確保すべきメモリの量がわからない場合，一時的に大きなサイズのメモリを確保する必要がある場合などに便利な機能である．しかし，注意すべき点も多く，間違って使用すると発見しにくいバグの原因となってしまう．
mallocとfree

malloc はヒープ領域に動的に初期化されていないメモリを確保し，そこへのポインタ値を返す． calloc は0に初期化されたメモリを確保し，そこへのポインタ値を返す． free は malloc により確保されたメモリを解放する．

#include <stdlib.h> void *malloc(size_t size); void *calloc(size_t count, size_t size); void free(void *ptr);

malloc により確保されたメモリの内容は不定であり，0 に初期化されているわけではない．一方，calloc により確保されたメモリの内容は 0 である．また，free は解放するメモリの内容を消去しない．

malloc で確保されたメモリ領域は，そのポインタ値を，関数の引数，戻り値，大域変数などから得ることが出来れば，プログラム中のどこでも使用できる．大域変数のための領域は，コンパイル時にその大きさが決まり，プログラム実行開始時に確保されるが， malloc で確保されるメモリ領域は，実行中に malloc が呼び出された時点で，引数で指定された大きさの領域が確保される． malloc への引数には，実行中の状況から計算により求めた値を指定することで，必要なだけのメモリを確保できる．条件により malloc が呼ばれなければ，そのメモリ領域は確保されない．

strlcpy, strlcat を使用して文字列のコピーを行うプログラムを，ローカル変数で配列を宣言するのではなく，malloc を用いて書き直すと以下のようになる．配列名だけを指定する場合と，ポインタ変数はほぼ同じように使用できるため，非常に似通ったプログラムになるが，以下の注意点，相違点がある．

malloc は領域を確保できない場合にNULLを返すため，そのチェックを忘れないようにする（14~17，20~23行目）．

すぐにプログラムが終了してしまうため実際上の意味はないが，36, 37行目で確保した領域を free により開放している．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 main() 6 { 7 char *buf5; 8 char *buf20; 9 char *d = "01234567890"; 10 char *s = "abcdefghijklmnopqrstuvwxyz"; 11 int i; 12 13 buf5 = malloc(5); 14 if (buf5 == NULL) { 15 perror("malloc"); 16 exit(1); 17 } 18 19 buf20 = malloc(20); 20 if (buf20 == NULL) { 21 perror("malloc"); 22 exit(1); 23 } 24 25 i = strlcpy(buf5, d, 5); 26 printf("cpy 5: src(%s) len(%d) dst(%s) len(%d)\n", 27 d, i, buf5, strlen(buf5)); 28 29 i = strlcpy(buf20, d, 20); 30 printf("cpy 20: src(%s) len(%d) dst(%s) len(%d)\n", 31 d, i, buf20, strlen(buf20)); 32 33 i = strlcat(buf20, s, 20); 34 printf("cat 20: dst(%s) len(%d)\n", buf20, strlen(buf20)); 35 36 free(buf5); 37 free(buf20); 38 }

配列は sizeof 演算子でその配列の大きさを取得できるが，ポインタ型変数に sizeof 演算子を用いた場合，その変数の大きさになってしまうことに注意する．従って，strlcpy, strlcat に渡すコピー先のバッファの大きさは malloc で指定した大きさを書く必要がある（25，29行目）．以下のようにポインタ型変数に sizeof 演算子を使用しても，確保しようとする（または確保した）領域の大きさにはならない．

13 buf5 = malloc(sizeof(buf5));

25 i = strlcpy(buf5, d, (buf5));

使用上の注意

malloc で確保したメモリは，確保したサイズだけ使用する． C言語では配列のインデックス（添字）が宣言された配列のサイズの範囲に収まっているかチェックしないのと同じように，malloc で確保したメモリが確保された範囲内で使用されているかどうかのチェックもしない．確保したサイズを超えてアクセスした場合，確保したサイズや実行時の状態により，セグメンテーションフォルトが起きることもあり得るし，アクセスできてしまうこともある．

以下は，上記のプログラムのbuf20をbuf5に置き換えて，確保したサイズを超えてアクセスした例である． 25, 29行目で，buf20を用いるべきところをbuf5に書き込んでおり，確保したサイズ以上に書き込んでいる． buf20の方は，23行目で bzero により内容を0に初期化し，buf5に確保したサイズ以上に書き込んだ結果どうなるか，32行目で出力してチェックしている．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 main() 6 { 7 char *buf5, *buf20; 8 char *d = "01234567890"; 9 char *s = "abcdefghijklmnopqrstuvwxyz"; 10 int i; 11 12 buf5 = malloc(5); 13 if (buf5 == NULL) { 14 perror("malloc"); 15 exit(1); 16 } 17 18 buf20 = malloc(20); 19 if (buf5 == NULL) { 20 perror("malloc"); 21 exit(1); 22 } 23 bzero(buf20, 20); 24 25 i = strlcpy(buf5, d, 20); 26 printf("cpy 20: src(%s) len(%d) dst(%s) len(%d)\n", 27 d, i, buf5, strlen(buf5)); 28 29 i = strlcat(buf5, s, 20); 30 printf("cat 20: dst(%s) len(%d)\n", buf5, strlen(buf5)); 31 32 printf("buf 20: dst(%s) len(%d)\n", buf20, strlen(buf20)); 33 34 free(buf5); 35 free(buf20); 36 }

これをコンパイル実行すると，特に実行時エラーは起こらない． 32行目でbuf20の内容を表示しているが，そこに確保したサイズを超えて書き込んだデータの一部が表示されており，buf20を破壊していることがわかる．

% ./a.out 1 buf5 = malloc(5); 2 free(buf5); 3 buf5 = NULL; 4 i = strlcpy(buf5, d, 5);

しかし，以下の例のように，別の関数 func_to_free で free が呼ばれ解放されてしまうような場合，func_to_free で free 後に上記のようにNULLを代入していても，呼び出しもとではそれは無意味なため注意が必要である．

1 buf5 = malloc(5); 2 func_to_free(buf5); // free(buf5); 3 i = strlcpy(buf5, d, 5);

メモリリーク

メモリリークとは，確保したメモリの解放を忘れ，使用しておらず使用する予定もないのに，確保したままになっている状態を指す．メモリリークが繰り返し起きた場合，大量にメモリが浪費された状態になる．最終的には，メモリ確保ができなくなる．メモリリークも，上記の問題と同じく，プログラムは一見正常に動いているように見えてしまう．しかし，長期間動作するプログラムで，月単位，年単位で問題が蓄積された結果起こることもあり，非常に発見が難しいバグである．そのため，常に気をつけてプログラミングをする必要がある．

以下は，非常に単純なメモリリークを起こすプログラムの例である． 12行目で確保した領域へのポインタをbufに入れ，18~20行目で使用している．この領域を開放せずに，22行目で同じ変数に別に確保した領域へのポインタを入れてしまっている．こうすると，12行目で確保した領域へのポインタが失われてしまい，解放することができなくなってしまう．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 main() 6 { 7 char *buf; 8 char *d = "01234567890"; 9 char *s = "abcdefghijklmnopqrstuvwxyz"; 10 int i; 11 12 buf = malloc(5); 13 if (buf == NULL) { 14 perror("malloc"); 15 exit(1); 16 } 17 18 i = strlcpy(buf, d, 5); 19 printf("cpy 5: src(%s) len(%d) dst(%s) len(%d)\n", 20 d, i, buf, strlen(buf)); 21 22 buf = malloc(20); 23 if (buf == NULL) { 24 perror("malloc"); 25 exit(1); 26 } 27 28 i = strlcpy(buf, d, 20); 29 printf("cpy 20: src(%s) len(%d) dst(%s) len(%d)\n", 30 d, i, buf, strlen(buf)); 31 32 free(buf); 33 }

実行結果は正しく，短時間の実行では問題が発生しないことが，メモリリークの発見を難しくしている．

ファイルアクセス

ファイルアクセスをする方法には，システムコールを用いる方法と，ライブラリ関数を用いる方法がある．どちらにせよ手順は同じで，アクセスしたいファイルを開き (open) ，読み書き (read, write) を行い，最後に閉じる (close)．

ライブラリを用いたファイルとの入出力

ライブラリを用いてファイルアクセスを行うために，ファイルを開き，閉じるためには fopen, fclose を用いる．読み書きのためには，実は標準入出力で述べた関数のうち，先頭に f がついている関数が使用できる．引数で指定できる FILE *stream を，stdin, stdout の代わりに，fopen の戻り値として得られる値にすればよい．ファイルからの入出力に便利なように fread, fwrite という関数も用意されている（これらも標準入出力で用いることができる）．

FILE * fopen(const char *path, const char *mode); int fclose(FILE *stream); size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

FILE構造体

ファイルを開くために使用する fopen の戻り値の型は FILE * （FILE構造体へのポインタ）である． 1文字入力の fgetc は，読み込み先として引数に FILE * 型の変数を指定し，1文字出力の fputc は引数に文字の他に書き込み先として FILE * 型の変数を指定する．

つまり，ライブラリを用いてファイルアクセスを行うためには，FILE構造体へのポインタ（通称，ファイルポインタ）が，ファイルの代理人のようなものになる．

FILE構造体には，読み書きしているファイル，ファイルに対し許される操作（読み込み，書き込み，又は両方），現在ファイルのどの部分をアクセスしているのか，エラーは起きていないか，などの情報を持つ．ファイルポインタは，このデータ構造体へのポインタになっており，入出力にあたってファイルポインタを指定することで，読み書きを行うことができるようになっている．

ファイルのコピー

fgetc, fputc を用いて標準入力から読み込み，標準出力へ書き出すプログラムは，fopen, fclose を前後に入れることで，簡単にファイルのコピーを行うプログラムになる．

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 main() 5 { 6 int c; 7 FILE *src, *dst; 8 9 src = fopen("src", "r"); 10 if (src == NULL) { 11 perror("src"); 12 exit(1); 13 } 14 15 dst = fopen("dst", "w"); 16 if (dst == NULL) { 17 perror("dst"); 18 fclose(src); 19 exit(1); 20 } 21 22 while ((c = fgetc(src)) != EOF) 23 fputc(c, dst); 24 25 fclose(src); 26 fclose(dst); 27 }

2行目の stdlib.h は，12行目，19行目の exit の宣言を含む．

8行目の fopen では，読込元のファイルとして "src" ，オープン時のモードとして "r" を指定している．モードは，オープンされたファイルに対しこの後許される操作，及びオープン時のどこから読み書きが始まるかを決定する． "r" は，ファイルを読み込みのためにオープンすることを意味し，ファイルの先頭から読み込みが始まる．

14行目の fopen では，書き込み先のファイルとして "dst" ，オープン時のモードとして "w" を指定している． "w" は，書き込みのためにファイルをオープンすることを意味し，ファイルが存在していなかった場合は新たに作られ，存在していた場合はファイルの長さは 0 にされる．また，書き込みはファイルの先頭から始まる．

他にモードとして指定できる文字列には，r+, w+, a, a+ （つまり rwa の文字のいずれか，又はそれに + を付けたもの）がある． r+, w+, a+ はどれも読み書きのためにファイルをオープンすることを意味するが，ファイルが存在していなかった場合の動作，また読み書きがどこから始まるか，といった点が異なる．正確な意味は FOPEN(3) を参照（man fopen）．

また，モードを指定する文字列に b を含むプログラムを目にすることがあるが，互換性のために残されているだけで，POSIXでは意味がない．

9～12行目，15～19行目は fopen に失敗した時の処理である．どちらも基本的に同じで，perror によりエラーメッセージを出力した後に，exit によりプログラムの実行を終了させている． exit の引数は，プロセスの終了を待っている親プロセスに渡されるが，この詳細は来週に開設する予定．

15～19行目の処理には，"src" ファイルへのファイルポインタをクローズする fclose が入っている（17行目）．エラー処理で exit してしまう場合は，全てのファイルは自動的にクローズされ，領域も開放されてしまうため，この fclose は実際は必要ない．しかし exit しない場合には，同時にオープンできるファイルには制限があり，またメモリリークが起きないようにするためにも，関連するファイルポインタを確実にクローズすることは重要である．

main関数の引数

ファイルのコピーなどのコマンドのプログラムを作る時には，コピーするファイル名をコマンド行の引数として渡せると便利である．このようなプログラム起動時の引数は，main 関数への引数として渡される．以下のプログラムは，コマンド行の引数を出力する．

1 #include <stdio.h> 2 3 main(int argc, char *argv[]) 4 { 5 int i; 6 7 for (i = 0; i < argc; i++) 8 puts(argv[i]); 9 }

これをコンパイル実行すると以下のような結果が得られる．

% ./a.out src dst

ライブラリ関数を用いてファイルのコピーを行うプログラムを，コピーするファイル名をコマンド行の引数として渡せるようにすると次のようなプログラムになる．

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 main(int argc, char *argv[]) 5 { 6 int c; 7 FILE *src, *dst; 8 9 if (argc != 3) { 10 printf("Usage: %s from_file to_file\n", argv[0]); 11 exit(1); 12 } 13 14 src = fopen(argv[1], "r"); 15 if (src == NULL) { 16 perror(argv[1]); 17 exit(1); 18 } 19 20 dst = fopen(argv[2], "w"); 21 if (dst == NULL) { 22 perror(argv[2]); 23 fclose(src); 24 exit(1); 25 } 26 27 while ((c = fgetc(src)) != EOF) 28 fputc(c, dst); 29 30 fclose(src); 31 fclose(dst); 32 }

argc, argv を解釈する場合は，引数の数をチェックすることが大切である．上記のプログラムでは 8～11行目で，引数の数が 3 でなければ，そのプログラムの使い方を表示し，プログラムを終了するようにしている．

これをコンパイル実行すると以下のような結果が得られる．

% ./a.out プログラム-->
システムコールを用いたファイルとの入出力

システムコールを用いてファイルアクセスを行うために，ファイルを開き，閉じるためには open, close を用いる．読み書きのためのシステムコールは read, write を用いる．ライブラリ関数と異なり，read, write 以外には読み書きのためのシステムコールはない．

int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); int close(int fd); ssize_t read(int fd, void *buf, size_t count); ssize_t write(int fd, const void *buf, size_t count);

ファイルアクセスのためのシステムコールは上記の open, close, read, write である．ライブラリ関数もファイルアクセスを行うために，最終的にはシステムコールを使用する．従って，fopen は open を呼び，fclose は close を呼ぶ．入力のための getchar, fgetc, fgets, fread は read を呼び，出力のための putchar, fputc, fputs, fwrite は write を呼ぶ．

ファイルディスクリプタ

fopen は FILE 構造体へのポインタを返し，その後オープンしたファイルへのアクセスのためにはそのポインタを用いる． open はオープンに成功すると 0 以上の整数を返す．その整数は，ファイルディスクリプタ（ファイル記述子）と呼ばれる．システムコールを用いてファイルアクセスを行う場合は，open によりファイルをオープンした後は，戻り値のファイルディスクリプタを指定することにより，そのファイルに対し読み書きを read, write を用いて行うことができる．ファイルアクセスが終了したら，ファイルディスクリプタを引数に close を呼ぶことで，そのファイルをクローズできる．

あるプロセスが一時にオープンできるファイルの数（ファイルディスクリプタの最大値）は制限されている．昔の UNIX では非常に少なかったが，現在はかなり多くのファイルを一時にオープンすることができる． Mac OS X では，通常のプロセスは 256 に設定されているが，unlimit により最大 10240 まで使用可能にできる（/usr/include/sys/syslimits.h の OPEN_MAX）．

標準入出力のファイルディスクリプタ

ライブラリ関数による入出力も結局はシステムコールを呼び出すことで実現されている．ということは，標準入出力（stdin, stdout, stderr）もシステムコールを通して入出力が処理されている．システムコールを通した入出力は，ファイルディスクリプタにより入出力先が指定されるため，標準入出力がなければおかしいことになる．

標準入出力のためのファイルディスクリプタとして 0, 1, 2 が割り当てられている． 0 が標準入力，1 が標準出力，2 が標準エラー出力に対応する．これら3つのファイルディスクリプタは，プログラムが実行される時に明示的にオープンしなくても，使える状態になっている．

ファイルのコピー

ライブラリ関数を用いてファイルのコピーを行うプログラムを，システムコールを用いるように書き換えると以下のプログラムのようになる．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <fcntl.h> 4 5 main() 6 { 7 char c; 8 int src, dst; 9 int count; 10 11 src = open("src", O_RDONLY); 12 if (src < 0) { 13 perror("src"); 14 exit(1); 15 } 16 17 dst = open("dst", O_WRONLY | O_CREAT | O_TRUNC, 0666); 18 if (dst < 0) { 19 perror("dst"); 20 close(src); 21 exit(1); 22 } 23 24 while ((count = read(src, &c, 1)) > 0) { 25 if (write(dst, &c, count) < 0) { 26 perror("write"); 27 exit(1); 28 } 29 } 30 31 if (count < 0) { 32 perror("read"); 33 exit(1); 34 } 35 36 close(src); 37 close(dst); 38 }

プログラムの流れは，ライブラリ関数を用いた場合と同じである． open への引数は，オープンしたいファイル名と，ファイルをオープンするモードである． O_RDONLY は読み込みのみ，O_WRONLY は書き込みのみである．読み書きの場合は O_RDWR を指定する． O_RDONLY, O_WRONLY, O_RDWR と一緒に設定できるモードがいくつかある． O_CREAT がセットされていると，ファイルが存在しなかった場合は作成する． O_TRUNC がセットされていると，ファイルが既に存在した場合はファイルの長さは 0 にされる．モードに O_CREAT が含まれる場合は，ファイルが作られた場合に設定するパーミッションが3番目の引数になる．実際に設定されるパーミッションは，umask のマスクがかかった値になる．

read は読み込める最大バイト数，write は書き込める最大バイト数を指定するが，それぞれ指定されただけの最大バイト数を読み込み又は書き込みできるとは限らない．実際に読み書きされたバイト数が read, write の戻り値として返される．

read, write で指定する読み書きの最大バイト数は，大きいほうが read, write システムコールの呼び出しとコピーの回数が少なくてすむので，より効率的である．つまり上記のプログラムのように 1 とするのは，非常に効率が悪い．通常 1024, 4096, 8192 などの値が用いられるが，最も効率の良い値は入出力先のデバイス，デバイスを制御するコントローラ，メモリの量などに依存する．

ライブラリとシステムコールの混在

同一のファイルに対するアクセスをライブラリとシステムコールで混ぜて行うことは，プログラミング上は可能ではあるが，結果がおかしくなる可能性があるので，避けるべきである．ライブラリ関数での入出力は，1文字単位の入出力も効率よく行えるように，入出力データを一時的に蓄えるバッファリングをすることで，システムコールの回数を減らしている．混ぜて使うと，バッファリングされたデータとの整合性が取れなくなってしまう．

どうしても，どちらかからどちらかへ変換したい時には，以下の関数を使用することができる． fileno, fdopen は，十分なテストをするなど何をしているのか理解するよう注意して使用すべきで，安易に使用すべきではない．

fflush は，上記の目的とは関係なく，バッファリングされたデータをフラッシュしたい時にも使用できる．

int fileno(FILE *stream); /* FILE構造体のファイルディスクリプタを返す */ FILE *fdopen(int fildes, char *mode); /* ファイルディスクリプタからFILE構造体を作る */ int fflush(FILE *stream); /* バッファリングされたデータをフラッシュ */

ファイルのランダムアクセス

全てをメモリ上に読み込むことが難しい大きなデータを扱う場合，全データはファイルに格納し，必要なデータのみを読み書きすることになる．その場合，データをファイルの先頭から順番に読み込んでいくシーケンシャルアクセスではなく，途中を読み飛ばす（読み書きする場所を移動する）ランダムアクセスができると効率が良い．

ランダムアクセスをするためには，システムコールの read, write を用いている場合には lseek，ライブラリ関数の fread, fwrite を用いている場合には fseek を用いる．これらは，ファイルを読み書きする位置（先頭からのバイト数）を移動する．この位置のことを，オフセット，シークポインタ，ファイルポインタなどと呼ぶ（ファイルポインタと呼ぶ場合は FILE* と紛らわしいので注意）．

off_t lseek(int fildes, off_t offset, int whence); int fseek(FILE *stream, long offset, int whence);

lseek, fseek 共に指定するパラメータは同じで，第3引数の whence で指定される位置に第2引数の offset バイト数を加えることによって得られた位置に移動する．つまり，offset に負の値を指定すると，whence で指定された位置から前に移動する． whence には以下のマクロのどれかを指定する．

SEEK_SET ファイルの先頭から offset バイト目に移動．

SEEK_CUR 現在の位置から offset バイト目に移動．

SEEK_END ファイルの末尾から offset バイト目に移動．

SEEK_END によりファイル末尾から先頭方向に向かって offset バイト目に移動したい場合（通常そうであると思われるが）は，offset には負の値を指定しなければいけないことに注意．

ファイルアクセス（応用）

自分でバッファを確保してのファイルコピー

fread, fwriteはライブラリで実装されており，バイト単位での入出力も効率良く行えるように，バッファリングしている．また，指定したオブジェクト（レコード）単位での読み書きを保障しているため，システムコールの read, write と比較して，使いやすい．（システムコールの read, write は，実際に読めた又は書けたバイト数を戻り値として返し，引数に指定した読みたい又は書きたいバイト数の読み書きの保障はしていない．）

バッファリングをしてくれる fread, fwrite を用いる際には，自分でバッファを用意する必要は基本的にはない．しかし，ある程度の大きさのデータを読み込むため，自分で動的に領域を確保する必要がある場合はある．そのような場合を想定し，mallocでバッファを確保してのファイルコピーの例を示す．

28行目でmallocでバッファを確保している．確保する領域のサイズを指定しているBUFSIZは stdio.h で定義されている標準的なバッファサイズを表すマクロである． 36行目にある feof は，freadの戻り値からはEOFとエラーの区別ができないため，EOFかどうかを確認するために使用している． 38, 46行目にある ferror は，同様の理由で，エラー処理を行うため，エラーを区別するために使用している．

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 main(int argc, char *argv[]) 5 { 6 FILE *src, *dst; 7 void *buf; 8 int rcount, wcount; 9 10 if (argc != 3) { 11 printf("Usage: %s from_file to_file\n", argv[0]); 12 exit(1); 13 } 14 15 src = fopen(argv[1], "r"); 16 if (src == NULL) { 17 perror(argv[1]); 18 exit(1); 19 } 20 21 dst = fopen(argv[2], "w"); 22 if (dst == NULL) { 23 perror(argv[2]); 24 fclose(src); 25 exit(1); 26 } 27 28 buf = malloc(BUFSIZ); 29 if (buf == NULL) { 30 perror("malloc"); 31 fclose(src); 32 fclose(dst); 33 exit(1); 34 } 35 36 while (!feof(src)) { 37 rcount = fread(buf, 1, BUFSIZ, src); 38 if (ferror(src)) { 39 perror("fwrite"); 40 fclose(src); 41 fclose(dst); 42 exit(1); 43 } 44 45 wcount = fwrite(buf, 1, rcount, dst); 46 if (ferror(dst)) { 47 perror("fwrite"); 48 fprintf(stderr, "tried to write %d bytes, " 49 "but only %d bytes were written.\n", rcount, wcount); 50 fclose(src); 51 fclose(dst); 52 exit(1); 53 } 54 } 55 56 fclose(src); 57 fclose(dst); 58 }

構造体の入出力

まとめて扱うと便利なデータは，Cプログラムでは構造体を用いて表現する．例えば住所録を作る場合，名前，住所，電話番号，メイルアドレスなどを構造体としてまとめて扱うと，ソートや検索など様々な処理がしやすくなる．

sizeof

そのような構造体のデータをファイルに保存，または読み出すために，まず知らなくてはならないことは，構造体の大きさである．住所録のそれぞれのエントリのために，以下のような構造体を定義したとする．

1 struct entry { 2 char name_family[32]; 3 char name_first[32]; 4 char addr[128]; 5 int zip1; 6 int zip2; 7 char mail[128]; 8 };

この構造体の大きさを知るためには sizeof 演算子を用いる． struct entry の定義は addr.h に書かれているとすると，以下のプログラムはそのバイト数を表示する．

1 #include <stdio.h> 2 #include "addr.h" 3 4 main() 5 { 6 printf("sizeof(struct addr) = %d\n", sizeof(struct entry)); 7 }

コンパイル実行すると，以下のようになる．

% ./a.out データファイルのポータビリティ

utmpデータの読み込み

/var/run/utmp というファイルには現在ログインしているユーザが記録されている．以下のプログラムは fread を利用し1エントリごとデータを読み込み，ログインユーザを表示するプログラムである．

struct utmp の定義は /usr/include/utmp.h から読み込まれる． 10行目の _PATH_UTMP は /var/run/utmp を表す．マクロになっているのはUNIXのバージョンによりパスが異なっていることがあるためであり，マクロにすることによりプログラムの移植性を高めることができる．（しかしながらUNIXの系統によっては異なるマクロが使われている． Linuxでは _PATH_UTMP ではなく UTMP_FILE となっている．）

18行目で読み込んだエントリを19～20行目で出力している． printf の出力フォーマットで %8.8s のピリオド（.）の前の8は8桁のフィールド幅を確保することを意味し，またピリオドの後ろの8は出力する最大文字数を表す．即ち，%8.8s は常に8文字分のフィールドにはみ出さないように出力されることを意味する．

注：下記のプログラムは Linux では動作するが，Mac OS X では utmp ファイルがなくなり実行できない．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <time.h> 4 #include <utmp.h> 5 6 main() 7 { 8 FILE *fp ; 9 struct utmp u; 10 11 fp = fopen(_PATH_UTMP, "r"); 12 13 if (fp == NULL) { 14 perror(_PATH_UTMP); 15 exit(-1); 16 } 17 18 while (fread(&u, sizeof(u), 1, fp) == 1) { 19 printf("%8.8s|%16.16s|%8.8s|%s", u.ut_name, 20 u.ut_host, u.ut_line, ctime(&u.ut_time)); 21 } 22 23 fclose(fp); 24 }

上記プログラムをコンパイル実行すると以下のようになる（結果は各コンピュータごとに異なる）．

% ./a.out 以下は getutxent を用いたプログラムである．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <time.h> 4 #include <utmpx.h> 5 6 main() 7 { 8 struct utmpx *up; 9 10 while ((up = getutxent()) != NULL) { 11 printf("%8.8s|%16.16s|%8.8s|%s", up->ut_user, 12 up->ut_host, up->ut_line, ctime(&up->ut_tv.tv_sec)); 13 } 14 }

データファイルのポータビリティ

構造体のデータを書き込み作成したデータを様々なコンピュータで共有しようとする時に注意しなければいけないのは，データがどのようにファイルに書かれているのかという点である．即ち，数値データがどのようにメモリ上で表現されているのかについて知る必要がある．例えば，以下のような点について気をつける必要がある．

バイト数： 32ビットプロセッサでは int は4バイトであるが，16ビットプロセッサでは 2 バイトのことも多い．
バイトオーダ： int の数値が4バイトで表されるとして，100番地に書き込むと，各バイトは100～103の番地に書き込まれる数値の中の一番小さい方を100番地，一番大きい方を103番地に書き込むプロセッサ（リトルエンディアン）と，逆に一番大きい方を100番地，一番小さい方を103番地に書き込むプロセッサ（ビッグエンディアン）がある．
アラインメント：プロセッサにとって直接の計算対象である数値をメモリ上に格納する時，そのプロセッサにとって最も都合が良いように配置してしまう．最近の多くのプロセッサでは int や double といった4バイトのデータは4バイト境界（4で割り切れる番地）に合わせて配置する．このような配置のことをアラインメントと呼ぶ．

ある意味，最もポータビリティが高いのは1バイトごとにアクセスできるテキストファイルである．例えば，様々なデータを扱えるように設計されたXMLはテキスト形式である．

構造体の入出力と動的メモリ確保

utmpファイルの各エントリの内容を保持するリストを作ることを考える．読み込むレコードが固定長ならば，ファイルのサイズから必要な領域のサイズを計算することもできるが，ここではエントリ読み込む度に必要な領域を動的に確保してみる．

7~10行目でリストを作る構造体を定義している．メンバnextが次の要素へのポインタであり，メンバuはutmp構造体である．つまり，構造体の中に構造体を埋め込んでいる． 24~43行目のforループで，領域を確保し，そこへエントリを読み込み，リストをアップデートしている．作成したリストは48~54行目で出力している．

注：下記のプログラムは Linux では動作するが，Mac OS X では utmp ファイルがなくなり実行できない．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <strings.h> 4 #include <time.h> 5 #include <utmp.h> 6 7 struct utmplist { 8 struct utmplist *next; 9 struct utmp u; 10 }; 11 12 main() 13 { 14 FILE *fp ; 15 struct utmplist *ulhead = NULL; 16 struct utmplist *ulprev, *ulp; 17 18 fp = fopen(_PATH_UTMP, "r"); 19 if (fp == NULL) { 20 perror(_PATH_UTMP); 21 exit(-1); 22 } 23 24 for (;;) { 25 ulp = calloc(1, sizeof(struct utmplist)); 26 if (ulp == NULL) { 27 perror("calloc"); 28 fclose(fp); 29 exit(-1); 30 } 31 32 if (fread(&ulp->u, sizeof(ulp->u), 1, fp) != 1) { 33 free(ulp); 34 break; 35 } 36 37 if (ulhead == NULL) 38 ulhead = ulp; 39 else 40 ulprev->next = ulp; 41 42 ulprev = ulp; 43 } 44 45 fclose(fp); 46 ulp = ulhead; 47 48 while (ulp) { 49 printf("%8.8s|%16.16s|%8.8s|%s", ulp->u.ut_name, 50 ulp->u.ut_host, ulp->u.ut_line, ctime(&ulp->u.ut_time)); 51 ulprev = ulp; 52 ulp = ulp->next; 53 free(ulprev); 54 } 55 }
上記の utmp ファイルを読み込むプログラムは main 関数が長くなり，やや読みにくい．そこで、読み込み部と書き出し部を関数に分け構造化したプログラムを以下に示す．関数単位で内容を把握することができ，わかりやすくなる．
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <strings.h> 4 #include <time.h> 5 #include <utmp.h> 6 7 struct utmplist { 8 struct utmplist *next; 9 struct utmp u; 10 }; 11 12 struct utmplist * 13 read_utmp(FILE *fp, struct utmplist *head) 14 { 15 struct utmplist *ulprev, *ulp; 16 17 for (;;) { 18 ulp = calloc(1, sizeof(struct utmplist)); 19 if (ulp == NULL) { 20 perror("calloc"); 21 fclose(fp); 22 exit(-1); 23 } 24 25 if (fread(&ulp->u, sizeof(ulp->u), 1, fp) != 1) { 26 free(ulp); 27 break; 28 } 29 30 if (head == NULL) 31 head = ulp; 32 else 33 ulprev->next = ulp; 34 35 ulprev = ulp; 36 } 37 38 return head; 39 } 40 41 void 42 write_utmp(FILE *fp, struct utmplist *head) 43 { 44 struct utmplist *ulprev; 45 struct utmplist *ulp = head; 46 47 while (ulp) { 48 fprintf(fp, "%8.8s|%16.16s|%8.8s|%s", ulp->u.ut_name, 49 ulp->u.ut_host, ulp->u.ut_line, ctime(&ulp->u.ut_time)); 50 ulprev = ulp; 51 ulp = ulp->next; 52 free(ulprev); 53 } 54 } 55 56 main() 57 { 58 FILE *fp ; 59 struct utmplist *ulhead = NULL; 60 61 fp = fopen(_PATH_UTMP, "r"); 62 if (fp == NULL) { 63 perror(_PATH_UTMP); 64 exit(-1); 65 } 66 67 ulhead = read_utmp(fp, ulhead); 68 69 fclose(fp); 70 71 write_utmp(stdout, ulhead); 72 }

ポインタ（３）

バッファへのポインタ

以下は，自分でバッファを確保してのファイルコピーの28~34行目を #if 0 ~ #endif で囲み，コンパイル時に無視（正確には cpp プリプロセッサにより削除）されるようにすることで，mallocによる動的メモリ確保が行われないようにしたプログラムである． 7行目で void * 型の変数 buf が宣言されているが，初期化されず，その値は不定のまま，39, 47行目で読み書きのバッファに指定されている． buf は有効なメモリ領域を指していないため，実行するとエラーになることが多い．例え実行できてしまったとしても，どこかの領域を破壊している可能性が高い．

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 main(int argc, char *argv[]) 5 { 6 FILE *src, *dst; 7 void *buf; 8 int rcount, wcount; 9 10 if (argc != 3) { 11 printf("Usage: %s from_file to_file\n", argv[0]); 12 exit(1); 13 } 14 15 src = fopen(argv[1], "r"); 16 if (src == NULL) { 17 perror(argv[1]); 18 exit(1); 19 } 20 21 dst = fopen(argv[2], "w"); 22 if (dst == NULL) { 23 perror(argv[2]); 24 fclose(src); 25 exit(1); 26 } 27 28 #if 0 29 buf = malloc(BUFSIZ); 30 if (buf == NULL) { 31 perror("malloc"); 32 fclose(src); 33 fclose(dst); 34 exit(1); 35 } 36 #endif 37 38 while (!feof(src)) { 39 rcount = fread(buf, 1, BUFSIZ, src); 40 if (ferror(src)) { 41 perror("fwrite"); 42 fclose(src); 43 fclose(dst); 44 exit(1); 45 } 46 47 wcount = fwrite(buf, 1, rcount, dst); 48 if (ferror(dst)) { 49 perror("fwrite"); 50 fprintf(stderr, "tried to write %d bytes, " 51 "but only %d bytes were written.\n", rcount, wcount); 52 fclose(src); 53 fclose(dst); 54 exit(1); 55 } 56 } 57 58 fclose(src); 59 fclose(dst); 60 }

しかしながら，このプログラムはコンパイルできてしまう．しかも，単純に cc コマンドをオプション無しで使用してコンパイルすると，何の警告も出力されないことが多い．

以下のように cc に -O -Wall という2つのオプションを付けてコンパイルすると，buf が初期化されずに使用されているという警告が出力される．（-O だけ，または -Wall だけでは警告は出力されない．両方のオプションを指定する必要がある．）その他，いろいろな警告を出力してくれるため，必要に応じて，このようなオプションを指定すると良い．

% cc -Wall -O bad-filecopy.c バッファオーバーフロー
バッファオーバーフローはプログラムの実行（プロセス）を乗っ取るため，悪意を持った攻撃者によって引き起こされる．バッファオーバーフローを起こすことにより，攻撃者は任意のプログラムを送り込み，それを実行することができてしまい，プロセスは乗っ取られてしまう．

バッファオーバーフローがどうして起こるのか理解するためには，プロセスが実行時に用いられるスタックの構造について理解する必要がある．

下図は，実行中のプロセスのメモリ空間においてどのようにデータが配置されているかを図示したものである．通常，最も下位アドレスに機械語命令が入ったテキスト領域が置かれる．その上にデータ領域が置かれる．データ領域とは別に，関数呼び出し時の戻りアドレス（リターンアドレス）や関数のローカル変数が格納されるスタック領域がある．データ領域はデータ割り当てが起こるたびに上位アドレスに向かって伸びていく．スタック領域は逆に，関数呼び出しが起こるたびに下位アドレスに向かって伸びていく．

スタックフレーム中のローカル変数に配列が含まれていると，配列の添字が小さいほうが下位アドレスにあり，大きいほうが上位アドレスにくる．上の図で buf がポインタとして例えば gets に渡されると，buf[0] から上位アドレスに向かって書き込まれていく． 64文字以上の文字が書き込まれると，buf[63] を超えて書き込まれ，buf として割り当てられた領域を超えて書き込まれてしまうことになる．さらに書き込まれると，リターンアドレスも書き換えられてしまう．スタック領域にうまくプログラムを書き込み，リターンアドレスをそのプログラムの開始アドレスに設定してあげると，関数が戻る時に書き込んだプログラムが実行されてしまう．

このような攻撃方法をスタックスマッシング (stack smashing) と呼ぶ．

以下はスタックを破壊してしまうプログラムの例である．

1 #include <stdio.h> 2 #include <string.h> 3 4 char *longstr = "01234567890abcdefghijklmnopqrstuvwxyz" 5 "01234567890abcdefghijklmnopqrstuvwxyz" 6 "01234567890abcdefghijklmnopqrstuvwxyz" 7 "01234567890abcdefghijklmnopqrstuvwxyz" 8 "01234567890abcdefghijklmnopqrstuvwxyz" 9 "01234567890abcdefghijklmnopqrstuvwxyz"; 10 11 void 12 with_check(char *src) 13 { 14 char buf[20]; 15 int i; 16 17 i = strlcpy(buf, src, sizeof(buf)); 18 19 if (i > sizeof(buf) - 1) 20 printf("with_check: buf is too short to copy src(%s).\n", 21 src); 22 23 printf("with_check: buf(%s)\n", buf); 24 } 25 26 void 27 without_check(char *src) 28 { 29 char buf[20]; 30 strcpy(buf, src); 31 printf("without_check: buf(%s)\n", buf); 32 } 33 34 main() 35 { 36 with_check(longstr); 37 without_check(longstr); 38 }

これをコンパイル実行すると，without_check関数を実行中にスタックが破壊され，without_check関数を呼び出したmain関数に戻る際におかしなアドレスに戻ろうとするため，以下のように異常終了してしまう．

% ./a.out プロセスの概念と機能
プログラムとプロセス

プログラムは，CPUが実行できる機械語命令とそれにより処理されるデータの集合（実行形式，ロードモジュール）がファイルに格納されたものである．他に，ヘッダと呼ばれる部分には機械語命令やデータなどの各領域の情報が含まれ，また共有ライブラリを用いるように動的リンクされた実行形式の場合は実行に必要な共有ライブラリの情報，ソースコードレベルのデバッグ情報付きでコンパイル（cc -g）された実行形式の場合はデバッグ情報なども含まれる．

一方，プログラムを実行中のものがプロセスである．プロセスには，プログラムに含まれる実行に必要な情報に加えて，プログラムには含まれない実行中の情報が入っている．初期値が 0 （初期値なし）のデータ領域はプログラムに含める必要性はなく，そのデータ領域がプロセス中のどこにどれだけの大きさ必要かという情報だけが含まれていればよい．しかし，プログラムの実行にはそのデータ領域が必要であるため，プロセスではそのデータ領域が実際に確保されている必要がある．逆に，ヘッダ情報やデバッグ情報は必要があればプログラムファイルから読み込めばよく，プロセスでの実行には必要ない．実行が進めばデータは書き換えられたり，追加されたりする（機械語命令は通常変わらない）．プログラムには含まれていない，実行の履歴（関数呼び出し，ローカル変数）を格納するためのデータ領域（スタック）も必要である．

プロセスの機能

プロセスの重要な機能として以下の２つがある．

資源割り当て
保護

資源割り当て

UNIXにおけるプロセスは，プロセッサ時間，メモリ，ファイル，キーボードやディスプレイ，プリンタなどのデバイスといった，処理を行うにあたって必要となる計算資源の割り当て単位である．ユーザがプログラムを起動すると，それはプロセスにより実行される． OSカーネルにより，プロセスに対しプロセッサ時間，メモリが割り当てられ実行が始まる．プロセスは，プログラムに記述された通りにファイルをオープン，アクセスし，キーボードやディスプレイなどのデバイスを使用する．ファイルをオープンした時に得るファイルディスクリプタは各プロセス固有のものになる．ファイルのアクセス権はユーザに対し与えられるが，計算資源はプロセスに対し与えられる．

基本的には，OSカーネルは，プロセッサ時間やメモリに関しては，それぞれのプロセスに平等になるように割り当てる．ファイルやデバイスに関しては先着順である．

保護

プロセスは，割り当てられた資源が保護される単位でもある．あるプロセスは他のプロセスに割り当てられた資源に対し許可なくアクセスすることはできない．例え同じユーザにより作成されたプロセス間であってもである．保護の機能により，例えばある暴走したプロセスが他のプロセスの実行内容を破壊するようなことは起こらない．

プロセスのメモリマップ

プロセスのメモリマップを詳しく見ると以下のようになる．

それぞれの領域の用途は以下の通りである：

テキスト領域プログラムの機械語命令が置かれる．この領域は読み出し専用になっており，同じプログラムから起動されるプロセスの間で共有可能になっている．

データ領域（初期値あり）プログラム中に指定された 0 以外の初期値を持つ大域 (global) 変数，静的局所 (static local) 変数が置かれる．

データ領域（初期値なし）通称 BSS (Block Started by Symbol) セグメント．初期値を持たない，又は初期値が 0 の大域変数，静的局所変数が置かれる．プロセス作成時に確保され，0 に初期化される．変数の名前（シンボル）だけなのが名前の由来．

ヒープ領域 malloc()などにより，プロセス実行時に確保されるデータ領域．

共有ライブラリ共有ライブラリのため領域はヒープとスタックの間にとられる．テキスト領域と同じく読み出し専用で，他のプログラムと共有される．

スタック領域 C言語の自動変数（staticでないローカル変数）や，引数，関数呼び出し時の戻り番地などが置かれる．

引数，環境変数コマンドに渡される引数，環境変数は，スタック領域の最上位部分に格納されている．

上記のメモリマップは，以下の簡単なプログラムで確かめることができる．環境変数が格納されている文字列へのポインタは environ という変数に格納されている．初期値が設定されない data0 はBSSセクションに配置され，初期値を持つ data1 はデータセクションに配置される．

1 #include <stdio.h> 2 3 extern char **environ; 4 5 int data0; 6 int data1 = 10; 7 8 main(int argc, char *argv[]) 9 { 10 char c; 11 12 printf("environ:\t%0.8p\n", environ); 13 printf("argv:\t\t%0.8p\n", argv); 14 printf("stack:\t\t%0.8p\n", &c); 15 16 printf("bss:\t\t%0.8p\n", &data0); 17 printf("data:\t\t%0.8p\n", &data1); 18 }

このプログラムをコンパイル実行してみると，以下のような結果が得られ，環境変数の文字列が最上位アドレスにあり，次にコマンド引数の文字列，そしてスタックの順であることがわかる．また，BSSセクションがデータセクションよりも上位アドレスに来ていることもわかる．

% ./a.out プログラムに既に出てきたが，プロセスには環境変数は文字列で渡され，その文字列の場所は外部変数 environ により指し示される．環境変数を構成する文字列は，構造的には argv と同じであり，environ は文字列の配列へのポインタ（従って型は char ** ）である．

環境変数を（便利に）操作するために以下のライブラリ関数が用意されている．

char *getenv(const char *name); int putenv(char *string); int setenv(const char *name, const char *value, int overwrite); void unsetenv(const char *name);

プロセスを操作するコマンド

プロセスに対して何らかの操作を行うプログラムにはいろいろある．以下は一部のよく使用するコマンドである．

シェル（sh, ksh, bash, zsh, csh, tcsh）コマンドの実行（プロセス作成，プログラム実行），リダイレクション，パイプ，その他．．．

ps, pstree, top プロセスの観察

kill プロセスの（強制）終了

nice プロセスの実行優先順位の制御

limit プロセスの利用可能資源の制御

gdb デバッグツール

これらのコマンドは，他のプログラムと何ら変わることが無く，様々なシステムコールを呼び出すことで，その機能を実現している．

プロセスの操作：プロセス作成，プログラム実行，プロセス終了

プロセスの作成とプログラムの実行

概要

ユーザのプログラムはプロセスにより実行される．通常，ユーザがシェルのコマンドプロンプトのところにコマンド名を打ち込むと，そのコマンドが実行される．この処理をもう少し詳しく見てみると，

シェルを実行するプロセスは，コマンドを実行するプロセスを作成する
作成されたプロセスは，指定されたコマンドを実行する
シェルは，コマンドを実行するプロセスが終了するのを待つ
コマンドが終了すると，シェルの実行が再開される
というステップになっている．これらのステップにはそれぞれ以下のシステムコールが対応している．

pid_t fork(void); int execve (const char *filename, char *const argv[], char *const envp[]); pid_t wait(int *status) void exit(int status);

fork システムコールは，fork システムコールを呼んだプロセスの複製を作成する． fork システムコールを呼んだプロセスが親プロセスとなり，複製され新たに作られたプロセスが子プロセスになる． execve システムコールは，execve システムコールを呼んだプロセスに指定されたプログラムをロード，実行する． wait システムコールは，子プロセスの終了を待つ． exit システムコールは，exit システムコールを呼んだプロセスを終了させる．

fork, execve, wait, exit によるプロセスの作成，プログラムの実行，プロセスの終了を図示すると以下のようになる．

UNIXでは，プロセスの作成はfork，プログラムの実行はexecveでしかできない．（Linuxにはcloneというシステムコールがあるが，これはスレッドをサポートするために無理矢理入れたものであり，ちょっと邪道である．）

forkによるプロセスの作成とexecveによるプログラムの実行というのは，一見不可解な組み合わせかもしれない． 1つのシステムコールでプロセスの作成しプログラムを実行してしまえば良いではないかと思うかもしれない．しかし，次のリダイレクションやパイプを見てみると，forkとexecveの組み合わせになっているなぞが（少しは）解けるかもしれない．

プログラム例（fork）

以下は，簡単のために exec をせず，fork, wait, exitだけを使ったプログラム例である．

forkは自分をコピーして子プロセスを作る．現在実行中の場所もコピーする．従って，子プロセスは fork から戻るところからプロセスの実行が始まる（19行目）． fork を呼び出した親プロセスも fork から戻る（同じく19行目）．どちらが親でどちらが子かは，fork の戻り値から判別することができる（24行目）． fork は親プロセスには生成した子プロセスのプロセスIDを戻り値として返す．子プロセスには 0 を返す． fork が失敗した時には負の値を返す．

親プロセスは fork の後 wait を呼び出し，子プロセスが終了するまで実行を一時停止する（27行目）．

子プロセスは getpid で取得したプロセスIDと共にメッセージを表示した後，exit を呼んでプロセスを終了する（12行目）． exit の引数として 2 を与えており，この値は wait で待っている親プロセスに渡される．

子プロセスが終了すると，wait で待っている親プロセスの実行は再開され，wait の呼び出しから戻る．戻るときに status の値がセットされる（27行目）．この status に，子プロセスが exit を呼び出した時の引数の値がセットされている．その値を取り出すために WEXITSTATUS というマクロが使われる（32行目）．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/types.h> 4 #include <sys/wait.h> 5 6 void 7 do_child() 8 { 9 printf("This is child(pid=%d).\n", getpid()); 10 11 exit(2); 12 } 13 14 main() 15 { 16 int child, status; 17 18 if ((child = fork()) < 0) { 19 perror("fork"); 20 exit(1); 21 } 22 23 if (child == 0) 24 do_child(); 25 else { 26 if (wait(&status) < 0) { 27 perror("wait"); 28 exit(1); 29 } 30 printf("The child (pid=%d) existed with status(%d).\n", 31 child, WEXITSTATUS(status)); 32 } 33 }

以下は，このプログラムをコンパイル，実行してみた結果である．親プロセスが受け取る fork の戻り値と，子プロセスが getpid で取得するプロセスIDが同じであること，また子プロセスでの exit の引数が，親プロセスの wait に渡されていることがわかる．

% ./a.out 1 #include <stdio.h> 2 3 extern char **environ; 4 5 main() 6 { 7 char *argv[2]; 8 9 argv[0] = "/bin/ls"; 10 argv[1] = NULL; 11 12 execve(argv[0], argv, environ); 13 }

実際に execve が実行するプログラムは，execve の第1引数で指定されたプログラムである．そのプロセスに，execve の第2引数に指定された argv が渡される．従って，以下のように書いても，/bin/ls は実行できる．

1 #include <stdio.h> 2 3 extern char **environ; 4 5 main() 6 { 7 char *argv[2]; 8 9 argv[0] = "ls"; 10 argv[1] = NULL; 11 12 execve("/bin/ls", argv, environ); 13 }

execve で実行するプログラムに引数を与えたい場合は，argv[1] 以降に指定すれば良い．以下は /bin/ls / を実行するプログラム例である．

1 #include <stdio.h> 2 3 extern char **environ; 4 5 main() 6 { 7 char *argv[3]; 8 9 argv[0] = "/bin/ls"; 10 argv[1] = "/"; 11 argv[2] = NULL; 12 13 execve(argv[0], argv, environ); 14 }

実行してみると，ルートディレクトリの内容が表示され，正しく引数が渡されていることがわかる．

% ./a.out 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/types.h> 4 #include <sys/wait.h> 5 6 extern char **environ; 7 8 void 9 do_child() 10 { 11 char *argv[3]; 12 13 printf("This is child(pid=%d)\n", getpid()); 14 15 argv[0] = "/bin/ls"; 16 argv[1] = "/"; 17 argv[2] = NULL; 18 19 execve(argv[0], argv, environ); 20 } 21 22 main() 23 { 24 int child, status; 25 26 if ((child = fork()) < 0) { 27 perror("fork"); 28 exit(1); 29 } 30 31 if (child == 0) 32 do_child(); 33 else { 34 if (wait(&status) < 0) { 35 perror("wait"); 36 exit(1); 37 } 38 printf("The child (pid=%d) existed with status(%d).\n", 39 child, WEXITSTATUS(status)); 40 } 41 }

実行結果としては，何ら変わりはないが，exit status は /bin/ls が設定しているため 0 になっている．

% ./a.out 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/types.h> 4 #include <sys/wait.h> 5 6 extern char **environ; 7 8 void 9 do_child() 10 { 11 char *argv[2]; 12 13 printf("This is child(pid=%d)\n", getpid()); 14 15 argv[0] = "/bin/xxxxx"; 16 argv[1] = NULL; 17 18 if (execve(argv[0], argv, environ) < 0) { 19 perror("execve"); 20 exit(1); 21 } 22 } 23 24 main() 25 { 26 int child, status; 27 28 if ((child = fork()) < 0) { 29 perror("fork"); 30 exit(1); 31 } 32 33 if (child == 0) 34 do_child(); 35 else { 36 if (wait(&status) < 0) { 37 perror("wait"); 38 exit(1); 39 } 40 printf("The child (pid=%d) existed with status(%d).\n", 41 child, WEXITSTATUS(status)); 42 } 43 }

上記のプログラムを実行してみると，execve は失敗し，perror の出力するエラーメッセージが表示される．

% ./a.out void _exit(int status); pid_t waitpid(pid_t pid, int *status, int options);

なぜ exit はライブラリ関数になっているのかは，atexit(3) を見てみるとわかる．

プログラム実行のためのライブラリ関数

execve は引数や環境変数を argv 形式で渡す必要がある，またプログラムのサーチしてくれないため，もう少し簡単に使えるようにと，以下のライブラリ関数が用意されている．

int execl(const char *path, const char *arg, ...); int execlp(const char *file, const char *arg, ...); int execle(const char *path, const char *arg , ..., char * const envp[]); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]);

execl, execlp, execle は，コマンド引数の渡し方が execve とは異なり，これらのライブラリ関数の引数として，コマンド引数ののように文字列を並べて渡す．

1 #include <stdio.h> 2 #include <unistd.h> 3 4 main() 5 { 6 execl("/bin/ls", "ls", "/", NULL); 7 }

また，execlp, execvp は環境変数 PATH を使用してコマンドをサーチしてくれる．

1 #include <stdio.h> 2 #include <unistd.h> 3 4 main() 5 { 6 execlp("ls", "ls", "/", NULL); 7 }

リダイレクション，パイプ

リダイレクション

概要

リダイレクションは標準入出力をファイルにする機能である．以下は，シェルから ls の結果をファイルに出力したり，wc への入力をファイルにしたりしている．

% ls *.c > a.txt int dup(int oldfd); int dup2(int oldfd, int newfd);

dup はファイルディスクリプタとして使用されていない最小の値を使用し，dup2 は newfd として指定された値を使用するという点だけが異なる．

dup2 を使用したリダイレクションの設定を図示すると，以下のようになる．

ファイルをオープンし，（例えば）ファイルディスクリプタ 3 を得る．
標準入力（ファイルディスクリプタ 0）をクローズする．
dup2 により，ファイルディスクリプタ 3 の複製をファイルディスクリプタ 0 として作成する．
ファイルディスクリプタ 3 をクローズすることにより，ファイルはファイルディスクリプタ 0 からのみアクセスできるようになる．

プログラム例

以下は，第1引数に指定されたファイルを，wc の標準入力とするプログラムである． 15～20行目で第1引数に指定されたファイルを open する処理を行っている． 22行目でファイルディスクリプタ 0 をクローズし，再利用可能な状態にしている． 23行目で dup2 を呼び出し，15行目でオープンしたファイルをファイルディスクリプタ 0 からもアクセスできるようにしている． 28行目で15行目のオープンで取得したファイルディスクリプタの方はクローズしている．これによりオープンしたファイルは，ファイルディスクリプタ 0 からのみアクセスできる状態になる． 30行目で execlp を呼び，wc を起動している．ファイルディスクリプタ 0 は15行目でオープンしたファイルとつながっているため，wc の標準入力はそのファイルから読み込まれることになる．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <unistd.h> 4 #include <fcntl.h> 5 6 main(int argc, char *argv[]) 7 { 8 int file_fd; 9 10 if (argc != 2) { 11 printf("Usage: %s file_name\n", argv[0]); 12 exit(1); 13 } 14 15 file_fd = open(argv[1], O_RDONLY); 16 if (file_fd < 0) { 17 perror("open"); 18 close(file_fd); 19 exit(1); 20 } 21 22 close(0); 23 if (dup2(file_fd, 0) < 0) { 24 perror("dup2"); 25 close(file_fd); 26 exit(1); 27 } 28 close(file_fd); 29 30 execlp("wc", "wc", NULL); 31 }

以下は，上記プログラムの実行結果である．

% ./a.out a.txt % ls *.c | wc

このパイプを実現しているのが，その名の通り pipe システムコールである．

int pipe(int filedes[2]);

pipe システムコールを呼ぶと，入力と出力それぞれの口（ファイルディスクリプタ）を持つパイプが1本作られる．ファイルディスクリプタは，上記の例だと filedes 配列に格納され，filedes[0] がパイプの出口，filedes[1] がパイプの入口のファイルディスクリプタになる．この関係は，ファイルディスクリプタ 0 が標準入力，ファイルディスクリプタ 1 が標準出力であることと対比させるとわかりやすい．即ち，filedes[0] から読み，filedes[1] に書く．

プロセス間のパイプの作成を図示すると以下のようになる．

pipe システムコールを呼ぶと，入力と出力それぞれの口（ファイルディスクリプタ）を持つパイプが1本作られる．
この状態で fork を呼ぶと，パイプ（入出力の口）が両方とも共有された状態になる．
一方のプロセスが入力を，もう一方が出力の口を閉じると，プロセスからプロセスへデータを送れる（プロセス間通信）状態になる．

プログラム例

以下のプログラムは，パイプを作成した後 fork をし，子プロセスから親プロセスへ文字列を送るプログラムである．

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int pipe_fd[2]; 5 6 void 7 do_child() 8 { 9 char *p = "Hello, dad!!\n"; 10 11 printf("this is child.\n"); 12 13 close(pipe_fd[0]); 14 15 while (*p) { 16 if (write(pipe_fd[1], p, 1) < 0) { 17 perror("write"); 18 exit(1); 19 } 20 p++; 21 } 22 } 23 24 void 25 do_parent() 26 { 27 char c; 28 int count, status; 29 30 printf("this is parent.\n"); 31 32 close(pipe_fd[1]); 33 34 while ((count = read(pipe_fd[0], &c, 1)) > 0) { 35 putchar(c); 36 } 37 38 if (count < 0) { 39 perror("read"); 40 exit(1); 41 } 42 43 if (wait(&status) < 0) { 44 perror("wait"); 45 exit(1); 46 } 47 } 48 49 main() 50 { 51 int child; 52 53 if (pipe(pipe_fd) < 0) { 54 perror("pipe"); 55 exit(1); 56 } 57 58 if ((child = fork()) < 0) { 59 perror("fork"); 60 exit(1); 61 } 62 63 if (child) 64 do_parent(); 65 else 66 do_child(); 67 }

53行目でパイプを作成した後，58行目で fork をしている．
子プロセスは13行目でパイプの出口をクローズし，親プロセスは32行目でパイプの入口をクローズする．
子プロセスは文字列をパイプに書き込み（15～21行目），親プロセスはそれをパイプから読み出す（34～36行目）．
このプログラムをコンパイル実行すると以下のような結果が得られる．

% ./a.out 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int pipe_fd[2]; 5 6 void 7 do_child() 8 { 9 char *p = "Hello, dad!!\n"; 10 11 printf("this is child\n"); 12 13 close(pipe_fd[0]); 14 15 close(1); 16 if (dup2(pipe_fd[1], 1) < 0) { 17 perror("dup2 (child)"); 18 exit(1); 19 } 20 close(pipe_fd[1]); 21 22 while (*p) 23 putchar(*p++); 24 } 25 26 void 27 do_parent() 28 { 29 char c; 30 int count, status; 31 32 printf("this is parent\n"); 33 34 close(pipe_fd[1]); 35 36 close(0); 37 if (dup2(pipe_fd[0], 0) < 0) { 38 perror("dup2 (parent)"); 39 exit(1); 40 } 41 close(pipe_fd[0]); 42 43 while ((c = getchar()) != EOF) 44 putchar(c); 45 46 if (wait(&status) < 0) { 47 perror("wait"); 48 exit(1); 49 } 50 } 51 52 main() 53 { 54 int child; 55 56 if (pipe(pipe_fd) < 0) { 57 perror("pipe"); 58 exit(1); 59 } 60 61 if ((child = fork()) < 0) { 62 perror("fork"); 63 exit(1); 64 } 65 66 if (child) 67 do_parent(); 68 else 69 do_child(); 70 }

プロセスの作成と実行を1度に行うシステムコールがあったとして，同じこと（別に全く同じである必要はないがプロセス間の通信）を実現しようとしたらどうなるであろうか？そのシステムコールにいろいろなオプションや引数を渡せるようにして実現するのであろうか．それとも，より汎用のプロセス間通信機能を使うのであろうか（現在のUNIXにはそのような機能が備わっているが）．少なくとも，forkとexecveが分かれていることにより，リダイレクションやパイプが簡単に実現できることがわかって貰えただろうか．

その他のプロセス操作のためのシステムコール，ライブラリ関数

プロセス強制終了

通常プロセスを終了するために使用される kill コマンドは，kill システムコールを呼ぶことで実現される． kill システムコールは，指定されたプロセスにシグナル呼ばれるイベントを送るためのものである．シグナルについては第5回目の講義で詳しく述べる．

int kill(pid_t pid, int sig);

メモリ領域確保

malloc はできるだけ動的に確保され free により開放されたメモリ領域を使いまわすように設計されているが，現在のヒープ領域だけではメモリ領域が足りなくなった時に，以下のヒープ領域を拡大するためのシステムコールが呼び出される．呼出し後はヒープ領域が拡大され，新たなメモリ領域確保ができるようになる．

int brk(void *end_data_segment); void *sbrk(ptrdiff_t increment);

簡単なプログラム実行

以下のライブラリ関数は，単純なプロセスの実行や，パイプを使用してのプロセスの実行を簡単に行えるように用意されている．

FILE *popen(const char *command, const char *type); int pclose(FILE *stream); int system (const char * string);

その他のシステムコール

以下は，プロセスの実行優先順位や利用可能資源の制御，デバッグ等を行うためのシステムコールである．

int nice(int inc); int getrlimit(int resource, struct rlimit *rlim); int getrusage(int who, struct rusage *usage); int setrlimit(int resource, const struct rlimit *rlim); int ptrace(int request, int pid, int addr, int data);

シグナル

概要

プロセスは，オペレーティングシステムがコンピュータ（プロセッサ）を抽象化し，使いやすくしたものである．コンピュータは入出力機器からのイベント通知を割り込みという仕組みで受け取る．プロセスには，割り込みに相当するイベント通知のメカニズム（ソフトウェア割り込み）として，シグナルが提供されている．

入出力機器

割り込みは入出力機器からのイベント通知のために考え出されたものである．入出力機器はコンピュータにI/Oコントローラを通して接続されている．以下の図は単純化したコンピュータの構成を示している．

コンピュータは，に加え，キーボード，マウス，グラフィックスディスプレイ，HDD，ネットワークインタフェースなどの入出力機器（I/Oデバイス）からなる．入出力機器はI/Oコントローラを通して制御される．プロセッサ，メインメモリ，I/Oコントローラはシステムバスに接続されており，システムバスを通してお互いにデータをやり取りしている．

I/Oコントローラは，システムバスと入出力機器の間でデータの橋渡しをする．入出力機器は様々な種類のコンピュータに対応するため，標準的なインタフェースを提供している． PCのキーボードやマウスにはPS/2というインタフェースがよく使われていたが，最近のPCやMacintoshではUSBが使われている． HDDはATA，SATAやSCSIというインタフェースがよく使われている．一方，システムバスはプロセッサ固有のものである．例えば Macintosh に使われてきた PowerPC というプロセッサのシステムバスと，Intel Pentium 4 のシステムバスは全く異なるものである． PowerPC や Intel Pentium 4 と称されていても，実際はいくつかの異なるシステムバスが使用されている．入出力機器の標準的なインタフェースに対応するように，I/Oコントローラはプロセッサとのセットで使われるように開発される．

システムバスは以下のバスから構成される．

アドレスバス
データバス
制御バス（コントロールバス）
データをメインメモリ又はI/Oコントローラから取り出す場合，プロセッサは取り出したいデータのあるアドレスをアドレスバスに出す．該当するアドレスにあるメインメモリ又はI/Oコントローラのデータがデータバスに出され，それをプロセッサは取得する．制御バスは，アドレスバスやデータバスへのアクセス制御を行ったり，I/Oコントローラの割り込み要求をプロセッサに通知するために使用される．

ポーリングと割込み

プロセッサはI/Oコントローラに入出力要求を出し，I/Oコントローラはその要求を解釈し，I/Oデバイスに伝える． I/Oデバイスは入出力要求を処理し，結果をI/Oコントローラに転送し，プロセッサはI/Oコントローラからその結果を受け取る．下図は，この処理の流れを図示したものである．

プロセッサはI/Oコントローラの状態をチェックし続けることで，処理が終了したかどうかを知る．従って，プロセッサは，I/Oコントローラ，I/Oデバイスがプロセッサからの入出力要求を処理している間は，プロセッサでの処理を続けられないため待ち時間ができてしまう．このようなI/Oデバイスへの入出力要求の処理方法をポーリング (Polling) と呼ぶ．

通常，I/Oデバイスはプロセッサの処理速度と比較すると非常に遅いため，ポーリングでI/O処理の終了を待っているとプロセッサの使用率を著しく下げてしまう．また，端末からの入力待ちのような場合，プロセッサがユーザからの入力を待つような処理形態では，複数の端末からの入力に対する応答性を良くすることは非常に難しい．

割り込み (interrupt) は，ポーリングの持つ非効率性を解決するため，入出力処理が終了したことをプロセッサに対し通知するために考え出された方法である． I/Oコントローラは，I/Oデバイスとの入出力処理が終了したら，プロセッサに対し割り込み要求を出す．プロセッサは割り込み要求を受け付けると，現在実行中の処理を中断し，割り込みを処理するために予め設定されたプログラムを呼び出し，実行する．この割り込み処理のためのプログラムを，割り込みハンドラとか割り込みサービスルーチン (ISR: Interrupt Service Routine) などと呼ぶ．

■ 割り込みは時間依存の処理を可能にする

割り込みが考え出されてから，時間に依存した処理もできるようになった．時間を刻むタイマデバイスから一定周期で（例えば1秒ごとに）割り込みがかかるようにすれば，そのタイミングでプロセスの切替をしたり，ポーリングを行ったりすることができるようになる．割り込みにより，特定のプロセスや特定のデバイスにかかりきりになることなく，公平に有効にプロセッサを分配活用できるようになった．

■ 関数呼び出しは同期処理，割り込みは非同期処理

割り込み処理は本来のプログラムの処理の流れとは無関係に，非同期的 (asynchronous) に発生する．一方，関数呼び出しは同期的 (synchronous) であり，明示的に関数を呼び出し，呼び出された関数で処理が行われ，関数呼び出しから戻ってくる．下図は，関数呼び出しと割り込み処理の違いを図示したものである．

ある関数における処理から別の関数（割り込み処理ハンドラもプログラムの中では関数として定義される）が呼び出されるという処理の流れだけを見ると，関数呼び出しも割り込み処理も違いはない．しかしながら，関数呼び出しの場合には関数を呼び出すという命令が入っているのに対し，割り込み処理の場合は割り込まれたプログラムには割り込み処理ハンドラを呼び出すような命令は一切ない．いつどこで割り込まれるかわからないのが，割り込みの特徴である．

OSカーネルで処理を行ううえで，いつでも割り込まれてしまうのでは，データの一貫性を保つことができないので，プロセッサには割り込みを禁止する命令が用意されている．

例外

割り込みとは別に，アクセスが許可されていない番地にアクセスしようとしたとか，0による除算をしようとしたとか，不正な命令（例えば特権が必要な命令）を実行しようとしたとかの理由で，プログラムの実行中にそのプログラムに原因が起因するエラーが起こることがある．このようなエラーのことを例外 (exception) と呼ぶ．例外が発生した場合，OSカーネルの例外ハンドラが起動され対処する．

割り込みと例外が良く似ている点は，OSカーネルの割り込み又は例外ハンドラが起動されるという点，そしてこれらのハンドラを呼び出す命令がプログラム中には含まれていないという点である．異なっているのは，割り込みの場合は割り込みハンドラが起動されるのは，デバイスなどプログラム外部の要因であるのに対し，例外の場合はプログラムの実行にその要因があるという点である．

シグナル

ハードウェアからの割り込みはや例外はOSカーネルにより処理される．ハードウェアを直接操作できるのはOSカーネルだけであるので，通常のユーザプロセスがハードウェアからの割り込みを直接受けることはない．例外は，その要因となったプログラムが処理することが可能な場合もあるが，プログラムに共通する処理も多いため，通常OSカーネルにより処理される．

しかしながら，割り込みや例外の概念はユーザプロセスとして動作するプログラムにも便利である．ある一定時間ごとに割り込みを発生させることができれば，現在の処理を継続しながら別の処理，例えばプロンプトを点滅させたり，アニメーションを実行したり，又は割り込みをサポートしていないデバイスに対しポーリングを行ったりというようなこと，ができる．また，非同期的に命令を送りそれに応じた処理を行わせるためにも，割り込みの概念は使用できる．例外が起こった場合に，そのイベントに対するプログラム独自の対処をしたい場合もある．

■ 割り込みを抽象化したのがシグナル

UNIXではプロセッサとメモリという基本的なコンピュータはプロセスとして抽象化されているが，同じように割り込み及び例外を抽象化したのがシグナル (signal) である．割り込みハンドラに相当するのがシグナルハンドラである．一般的に使用される割り込みや例外の種類に応じたシグナルがOSカーネルにより定義されている．プロセスはそれぞれのシグナルの種類に対しシグナルハンドラをOSカーネルに登録することができる．プロセスは，実行中のプログラムに起因する例外や，プロセス外部からのイベントをシグナルとして受け取り，OSカーネルに登録したシグナルハンドラが起動される．

プロセス外部からのイベントとして良く使用されているのが，キーボードから Ctrl-C や Ctrl-Z によるプロセス実行の中止又は中断である．これらのキーボードからの入力は，OSカーネルに含まれるデバイスを制御するデバイスドライバにより処理され，プロセスにはシグナルとして通知される．

シグナルを用いたプログラミング

シグナルの種類とデフォルトの動作

SIGNAL(3) BSD Library Functions Manual SIGNAL(3) NAME signal -- simplified software signal facilities LIBRARY Standard C Library (libc, -lc) SYNOPSIS #include <signal.h> void (* signal(int sig, void (*func)(int)))(int); or in the equivalent but easier to read typedef'd version: typedef void (*sig_t) (int); sig_t signal(int sig, sig_t func); DESCRIPTION This signal() facility is a simplified interface to the more general sigaction(2) facility. .... 一部省略 .... No Name Default Action Description 1 SIGHUP terminate process terminal line hangup 2 SIGINT terminate process interrupt program 3 SIGQUIT create core image quit program 4 SIGILL create core image illegal instruction 5 SIGTRAP create core image trace trap 6 SIGABRT create core image abort program (formerly SIGIOT) 7 SIGEMT create core image emulate instruction executed 8 SIGFPE create core image floating-point exception 9 SIGKILL terminate process kill program 10 SIGBUS create core image bus error 11 SIGSEGV create core image segmentation violation 12 SIGSYS create core image non-existent system call invoked 13 SIGPIPE terminate process write on a pipe with no reader 14 SIGALRM terminate process real-time timer expired 15 SIGTERM terminate process software termination signal 16 SIGURG discard signal urgent condition present on socket 17 SIGSTOP stop process stop (cannot be caught or ignored) 18 SIGTSTP stop process stop signal generated from keyboard 19 SIGCONT discard signal continue after stop 20 SIGCHLD discard signal child status has changed 21 SIGTTIN stop process background read attempted from control terminal 22 SIGTTOU stop process background write attempted to control terminal 23 SIGIO discard signal I/O is possible on a descriptor (see fcntl(2)) 24 SIGXCPU terminate process cpu time limit exceeded (see setrlimit(2)) 25 SIGXFSZ terminate process file size limit exceeded (see setrlimit(2)) 26 SIGVTALRM terminate process virtual time alarm (see setitimer(2)) 27 SIGPROF terminate process profiling timer alarm (see setitimer(2)) 28 SIGWINCH discard signal Window size change 29 SIGINFO discard signal status request from keyboard 30 SIGUSR1 terminate process User defined signal 1 31 SIGUSR2 terminate process User defined signal 2 32 SIGTHR terminate process thread interrupt .... 以下省略 ....

signal システムコール

signal システムコールは，シグナルをサポートするために最初に作られたシステムコールである．

typedef void (*sig_t)(int); sig_t signal(int sig, sig_t func);

シグナルハンドラを変更するシグナルと新しいシグナルハンドラを引数に指定して呼び出すと，古いシグナルハンドラが返される． signal システムコールの引数と戻り値の型は sig_t であり，これは int 型を引数に取り値を返さない（つまり void型の）関数へのポインタ（アドレス）という意味である．即ち，シグナルハンドラは以下のようにプロトタイプ宣言されるような関数ということになり，このような関数へのポインタが，signal システムコールの引数や戻り値になる．シグナルハンドラの引数は，送られてきたシグナルの番号である．

void signal_handler(int);

古いシグナルハンドラの値としては次が返されることもある：

SIG_IGN　シグナルの無視
SIG_DFL　デフォルトの動作

シグナルと共に使われるシステムコールに pause がある． pause を呼び出すとシグナルを受け取るまでプロセスの実行をブロックする．シグナルを受け取ると，シグナルハンドラの実行後に，pauseから戻る．

int pause(void);

以下は signal と pause を使ったプログラム例である．

7～21行目：シグナルハンドラの定義．3回起動すると exit を呼ぶ．
25行目：SIGINTに対するシグナルハンドラとして sigint_handler を設定
31行目：pause でシグナルを受け取るまでブロック
つまり，Ctrl-C たたく度に sigint_handler が起動し，3回たたくと終了する．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <signal.h> 4 5 volatile sig_atomic_t sigint_count = 3; 6 7 void 8 sigint_handler(int signum) 9 { 10 printf("sigint_handler(%d): sigint_count(%d)\n", 11 signum, sigint_count); 12 13 if (--sigint_count <= 0) { 14 printf("sigint_handler: exiting ... \n"); 15 exit(1); 16 } 17 18 #if 0 /* For the original System V signal */ 19 signal(SIGINT, &sigint_handler); 20 #endif 21 } 22 23 main() 24 { 25 signal(SIGINT, &sigint_handler); 26 27 for (;;) { 28 printf("main: sigint_count(%d), calling pause ....\n", 29 sigint_count); 30 31 pause(); 32 33 printf("main: return from pause. sigint_count(%d)\n", 34 sigint_count); 35 } 36 }

5行目の volatile sig_atomic_t は見慣れないかもしれないが，その説明は後述する．

コンパイル，実行すると以下のようになる． Ctrl-C は ^C として表示される．送られてきたシグナルの番号がシグナルハンドラ sigint_handler の引数になるため，SIGINT の番号である 2 が sigint_handler の引数として渡されているのがわかる．

% ./a.out int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

sigaction システムコールは，第1引数にシグナル番号，第2引数に設定するシグナルの動作を指定して呼び出すと，第3引数に古い設定が返される．

上記の問題点におけるPOSIXシグナルのデフォルトの動作は次のようになっている．

システムコールを呼び出しブロックしている時の動作：
古い signal と同じく，システムコールはキャンセルされ EINTR というエラーが返される．

シグナルハンドラのマスクとリセット：
この点ついてはBSD UNIXと同じでる．シグナルハンドラの実行中に同じシグナルが通知されたら，そのシグナルは保留され，現在実行中のシグナルハンドラ処理の終了を待ち，もう一度シグナルハンドラを起動する．また，シグナルハンドラはリセットされない．

どちらの点についても，設定により古い signal 又は BSD UNIX の動作をさせることができるようになっている．

シグナルの動作は以下の struct sigaction を用いて設定する．

struct sigaction { union { void (*__sa_handler)(int); void (*__sa_sigaction)(int, struct __siginfo *, void *); } __sigaction_u; /* signal handler */ int sa_flags; /* see signal options below */ sigset_t sa_mask; /* signal mask to apply */ }; #define sa_handler __sigaction_u.__sa_handler #define sa_sigaction __sigaction_u.__sa_sigaction

sa_handler　シグナルハンドラ
sa_sigaction　より詳しいシグナル情報を引数に受け取ることのできるシグナルハンドラ．sa_flags に SA_SIGINFO を加えることで sa_handler の代わりに使用できるようになる．
sa_mask　シグナルハンドラ起動時に，対応するシグナルの他にマスクしたいシグナル
sa_flags　動作の詳細を設定するフラグ
sa_restorer　オブソリート（使用してはいけない）

古い signal のプログラムを，sigaction で sa_handler を使うように変更すると以下のようになる．基本的には全く同じであるが，若干異なっている．

24行目：スタック上に取られるローカル変数の初期値は不定であるため，struct sigaction 型の変数 sa_sigint をゼロクリア
25行目：シグナルハンドラは sigint_handler
26行目：sa_flags に SA_RESTART を設定し，シグナルにより中断されたシステムコールの処理は再開するように設定
28行目：sigaction によりシグナルを設定

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <signal.h> 4 #include <string.h> 5 6 volatile sig_atomic_t sigint_count = 3; 7 8 void 9 sigint_handler(int signum) 10 { 11 printf("sigint_handler(%d): sigint_count(%d)\n", 12 signum, sigint_count); 13 14 if (--sigint_count <= 0) { 15 printf("sigint_handler: exiting ... \n"); 16 exit(1); 17 } 18 } 19 20 main() 21 { 22 struct sigaction sa_sigint; 23 24 memset(&sa_sigint, 0, sizeof(sa_sigint)); 25 sa_sigint.sa_handler = sigint_handler; 26 sa_sigint.sa_flags = SA_RESTART; 27 28 if (sigaction(SIGINT, &sa_sigint, NULL) < 0) { 29 perror("sigaction"); 30 exit(1); 31 } 32 33 for (;;) { 34 printf("main: sigint_count(%d), calling pause ....\n", 35 sigint_count); 36 37 pause(); 38 39 printf("main: return from pause. sigint_count(%d)\n", 40 sigint_count); 41 } 42 }

上記プログラムの実行結果は，古い signal を用いた場合と同一であるので，省略．

同じプログラムを，sigaction で sa_sigaction を使うように変更したプログラムは以下のようになる．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <signal.h> 4 #include <string.h> 5 6 volatile sig_atomic_t sigint_count = 3; 7 8 void 9 sigint_action(int signum, siginfo_t *info, void *ctx) 10 { 11 printf("sigint_handler(%d): sigint_count(%d) signo(%d) code(0x%x)\n", 12 signum, sigint_count, info->si_signo, info->si_code); 13 14 if (--sigint_count <= 0) { 15 printf("sigint_handler: exiting ... \n"); 16 exit(1); 17 } 18 } 19 20 main() 21 { 22 struct sigaction sa_sigint; 23 24 memset(&sa_sigint, 0, sizeof(sa_sigint)); 25 sa_sigint.sa_sigaction = sigint_action; 26 sa_sigint.sa_flags = SA_RESTART | SA_SIGINFO; 27 28 if (sigaction(SIGINT, &sa_sigint, NULL) < 0) { 29 perror("sigaction"); 30 exit(1); 31 } 32 33 while (1) { 34 printf("main: sigint_count(%d), calling pause ....\n", 35 sigint_count ); 36 37 pause(); 38 39 printf("main: return from pause. sigint_count(%d)\n", 40 sigint_count ); 41 } 42 }

コンパイル，実行すると以下のようになる． Ctrl-C は ^C として表示される．通知されたシグナルについてより多くの情報を引数として受け取れるが，その詳細については SIGACTION(2) を参照．

% ./a.out 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <signal.h> 4 #include <string.h> 5 6 volatile sig_atomic_t sigint_count = 3; 7 8 main() 9 { 10 struct sigaction sa_ignore; 11 12 memset(&sa_ignore, 0, sizeof(sa_ignore)); 13 sa_ignore.sa_handler = SIG_IGN; 14 15 if (sigaction(SIGINT, &sa_ignore, NULL) < 0) { 16 perror("sigaction"); 17 exit(1); 18 } 19 20 while (1) { 21 printf("main: sigint_count(%d), calling pause() ....\n", 22 sigint_count ); 23 24 pause(); 25 26 printf("main: return from pause(). sigint_count(%d)\n", 27 sigint_count ); 28 } 29 }

コンパイル，実行すると以下のようになる． Ctrl-C は ^C，Ctrl-Z は ^Z として表示される．

% ./a.out #define SIG_DFL (void (*)(int))0 #define SIG_IGN (void (*)(int))1

kill

プロセスへシグナルを送るためには kill システムコールを使用する．引数に送り先のプロセスIDと送るシグナルを指定する．

int kill(pid_t pid, int sig);

以下は，引数にプロセスIDを指定し，そのプロセスに対し SIGINT を送るプログラムである．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <signal.h> 4 5 main(int argc, char *argv[]) 6 { 7 pid_t pid; 8 9 if (argc != 2) { 10 printf("Usage: %s pid\n", argv[0]); 11 exit(1); 12 } 13 14 pid = atoi(argv[1]); 15 16 if (pid <= 0) { 17 printf("Invalid pid: %d\n", pid); 18 exit(1); 19 } 20 21 if (kill(pid, SIGINT) < 0) { 22 perror("kill"); 23 exit(1); 24 } 25 }

シグナルハンドラ内での処理についての注意

上記のプログラムで，シグナルハンドラ内で値が変更される変数は，以下のように宣言している．

volatile sig_atomic_t sigint_count = 3;

sig_atomic_t は，割り込まれずに書き込みが可能な変数の型である． volatile は型修飾子と呼ばれるもので，型の前に付けて使用する． volatile を付けることで，コンパイラによる最適化が抑止され，この場合 sigint_count に対する読み書きは，必ずメモリに対して行なわれるようになる．

このような宣言が必要な理由は，シグナルハンドラの呼び出しが，関数呼び出しのようにプログラムの制御の流れに沿ったものではなく，プログラム外部のイベントに起因し非同期的に起こるものだからである．プログラムの制御の流れに沿っている場合，変数への読み書きはコンパイラの制御下にあるため，最適化により一時的にレジスタに置かれている変数の値が正しく参照される．しかし，シグナルハンドラは，本来のプログラムの制御の流れとは無関係に，プログラムの実行に割り込んで呼び出される．最適化により変数の値が一時的にレジスタに置かれているところにシグナルハンドラの呼び出しが起こった場合，シグナルハンドラはその最新の値にアクセスすることはできない．また，シグナルハンドラが変数の値を書き換えたとしても，割り込まれたプログラムはその変更に気がつかないこともあり得る．

volatile 宣言された変数に対する読み書きは，必ずメモリに対して行なわれるため，シグナルハンドラによる割り込みが起こっても，最新の値を参照することができる．また，sig_atomic_t は割り込まれずに書き込みが可能な変数の型を提供するため，変数の読み書きの途中で割り込まれることがない．そのため，一貫性のある値を読み書きすることができる．

シグナルハンドラは，本来のプログラムの制御の流に割り込んで呼び出されるため，プログラムの制御自体に矛盾を引き起こす場合もある．そのような矛盾を引き起こしてしまうライブラリ関数，システムコールは数多くあるため，シグナルハンドラ内で使用可能なライブラリ関数，システムコールは制限されている．

シグナルハンドラ内で使用可能な関数のリストについては sigaction(2) を参照のこと．

例えば，printf はシグナルハンドラ内で使用可能な関数のリストには含まれておらず，シグナルハンドラ内で使用するべきではない． write は使用可能なので，メッセージを出力する必要がある場合は，write を用いる．

インターバルタイマ

ある一定時間ごとに割り込みを発生させ，現在の処理を継続しながら別の処理，例えばプロンプトを点滅させたり，アニメーションを実行したり，又は割り込みをサポートしていないデバイスに対しポーリングを行ったりというようなこと，がしたい場合にはインターバルタイマという機能を使用する．インターバルタイマは setitimer システムコールを用いて設定できる．

int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);

インターバルタイマは第2引数で指定した時間が経つ（残り時間が 0 になる）とシグナルで通知するが，どのような時間なのかを，第1引数の which で以下のタイマーから1つを設定する．

ITIMER_REAL　実際に経過した時間が減少し，残り時間が 0 になったら SIGALRM が通知される
ITIMER_VIRTUAL　プロセスがユーザプログラムを実行している時間だけ減少し，残り時間が 0 になったら SIGVALRM が通知される
ITIMER_PROF　カーネル内も含めてプロセスが実行している時間だけ減少し，残り時間が 0 になったら SIGPROF が通知される

第2引数で時間を指定するために使用する struct itimerval とその中で使われている struct timeval の定義は以下のようになっている．

struct itimerval { struct timeval it_interval; /* next value */ struct timeval it_value; /* current value */ }; struct timeval { long tv_sec; /* seconds */ long tv_usec; /* microseconds */ };

it_value が 0 になると，which で指定されるタイマに対応するシグナルが通知される．そして，it_interval の値が次の時間として設定される． it_value, it_interval どちらの値も 0 になったタイマは停止する．

タイマをキャンセルするためには it_value に 0 を指定して，setitimer を呼び出せば良い．

以下は，ITIMER_REAL で実際の時間で 1 秒ごとにシグナルを受け，10回シグナルを受け取ると終了するプログラムである．終了する前にタイマをキャンセルしている．

1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <signal.h> 4 #include <string.h> 5 #include <sys/time.h> 6 7 volatile sig_atomic_t alrm_count = 10; 8 9 void alrm() 10 { 11 alrm_count--; 12 } 13 14 main() 15 { 16 struct sigaction sa_alarm; 17 struct itimerval itimer; 18 19 memset(&sa_alarm, 0, sizeof(sa_alarm)); 20 sa_alarm.sa_handler = alrm; 21 sa_alarm.sa_flags = SA_RESTART; 22 23 if (sigaction(SIGALRM, &sa_alarm, NULL) < 0) { 24 perror("sigaction"); 25 exit(1); 26 } 27 28 itimer.it_value.tv_sec = itimer.it_interval.tv_sec = 1; 29 itimer.it_value.tv_usec = itimer.it_interval.tv_usec = 0; 30 31 if (setitimer(ITIMER_REAL, &itimer, NULL) < 0) { 32 perror("setitimer"); 33 exit(1); 34 } 35 36 while (alrm_count) { 37 pause(); 38 printf("%d: %d\n", alrm_count, time(NULL)); 39 } 40 41 itimer.it_value.tv_sec = itimer.it_interval.tv_sec = 0; 42 itimer.it_value.tv_usec = itimer.it_interval.tv_usec = 0; 43 44 if (setitimer(ITIMER_REAL, &itimer, NULL) < 0) { 45 perror("setitimer"); 46 exit(1); 47 } 48 }

コンパイル，実行するといかのようになる．

% ./a.out

第1週	講義システムプログラムの目的ソフトウェアの構成とシステムプログラムプログラムの実行環境プログラムの開発環境プログラミングとデバッグポインタ（１）
第2週	文字，文字列のデータ表現標準入出力文字，文字列操作ライブラリポインタ（２）
第3週	ファイルアクセスファイルアクセス（応用）ポインタ（３）バッファオーバーフロー
第4週	プロセスの概念と機能プロセスの操作：プロセス作成，プログラム実行，プロセス終了リダイレクション，パイプその他のプロセス操作のためのシステムコール，ライブラリ関数
第5週	シグナル

抽象概念	ハードウェア機能
プロセス	プロセッサ，メモリ
ファイル，ディレクトリ	ストレージ
プロセス間通信	コンピュータ間の通信
シグナル	割り込み
アクセス制御	コンピュータ共有時の保護

上位3ビット→ ↓下位4ビット	0	1	2	3	4	5	6	7
0	NUL	DLE	SP	0	@	P	`	p
1	SOH	DC1	!	1	A	Q	a	q
2	STX	DC2	"	2	B	R	b	r
3	ETX	DC3	#	3	C	S	c	s
4	EOT	DC4	$	4	D	T	d	t
5	ENQ	NAC	%	5	E	U	e	u
6	ACK	SYN	&	6	F	V	f	v
7	BEL	ETB	'	7	G	W	g	w
8	BS	CAN	(	8	H	X	h	x
9	HT	EM	)	9	I	Y	i	y
A	LF/NL	SUB	*	:	J	Z	j	z
B	VT	ESC	+	;	K	[	k	{
C	FF	FS	,	<	L	＼	l	\|
D	CR	GS	-	=	M	]	m	}
E	SO	RS	.	>	N	^	n	~
F	SI	US	/	?	O	_	o	DEL

下位4ビット→ ↓上位4ビット	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
A0		亜	唖	娃	阿	哀	愛	挨	姶	逢	葵	茜	穐	悪	握	渥
B0	旭	葦	芦	鯵	梓	圧	斡	扱	宛	姐	虻	飴	絢	綾	鮎	或
C0	粟	袷	安	庵	按	暗	案	闇	鞍	杏	以	伊	位	依	偉	囲
D0	夷	委	威	尉	惟	意	慰	易	椅	為	畏	異	移	維	緯	胃
E0	萎	衣	謂	違	遺	医	井	亥	域	育	郁	磯	一	壱	溢	逸
F0	稲	茨	芋	鰯	允	印	咽	員	因	姻	引	飲	淫	胤	蔭

条件			戻り値
s1	<	s2	0より小さい数
s1	==	s2	0
s1	>	s2	0より大きい数

SEEK_SET	ファイルの先頭から offset バイト目に移動．
SEEK_CUR	現在の位置から offset バイト目に移動．
SEEK_END	ファイルの末尾から offset バイト目に移動．

テキスト領域	プログラムの機械語命令が置かれる．この領域は読み出し専用になっており，同じプログラムから起動されるプロセスの間で共有可能になっている．
データ領域（初期値あり）	プログラム中に指定された 0 以外の初期値を持つ大域 (global) 変数，静的局所 (static local) 変数が置かれる．
データ領域（初期値なし）	通称 BSS (Block Started by Symbol) セグメント．初期値を持たない，又は初期値が 0 の大域変数，静的局所変数が置かれる．プロセス作成時に確保され，0 に初期化される．変数の名前（シンボル）だけなのが名前の由来．
ヒープ領域	malloc()などにより，プロセス実行時に確保されるデータ領域．
共有ライブラリ	共有ライブラリのため領域はヒープとスタックの間にとられる．テキスト領域と同じく読み出し専用で，他のプログラムと共有される．
スタック領域	C言語の自動変数（staticでないローカル変数）や，引数，関数呼び出し時の戻り番地などが置かれる．
引数，環境変数	コマンドに渡される引数，環境変数は，スタック領域の最上位部分に格納されている．

シェル（sh, ksh, bash, zsh, csh, tcsh）	コマンドの実行（プロセス作成，プログラム実行），リダイレクション，パイプ，その他．．．
ps, pstree, top	プロセスの観察
kill	プロセスの（強制）終了
nice	プロセスの実行優先順位の制御
limit	プロセスの利用可能資源の制御
gdb	デバッグツール

下位4ビット→ ↓上位4ビット	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
A0		亜	唖	娃	阿	哀	愛	挨	姶	逢	葵	茜	穐	悪	握	渥
B0	旭	葦	芦	鯵	梓	圧	斡	扱	宛	姐	虻	飴	絢	綾	鮎	或
C0	粟	袷	安	庵	按	暗	案	闇	鞍	杏	以	伊	位	依	偉	囲
D0	夷	委	威	尉	惟	意	慰	易	椅	為	畏	異	移	維	緯	胃
E0	萎	衣	謂	違	遺	医	井	亥	域	育	郁	磯	一	壱	溢	逸
F0	稲	茨	芋	鰯	允	印	咽	員	因	姻	引	飲	淫	胤	蔭

目次

オペレーティングシステム（OS: Operating System）とは

API（Application Program Interface）を用いたプログラミング

プログラムの種類

UNIX OSの構成要素

シェル

XウィンドウシステムとGUI（Graphical User Interface）

コマンド，アプリケーション

サーバ，デーモン

システムコール，ライブラリ，ミドルウェア

UNIXカーネル

プログラム，ライブラリ関数，システムコールの関係

プログラムとプロセスの関係

プロセスの観察

※注意※

コンパイルとリンク

コンパイル・実行・修正

ccにより起動されるプログラム

リンク

動的リンクと静的リンク

デバッグ

& と * の関係

ポインタを使うとできること

ポインタを使う時に気をつけること

関数間でのポインタ値の受け渡し

その他よくある間違い

文字コード

EUC-JP

バックスラッシュ「＼」と円マーク「\」

さらに詳しい解説

C言語における文字と文字列

文字

文字列

文字操作

文字列の長さ

文字列の比較

文字や文字列の検索

文字列のコピー，連結（１）

文字列のコピー，連結（２）

動的メモリ確保

mallocとfree

使用上の注意

メモリリーク

ライブラリを用いたファイルとの入出力

FILE構造体

ファイルのコピー

システムコールを用いたファイルとの入出力

ファイルディスクリプタ

標準入出力のファイルディスクリプタ

ファイルのコピー

ライブラリとシステムコールの混在

ファイルのランダムアクセス

構造体の入出力

sizeof

utmpデータの読み込み

構造体の入出力と動的メモリ確保

バッファへのポインタ

プログラムとプロセス

プロセスの機能

資源割り当て

保護

プロセスのメモリマップ

プロセスを操作するコマンド

プロセスの作成とプログラムの実行

概要

プログラム例（fork）

プログラム実行のためのライブラリ関数

リダイレクション

概要

プログラム例

プロセス強制終了

メモリ領域確保

簡単なプログラム実行

その他のシステムコール

概要

入出力機器

ポーリングと割込み

例外

シグナル

シグナルを用いたプログラミング

下位4ビット→ ↓上位4ビット	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F
A0		亜	唖	娃	阿	哀	愛	挨	姶	逢	葵	茜	穐	悪	握	渥
B0	旭	葦	芦	鯵	梓	圧	斡	扱	宛	姐	虻	飴	絢	綾	鮎	或
C0	粟	袷	安	庵	按	暗	案	闇	鞍	杏	以	伊	位	依	偉	囲
D0	夷	委	威	尉	惟	意	慰	易	椅	為	畏	異	移	維	緯	胃
E0	萎	衣	謂	違	遺	医	井	亥	域	育	郁	磯	一	壱	溢	逸
F0	稲	茨	芋	鰯	允	印	咽	員	因	姻	引	飲	淫	胤	蔭