objectstore: conflate onjournal and ondisk

No callers actually make this distinction, and the ObjectStore
hides the details of if/whether/how things go to the journal
or disk or in what order, so simplify things all around.

diff --git a/src/os/FileStore.cc b/src/os/FileStore.cc
index bae8232f92db7813d540270eb44ed4ac133953c0..c6707b13f9e9b7b5d157999b4c4634dfea59d951 100644 (file)
--- a/src/os/FileStore.cc
+++ b/src/os/FileStore.cc
@@ -649,8 +649,7 @@ int FileStore::umount()
 
 /// -----------------------------
 
-void FileStore::queue_op(__u64 op_seq, list<Transaction*>& tls, Context *onreadable,
-                        Context *oncommit)
+void FileStore::queue_op(__u64 op_seq, list<Transaction*>& tls, Context *onreadable)
 {
   __u64 bytes = 0, ops = 0;
   for (list<Transaction*>::iterator p = tls.begin();
@@ -668,7 +667,6 @@ void FileStore::queue_op(__u64 op_seq, list<Transaction*>& tls, Context *onreada
   o->op = op_seq;
   o->tls.swap(tls);
   o->onreadable = onreadable;
-  o->oncommit = oncommit;
   o->ops = ops;
   o->bytes = bytes;
 
@@ -689,7 +687,7 @@ void FileStore::queue_op(__u64 op_seq, list<Transaction*>& tls, Context *onreada
 void FileStore::_do_op(Op *o)
 {
   dout(10) << "_do_op " << o << " " << o->op << " start" << dendl;
-  op_apply_start(o->op, o->oncommit);
+  op_apply_start(o->op);
   int r = do_transactions(o->tls, o->op);
   op_apply_finish();
   dout(10) << "_do_op " << o << " " << o->op << " r = " << r
@@ -736,14 +734,13 @@ struct C_JournaledAhead : public Context {
   __u64 op;
   list<ObjectStore::Transaction*> tls;
   Context *onreadable;
-  Context *onjournal;
   Context *ondisk;
 
   C_JournaledAhead(FileStore *f, __u64 o, list<ObjectStore::Transaction*>& t,
-             Context *onr, Context *onj, Context *ond) :
-    fs(f), op(o), tls(t), onreadable(onr), onjournal(onj), ondisk(ond) { }
+             Context *onr, Context *ond) :
+    fs(f), op(o), tls(t), onreadable(onr), ondisk(ond) { }
   void finish(int r) {
-    fs->_journaled_ahead(op, tls, onreadable, onjournal, ondisk);
+    fs->_journaled_ahead(op, tls, onreadable, ondisk);
   }
 };
 
@@ -756,7 +753,6 @@ int FileStore::queue_transaction(Transaction *t)
 
 int FileStore::queue_transactions(list<Transaction*> &tls,
                                  Context *onreadable,
-                                 Context *onjournal,
                                  Context *ondisk)
 {
   if (journal && journal->is_writeable()) {
@@ -767,10 +763,10 @@ int FileStore::queue_transactions(list<Transaction*> &tls,
       __u64 op = op_journal_start(0);
       dout(10) << "queue_transactions (parallel) " << op << " " << tls << dendl;
       
-      journal_transactions(tls, op, onjournal);
+      journal_transactions(tls, op, ondisk);
       
       // queue inside journal lock, to preserve ordering
-      queue_op(op, tls, onreadable, ondisk);
+      queue_op(op, tls, onreadable);
       
       op_journal_finish();
       return 0;
@@ -778,23 +774,22 @@ int FileStore::queue_transactions(list<Transaction*> &tls,
     else if (g_conf.filestore_journal_writeahead) {
       __u64 op = op_journal_start(0);
       dout(10) << "queue_transactions (writeahead) " << op << " " << tls << dendl;
-      journal_transactions(tls, op, new C_JournaledAhead(this, op, tls, onreadable, onjournal, ondisk));
+      journal_transactions(tls, op, new C_JournaledAhead(this, op, tls, onreadable, ondisk));
       op_journal_finish();
       return 0;
     }
   }
 
-  __u64 op_seq = op_apply_start(0, ondisk);
+  __u64 op_seq = op_apply_start(0);
   dout(10) << "queue_transactions (trailing journal) " << op_seq << " " << tls << dendl;
   int r = do_transactions(tls, op_seq);
   op_apply_finish();
     
   if (r >= 0) {
     op_journal_start(op_seq);
-    journal_transactions(tls, op_seq, onjournal);
+    journal_transactions(tls, op_seq, ondisk);
     op_journal_finish();
   } else {
-    delete onjournal;
     delete ondisk;
   }
 
@@ -808,15 +803,14 @@ int FileStore::queue_transactions(list<Transaction*> &tls,
 void FileStore::_journaled_ahead(__u64 op,
                                 list<Transaction*> &tls,
                                 Context *onreadable,
-                                Context *onjournal,
                                 Context *ondisk)
 {
   dout(10) << "_journaled_ahead " << op << " " << tls << dendl;
   // this should queue in order because the journal does it's completions in order.
-  queue_op(op, tls, onreadable, ondisk);
-  if (onjournal) {
-    onjournal->finish(0);
-    delete onjournal;
+  queue_op(op, tls, onreadable);
+  if (ondisk) {
+    ondisk->finish(0);
+    delete ondisk;
   }
 }
 
@@ -850,16 +844,14 @@ int FileStore::do_transactions(list<Transaction*> &tls, __u64 op_seq)
 }
 
 unsigned FileStore::apply_transaction(Transaction &t,
-                                     Context *onjournal,
                                      Context *ondisk)
 {
   list<Transaction*> tls;
   tls.push_back(&t);
-  return apply_transactions(tls, onjournal, ondisk);
+  return apply_transactions(tls, ondisk);
 }
 
 unsigned FileStore::apply_transactions(list<Transaction*> &tls,
-                                      Context *onjournal,
                                       Context *ondisk)
 {
   int r = 0;
@@ -873,7 +865,7 @@ unsigned FileStore::apply_transactions(list<Transaction*> &tls,
     C_SafeCond *onreadable = new C_SafeCond(&my_lock, &my_cond, &done, &r);
 
     dout(10) << "apply queued" << dendl;
-    queue_transactions(tls, onreadable, onjournal, ondisk);
+    queue_transactions(tls, onreadable, ondisk);
     
     my_lock.Lock();
     while (!done)
@@ -881,16 +873,15 @@ unsigned FileStore::apply_transactions(list<Transaction*> &tls,
     my_lock.Unlock();
     dout(10) << "apply done r = " << r << dendl;
   } else {
-    __u64 op_seq = op_apply_start(0, ondisk);
+    __u64 op_seq = op_apply_start(0);
     r = do_transactions(tls, op_seq);
     op_apply_finish();
 
     if (r >= 0) {
       op_journal_start(op_seq);
-      journal_transactions(tls, op_seq, onjournal);
+      journal_transactions(tls, op_seq, ondisk);
       op_journal_finish();
     } else {
-      delete onjournal;
       delete ondisk;
     }
   }

diff --git a/src/os/FileStore.h b/src/os/FileStore.h
index 0be9e2228f928d5a0f152f7079f9d7c7094d509a..dcff5dbae74ec7cc72544647be0db4b366145ede 100644 (file)
--- a/src/os/FileStore.h
+++ b/src/os/FileStore.h
@@ -89,7 +89,7 @@ class FileStore : public JournalingObjectStore {
   struct Op {
     __u64 op;
     list<Transaction*> tls;
-    Context *onreadable, *oncommit;
+    Context *onreadable;
     __u64 ops, bytes;
   };
   deque<Op*> op_queue;
@@ -136,9 +136,9 @@ class FileStore : public JournalingObjectStore {
 
   void _do_op(Op *o);
   void _finish_op(Op *o);
-  void queue_op(__u64 op, list<Transaction*>& tls, Context *onreadable, Context *ondisk);
+  void queue_op(__u64 op, list<Transaction*>& tls, Context *onreadable);
   void _journaled_ahead(__u64 op, list<Transaction*> &tls,
-                       Context *onreadable,    Context *onjournal, Context *ondisk);
+                       Context *onreadable, Context *ondisk);
   friend class C_JournaledAhead;
 
   // flusher thread
@@ -187,15 +187,14 @@ class FileStore : public JournalingObjectStore {
   int statfs(struct statfs *buf);
 
   int do_transactions(list<Transaction*> &tls, __u64 op_seq);
-  unsigned apply_transaction(Transaction& t, Context *onjournal=0, Context *ondisk=0);
-  unsigned apply_transactions(list<Transaction*>& tls, Context *onjournal=0, Context *ondisk=0);
+  unsigned apply_transaction(Transaction& t, Context *ondisk=0);
+  unsigned apply_transactions(list<Transaction*>& tls, Context *ondisk=0);
   int _transaction_start(__u64 bytes, __u64 ops);
   void _transaction_finish(int id);
   unsigned _do_transaction(Transaction& t);
 
   int queue_transaction(Transaction* t);
-  int queue_transactions(list<Transaction*>& tls, Context *onreadable,
-                         Context *onjournal=0, Context *ondisk=0);
+  int queue_transactions(list<Transaction*>& tls, Context *onreadable, Context *ondisk=0);
 
   // ------------------
   // objects

diff --git a/src/os/JournalingObjectStore.cc b/src/os/JournalingObjectStore.cc
index c584c71d0c2f5f14ca21bec1d72d2fd0e202a5eb..a8cfda0daacf4a8b0bef8135aba4282188c5ca84 100644 (file)
--- a/src/os/JournalingObjectStore.cc
+++ b/src/os/JournalingObjectStore.cc
@@ -88,7 +88,7 @@ int JournalingObjectStore::journal_replay(__u64 fs_op_seq)
 
 // ------------------------------------
 
-__u64 JournalingObjectStore::op_apply_start(__u64 op, Context *ondisk) 
+__u64 JournalingObjectStore::op_apply_start(__u64 op) 
 {
   lock.Lock();
   while (blocked) {
@@ -101,9 +101,6 @@ __u64 JournalingObjectStore::op_apply_start(__u64 op, Context *ondisk)
     op = ++op_seq;
   dout(10) << "op_apply_start " << op << dendl;
 
-  if (ondisk)
-    commit_waiters[op].push_back(ondisk);
-
   lock.Unlock();
   return op;
 }

diff --git a/src/os/JournalingObjectStore.h b/src/os/JournalingObjectStore.h
index 8ed782a73d37b882c2bc4867d934a5f9d1e932d1..047610939852c18a75576244238d9d3657563b1a 100644 (file)
--- a/src/os/JournalingObjectStore.h
+++ b/src/os/JournalingObjectStore.h
@@ -41,7 +41,7 @@ protected:
   int journal_replay(__u64 fs_op_seq);
 
   // --
-  __u64 op_apply_start(__u64 op, Context *ondisk);
+  __u64 op_apply_start(__u64 op);
   void op_apply_finish();
   __u64 op_journal_start(__u64 op);
   void op_journal_finish();

diff --git a/src/os/ObjectStore.h b/src/os/ObjectStore.h
index 4bc7c61a97eb46fec8a2f7f3a512e3b2ac3a0480..34a6155edc1223f6c60866cdaf74e98b3d79c606 100644 (file)
--- a/src/os/ObjectStore.h
+++ b/src/os/ObjectStore.h
@@ -464,17 +464,17 @@ public:
   };
 
 
-  virtual unsigned apply_transaction(Transaction& t, Context *onjournal=0, Context *ondisk=0) = 0;
-  virtual unsigned apply_transactions(list<Transaction*>& tls, Context *onjournal=0, Context *ondisk=0) = 0;
+  virtual unsigned apply_transaction(Transaction& t, Context *ondisk=0) = 0;
+  virtual unsigned apply_transactions(list<Transaction*>& tls, Context *ondisk=0) = 0;
 
   virtual int queue_transaction(Transaction* t) = 0;
-  virtual int queue_transaction(Transaction *t, Context *onreadable, Context *onjournal=0, Context *ondisk=0) {
+  virtual int queue_transaction(Transaction *t, Context *onreadable, Context *ondisk=0) {
     list<Transaction*> tls;
     tls.push_back(t);
-    return queue_transactions(tls, onreadable, onjournal, ondisk);
+    return queue_transactions(tls, onreadable, ondisk);
   }
   virtual int queue_transactions(list<Transaction*>& tls, Context *onreadable,
-                                Context *onjournal=0, Context *ondisk=0) = 0;
+                                Context *ondisk=0) = 0;