Remove usage of unsafe from gkvlite

store.go

 // Package gkvlite provides a simple, ordered, ACID, key-value
 // persistence library.  It provides persistent, immutable data
 // structure abstrations.
 package gkvlite
 
 import (
         "bytes"
         "encoding/binary"
         "encoding/json"
         "errors"
         "fmt"
         "io"
         "os"
         "reflect"
         "sort"
         "sync"
         "sync/atomic"
-        "unsafe"
 )
 
 // A persistable store holding collections of ordered keys & values.
 type Store struct {
+        m sync.Mutex
+
         // Atomic CAS'ed int64/uint64's must be at the top for 32-bit compatibility.
-        size       int64          // Atomic protected; file size or next write position.
-        nodeAllocs uint64         // Atomic protected; total node allocation stats.
-        coll       unsafe.Pointer // Copy-on-write map[string]*Collection.
-        file       StoreFile      // When nil, we're memory-only or no persistence.
-        callbacks  StoreCallbacks // Optional / may be nil.
-        readOnly   bool           // When true, Flush()'ing is disallowed.
+        size       int64                   // Atomic protected; file size or next write position.
+        nodeAllocs uint64                  // Atomic protected; total node allocation stats.
+        coll       *map[string]*Collection // Copy-on-write map[string]*Collection.
+        file       StoreFile               // When nil, we're memory-only or no persistence.
+        callbacks  StoreCallbacks          // Optional / may be nil.
+        readOnly   bool                    // When true, Flush()'ing is disallowed.
+}
+
+func (s *Store) setColl(n *map[string]*Collection) {
+        s.m.Lock()
+        defer s.m.Unlock()
+        s.coll = n
+}
+
+func (s *Store) getColl() *map[string]*Collection {
+        s.m.Lock()
+        defer s.m.Unlock()
+        return s.coll
+}
+
+func (s *Store) casColl(o, n *map[string]*Collection) bool {
+        s.m.Lock()
+        defer s.m.Unlock()
+        if s.coll == o {
+                s.coll = n
+                return true
+        }
+        return false
 }
 
 // The StoreFile interface is implemented by os.File.  Application
 // specific implementations may add concurrency, caching, stats, etc.
 type StoreFile interface {
         io.ReaderAt
         io.WriterAt
         Stat() (os.FileInfo, error)
         Truncate(size int64) error
 }
