Chapter 7

rcy17 · rcy17 · commit 72be8e46fec8 · 2023-03-05T23:32:13.000+08:00
diff --git a/.github/workflows/github-autotest.yml b/.github/workflows/github-autotest.yml
@@ -1,44 +1,16 @@
 name: auto-test
 
-on:
+on: 
   push:
 
 jobs:
   base-test:
     runs-on: ubuntu-latest
-    outputs:
-      points: ${{ steps.end.outputs.points}}
     container:
         image: duskmoon/dev-env:ucore-ci
     steps:
       - uses: actions/checkout@v3
-      - run: git clone https://github.com/LearningOS/uCore-Tutorial-Checker-2023S.git ucore-tutorial-ci
+      - run: git clone https://github.com/LearningOS/uCore-Tutorial-Checker-2023S.git ucore-tutorial-ci 
       - run: git clone https://github.com/LearningOS/uCore-Tutorial-Test-2023S.git ucore-tutorial-ci/workplace/user
-      - name: run test
-        id: tester
-        run: cd ucore-tutorial-ci && make test passwd=${{ secrets.BASE_TEST_TOKEN }} CHAPTER=`echo ${GITHUB_REF##*/} | grep -oP 'ch\K[0-9]'` > ../output.txt && cat ../output.txt
-      - name: end
-        id: end
-        run: cat output.txt | grep "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}" >> $GITHUB_OUTPUT
-  deploy:
-    if: github.repository != 'LearningOS/uCore-Tutorial-Code-2023S'
-    name: Deploy to pages
-    needs: base-test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        continue-on-error: true
-        with:
-          ref: 'gh-pages'
-      - name: Save Log File
-        uses: yfblock/multi-rank-log@main
-        with:
-          points: ${{ needs.base-test.outputs.points }}
-      - name: GitHub Pages
-        uses: crazy-max/ghaction-github-pages@v3
-        with:
-          target_branch: gh-pages
-          build_dir: ./public
-          keep_history: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - run: cd ucore-tutorial-ci && make test passwd=${{ secrets.BASE_TEST_TOKEN }} CHAPTER=`echo ${GITHUB_REF##*/} | grep -oP 'ch\K[0-9]'`
+      
diff --git a/os/file.c b/os/file.c
@@ -30,6 +30,9 @@ void fileclose(struct file *f)
 	case FD_STDIO:
 		// Do nothing
 		break;
+	case FD_PIPE:
+		pipeclose(f->pipe, f->writable);
+		break;
 	case FD_INODE:
 		iput(f->ip);
 		break;
@@ -63,7 +66,9 @@ int show_all_files()
 }
 
 //Create a new empty file based on path and type and return its inode;
+
 //if the file under the path exists, return its inode;
+
 //returns 0 if the type of file to be created is not T_file
 static struct inode *create(char *path, short type)
 {
@@ -94,7 +99,9 @@ static struct inode *create(char *path, short type)
 }
 
 //A process creates or opens a file according to its path, returning the file descriptor of the created or opened file.
+
 //If omode is O_CREATE, create a new file
+
 //if omode if the others,open a created file.
 int fileopen(char *path, uint64 omode)
 {
@@ -114,10 +121,7 @@ int fileopen(char *path, uint64 omode)
 	}
 	if (ip->type != T_FILE)
 		panic("unsupported file inode type\n");
