lab fs done

Makefile

@@ -257,10 +257,15 @@ endif
 
 ifeq ($(LAB),fs)
 UPROGS += \
-	$U/_bigfile
+	$U/_bigfile\
+	$U/_symlinktest
 endif
 
 
+ifeq ($(LAB),mmap)
+UPROGS += \
+	$U/_mmaptest
+endif
 
 ifeq ($(LAB),net)
 UPROGS += \

conf/lab.mk

@@ -1 +1 @@
-LAB=lock
+LAB=fs

grade-lab-fs

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+import re
+from gradelib import *
+
+r = Runner(save("xv6.out"))
+
+@test(40, "running bigfile")
+def test_bigfile():
+    r.run_qemu(shell_script([
+        'bigfile'
+    ]), timeout=240)
+    r.match('^wrote 65803 blocks$')
+    r.match('^reading bigfile$')
+    r.match('^bigfile done; ok$')
+
+@test(0, "running symlinktest")
+def test_symlinktest():
+    r.run_qemu(shell_script([
+        'symlinktest'
+    ]), timeout=20)
+
+@test(20, "symlinktest: symlinks", parent=test_symlinktest)
+def test_symlinktest_symlinks():
+    r.match("^test symlinks: ok$")
+
+@test(20, "symlinktest: concurrent symlinks", parent=test_symlinktest)
+def test_symlinktest_symlinks():
+    r.match("^test concurrent symlinks: ok$")
+
+@test(19, "usertests")
+def test_usertests():
+    r.run_qemu(shell_script([
+        'usertests -q'
+    ]), timeout=360)
+    r.match('^ALL TESTS PASSED$')
+
+@test(1, "time")
+def test_time():
+    check_time()
+
+run_tests()

grade-lab-lock

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-
-import re
-from gradelib import *
-
-r = Runner(save("xv6.out"))
-
-@test(0, "running kalloctest")
-def test_kalloctest():
-    r.run_qemu(shell_script([
-        'kalloctest'
-    ]), timeout=300)
-    
-@test(10, "kalloctest: test1", parent=test_kalloctest)
-def test_kalloctest_test1():
-    r.match('^test1 OK$')
-    
-@test(10, "kalloctest: test2", parent=test_kalloctest)
-def test_kalloctest_test2():
-    r.match('^test2 OK$')
-
-@test(10, "kalloctest: test3", parent=test_kalloctest)
-def test_kalloctest_test3():
-    r.match('^test3 OK$')
-
-@test(10, "kalloctest: sbrkmuch")
-def test_sbrkmuch():
-    r.run_qemu(shell_script([
-        'usertests sbrkmuch'
-    ]), timeout=90)
-    r.match('^ALL TESTS PASSED$')
-
-@test(0, "running bcachetest")
-def test_bcachetest():
-    r.run_qemu(shell_script([
-        'bcachetest'
-    ]), timeout=150)
-    
-@test(20, "bcachetest: test0", parent=test_bcachetest)
-def test_bcachetest_test0():
-    r.match('^test0: OK$')
-    
-@test(10, "bcachetest: test1", parent=test_bcachetest)
-def test_bcachetest_test1():
-    r.match('^test1 OK$')
-
-@test(10, "bcachetest: test2", parent=test_bcachetest)
-def test_bcachetest_test2():
-    r.match('^test2 OK$')
-
-@test(10, "bcachetest: test3", parent=test_bcachetest)
-def test_bcachetest_test3():
-    r.match('^test3 OK$')
-
-@test(19, "usertests")
-def test_usertests():
-    r.run_qemu(shell_script([
-        'usertests -q'
-    ]), timeout=300)
-    r.match('^ALL TESTS PASSED$')
-
-@test(1, "time")
-def test_time():
-    check_time()
-
-run_tests()

gradelib.py

@@ -238,7 +238,7 @@ def make(*target):
     post_make()
 
 def show_command(cmd):
-    from pipes import quote
+    from shlex import quote
     print("\n$", " ".join(map(quote, cmd)))
 
 def maybe_unlink(*paths):

kernel/defs.h

@@ -1,7 +1,3 @@
-#ifdef LAB_MMAP
-typedef unsigned long size_t;
-typedef long int off_t;
-#endif
 struct buf;
 struct context;
 struct file;
@@ -121,10 +117,6 @@ void            initlock(struct spinlock*, char*);
 void            release(struct spinlock*);
 void            push_off(void);
 void            pop_off(void);
-int             atomic_read4(int *addr);
-#ifdef LAB_LOCK
-void            freelock(struct spinlock*);
-#endif
 
 // sleeplock.c
 void            acquiresleep(struct sleeplock*);
@@ -181,12 +173,6 @@ uint64          walkaddr(pagetable_t, uint64);
 int             copyout(pagetable_t, uint64, char *, uint64);
 int             copyin(pagetable_t, char *, uint64, uint64);
 int             copyinstr(pagetable_t, char *, uint64, uint64);
-#if defined(LAB_PGTBL) || defined(SOL_MMAP)
-void            vmprint(pagetable_t);
-#endif
-#ifdef LAB_PGTBL
-pte_t*          pgpte(pagetable_t, uint64);
-#endif
 
 // plic.c
 void            plicinit(void);
@@ -202,38 +188,4 @@ void            virtio_disk_intr(void);
 // number of elements in fixed-size array
 #define NELEM(x) (sizeof(x)/sizeof((x)[0]))
 
-
-
-#ifdef LAB_PGTBL
-// vmcopyin.c
-int             copyin_new(pagetable_t, char *, uint64, uint64);
-int             copyinstr_new(pagetable_t, char *, uint64, uint64);
-#endif
-
-#ifdef LAB_LOCK
-// stats.c
-void            statsinit(void);
-void            statsinc(void);
-
-// sprintf.c
-int             snprintf(char*, unsigned long, const char*, ...);
-#endif
-
-#ifdef KCSAN
-void            kcsaninit();
-#endif
-
-#ifdef LAB_NET
-// pci.c
-void            pci_init();
-
-// e1000.c
-void            e1000_init(uint32 *);
-void            e1000_intr(void);
-int             e1000_transmit(char *, int);
-
-// net.c
-void            netinit(void);
-void            net_rx(char *buf, int len);
-
-#endif
+#define DEBUG()     printf("File: %s, Line: %d, Function: %s\n", __FILE__, __LINE__, __func__)

kernel/fcntl.h

@@ -3,3 +3,4 @@
 #define O_RDWR    0x002
 #define O_CREATE  0x200
 #define O_TRUNC   0x400
+#define O_NOFOLLOW 0x004

kernel/file.h

@@ -26,7 +26,7 @@ struct inode {
   short minor;
   short nlink;
   uint size;
-  uint addrs[NDIRECT+1];
+  uint addrs[NDIRECT+2];
 };
 
 // map major device number to device functions.
