1 files changed, 227 insertions, 227 deletions
diff --git a/db/reccache.h b/db/reccache.h
index 4933166dde3..5fc83ee8d2b 100644
--- a/db/reccache.h
+++ b/db/reccache.h
@@ -1,227 +1,227 @@
-// reccache.h
-
-/* CachedBasicRecStore
-   This is our store which implements a traditional page-cache type of storage
-   (not memory mapped files).
-*/
-
-/* LOCK HIERARCHY
-     
-     dblock
-       RecCache::rcmutex
-
-     i.e. always lock dblock first if you lock both
-
-*/
-
-#pragma once
-
-#include "reci.h"
-#include "recstore.h"
-
-namespace mongo { 
-
-class RecCache {
-    struct Node { 
-        Node(void* _data) : data((char *) _data) { dirty = false; newer = 0; }
-        ~Node() { 
-            free(data);
-            data = 0;
-        }
-        char *data;
-        DiskLoc loc;
-        bool dirty;
-        Node *older, *newer; // lru
-    };
-    boost::mutex rcmutex; // mainly to coordinate with the lazy writer thread
-    unsigned recsize;
-    map<DiskLoc, Node*> m; // the cache
-    Node *newest, *oldest;
-    unsigned nnodes;
-    set<DiskLoc> dirtyl;
-    vector<BasicRecStore*> stores; // DiskLoc::a() indicates the index into this vector
-    map<string, BasicRecStore*> storesByNsKey; // nskey -> BasicRecStore*
-public:
-    static unsigned MAXNODES;
-    enum BaseValue { Base = 10000 };
-private:
-    BasicRecStore* _initStore(string fname);
-    BasicRecStore* initStore(int n);
-    string findStoreFilename(const char *_ns, bool& found);
-    void initStoreByNs(const char *ns, const string& nskey);
-    void closeStore(BasicRecStore *rs);
-
-    static string directory();
-    static string mknskey(const char *ns) { 
-        return directory() + ns;
-    }
-
-    /* get the right file for a given diskloc */
-    BasicRecStore& store(DiskLoc& d) { 
-        int n = d.a() - Base;
-        if( (int) stores.size() > n ) { 
-            BasicRecStore *rs = stores[n];
-            if( rs ) {
-                assert( rs->fileNumber == n );
-                return *rs;
-            }
-        }
-        return *initStore(n);
-    }
-    BasicRecStore& store(const char *ns) {
-        string nskey = mknskey(ns);
-        BasicRecStore *&rs = storesByNsKey[nskey];
-        if( rs )
-            return *rs;
-        initStoreByNs(ns, nskey);
-        return *rs;
-    }
-
-    void writeDirty( set<DiskLoc>::iterator i, bool rawLog = false );
-    void writeIfDirty(Node *n);
-    void touch(Node* n) { 
-        if( n == newest )
-            return;
-        if( n == oldest ) {
-            oldest = oldest->newer;
-            assert( oldest || nnodes == 1 );
-        }
-        if( n->older ) 
-            n->older->newer = n->newer;
-        if( n->newer ) 
-            n->newer->older = n->older;
-        n->newer = 0;        
-        n->older = newest;
-        newest->newer = n;
-        newest = n;
-    }
-    Node* mkNode() { 
-        Node *n = new Node(calloc(recsize,1)); // calloc is TEMP for testing.  change to malloc
-        n->older = newest;
-        if( newest )
-            newest->newer = n;
-        else {
-            assert( oldest == 0 );
-            oldest = n;
-        }
-        newest = n;
-        nnodes++;
-        return n;
-    }
-    fileofs fileOfs(DiskLoc d) { 
-        return ((fileofs) d.getOfs()) * recsize;
-    }
-
-    void dump();
-    void _ejectOld();
-
-public:
-    /* all public functions (except constructor) should use the mutex */
-
-    RecCache(unsigned recsz) : recsize(recsz) { 
-        nnodes = 0;
-        newest = oldest = 0;
-    }
-
-    /* call this after doing some work, after you are sure you are done with modifications.
-       we call it from dbunlocking().
-    */
-    void ejectOld() { 
-        if( nnodes > MAXNODES ) // just enough here to be inlineable for speed reasons.  _ejectOld does the real work
-            _ejectOld();
-    }
-
-    /* bg writer thread invokes this */
-    void writeLazily();
-
-    /* Note that this may be called BEFORE the actual writing to the node 
-       takes place.  We do flushing later on a dbunlocking() call, which happens 
-       after the writing.
-    */
-    void dirty(DiskLoc d) {
-        assert( d.a() >= Base );
-        boostlock lk(rcmutex);
-        map<DiskLoc, Node*>::iterator i = m.find(d);
-        if( i != m.end() ) {
-            Node *n = i->second;
-            if( !n->dirty ) { 
-                n->dirty = true;
-                dirtyl.insert(n->loc);
-            }
-        }
-    }
-
-    char* get(DiskLoc d, unsigned len) { 
-        assert( d.a() >= Base );
-        assert( len == recsize );
-
-        boostlock lk(rcmutex);
-        map<DiskLoc, Node*>::iterator i = m.find(d);
-        if( i != m.end() ) {
-            touch(i->second);
-            return i->second->data;
-        }
-
-        Node *n = mkNode();
-        n->loc = d;
-        store(d).get(fileOfs(d), n->data, recsize); // could throw exception
-        m.insert( pair<DiskLoc, Node*>(d, n) );
-        return n->data;
-    }
-
-    void drop(const char *ns);
-
-    DiskLoc insert(const char *ns, const void *obuf, int len, bool god) {
-        boostlock lk(rcmutex);
-        BasicRecStore& rs = store(ns);
-        fileofs o = rs.insert((const char *) obuf, len);
-        assert( o % recsize == 0 );
-        fileofs recnum = o / recsize;
-        massert( "RecCache file too large?", recnum <= 0x7fffffff );
-        Node *n = mkNode();
-        memcpy(n->data, obuf, len);
-        DiskLoc d(rs.fileNumber + Base, (int) recnum);
-        n->loc = d;
-        m[d] = n;
-        return d;
-    }
-
-    void closeFiles(string dbname, string path);
-
-    // at termination: write dirty pages and close all files
-    void closing();
-};
-
-extern RecCache theRecCache;
-
-class CachedBasicRecStore : public RecStoreInterface { 
-public:
-    virtual char* get(DiskLoc d, unsigned len) { 
-        return theRecCache.get(d, len);
-    }
-
-    virtual DiskLoc insert(const char *ns, const void *obuf, int len, bool god) { 
-        return theRecCache.insert(ns, obuf, len, god);
-    }
-
-    virtual void modified(DiskLoc d) { 
-        theRecCache.dirty(d);
-    }
-
-    /* drop collection */
-    virtual void drop(const char *ns) { 
-        theRecCache.drop(ns);
-    }
-
-    /* close datafiles associated with the db specified. */
-    virtual void closeFiles(string dbname, string path) {
-        theRecCache.closeFiles(dbname, dbpath);
-    }
-};
-
-inline void dbunlocking() { 
-//    dassert( dbMutexInfo.isLocked() );
-    theRecCache.ejectOld();
-}
-
-} /*namespace*/
+// reccache.h
+
+/* CachedBasicRecStore
+   This is our store which implements a traditional page-cache type of storage
+   (not memory mapped files).
+*/
+
+/* LOCK HIERARCHY
+     
+     dblock
+       RecCache::rcmutex
+
+     i.e. always lock dblock first if you lock both
+
+*/
+
+#pragma once
+
+#include "reci.h"
+#include "recstore.h"
+
+namespace mongo { 
+
+class RecCache {
+    struct Node { 
+        Node(void* _data) : data((char *) _data) { dirty = false; newer = 0; }
+        ~Node() { 
+            free(data);
+            data = 0;
+        }
+        char *data;
+        DiskLoc loc;
+        bool dirty;
+        Node *older, *newer; // lru
+    };
+    boost::mutex &rcmutex; // mainly to coordinate with the lazy writer thread
+    unsigned recsize;
+    map<DiskLoc, Node*> m; // the cache
+    Node *newest, *oldest;
+    unsigned nnodes;
+    set<DiskLoc> dirtyl;
+    vector<BasicRecStore*> stores; // DiskLoc::a() indicates the index into this vector
+    map<string, BasicRecStore*> storesByNsKey; // nskey -> BasicRecStore*
+public:
+    static unsigned MAXNODES;
+    enum BaseValue { Base = 10000 };
+private:
+    BasicRecStore* _initStore(string fname);
+    BasicRecStore* initStore(int n);
+    string findStoreFilename(const char *_ns, bool& found);
+    void initStoreByNs(const char *ns, const string& nskey);
+    void closeStore(BasicRecStore *rs);
+
+    static string directory();
+    static string mknskey(const char *ns) { 
+        return directory() + ns;
+    }
+
+    /* get the right file for a given diskloc */
+    BasicRecStore& store(DiskLoc& d) { 
+        int n = d.a() - Base;
+        if( (int) stores.size() > n ) { 
+            BasicRecStore *rs = stores[n];
+            if( rs ) {
+                assert( rs->fileNumber == n );
+                return *rs;
+            }
+        }
+        return *initStore(n);
+    }
+    BasicRecStore& store(const char *ns) {
+        string nskey = mknskey(ns);
+        BasicRecStore *&rs = storesByNsKey[nskey];
+        if( rs )
+            return *rs;
+        initStoreByNs(ns, nskey);
+        return *rs;
+    }
+
+    void writeDirty( set<DiskLoc>::iterator i, bool rawLog = false );
+    void writeIfDirty(Node *n);
+    void touch(Node* n) { 
+        if( n == newest )
+            return;
+        if( n == oldest ) {
+            oldest = oldest->newer;
+            assert( oldest || nnodes == 1 );
+        }
+        if( n->older ) 
+            n->older->newer = n->newer;
+        if( n->newer ) 
+            n->newer->older = n->older;
+        n->newer = 0;        
+        n->older = newest;
+        newest->newer = n;
+        newest = n;
+    }
+    Node* mkNode() { 
+        Node *n = new Node(calloc(recsize,1)); // calloc is TEMP for testing.  change to malloc
+        n->older = newest;
+        if( newest )
+            newest->newer = n;
+        else {
+            assert( oldest == 0 );
+            oldest = n;
+        }
+        newest = n;
+        nnodes++;
+        return n;
+    }
+    fileofs fileOfs(DiskLoc d) { 
+        return ((fileofs) d.getOfs()) * recsize;
+    }
+
+    void dump();
+    void _ejectOld();
+
+public:
+    /* all public functions (except constructor) should use the mutex */
+
+    RecCache(unsigned recsz) : rcmutex( *( new boost::mutex() ) ), recsize(recsz) { 
+        nnodes = 0;
+        newest = oldest = 0;
+    }
+
+    /* call this after doing some work, after you are sure you are done with modifications.
+       we call it from dbunlocking().
+    */
+    void ejectOld() { 
+        if( nnodes > MAXNODES ) // just enough here to be inlineable for speed reasons.  _ejectOld does the real work
+            _ejectOld();
+    }
+
+    /* bg writer thread invokes this */
+    void writeLazily();
+
+    /* Note that this may be called BEFORE the actual writing to the node 
+       takes place.  We do flushing later on a dbunlocking() call, which happens 
+       after the writing.
+    */
+    void dirty(DiskLoc d) {
+        assert( d.a() >= Base );
+        boostlock lk(rcmutex);
+        map<DiskLoc, Node*>::iterator i = m.find(d);
+        if( i != m.end() ) {
+            Node *n = i->second;
+            if( !n->dirty ) { 
+                n->dirty = true;
+                dirtyl.insert(n->loc);
+            }
+        }
+    }
+
+    char* get(DiskLoc d, unsigned len) { 
+        assert( d.a() >= Base );
+        assert( len == recsize );
+
+        boostlock lk(rcmutex);
+        map<DiskLoc, Node*>::iterator i = m.find(d);
+        if( i != m.end() ) {
+            touch(i->second);
+            return i->second->data;
+        }
+
+        Node *n = mkNode();
+        n->loc = d;
+        store(d).get(fileOfs(d), n->data, recsize); // could throw exception
+        m.insert( pair<DiskLoc, Node*>(d, n) );
+        return n->data;
+    }
+
+    void drop(const char *ns);
+
+    DiskLoc insert(const char *ns, const void *obuf, int len, bool god) {
+        boostlock lk(rcmutex);
+        BasicRecStore& rs = store(ns);
+        fileofs o = rs.insert((const char *) obuf, len);
+        assert( o % recsize == 0 );
+        fileofs recnum = o / recsize;
+        massert( "RecCache file too large?", recnum <= 0x7fffffff );
+        Node *n = mkNode();
+        memcpy(n->data, obuf, len);
+        DiskLoc d(rs.fileNumber + Base, (int) recnum);
+        n->loc = d;
+        m[d] = n;
+        return d;
+    }
+
+    void closeFiles(string dbname, string path);
+
+    // at termination: write dirty pages and close all files
+    void closing();
+};
+
+extern RecCache theRecCache;
+
+class CachedBasicRecStore : public RecStoreInterface { 
+public:
+    virtual char* get(DiskLoc d, unsigned len) { 
+        return theRecCache.get(d, len);
+    }
+
+    virtual DiskLoc insert(const char *ns, const void *obuf, int len, bool god) { 
+        return theRecCache.insert(ns, obuf, len, god);
+    }
+
+    virtual void modified(DiskLoc d) { 
+        theRecCache.dirty(d);
+    }
+
+    /* drop collection */
+    virtual void drop(const char *ns) { 
+        theRecCache.drop(ns);
+    }
+
+    /* close datafiles associated with the db specified. */
+    virtual void closeFiles(string dbname, string path) {
+        theRecCache.closeFiles(dbname, dbpath);
+    }
+};
+
+inline void dbunlocking() { 
+//    dassert( dbMutexInfo.isLocked() );
+    theRecCache.ejectOld();
+}
+
+} /*namespace*/