linux系统调用之write源码解析（基于linux0.11）

int sys_write(unsigned int fd,char * buf,int count)
{
    struct file * file;
    struct m_inode * inode;

    if (fd>=NR_OPEN || count <0 || !(file=current->filp[fd]))
        return -EINVAL;
    if (!count)
        return 0;
    inode=file->f_inode;
    if (inode->i_pipe)
        return (file->f_mode&2)?write_pipe(inode,buf,count):-EIO;
    if (S_ISCHR(inode->i_mode))
        return rw_char(WRITE,inode->i_zone[0],buf,count,&file->f_pos);
    if (S_ISBLK(inode->i_mode))
        return block_write(inode->i_zone[0],&file->f_pos,buf,count);
    if (S_ISREG(inode->i_mode))
        return file_write(inode,file,buf,count);
    printk("(Write)inode->i_mode=%06o\n\r",inode->i_mode);
    return -EINVAL;
}

int file_write(struct m_inode * inode, struct file * filp, char * buf, int count)
{
    off_t pos;
    int block,c;
    struct buffer_head * bh;
    char * p;
    int i=0;

/*
 * ok, append may not work when many processes are writing at the same time
 * but so what. That way leads to madness anyway.
 */
    // 如果设置了追加标记位，则更新当前位置指针到文件最后一个字节
    if (filp->f_flags & O_APPEND)
        pos = inode->i_size;
    else
        pos = filp->f_pos;
    // i为已经写入的长度，count为需要写入的长度
    while (i<count) {
        // 读取一个硬盘的数据块，如果没有则创建一个块，即标记硬盘中这个块已经被使用
        if (!(block = create_block(inode,pos/BLOCK_SIZE)))
            break;
        // 然后根据返回的块号把这个块内容读进来
        if (!(bh=bread(inode->i_dev,block)))
            break;
        c = pos % BLOCK_SIZE;
        p = c + bh->b_data; // 开始写入数据的位置
        bh->b_dirt = 1; // 标记数据需要回写硬盘
        c = BLOCK_SIZE-c; // 算出能写的长度
        if (c > count-i) c = count-i; // 比较能写的长度和还需要写的长度，取小的
        pos += c; // 更新偏移指针，c为准备写入的长度
        // 如果超过原来长度则需要更新i_size字段，标记inode需要回写
        if (pos > inode->i_size) {
            inode->i_size = pos;
            inode->i_dirt = 1;
        }
        i += c; // 更新已经写入的长度
        while (c-->0)
            *(p++) = get_fs_byte(buf++);
        brelse(bh);
    }
    inode->i_mtime = CURRENT_TIME;
    if (!(filp->f_flags & O_APPEND)) {
        filp->f_pos = pos;
        inode->i_ctime = CURRENT_TIME;
    }
    return (i?i:-1);
}
file_write的大概逻辑就是根据inode中记录的文件信息，根据需要写入的位置算出，硬盘的位置或者说块号。如果对应的块已经存在，则直接返回对应的块号，否则需要新建块。我们看bmap函数。
// 查找inode中第block块对应硬盘的块号
int bmap(struct m_inode * inode,int block)
{
    return _bmap(inode,block,0);
}
// 找到inode中块号为block的块对应哪个硬盘块号或如果没有该块则在硬盘中新建一个块
static int _bmap(struct m_inode * inode,int block,int create)
{
    struct buffer_head * bh;
    int i;

    if (block<0)
        panic("_bmap: block<0");
    // 文件的大小最大值,(7+512+512*512) * 硬盘每块的大小
    if (block >= 7+512+512*512)
        panic("_bmap: block>big");
    // 块号小于7则直接在i_zone数组的前面7个中找就行
    if (block<7) {
        // 如果是创建模式并且该索引为空则创建一个块
        if (create && !inode->i_zone[block])
            // 保存块号
            if (inode->i_zone[block]=new_block(inode->i_dev)) {
                inode->i_ctime=CURRENT_TIME;
                // 该inode需要回写硬盘
                inode->i_dirt=1;
            }
        // 返回硬盘中的块号
        return inode->i_zone[block];
    }
    block -= 7;
    if (block<512) {
        if (create && !inode->i_zone[7])
            if (inode->i_zone[7]=new_block(inode->i_dev)) {
                inode->i_dirt=1;
                inode->i_ctime=CURRENT_TIME;
            }
        if (!inode->i_zone[7])
            return 0;
        // 索引为7的块是间接块，需要把内容读进来才知道具体的硬盘块号
        if (!(bh = bread(inode->i_dev,inode->i_zone[7])))
            return 0;
        // 直接根据block取得对应的硬盘块号
        i = ((unsigned short *) (bh->b_data))[block];
        // 之前没有，新建一个块
        if (create && !i)
            if (i=new_block(inode->i_dev)) {
                ((unsigned short *) (bh->b_data))[block]=i;
                bh->b_dirt=1;
            }
        brelse(bh);
        return i;
    }
    block -= 512;
    if (create && !inode->i_zone[8])
        if (inode->i_zone[8]=new_block(inode->i_dev)) {
            inode->i_dirt=1;
            inode->i_ctime=CURRENT_TIME;
        }
    if (!inode->i_zone[8])
        return 0;
    // 先取得一级索引对应的数据，数据中的每一项对应512个项
    if (!(bh=bread(inode->i_dev,inode->i_zone[8])))
        return 0;
    // 每一个索引对应512个项，所以除以512，即右移9位，取得二级索引
    i = ((unsigned short *)bh->b_data)[block>>9];
    if (create && !i)
        if (i=new_block(inode->i_dev)) {
            ((unsigned short *) (bh->b_data))[block>>9]=i;
            bh->b_dirt=1;
        }
    brelse(bh);
    if (!i)
        return 0;
    // 取得二级索引对应的数据
    if (!(bh=bread(inode->i_dev,i)))
        return 0;
    // 算出偏移，最大偏移是511，所以&511
    i = ((unsigned short *)bh->b_data)[block&511];
    if (create && !i)
        if (i=new_block(inode->i_dev)) {
            ((unsigned short *) (bh->b_data))[block&511]=i;
            bh->b_dirt=1;
        }
    brelse(bh);
    return i;
}

