1 files changed, 84 insertions, 33 deletions

diff --git a/log.c b/log.c
index 95cc4d5..0abe1fe 100644
--- a/log.c
+++ b/log.c
@@ -5,18 +5,19 @@
 #include "fs.h"
 #include "buf.h"
 
-// Simple logging. Each file system system call
-// should be surrounded with begin_trans() and commit_trans() calls.
+// Simple logging that allows concurrent FS system calls.
 //
-// The log holds at most one transaction at a time. Commit forces
-// the log (with commit record) to disk, then installs the affected
-// blocks to disk, then erases the log. begin_trans() ensures that
-// only one system call can be in a transaction; others must wait.
-// 
-// Allowing only one transaction at a time means that the file
-// system code doesn't have to worry about the possibility of
-// one transaction reading a block that another one has modified,
-// for example an i-node block.
+// A log transaction contains the updates of multiple FS system
+// calls. The logging system only commits when there are
+// no FS system calls active. Thus there is never
+// any reasoning required about whether a commit might
+// write an uncommitted system call's updates to disk.
+//
+// A system call should call begin_op()/end_op() to mark
+// its start and end. Usually begin_op() just increments
+// the count of in-progress FS system calls and returns.
+// But if it thinks the log is close to running out, it
+// sleeps until the last outstanding end_op() commits.
 //
 // The log is a physical re-do log containing disk blocks.
 // The on-disk log format:
@@ -38,13 +39,15 @@ struct log {
   struct spinlock lock;
   int start;
   int size;
-  int busy; // a transaction is active
+  int outstanding; // how many FS sys calls are executing.
+  int committing;  // in commit(), please wait.
   int dev;
   struct logheader lh;
 };
 struct log log;
 
 static void recover_from_log(void);
+static void commit();
 
 void
 initlog(void)
@@ -117,36 +120,88 @@ recover_from_log(void)
   write_head(); // clear the log
 }
 
+// called at the start of each FS system call.
 void
-begin_trans(void)
+begin_op(void)
 {
   acquire(&log.lock);
-  while (log.busy) {
-    sleep(&log, &log.lock);
+  while(1){
+    if(log.committing){
+      sleep(&log, &log.lock);
+    } else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
+      // this op might exhaust log space; wait for commit.
+      sleep(&log, &log.lock);
+    } else {
+      log.outstanding += 1;
+      release(&log.lock);
+      break;
+    }
   }
-  log.busy = 1;
-  release(&log.lock);
 }
 
+// called at the end of each FS system call.
+// commits if this was the last outstanding operation.
 void
-commit_trans(void)
+end_op(void)
+{
+  int do_commit = 0;
+
+  acquire(&log.lock);
+  log.outstanding -= 1;
+  if(log.committing)
+    panic("log.committing");
+  if(log.outstanding == 0){
+    do_commit = 1;
+    log.committing = 1;
+  } else {
+    // begin_op() may be waiting for log space.
+    wakeup(&log);
+  }
+  release(&log.lock);
+
+  if(do_commit){
+    // call commit w/o holding locks, since not allowed
+    // to sleep with locks.
+    commit();
+    acquire(&log.lock);
+    log.committing = 0;
+    wakeup(&log);
+    release(&log.lock);
+  }
+}
+
+// Copy modified blocks from cache to log.
+static void 
+write_log(void)
+{
+  int tail;
+
+  for (tail = 0; tail < log.lh.n; tail++) {
+    struct buf *to = bread(log.dev, log.start+tail+1); // log block
+    struct buf *from = bread(log.dev, log.lh.sector[tail]); // cache block
+    memmove(to->data, from->data, BSIZE);
+    bwrite(to);  // write the log
+    brelse(from); 
+    brelse(to);
+  }
+}
+
+static void
+commit()
 {
   if (log.lh.n > 0) {
+    write_log();     // Write modified blocks from cache to log
     write_head();    // Write header to disk -- the real commit
     install_trans(); // Now install writes to home locations
     log.lh.n = 0; 
     write_head();    // Erase the transaction from the log
   }
-  
-  acquire(&log.lock);
-  log.busy = 0;
-  wakeup(&log);
-  release(&log.lock);
 }
 
 // Caller has modified b->data and is done with the buffer.
-// Append the block to the log and record the block number, 
-// but don't write the log header (which would commit the write).
+// Record the block number and pin in the cache with B_DIRTY.
+// commit()/write_log() will do the disk write.
+//
 // log_write() replaces bwrite(); a typical use is:
 //   bp = bread(...)
 //   modify bp->data[]
@@ -159,21 +214,17 @@ log_write(struct buf *b)
 
   if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
     panic("too big a transaction");
-  if (!log.busy)
-    panic("write outside of trans");
+  if (log.outstanding < 1)
+    panic("log_write outside of trans");
 
   for (i = 0; i < log.lh.n; i++) {
-    if (log.lh.sector[i] == b->sector)   // log absorbtion?
+    if (log.lh.sector[i] == b->sector)   // log absorbtion
       break;
   }
   log.lh.sector[i] = b->sector;
-  struct buf *lbuf = bread(b->dev, log.start+i+1);
-  memmove(lbuf->data, b->data, BSIZE);
-  bwrite(lbuf);
-  brelse(lbuf);
   if (i == log.lh.n)
     log.lh.n++;
-  b->flags |= B_DIRTY; // XXX prevent eviction
+  b->flags |= B_DIRTY; // prevent eviction
 }
 
 //PAGEBREAK!