@@ -38,4 +38,3 @@ struct devsw {
 extern struct devsw devsw[];
 
 #define CONSOLE 1
-#define STATS   2

kernel/fs.c

@@ -295,11 +295,11 @@ ilock(struct inode *ip)
   struct buf *bp;
   struct dinode *dip;
 
-  if(ip == 0 || atomic_read4(&ip->ref) < 1)
+  if(ip == 0 || ip->ref < 1)
     panic("ilock");
 
   acquiresleep(&ip->lock);
-  
+
   if(ip->valid == 0){
     bp = bread(ip->dev, IBLOCK(ip->inum, sb));
     dip = (struct dinode*)bp->data + ip->inum%IPB;
@@ -320,7 +320,7 @@ ilock(struct inode *ip)
 void
 iunlock(struct inode *ip)
 {
-  if(ip == 0 || !holdingsleep(&ip->lock) || atomic_read4(&ip->ref) < 1)
+  if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
     panic("iunlock");
 
   releasesleep(&ip->lock);
@@ -398,24 +398,61 @@ bmap(struct inode *ip, uint bn)
 
   if(bn < NINDIRECT){
     // Load indirect block, allocating if necessary.
-    if((addr = ip->addrs[NDIRECT]) == 0){
-      addr = balloc(ip->dev);
-      if(addr == 0)
-        return 0;
-      ip->addrs[NDIRECT] = addr;
-    }
-    bp = bread(ip->dev, addr);
-    a = (uint*)bp->data;
-    if((addr = a[bn]) == 0){
-      addr = balloc(ip->dev);
-      if(addr){
-        a[bn] = addr;
-        log_write(bp);
+    if(bn<NINDIRECT1){
+      if((addr = ip->addrs[NDIRECT]) == 0){
+        addr = balloc(ip->dev);
+        if(addr == 0)
+          return 0;
+        ip->addrs[NDIRECT] = addr;
       }
+      bp = bread(ip->dev, addr);
+      a = (uint*)bp->data;
+      if((addr = a[bn]) == 0){
+        addr = balloc(ip->dev);
+        if(addr){
+          a[bn] = addr;
+          log_write(bp);
+        }
+      }
+      brelse(bp);
+      return addr;
+    }else{
+      bn-=NINDIRECT1;
+      if((addr = ip->addrs[NDIRECT+1])==0){
+        addr = balloc(ip->dev);
+        if(addr == 0)
+          return 0;
+        ip->addrs[NDIRECT+1] = addr;
+      }
+      bp=bread(ip->dev,addr);
+      a = (uint *)bp->data;
+      const uint offset=bn%NINDIRECT1;
+      bn/=NINDIRECT1;
+      if((addr = a[bn])==0){
+        addr=balloc(ip->dev);
+        if(addr){
+          a[bn] = addr;
+          log_write(bp);
+        }
+      }
+      {
+        struct buf *bp=bread(ip->dev,addr);
+        a = (uint *)bp->data;
+        if((addr = a[offset])==0){
+          addr=balloc(ip->dev);
+          if(addr){
+            a[offset]=addr;
+            log_write(bp);
+          }
+        }
+        brelse(bp);
+      }
+      brelse(bp);
+      return addr;
     }
-    brelse(bp);
-    return addr;
+
   }
+
   panic("bmap: out of range");
 }
 
@@ -438,7 +475,7 @@ itrunc(struct inode *ip)
   if(ip->addrs[NDIRECT]){
     bp = bread(ip->dev, ip->addrs[NDIRECT]);
     a = (uint*)bp->data;
-    for(j = 0; j < NINDIRECT; j++){
+    for(j = 0; j < NINDIRECT1; j++){
       if(a[j])
         bfree(ip->dev, a[j]);
     }
@@ -446,7 +483,25 @@ itrunc(struct inode *ip)
     bfree(ip->dev, ip->addrs[NDIRECT]);
     ip->addrs[NDIRECT] = 0;
   }
-  
+  if(ip->addrs[NDIRECT+1]){
+    bp = bread(ip->dev,ip->addrs[NDIRECT+1]);
+    a = (uint*)bp->data;
+    for(j = 0;j<NINDIRECT1;++j){
+      if(a[j]){
+        struct buf *bp=bread(ip->dev,a[j]);
+        for(int j=0;j<NINDIRECT1;++j){
+          uint *a=(uint*)bp->data;
+          if(a[j])
+            bfree(ip->dev,a[j]);
+        }
+        brelse(bp);
+        bfree(ip->dev,a[j]);
+      }
+    }
+    brelse(bp);
+    bfree(ip->dev,ip->addrs[NDIRECT+1]);
+    ip->addrs[NDIRECT+1] = 0;
+  }
   ip->size = 0;
   iupdate(ip);
 }
@@ -507,11 +562,12 @@ writei(struct inode *ip, int user_src, uint64 src, uint off, uint n)
   uint tot, m;
   struct buf *bp;
 
-  if(off > ip->size || off + n < off)
+  if(off > ip->size || off + n < off){
     return -1;
-  if(off + n > MAXFILE*BSIZE)
+  }
+  if(off + n > MAXFILE*BSIZE){
     return -1;
-
+  }
   for(tot=0; tot<n; tot+=m, off+=m, src+=m){
     uint addr = bmap(ip, off/BSIZE);
     if(addr == 0)

kernel/fs.h

@@ -24,8 +24,9 @@ struct superblock {
 
 #define FSMAGIC 0x10203040
 
-#define NDIRECT 12
-#define NINDIRECT (BSIZE / sizeof(uint))
+#define NDIRECT 11
+#define NINDIRECT1 (BSIZE / sizeof(uint))
+#define NINDIRECT (NINDIRECT1 + NINDIRECT1 * NINDIRECT1)
 #define MAXFILE (NDIRECT + NINDIRECT)
 
 // On-disk inode structure
@@ -35,7 +36,7 @@ struct dinode {
   short minor;          // Minor device number (T_DEVICE only)
   short nlink;          // Number of links to inode in file system
   uint size;            // Size of file (bytes)
-  uint addrs[NDIRECT+1];   // Data block addresses
+  uint addrs[NDIRECT+2];   // Data block addresses
 };
 
 // Inodes per block.

kernel/kcsan.c

@@ -1,323 +0,0 @@
-#include "types.h"
-#include "param.h"
-#include "memlayout.h"
-#include "spinlock.h"
-#include "riscv.h"
-#include "proc.h"
-#include "defs.h"
-
-//
-// Race detector using gcc's thread sanitizer. It delays all stores
-// and loads and monitors if any other CPU is using the same address.
-// If so, we have a race and print out the backtrace of the thread
-// that raced and the thread that set the watchpoint.
-//
-
-//
-// To run with kcsan:
-// make clean
-// make KCSAN=1 qemu
-//
-
-// The number of watch points.
-#define NWATCH (NCPU)
-
-// The number of cycles to delay stores, whatever that means on qemu.
-//#define DELAY_CYCLES 20000
-#define DELAY_CYCLES 200000
-
-#define MAXTRACE 20
-
-int
-trace(uint64 *trace, int maxtrace)
-{
-  uint64 i = 0;
-  
-  push_off();
-  
-  uint64 fp = r_fp();
-  uint64 ra, low = PGROUNDDOWN(fp) + 16, high = PGROUNDUP(fp);
-
-  while(!(fp & 7) && fp >= low && fp < high){
-    ra = *(uint64*)(fp - 8);
-    fp = *(uint64*)(fp - 16);
-    trace[i++] = ra;
-    if(i >= maxtrace)
-      break;
-  }
-
-  pop_off();
-  
-  return i;
-}
-
-struct watch {
-  uint64 addr;
-  int write;
-  int race;
-  uint64 trace[MAXTRACE];
-  int tracesz;
-};
-  
-struct {
-  struct spinlock lock;
-  struct watch points[NWATCH];
-  int on;
-} tsan;
-
-static struct watch*
-wp_lookup(uint64 addr)
-{
-  for(struct watch *w = &tsan.points[0]; w < &tsan.points[NWATCH]; w++) {
-    if(w->addr == addr) {
-      return w;
-    }
-  }
-  return 0;
-}
-
-static int
-wp_install(uint64 addr, int write)
-{
-  for(struct watch *w = &tsan.points[0]; w < &tsan.points[NWATCH]; w++) {
-    if(w->addr == 0) {
-      w->addr = addr;
-      w->write = write;
-      w->tracesz = trace(w->trace, MAXTRACE);
-      return 1;
-    }
-  }
-  panic("wp_install");
-  return 0;
-}
-
-static void
-wp_remove(uint64 addr)
-{
-  for(struct watch *w = &tsan.points[0]; w < &tsan.points[NWATCH]; w++) {
-    if(w->addr == addr) {
-      w->addr = 0;
-      w->tracesz = 0;
-      return;
-    }
-  }
-  panic("remove");
-}
-
-static void
-printtrace(uint64 *t, int n)
-{
-  int i;
-  
-  for(i = 0; i < n; i++) {
-    printf("%p\n", (void*) t[i]);
-  }
-}
-
-static void
-race(char *s, struct watch *w) {
-  uint64 t[MAXTRACE];
-  int n;
-  
-  n = trace(t, MAXTRACE);
-  printf("== race detected ==\n");
-  printf("backtrace for racing %s\n", s);
-  printtrace(t, n);
-  printf("backtrace for watchpoint:\n");
-  printtrace(w->trace, w->tracesz);
-  printf("==========\n");
-}
-
-// cycle counter
-static inline uint64
-r_cycle()
-{
-  uint64 x;
-  asm volatile("rdcycle %0" : "=r" (x) );
-  return x;
-}
-
-static void delay(void) __attribute__((noinline));
-static void delay() {
-  uint64 stop = r_cycle() + DELAY_CYCLES;
-  uint64 c = r_cycle();
-  while(c < stop) {
-    c = r_cycle();
-  }
-}
-
-static void
-kcsan_read(uint64 addr, int sz)
-{
-  struct watch *w;
-  
-  acquire(&tsan.lock);
-  if((w = wp_lookup(addr)) != 0) {
-    if(w->write) {
-      race("load", w);
-    }
-    release(&tsan.lock);
-    return;
-  }
-  release(&tsan.lock);
-}
-
-static void
-kcsan_write(uint64 addr, int sz)
-{
-  struct watch *w;
-  
-  acquire(&tsan.lock);
-  if((w = wp_lookup(addr)) != 0) {
-    race("store", w);
-    release(&tsan.lock);
-  }
-
-  // no watchpoint; try to install one
-  if(wp_install(addr, 1)) {
-
-    release(&tsan.lock);
-
-    // XXX maybe read value at addr before and after delay to catch
-    // races of unknown origins (e.g., device).
-
-    delay(); 
-
-    acquire(&tsan.lock);
-
-    wp_remove(addr);
-  }
-  release(&tsan.lock);
-}
-
-// tsan.on will only have effect with "make KCSAN=1"
-void
-kcsaninit(void)
-{
-  initlock(&tsan.lock, "tsan");
-  tsan.on = 1;
-  __sync_synchronize();
-}
-
-//
-// Calls inserted by compiler into kernel binary, except for this file.
-//
-
-void
-__tsan_init(void)
-{
-}
-
-void
-__tsan_read1(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  // kcsan_read(addr, 1);
-}
-
-void
-__tsan_read2(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  kcsan_read(addr, 2);
-}
-
-void
-__tsan_read4(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  kcsan_read(addr, 4);
-}
-
-void
-__tsan_read8(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  kcsan_read(addr, 8);
-}
-
-void
-__tsan_read_range(uint64 addr, uint64 size)
-{
-  if(!tsan.on)
-    return;
-  kcsan_read(addr, size);
-}
-
-void
-__tsan_write1(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  // kcsan_write(addr, 1);
-}
-
-void
-__tsan_write2(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  kcsan_write(addr, 2);
-}
-
-void
-__tsan_write4(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  kcsan_write(addr, 4);
-}
-
-void
-__tsan_write8(uint64 addr)
-{
-  if(!tsan.on)
-    return;
-  kcsan_write(addr, 8);
-}
-
-void
-__tsan_write_range(uint64 addr, uint64 size)
-{
-  if(!tsan.on)
-    return;
-  kcsan_write(addr, size);
-}
-
-void
-__tsan_atomic_thread_fence(int order)
-{
-  __sync_synchronize();
-}
-
-uint32
-__tsan_atomic32_load(uint *ptr, uint *val, int order)
-{
-  uint t;
-  __atomic_load(ptr, &t, __ATOMIC_SEQ_CST);
-  return t;
-}
-
-void
-__tsan_atomic32_store(uint *ptr, uint val, int order)
-{
-  __atomic_store(ptr, &val, __ATOMIC_SEQ_CST);
-}
-
-// We don't use this
-void
-__tsan_func_entry(uint64 pc)
-{
-}
-
-// We don't use this
-void
-__tsan_func_exit(void)
-{
-}
-
-

kernel/main.c

@@ -12,9 +12,6 @@ main()
 {
   if(cpuid() == 0){
     consoleinit();
-#if defined(LAB_LOCK)
-    statsinit();
-#endif
     printfinit();
     printf("\n");
     printf("xv6 kernel is booting\n");
@@ -31,17 +28,11 @@ main()
     iinit();         // inode table
     fileinit();      // file table
     virtio_disk_init(); // emulated hard disk
-#ifdef LAB_NET
-    pci_init();
-#endif    
     userinit();      // first user process
-#ifdef KCSAN
-    kcsaninit();
-#endif
     __sync_synchronize();
     started = 1;
   } else {
-    while(atomic_read4((int *) &started) == 0)
+    while(started == 0)
       ;
     __sync_synchronize();
     printf("hart %d starting\n", cpuid());

kernel/param.h

@@ -1,4 +1,8 @@
-#define NPROC        64  // maximum number of processes
+#ifdef LAB_FS
+#define NPROC        10  // maximum number of processes
+#else
+#define NPROC        64  // maximum number of processes (speedsup bigfile)
+#endif
 #define NCPU          8  // maximum number of CPUs
 #define NOFILE       16  // open files per process
 #define NFILE       100  // open files per system
@@ -9,7 +13,21 @@
 #define MAXOPBLOCKS  10  // max # of blocks any FS op writes
 #define LOGSIZE      (MAXOPBLOCKS*3)  // max data blocks in on-disk log
 #define NBUF         (MAXOPBLOCKS*3)  // size of disk block cache
-#define FSSIZE       2000  // size of file system in blocks
+#ifdef LAB_FS
+#define FSSIZE       200000  // size of file system in blocks
+#else
+#ifdef LAB_LOCK
+#define FSSIZE       10000  // size of file system in blocks
+#else
+#define FSSIZE       2000   // size of file system in blocks
+#endif
+#endif
 #define MAXPATH      128   // maximum file path name
-#define USERSTACK    1     // user stack pages
+
+#ifdef LAB_UTIL
+#define USERSTACK    2     // user stack pages
+#else
+#define USERSTACK    1     // user stack pages
+#endif
+
 

kernel/pipe.c

@@ -68,9 +68,6 @@ pipeclose(struct pipe *pi, int writable)
   }
   if(pi->readopen == 0 && pi->writeopen == 0){
     release(&pi->lock);
-#ifdef LAB_LOCK
-    freelock(&pi->lock);
-#endif    
     kfree((char*)pi);
   } else
     release(&pi->lock);

kernel/proc.c

@@ -98,7 +98,6 @@ allocpid()
   pid = nextpid;
   nextpid = nextpid + 1;
   release(&pid_lock);
-
   return pid;
 }
 
@@ -132,6 +131,7 @@ found:
     return 0;
   }
 
+
   // An empty user page table.
   p->pagetable = proc_pagetable(p);
   if(p->pagetable == 0){
@@ -202,6 +202,7 @@ proc_pagetable(struct proc *p)
     return 0;
   }
 
+
   return pagetable;
 }
 
@@ -263,6 +264,7 @@ growproc(int n)
   struct proc *p = myproc();
 
   sz = p->sz;
+  
   if(n > 0){
     if((sz = uvmalloc(p->pagetable, sz, sz + n, PTE_W)) == 0) {
       return -1;
@@ -287,7 +289,7 @@ fork(void)
   if((np = allocproc()) == 0){
     return -1;
   }
-
+  
   // Copy user memory from parent to child.
   if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
     freeproc(np);
@@ -296,6 +298,7 @@ fork(void)
   }
   np->sz = p->sz;
 
+
   // copy saved user registers.
   *(np->trapframe) = *(p->trapframe);
 
@@ -313,13 +316,14 @@ fork(void)
   pid = np->pid;
 
   release(&np->lock);
-
+  
   acquire(&wait_lock);
   np->parent = p;
   release(&wait_lock);
 
   acquire(&np->lock);
   np->state = RUNNABLE;
+
   release(&np->lock);
 
   return pid;
@@ -360,6 +364,7 @@ exit(int status)
     }
   }
 
+  
   begin_op();
   iput(p->cwd);
   end_op();
@@ -454,28 +459,33 @@ scheduler(void)
     // processes are waiting.
     intr_on();
 
-    int found = 0;
+    int nproc = 0;
     for(p = proc; p < &proc[NPROC]; p++) {
       acquire(&p->lock);
+      if(p->state != UNUSED) {
+        nproc++;
+      }
       if(p->state == RUNNABLE) {
         // Switch to chosen process.  It is the process's job
         // to release its lock and then reacquire it
         // before jumping back to us.
         p->state = RUNNING;
         c->proc = p;
+        
         swtch(&c->context, &p->context);
 
         // Process is done running for now.
         // It should have changed its p->state before coming back.
         c->proc = 0;
-        found = 1;
       }
       release(&p->lock);
     }
-    if(found == 0) {
+    if(nproc <= 2) {   // only init and sh exist
       // nothing to run; stop running on this core until an interrupt.
       intr_on();
+#ifndef LAB_FS
       asm volatile("wfi");
+#endif
     }
   }
 }
@@ -524,7 +534,7 @@ void
 forkret(void)
 {
   static int first = 1;
-
+  
   // Still holding p->lock from scheduler.
   release(&myproc()->lock);
 
@@ -693,3 +703,6 @@ procdump(void)
     printf("\n");
   }
 }
+
+
+

kernel/riscv.h

@@ -204,7 +204,7 @@ r_menvcfg()
 static inline void 
 w_menvcfg(uint64 x)
 {
-  //asm volatile("csrw menvcfg, %0" : : "r" (x));
+  // asm volatile("csrw menvcfg, %0" : : "r" (x));
   asm volatile("csrw 0x30a, %0" : : "r" (x));
 }
 
@@ -314,14 +314,6 @@ r_sp()
   return x;
 }
 
