インテルの486以降のx86系のCPUには、4段階の特権レベルがある。

特権レベルの数が小さくなれば、強い権限になるという。
権限とは何かですが、それは、すぐ後に説明します。

カーネルプログラムは特権レベルが「0」です。
アプリケーションプログラムは「3」です。

カーネルプログラムは権限が強いという意味です。

通常、特権レベル「0」の状態で動いている事を「カーネルモード」と呼び、
特権レベル「3」の状態で動いている事を「ユーザーモード」と呼ぶ

特権レベル「0」で動いているカーネルプログラムは、同じ特権レベルの
プログラムやデータや、特権レベルの低いアプリケーションの
プログラムやデータにアクセスできる。

だが、特権レベル「3」のアプリケーションプログラムの場合、
直接、カーネルのプログラムやデータにアクセスできないようなっている。
それは、勝手にアプリケーションからカーネルのプログラムや
データにアクセスして、悪さなどを行わないようにするための
保護機能として存在している。

#include <stdio.h>

int main(void)
{
    int a[1] ,i ;

    for ( i = 0 ; i < 1000 ; i++ )
	{
	a[i] = i ;
	printf("address = %p : i = %d\n",&a[i],i);
	}

    return(0);
}

suga@jitaku[~/pro]%  ./sig0
address = 0xbffff7d4 : i = 0
address = 0xbffff7d8 : i = 1

(途中、省略）

address = 0xbffffff8 : i = 521
address = 0xbffffffc : i = 522
セグメントエラー
suga@jitaku[~/pro]% 

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

void shori(int sig)
{
    printf("メモリの領域の不正侵入をしました。自害するのらー！！\n");
    exit(1);
}

int main(void)
{
    int a[1] ,i ;

    (void)signal(SIGSEGV,shori);

    for ( i = 0 ; i < 1000 ; i++ )
	{
	a[i] = i ;
	printf("address = %p : i = %d\n",&a[i],i);
	}

    return(0);
}

suga@jitaku[~/pro]%  ./sig1
address = 0xbffff7d4 : i = 0
address = 0xbffff7d8 : i = 1

(途中、省略）

address = 0xbffffff8 : i = 521
address = 0xbffffffc : i = 522
メモリの領域の不正侵入をしました。自害するのらー！！
suga@jitaku[~/pro]% 

インテルの32ビットの80x86CPUの場合、仮想メモリエリアは4Gバイトになる。
Linuxでは1〜3Gまでのエリアをプロセス用に、3G以降をカーネルエリアに
割り当てている。ここでの番地は論理メモリ(リニアアドレス)です。
番地「0xc0000000」は、カーネルエリアの先頭の番地を表します。

これがメモリの話で、お馴染みの論理アドレスと物理アドレスの違いです。
論理アドレス(リニアアドレス)では、それぞれのプロセスが個々に
割り当てられているが、実際に、見ている物理アドレスは別の所を指している。
そのため、ユーザープロセス同士が、お互いのメモリエリアを見る事は
できない仕組みになっている。つまり、違うプロセスへのメモリ領域に
侵入するのは不可能なため、衝突は起こり得ないのだ。

#include <stdio.h>

int main(void)
{
    int *a ;

    a = (int *)0x2141342 ;

    *a = 5 ;

    printf("a = %d\n",*a);

    return(0);
}

[suga@xxx kmem]$ ./user1
[suga@xxx kmem]$ Segmentation fault

ユーザープロセスには先頭から3G分、リニアアドレスが割り当てられている。
しかし、プロセス実行時に使える範囲を管理しているのは、カーネルだ。
上図のように、カーネルがプロセスに使える範囲を割り当てている。
もし、それ以外の範囲を使おうとしたら以下のようになる。

特権モードで動くドライバは、カーネルのメモリ領域で
バッファオーバーフローを起こすため、カーネルの大事なエリアを破壊し
カーネルがフリーズしてしまう事がある。

「システムゲート」の事を「コールゲート」という場合もある。

普通、ユーザーモードから特権モードのプログラムは扱えないのだが、
システムコールを使えば、システムゲートと呼ばれる門をくぐり抜け
限定的な範囲で特権モードのプログラムが使えるようになる。

例えば、ハードディスクへ書き込みを行う場合、ユーザープロセスは
write()システムコールを発行する。
そして、write()を経由して、カーネルはドライバを操作して
データをハードディスクへ書き込む。

システムコール「abc()」がアプリケーション側で呼び出した場合、
その処理を行うのは、カーネル側のプログラム中にある
「sys_abc()」という関数だ。sys_が頭についた形になる。

そのため、flock()の処理は、sys_flock()で定義されている。

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
int a ;
printf("memory = %p\n",&a);
return(&a);
}

普通のプログラムからflock()システムコールを呼び出した時に、
宣言した変数のアドレスを表示させ、しかも、返り値として
そのアドレスを返すプログラムにした。

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
int a ;
printk("memory = %p\n",&a);
return(&a);
}

