├── .gitignore
├── .travis.yml
├── LICENSE.md
├── README.md
├── Vagrantfile
├── go.mod
├── process.go
├── process_darwin.go
├── process_darwin_test.go
├── process_freebsd.go
├── process_linux.go
├── process_solaris.go
├── process_test.go
├── process_unix.go
├── process_unix_test.go
└── process_windows.go


/.gitignore:
--------------------------------------------------------------------------------
1 | .vagrant/
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | arch:
2 |   - amd64
3 |   - ppc64le
4 |   
5 | language: go
6 | 
7 | go:
8 |   - 1.13
9 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Mitchell Hashimoto
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Process List Library for Go [![GoDoc](https://godoc.org/github.com/mitchellh/go-ps?status.png)](https://godoc.org/github.com/mitchellh/go-ps)
 2 | 
 3 | go-ps is a library for Go that implements OS-specific APIs to list and
 4 | manipulate processes in a platform-safe way. The library can find and
 5 | list processes on Linux, Mac OS X, Solaris, and Windows.
 6 | 
 7 | If you're new to Go, this library has a good amount of advanced Go educational
 8 | value as well. It uses some advanced features of Go: build tags, accessing
 9 | DLL methods for Windows, cgo for Darwin, etc.
10 | 
11 | How it works:
12 | 
13 |   * **Darwin** uses the `sysctl` syscall to retrieve the process table.
14 |   * **Unix** uses the procfs at `/proc` to inspect the process tree.
15 |   * **Windows** uses the Windows API, and methods such as
16 |     `CreateToolhelp32Snapshot` to get a point-in-time snapshot of
17 |     the process table.
18 | 
19 | ## Installation
20 | 
21 | Install using standard `go get`:
22 | 
23 | ```
24 | $ go get github.com/mitchellh/go-ps
25 | ...
26 | ```
27 | 
28 | ## TODO
29 | 
30 | Want to contribute? Here is a short TODO list of things that aren't
31 | implemented for this library that would be nice:
32 | 
33 |   * FreeBSD support
34 |   * Plan9 support
35 | 


--------------------------------------------------------------------------------
/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | # Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
 5 | VAGRANTFILE_API_VERSION = "2"
 6 | 
 7 | Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
 8 |   config.vm.box = "chef/ubuntu-12.04"
 9 | 
10 |   config.vm.provision "shell", inline: $script
11 | 
12 |   ["vmware_fusion", "vmware_workstation"].each do |p|
13 |     config.vm.provider "p" do |v|
14 |       v.vmx["memsize"] = "1024"
15 |       v.vmx["numvcpus"] = "2"
16 |       v.vmx["cpuid.coresPerSocket"] = "1"
17 |     end
18 |   end
19 | end
20 | 
21 | $script = <<SCRIPT
22 | SRCROOT="/opt/go"
23 | 
24 | # Install Go
25 | sudo apt-get update
26 | sudo apt-get install -y build-essential mercurial
27 | sudo hg clone -u release https://code.google.com/p/go ${SRCROOT}
28 | cd ${SRCROOT}/src
29 | sudo ./all.bash
30 | 
31 | # Setup the GOPATH
32 | sudo mkdir -p /opt/gopath
33 | cat <<EOF >/tmp/gopath.sh
34 | export GOPATH="/opt/gopath"
35 | export PATH="/opt/go/bin:\$GOPATH/bin:\$PATH"
36 | EOF
37 | sudo mv /tmp/gopath.sh /etc/profile.d/gopath.sh
38 | sudo chmod 0755 /etc/profile.d/gopath.sh
39 | 
40 | # Make sure the gopath is usable by bamboo
41 | sudo chown -R vagrant:vagrant $SRCROOT
42 | sudo chown -R vagrant:vagrant /opt/gopath
43 | SCRIPT
44 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/mitchellh/go-ps
2 | 
3 | go 1.13
4 | 


--------------------------------------------------------------------------------
/process.go:
--------------------------------------------------------------------------------
 1 | // ps provides an API for finding and listing processes in a platform-agnostic
 2 | // way.
 3 | //
 4 | // NOTE: If you're reading these docs online via GoDocs or some other system,
 5 | // you might only see the Unix docs. This project makes heavy use of
 6 | // platform-specific implementations. We recommend reading the source if you
 7 | // are interested.
 8 | package ps
 9 | 
10 | // Process is the generic interface that is implemented on every platform
11 | // and provides common operations for processes.
12 | type Process interface {
13 | 	// Pid is the process ID for this process.
14 | 	Pid() int
15 | 
16 | 	// PPid is the parent process ID for this process.
17 | 	PPid() int
18 | 
19 | 	// Executable name running this process. This is not a path to the
20 | 	// executable.
21 | 	Executable() string
22 | }
23 | 
24 | // Processes returns all processes.
25 | //
26 | // This of course will be a point-in-time snapshot of when this method was
27 | // called. Some operating systems don't provide snapshot capability of the
28 | // process table, in which case the process table returned might contain
29 | // ephemeral entities that happened to be running when this was called.
30 | func Processes() ([]Process, error) {
31 | 	return processes()
32 | }
33 | 
34 | // FindProcess looks up a single process by pid.
35 | //
36 | // Process will be nil and error will be nil if a matching process is
37 | // not found.
38 | func FindProcess(pid int) (Process, error) {
39 | 	return findProcess(pid)
40 | }
41 | 


--------------------------------------------------------------------------------
/process_darwin.go:
--------------------------------------------------------------------------------
  1 | // +build darwin
  2 | 
  3 | package ps
  4 | 
  5 | import (
  6 | 	"bytes"
  7 | 	"encoding/binary"
  8 | 	"syscall"
  9 | 	"unsafe"
 10 | )
 11 | 
 12 | type DarwinProcess struct {
 13 | 	pid    int
 14 | 	ppid   int
 15 | 	binary string
 16 | }
 17 | 
 18 | func (p *DarwinProcess) Pid() int {
 19 | 	return p.pid
 20 | }
 21 | 
 22 | func (p *DarwinProcess) PPid() int {
 23 | 	return p.ppid
 24 | }
 25 | 
 26 | func (p *DarwinProcess) Executable() string {
 27 | 	return p.binary
 28 | }
 29 | 
 30 | func findProcess(pid int) (Process, error) {
 31 | 	ps, err := processes()
 32 | 	if err != nil {
 33 | 		return nil, err
 34 | 	}
 35 | 
 36 | 	for _, p := range ps {
 37 | 		if p.Pid() == pid {
 38 | 			return p, nil
 39 | 		}
 40 | 	}
 41 | 
 42 | 	return nil, nil
 43 | }
 44 | 
 45 | func processes() ([]Process, error) {
 46 | 	buf, err := darwinSyscall()
 47 | 	if err != nil {
 48 | 		return nil, err
 49 | 	}
 50 | 
 51 | 	procs := make([]*kinfoProc, 0, 50)
 52 | 	k := 0
 53 | 	for i := _KINFO_STRUCT_SIZE; i < buf.Len(); i += _KINFO_STRUCT_SIZE {
 54 | 		proc := &kinfoProc{}
 55 | 		err = binary.Read(bytes.NewBuffer(buf.Bytes()[k:i]), binary.LittleEndian, proc)
 56 | 		if err != nil {
 57 | 			return nil, err
 58 | 		}
 59 | 
 60 | 		k = i
 61 | 		procs = append(procs, proc)
 62 | 	}
 63 | 
 64 | 	darwinProcs := make([]Process, len(procs))
 65 | 	for i, p := range procs {
 66 | 		darwinProcs[i] = &DarwinProcess{
 67 | 			pid:    int(p.Pid),
 68 | 			ppid:   int(p.PPid),
 69 | 			binary: darwinCstring(p.Comm),
 70 | 		}
 71 | 	}
 72 | 
 73 | 	return darwinProcs, nil
 74 | }
 75 | 
 76 | func darwinCstring(s [16]byte) string {
 77 | 	i := 0
 78 | 	for _, b := range s {
 79 | 		if b != 0 {
 80 | 			i++
 81 | 		} else {
 82 | 			break
 83 | 		}
 84 | 	}
 85 | 
 86 | 	return string(s[:i])
 87 | }
 88 | 
 89 | func darwinSyscall() (*bytes.Buffer, error) {
 90 | 	mib := [4]int32{_CTRL_KERN, _KERN_PROC, _KERN_PROC_ALL, 0}
 91 | 	size := uintptr(0)
 92 | 
 93 | 	_, _, errno := syscall.Syscall6(
 94 | 		syscall.SYS___SYSCTL,
 95 | 		uintptr(unsafe.Pointer(&mib[0])),
 96 | 		4,
 97 | 		0,
 98 | 		uintptr(unsafe.Pointer(&size)),
 99 | 		0,
100 | 		0)
101 | 
102 | 	if errno != 0 {
103 | 		return nil, errno
104 | 	}
105 | 
106 | 	bs := make([]byte, size)
107 | 	_, _, errno = syscall.Syscall6(
108 | 		syscall.SYS___SYSCTL,
109 | 		uintptr(unsafe.Pointer(&mib[0])),
110 | 		4,
111 | 		uintptr(unsafe.Pointer(&bs[0])),
112 | 		uintptr(unsafe.Pointer(&size)),
113 | 		0,
114 | 		0)
115 | 
116 | 	if errno != 0 {
117 | 		return nil, errno
118 | 	}
119 | 
120 | 	return bytes.NewBuffer(bs[0:size]), nil
121 | }
122 | 
123 | const (
124 | 	_CTRL_KERN         = 1
125 | 	_KERN_PROC         = 14
126 | 	_KERN_PROC_ALL     = 0
127 | 	_KINFO_STRUCT_SIZE = 648
128 | )
129 | 
130 | type kinfoProc struct {
131 | 	_    [40]byte
132 | 	Pid  int32
133 | 	_    [199]byte
134 | 	Comm [16]byte
135 | 	_    [301]byte
136 | 	PPid int32
137 | 	_    [84]byte
138 | }
139 | 


--------------------------------------------------------------------------------
/process_darwin_test.go:
--------------------------------------------------------------------------------
 1 | // +build darwin
 2 | 
 3 | package ps
 4 | 
 5 | import (
 6 | 	"testing"
 7 | )
 8 | 
 9 | func TestDarwinProcess_impl(t *testing.T) {
10 | 	var _ Process = new(DarwinProcess)
11 | }
12 | 


--------------------------------------------------------------------------------
/process_freebsd.go:
--------------------------------------------------------------------------------
  1 | // +build freebsd
  2 | 
  3 | package ps
  4 | 
  5 | import (
  6 | 	"bytes"
  7 | 	"encoding/binary"
  8 | 	"syscall"
  9 | 	"unsafe"
 10 | )
 11 | 
 12 | // copied from sys/sysctl.h
 13 | const (
 14 | 	CTL_KERN           = 1  // "high kernel": proc, limits
 15 | 	KERN_PROC          = 14 // struct: process entries
 16 | 	KERN_PROC_PID      = 1  // by process id
 17 | 	KERN_PROC_PROC     = 8  // only return procs
 18 | 	KERN_PROC_PATHNAME = 12 // path to executable
 19 | )
 20 | 
 21 | // copied from sys/user.h
 22 | type Kinfo_proc struct {
 23 | 	Ki_structsize   int32
 24 | 	Ki_layout       int32
 25 | 	Ki_args         int64
 26 | 	Ki_paddr        int64
 27 | 	Ki_addr         int64
 28 | 	Ki_tracep       int64
 29 | 	Ki_textvp       int64
 30 | 	Ki_fd           int64
 31 | 	Ki_vmspace      int64
 32 | 	Ki_wchan        int64
 33 | 	Ki_pid          int32
 34 | 	Ki_ppid         int32
 35 | 	Ki_pgid         int32
 36 | 	Ki_tpgid        int32
 37 | 	Ki_sid          int32
 38 | 	Ki_tsid         int32
 39 | 	Ki_jobc         [2]byte
 40 | 	Ki_spare_short1 [2]byte
 41 | 	Ki_tdev         int32
 42 | 	Ki_siglist      [16]byte
 43 | 	Ki_sigmask      [16]byte
 44 | 	Ki_sigignore    [16]byte
 45 | 	Ki_sigcatch     [16]byte
 46 | 	Ki_uid          int32
 47 | 	Ki_ruid         int32
 48 | 	Ki_svuid        int32
 49 | 	Ki_rgid         int32
 50 | 	Ki_svgid        int32
 51 | 	Ki_ngroups      [2]byte
 52 | 	Ki_spare_short2 [2]byte
 53 | 	Ki_groups       [64]byte
 54 | 	Ki_size         int64
 55 | 	Ki_rssize       int64
 56 | 	Ki_swrss        int64
 57 | 	Ki_tsize        int64
 58 | 	Ki_dsize        int64
 59 | 	Ki_ssize        int64
 60 | 	Ki_xstat        [2]byte
 61 | 	Ki_acflag       [2]byte
 62 | 	Ki_pctcpu       int32
 63 | 	Ki_estcpu       int32
 64 | 	Ki_slptime      int32
 65 | 	Ki_swtime       int32
 66 | 	Ki_cow          int32
 67 | 	Ki_runtime      int64
 68 | 	Ki_start        [16]byte
 69 | 	Ki_childtime    [16]byte
 70 | 	Ki_flag         int64
 71 | 	Ki_kiflag       int64
 72 | 	Ki_traceflag    int32
 73 | 	Ki_stat         [1]byte
 74 | 	Ki_nice         [1]byte
 75 | 	Ki_lock         [1]byte
 76 | 	Ki_rqindex      [1]byte
 77 | 	Ki_oncpu        [1]byte
 78 | 	Ki_lastcpu      [1]byte
 79 | 	Ki_ocomm        [17]byte
 80 | 	Ki_wmesg        [9]byte
 81 | 	Ki_login        [18]byte
 82 | 	Ki_lockname     [9]byte
 83 | 	Ki_comm         [20]byte
 84 | 	Ki_emul         [17]byte
 85 | 	Ki_sparestrings [68]byte
 86 | 	Ki_spareints    [36]byte
 87 | 	Ki_cr_flags     int32
 88 | 	Ki_jid          int32
 89 | 	Ki_numthreads   int32
 90 | 	Ki_tid          int32
 91 | 	Ki_pri          int32
 92 | 	Ki_rusage       [144]byte
 93 | 	Ki_rusage_ch    [144]byte
 94 | 	Ki_pcb          int64
 95 | 	Ki_kstack       int64
 96 | 	Ki_udata        int64
 97 | 	Ki_tdaddr       int64
 98 | 	Ki_spareptrs    [48]byte
 99 | 	Ki_spareint64s  [96]byte
100 | 	Ki_sflag        int64
101 | 	Ki_tdflags      int64
102 | }
103 | 
104 | // UnixProcess is an implementation of Process that contains Unix-specific
105 | // fields and information.
106 | type UnixProcess struct {
107 | 	pid   int
108 | 	ppid  int
109 | 	state rune
110 | 	pgrp  int
111 | 	sid   int
112 | 
113 | 	binary string
114 | }
115 | 
116 | func (p *UnixProcess) Pid() int {
117 | 	return p.pid
118 | }
119 | 
120 | func (p *UnixProcess) PPid() int {
121 | 	return p.ppid
122 | }
123 | 
124 | func (p *UnixProcess) Executable() string {
125 | 	return p.binary
126 | }
127 | 
128 | // Refresh reloads all the data associated with this process.
129 | func (p *UnixProcess) Refresh() error {
130 | 
131 | 	mib := []int32{CTL_KERN, KERN_PROC, KERN_PROC_PID, int32(p.pid)}
132 | 
133 | 	buf, length, err := call_syscall(mib)
134 | 	if err != nil {
135 | 		return err
136 | 	}
137 | 	proc_k := Kinfo_proc{}
138 | 	if length != uint64(unsafe.Sizeof(proc_k)) {
139 | 		return err
140 | 	}
141 | 
142 | 	k, err := parse_kinfo_proc(buf)
143 | 	if err != nil {
144 | 		return err
145 | 	}
146 | 
147 | 	p.ppid, p.pgrp, p.sid, p.binary = copy_params(&k)
148 | 	return nil
149 | }
150 | 
151 | func copy_params(k *Kinfo_proc) (int, int, int, string) {
152 | 	n := -1
153 | 	for i, b := range k.Ki_comm {
154 | 		if b == 0 {
155 | 			break
156 | 		}
157 | 		n = i + 1
158 | 	}
159 | 	comm := string(k.Ki_comm[:n])
160 | 
161 | 	return int(k.Ki_ppid), int(k.Ki_pgid), int(k.Ki_sid), comm
162 | }
163 | 
164 | func findProcess(pid int) (Process, error) {
165 | 	mib := []int32{CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, int32(pid)}
166 | 
167 | 	_, _, err := call_syscall(mib)
168 | 	if err != nil {
169 | 		return nil, err
170 | 	}
171 | 
172 | 	return newUnixProcess(pid)
173 | }
174 | 
175 | func processes() ([]Process, error) {
176 | 	results := make([]Process, 0, 50)
177 | 
178 | 	mib := []int32{CTL_KERN, KERN_PROC, KERN_PROC_PROC, 0}
179 | 	buf, length, err := call_syscall(mib)
180 | 	if err != nil {
181 | 		return results, err
182 | 	}
183 | 
184 | 	// get kinfo_proc size
185 | 	k := Kinfo_proc{}
186 | 	procinfo_len := int(unsafe.Sizeof(k))
187 | 	count := int(length / uint64(procinfo_len))
188 | 
189 | 	// parse buf to procs
190 | 	for i := 0; i < count; i++ {
191 | 		b := buf[i*procinfo_len : i*procinfo_len+procinfo_len]
192 | 		k, err := parse_kinfo_proc(b)
193 | 		if err != nil {
194 | 			continue
195 | 		}
196 | 		p, err := newUnixProcess(int(k.Ki_pid))
197 | 		if err != nil {
198 | 			continue
199 | 		}
200 | 		p.ppid, p.pgrp, p.sid, p.binary = copy_params(&k)
201 | 
202 | 		results = append(results, p)
203 | 	}
204 | 
205 | 	return results, nil
206 | }
207 | 
208 | func parse_kinfo_proc(buf []byte) (Kinfo_proc, error) {
209 | 	var k Kinfo_proc
210 | 	br := bytes.NewReader(buf)
211 | 	err := binary.Read(br, binary.LittleEndian, &k)
212 | 	if err != nil {
213 | 		return k, err
214 | 	}
215 | 
216 | 	return k, nil
217 | }
218 | 
219 | func call_syscall(mib []int32) ([]byte, uint64, error) {
220 | 	miblen := uint64(len(mib))
221 | 
222 | 	// get required buffer size
223 | 	length := uint64(0)
224 | 	_, _, err := syscall.RawSyscall6(
225 | 		syscall.SYS___SYSCTL,
226 | 		uintptr(unsafe.Pointer(&mib[0])),
227 | 		uintptr(miblen),
228 | 		0,
229 | 		uintptr(unsafe.Pointer(&length)),
230 | 		0,
231 | 		0)
232 | 	if err != 0 {
233 | 		b := make([]byte, 0)
234 | 		return b, length, err
235 | 	}
236 | 	if length == 0 {
237 | 		b := make([]byte, 0)
238 | 		return b, length, err
239 | 	}
240 | 	// get proc info itself
241 | 	buf := make([]byte, length)
242 | 	_, _, err = syscall.RawSyscall6(
243 | 		syscall.SYS___SYSCTL,
244 | 		uintptr(unsafe.Pointer(&mib[0])),
245 | 		uintptr(miblen),
246 | 		uintptr(unsafe.Pointer(&buf[0])),
247 | 		uintptr(unsafe.Pointer(&length)),
248 | 		0,
249 | 		0)
250 | 	if err != 0 {
251 | 		return buf, length, err
252 | 	}
253 | 
254 | 	return buf, length, nil
255 | }
256 | 
257 | func newUnixProcess(pid int) (*UnixProcess, error) {
258 | 	p := &UnixProcess{pid: pid}
259 | 	return p, p.Refresh()
260 | }
261 | 


--------------------------------------------------------------------------------
/process_linux.go:
--------------------------------------------------------------------------------
 1 | // +build linux
 2 | 
 3 | package ps
 4 | 
 5 | import (
 6 | 	"fmt"
 7 | 	"io/ioutil"
 8 | 	"strings"
 9 | )
10 | 
11 | // Refresh reloads all the data associated with this process.
12 | func (p *UnixProcess) Refresh() error {
13 | 	statPath := fmt.Sprintf("/proc/%d/stat", p.pid)
14 | 	dataBytes, err := ioutil.ReadFile(statPath)
15 | 	if err != nil {
16 | 		return err
17 | 	}
18 | 
19 | 	// First, parse out the image name
20 | 	data := string(dataBytes)
21 | 	binStart := strings.IndexRune(data, '(') + 1
22 | 	binEnd := strings.IndexRune(data[binStart:], ')')
23 | 	p.binary = data[binStart : binStart+binEnd]
24 | 
25 | 	// Move past the image name and start parsing the rest
26 | 	data = data[binStart+binEnd+2:]
27 | 	_, err = fmt.Sscanf(data,
28 | 		"%c %d %d %d",
29 | 		&p.state,
30 | 		&p.ppid,
31 | 		&p.pgrp,
32 | 		&p.sid)
33 | 
34 | 	return err
35 | }
36 | 


--------------------------------------------------------------------------------
/process_solaris.go:
--------------------------------------------------------------------------------
 1 | // +build solaris
 2 | 
 3 | package ps
 4 | 
 5 | import (
 6 | 	"encoding/binary"
 7 | 	"fmt"
 8 | 	"os"
 9 | )
10 | 
11 | type ushort_t uint16
12 | 
13 | type id_t int32
14 | type pid_t int32
15 | type uid_t int32
16 | type gid_t int32
17 | 
18 | type dev_t uint64
19 | type size_t uint64
20 | type uintptr_t uint64
21 | 
22 | type timestruc_t [16]byte
23 | 
24 | // This is copy from /usr/include/sys/procfs.h
25 | type psinfo_t struct {
26 | 	Pr_flag   int32     /* process flags (DEPRECATED; do not use) */
27 | 	Pr_nlwp   int32     /* number of active lwps in the process */
28 | 	Pr_pid    pid_t     /* unique process id */
29 | 	Pr_ppid   pid_t     /* process id of parent */
30 | 	Pr_pgid   pid_t     /* pid of process group leader */
31 | 	Pr_sid    pid_t     /* session id */
32 | 	Pr_uid    uid_t     /* real user id */
33 | 	Pr_euid   uid_t     /* effective user id */
34 | 	Pr_gid    gid_t     /* real group id */
35 | 	Pr_egid   gid_t     /* effective group id */
36 | 	Pr_addr   uintptr_t /* address of process */
37 | 	Pr_size   size_t    /* size of process image in Kbytes */
38 | 	Pr_rssize size_t    /* resident set size in Kbytes */
39 | 	Pr_pad1   size_t
40 | 	Pr_ttydev dev_t /* controlling tty device (or PRNODEV) */
41 | 
42 | 	// Guess this following 2 ushort_t values require a padding to properly
43 | 	// align to the 64bit mark.
44 | 	Pr_pctcpu   ushort_t /* % of recent cpu time used by all lwps */
45 | 	Pr_pctmem   ushort_t /* % of system memory used by process */
46 | 	Pr_pad64bit [4]byte
47 | 
48 | 	Pr_start    timestruc_t /* process start time, from the epoch */
49 | 	Pr_time     timestruc_t /* usr+sys cpu time for this process */
50 | 	Pr_ctime    timestruc_t /* usr+sys cpu time for reaped children */
51 | 	Pr_fname    [16]byte    /* name of execed file */
52 | 	Pr_psargs   [80]byte    /* initial characters of arg list */
53 | 	Pr_wstat    int32       /* if zombie, the wait() status */
54 | 	Pr_argc     int32       /* initial argument count */
55 | 	Pr_argv     uintptr_t   /* address of initial argument vector */
56 | 	Pr_envp     uintptr_t   /* address of initial environment vector */
57 | 	Pr_dmodel   [1]byte     /* data model of the process */
58 | 	Pr_pad2     [3]byte
59 | 	Pr_taskid   id_t      /* task id */
60 | 	Pr_projid   id_t      /* project id */
61 | 	Pr_nzomb    int32     /* number of zombie lwps in the process */
62 | 	Pr_poolid   id_t      /* pool id */
63 | 	Pr_zoneid   id_t      /* zone id */
64 | 	Pr_contract id_t      /* process contract */
65 | 	Pr_filler   int32     /* reserved for future use */
66 | 	Pr_lwp      [128]byte /* information for representative lwp */
67 | }
68 | 
69 | func (p *UnixProcess) Refresh() error {
70 | 	var psinfo psinfo_t
71 | 
72 | 	path := fmt.Sprintf("/proc/%d/psinfo", p.pid)
73 | 	fh, err := os.Open(path)
74 | 	if err != nil {
75 | 		return err
76 | 	}
77 | 	defer fh.Close()
78 | 
79 | 	err = binary.Read(fh, binary.LittleEndian, &psinfo)
80 | 	if err != nil {
81 | 		return err
82 | 	}
83 | 
84 | 	p.ppid = int(psinfo.Pr_ppid)
85 | 	p.binary = toString(psinfo.Pr_fname[:], 16)
86 | 	return nil
87 | }
88 | 
89 | func toString(array []byte, len int) string {
90 | 	for i := 0; i < len; i++ {
91 | 		if array[i] == 0 {
92 | 			return string(array[:i])
93 | 		}
94 | 	}
95 | 	return string(array[:])
96 | }
97 | 


--------------------------------------------------------------------------------
/process_test.go:
--------------------------------------------------------------------------------
 1 | package ps
 2 | 
 3 | import (
 4 | 	"os"
 5 | 	"testing"
 6 | )
 7 | 
 8 | func TestFindProcess(t *testing.T) {
 9 | 	p, err := FindProcess(os.Getpid())
10 | 	if err != nil {
11 | 		t.Fatalf("err: %s", err)
12 | 	}
13 | 	if p == nil {
14 | 		t.Fatal("should have process")
15 | 	}
16 | 
17 | 	if p.Pid() != os.Getpid() {
18 | 		t.Fatalf("bad: %#v", p.Pid())
19 | 	}
20 | }
21 | 
22 | func TestProcesses(t *testing.T) {
23 | 	// This test works because there will always be SOME processes
24 | 	// running.
25 | 	p, err := Processes()
26 | 	if err != nil {
27 | 		t.Fatalf("err: %s", err)
28 | 	}
29 | 
30 | 	if len(p) <= 0 {
31 | 		t.Fatal("should have processes")
32 | 	}
33 | 
34 | 	found := false
35 | 	for _, p1 := range p {
36 | 		if p1.Executable() == "go" || p1.Executable() == "go.exe" {
37 | 			found = true
38 | 			break
39 | 		}
40 | 	}
41 | 
42 | 	if !found {
43 | 		t.Fatal("should have Go")
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/process_unix.go:
--------------------------------------------------------------------------------
 1 | // +build linux solaris
 2 | 
 3 | package ps
 4 | 
 5 | import (
 6 | 	"fmt"
 7 | 	"io"
 8 | 	"os"
 9 | 	"strconv"
10 | )
11 | 
12 | // UnixProcess is an implementation of Process that contains Unix-specific
13 | // fields and information.
14 | type UnixProcess struct {
15 | 	pid   int
16 | 	ppid  int
17 | 	state rune
18 | 	pgrp  int
19 | 	sid   int
20 | 
21 | 	binary string
22 | }
23 | 
24 | func (p *UnixProcess) Pid() int {
25 | 	return p.pid
26 | }
27 | 
28 | func (p *UnixProcess) PPid() int {
29 | 	return p.ppid
30 | }
31 | 
32 | func (p *UnixProcess) Executable() string {
33 | 	return p.binary
34 | }
35 | 
36 | func findProcess(pid int) (Process, error) {
37 | 	dir := fmt.Sprintf("/proc/%d", pid)
38 | 	_, err := os.Stat(dir)
39 | 	if err != nil {
40 | 		if os.IsNotExist(err) {
41 | 			return nil, nil
42 | 		}
43 | 
44 | 		return nil, err
45 | 	}
46 | 
47 | 	return newUnixProcess(pid)
48 | }
49 | 
50 | func processes() ([]Process, error) {
51 | 	d, err := os.Open("/proc")
52 | 	if err != nil {
53 | 		return nil, err
54 | 	}
55 | 	defer d.Close()
56 | 
57 | 	results := make([]Process, 0, 50)
58 | 	for {
59 | 		names, err := d.Readdirnames(10)
60 | 		if err == io.EOF {
61 | 			break
62 | 		}
63 | 		if err != nil {
64 | 			return nil, err
65 | 		}
66 | 
67 | 		for _, name := range names {
68 | 			// We only care if the name starts with a numeric
69 | 			if name[0] < '0' || name[0] > '9' {
70 | 				continue
71 | 			}
72 | 
73 | 			// From this point forward, any errors we just ignore, because
74 | 			// it might simply be that the process doesn't exist anymore.
75 | 			pid, err := strconv.ParseInt(name, 10, 0)
76 | 			if err != nil {
77 | 				continue
78 | 			}
79 | 
80 | 			p, err := newUnixProcess(int(pid))
81 | 			if err != nil {
82 | 				continue
83 | 			}
84 | 
85 | 			results = append(results, p)
86 | 		}
87 | 	}
88 | 
89 | 	return results, nil
90 | }
91 | 
92 | func newUnixProcess(pid int) (*UnixProcess, error) {
93 | 	p := &UnixProcess{pid: pid}
94 | 	return p, p.Refresh()
95 | }
96 | 


--------------------------------------------------------------------------------
/process_unix_test.go:
--------------------------------------------------------------------------------
 1 | // +build linux solaris
 2 | 
 3 | package ps
 4 | 
 5 | import (
 6 | 	"testing"
 7 | )
 8 | 
 9 | func TestUnixProcess_impl(t *testing.T) {
10 | 	var _ Process = new(UnixProcess)
11 | }
12 | 


--------------------------------------------------------------------------------
/process_windows.go:
--------------------------------------------------------------------------------
  1 | // +build windows
  2 | 
  3 | package ps
  4 | 
  5 | import (
  6 | 	"fmt"
  7 | 	"syscall"
  8 | 	"unsafe"
  9 | )
 10 | 
 11 | // Windows API functions
 12 | var (
 13 | 	modKernel32                  = syscall.NewLazyDLL("kernel32.dll")
 14 | 	procCloseHandle              = modKernel32.NewProc("CloseHandle")
 15 | 	procCreateToolhelp32Snapshot = modKernel32.NewProc("CreateToolhelp32Snapshot")
 16 | 	procProcess32First           = modKernel32.NewProc("Process32FirstW")
 17 | 	procProcess32Next            = modKernel32.NewProc("Process32NextW")
 18 | )
 19 | 
 20 | // Some constants from the Windows API
 21 | const (
 22 | 	ERROR_NO_MORE_FILES = 0x12
 23 | 	MAX_PATH            = 260
 24 | )
 25 | 
 26 | // PROCESSENTRY32 is the Windows API structure that contains a process's
 27 | // information.
 28 | type PROCESSENTRY32 struct {
 29 | 	Size              uint32
 30 | 	CntUsage          uint32
 31 | 	ProcessID         uint32
 32 | 	DefaultHeapID     uintptr
 33 | 	ModuleID          uint32
 34 | 	CntThreads        uint32
 35 | 	ParentProcessID   uint32
 36 | 	PriorityClassBase int32
 37 | 	Flags             uint32
 38 | 	ExeFile           [MAX_PATH]uint16
 39 | }
 40 | 
 41 | // WindowsProcess is an implementation of Process for Windows.
 42 | type WindowsProcess struct {
 43 | 	pid  int
 44 | 	ppid int
 45 | 	exe  string
 46 | }
 47 | 
 48 | func (p *WindowsProcess) Pid() int {
 49 | 	return p.pid
 50 | }
 51 | 
 52 | func (p *WindowsProcess) PPid() int {
 53 | 	return p.ppid
 54 | }
 55 | 
 56 | func (p *WindowsProcess) Executable() string {
 57 | 	return p.exe
 58 | }
 59 | 
 60 | func newWindowsProcess(e *PROCESSENTRY32) *WindowsProcess {
 61 | 	// Find when the string ends for decoding
 62 | 	end := 0
 63 | 	for {
 64 | 		if e.ExeFile[end] == 0 {
 65 | 			break
 66 | 		}
 67 | 		end++
 68 | 	}
 69 | 
 70 | 	return &WindowsProcess{
 71 | 		pid:  int(e.ProcessID),
 72 | 		ppid: int(e.ParentProcessID),
 73 | 		exe:  syscall.UTF16ToString(e.ExeFile[:end]),
 74 | 	}
 75 | }
 76 | 
 77 | func findProcess(pid int) (Process, error) {
 78 | 	ps, err := processes()
 79 | 	if err != nil {
 80 | 		return nil, err
 81 | 	}
 82 | 
 83 | 	for _, p := range ps {
 84 | 		if p.Pid() == pid {
 85 | 			return p, nil
 86 | 		}
 87 | 	}
 88 | 
 89 | 	return nil, nil
 90 | }
 91 | 
 92 | func processes() ([]Process, error) {
 93 | 	handle, _, _ := procCreateToolhelp32Snapshot.Call(
 94 | 		0x00000002,
 95 | 		0)
 96 | 	if handle < 0 {
 97 | 		return nil, syscall.GetLastError()
 98 | 	}
 99 | 	defer procCloseHandle.Call(handle)
100 | 
101 | 	var entry PROCESSENTRY32
102 | 	entry.Size = uint32(unsafe.Sizeof(entry))
103 | 	ret, _, _ := procProcess32First.Call(handle, uintptr(unsafe.Pointer(&entry)))
104 | 	if ret == 0 {
105 | 		return nil, fmt.Errorf("Error retrieving process info.")
106 | 	}
107 | 
108 | 	results := make([]Process, 0, 50)
109 | 	for {
110 | 		results = append(results, newWindowsProcess(&entry))
111 | 
112 | 		ret, _, _ := procProcess32Next.Call(handle, uintptr(unsafe.Pointer(&entry)))
113 | 		if ret == 0 {
114 | 			break
115 | 		}
116 | 	}
117 | 
118 | 	return results, nil
119 | }
120 | 


--------------------------------------------------------------------------------