上一篇文章记录了如何进行文件的创建，那么本篇文章要记录的事情就是如何在创建的文件中进行读写操作，毕竟文件是要操作才有意义的。
读写文件
由于我们使用“一次分配，终身使用”的扇区分配策略，所以文件读写变得非常容易，我们先来添加处理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”，写入操作成功了。
虽然目前的测试还远远不够充分，但是我们有理由庆贺一番了，因为有了创建和读写功能，我们的文件系统就算是具备雏形了。
欢迎关注我的公众号
![[软件工具]通用OCR识别文字识别中文识别服务程序可局域网访问](https://img-blog.csdnimg.cn/direct/079198661ad94b4eb65176851b453dd0.jpeg)
