Lomanic
/
gopsutil
mirror of https://github.com/shirou/gopsutil
1
0
Fork 0
Code Issues Releases Activity

disk: add disk_io_counter to FreeBSD by using sysctl(kern.devstat.all).

Browse Source
pull/43/merge
WAKAYAMA shirou 11 years ago
parent be5b5a5754
commit 0451709fe3
4 changed files with 182 additions and 130 deletions
Show Stats Download Patch File Download Diff File

2
README.rst
Unescape Escape View File

@ -135,7 +135,7 @@ cpu_times_percent x x x
virtual_memory x x x x virtual_memory x x x x
swap_memory x x x swap_memory x x x
disk_partitions x x x x disk_partitions x x x x
disk_io_counters x disk_io_counters x x
disk_usage x x x x disk_usage x x x x
net_io_counters x x b x net_io_counters x x b x
boot_time x x x x boot_time x x x x

111
disk/disk_freebsd.go
Unescape Escape View File

@ -3,79 +3,88 @@
package disk package disk
import ( import (
"bytes"
"encoding/binary"
"strconv"
"syscall" "syscall"
"unsafe" "unsafe"
common "github.com/shirou/gopsutil/common" common "github.com/shirou/gopsutil/common"
) )
const (
CTLKern = 1
KernDevstat = 773
KernDevstatAll = 772
)
func DiskPartitions(all bool) ([]DiskPartitionStat, error) { func DiskPartitions(all bool) ([]DiskPartitionStat, error) {
var ret []DiskPartitionStat var ret []DiskPartitionStat
// get length // get length
count, err := syscall.Getfsstat(nil, MntWait) count, err := syscall.Getfsstat(nil, MNT_WAIT)
if err != nil { if err != nil {
return ret, err return ret, err
} }
fs := make([]Statfs, count) fs := make([]Statfs, count)
_, err = Getfsstat(fs, MntWait) _, err = Getfsstat(fs, MNT_WAIT)
for _, stat := range fs { for _, stat := range fs {
opts := "rw" opts := "rw"
if stat.FFlags&MntReadOnly != 0 { if stat.Flags&MNT_RDONLY != 0 {
opts = "ro" opts = "ro"
} }
if stat.FFlags&MntSynchronous != 0 { if stat.Flags&MNT_SYNCHRONOUS != 0 {
opts += ",sync" opts += ",sync"
} }
if stat.FFlags&MntNoExec != 0 { if stat.Flags&MNT_NOEXEC != 0 {
opts += ",noexec" opts += ",noexec"
} }
if stat.FFlags&MntNoSuid != 0 { if stat.Flags&MNT_NOSUID != 0 {
opts += ",nosuid" opts += ",nosuid"
} }
if stat.FFlags&MntUnion != 0 { if stat.Flags&MNT_UNION != 0 {
opts += ",union" opts += ",union"
} }
if stat.FFlags&MntAsync != 0 { if stat.Flags&MNT_ASYNC != 0 {
opts += ",async" opts += ",async"
} }
if stat.FFlags&MntSuidDir != 0 { if stat.Flags&MNT_SUIDDIR != 0 {
opts += ",suiddir" opts += ",suiddir"
} }
if stat.FFlags&MntSoftDep != 0 { if stat.Flags&MNT_SOFTDEP != 0 {
opts += ",softdep" opts += ",softdep"
} }
if stat.FFlags&MntNoSymFollow != 0 { if stat.Flags&MNT_NOSYMFOLLOW != 0 {
opts += ",nosymfollow" opts += ",nosymfollow"
} }
if stat.FFlags&MntGEOMJournal != 0 { if stat.Flags&MNT_GJOURNAL != 0 {
opts += ",gjounalc" opts += ",gjounalc"
} }
if stat.FFlags&MntMultilabel != 0 { if stat.Flags&MNT_MULTILABEL != 0 {
opts += ",multilabel" opts += ",multilabel"
} }
if stat.FFlags&MntACLs != 0 { if stat.Flags&MNT_ACLS != 0 {
opts += ",acls" opts += ",acls"
} }
if stat.FFlags&MntNoATime != 0 { if stat.Flags&MNT_NOATIME != 0 {
opts += ",noattime" opts += ",noattime"
} }
if stat.FFlags&MntClusterRead != 0 { if stat.Flags&MNT_NOCLUSTERR != 0 {
opts += ",nocluster" opts += ",nocluster"
} }
if stat.FFlags&MntClusterWrite != 0 { if stat.Flags&MNT_NOCLUSTERW != 0 {
opts += ",noclusterw" opts += ",noclusterw"
} }
if stat.FFlags&MntNFS4ACLs != 0 { if stat.Flags&MNT_NFS4ACLS != 0 {
opts += ",nfs4acls" opts += ",nfs4acls"
} }
d := DiskPartitionStat{ d := DiskPartitionStat{
Device: common.ByteToString(stat.FMntfromname[:]), Device: common.IntToString(stat.Mntfromname[:]),
Mountpoint: common.ByteToString(stat.FMntonname[:]), Mountpoint: common.IntToString(stat.Mntonname[:]),
Fstype: common.ByteToString(stat.FFstypename[:]), Fstype: common.IntToString(stat.Fstypename[:]),
Opts: opts, Opts: opts,
} }
ret = append(ret, d) ret = append(ret, d)
@ -85,35 +94,55 @@ func DiskPartitions(all bool) ([]DiskPartitionStat, error) {
} }
func DiskIOCounters() (map[string]DiskIOCountersStat, error) { func DiskIOCounters() (map[string]DiskIOCountersStat, error) {
return nil, common.NotImplementedError
// statinfo->devinfo->devstat // statinfo->devinfo->devstat
// /usr/include/devinfo.h // /usr/include/devinfo.h
// get length // sysctl.sysctl ('kern.devstat.all', 0)
count, err := Getfsstat(nil, MntWait) ret := make(map[string]DiskIOCountersStat)
mib := []int32{CTLKern, KernDevstat, KernDevstatAll}
buf, length, err := common.CallSyscall(mib)
if err != nil { if err != nil {
return nil, err return nil, err
} }
fs := make([]Statfs, count) ds := Devstat{}
_, err = Getfsstat(fs, MntWait) devstatLen := int(unsafe.Sizeof(ds))
count := int(length / uint64(devstatLen))
ret := make(map[string]DiskIOCountersStat, 0) buf = buf[8:] // devstat.all has version in the head.
for _, stat := range fs { // parse buf to Devstat
name := common.ByteToString(stat.FMntonname[:]) for i := 0; i < count; i++ {
d := DiskIOCountersStat{ b := buf[i*devstatLen : i*devstatLen+devstatLen]
d, err := parseDevstat(b)
if err != nil {
continue
}
un := strconv.Itoa(int(d.Unit_number))
name := common.IntToString(d.Device_name[:]) + un
ds := DiskIOCountersStat{
ReadCount: d.Operations[DEVSTAT_READ],
WriteCount: d.Operations[DEVSTAT_WRITE],
ReadBytes: d.Bytes[DEVSTAT_READ],
WriteBytes: d.Bytes[DEVSTAT_WRITE],
ReadTime: d.Duration[DEVSTAT_READ].Compute(),
WriteTime: d.Duration[DEVSTAT_WRITE].Compute(),
Name: name, Name: name,
ReadCount: stat.FSyncwrites + stat.FAsyncwrites,
WriteCount: stat.FSyncreads + stat.FAsyncreads,
} }
ret[name] = ds
ret[name] = d
} }
return ret, nil return ret, nil
} }
func (b Bintime) Compute() uint64 {
BINTIME_SCALE := 5.42101086242752217003726400434970855712890625e-20
return uint64(b.Sec) + b.Frac*uint64(BINTIME_SCALE)
}
// BT2LD(time) ((long double)(time).sec + (time).frac * BINTIME_SCALE)
// Getfsstat is borrowed from pkg/syscall/syscall_freebsd.go // Getfsstat is borrowed from pkg/syscall/syscall_freebsd.go
// change Statfs_t to Statfs in order to get more information // change Statfs_t to Statfs in order to get more information
func Getfsstat(buf []Statfs, flags int) (n int, err error) { func Getfsstat(buf []Statfs, flags int) (n int, err error) {
@ -130,3 +159,15 @@ func Getfsstat(buf []Statfs, flags int) (n int, err error) {
} }
return return
} }
func parseDevstat(buf []byte) (Devstat, error) {
var ds Devstat
br := bytes.NewReader(buf)
// err := binary.Read(br, binary.LittleEndian, &ds)
err := Read(br, binary.LittleEndian, &ds)
if err != nil {
return ds, err
}
return ds, nil
}

191
disk/disk_freebsd_amd64.go
Unescape Escape View File

@ -1,104 +1,111 @@
// +build freebsd // Created by cgo -godefs - DO NOT EDIT
// +build amd64 // cgo -godefs types_freebsd.go
package disk package disk
const ( const (
MntWait = 1 sizeofPtr = 0x8
MfsNameLen = 16 /* length of type name including null */ sizeofShort = 0x2
MNameLen = 88 /* size of on/from name bufs */ sizeofInt = 0x4
sizeofLong = 0x8
sizeofLongLong = 0x8
sizeofLongDouble = 0x8
DEVSTAT_NO_DATA = 0x00
DEVSTAT_READ = 0x01
DEVSTAT_WRITE = 0x02
DEVSTAT_FREE = 0x03
MNT_RDONLY = 0x00000001
MNT_SYNCHRONOUS = 0x00000002
MNT_NOEXEC = 0x00000004
MNT_NOSUID = 0x00000008
MNT_UNION = 0x00000020
MNT_ASYNC = 0x00000040
MNT_SUIDDIR = 0x00100000
MNT_SOFTDEP = 0x00200000
MNT_NOSYMFOLLOW = 0x00400000
MNT_GJOURNAL = 0x02000000
MNT_MULTILABEL = 0x04000000
MNT_ACLS = 0x08000000
MNT_NOATIME = 0x10000000
MNT_NOCLUSTERR = 0x40000000
MNT_NOCLUSTERW = 0x80000000
MNT_NFS4ACLS = 0x00000010
MNT_WAIT = 1
MNT_NOWAIT = 2
MNT_LAZY = 3
MNT_SUSPEND = 4
) )
// sys/mount.h type (
const ( _C_short int16
MntReadOnly = 0x00000001 /* read only filesystem */ _C_int int32
MntSynchronous = 0x00000002 /* filesystem written synchronously */ _C_long int64
MntNoExec = 0x00000004 /* can't exec from filesystem */ _C_long_long int64
MntNoSuid = 0x00000008 /* don't honor setuid bits on fs */ _C_long_double int64
MntUnion = 0x00000020 /* union with underlying filesystem */
MntAsync = 0x00000040 /* filesystem written asynchronously */
MntSuidDir = 0x00100000 /* special handling of SUID on dirs */
MntSoftDep = 0x00200000 /* soft updates being done */
MntNoSymFollow = 0x00400000 /* do not follow symlinks */
MntGEOMJournal = 0x02000000 /* GEOM journal support enabled */
MntMultilabel = 0x04000000 /* MAC support for individual objects */
MntACLs = 0x08000000 /* ACL support enabled */
MntNoATime = 0x10000000 /* disable update of file access time */
MntClusterRead = 0x40000000 /* disable cluster read */
MntClusterWrite = 0x80000000 /* disable cluster write */
MntNFS4ACLs = 0x00000010
) )
type Statfs struct { type Statfs struct {
FVersion uint32 /* structure version number */ Version uint32
FType uint32 /* type of filesystem */ Type uint32
FFlags uint64 /* copy of mount exported flags */ Flags uint64
FBsize uint64 /* filesystem fragment size */ Bsize uint64
FIosize uint64 /* optimal transfer block size */ Iosize uint64
FBlocks uint64 /* total data blocks in filesystem */ Blocks uint64
FBfree uint64 /* free blocks in filesystem */ Bfree uint64
FBavail int64 /* free blocks avail to non-superuser */ Bavail int64
FFiles uint64 /* total file nodes in filesystem */ Files uint64
FFfree int64 /* free nodes avail to non-superuser */ Ffree int64
FSyncwrites uint64 /* count of sync writes since mount */ Syncwrites uint64
FAsyncwrites uint64 /* count of async writes since mount */ Asyncwrites uint64
FSyncreads uint64 /* count of sync reads since mount */ Syncreads uint64
FAsyncreads uint64 /* count of async reads since mount */ Asyncreads uint64
FSpare [10]uint64 /* unused spare */ Spare [10]uint64
FNamemax uint32 /* maximum filename length */ Namemax uint32
FOwner uint32 /* user that mounted the filesystem */ Owner uint32
FFsid int32 /* filesystem id */ Fsid Fsid
FCharspare [80]byte /* spare string space */ Charspare [80]int8
FFstypename [MfsNameLen]byte /* filesystem type name */ Fstypename [16]int8
FMntfromname [MNameLen]byte /* mounted filesystem */ Mntfromname [88]int8
FMntonname [MNameLen]byte /* directory on which mounted */ Mntonname [88]int8
}
type Fsid struct {
Val [2]int32
} }
// /usr/include/devstat.h type Devstat struct {
// devstat_getdevs() Sequence0 uint32
// kern.devstat.all -> devstats list struct Allocated int32
Start_count uint32
// struct devinfo { End_count uint32
// struct devstat *devices; Busy_from Bintime
// u_int8_t *mem_ptr; Dev_links _Ctype_struct___0
// long generation; Device_number uint32
// int numdevs; Device_name [16]int8
// }; Unit_number int32
// Bytes [4]uint64
// struct statinfo { Operations [4]uint64
// long cp_time[CPUSTATES]; Duration [4]Bintime
// long tk_nin; Busy_time Bintime
// long tk_nout; Creation_time Bintime
// struct devinfo *dinfo; Block_size uint32
// long double snap_time; Pad_cgo_0 [4]byte
// }; Tag_types [3]uint64
Flags uint32
// /usr/include/devinfo.h Device_type uint32
Priority uint32
Pad_cgo_1 [4]byte
Id *byte
Sequence1 uint32
Pad_cgo_2 [4]byte
}
type Bintime struct {
Sec int64
Frac uint64
}
// struct devinfo_dev { type _Ctype_struct___0 struct {
// devinfo_handle_t dd_handle; /* device handle */ Empty uint64
// devinfo_handle_t dd_parent; /* parent handle */ }
// char *dd_name; /* name of device */
// char *dd_desc; /* device description */
// char *dd_drivername; /* name of attached driver */
// char *dd_pnpinfo; /* pnp info from parent bus */
// char *dd_location; /* Where bus thinks dev at */
// uint32_t dd_devflags; /* API flags */
// uint16_t dd_flags; /* internal dev flags */
// device_state_t dd_state; /* attachment state of dev */
// };
//
// struct devinfo_rman {
// devinfo_handle_t dm_handle; /* resource manager handle */
// u_long dm_start; /* resource start */
// u_long dm_size; /* resource size */
// char *dm_desc; /* resource description */
// };
//
// struct devinfo_res {
// devinfo_handle_t dr_handle; /* resource handle */
// devinfo_handle_t dr_rman; /* resource manager handle */
// devinfo_handle_t dr_device; /* owning device */
// u_long dr_start; /* region start */
// u_long dr_size; /* region size */
// };

6
disk/disk_test.go
Unescape Escape View File

@ -35,11 +35,15 @@ func TestDisk_partitions(t *testing.T) {
func TestDisk_io_counters(t *testing.T) { func TestDisk_io_counters(t *testing.T) {
ret, err := DiskIOCounters() ret, err := DiskIOCounters()
if err != nil || len(ret) == 0 { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
if len(ret) == 0 {
t.Errorf("ret is empty", ret)
}
empty := DiskIOCountersStat{} empty := DiskIOCountersStat{}
for part, io := range ret { for part, io := range ret {
fmt.Println(io)
if io == empty { if io == empty {
t.Errorf("io_counter error %v, %v", part, io) t.Errorf("io_counter error %v, %v", part, io)
} }

Write Preview
Loading…
Cancel
Save