@@ -10,9 +10,7 @@ import (
10
10
"path/filepath"
11
11
"strconv"
12
12
"strings"
13
- "time"
14
13
15
- "github.com/shirou/gopsutil/v3/cpu"
16
14
"github.com/shirou/gopsutil/v3/internal/common"
17
15
"github.com/shirou/gopsutil/v3/net"
18
16
"github.com/tklauser/go-sysconf"
@@ -46,116 +44,69 @@ type _Ctype_struct___0 struct {
46
44
func pidsWithContext (ctx context.Context ) ([]int32 , error ) {
47
45
var ret []int32
48
46
49
- pids , err := callPsWithContext ( ctx , "pid" , 0 , false , false )
47
+ kprocs , err := unix . SysctlKinfoProcSlice ( "kern.proc.all" )
50
48
if err != nil {
51
49
return ret , err
52
50
}
53
51
54
- for _ , pid := range pids {
55
- v , err := strconv .Atoi (pid [0 ])
56
- if err != nil {
57
- return ret , err
58
- }
59
- ret = append (ret , int32 (v ))
52
+ for _ , proc := range kprocs {
53
+ ret = append (ret , int32 (proc .Proc .P_pid ))
60
54
}
61
55
62
56
return ret , nil
63
57
}
64
58
65
59
func (p * Process ) PpidWithContext (ctx context.Context ) (int32 , error ) {
66
- r , err := callPsWithContext (ctx , "ppid" , p .Pid , false , false )
67
- if err != nil {
68
- return 0 , err
69
- }
70
-
71
- v , err := strconv .Atoi (r [0 ][0 ])
60
+ k , err := p .getKProc ()
72
61
if err != nil {
73
62
return 0 , err
74
63
}
75
64
76
- return int32 ( v ), err
65
+ return k . Eproc . Ppid , nil
77
66
}
78
67
79
68
func (p * Process ) NameWithContext (ctx context.Context ) (string , error ) {
80
69
k , err := p .getKProc ()
81
70
if err != nil {
82
71
return "" , err
83
72
}
84
- name := common .IntToString (k .Proc .P_comm [:])
73
+
74
+ name := common .ByteToString (k .Proc .P_comm [:])
85
75
86
76
if len (name ) >= 15 {
87
77
cmdName , err := p .cmdNameWithContext (ctx )
88
78
if err != nil {
89
79
return "" , err
90
80
}
91
81
if len (cmdName ) > 0 {
92
- extendedName := filepath .Base (cmdName [ 0 ] )
82
+ extendedName := filepath .Base (cmdName )
93
83
if strings .HasPrefix (extendedName , p .name ) {
94
84
name = extendedName
95
85
} else {
96
- name = cmdName [ 0 ]
86
+ name = cmdName
97
87
}
98
88
}
99
89
}
100
90
101
91
return name , nil
102
92
}
103
93
104
- // cmdNameWithContext returns the command name (including spaces) without any arguments
105
- func (p * Process ) cmdNameWithContext (ctx context.Context ) ([]string , error ) {
106
- r , err := callPsWithContext (ctx , "command" , p .Pid , false , true )
107
- if err != nil {
108
- return nil , err
109
- }
110
- return r [0 ], err
111
- }
112
-
113
94
func (p * Process ) createTimeWithContext (ctx context.Context ) (int64 , error ) {
114
- r , err := callPsWithContext ( ctx , "etime" , p . Pid , false , false )
95
+ k , err := p . getKProc ( )
115
96
if err != nil {
116
97
return 0 , err
117
98
}
118
99
119
- elapsedSegments := strings .Split (strings .Replace (r [0 ][0 ], "-" , ":" , 1 ), ":" )
120
- var elapsedDurations []time.Duration
121
- for i := len (elapsedSegments ) - 1 ; i >= 0 ; i -- {
122
- p , err := strconv .ParseInt (elapsedSegments [i ], 10 , 0 )
123
- if err != nil {
124
- return 0 , err
125
- }
126
- elapsedDurations = append (elapsedDurations , time .Duration (p ))
127
- }
128
-
129
- elapsed := time .Duration (elapsedDurations [0 ]) * time .Second
130
- if len (elapsedDurations ) > 1 {
131
- elapsed += time .Duration (elapsedDurations [1 ]) * time .Minute
132
- }
133
- if len (elapsedDurations ) > 2 {
134
- elapsed += time .Duration (elapsedDurations [2 ]) * time .Hour
135
- }
136
- if len (elapsedDurations ) > 3 {
137
- elapsed += time .Duration (elapsedDurations [3 ]) * time .Hour * 24
138
- }
139
-
140
- start := time .Now ().Add (- elapsed )
141
- return start .Unix () * 1000 , nil
100
+ return k .Proc .P_starttime .Sec * 1000 + int64 (k .Proc .P_starttime .Usec )/ 1000 , nil
142
101
}
143
102
144
103
func (p * Process ) ParentWithContext (ctx context.Context ) (* Process , error ) {
145
- out , err := common . CallLsofWithContext (ctx , invoke , p . Pid , "-FR" )
104
+ ppid , err := p . PpidWithContext (ctx )
146
105
if err != nil {
147
106
return nil , err
148
107
}
149
- for _ , line := range out {
150
- if len (line ) >= 1 && line [0 ] == 'R' {
151
- v , err := strconv .Atoi (line [1 :])
152
- if err != nil {
153
- return nil , err
154
- }
155
- return NewProcessWithContext (ctx , int32 (v ))
156
- }
157
- }
158
- return nil , fmt .Errorf ("could not find parent line" )
108
+
109
+ return NewProcessWithContext (ctx , ppid )
159
110
}
160
111
161
112
func (p * Process ) StatusWithContext (ctx context.Context ) ([]string , error ) {
@@ -188,7 +139,7 @@ func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error) {
188
139
}
189
140
190
141
// See: http://unix.superglobalmegacorp.com/Net2/newsrc/sys/ucred.h.html
191
- userEffectiveUID := int32 (k .Eproc .Ucred .UID )
142
+ userEffectiveUID := int32 (k .Eproc .Ucred .Uid )
192
143
193
144
return []int32 {userEffectiveUID }, nil
194
145
}
@@ -200,7 +151,7 @@ func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error) {
200
151
}
201
152
202
153
gids := make ([]int32 , 0 , 3 )
203
- gids = append (gids , int32 (k .Eproc .Pcred .P_rgid ), int32 (k .Eproc .Ucred . Ngroups ), int32 (k .Eproc .Pcred .P_svgid ))
154
+ gids = append (gids , int32 (k .Eproc .Pcred .P_rgid ), int32 (k .Eproc .Pcred . P_rgid ), int32 (k .Eproc .Pcred .P_svgid ))
204
155
205
156
return gids , nil
206
157
}
@@ -250,14 +201,6 @@ func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, e
250
201
return nil , common .ErrNotImplementedError
251
202
}
252
203
253
- func (p * Process ) NumThreadsWithContext (ctx context.Context ) (int32 , error ) {
254
- r , err := callPsWithContext (ctx , "utime,stime" , p .Pid , true , false )
255
- if err != nil {
256
- return 0 , err
257
- }
258
- return int32 (len (r )), nil
259
- }
260
-
261
204
func convertCPUTimes (s string ) (ret float64 , err error ) {
262
205
var t int
263
206
var _tmp string
@@ -304,56 +247,6 @@ func convertCPUTimes(s string) (ret float64, err error) {
304
247
return float64 (t ) / float64 (clockTicks ), nil
305
248
}
306
249
307
- func (p * Process ) TimesWithContext (ctx context.Context ) (* cpu.TimesStat , error ) {
308
- r , err := callPsWithContext (ctx , "utime,stime" , p .Pid , false , false )
309
- if err != nil {
310
- return nil , err
311
- }
312
-
313
- utime , err := convertCPUTimes (r [0 ][0 ])
314
- if err != nil {
315
- return nil , err
316
- }
317
- stime , err := convertCPUTimes (r [0 ][1 ])
318
- if err != nil {
319
- return nil , err
320
- }
321
-
322
- ret := & cpu.TimesStat {
323
- CPU : "cpu" ,
324
- User : utime ,
325
- System : stime ,
326
- }
327
- return ret , nil
328
- }
329
-
330
- func (p * Process ) MemoryInfoWithContext (ctx context.Context ) (* MemoryInfoStat , error ) {
331
- r , err := callPsWithContext (ctx , "rss,vsize,pagein" , p .Pid , false , false )
332
- if err != nil {
333
- return nil , err
334
- }
335
- rss , err := strconv .Atoi (r [0 ][0 ])
336
- if err != nil {
337
- return nil , err
338
- }
339
- vms , err := strconv .Atoi (r [0 ][1 ])
340
- if err != nil {
341
- return nil , err
342
- }
343
- pagein , err := strconv .Atoi (r [0 ][2 ])
344
- if err != nil {
345
- return nil , err
346
- }
347
-
348
- ret := & MemoryInfoStat {
349
- RSS : uint64 (rss ) * 1024 ,
350
- VMS : uint64 (vms ) * 1024 ,
351
- Swap : uint64 (pagein ),
352
- }
353
-
354
- return ret , nil
355
- }
356
-
357
250
func (p * Process ) ChildrenWithContext (ctx context.Context ) ([]* Process , error ) {
358
251
pids , err := common .CallPgrepWithContext (ctx , invoke , p .Pid )
359
252
if err != nil {
@@ -399,17 +292,8 @@ func ProcessesWithContext(ctx context.Context) ([]*Process, error) {
399
292
400
293
// Returns a proc as defined here:
401
294
// http://unix.superglobalmegacorp.com/Net2/newsrc/sys/kinfo_proc.h.html
402
- func (p * Process ) getKProc () (* KinfoProc , error ) {
403
- buf , err := unix .SysctlRaw ("kern.proc.pid" , int (p .Pid ))
404
- if err != nil {
405
- return nil , err
406
- }
407
- k , err := parseKinfoProc (buf )
408
- if err != nil {
409
- return nil , err
410
- }
411
-
412
- return & k , nil
295
+ func (p * Process ) getKProc () (* unix.KinfoProc , error ) {
296
+ return unix .SysctlKinfoProc ("kern.proc.pid" , int (p .Pid ))
413
297
}
414
298
415
299
// call ps command.
0 commit comments