Module Core_extended__Procfs.Process.Stat

type t = {
comm : string;

(** The filename of the executable *)

state : char;

(** One character from the string "RSDZTW" *)

ppid : Core.Pid.t option;

(** The PID of the parent. *)

pgrp : Core.Pid.t option;

(** The process group ID of the process. *)

session : int;

(** The session ID of the process. *)

tty_nr : int;

(** The tty the process uses. *)

tpgid : int;

(** The process group ID of the process which currently owns the tty... *)

flags : bigint;

(** The kernel flags word of the process. *)

minflt : bigint;

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

cminflt : bigint;

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

majflt : bigint;

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

cmajflt : bigint;

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

utime : bigint;

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

stime : bigint;

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

cutime : bigint;

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

cstime : bigint;

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

priority : bigint;

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

nice : bigint;

(** The nice value ranges from 19 to -19 *)

unused : bigint;

(** placeholder for removed field *)

itrealvalue : bigint;

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

starttime : bigint;

(** The time in jiffies the process started after system boot. *)

vsize : bigint;

(** Virtual memory size in bytes. *)

rss : bigint;

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

rlim : bigint;

(** Current limit in bytes on the rss of the process. *)

startcode : bigint;

(** The address above which program text can run. *)

endcode : bigint;

(** The address below which program text can run. *)

startstack : bigint;

(** The address of the start of the stack. *)

kstkesp : bigint;

(** The current value of esp (stack pointer) *)

kstkeip : bigint;

(** The current value of eip (instruction pointer) *)

signal : bigint;

(** The bitmap of pending signals. *)

blocked : bigint;

(** The bitmap of blocked signals. *)

sigignore : bigint;

(** The bitmap of ignored signals. *)

sigcatch : bigint;

(** The bitmap of caught signals. *)

wchan : bigint;

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

nswap : bigint;

(** (no longer maintained) *)

cnswap : bigint;

(** (no longer maintained) *)

exit_signal : int;

(** Signal sent to parent when we die. *)

processor : int;

(** CPU number last executed on. *)

rt_priority : bigint;

(** Real-time scheduling priority. *)

policy : bigint;

(** Scheduling policy *)

}
include sig ... end
val policy : t ‑> bigint
val rt_priority : t ‑> bigint
val processor : t ‑> int
val exit_signal : t ‑> int
val cnswap : t ‑> bigint
val nswap : t ‑> bigint
val wchan : t ‑> bigint
val sigcatch : t ‑> bigint
val sigignore : t ‑> bigint
val blocked : t ‑> bigint
val signal : t ‑> bigint
val kstkeip : t ‑> bigint
val kstkesp : t ‑> bigint
val startstack : t ‑> bigint
val endcode : t ‑> bigint
val startcode : t ‑> bigint
val rlim : t ‑> bigint
val rss : t ‑> bigint
val vsize : t ‑> bigint
val starttime : t ‑> bigint
val itrealvalue : t ‑> bigint
val unused : t ‑> bigint
val nice : t ‑> bigint
val priority : t ‑> bigint
val cstime : t ‑> bigint
val cutime : t ‑> bigint
val stime : t ‑> bigint
val utime : t ‑> bigint
val cmajflt : t ‑> bigint
val majflt : t ‑> bigint
val cminflt : t ‑> bigint
val minflt : t ‑> bigint
val flags : t ‑> bigint
val tpgid : t ‑> int
val tty_nr : t ‑> int
val session : t ‑> int
val pgrp : t ‑> Core.Pid.t option
val ppid : t ‑> Core.Pid.t option
val state : t ‑> char
val comm : t ‑> string
module Fields : sig ... end
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
val extract_command : string ‑> [ `command of string ] * [ `rest of string ]
val of_string : string ‑> t