目录
使用 dup2 系统调用
为命令行解释器添加重定向功能
理解缓冲区问题
缓存区的刷新策略
FILE的本质
尝试封装C语言的FILE
小共识：
cd->当前路径->当前进程的工作路径->工作路径可以被修改->每个进程都有当前路径->故cd改的是子进程的路径->修改父进程的路径需要系统调用
fd的分配规则：从小到大，按照顺序从struct file* fd_array[]寻找最小且没有被占用的fd
重定向的本质：
重定向的本质：上层用的fd不变，在内核中更改fd对应的struct file*的地址。
使用 dup2 系统调用
#include <unistd.h>
int dup2(int oldfd, int newfd);将newfd中内容拷贝到oldfd.
将向显示器打印的内容重定向到log.txt.
为命令行解释器添加重定向功能
#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3
#define NUM 1024
#define OPT_NUM 64
#define trimSpace(start) do{\
while(isspace(*start)) ++start;\
}while(0)
char lineCommand[NUM];
char* myargv[OPT_NUM];
int lastCode=0;
int lastSig=0;
int redirType=NONE_REDIR;
char* redirFile=NULL;
void comandCheck(char* commands)
{
assert(commands);
char* start=commands;
char* end=commands+strlen(commands);
while (start<end)
{
if(*start=='>')
{
*start='\0';
start++;
if(*start=='>')
{
//"ls -a >> file.log"
redirType=APPEND_REDIR;
start++;
}
else
{
//"ls -a> file.log"
redirType=OUTPUT_REDIR;
}
trimSpace(start);
redirFile=start;
break;
}
else if(*start=='<')
{
//"cat < file.txt"
*start='\0';
start++;
trimSpace(start);
redirType=INPUT_REDIR;
redirFile=start;
break;
}
else
{
start++;
}
}
}进程具有独立性，所以子进程会拷贝一份父进程的files_struct二者相互独立。而文件部分二者共享（上图中的虚线部分）。程序替换时不影响PCB及PCB内部的细节。
一个被打开的文件中包含引用计数，父进程或子进程关闭文件其本质是让引用计数--。
理解缓冲区问题
缓存区的刷新策略
a.立即刷新-无缓冲
b.行刷新---显示器（键盘）
c.缓冲区满---全缓存----磁盘文件
两种特殊情况
1.用户强制刷新---（fflush）
2.进程退出----通常情况下会进行缓冲区的刷新。
例如：
printf("hello printf\n");
fprintf(stdout,"hello printf\n");
const char* fputsString="hello fputs\n";
fputs(fputsString,stdout);
const char* wstring="hello write\n";
write(1,wstring,strlen(wstring));
fork();c语言的库函数被打印了两次而系统接口write只被打印了一次。这是为什么？？？？？？？？
在代码结束之前创建子进程
1.如果没有进行> 可以看到4条消息，stdout默认使用的是行刷新，在进程fork之前，C函数已经被打印输出到显示器上（外设），FIEL内部，进程内部就没有对应的数据了。
2.如果进行>,写入文件不在是显示器，而是普通文件，采用的刷新策略是全缓冲，三条C函数虽然带了'\n’， 但是不足以将整个缓存区写满，！！！！！！所以数据没有被刷新。
执行fork（）函数时，stdout属于父进程，创建子进程时，创建之后的操作就是退出！！先退出的进程要进行缓存区的刷新（即为修改），这时会发生写时拷贝，最终数据会显示两份（父子进程最终都会去找缓冲区，然后将数据进行刷新）。
3.而write为什么没有呢？？？ write没有FILE，而是用的fd，故没有C提供的缓冲区。
FILE的本质
>log.txt清空文件
尝试封装C语言的FILE
#pragma once
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<errno.h>
#include<ctype.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/wait.h>
#define SIZE 1024
#define SYNC_NOW 1
#define SYNC_LINE 2
#define SYNC_FULL 4
typedef struct _FILE
{
int flags;//刷新方式
int fileno;
int cap;//buffer的总容量
int size;//buffer当前容量
char buffer[SIZE];
}FILE_;
FILE_* fopen_(const char* path_name,const char* mode);
void fwrite_(const void* ptr,int num,FILE_* fp);
void fclose_(FILE_* fp);
void fflush_(FILE_* fp);
FILE_* fopen_(const char* path_name,const char* mode)
{
int flags=0;
int defaultMode=0666;
if(strcmp(mode,"r")==0)
{
flags|=O_RDONLY;
}
else if(strcmp(mode,"w")==0)
{
flags|=(O_WRONLY|O_CREAT|O_TRUNC);
}
else if(strcmp(mode,"a")==0)
{
flags|=(O_WRONLY|O_CREAT|O_APPEND);
}
else
{
//..
}
int fd=0;
if(flags&O_RDONLY) fd=open(path_name,flags);
else fd=open(path_name,flags,defaultMode);
if(fd<0)
{
const char* err=strerror(errno);
write(2,err,strlen(err));
return NULL;
}
FILE_* fp=(FILE_*)malloc(sizeof(FILE_));
assert(fp);
fp->flags=SYNC_LINE;//默认是行刷新
fp->fileno=fd;
fp->cap=SIZE;
fp->size=0;
memset(fp->buffer,0,SIZE);
return fp;
}
void fwrite_(const void* ptr,int num,FILE_* fp)
{
//1.写入到缓冲区中
memcpy(fp->buffer+fp->size,ptr,num);
fp->size+=num;
//2.判断是否刷新
if(fp->flags&SYNC_NOW)
{
write(fp->fileno,fp->buffer,fp->size);
fp->size=0;
}
else if(fp->flags&SYNC_FULL)
{
if(fp->size==fp->cap)
{
write(fp->fileno,fp->buffer,fp->size);
fp->size=0;
}
}
else if(fp->flags&SYNC_LINE)
{
if(fp->buffer[fp->size-1]=='\n')
{
write(fp->fileno,fp->buffer,fp->size);
fp->size=0;
}
}
else
{
}
}
void fflush_(FILE_* fp){
if(fp->size>0) write(fp->fileno,fp->buffer,fp->size);
}
void fclose_(FILE_* fp)
{
fflush_(fp);
close(fp->fileno);
}
故数据被写到硬件上至少会进过三次拷贝。
void fflush_(FILE_* fp){
if(fp->size>0) write(fp->fileno,fp->buffer,fp->size);
fsync(fp->fileno);//将数据，强制要求os进行外设刷新
fp->size=0;
}
