type gid[permalink] [source]

type gid = rt::gid_t;

Group ID.

type limit[permalink] [source]

type limit = rt::rlim_t;

A resource limit.

type pid[permalink] [source]

type pid = rt::pid_t;

Process ID.

type pipe_flag[permalink] [source]

type pipe_flag = enum {
	NOCLOEXEC = rt::O_CLOEXEC,
	DIRECT = rt::O_DIRECT,
	NONBLOCK = rt::O_NONBLOCK,
};

Flags to use for the io::files returned by pipe. Only NOCLOEXEC and NONBLOCK are guaranteed to be available.

type resource[permalink] [source]

type resource = enum {
	CPU = rt::RLIMIT_CPU, // Maximum CPU time (seconds)
	FSIZE = rt::RLIMIT_FSIZE, // Maximum size of files (bytes)
	DATA = rt::RLIMIT_DATA, // Maximum size of data segment (bytes)
	STACK = rt::RLIMIT_STACK, // Maximum size of stack(s) (bytes)
	CORE = rt::RLIMIT_CORE, // Maximum size of a core dump (bytes)
	NOFILE = rt::RLIMIT_NOFILE, // Maximum number of open files
	AS = rt::RLIMIT_AS, // Maximum address space size (bytes)
	NPROC = rt::RLIMIT_NPROC, // Total processes per user ID (Linux)
	RSS = rt::RLIMIT_RSS, // Maximum size of resident set (bytes, Linux)
	MEMLOCK = rt::RLIMIT_MEMLOCK, // Maximum amount of data "locked" in RAM (bytes, Linux)
	LOCKS = rt::RLIMIT_LOCKS, // Maximum flock locks and fcntl leases (Linux, removed in 2.4.24)
	SIGPENDING = rt::RLIMIT_SIGPENDING, // Maximum queued signals per user ID (Linux)
	MSGQUEUE = rt::RLIMIT_MSGQUEUE, // Maximum size of POSIX message queues per user ID (Linux)
	NICE = rt::RLIMIT_NICE, // Maximum "niceness" of process (Linux, see getrlimit(2))
	RTPRIO = rt::RLIMIT_RTPRIO, // Maximum real-time priority of process (Linux, see getrlimit(2))
	RTTIME = rt::RLIMIT_RTTIME, // Maximum real-time CPU time (microseconds, Linux)
};

Resources with limited or limitable usage constraints.

type rlimit[permalink] [source]

type rlimit = struct {
	soft: limit,
	hard: limit,
};

Soft and hard limits for a resource.

type uid[permalink] [source]

type uid = rt::uid_t;

User ID.

def INFINITY[permalink] [source]

def INFINITY: limit = rt::RLIM_INFINITY;

A limit representing an unlimited value.

fn getegid[permalink] [source]

fn getegid() gid;

Returns the current process effective group ID.

fn geteuid[permalink] [source]

fn geteuid() uid;

Returns the current process effective user ID.

fn getgid[permalink] [source]

fn getgid() gid;

Returns the current process group ID.

fn getgroups[permalink] [source]

fn getgroups() []gid;

Returns a list of supplementary group IDs for the current process. The returned slice is statically allocated.

fn getpgid[permalink] [source]

fn getpgid(pid: pid) (pid | errors::noentry);

Returns the process group associated with the given pid.

fn getpgrp[permalink] [source]

fn getpgrp() pid;

Returns the current process group ID.

fn getpid[permalink] [source]

fn getpid() pid;

Returns the current process ID.

fn getppid[permalink] [source]

fn getppid() pid;

Returns the parent process ID.

fn getpsid[permalink] [source]

fn getpsid(pid: pid) (pid | errors::noentry | errors::noaccess);

Returns the session ID associated with the given process.

fn getrlimit[permalink] [source]

fn getrlimit(res: resource) rlimit;

Returns the current limits for a resource.

fn getsid[permalink] [source]

fn getsid() pid;

Returns the current process's session ID.

fn getuid[permalink] [source]

fn getuid() uid;

Returns the current process user ID.

fn nice[permalink] [source]

fn nice(inc: int) (void | errors::error);

Adds the argument to the niceness of the current process. The input should be between -20 and 19 (inclusive); lower numbers represent a higher priority. Generally, you must have elevated permissions to reduce your niceness, but not to increase it.

fn pipe[permalink] [source]

fn pipe(flags: pipe_flag = 0) ((io::file, io::file) | errors::error);

Create a pair of two linked io::files, such that any data written to the second io::file may be read from the first.

fn setegid[permalink] [source]

fn setegid(gid: gid) void;

Sets the caller's effective group ID to the specified value. This generally requires elevated permissions from the calling process.

If the system returns an error, this function will abort the program. Failing to handle errors from setegid is a grave security issue in your program, and therefore we require this function to succeed. If you need to handle the error case gracefully, call the appropriate syscall wrapper in rt:: yourself, and take extreme care to handle errors correctly.

fn seteuid[permalink] [source]

fn seteuid(uid: uid) void;

Sets the caller's effective user ID to the specified value. This generally requires elevated permissions from the calling process.

If the system returns an error, this function will abort the program. Failing to handle errors from seteuid is a grave security issue in your program, and therefore we require this function to succeed. If you need to handle the error case gracefully, call the appropriate syscall wrapper in rt:: yourself, and take extreme care to handle errors correctly.

fn setgid[permalink] [source]

fn setgid(gid: gid) void;

Sets the caller's group ID to the specified value. This generally requires elevated permissions from the calling process.

If the system returns an error, this function will abort the program. Failing to handle errors from setuid is a grave security issue in your program, and therefore we require this function to succeed. If you need to handle the error case gracefully, call the appropriate syscall wrapper in rt:: yourself, and take extreme care to handle errors correctly.

fn setgroups[permalink] [source]

fn setgroups(gids: []gid) void;

Sets the list of supplementary group IDs which apply to the current process. This generally requires elevated permissions.

If the system returns an error, this function will abort the program. Failing to handle errors from setgroups is a grave security issue in your program, and therefore we require this function to succeed. If you need to handle the error case gracefully, call the appropriate syscall wrapper in rt:: yourself, and take extreme care to handle errors correctly.

fn setpgid[permalink] [source]

fn setpgid(targ: pid, pgid: pid) (void | errors::error);

Sets the process group ID of the specified process. This function is error-prone; see the notes in the POSIX specification for its many caveats.

fn setrlimit[permalink] [source]

fn setrlimit(res: resource, limit: *rlimit) (void | errors::error);

Modifies a resource limit.

fn setsid[permalink] [source]

fn setsid() void;

Creates a new session and sets the current process to the session leader. A new process group is also created with its process group ID equal to the pid of the current process, and the current process is made the process group leader.

Upon return, the new session will have no controlling terminal. To establish one, the caller must open a terminal file with fs::flag::CTTY; this opt-in approach differs from the Unix norm where O_NOCTTY is required to opt-out of establishing a controlling terminal.

The current process cannot be a process group leader; this is a programmer error and will cause a runtime assertion failure.

fn setuid[permalink] [source]

fn setuid(uid: uid) void;

Sets the caller's user ID to the specified value. This generally requires elevated permissions from the calling process.

If the system returns an error, this function will abort the program. Failing to handle errors from setuid is a grave security issue in your program, and therefore we require this function to succeed. If you need to handle the error case gracefully, call the appropriate syscall wrapper in rt:: yourself, and take extreme care to handle errors correctly.

fn umask[permalink] [source]

fn umask(mode: fs::mode) fs::mode;

Sets the file mode creation mask for the current process and return the previous value of the mask.