Merge branch 'old-types' into scale-amd64

ca9a35c1 · Silas Boyd-Wickizer · ef921d5f · 7ba4c12c · ca9a35c1 · ca9a35c1
--- a/Makefile
+++ b/Makefile
@@ -131,8 +131,11 @@ mscan.sorted: mscan.out $(QEMUSRC)/mtrace-tools/sersec-sort
 rsync: $(KERN)
 	rsync -avP $(KERN) amsterdam.csail.mit.edu:/tftpboot/$(HW)/kernel.xv6

+ifneq ($(HW),tom)
+IPMIOPTS = -A MD5 -U ADMIN
+endif
 reboot:
-	ipmitool -I lanplus -A MD5 -H $(HW)adm.csail.mit.edu -U ADMIN -f .passwd.$(HW) power reset
+	ipmitool -I lanplus $(IPMIOPTS) -H $(HW)adm.csail.mit.edu -f.passwd.$(HW) power reset

 bench:
 	/bin/echo -ne "xv6\\nbench\\nexit\\n" | nc $(HW).csail.mit.edu 23

--- a/bin/bench.cc
+++ b/bin/bench.cc
@@ -62,34 +62,30 @@ struct TimedExec : public Bench
  NEW_OPERATOR(TimedExec)
 };

-struct Dirbench : public Bench
+struct LoopsBench : public Bench
 {
-  Dirbench() : Bench() {}
+  LoopsBench(const char *cmd, int nloops, int cpuinc) :
+    Bench(), cmd_(cmd), nloops_(nloops), cpuinc_(cpuinc) {}

  virtual void run(void) {
-#ifdef HW_qemu
-    int nloop = 50;
-#else
-    int nloop = 1000;
-#endif
    char nloopstr[16];
-    snprintf(nloopstr, sizeof(nloopstr), "%u", nloop); 
+    snprintf(nloopstr, sizeof(nloopstr), "%u", nloops_); 
+    const char *argv[] = { cmd_, 0, nloopstr, 0 };

-    const char *argv[] = { "/dirbench", 0, nloopstr, 0 };
    char *res = result_;
    char *q = res + sizeof(result_);

    snprintf(res, q-res, "#cores usecs loops/core\n");
    res += strlen(res);

-    for (int i = 6; i <= NCPU; i += 6) {
+    for (int i = cpuinc_; i <= NCPU; i += cpuinc_) {
      char cores[16];
      snprintf(cores, sizeof(cores), "%u", i);
      argv[1] = cores;
      u64 r = time_this(argv);      
      // r in usecs
      r = (r*(1000*1000)) / cpuhz();
-      snprintf(res, q-res, "%u %lu %lu\n", i, r, nloop);
+      snprintf(res, q-res, "%u %lu %lu\n", i, r, nloops_);
      res += strlen(res);
    }
  }
@@ -98,9 +94,11 @@ struct Dirbench : public Bench
    return result_;
  }

+  const char* cmd_;
+  int nloops_;
+  int cpuinc_;
  char result_[1024];
-
-  NEW_OPERATOR(Dirbench)
+  NEW_OPERATOR(LoopsBench)
 };

 #define CMD(...) new TimedExec((const char *[]){__VA_ARGS__, 0})
@@ -113,7 +111,11 @@ main(int ac, char **av)
  static Bench* the_bench[128];
  int n = 0;

-  the_bench[n++] = new Dirbench();
+  //the_bench[n++] = new LoopsBench("/dirbench", 1000, 6);
+  the_bench[n++] = new LoopsBench("/filebench", 100000, 6);
+
+  //the_bench[n++] = CMD("filebench", "6", "10000");
+  //the_bench[n++] = CMD("filebench", "48", "10000");

  //the_bench[n++] = CMD("forkexecbench");
  //the_bench[n++] = CMD("mktree", STR(NCPU), "tree.xdu", "4", "4");

--- a/bin/filebench.cc
+++ b/bin/filebench.cc
@@ -44,6 +44,10 @@ bench(int tid, int nloop)
    r = pread(fd, chunkbuf, CHUNKSZ, CHUNKSZ*tid);
    if (r != CHUNKSZ)
      die("pread");
+
+    r = pwrite(fd, chunkbuf, CHUNKSZ, CHUNKSZ*tid);
+    if (r != CHUNKSZ)
+      die("pwrite");
  }

  close(fd);

--- a/include/file.hh
+++ b/include/file.hh
@@ -16,6 +16,7 @@ struct file : public referenced, public rcu_freed {
  int          stat(struct stat*);
  int          read(char *addr, int n);
  ssize_t      pread(char *addr, size_t n, off_t offset);
+  ssize_t      pwrite(const char *addr, size_t n, off_t offset);
  int          write(const char *addr, int n);

  enum { FD_NONE, FD_PIPE, FD_INODE, FD_SOCKET } type;  

--- a/kernel/file.cc
+++ b/kernel/file.cc
@@ -121,3 +121,29 @@ file::write(const char *addr, int n)
    return netwrite(socket, addr, n);
  panic("filewrite");
 }
+
+ssize_t
+file::pwrite(const char *addr, size_t n, off_t off)
+{
+  if(type == file::FD_INODE){
+    bool unlock;
+    int r;
+
+    if(ip->type == 0 || ip->type == T_DIR)
+      panic("filewrite but 0 or T_DIR");
+
+    unlock = false;
+    if (n+off > ip->size) {
+      ilock(ip, 1);
+      unlock = true;
+    }
+
+    r = writei(ip, addr, off, n);
+
+    if (unlock)
+      iunlock(ip);
+
+    return r;
+  }
+  return -1;
+}
--- a/kernel/sysfile.cc
+++ b/kernel/sysfile.cc
@@ -97,6 +97,33 @@ sys_write(int fd, const void *p, size_t n)
 }

 //SYSCALL
+ssize_t
+sys_pwrite(int fd, const void *ubuf, size_t count, off_t offset)
+{
+  sref<file> f;
+  if (!getfile(fd, &f))
+    return -1;
+
+  if (count < PGSIZE) {
+    ssize_t r;
+    char* b;
+    b = kalloc("pwritebuf");
+    fetchmem(b, ubuf, count);
+    r = f->pwrite(b, count, offset);
+    kfree(b);
+    return r;
+  } else {
+    // XXX(sbw) pagefaulting doesn't guarantee ubuf is mapped 
+    // while pread executes
+    uptr i = (uptr)ubuf;
+    for(uptr va = PGROUNDDOWN(i); va < i+count; va = va + PGSIZE)
+      if(pagefault(myproc()->vmap, va, 0) < 0)
+        return -1;
+    return f->pwrite((char*)ubuf, count, offset);
+  }
+}
+
+//SYSCALL
 int
 sys_close(int fd)
 {