-static inline uint64
-r_fp()
-{
-  uint64 x;
-  asm volatile("mv %0, s0" : "=r" (x) );
-  return x;
-}
-
 // read and write tp, the thread pointer, which xv6 uses to hold
 // this core's hartid (core number), the index into cpus[].
 static inline uint64
@@ -362,11 +354,6 @@ typedef uint64 *pagetable_t; // 512 PTEs
 #define PGSIZE 4096 // bytes per page
 #define PGSHIFT 12  // bits of offset within a page
 
-#ifdef LAB_PGTBL
-#define SUPERPGSIZE (2 * (1 << 20)) // bytes per page
-#define SUPERPGROUNDUP(sz)  (((sz)+SUPERPGSIZE-1) & ~(SUPERPGSIZE-1))
-#endif
-
 #define PGROUNDUP(sz)  (((sz)+PGSIZE-1) & ~(PGSIZE-1))
 #define PGROUNDDOWN(a) (((a)) & ~(PGSIZE-1))
 
@@ -376,12 +363,6 @@ typedef uint64 *pagetable_t; // 512 PTEs
 #define PTE_X (1L << 3)
 #define PTE_U (1L << 4) // user can access
 
-
-
-#if defined(LAB_MMAP) || defined(LAB_PGTBL)
-#define PTE_LEAF(pte) (((pte) & PTE_R) | ((pte) & PTE_W) | ((pte) & PTE_X))
-#endif
-
 // shift a physical address to the right place for a PTE.
 #define PA2PTE(pa) ((((uint64)pa) >> 12) << 10)
 

