Remove usage of unsafe from gkvlite

node.go

 package gkvlite
 
 import (
         "encoding/binary"
         "fmt"
+        "sync"
         "sync/atomic"
-        "unsafe"
 )
 
 // A persistable node.
 type node struct {
         numNodes, numBytes uint64
         item               itemLoc
         left, right        nodeLoc
         next               *node // For free-list tracking.
 }
 
 // A persistable node and its persistence location.
 type nodeLoc struct {
-        loc  unsafe.Pointer // *ploc - can be nil if node is dirty (not yet persisted).
-        node unsafe.Pointer // *node - can be nil if node is not fetched into memory yet.
-        next *nodeLoc       // For free-list tracking.
+        m sync.Mutex
+
+        loc  *ploc    // *ploc - can be nil if node is dirty (not yet persisted).
+        node *node    // *node - can be nil if node is not fetched into memory yet.
+        next *nodeLoc // For free-list tracking.
 }
 
 var empty_nodeLoc = &nodeLoc{} // Sentinel.
 
 func (nloc *nodeLoc) Loc() *ploc {
-        return (*ploc)(atomic.LoadPointer(&nloc.loc))
+        nloc.m.Lock()
+        defer nloc.m.Unlock()
+        return nloc.loc
+}
+
+func (nloc *nodeLoc) setLoc(n *ploc) {
+        nloc.m.Lock()
+        defer nloc.m.Unlock()
+        nloc.loc = n
 }
 
 func (nloc *nodeLoc) Node() *node {
-        return (*node)(atomic.LoadPointer(&nloc.node))
+        nloc.m.Lock()
+        defer nloc.m.Unlock()
+        return nloc.node
+}
+
+func (nloc *nodeLoc) setNode(n *node) {
+        nloc.m.Lock()
+        defer nloc.m.Unlock()
+        nloc.node = n
 }
 
 func (nloc *nodeLoc) Copy(src *nodeLoc) *nodeLoc {
         if src == nil {
                 return nloc.Copy(empty_nodeLoc)
         }
-        atomic.StorePointer(&nloc.loc, unsafe.Pointer(src.Loc()))
-        atomic.StorePointer(&nloc.node, unsafe.Pointer(src.Node()))
+        newloc := src.Loc()
+        newnode := src.Node()
+
+        nloc.m.Lock()
+        defer nloc.m.Unlock()
+        nloc.loc = newloc
+        nloc.node = newnode
         return nloc
 }
 
 func (nloc *nodeLoc) isEmpty() bool {
         return nloc == nil || (nloc.Loc().isEmpty() && nloc.Node() == nil)
 }
 
 func (nloc *nodeLoc) write(o *Store) error {
         if nloc != nil && nloc.Loc().isEmpty() {
                 node := nloc.Node()
@@ skipping 12 matching lines @@
                 binary.BigEndian.PutUint64(b[pos:pos+8], node.numBytes)
                 pos += 8
                 if pos != length {
                         return fmt.Errorf("nodeLoc.write() pos: %v didn't match length: %v",
                                 pos, length)
                 }
                 if _, err := o.file.WriteAt(b, offset); err != nil {
                         return err
                 }
                 atomic.StoreInt64(&o.size, offset+int64(length))
-                atomic.StorePointer(&nloc.loc,
-                        unsafe.Pointer(&ploc{Offset: offset, Length: uint32(length)}))
+                nloc.setLoc(&ploc{Offset: offset, Length: uint32(length)})
         }
         return nil
 }
 
 func (nloc *nodeLoc) read(o *Store) (n *node, err error) {
         if nloc == nil {
                 return nil, nil
         }
         n = nloc.Node()
         if n != nil {
@@ skipping 10 matching lines @@
         b := make([]byte, loc.Length)
         if _, err := o.file.ReadAt(b, loc.Offset); err != nil {
                 return nil, err
         }
         pos := 0
         atomic.AddUint64(&o.nodeAllocs, 1)
         n = &node{}
         var p *ploc
         p = &ploc{}
         p, pos = p.read(b, pos)
-        n.item.loc = unsafe.Pointer(p)
+        n.item.loc = p
         p = &ploc{}
         p, pos = p.read(b, pos)
-        n.left.loc = unsafe.Pointer(p)
+        n.left.loc = p
         p = &ploc{}
         p, pos = p.read(b, pos)
-        n.right.loc = unsafe.Pointer(p)
+        n.right.loc = p
         n.numNodes = binary.BigEndian.Uint64(b[pos : pos+8])
         pos += 8
         n.numBytes = binary.BigEndian.Uint64(b[pos : pos+8])
         pos += 8
         if pos != len(b) {
                 return nil, fmt.Errorf("nodeLoc.read() pos: %v didn't match length: %v",
                         pos, len(b))
         }
-        atomic.StorePointer(&nloc.node, unsafe.Pointer(n))
+        nloc.setNode(n)
         return n, nil
 }
 
 func numInfo(o *Store, left *nodeLoc, right *nodeLoc) (
         leftNum uint64, leftBytes uint64, rightNum uint64, rightBytes uint64, err error) {
         leftNode, err := left.read(o)
         if err != nil {
                 return 0, 0, 0, 0, err
         }
         rightNode, err := right.read(o)
@@ skipping 24 matching lines @@
         }
         fmt.Printf("%p - %v\n", nNode, k)
         dump(o, &nNode.right, level+1)
 }
 
 func dumpIndent(level int) {
         for i := 0; i < level; i++ {
                 fmt.Print(" ")
         }
 }