Module Procfs

module Procfs: Procfs

Process and system stats

type bigint = Core.Std.Big_int.big_int

module Process: sig .. end

module Meminfo: sig .. end

module Kstat: sig .. end

module Loadavg: sig .. end

val get_all_procs : unit -> Process.t list

get_all_procs returns a list of all processes on the system

val with_pid_exn : Core.Std.Pid.t -> Process.t

with_pid_exn pid returns a single process that matches pid, or raises Not_found

val with_pid : Core.Std.Pid.t -> Process.t option

with_pid pid returns a single process that matches pid

val with_uid : int -> Process.t list

with_uid uid returns all processes owned by uid

val pgrep : (Process.t -> bool) -> Process.t list

pgrep f returns all processes for which f is true

val pkill : signal:Core.Std.Signal.t ->
       (Process.t -> bool) ->
       (Core.Std.Pid.t * (unit, Core.Unix.error) Core.Result.t) list

pkill ~signal f sends the signal to all processes for which f returns true. It returns the list of processes that were signaled, and the resulting errors if any.

val with_username_exn : string -> Process.t list

with_username_exn user calls with_uid after looking up the user's uid

val with_username : string -> Process.t list option

with_username user calls with_uid after looking up the user's uid

val jiffies_per_second_exn : unit -> float

jiffies_per_second_exn. A jiffy "is one tick of the system timer interrupt. It is not an absolute time interval unit, since its duration depends on the clock interrupt frequency of the particular hardware platform."

Further reading: https://secure.wikimedia.org/wikipedia/en/wiki/Jiffy_(time)

val jiffies_per_second : unit -> float option

val meminfo_exn : unit -> Meminfo.t

meminfo_exn queries /proc/meminfo and fills out Meminfo.t. All values in bytes.

val meminfo : unit -> Meminfo.t option

val loadavg_exn : unit -> Loadavg.t

loadavg_exn parses /proc/loadavg.

val loadavg : unit -> Loadavg.t option

module Net: sig .. end

module Mount: sig .. end

val mounts : unit -> Mount.t list

val mounts_of_fstab : unit -> Mount.t list

val supported_filesystems : unit -> string list

val uptime : unit -> Core.Time.Span.t

val process_age : Process.t -> Core.Time.Span.t option

val process_age' : jiffies_per_second:float -> Process.t -> Core.Time.Span.t

val bigint_of_sexp : Sexplib.Sexp.t -> bigint

val sexp_of_bigint : bigint -> Sexplib.Sexp.t

The filename of the executable

One character from the string "RSDZTW"

The PID of the parent.

The process group ID of the process.

The session ID of the process.

The tty the process uses.

The process group ID of the process which currently owns the tty...

The kernel flags word of the process.

The number of minor faults the process has made which have not required loading a memory page from disk.

The number of minor faults that the process’s waited-for children have made.

The number of major faults the process has made which have required loading a page from disk.

The number of major faults that the process’s waited-for children have made.

The number of jiffies that this process has been scheduled in user mode.

The number of jiffies that this process has been scheduled in kernel mode.

The number of jiffies that this process’s waited-for children have been scheduled in user mode.

The number of jiffies that this process’s waited-for children have been scheduled in kernel mode.

The standard nice value, plus fifteen. The value is never negative in the kernel.

The nice value ranges from 19 to -19

placeholder for removed field

The time in jiffies before the next SIGALRM is sent to the process due to an interval timer.

The time in jiffies the process started after system boot.

Virtual memory size in bytes.

Resident Set Size: number of pages the process has in real memory.

Current limit in bytes on the rss of the process.

The address above which program text can run.

The address below which program text can run.

The address of the start of the stack.

The current value of esp (stack pointer)

The current value of eip (instruction pointer)

The bitmap of pending signals.

The bitmap of blocked signals.

The bitmap of ignored signals.

The bitmap of caught signals.

This is the "channel" in which the process is waiting. Address of a system call.

(no longer maintained)

(no longer maintained)

Signal sent to parent when we die.

CPU number last executed on.

Real-time scheduling priority.

Scheduling policy

total program size

resident set size

shared pages

text (code)

library

data/stack

dirty pages (unused)

Real user ID

Effective user ID

Saved user ID

FS user ID

Real group ID

Effective group ID

Saved group ID

FS group ID

File descriptor (0=stdin, 1=stdout, etc.)

Kind of file

Process ID

Command-line (not reliable).

Symlink to working directory.

Process environment.

Symlink to executed command.

Per-process root (e.g. chroot)

Per-process rlimit settings

Status information.

Memory status information.

Some more assorted status information.

Status information for each task (thread)

Show what top would show for COMMAND

File descriptors

OOM killer niceness range: -17 to +15

OOM "sacrifice" priority

t corresponds to the values in /proc/meminfo. All values in bytes.

t corresponds to the values in /proc/loadavg.

get_all_procs returns a list of all processes on the system

with_pid_exn pid returns a single process that matches pid, or raises Not_found

with_pid pid returns a single process that matches pid

with_uid uid returns all processes owned by uid

pgrep f returns all processes for which f is true

pkill ~signal f sends the signal to all processes for which f returns true. It returns the list of processes that were signaled, and the resulting errors if any.

with_username_exn user calls with_uid after looking up the user's uid

with_username user calls with_uid after looking up the user's uid

jiffies_per_second_exn. A jiffy "is one tick of the system timer interrupt. It is not an absolute time interval unit, since its duration depends on the clock interrupt frequency of the particular hardware platform."

Further reading: https://secure.wikimedia.org/wikipedia/en/wiki/Jiffy_(time)

meminfo_exn queries /proc/meminfo and fills out Meminfo.t. All values in bytes.

loadavg_exn parses /proc/loadavg.

/proc/net/tcp, or what netstat or lsof -i parses.

These don't do any IO and should be async-ok

This does IO and is not async-ok.