printf()関数をprintk()関数に置き換えた。

printk()関数は、カーネルのメッセージを表示させるための関数で、
カーネルのソース kernel/printk.c で定義されている。

この時点ではprintk()関数の正しい使い方など知らなかった。
単にカーネルソース上で、メッセージを出力するための、
よく見かける関数という程度の認識だった (^^;;

Feb  4 14:40:34 xxx kernel: VFS: Mounted root (ext2 filesystem) readonly.
Feb  4 14:40:34 xxx kernel: Freeing unused kernel memory: 280k freed
Feb  4 14:40:34 xxx kernel: Adding Swap: 289160k swap-space (priority -1)
Feb  4 14:40:34 xxx kernel: ide-floppy driver 0.99.newide
Feb  4 14:40:34 xxx kernel: hdc: driver not present
Feb  4 14:40:34 xxx kernel: memory = c723bfb8
Feb  4 14:40:34 xxx kernel: memory = c723bfb8
Feb  4 14:40:34 xxx kernel: memory = c723bfb8
Feb  4 14:40:34 xxx kernel: memory = c723bfb8
Feb  4 14:40:34 xxx keytable: Loading keymap:  succeeded
Feb  4 14:40:34 xxx keytable: Loading system font:  succeeded

これを見た時、カーネルの書き換えができたと喜びつつも、
結構、ファイルロックに関するflock()システムコールが使われていたので、
システムファイルなどに不整合が起こらないか心配になりました (^^;;

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>


int main(void)
{
  int i ;

  i = flock(1,1,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

[suga@xxx kmem]$ ./kmem0
memory = c723bfb8
memory = 0xc723bfb8
[suga@xxx kmem]$

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  /* fdはファイルディスクリプタ */

  /*  宣言した変数の番地を返り値として返す */
  if ( fd == 999 )
     {
     int a ;
     return(&a);
     }

error = -EBADF;
filp = fget(fd);
if (!filp)
goto out;

(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>


int main(void)
{
  int i ;

  i = flock(999,5,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

[suga@xxx kmem]$ ./kmem1
memory = 0xc5fcbf80
[suga@xxx kmem]$

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  /* fdはファイルディスクリプタ */

  /*  カーネルメモリ上に、シェルを走らせるコードを仕込む 
      そして、バッファオーバーフローを起こして、
      カーネルモードでシェルを走らせてみる */
  if ( fd == 9999 )
     {
     int a[2] ;
     int i ;
     const char shellcode[] = {
          0x31, 0xc0, 0x31, 0xd2, 0xeb, 0x11, 0x5b, 0x88,
          0x43, 0x07, 0x89, 0x5b, 0x08, 0x89, 0x43, 0x0c,
          0x8d, 0x4b, 0x08, 0xb0, 0x0b, 0xcd, 0x80, 0xe8,
          0xea, 0xff, 0xff, 0xff, 0x2f, 0x62, 0x69, 0x6e,
          0x2f, 0x73, 0x68, 0x00 } ;

     for ( i = 0 ; i < 20 ; i++ )
       {
       a[i] = (int)shellcode;
       }

     return(0);
     }

(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>

int main(void)
{
  int fd , i ;

  i = flock(9999,5,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

[suga@xxx kmem]$ ./kmem2
<1>Unable to handle kernel paging request at virtual address 85818580
 printing eip:
c5fcbf84
*pde = 00000000
Oops: 0000

CPU:    0
EIP:    0010:[<c5fcbf84>]    Not tainted
EFLAGS: 00010286

EIP is at ___strtok_R29805c13 [] 0x5c6b0d4 (2.4.18-3custom)
eax: 00000000   ebx: c5fcbf84   ecx: c5fcbf84   edx: ffffffff
esi: c5fcbf84   edi: c5fcbf84   ebp: bffffb48   esp: c5fcbfc4
ds: 0018   es: 0018   ss: 0018
Process kmem2 (pid: 801, stackpage=c5fcb000)
Stack: c5fcbf84 00000005 4213030c 40013020 bffffbb4 bffffb48 0000008f 0000002b
       0000002b 0000008f 420daf21 00000023 00000246 bffffb2c 0000002b
Call Trace:

Code: 14 8a 10 c0 90 bf fc c5 00 00 00 00 84 bf fc c5 84 bf fc c5
Segmentation fault

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  /* fdはファイルディスクリプタ */

 if ( fd == 888 )
     {
       int a ;
       int b ;
       int c ;
       int d ;

       printk("a = %p : b = %p : c = %p : d = %p\n",&a,&b,&c,&d);
       return(&a);
     }

(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>


int main(void)
{
  int i ;

  i = flock(888,5,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

[suga@xxx kmem]$ ./kmem4
a = c5fd7ee4 : b = c5fd7ee8 : c = c5fd7eec : d = c5fd7ef0
memory = 0xc5fd7ee4
[suga@xxx kmem]$

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  /* fdはファイルディスクリプタ */

  /*  バッファオーバーフローを起こして、カーネル領域の
      大事な部分を破壊して、Linuxを固まらせる */
  if ( fd == 99999 )
     {
      int i ;
      int a[1] ;

      for ( i = 0 ; i < 10000 ; i++ )
          {
          a[i] = i ;
          }
    return(0);
    }

(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>


int main(void)
{
  int i ;

  i = flock(99999,5,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

struct task_struct {
        /*
         * offsets of these are hardcoded elsewhere - touch with care
         */
        volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
        unsigned long flags;    /* per process flags, defined below */
        int sigpending;
        mm_segment_t addr_limit;        /* thread address space:
                                                0-0xBFFFFFFF for user-thead
                                                0-0xFFFFFFFF for kernel-thread
                                         */
        struct exec_domain *exec_domain;
        volatile long need_resched;
        unsigned long ptrace;

        int lock_depth;         /* Lock depth */

        /*
         * offset 32 begins here on 32-bit platforms.
         */
        unsigned int cpu;
        int prio, static_prio;
        list_t run_list;
        prio_array_t *array;

        unsigned long sleep_avg;
        unsigned long sleep_timestamp;

        unsigned long policy;
        unsigned long cpus_allowed;
        unsigned int time_slice;

        task_t *next_task, *prev_task;

        struct mm_struct *mm, *active_mm;


/* task state */
        struct linux_binfmt *binfmt;
        int exit_code, exit_signal;
        int pdeath_signal;  /*  The signal sent when the parent dies  */
        /* ??? */
        unsigned long personality;
        int did_exec:1;
        pid_t pid;
        pid_t pgrp;
        pid_t tty_old_pgrp;
        pid_t session;
        pid_t tgid;
        /* boolean value for session group leader */
        int leader;
        /* 
         * pointers to (original) parent process, youngest child, younger sibling,
         * older sibling, respectively.  (p->father can be replaced with 
         * p->p_pptr->pid)
         */
        task_t *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
        struct list_head thread_group;

        /* PID hash table linkage. */
        task_t *pidhash_next;
         task_t **pidhash_pprev;

        wait_queue_head_t wait_chldexit;        /* for wait4() */
        struct completion *vfork_done;          /* for vfork() */
        unsigned long rt_priority;
        unsigned long it_real_value, it_prof_value, it_virt_value;
        unsigned long it_real_incr, it_prof_incr, it_virt_incr;
        struct timer_list real_timer;
        struct tms times;
        unsigned long start_time;
        long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS];
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
        unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
        int swappable:1;
/* process credentials */
        uid_t uid,euid,suid,fsuid;
        gid_t gid,egid,sgid,fsgid;
        int ngroups;
        gid_t   groups[NGROUPS];
        kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
        int keep_capabilities:1;
        struct user_struct *user;
/* limits */
        struct rlimit rlim[RLIM_NLIMITS];
        unsigned short used_math;
        char comm[16];
/* file system info */
        int link_count, total_link_count;
        struct tty_struct *tty; /* NULL if no tty */
        unsigned int locks; /* How many file locks are being held */
/* ipc stuff */
        struct sem_undo *semundo;
         struct sem_queue *semsleeping;
/* CPU-specific state of this task */
        struct thread_struct thread;
/* filesystem information */
        struct fs_struct *fs;
/* open file information */
        struct files_struct *files;
/* namespace */
        struct namespace *namespace;
/* signal handlers */
        spinlock_t sigmask_lock;        /* Protects signal and blocked */
        struct signal_struct *sig;

        sigset_t blocked;
        struct sigpending pending;

        unsigned long sas_ss_sp;
        size_t sas_ss_size;
        int (*notifier)(void *priv);
        void *notifier_data;
        sigset_t *notifier_mask;

        /* TUX state */
        void *tux_info;
        void (*tux_exit)(void);


/* Thread group tracking */
        u32 parent_exec_id;
        u32 self_exec_id;
/* Protection of (de-)allocation: mm, files, fs, tty */
        spinlock_t alloc_lock;

/* journalling filesystem info */
        void *journal_info;
};

普段から思う事だが、英語の読み方を訳さずに、発音をカタカナにして
コンピューター用語にしている場合が多いと感じる。
日本語の柔軟性といえば、そうなのだが、学習者にとっては
とっつきにくくしている側面もある。

英語国民だと、コンピューター用語は英語から派生している場合が多いので、
造語でない限り、用語から意味の類推が可能になる。
英語国民の場合、コンピューターの学習も楽だと考えられる。

「日本語に訳せない用語まで訳せ」とは書かないが、翻訳本の中には、
訳せば良い用語まで、英語の発音をカタカナ表記して使っているため、
内容を見ても、何を書いてあるのか理解できない場合もあったりする。
英和辞典を引いて調べたりするのだが、カタカナから綴りを連想してから
辞書を調べるのは手間がかかったりする。

「頼むから用語は訳してくれー！！」と思う今日この頃・・・ (--;;

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  if ( fd == 444 )
     {
       int a ;
       /* 実行中のプロセスのユーザーID をrootの「0」にする */
       current->uid = 0 ;

       return(&a);
     }

(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
  int fd , i ;

  /* ここでUIDをrootの「0」に書き換える */
  i = flock(444,5,F_GETLK);

  /* rootでシェルを走らせる */
  system("/bin/sh");

  return(0);
}

[suga@xxx buf]$ id
uid=500(suga) gid=500(suga) groups=500(suga)
[suga@xxx buf]$ ./kmem7
sh-2.05a# id
uid=0(root) gid=500(suga) groups=500(suga)

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  if ( fd == 1000 )
     {
     int a ;
     /* カレントプロセスのアドレスの表示 */
     printk("current process address = %p\n",current);
     return(&a);
     }

(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>

int main(void)
{
  int fd , i ;

  i = flock(1000,5,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

[suga@xxx buf]$ ./kmem9
current process address = c5fde000
memory = 0xc5fdfed4
[suga@xxx buf]$

[suga@xxx buf]$ ./kmem9 & ./kmem9 & ./kmem9
[1] 856
[2] 857
current process address = c59ba000
memory = 0xc59bbed4
current process address = c5bf8000
memory = 0xc5bf9ed4
current process address = c55ae000
memory = 0xc55afed4

ユーザープロセスが、システムコールで特権モードになった時、
カーネルプログラムで宣言した変数は、カーネルスタックと
呼ばれる領域に保管される。

このカーネルスタックは、ユーザープロセスのスタック領域と同様に
メモリの下位から上位へと積み重なる形になる。

プロセスディスクリプタと、そのプロセスが使うカーネルスタック領域は
プロセスごとにセットとして存在する。
カーネルスタックを使う量は、少ないという事で、セットの合計は
Linux-2.4.18では、8Kバイトという量になっている。

#include <stdio.h>

int main(void)
{

  int a ;
  int b ;
  int c ;
  int d ;

  printf("a = %p : b = %p : c = %p : d = %p\n",&a,&b,&c,&d);

  return(0);
}

[suga@xxx buf]$ gcc com1.c -o com1
[suga@xxx buf]$ gcc com1.c -o com1-1 -O2
[suga@xxx buf]$ ./com1
a = 0xbffffa14 : b = 0xbffffa10 : c = 0xbffffa0c : d = 0xbffffa08
[suga@xxx buf]$ ./com1-1
a = 0xbffff9f8 : b = 0xbffff9fc : c = 0xbffffa00 : d = 0xbffffa04
[suga@xxx buf]$

ピンクの部分は最適化オプションをつけなかった場合の結果。
青の部分は最適化オプションをつけた場合の結果。

ピンクの部分は変数を宣言した順番にメモリの上位へ積み重なっている。
だが、青い部分は変数を宣言した順番にメモリの下位へいっている。
全く反対になっているのだ。

cc  -D__KERNEL__ -I/usr/src/linux-2.4.18-s4/include -Wall 
                 -Wstrict-prototypes -Wno-trigraphs -O2 
                  -fomit-frame-pointer -fno-strict-aliasing 
                  -fno-common -Wno-unused -pipe
		  -mpreferred-stack-boundary=2
                  -march=i686 -DKBUILD_BASENAME=locks
		  -c -o locks.o locks.c

ユーザープロセスには先頭から3G分、リニアアドレスが割り当てられている。
しかし、プロセス実行時に使える範囲を管理しているのは、カーネルだ。
上図のように、カーネルがプロセスに使える範囲を割り当てている。

プロセスディスクリプタは、プロセスが使っているメモリ情報に関する
メモリディスクリプタを指している。
メモリディスクリプタは、使えるメモリの範囲を記録している
メモリリージョンを指している。

ちなみに、メモリディスクリプタのデータ構造の、mm_struct構造体は
include/linux/sched.hに定義されています。

メモリリージョンのデータ構造の、vm_area_struct構造体は
include/linux/mm.hに定義されています。

asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
{
struct file *filp;
int error, type;

  if ( fd == 1003 )
     {
       int i , count ,a ;
       struct vm_area_struct *region ;

       /* メモリリージョンの数 */
       count = (int)current->mm->map_count ;

       /* メモリディスクリプタの情報を抜粋 */
       printk("count = %d\n",count);

       /* プロセスの実行コードの領域の先頭と終端アドレス */
       printk("code start  = %p\n",current->mm->start_code);
       printk("code end    = %p\n",current->mm->end_code);

       /* プロセスのヒープ領域の先頭と終端アドレス */
       printk("heap start  = %p\n",current->mm->start_brk);
       printk("heap end    = %p\n",current->mm->brk);

       /* プロセスのスタック領域の先頭アドレス */
       printk("stack start = %p\n",current->mm->start_stack);

       region = current->mm->mmap ; /* メモリリージョンの先頭 */
       for ( i = 0 ; i < count ; i++ )
           {
           printk("no%d : start = %p\n",i+1,region->vm_start);
           printk("no%d : end   = %p\n",i+1,region->vm_end-1);
           region = region->vm_next ; /* 次のメモリリージョン */
           }
       return(&a);
     }


(以下省略)
}

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>

int main(void)
{
  int i ;

  i = flock(1003,5,F_GETLK);

  printf("memory = %p\n",i);

  return(0);
}

[suga@xxx buf]$ ./kmem12
count = 8
code start  = 08048000
code end    = 08048535
heap start  = 08049664
heap end    = 0804a000
stack start = bffffbb0
no1 : start = 08048000
no1 : end   = 08048fff
no2 : start = 08049000
no2 : end   = 08049fff
no3 : start = 40000000
no3 : end   = 40012fff
no4 : start = 40013000
no4 : end   = 40013fff
no5 : start = 42000000
no5 : end   = 4212bfff
no6 : start = 4212c000
no6 : end   = 42130fff
no7 : start = 42131000
no7 : end   = 42134fff
no8 : start = bfffe000
no8 : end   = bfffffff
memory = 0xc6343ec8