@@ skipping 48 matching lines @@
 var rootsLen int64 = int64(2*len(MAGIC_BEG) + 4 + 4 + rootsEndLen)
 
 // Provide a nil StoreFile for in-memory-only (non-persistent) usage.
 func NewStore(file StoreFile) (*Store, error) {
         return NewStoreEx(file, StoreCallbacks{})
 }
 
 func NewStoreEx(file StoreFile,
         callbacks StoreCallbacks) (*Store, error) {
         coll := make(map[string]*Collection)
-        res := &Store{coll: unsafe.Pointer(&coll), callbacks: callbacks}
+        res := &Store{coll: &coll, callbacks: callbacks}
         if file == nil || !reflect.ValueOf(file).Elem().IsValid() {
                 return res, nil // Memory-only Store.
         }
         res.file = file
         if err := res.readRoots(); err != nil {
                 return nil, err
         }
         return res, nil
 }
 
 // SetCollection() is used to create a named Collection, or to modify
 // the KeyCompare function on an existing Collection.  In either case,
 // a new Collection to use is returned.  A newly created Collection
 // and any mutations on it won't be persisted until you do a Flush().
 func (s *Store) SetCollection(name string, compare KeyCompare) *Collection {
         if compare == nil {
                 compare = bytes.Compare
         }
         for {
-                orig := atomic.LoadPointer(&s.coll)
+                orig := s.getColl()
                 coll := copyColl(*(*map[string]*Collection)(orig))
                 cnew := s.MakePrivateCollection(compare)
                 cnew.name = name
                 cold := coll[name]
                 if cold != nil {
                         cnew.rootLock = cold.rootLock
                         cnew.root = cold.rootAddRef()
                 }
                 coll[name] = cnew
-                if atomic.CompareAndSwapPointer(&s.coll, orig, unsafe.Pointer(&coll)) {
+                if s.casColl(orig, &coll) {
                         cold.closeCollection()
                         return cnew
                 }
                 cnew.closeCollection()
         }
 }
 
 // Returns a new, unregistered (non-named) collection.  This allows
 // advanced users to manage collections of private collections.
 func (s *Store) MakePrivateCollection(compare KeyCompare) *Collection {
         if compare == nil {
                 compare = bytes.Compare
         }
         return &Collection{
                 store:    s,
                 compare:  compare,
                 rootLock: &sync.Mutex{},
                 root:     &rootNodeLoc{refs: 1, root: empty_nodeLoc},
         }
 }
 
 // Retrieves a named Collection.
 func (s *Store) GetCollection(name string) *Collection {
-        coll := *(*map[string]*Collection)(atomic.LoadPointer(&s.coll))
-        return coll[name]
+        return (*s.getColl())[name]
 }
 
 func (s *Store) GetCollectionNames() []string {
-        return collNames(*(*map[string]*Collection)(atomic.LoadPointer(&s.coll)))
+        return collNames(*s.getColl())
 }
 
 func collNames(coll map[string]*Collection) []string {
         res := make([]string, 0, len(coll))
         for name := range coll {
                 res = append(res, name)
         }
         sort.Strings(res) // Sorting because common callers need stability.
         return res
 }
 
 // The Collection removal won't be reflected into persistence until
 // you do a Flush().  Invoking RemoveCollection(x) and then
 // SetCollection(x) is a fast way to empty a Collection.
 func (s *Store) RemoveCollection(name string) {
         for {
-                orig := atomic.LoadPointer(&s.coll)
+                orig := s.getColl()
                 coll := copyColl(*(*map[string]*Collection)(orig))
                 cold := coll[name]
                 delete(coll, name)
-                if atomic.CompareAndSwapPointer(&s.coll, orig, unsafe.Pointer(&coll)) {
+                if s.casColl(orig, &coll) {
                         cold.closeCollection()
                         return
                 }
         }
 }
 
 func copyColl(orig map[string]*Collection) map[string]*Collection {
         res := make(map[string]*Collection)
         for name, c := range orig {
                 res[name] = c
         }
         return res
 }
 
 // Writes (appends) any dirty, unpersisted data to file.  As a
 // greater-window-of-data-loss versus higher-performance tradeoff,
 // consider having many mutations (Set()'s & Delete()'s) and then
 // have a less occasional Flush() instead of Flush()'ing after every
 // mutation.  Users may also wish to file.Sync() after a Flush() for
 // extra data-loss protection.
 func (s *Store) Flush() error {
         if s.readOnly {
                 return errors.New("readonly, so cannot Flush()")
         }
         if s.file == nil {
                 return errors.New("no file / in-memory only, so cannot Flush()")
         }
-        coll := *(*map[string]*Collection)(atomic.LoadPointer(&s.coll))
+        coll := *s.getColl()
         rnls := map[string]*rootNodeLoc{}
         cnames := collNames(coll)
         for _, name := range cnames {
                 c := coll[name]
                 rnls[name] = c.rootAddRef()
         }
         defer func() {
                 for _, name := range cnames {
                         coll[name].rootDecRef(rnls[name])
                 }
         }()
         for _, name := range cnames {
                 if err := coll[name].write(rnls[name].root); err != nil {
                         return err
                 }
         }
         return s.writeRoots(rnls)
 }
 
 // Reverts the last Flush(), bringing the Store back to its state at
 // its next-to-last Flush() or to an empty Store (with no Collections)
 // if there were no next-to-last Flush().  This call will truncate the
 // Store file.
 func (s *Store) FlushRevert() error {
         if s.file == nil {
                 return errors.New("no file / in-memory only, so cannot FlushRevert()")
         }
-        orig := atomic.LoadPointer(&s.coll)
+        orig := s.getColl()
         coll := make(map[string]*Collection)
-        if atomic.CompareAndSwapPointer(&s.coll, orig, unsafe.Pointer(&coll)) {
+        if s.casColl(orig, &coll) {
                 for _, cold := range *(*map[string]*Collection)(orig) {
                         cold.closeCollection()
                 }
         }
         if atomic.LoadInt64(&s.size) > rootsLen {
                 atomic.AddInt64(&s.size, -1)
         }
         err := s.readRootsScan(true)
         if err != nil {
                 return err
         }
         if s.readOnly {
                 return nil
         }
         return s.file.Truncate(atomic.LoadInt64(&s.size))
 }
 
 // Returns a read-only snapshot, including any mutations on the
 // original Store that have not been Flush()'ed to disk yet.  The
 // snapshot has its mutations and Flush() operations disabled because
 // the original store "owns" writes to the StoreFile.
 func (s *Store) Snapshot() (snapshot *Store) {
-        coll := copyColl(*(*map[string]*Collection)(atomic.LoadPointer(&s.coll)))
+        coll := copyColl(*s.getColl())
         res := &Store{
-                coll:      unsafe.Pointer(&coll),
+                coll:      &coll,
                 file:      s.file,
                 size:      atomic.LoadInt64(&s.size),
                 readOnly:  true,
                 callbacks: s.callbacks,
         }
         for _, name := range collNames(coll) {
                 collOrig := coll[name]
                 coll[name] = &Collection{
                         store:    res,
                         compare:  collOrig.compare,
                         rootLock: collOrig.rootLock,
                         root:     collOrig.rootAddRef(),
                 }
         }
         return res
 }
 
 func (s *Store) Close() {
         s.file = nil
-        cptr := atomic.LoadPointer(&s.coll)
-        if cptr == nil ||
-                !atomic.CompareAndSwapPointer(&s.coll, cptr, unsafe.Pointer(nil)) {
+        cptr := s.getColl()
+        if cptr == nil || !s.casColl(cptr, nil) {
                 return
         }
         coll := *(*map[string]*Collection)(cptr)
         for _, name := range collNames(coll) {
                 coll[name].closeCollection()
         }
 }
 
 // Copy all active collections and their items to a different file.
 // If flushEvery > 0, then during the item copying, Flush() will be
 // invoked at every flushEvery'th item and at the end of the item
 // copying.  The copy will not include any old items or nodes so the
 // copy should be more compact if flushEvery is relatively large.
 func (s *Store) CopyTo(dstFile StoreFile, flushEvery int) (res *Store, err error) {
         dstStore, err := NewStore(dstFile)
         if err != nil {
                 return nil, err
         }
-        coll := *(*map[string]*Collection)(atomic.LoadPointer(&s.coll))
+        coll := *s.getColl()
         for _, name := range collNames(coll) {
                 srcColl := coll[name]
                 dstColl := dstStore.SetCollection(name, srcColl.compare)
                 minItem, err := srcColl.MinItem(true)
                 if err != nil {
                         return nil, err
                 }
                 if minItem == nil {
                         continue
                 }
@@ skipping 132 matching lines @@
                                 for collName, t := range m {
                                         t.name = collName
                                         t.store = o
                                         if o.callbacks.KeyCompareForCollection != nil {
                                                 t.compare = o.callbacks.KeyCompareForCollection(collName)
                                         }
                                         if t.compare == nil {
                                                 t.compare = bytes.Compare
                                         }
                                 }
-                                atomic.StorePointer(&o.coll, unsafe.Pointer(&m))
+                                o.setColl(&m)
                                 return nil
                         } // else, perhaps value was unlucky in having MAGIC_END's.
                 } // else, perhaps a gkvlite file was stored as a value.
                 atomic.AddInt64(&o.size, -1) // Roots were wrong, so keep scanning.
         }
 }
 
 func (o *Store) ItemAlloc(c *Collection, keyLength uint32) *Item {
         if o.callbacks.ItemAlloc != nil {
                 return o.callbacks.ItemAlloc(c, keyLength)
@@ skipping 23 matching lines @@
         return err
 }
 
 func (o *Store) ItemValWrite(c *Collection, i *Item, w io.WriterAt, offset int64) error {
         if o.callbacks.ItemValWrite != nil {
                 return o.callbacks.ItemValWrite(c, i, w, offset)
         }
         _, err := w.WriteAt(i.Val, offset)
         return err
 }