kernel/spinlock.c

@@ -8,52 +8,12 @@
 #include "proc.h"
 #include "defs.h"
 
-#ifdef LAB_LOCK
-#define NLOCK 500
-
-static struct spinlock *locks[NLOCK];
-struct spinlock lock_locks;
-
-void
-freelock(struct spinlock *lk)
-{
-  acquire(&lock_locks);
-  int i;
-  for (i = 0; i < NLOCK; i++) {
-    if(locks[i] == lk) {
-      locks[i] = 0;
-      break;
-    }
-  }
-  release(&lock_locks);
-}
-
-static void
-findslot(struct spinlock *lk) {
-  acquire(&lock_locks);
-  int i;
-  for (i = 0; i < NLOCK; i++) {
-    if(locks[i] == 0) {
-      locks[i] = lk;
-      release(&lock_locks);
-      return;
-    }
-  }
-  panic("findslot");
-}
-#endif
-
 void
 initlock(struct spinlock *lk, char *name)
 {
   lk->name = name;
   lk->locked = 0;
   lk->cpu = 0;
-#ifdef LAB_LOCK
-  lk->nts = 0;
-  lk->n = 0;
-  findslot(lk);
-#endif  
 }
 
 // Acquire the lock.
@@ -65,21 +25,12 @@ acquire(struct spinlock *lk)
   if(holding(lk))
     panic("acquire");
 
-#ifdef LAB_LOCK
-    __sync_fetch_and_add(&(lk->n), 1);
-#endif      
-
   // On RISC-V, sync_lock_test_and_set turns into an atomic swap:
   //   a5 = 1
   //   s1 = &lk->locked
   //   amoswap.w.aq a5, a5, (s1)
-  while(__sync_lock_test_and_set(&lk->locked, 1) != 0) {
-#ifdef LAB_LOCK
-    __sync_fetch_and_add(&(lk->nts), 1);
-#else
-   ;
-#endif
-  }
+  while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
+    ;
 
   // Tell the C compiler and the processor to not move loads or stores
   // past this point, to ensure that the critical section's memory
@@ -157,61 +108,3 @@ pop_off(void)
   if(c->noff == 0 && c->intena)
     intr_on();
 }
-
-// Read a shared 32-bit value without holding a lock
-int
-atomic_read4(int *addr) {
-  uint32 val;
-  __atomic_load(addr, &val, __ATOMIC_SEQ_CST);
-  return val;
-}
-
-#ifdef LAB_LOCK
-int
-snprint_lock(char *buf, int sz, struct spinlock *lk)
-{
-  int n = 0;
-  if(lk->n > 0) {
-    n = snprintf(buf, sz, "lock: %s: #test-and-set %d #acquire() %d\n",
-                 lk->name, lk->nts, lk->n);
-  }
-  return n;
-}
-
-int
-statslock(char *buf, int sz) {
-  int n;
-  int tot = 0;
-
-  acquire(&lock_locks);
-  n = snprintf(buf, sz, "--- lock kmem/bcache stats\n");
-  for(int i = 0; i < NLOCK; i++) {
-    if(locks[i] == 0)
-      break;
-    if(strncmp(locks[i]->name, "bcache", strlen("bcache")) == 0 ||
-       strncmp(locks[i]->name, "kmem", strlen("kmem")) == 0) {
-      tot += locks[i]->nts;
-      n += snprint_lock(buf +n, sz-n, locks[i]);
-    }
-  }
-  
-  n += snprintf(buf+n, sz-n, "--- top 5 contended locks:\n");
-  int last = 100000000;
-  // stupid way to compute top 5 contended locks
-  for(int t = 0; t < 5; t++) {
-    int top = 0;
-    for(int i = 0; i < NLOCK; i++) {
-      if(locks[i] == 0)
-        break;
-      if(locks[i]->nts > locks[top]->nts && locks[i]->nts < last) {
-        top = i;
-      }
-    }
-    n += snprint_lock(buf+n, sz-n, locks[top]);
-    last = locks[top]->nts;
-  }
-  n += snprintf(buf+n, sz-n, "tot= %d\n", tot);
-  release(&lock_locks);  
-  return n;
-}
-#endif

kernel/spinlock.h

@@ -5,9 +5,5 @@ struct spinlock {
   // For debugging:
   char *name;        // Name of lock.
   struct cpu *cpu;   // The cpu holding the lock.
-#ifdef LAB_LOCK
-  int nts;
-  int n;
-#endif
 };
 

kernel/sprintf.c

@@ -1,88 +0,0 @@
-#include <stdarg.h>
-
-#include "types.h"
-#include "param.h"
-#include "spinlock.h"
-#include "sleeplock.h"
-#include "fs.h"
-#include "file.h"
-#include "riscv.h"
-#include "defs.h"
-
-static char digits[] = "0123456789abcdef";
-
-static int
-sputc(char *s, char c)
-{
-  *s = c;
-  return 1;
-}
-
-static int
-sprintint(char *s, int xx, int base, int sign)
-{
-  char buf[16];
-  int i, n;
-  uint x;
-
-  if(sign && (sign = xx < 0))
-    x = -xx;
-  else
-    x = xx;
-
-  i = 0;
-  do {
-    buf[i++] = digits[x % base];
-  } while((x /= base) != 0);
-
-  if(sign)
-    buf[i++] = '-';
-
-  n = 0;
-  while(--i >= 0)
-    n += sputc(s+n, buf[i]);
-  return n;
-}
-
-int
-snprintf(char *buf, unsigned long sz, const char *fmt, ...)
-{
-  va_list ap;
-  int i, c;
-  int off = 0;
-  char *s;
-
-  va_start(ap, fmt);
-  for(i = 0; off < sz && (c = fmt[i] & 0xff) != 0; i++){
-    if(c != '%'){
-      off += sputc(buf+off, c);
-      continue;
-    }
-    c = fmt[++i] & 0xff;
-    if(c == 0)
-      break;
-    switch(c){
-    case 'd':
-      off += sprintint(buf+off, va_arg(ap, int), 10, 1);
-      break;
-    case 'x':
-      off += sprintint(buf+off, va_arg(ap, int), 16, 1);
-      break;
-    case 's':
-      if((s = va_arg(ap, char*)) == 0)
-        s = "(null)";
-      for(; *s && off < sz; s++)
-        off += sputc(buf+off, *s);
-      break;
-    case '%':
-      off += sputc(buf+off, '%');
-      break;
-    default:
-      // Print unknown % sequence to draw attention.
-      off += sputc(buf+off, '%');
-      off += sputc(buf+off, c);
-      break;
-    }
-  }
-  return off;
-}

kernel/start.c