/*
    新建一个数据块，首先利用超级块的块位图信息找到一个可用的数据块，
    然后读进来，清0，等待回写，返回块号
*/
int new_block(int dev)
{
    struct buffer_head * bh;
    struct super_block * sb;
    int i,j;
    // 获取文件系统的超级块信息
    if (!(sb = get_super(dev)))
        panic("trying to get new block from nonexistant device");
    j = 8192;
    // 找第一个未使用的块的位置
    for (i=0 ; i<8 ; i++)
        //s_zmap[i]为数据块位图的缓存 
        if (bh=sb->s_zmap[i])
            if ((j=find_first_zero(bh->b_data))<8192)
                break;
    if (i>=8 || !bh || j>=8192)
        return 0;
    // 置第j个数据块已使用标记
    if (set_bit(j,bh->b_data))
        panic("new_block: bit already set");
    // 该位图对应的buffer需要回写
    bh->b_dirt = 1;
    // 位图存在多个块中，i为第i个块，每个块对应的位图管理着8192个数据块
    j += i*8192 + sb->s_firstdatazone-1; // 算出块号
    // 超过了最大块号
    if (j >= sb->s_nzones)
        return 0;
    // 拿到一个buffer，然后清0，等待回写
    if (!(bh=getblk(dev,j)))
        panic("new_block: cannot get block");
    if (bh->b_count != 1)
        panic("new block: count is != 1");
    // 清0防止脏数据
    clear_block(bh->b_data);
    // 内容是最新的
    bh->b_uptodate = 1;
    // 需要回写硬盘，因为新建的内容在硬盘还没有
    bh->b_dirt = 1;
    brelse(bh);
    return j;
}