chore(proctree): use atomic types

pkg/proctree/process.go

@@ -10,17 +10,17 @@ import (
 
 // Process represents a process.
 type Process struct {
-	processHash uint32    // hash of process (immutable, so no need of concurrency control)
-	parentHash  uint32    // hash of parent
-	info        *TaskInfo // task info (immutable pointer)
-	executable  *FileInfo // executable info (immutable pointer)
+	processHash uint32        // hash of process (immutable, so no need of concurrency control)
+	parentHash  atomic.Uint32 // hash of parent
+	info        *TaskInfo     // task info (immutable pointer)
+	executable  *FileInfo     // executable info (immutable pointer)
 }
 
 // NewProcess creates a new thread with an initialized task info.
 func NewProcess(hash uint32, info *TaskInfo) *Process {
 	return &Process{
 		processHash: hash,
-		parentHash:  0,
+		parentHash:  atomic.Uint32{},
 		info:        info,
 		executable:  NewFileInfo(),
 	}
@@ -35,7 +35,7 @@ func (p *Process) GetHash() uint32 {
 
 // GetParentHash returns the hash of the parent.
 func (p *Process) GetParentHash() uint32 {
-	return atomic.LoadUint32(&p.parentHash)
+	return p.parentHash.Load()
 }
 
 // GetInfo returns a instanced task info.
@@ -52,5 +52,5 @@ func (p *Process) GetExecutable() *FileInfo {
 
 // SetParentHash sets the hash of the parent.
 func (p *Process) SetParentHash(parentHash uint32) {
-	atomic.StoreUint32(&p.parentHash, parentHash)
+	p.parentHash.Store(parentHash)
 }

pkg/proctree/process_test.go

@@ -0,0 +1,14 @@
+package proctree
+
+import (
+	"os"
+	"testing"
+
+	"github.com/aquasecurity/tracee/pkg/utils/tests"
+)
+
+// TestProcess_PrintSizes prints the sizes of the structs used in the Process type.
+// Run it as DEBUG test to see the output.
+func TestProcess_PrintSizes(t *testing.T) {
+	tests.PrintStructSizes(t, os.Stdout, Process{})
+}

pkg/proctree/thread.go

@@ -4,11 +4,11 @@ import "sync/atomic"
 
 // Thread represents a thread.
 type Thread struct {
-	threadHash uint32    // hash of thread (immutable, so no need of concurrency control)
-	parentHash uint32    // hash of parent
-	leaderHash uint32    // hash of thread group leader
-	_          [4]byte   // padding
-	info       *TaskInfo // task info (immutable pointer)
+	threadHash uint32        // hash of thread (immutable, so no need of concurrency control)
+	parentHash atomic.Uint32 // hash of parent
+	leaderHash atomic.Uint32 // hash of thread group leader
+	_          [4]byte       // padding
+	info       *TaskInfo     // task info (immutable pointer)
 }
 
 // NOTE: The importance of having the thread group leader hash to each thread is the following: the
@@ -21,8 +21,8 @@ type Thread struct {
 func NewThread(hash uint32, info *TaskInfo) *Thread {
 	return &Thread{
 		threadHash: hash,
-		parentHash: 0,
-		leaderHash: 0,
+		parentHash: atomic.Uint32{},
+		leaderHash: atomic.Uint32{},
 		info:       info,
 	}
 }
@@ -36,12 +36,12 @@ func (t *Thread) GetHash() uint32 {
 
 // GetParentHash returns the hash of the parent.
 func (t *Thread) GetParentHash() uint32 {
-	return atomic.LoadUint32(&t.parentHash)
+	return t.parentHash.Load()
 }
 
 // GEtLeaderHash returns the hash of the thread group leader.
 func (t *Thread) GetLeaderHash() uint32 {
-	return atomic.LoadUint32(&t.leaderHash)
+	return t.leaderHash.Load()
 }
 
 // GetInfo returns a instanced task info.
@@ -53,10 +53,10 @@ func (t *Thread) GetInfo() *TaskInfo {
 
 // SetParentHash sets the hash of the parent.
 func (t *Thread) SetParentHash(parentHash uint32) {
-	atomic.StoreUint32(&t.parentHash, parentHash)
+	t.parentHash.Store(parentHash)
 }
 
 // SetLeaderHash sets the hash of the thread group leader.
 func (t *Thread) SetLeaderHash(leaderHash uint32) {
-	atomic.StoreUint32(&t.leaderHash, leaderHash)
+	t.leaderHash.Store(leaderHash)
 }

pkg/proctree/thread_test.go

@@ -10,6 +10,5 @@ import (
 // TestThread_PrintSizes prints the sizes of the structs used in the Thread type.
 // Run it as DEBUG test to see the output.
 func TestThread_PrintSizes(t *testing.T) {
-	thread := Thread{}
-	tests.PrintStructSizes(t, os.Stdout, thread)
+	tests.PrintStructSizes(t, os.Stdout, Thread{})
 }