@@ -32,11 +32,6 @@ start()
   w_mideleg(0xffff);
   w_sie(r_sie() | SIE_SEIE | SIE_STIE | SIE_SSIE);
 
-#ifdef KCSAN
-  // allow supervisor to read cycle counter register
-  w_mcounteren(r_mcounteren()|0x3);
-#endif
-  
   // configure Physical Memory Protection to give supervisor mode
   // access to all of physical memory.
   w_pmpaddr0(0x3fffffffffffffull);

kernel/stat.h

@@ -1,7 +1,7 @@
 #define T_DIR     1   // Directory
 #define T_FILE    2   // File
 #define T_DEVICE  3   // Device
-
+#define T_SYMLINK 4
 struct stat {
   int dev;     // File system's disk device
   uint ino;    // Inode number

kernel/stats.c

@@ -1,69 +0,0 @@
-#include <stdarg.h>
-
-#include "types.h"
-#include "param.h"
-#include "spinlock.h"
-#include "sleeplock.h"
-#include "fs.h"
-#include "file.h"
-#include "riscv.h"
-#include "defs.h"
-
-#define BUFSZ 4096
-static struct {
-  struct spinlock lock;
-  char buf[BUFSZ];
-  int sz;
-  int off;
-} stats;
-
-int statscopyin(char*, int);
-int statslock(char*, int);
-  
-int
-statswrite(int user_src, uint64 src, int n)
-{
-  return -1;
-}
-
-int
-statsread(int user_dst, uint64 dst, int n)
-{
-  int m;
-
-  acquire(&stats.lock);
-
-  if(stats.sz == 0) {
-#ifdef LAB_PGTBL
-    stats.sz = statscopyin(stats.buf, BUFSZ);
-#endif
-#ifdef LAB_LOCK
-    stats.sz = statslock(stats.buf, BUFSZ);
-#endif
-  }
-  m = stats.sz - stats.off;
-
-  if (m > 0) {
-    if(m > n)
-      m  = n;
-    if(either_copyout(user_dst, dst, stats.buf+stats.off, m) != -1) {
-      stats.off += m;
-    }
-  } else {
-    m = -1;
-    stats.sz = 0;
-    stats.off = 0;
-  }
-  release(&stats.lock);
-  return m;
-}
-
-void
-statsinit(void)
-{
-  initlock(&stats.lock, "stats");
-
-  devsw[STATS].read = statsread;
-  devsw[STATS].write = statswrite;
-}
-

kernel/syscall.c

@@ -101,7 +101,7 @@ extern uint64 sys_unlink(void);
 extern uint64 sys_link(void);
 extern uint64 sys_mkdir(void);
 extern uint64 sys_close(void);
-
+extern uint64 sys_symlink(void);
 // An array mapping syscall numbers from syscall.h
 // to the function that handles the system call.
 static uint64 (*syscalls[])(void) = {
@@ -126,6 +126,7 @@ static uint64 (*syscalls[])(void) = {
 [SYS_link]    sys_link,
 [SYS_mkdir]   sys_mkdir,
 [SYS_close]   sys_close,
+[SYS_symlink] sys_symlink
 };
 
 void

kernel/syscall.h

@@ -20,3 +20,4 @@
 #define SYS_link   19
 #define SYS_mkdir  20
 #define SYS_close  21
+#define SYS_symlink 22

kernel/sysfile.c

@@ -327,6 +327,27 @@ sys_open(void)
       end_op();
       return -1;
     }
+    int dep=0;
+    if((omode & O_NOFOLLOW)==0){
+      while(1){
+        ilock(ip);
+        if(ip->type!=T_SYMLINK){
+          iunlock(ip);
+          break;
+        }
+        readi(ip,0,(uint64)path,0,MAXPATH);
+        iunlockput(ip);
+        if((ip = namei(path)) == 0){
+          end_op();
+          return -1;
+        }
+        ++dep;
+        if(dep>=10){
+          end_op();
+          return -1;
+        }
+      }
+    }
     ilock(ip);
     if(ip->type == T_DIR && omode != O_RDONLY){
       iunlockput(ip);
@@ -348,7 +369,7 @@ sys_open(void)
     end_op();
     return -1;
   }
-
+  
   if(ip->type == T_DEVICE){
     f->type = FD_DEVICE;
     f->major = ip->major;
@@ -474,6 +495,31 @@ sys_exec(void)
   return -1;
 }
 
+uint64 sys_symlink(){
+  char target[MAXPATH],path[MAXPATH];
+  if(argstr(0, target, MAXPATH) < 0 || argstr(1, path, MAXPATH) < 0)
+    goto ERR1;
+  begin_op();
+  struct inode *ip;
+  if((ip = namei(path)) == 0){
+    if((ip = create(path, T_SYMLINK,0,0))==0)
+      goto ERR2;
+  }else
+    ilock(ip);
+  if(writei(ip,0,(uint64)target,0,MAXPATH)<0){
+    goto ERR3;
+  }
+  iunlockput(ip);
+  end_op();
+  return 0;
+  ERR3:
+  iunlockput(ip);
+  ERR2:
+  end_op();
+  ERR1:
+  return -1;
+}
+
 uint64
 sys_pipe(void)
 {

kernel/virtio_disk.c

@@ -212,28 +212,6 @@ alloc3_desc(int *idx)
   return 0;
 }
 
-#ifdef LAB_LOCK
-//
-// check that there are at most NBUF distinct
-// struct buf's, which the lock lab requires.
-//
-static struct buf *xbufs[NBUF];
-static void
-checkbuf(struct buf *b)
-{
-  for(int i = 0; i < NBUF; i++){
-    if(xbufs[i] == b){
-      return;
-    }
-    if(xbufs[i] == 0){
-      xbufs[i] = b;
-      return;
-    }
-  }
-  panic("more than NBUF bufs");
-}
-#endif
-
 void
 virtio_disk_rw(struct buf *b, int write)
 {
@@ -241,10 +219,6 @@ virtio_disk_rw(struct buf *b, int write)
 
   acquire(&disk.vdisk_lock);
 
-#ifdef LAB_LOCK
-  checkbuf(b);
-#endif
-
   // the spec's Section 5.2 says that legacy block operations use
   // three descriptors: one for type/reserved/sector, one for the
   // data, one for a 1-byte status result.

time.txt

@@ -0,0 +1 @@
+6

user/bcachetest.c

@@ -1,400 +0,0 @@
-#include "kernel/fcntl.h"
-#include "kernel/param.h"
-#include "kernel/types.h"
-#include "kernel/stat.h"
-#include "kernel/riscv.h"
-#include "kernel/fs.h"
-#include "user/user.h"
-
-void test0();
-void test1();
-void test2();
-void test3();
-
-#define SZ 4096
-char buf[SZ];
-
-int
-main(int argc, char *argv[])
-{
-  test0();
-  test1();
-  test2();
-  test3();
-  exit(0);
-}
-
-void
-createfile(char *file, int nblock)
-{
-  int fd;
-  char buf[BSIZE];
-  int i;
-  
-  fd = open(file, O_CREATE | O_RDWR);
-  if(fd < 0){
-    printf("createfile %s failed\n", file);
-    exit(-1);
-  }
-  for(i = 0; i < nblock; i++) {
-    if(write(fd, buf, sizeof(buf)) != sizeof(buf)) {
-      printf("write %s failed\n", file);
-      exit(-1);
-    }
-  }
-  close(fd);
-}
-
-void
-readfile(char *file, int nbytes, int inc)
-{
-  char buf[BSIZE];
-  int fd;
-  int i;
-
-  if(inc > BSIZE) {
-    printf("readfile: inc too large\n");
-    exit(-1);
-  }
-  if ((fd = open(file, O_RDONLY)) < 0) {
-    printf("readfile open %s failed\n", file);
-    exit(-1);
-  }
-  for (i = 0; i < nbytes; i += inc) {
-    if(read(fd, buf, inc) != inc) {
-      printf("read %s failed for block %d (%d)\n", file, i, nbytes);
-      exit(-1);
-    }
-  }
-  close(fd);
-}
-
-int ntas(int print)
-{
-  int n;
-  char *c;
-
-  if (statistics(buf, SZ) <= 0) {
-    fprintf(2, "ntas: no stats\n");
-  }
-  c = strchr(buf, '=');
-  n = atoi(c+2);
-  if(print)
-    printf("%s", buf);
-  return n;
-}
-
-// Test reading small files concurrently
-void
-test0()
-{
-  char file[2];
-  char dir[2];
-  enum { N = 10, NCHILD = 3 };
-  int m, n;
-
-  dir[0] = '0';
-  dir[1] = '\0';
-  file[0] = 'F';
-  file[1] = '\0';
-
-  printf("start test0\n");
-  for(int i = 0; i < NCHILD; i++){
-    dir[0] = '0' + i;
-    mkdir(dir);
-    if (chdir(dir) < 0) {
-      printf("chdir failed\n");
-      exit(1);
-    }
-    unlink(file);
-    createfile(file, N);
-    if (chdir("..") < 0) {
-      printf("chdir failed\n");
-      exit(1);
-    }
-  }
-  m = ntas(0);
-  for(int i = 0; i < NCHILD; i++){
-    dir[0] = '0' + i;
-    int pid = fork();
-    if(pid < 0){
-      printf("fork failed");
-      exit(-1);
-    }
-    if(pid == 0){
-      if (chdir(dir) < 0) {
-        printf("chdir failed\n");
-        exit(1);
-      }
-
-      readfile(file, N*BSIZE, 1);
-
-      exit(0);
-    }
-  }
-  
-  int status = 0;
-  for(int i = 0; i < NCHILD; i++){
-    wait(&status);
-    if (status != 0) {
-      printf("FAIL: a child failed\n");
-      exit(1);
-    }  
-  }
-  
-  printf("test0 results:\n");
-  n = ntas(1);
-  if (n-m < 500)
-    printf("test0: OK\n");
-  else
-    printf("test0: FAIL\n");
-}
-
-// Test bcache evictions by reading a large file concurrently
-void test1()
-{
-  char file[3];
-  enum { N = 200, BIG=100, NCHILD=2 };
-  
-  printf("start test1\n");
-  file[0] = 'B';
-  file[2] = '\0';
-  for(int i = 0; i < NCHILD; i++){
-    file[1] = '0' + i;
-    unlink(file);
-    if (i == 0) {
-      createfile(file, BIG);
-    } else {
-      createfile(file, 1);
-    }
-  }
-  for(int i = 0; i < NCHILD; i++){
-    file[1] = '0' + i;
-    int pid = fork();
-    if(pid < 0){
-      printf("fork failed");
-      exit(-1);
-    }
-    if(pid == 0){
-      if (i==0) {
-        for (i = 0; i < N; i++) {
-          readfile(file, BIG*BSIZE, BSIZE);
-        }
-        unlink(file);
-        exit(0);
-      } else {
-        for (i = 0; i < N*20; i++) {
-          readfile(file, 1, BSIZE);
-        }
-        unlink(file);
-      }
-      exit(0);
-    }
-  }
-
-  int status = 0;
-  for(int i = 0; i < NCHILD; i++){
-    wait(&status);
-    if (status != 0) {
-      printf("FAIL: a child failed\n");
-      exit(1);
-    }  
-  }
-
-  printf("\ntest1 OK\n");
-}
-
-//
-// test concurrent creates.
-//
-void
-test2()
-{
-  int nc = 4;
-  char file[16];
-
-  printf("start test2\n");
-  
-  mkdir("d2");
-
-  file[0] = 'd';
-  file[1] = '2';
-  file[2] = '/';
-
-  // remove any stale existing files.
-  for(int i = 0; i < 50; i++){
-    for(int ci = 0; ci < nc; ci++){
-      file[3] = 'a' + ci;
-      file[4] = '0' + i;
-      file[5] = '\0';
-      unlink(file);
-    }
-  }
-
-  int pids[nc];
-  for(int ci = 0; ci < nc; ci++){
-    pids[ci] = fork();
-    if(pids[ci] < 0){
-      printf("test2: fork failed\n");
-      exit(1);
-    }
-    if(pids[ci] == 0){
-      char me = "abcdefghijklmnop"[ci];
-      int pid = getpid();
-      int nf = (ci == 0 ? 10 : 15);
-
-      // create nf files.
-      for(int i = 0; i < nf; i++){
-        file[3] = me;
-        file[4] = '0' + i;
-        file[5] = '\0';
-        int fd = open(file, O_CREATE | O_RDWR);
-        if(fd < 0){
-          printf("test2: create %s failed\n", file);
-          exit(1);
-        }
-        int xx = (pid << 16) | i;
-        for(int nw = 0; nw < 2; nw++){
-          // the sleep() increases the chance of simultaneous
-          // calls to bget().
-          sleep(1);
-          if(write(fd, &xx, sizeof(xx)) <= 0){
-            printf("test2: write %s failed\n", file);
-            exit(1);
-          }
-        }
-        close(fd);
-      }
-
-      // read back the nf files.
-      for(int i = 0; i < nf; i++){
-        file[3] = me;
-        file[4] = '0' + i;
-        file[5] = '\0';
-        // printf("r %s\n", file);
-        int fd = open(file, O_RDWR);
-        if(fd < 0){
-          printf("test2: open %s failed\n", file);
-          exit(1);
-        }
-        int xx = (pid << 16) | i;
-        for(int nr = 0; nr < 2; nr++){
-          int z = 0;
-          sleep(1);
-          int n = read(fd, &z, sizeof(z));
-          if(n != sizeof(z)){
-            printf("test2: read %s returned %d, expected %ld\n", file, n, sizeof(z));
-            exit(1);
-          }
-          if(z != xx){
-            printf("test2: file %s contained %d, not %d\n", file, z, xx);
-            exit(1);
-          }
-        }
-        close(fd);
-      }
-
-      // delete the nf files.
-      for(int i = 0; i < nf; i++){
-        file[3] = me;
-        file[4] = '0' + i;
-        file[5] = '\0';
-        //printf("u %s\n", file);
-        if(unlink(file) != 0){
-          printf("test2: unlink %s failed\n", file);
-          exit(1);
-        }
-      }
-
-      exit(0);
-    }
-  }
-
-  int ok = 1;
-
-  for(int ci = 0; ci < nc; ci++){
-    int st = 0;
-    int ret = wait(&st);
-    if(ret <= 0){
-      printf("test2: wait() failed\n");
-      ok = 0;
-    }
-    if(st != 0)
-      ok = 0;
-  }
-  if(ok) {
-    printf("\ntest2 OK\n");
-  } else {
-    printf("test2 failed\n");
-  }
-}
-
-//
-// generate big log transactions to check that bget() can
-// make use of any of the NBUF buffers for any block number.
-//
-void
-test3()
-{
-  int nc = 5;
-  char file[16];
-
-  printf("start test3\n");
-  
-  mkdir("d2");
-
-  file[0] = 'd';
-  file[1] = '2';
-  file[2] = '/';
-
-  int pids[nc];
-  for(int ci = 0; ci < nc; ci++){
-    pids[ci] = fork();
-    if(pids[ci] < 0){
-      printf("test3: fork failed\n");
-      exit(1);
-    }
-    if(pids[ci] == 0){
-      file[3] = 'a' + ci;
-      file[4] = '\0';
-      unlink(file);
-      int fd = open(file, O_CREATE | O_RDWR);
-      if(fd < 0){
-        printf("test3: create %s failed\n", file);
-        exit(1);
-      }
-      write(fd, "x", 1);
-      static char junk[12*512];
-      for(int i = 0; i < 12; i++){
-        sleep(1);
-        write(fd, junk, sizeof(junk));
-      }
-      exit(0);
-    }
-  }
-
-  int ok = 1;
-
-  for(int ci = 0; ci < nc; ci++){
-    int st = 0;
-    int ret = wait(&st);
-    if(ret <= 0){
-      printf("test3: wait() failed\n");
-      ok = 0;
-    }
-    if(st != 0)
-      ok = 0;
-  }
-
-  for(int ci = 0; ci < nc; ci++){
-    file[3] = 'a' + ci;
-    file[4] = '\0';
-    unlink(file);
-  }
-
-  if(ok) {
-    printf("\ntest3 OK\n");
-  } else {
-    printf("test3 failed\n");
-  }
-}

user/bigfile.c

@@ -0,0 +1,63 @@
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "user/user.h"
+#include "kernel/fcntl.h"
+#include "kernel/fs.h"
+
+int
+main()
+{
+  char buf[BSIZE];
+  int fd, i, blocks, readblocks;
+
+  fd = open("big.file", O_CREATE | O_WRONLY);
+  if(fd < 0){
+    printf("bigfile: cannot open big.file for writing\n");
+    exit(-1);
+  }
+
+  blocks = 0;
+  while(1){
+    *(int*)buf = blocks;
+    int cc = write(fd, buf, sizeof(buf));
+    if(cc <= 0)
+      break;
+    blocks++;
+    if (blocks % 100 == 0)
+      printf(".");
+  }
+
+  printf("\nwrote %d blocks\n", blocks);
+  if(blocks != 65803) {
+    printf("bigfile: file is too small\n");
+    exit(-1);
+  }
+  
+  close(fd);
+  fd = open("big.file", O_RDONLY);
+  printf("reading bigfile\n");
+  if(fd < 0){
+    printf("bigfile: cannot re-open big.file for reading\n");
+    exit(-1);
+  }
+  readblocks = 0;
+  for(i = 0; i < blocks; i++){
+    int cc = read(fd, buf, sizeof(buf));
+    if(cc <= 0){
+      printf("bigfile: read error at block %d\n", i);
+      exit(-1);
+    }
+    if(*(int*)buf != i){
+      printf("bigfile: read the wrong data (%d) for block %d\n",
+             *(int*)buf, i);
+      exit(-1);
+    }
+    readblocks++;
+    if (readblocks % 100 == 0)
+      printf(".");
+  }
+
+  printf("\nbigfile done; ok\n"); 
+
+  exit(0);
+}

user/init.c

@@ -18,7 +18,6 @@ main(void)
 
   if(open("console", O_RDWR) < 0){
     mknod("console", CONSOLE, 0);
-    mknod("statistics", STATS, 0);
     open("console", O_RDWR);
   }
   dup(0);  // stdout

user/kalloctest.c

@@ -1,198 +0,0 @@
-#include "kernel/param.h"
-#include "kernel/types.h"
-#include "kernel/stat.h"
-#include "kernel/riscv.h"
-#include "kernel/memlayout.h"
-#include "kernel/fcntl.h"
-#include "user/user.h"
-
-#define NCHILD 2
-#define N 100000
-#define SZ 4096
-
-void test1(void);
-void test2(void);
-void test3(void);
-char buf[SZ];
-
-int countfree();
-  
-int
-main(int argc, char *argv[])
-{
-  test1();
-  test2();
-  test3();
-  exit(0);
-}
-
-int ntas(int print)
-{
-  int n;
-  char *c;
-
-  if (statistics(buf, SZ) <= 0) {
-    fprintf(2, "ntas: no stats\n");
-  }
-  c = strchr(buf, '=');
-  n = atoi(c+2);
-  if(print)
-    printf("%s", buf);
-  return n;
-}
-
-// Test concurrent kallocs and kfrees
-void test1(void)
-{
-  void *a, *a1;
-  int n, m;
-
-  printf("start test1\n");  
-  m = ntas(0);
-  for(int i = 0; i < NCHILD; i++){
-    int pid = fork();
-    if(pid < 0){
-      printf("fork failed");
-      exit(-1);
-    }
-    if(pid == 0){
-      for(i = 0; i < N; i++) {
-        a = sbrk(4096);
-        *(int *)(a+4) = 1;
-        a1 = sbrk(-4096);
-        if (a1 != a + 4096) {
-          printf("test1: FAIL wrong sbrk\n");
-          exit(1);
-        }
-      }
-      exit(0);
-    }
-  }
-  int status = 0;
-  for(int i = 0; i < NCHILD; i++){
-    wait(&status);
-    if (status != 0) {
-      printf("FAIL: a child failed\n");
-      exit(1);
-    }
-  }
-  printf("test1 results:\n");
-  n = ntas(1);
-  if(n-m < 10) 
-    printf("test1 OK\n");
-  else
-    printf("test1 FAIL\n");
-}
-
-
-// Test stealing
-void test2() {
-  int free0 = countfree();
-  int free1;
-  int n = (PHYSTOP-KERNBASE)/PGSIZE;
-  printf("start test2\n");  
-  printf("total free number of pages: %d (out of %d)\n", free0, n);
-  if(n - free0 > 1000) {
-    printf("test2 FAILED: cannot allocate enough memory");
-    exit(1);
-  }
-  for (int i = 0; i < 50; i++) {
-    free1 = countfree();
-    if(i % 10 == 9)
-      printf(".");
-    if(free1 != free0) {
-      printf("test2 FAIL: losing pages %d %d\n", free0, free1);
-      exit(1);
-    }
-  }
-  printf("\ntest2 OK\n");  
-}
-
-// Test concurrent kalloc/kfree and stealing
-void test3(void)
-{
-  uint64 a, a1;
-  int n, m;
-
-  m = ntas(0);
-  printf("start test3\n");
-  int pid;
-  
-  for(int i = 0; i < NCHILD; i++){
-    pid = fork();
-    if(pid < 0){
-      printf("fork failed");
-      exit(-1);
-    }
-    if(pid == 0){
-      if (i == 0) {
-        for(i = 0; i < N; i++) {
-          a = (uint64) sbrk(4096);
-          if(a == 0xffffffffffffffff){
-            // no freemem
-            continue;
-          }
-          *(int *)(a+4) = 1;
-          a1 = (uint64) sbrk(-4096);
-          if (a1 != a + 4096) {
-            printf("test3 FAIL: wrong sbrk\n");
-            exit(1);
-          }
-          if ((i + 1) % 10000 == 0) {
-            printf(".");
-          }
-        }
-        printf("child done %d\n", i);
-        exit(0);
-      } else {
-        while (1) {
-          int free0 = countfree();
-          int free1 = countfree();
-          if(free0 - free1 > 1) {
-            printf("test3 FAIL: losing pages %d %d\n", free0, free1);
-            exit(1);
-          }
-        }
-      }
-    }
-  }
-
-  int status = 0;
-  for(int i = 0; i < NCHILD-1; i++){
-    wait(&status);
-    if (status != 0) {
-      printf("a child failed\n");
-      exit(1);
-    }
-  }
-  kill(pid);
-
-  n = ntas(1);
-  if(n-m < 4000) 
-    printf("\ntest3 OK\n");
-  else
-    printf("test3 FAIL m %d n %d\n", m, n);
-}
-
-
-//
-// countfree() from usertests.c
-//
-int
-countfree()
-{
-  uint64 sz0 = (uint64)sbrk(0);
-  int n = 0;
-
-  while(1){
-    uint64 a = (uint64) sbrk(4096);
-    if(a == 0xffffffffffffffff){
-      break;
-    }
-    // modify the memory to make sure it's really allocated.
-    *(char *)(a + 4096 - 1) = 1;
-    n += 1;
-  }
-  sbrk(-((uint64)sbrk(0) - sz0));
-  return n;
-}

user/statistics.c

@@ -1,24 +0,0 @@
-#include "kernel/types.h"
-#include "kernel/stat.h"
-#include "kernel/fcntl.h"
-#include "user/user.h"
-
-int
-statistics(void *buf, int sz)
-{
-  int fd, i, n;
-  
-  fd = open("statistics", O_RDONLY);
-  if(fd < 0) {
-      fprintf(2, "stats: open failed\n");
-      exit(1);
-  }
-  for (i = 0; i < sz; ) {
-    if ((n = read(fd, buf+i, sz-i)) < 0) {
-      break;
-    }
-    i += n;
-  }
-  close(fd);
-  return i;
-}

user/stats.c

@@ -1,24 +0,0 @@
-#include "kernel/types.h"
-#include "kernel/stat.h"
-#include "kernel/fcntl.h"
-#include "user/user.h"
-
-#define SZ 4096
-char buf[SZ];
-
-int
-main(void)
-{
-  int i, n;
-  
-  while (1) {
-    n = statistics(buf, SZ);
-    for (i = 0; i < n; i++) {
-      write(1, buf+i, 1);
-    }
-    if (n != SZ)
-      break;
-  }
-
-  exit(0);
-}

user/symlinktest.c

@@ -0,0 +1,244 @@
+#include "kernel/param.h"
+#include "kernel/types.h"
+#include "kernel/stat.h"
+#include "kernel/riscv.h"
+#include "kernel/fcntl.h"
+#include "kernel/spinlock.h"
+#include "kernel/sleeplock.h"
+#include "kernel/fs.h"
+#include "kernel/file.h"
+#include "user/user.h"
+
+#define fail(msg) do {printf("FAILURE: " msg "\n"); failed = 1; goto done;} while (0);
+static int failed = 0;
+
+static void testsymlink(void);
+static void concur(void);
+static void cleanup(void);
+
+int
+main(int argc, char *argv[])
+{
+  cleanup();
+  testsymlink();
+  concur();
+  exit(failed);
+}
+
+static void
+cleanup(void)
+{
+  unlink("/testsymlink/a");
+  unlink("/testsymlink/b");
+  unlink("/testsymlink/c");
+  unlink("/testsymlink/1");
+  unlink("/testsymlink/2");
+  unlink("/testsymlink/3");
+  unlink("/testsymlink/4");
+  unlink("/testsymlink/z");
+  unlink("/testsymlink/y");
+  for(int i = 0; i < NINODE+2; i++){
+    char name[32];
+    memset(name, 0, sizeof(name));
+    const char *base = "/testsymlink/";
+    strcpy(name, base);
+    name[strlen(base)+0] = 'a' + (i / 26);
+    name[strlen(base)+1] = 'a' + (i % 26);
+    unlink(name);
+  }
+  unlink("/testsymlink");
+}
+
+// stat a symbolic link using O_NOFOLLOW
+static int
+stat_slink(char *pn, struct stat *st)
+{
+  int fd = open(pn, O_RDONLY | O_NOFOLLOW);
+  if(fd < 0)
+    return -1;
+  if(fstat(fd, st) != 0)
+    return -1;
+  return 0;
+}
+
+static void
+testsymlink(void)
+{
+  int r, fd1 = -1, fd2 = -1;
+  char buf[4] = {'a', 'b', 'c', 'd'};
+  char c = 0, c2 = 0;
+  struct stat st;
+    
+  printf("Start: test symlinks\n");
+
+  mkdir("/testsymlink");
+
+  fd1 = open("/testsymlink/a", O_CREATE | O_RDWR);
+  if(fd1 < 0) fail("failed to open a");
+
+  r = symlink("/testsymlink/a", "/testsymlink/b");
+  if(r < 0)
+    fail("symlink b -> a failed");
+
+  if(write(fd1, buf, sizeof(buf)) != 4)
+    fail("failed to write to a");
+
+  if (stat_slink("/testsymlink/b", &st) != 0)
+    fail("failed to stat b");
+  if(st.type != T_SYMLINK)
+    fail("b isn't a symlink");
+
+  fd2 = open("/testsymlink/b", O_RDWR);
+  if(fd2 < 0)
+    fail("failed to open b");
+  read(fd2, &c, 1);
+  if (c != 'a')
+    fail("failed to read bytes from b");
+
+  unlink("/testsymlink/a");
+  if(open("/testsymlink/b", O_RDWR) >= 0)
+    fail("Should not be able to open b after deleting a");
+
+  r = symlink("/testsymlink/b", "/testsymlink/a");
+  if(r < 0)
+    fail("symlink a -> b failed");
+
+  r = open("/testsymlink/b", O_RDWR);
+  if(r >= 0)
+    fail("Should not be able to open b (cycle b->a->b->..)\n");
+  
+  r = symlink("/testsymlink/nonexistent", "/testsymlink/c");
+  if(r != 0)
+    fail("Symlinking to nonexistent file should succeed\n");
+
+  r = symlink("/testsymlink/2", "/testsymlink/1");
+  if(r) fail("Failed to link 1->2");
+  r = symlink("/testsymlink/3", "/testsymlink/2");
+  if(r) fail("Failed to link 2->3");
+  r = symlink("/testsymlink/4", "/testsymlink/3");
+  if(r) fail("Failed to link 3->4");
+
+  close(fd1);
+  close(fd2);
+  fd1 = fd2 = -1;
+
+  fd1 = open("/testsymlink/4", O_CREATE | O_RDWR);
+  if(fd1<0) fail("Failed to create 4\n");
+  fd2 = open("/testsymlink/1", O_RDWR);
+  if(fd2<0) fail("Failed to open 1\n");
+
+  c = '#';
+  r = write(fd2, &c, 1);
+  if(r!=1) fail("Failed to write to 1\n");
+  r = read(fd1, &c2, 1);
+  if(r!=1) fail("Failed to read from 4\n");
+  if(c!=c2)
+    fail("Value read from 4 differed from value written to 1\n");
+
+
+  close(fd1);
+  close(fd2);
+  fd1 = fd2 = -1;
+  //
+  // check that many symlinks can co-exist.
+  //
+  for(int i = 0; i < NINODE+2; i++){
+    char name[32];
+    memset(name, 0, sizeof(name));
+    const char *base = "/testsymlink/";
+    strcpy(name, base);
+    name[strlen(base)+0] = 'a' + (i / 26);
+    name[strlen(base)+1] = 'a' + (i % 26);
+    r = symlink("/testsymlink/4", name);
+    if(r) fail("symlink() failed in many test");
+  }
+  for(int i = 0; i < NINODE+2; i++){
+    char name[32];
+    memset(name, 0, sizeof(name));
+    const char *base = "/testsymlink/";
+    strcpy(name, base);
+    name[strlen(base)+0] = 'a' + (i / 26);
+    name[strlen(base)+1] = 'a' + (i % 26);
+    fd1 = open(name, O_RDONLY);
+    if(fd1 < 0)
+      fail("open() failed in many test");
+    char buf[16];
+    buf[0] = '\0';
+    if(read(fd1, buf, sizeof(buf)) != 1)
+      fail("read() failed in many test");
+    if(buf[0] != '#')
+      fail("wrong content in many test");
+    close(fd1);
+    fd1 = -1;
+  }
+
+  unlink("/testsymlink/a");
+  if(symlink("/README", "/testsymlink/a") != 0)
+    fail("could not link to /README");
+  fd1 = open("/testsymlink/a", O_RDONLY);
+  if(fd1 < 0)
+    fail("could not open symlink pointing to /README");
+  close(fd1);
+  fd1 = -1;
+
+  printf("test symlinks: ok\n");
+done:
+  close(fd1);
+  close(fd2);
+}
+
+static void
+concur(void)
+{
+  int pid, i;
+  int fd;
+  struct stat st;
+  int nchild = 2;
+
+  printf("Start: test concurrent symlinks\n");
+    
+  fd = open("/testsymlink/z", O_CREATE | O_RDWR);
+  if(fd < 0) {
+    printf("FAILED: open failed");
+    exit(1);
+  }
+  close(fd);
+
+  for(int j = 0; j < nchild; j++) {
+    pid = fork();
+    if(pid < 0){
+      printf("FAILED: fork failed\n");
+      exit(1);
+    }
+    if(pid == 0) {
+      int m = 0;
+      unsigned int x = (pid ? 1 : 97);
+      for(i = 0; i < 100; i++){
+        x = x * 1103515245 + 12345;
+        if((x % 3) == 0) {
+          symlink("/testsymlink/z", "/testsymlink/y");
+          if (stat_slink("/testsymlink/y", &st) == 0) {
+            m++;
+            if(st.type != T_SYMLINK) {
+              printf("FAILED: type %d not a symbolic link\n", st.type);
+              exit(1);
+            }
+          }
+        } else {
+          unlink("/testsymlink/y");
+        }
+      }
+      exit(0);
+    }
+  }
+
+  int r;
+  for(int j = 0; j < nchild; j++) {
+    wait(&r);
+    if(r != 0) {
+      printf("test concurrent symlinks: failed\n");
+      exit(1);
+    }
+  }
+  printf("test concurrent symlinks: ok\n");
+}

user/user.h

@@ -1,7 +1,3 @@
-#ifdef LAB_MMAP
-typedef unsigned long size_t;
-typedef long int off_t;
-#endif
 struct stat;
 
 // system calls
@@ -26,18 +22,7 @@ int getpid(void);
 char* sbrk(int);
 int sleep(int);
 int uptime(void);
-#ifdef LAB_NET
-int bind(uint16);
-int unbind(uint16);
-int send(uint16, uint32, uint16, char *, uint32);
-int recv(uint16, uint32*, uint16*, char *, uint32);
-#endif
-#ifdef LAB_PGTBL
-int ugetpid(void);
-uint64 pgpte(void*);
-void kpgtbl(void);
-#endif
-
+int symlink(const char *,const char *);
 // ulib.c
 int stat(const char*, struct stat*);
 char* strcpy(char*, const char*);
@@ -52,9 +37,6 @@ void* memset(void*, int, uint);
 int atoi(const char*);
 int memcmp(const void *, const void *, uint);
 void *memcpy(void *, const void *, uint);
-#ifdef LAB_LOCK
-int statistics(void*, int);
-#endif
 
 // umalloc.c
 void* malloc(uint);

user/usys.pl

@@ -36,3 +36,4 @@ entry("getpid");
 entry("sbrk");
 entry("sleep");
 entry("uptime");
+entry("symlink");