-	if ((f = filealloc()) == 0 ||
-	    (fd = fdalloc(f)) <
-		    0) { //Assign a system-level table entry to a newly created or opened file
-		//and then create a file descriptor that points to it
+	if ((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0) {
 		if (f)
 			fileclose(f);
 		iput(ip);
diff --git a/os/file.h b/os/file.h
@@ -20,12 +20,23 @@ struct inode {
 	// LAB4: You may need to add link count here
 };
 
+//a struct for pipe
+struct pipe {
+	char data[PIPESIZE];
+	uint nread; // number of bytes read
+	uint nwrite; // number of bytes written
+	int readopen; // read fd is still open
+	int writeopen; // write fd is still open
+};
+
+// file.h
 // Defines a file in memory that provides information about the current use of the file and the corresponding inode location
 struct file {
-	enum { FD_NONE = 0, FD_INODE, FD_STDIO } type;
+	enum { FD_NONE = 0, FD_PIPE, FD_INODE, FD_STDIO } type;
 	int ref; // reference count
 	char readable;
 	char writable;
+	struct pipe *pipe; // FD_PIPE
 	struct inode *ip; // FD_INODE
 	uint off;
 };
@@ -39,6 +50,10 @@ enum {
 
 extern struct file filepool[FILEPOOLSIZE];
 
+int pipealloc(struct file *, struct file *);
+void pipeclose(struct pipe *, int);
+int piperead(struct pipe *, uint64, int);
+int pipewrite(struct pipe *, uint64, int);
 void fileclose(struct file *);
 struct file *filealloc();
 int fileopen(char *, uint64);
diff --git a/os/fs.c b/os/fs.c
@@ -428,8 +428,6 @@ int dirlink(struct inode *dp, char *name, uint inum)
 	return 0;
 }
 
-// LAB4: You may want to add dirunlink here
-
 //Return the inode of the root directory
 struct inode *root_dir()
 {
diff --git a/os/pipe.c b/os/pipe.c
@@ -0,0 +1,99 @@
+#include "defs.h"
+#include "proc.h"
+#include "riscv.h"
+
+int pipealloc(struct file *f0, struct file *f1)
+{
+	struct pipe *pi;
+	pi = 0;
+	if ((pi = (struct pipe *)kalloc()) == 0)
+		goto bad;
+	pi->readopen = 1;
+	pi->writeopen = 1;
+	pi->nwrite = 0;
+	pi->nread = 0;
+	f0->type = FD_PIPE;
+	f0->readable = 1;
+	f0->writable = 0;
+	f0->pipe = pi;
+	f1->type = FD_PIPE;
+	f1->readable = 0;
+	f1->writable = 1;
+	f1->pipe = pi;
+	return 0;
+bad:
+	if (pi)
+		kfree((char *)pi);
+	return -1;
+}
+
+void pipeclose(struct pipe *pi, int writable)
+{
+	if (writable) {
+		pi->writeopen = 0;
+	} else {
+		pi->readopen = 0;
+	}
+	if (pi->readopen == 0 && pi->writeopen == 0) {
+		kfree((char *)pi);
+	}
+}
+
+int pipewrite(struct pipe *pi, uint64 addr, int n)
+{
+	int w = 0;
+	uint64 size;
+	struct proc *p = curr_proc();
+	if (n <= 0) {
+		panic("invalid read num");
+	}
+	while (w < n) {
+		if (pi->readopen == 0) {
+			return -1;
+		}
+		if (pi->nwrite == pi->nread + PIPESIZE) { // DOC: pipewrite-full
+			yield();
+		} else {
+			size = MIN(MIN(n - w,
+				       pi->nread + PIPESIZE - pi->nwrite),
+				   PIPESIZE - (pi->nwrite % PIPESIZE));
+			if (copyin(p->pagetable,
+				   &pi->data[pi->nwrite % PIPESIZE], addr + w,
+				   size) < 0) {
+				panic("copyin");
+			}
+			pi->nwrite += size;
+			w += size;
+		}
+	}
+	return w;
+}
+
+int piperead(struct pipe *pi, uint64 addr, int n)
+{
+	int r = 0;
+	uint64 size = -1;
+	struct proc *p = curr_proc();
+	if (n <= 0) {
+		panic("invalid read num");
+	}
+	while (pi->nread == pi->nwrite) {
+		if (pi->writeopen)
+			yield();
+		else
+			return -1;
+	}
+	while (r < n && size != 0) { // DOC: piperead-copy
+		if (pi->nread == pi->nwrite)
+			break;
+		size = MIN(MIN(n - r, pi->nwrite - pi->nread),
+			   PIPESIZE - (pi->nread % PIPESIZE));
+		if (copyout(p->pagetable, addr + r,
+			    &pi->data[pi->nread % PIPESIZE], size) < 0) {
+			panic("copyout");
+		}
+		pi->nread += size;
+		r += size;
+	}
+	return r;
+}
diff --git a/os/syscall.c b/os/syscall.c
@@ -44,6 +44,8 @@ uint64 sys_write(int fd, uint64 va, uint64 len)
 	switch (f->type) {
 	case FD_STDIO:
 		return console_write(va, len);
+	case FD_PIPE:
+		return pipewrite(f->pipe, va, len);
 	case FD_INODE:
 		return inodewrite(f, va, len);
 	default:
@@ -64,6 +66,8 @@ uint64 sys_read(int fd, uint64 va, uint64 len)
 	switch (f->type) {
 	case FD_STDIO:
 		return console_read(va, len);
+	case FD_PIPE:
+		return piperead(f->pipe, va, len);
 	case FD_INODE:
 		return inoderead(f, va, len);
 	default:
@@ -154,6 +158,38 @@ uint64 sys_set_priority(long long prio)
 	return -1;
 }
 
+uint64 sys_pipe(uint64 fdarray)
+{
+	struct proc *p = curr_proc();
+	uint64 fd0, fd1;
+	struct file *f0, *f1;
+	if (f0 < 0 || f1 < 0) {
+		return -1;
+	}
+	f0 = filealloc();
+	f1 = filealloc();
+	if (pipealloc(f0, f1) < 0)
+		goto err0;
+	fd0 = fdalloc(f0);
+	fd1 = fdalloc(f1);
+	if (fd0 < 0 || fd1 < 0)
+		goto err0;
+	if (copyout(p->pagetable, fdarray, (char *)&fd0, sizeof(fd0)) < 0 ||
+	    copyout(p->pagetable, fdarray + sizeof(uint64), (char *)&fd1,
+		    sizeof(fd1)) < 0) {
+		goto err1;
+	}
+	return 0;
+
+err1:
+	p->files[fd0] = 0;
+	p->files[fd1] = 0;
+err0:
+	fileclose(f0);
+	fileclose(f1);
+	return -1;
+}
+
 uint64 sys_openat(uint64 va, uint64 omode, uint64 _flags)
 {
 	struct proc *p = curr_proc();
@@ -177,6 +213,16 @@ uint64 sys_close(int fd)
 	return 0;
 }
 
+uint64 sys_sbrk(int n)
+{
+	uint64 addr;
+	struct proc *p = curr_proc();
+	addr = p->program_brk;
+	if (growproc(n) < 0)
+		return -1;
+	return addr;
+}
+
 int sys_fstat(int fd, uint64 stat)
 {
 	//TODO: your job is to complete the syscall
@@ -196,16 +242,6 @@ int sys_unlinkat(int dirfd, uint64 name, uint64 flags)
 	return -1;
 }
 
-uint64 sys_sbrk(int n)
-{
-	uint64 addr;
-	struct proc *p = curr_proc();
-	addr = p->program_brk;
-	if (growproc(n) < 0)
-		return -1;
-	return addr;
-}
-
 extern char trap_page[];
 
 void syscall()
@@ -253,6 +289,9 @@ void syscall()
 	case SYS_wait4:
 		ret = sys_wait(args[0], args[1]);
 		break;
+	case SYS_pipe2:
+		ret = sys_pipe(args[0]);
+		break;
 	case SYS_fstat:
 		ret = sys_fstat(args[0], args[1]);
 		break;
@@ -261,7 +300,6 @@ void syscall()
 		break;
 	case SYS_unlinkat:
 		ret = sys_unlinkat(args[0], args[1], args[2]);
-		break;
 	case SYS_spawn:
 		ret = sys_spawn(args[0]);
 		break;

Original file line number	Diff line number	Diff line change
`@@ -428,8 +428,6 @@ int dirlink(struct inode dp, char name, uint inum)`
`428`	`428`	`return 0;`
`429`	`429`	`}`
`430`	`430`
`431`		`-// LAB4: You may want to add dirunlink here`
`432`		`-`
`433`	`431`	`//Return the inode of the root directory`
`434`	`432`	`struct inode *root_dir()`
`435`	`433`	`{`