����12-8 linux/fs/block_dev.c


  1 /*

  2  *  linux/fs/block_dev.c

  3  *

  4  *  (C) 1991  Linus Torvalds

  5  */

  6

  7 #include <errno.h>        // �����ͷ�ļ�������ϵͳ�и��ֳ����š�

  8

  9 #include <linux/sched.h>  // ���ȳ���ͷ�ļ�������������ṹtask_struct������0�����ݣ�

                              // ����һЩ�й��������������úͻ�ȡ��Ƕ��ʽ��ຯ������䡣

 10 #include <linux/kernel.h> // �ں�ͷ�ļ�������һЩ�ں˳��ú�����ԭ�ζ��塣

 11 #include <asm/segment.h>  // �β���ͷ�ļ����������йضμĴ���������Ƕ��ʽ��ຯ����

 12 #include <asm/system.h>   // ϵͳͷ�ļ������������û��޸�������/�ж��ŵȵ�Ƕ��ʽ���ꡣ

 13

    // �豸���ݿ�����ָ�����顣ÿ��ָ����ָ��ָ�����豸�ŵ��ܿ�������hd_sizes[]������

    // ��������ÿһ���Ӧ���豸��ȷ����һ�����豸����ӵ�е����ݿ�������1���С = 1KB����

 14 extern int *blk_size[];              // blk_drv/ll_rw_blk.c��49�С�

 15

    //// ���ݿ�д���� - ��ָ���豸�Ӹ���ƫ�ƴ�д��ָ���������ݡ�

    // ������dev - �豸�ţ�pos - �豸�ļ���ƫ����ָ�룻buf - �û��ռ��л�������ַ��

    // count - Ҫ���͵��ֽ�����

    // ������д���ֽ�������û��д���κ��ֽڻ�������򷵻س����š�

    // �����ں���˵��д����������ٻ�������д�����ݡ�ʲôʱ����������д���豸���ɸ��ٻ�

    // �������������������ġ����⣬��Ϊ���豸���Կ�Ϊ��λ���ж�д����˶���д��ʼλ��

    // �����ڿ���ʼ��ʱ����Ҫ�Ƚ���ʼ�ֽ����ڵ������������Ȼ����Ҫд�����ݴ�д��ʼ��

    // ��д���ÿ飬�ٽ�������һ������д�̣������ɸ��ٻ������ȥ��������

 16 int block_write(int dev, long * pos, char * buf, int count)

 17 {

    // �������ļ���λ��pos����ɿ�ʼ��д�̿�Ŀ����block���������д��1�ֽ��ڸÿ���

    // ��ƫ��λ��offset��

 18         int block = *pos >> BLOCK_SIZE_BITS;         // pos�����ļ����ݿ�š�

 19         int offset = *pos & (BLOCK_SIZE-1);          // pos�����ݿ���ƫ��ֵ��

 20         int chars;

 21         int written = 0;

 22         int size;

 23         struct buffer_head * bh;

 24         register char * p;                   // �ֲ��Ĵ���������������ڼĴ����С�

 25

    // ��дһ�����豸�ļ�ʱ��Ҫ��д�������ݿ�����Ȼ���ܳ���ָ���豸��������������ݿ���

    // ���������������ȡ��ָ���豸�Ŀ�����size���ȽϺ����ƺ�������������д�����ݳ��ȡ�

    // ���ϵͳ��û�ж��豸ָ�����ȣ���ʹ��Ĭ�ϳ���0x7fffffff��2GB���飩��

 26         if (blk_size[MAJOR(dev)])

 27                 size = blk_size[MAJOR(dev)][MINOR(dev)];

 28         else

 29                 size = 0x7fffffff;

    // Ȼ�����Ҫд����ֽ���count��ѭ��ִ�����²�����ֱ������ȫ��д�롣��ѭ��ִ�й���

    // �У�����ǰд�����ݵĿ���Ѿ����ڻ����ָ���豸���ܿ������򷵻���д�ֽ������˳���

    // Ȼ���ټ����ڵ�ǰ���������ݿ��п�д����ֽ����������Ҫд����ֽ������һ�飬��

    // ô��ֻ��дcount�ֽڡ��������Ҫд1���������ݣ���ֱ������1����ٻ���飬������

    // �����ݷ��뼴�ɡ��������Ҫ���뽫��д�벿�����ݵ����ݿ飬��Ԥ�����������ݡ�Ȼ��

    // ��ŵ��� 1��Ϊ�´β�������׼���������������ʧ�ܣ��򷵻���д�ֽ��������û��д

    // ���κ��ֽڣ��򷵻س����ţ���������

 30         while (count>0) {

 31                 if (block >= size)

 32                         return written?written:-EIO;

 33                 chars = BLOCK_SIZE - offset;            // �����д����ֽ�����

 34                 if (chars > count)

 35                         chars=count;

 36                 if (chars == BLOCK_SIZE)

 37                         bh = getblk(dev,block);         // buffer.c ��206��322�С�

 38                 else

 39                         bh = breada(dev,block,block+1,block+2,-1);

 40                 block++;

 41                 if (!bh)

 42                         return written?written:-EIO;

    // �����Ȱ�ָ��pָ��������ݵĻ�����п�ʼд�����ݵ�λ�ô��������һ��ѭ��д�����

    // �ݲ���һ�飬����ӿ鿪ʼ����д���޸ģ�������ֽڣ����������Ԥ������offsetΪ�㡣

    // �˺��ļ���ƫ��ָ��posǰ�ƴ˴ν�Ҫд���ֽ���chars�����ۼ���ЩҪд���ֽ�����ͳ

    // ��ֵwritten�С��ٰѻ���Ҫд�ļ���ֵcount ��ȥ�˴�Ҫд���ֽ���chars��Ȼ�����Ǵ�

    // �û�����������chars���ֽڵ�pָ��ĸ��ٻ�����п�ʼд���λ�ô���������������

    // �û����������޸ı�־�����ͷŸû�������Ҳ���û��������ü����ݼ�1����

 43                 p = offset + bh->b_data;

 44                 offset = 0;

 45                 *pos += chars;

 46                 written += chars;                     // �ۼ�д���ֽ�����

 47                 count -= chars;

 48                 while (chars-->0)

 49                         *(p++) = get_fs_byte(buf++);

 50                 bh->b_dirt = 1;

 51                 brelse(bh);

 52         }

 53         return written;                           // ������д����ֽ����������˳���

 54 }

 55

    //// ���ݿ������ - ��ָ���豸��λ�ô�����ָ���������ݵ��û��������С�

    // ������dev - �豸�ţ�pos - �豸�ļ���ƫ����ָ�룻buf - �û��ռ��л�������ַ��

    // count - Ҫ���͵��ֽ�����

    // �����Ѷ����ֽ�������û�ж����κ��ֽڻ�������򷵻س����š�

 56 int block_read(int dev, unsigned long * pos, char * buf, int count)

 57 {

 58         int block = *pos >> BLOCK_SIZE_BITS;

 59         int offset = *pos & (BLOCK_SIZE-1);

 60         int chars;

 61         int size;

 62         int read = 0;

 63         struct buffer_head * bh;

 64         register char * p;                    // �ֲ��Ĵ���������������ڼĴ����С�

 65

    // �ڶ�һ�����豸�ļ�ʱ��Ҫ����������ݿ�����Ȼ���ܳ���ָ���豸��������������ݿ���

    // ���������������ȡ��ָ���豸�Ŀ�����size���ȽϺ����ƺ������������Ķ������ݳ��ȡ�

    // ���ϵͳ��û�ж��豸ָ�����ȣ���ʹ��Ĭ�ϳ���0x7fffffff��2GB���飩��

 66         if (blk_size[MAJOR(dev)])

 67                 size = blk_size[MAJOR(dev)][MINOR(dev)];

 68         else

 69                 size = 0x7fffffff;

    // Ȼ�����Ҫ������ֽ���count��ѭ��ִ�����²�����ֱ������ȫ�����롣��ѭ��ִ�й���

    // �У�����ǰ�������ݵĿ���Ѿ����ڻ����ָ���豸���ܿ������򷵻��Ѷ��ֽ������˳���

    // Ȼ���ټ����ڵ�ǰ���������ݿ����������ֽ����������Ҫ������ֽ���������һ�飬��

    // ô��ֻ���count�ֽڡ�Ȼ����ö��麯��breada()������Ҫ�����ݿ飬��Ԥ�����������ݣ�

    // ����������������򷵻��Ѷ��ֽ��������û�ж����κ��ֽڣ��򷵻س����š�Ȼ�󽫿��

    // ����1��Ϊ�´β�������׼���������������ʧ�ܣ��򷵻���д�ֽ��������û�ж�����

    // ���ֽڣ��򷵻س����ţ���������

 70         while (count>0) {

 71                 if (block >= size)

 72                         return read?read:-EIO;

 73                 chars = BLOCK_SIZE-offset;

 74                 if (chars > count)

 75                         chars = count;

 76                 if (!(bh = breada(dev,block,block+1,block+2,-1)))

 77                         return read?read:-EIO;

 78                 block++;

    // �����Ȱ�ָ��pָ������̿�Ļ�����п�ʼ�������ݵ�λ�ô��������һ��ѭ����������

    // ���ݲ���һ�飬����ӿ���ʼ����ȡ�����ֽڣ����������Ԥ������offsetΪ�㡣 �˺�

    // �ļ���ƫ��ָ��posǰ�ƴ˴ν�Ҫ�����ֽ���chars�������ۼ���ЩҪ�����ֽ�����ͳ��ֵ

    // read�С��ٰѻ���Ҫ���ļ���ֵcount��ȥ�˴�Ҫ�����ֽ���chars��Ȼ�����ǴӸ��ٻ���

    // ����pָ��Ŀ�ʼ����λ�ô�����chars���ֽڵ��û��������У�ͬʱ���û�������ָ��ǰ

    // �ơ����θ��������ͷŸû���顣

 79                 p = offset + bh->b_data;

 80                 offset = 0;

 81                 *pos += chars;

 82                 read += chars;                   // �ۼƶ����ֽ�����

 83                 count -= chars;

 84                 while (chars-->0)

 85                         put_fs_byte(*(p++),buf++);

 86                 brelse(bh);

 87         }

 88         return read;                             // �����Ѷ�ȡ���ֽ����������˳���

 89 }

 90