《ORANGE’S：一个操作系统的实现》读书笔记（三十）文件系统（五）

上一篇文章记录了如何进行文件的创建，那么本篇文章要记录的事情就是如何在创建的文件中进行读写操作，毕竟文件是要操作才有意义的。

读写文件

由于我们使用“一次分配，终身使用”的扇区分配策略，所以文件读写变得非常容易，我们先来添加处理READ和WRITE消息的代码：

代码 fs/main.c，文件系统处理READ和WRITE消息。

/**
 * <Ring 1> The main loop of TASK FS.
 */
PUBLIC void task_fs()
{
...
        switch (fs_msg.type) {
            case OPEN:
                fs_msg.FD = do_open();
                break;
            case CLOSE:
                fs_msg.RETVAL = do_close();
                break;
            case READ:
            case WRITE:
                fs_msg.CNT = do_rdwt();
                break;
            default:
                dump_msg("FS::unknown message:", &fs_msg);
                assert(0);
                break;
...
}

读写两种消息由同一个函数do_rdwt()来处理，代码如下所示。

代码 fs/read_write.c，do_rdwt，这是新建的文件。

/**
 * Read/Write file and return byte count read/written.
 * 
 * Sector map is not needed to update, since the sectors for the file have been
 * allocated and the bits are set when the file was created.
 * 
 * @return How many bytes have been read/written.
 */
PUBLIC int do_rdwt()
{
    int fd = fs_msg.FD;         /*< file descriptor. */
    void * buf = fs_msg.BUF;    /*< r/w buffer */
    int len = fs_msg.CNT;       /*< r/w bytes */

    int src = fs_msg.source;    /* caller proc nr. */

    assert((pcaller->filp[fd] >= &f_desc_table[0]) &&
           (pcaller->filp[fd] < &f_desc_table[NR_FILE_DESC]));
    
    if (!(pcaller->filp[fd]->fd_mode & O_RDWR)) {
        return -1;
    }

    int pos = pcaller->filp[fd]->fd_pos;

    struct inode * pin = pcaller->filp[fd]->fd_inode;

    assert(pin >= &inode_table[0] && pin < &inode_table[NR_INODE]);

    int imode = pin->i_mode & I_TYPE_MASK;

    if (imode == I_CHAR_SPECIAL) {
        int t = fs_msg.type == READ ? DEV_READ : DEV_WRITE;
        fs_msg.type = t;

        int dev = pin->i_start_sect;
        assert(MAJOR(dev) == 4);

        fs_msg.DEVICE = MINOR(dev);
        fs_msg.BUF = buf;
        fs_msg.CNT = len;
        fs_msg.PROC_NR = src;
        assert(dd_map[MAJOR(dev)].driver_nr != INVALID_DRIVER);
        send_recv(BOTH, dd_map[MAJOR(dev)].driver_nr, &fs_msg);
        assert(fs_msg.CNT == len);

        return fs_msg.CNT;
    } else {
        assert(pin->i_mode == I_REGULAR || pin->i_mode == I_DIRECTORY);
        assert((fs_msg.type == READ) || (fs_msg.type == WRITE));

        int pos_end;
        if (fs_msg.type == READ) {
            pos_end = min(pos + len, pin->i_size);
        } else {
            pos_end = min(pos + len, pin->i_nr_sects * SECTOR_SIZE);
        }

        int off = pos % SECTOR_SIZE;
        int rw_sect_min = pin->i_start_sect + (pos >> SECTOR_SIZE_SHIFT);
        int rw_sect_max = pin->i_start_sect + (pos_end >> SECTOR_SIZE_SHIFT);

        int chunk = min(rw_sect_max - rw_sect_min + 1, FSBUF_SIZE >> SECTOR_SIZE_SHIFT);

        int bytes_rw = 0;
        int bytes_left = len;
        int i;
        for (i = rw_sect_min; i <= rw_sect_max; i += chunk) {
            /* read/write this amount of bytes every time */
            int bytes = min(bytes_left, chunk * SECTOR_SIZE - off);
            rw_sector(DEV_READ, pin->i_dev, i * SECTOR_SIZE, chunk * SECTOR_SIZE, TASK_FS, fsbuf);

            if (fs_msg.type == READ) {
                phys_copy((void*)va2la(src, buf + bytes_rw),
                          (void*)va2la(TASK_FS, fsbuf + off),
                          bytes);
            } else { /* WRITE */
                phys_copy((void*)va2la(TASK_FS, fsbuf + off),
                          (void*)va2la(src, buf + bytes_rw),
                          bytes);

                rw_sector(DEV_WRITE, pin->i_dev, i * SECTOR_SIZE, chunk * SECTOR_SIZE, TASK_FS, fsbuf);
            }

            off = 0;
            bytes_rw += bytes;
            pcaller->filp[fd]->fd_pos += bytes;
            bytes_left -= bytes;
        }

        if (pcaller->filp[fd]->fd_pos > pin->i_size) {
            /* update inode::size */
            pin->i_size = pcaller->filp[fd]->fd_pos;

            /* write the updated i-node back to disk*/
            sync_inode(pin);
        }

        return bytes_rw;
    }
}

在读写的过程中，我们仍然照顾到了字符设备特殊文件。跟前面一样，我们仍然是把它扔给相应的驱动程序——虽然驱动程序并未准备好处理，但发送一个消息只是举手之劳，我们不妨先把它添上。

读写普通文件时，file_desc结构体的成员悉数到场。首先是对fd_mode进行简单的判断，这其实是判断open()函数调用时是否传入了正确的flag参数，因为fd_mode是从那里得来的。我们对flags的可选值进行了简化，它的可选值只有两个：O_CREAT和O_RDWR，要想读写文件，调用open()时需要加上O_RDWR。

fd_pos的用途在于记录读写到文件的哪个位置，类似于一个书签，在文件刚打开时它被置为0。

fd_inode所指向的便是被操作文件的i-node了，我们通过它获得文件的开始扇区、文件类型，以及文件大小等信息。

真正的读写过程从第52行开始。变量pos表示开始读写的位置，pos_end表示结束读写的位置，读操作时pos_end不能越过文件已有的大小，写操作时pos_end不能越过为文件所分配的最大空间。通过pos和pos_end，我们可以计算出读/写操作所涉及的扇区边界，这里用rw_sect_min和rw_sect_max表示。计算时用右移操作代替除法运算，右移SECTOR_SIZE_SHIFT位相当于被SECTOR_SIZE除。

对扇区的读写以chunk为单位，最大不能超过为fsbuf分配的空间。

需要注意，不仅读操作，写操作也需要先将目标扇区读出，因为读写都是以扇区为单位的，而写操作可以在文件的任意位置进行，所以以扇区为单位的上下文需要先行读出。写操作的另一特殊之处在于它可能改变文件大小，所以返回之前要检查这一点，如果文件大小被改变，则需要更新i-node。

现在FS能处理READ和WRITE消息了，我们马上写两个函数：read()和write()，以便用户进程使用，具体如下代码所示。

代码 lib/read.c，read()，这是新建的文件。

/**
 * Read from a file descriptor.
 * 
 * @param fd    File descriptor.
 * @param buf   Buffer to accept the bytes read.
 * @param count How many bytes to read.
 * 
 * @return On success, the number of bytes read are returned.
 *         On error, -1 is returned.
 */
PUBLIC int read(int fd, void *buf, int count)
{
    MESSAGE msg;
    msg.type = READ;
    msg.FD = fd;
    msg.BUF = buf;
    msg.CNT = count;

    send_recv(BOTH, TASK_FS, &msg);

    return msg.CNT;
}

代码 lib/write.c，write()，这是新建的文件。

/**
 * Write to a file descriptor.
 * 
 * @param fd    File descriptor.
 * @param buf   Buffer including the bytes to write.
 * @param count How many bytes to write.
 * 
 * @return  On success, the number of bytes written are returned.
 *          On error, -1 is returned.
 */
PUBLIC int write(int fd, const void *buf, int count)
{
    MESSAGE msg;
    msg.type = WRITE;
    msg.FD = fd;
    msg.BUF = (void*)buf;
    msg.CNT = count;

    send_recv(BOTH, TASK_FS, &msg);

    return msg.CNT;
}

测试文件读写

好了，现在可以读写文件了，我们马上来测试一下，修改TestA，代码如下所示。

代码 kernel/main.c，读写文件。

void TestA()
{
    int fd;
    int n;
    const char filename[] = "blah";
    const char bufw[] = "abcde";

    const int rd_bytes = 3;
    char bufr[rd_bytes];

    assert(rd_bytes <= strlen(bufw));

    /* create */
    fd = open(filename, O_CREAT | O_RDWR);
    assert(fd != -1);
    printf("File created. fd: %d\n", fd);

    /* write */
    n = write(fd, bufw, strlen(bufw));
    assert(n == strlen(bufw));

    /* close */
    close(fd);

    /* open */
    fd = open(filename, O_RDWR);
    assert(fd != -1);
    printf("File opened. fd: %d\n", fd);

    /* read */
    n = read(fd, bufr, rd_bytes);
    assert(n == rd_bytes);
    bufr[n] = 0;
    printf("%d bytes read: %s\n", n, bufr);

    /* close */
    close(fd);

    spin("TestA");
}

好了，现在可以make并运行查看结果了，由于我们新添加了几个C文件，不要忘记更改Makefile。运行结果如下图所示。

从运行结果看，文件读操作成功了，“abc”三个字符被读出，为保险起见，我们还是深入磁盘映像，看一下如今的“/blah”文件变成什么样了：

理所应当地，inode-map、sector-map以及根目录区没有任何改变，只是“/blah”的i-node变了，i_size变成了5，这是正确的，因为我们写入了5个字节。

接下来还要看一看“/blah”实际占用的扇区中数据的情况。从i-node中可知，文件的开始扇区号是909h，将它与分区的开始扇区号6000h相加，得到“/blah”占用的首扇区的LBA：6909h，将它乘以200h，得到D21200h，这便是“/blah”数据扇区的字节偏移了，让我们来看看里面的内容：

看到了“abcde”，写入操作成功了。

虽然目前的测试还远远不够充分，但是我们有理由庆贺一番了，因为有了创建和读写功能，我们的文件系统就算是具备雏形了。
?

欢迎关注我的公众号