Module: Process
- Defined in:
- process.c
Defined Under Namespace
Modules: GID, Sys, UID Classes: Status
Constant Summary collapse
- WNOHANG =
INT2FIX(0)
- WUNTRACED =
INT2FIX(0)
- PRIO_PROCESS =
INT2FIX(PRIO_PROCESS)
- PRIO_PGRP =
INT2FIX(PRIO_PGRP)
- PRIO_USER =
INT2FIX(PRIO_USER)
- RLIM_INFINITY =
RLIM2NUM(RLIM_INFINITY)
- RLIM_SAVED_MAX =
RLIM2NUM(RLIM_SAVED_MAX)
- RLIM_SAVED_CUR =
RLIM2NUM(RLIM_SAVED_CUR)
- RLIMIT_CORE =
INT2FIX(RLIMIT_CORE)
- RLIMIT_CPU =
INT2FIX(RLIMIT_CPU)
- RLIMIT_DATA =
INT2FIX(RLIMIT_DATA)
- RLIMIT_FSIZE =
INT2FIX(RLIMIT_FSIZE)
- RLIMIT_NOFILE =
INT2FIX(RLIMIT_NOFILE)
- RLIMIT_STACK =
INT2FIX(RLIMIT_STACK)
- RLIMIT_AS =
INT2FIX(RLIMIT_AS)
- RLIMIT_MEMLOCK =
INT2FIX(RLIMIT_MEMLOCK)
- RLIMIT_NPROC =
INT2FIX(RLIMIT_NPROC)
- RLIMIT_RSS =
INT2FIX(RLIMIT_RSS)
- RLIMIT_SBSIZE =
INT2FIX(RLIMIT_SBSIZE)
Class Method Summary collapse
-
.abort ⇒ Object
Terminate execution immediately, effectively by calling
Kernel.exit(1)
. -
.detach(pid) ⇒ Object
Some operating systems retain the status of terminated child processes until the parent collects that status (normally using some variant of
wait()
. If the parent never collects this status, the child stays around as a zombie process.Process::detach
prevents this by setting up a separate Ruby thread whose sole job is to reap the status of the process pid when it terminates. Usedetach
only when you do not intent to explicitly wait for the child to terminate.detach
only checks the status periodically (currently once each second). -
.egid ⇒ Object
Returns the effective group ID for this process.
-
.egid=(fixnum) ⇒ Fixnum
Sets the effective group ID for this process.
-
.euid ⇒ Object
Returns the effective user ID for this process.
-
.euid=(integer) ⇒ Object
Sets the effective user ID for this process.
-
.exit ⇒ Object
Initiates the termination of the Ruby script by raising the
SystemExit
exception. -
.exit!(fixnum = -1) ⇒ Object
Exits the process immediately.
-
.fork ⇒ Object
Creates a subprocess.
-
.getpgid(pid) ⇒ Integer
Returns the process group ID for the given process id.
- .getpgrp ⇒ Object
-
.getpriority(kind, integer) ⇒ Fixnum
Gets the scheduling priority for specified process, process group, or user.
-
.getrlimit(resource) ⇒ Array
Gets the resource limit of the process.
-
.gid ⇒ Object
Returns the (real) group ID for this process.
-
.gid=(fixnum) ⇒ Fixnum
Sets the group ID for this process.
-
.groups ⇒ Array
Get an
Array
of the gids of groups in the supplemental group access list for this process. -
.groups=(array) ⇒ Array
Set the supplemental group access list to the given
Array
of group IDs. -
.initgroups(username, gid) ⇒ Array
Initializes the supplemental group access list by reading the system group database and using all groups of which the given user is a member.
-
.kill(signal, pid, ...) ⇒ Fixnum
Sends the given signal to the specified process id(s), or to the current process if pid is zero.
-
.maxgroups ⇒ Fixnum
Returns the maximum number of gids allowed in the supplemental group access list.
-
.maxgroups=(fixnum) ⇒ Fixnum
Sets the maximum number of gids allowed in the supplemental group access list.
-
.pid ⇒ Fixnum
Returns the process id of this process.
-
.ppid ⇒ Fixnum
Returns the process id of the parent of this process.
-
.setpgid(pid, integer) ⇒ 0
Sets the process group ID of pid (0 indicates this process) to integer.
-
.setpgrp ⇒ 0
Equivalent to
setpgid(0,0)
. -
.setpriority(kind, integer, priority) ⇒ 0
See
Process#getpriority
. -
.setrlimit ⇒ Object
Sets the resource limit of the process.
-
.setsid ⇒ Fixnum
Establishes this process as a new session and process group leader, with no controlling tty.
-
.times ⇒ aStructTms
Returns a
Tms
structure (seeStruct::Tms
on page 388) that contains user and system CPU times for this process. -
.uid ⇒ Object
Returns the (real) user ID of this process.
-
.uid=(integer) ⇒ Numeric
Sets the (integer) user ID for this process.
-
.wait ⇒ Object
Waits for a child process to exit, returns its process id, and sets
$?
to aProcess::Status
object containing information on that process. -
.wait2 ⇒ Object
Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a
Process::Status
object) of that child. -
.waitall ⇒ Array
Waits for all children, returning an array of pid/status pairs (where status is a
Process::Status
object). -
.waitpid ⇒ Object
Waits for a child process to exit, returns its process id, and sets
$?
to aProcess::Status
object containing information on that process. -
.waitpid2 ⇒ Object
Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a
Process::Status
object) of that child.
Class Method Details
.abort ⇒ Object .Kernel::abort ⇒ Object .Process::abort ⇒ Object
Terminate execution immediately, effectively by calling Kernel.exit(1)
. If msg is given, it is written to STDERR prior to terminating.
|
# File 'process.c'
VALUE
rb_f_abort(argc, argv)
int argc;
VALUE *argv;
{
rb_secure(4);
if (argc == 0) {
if (!NIL_P(ruby_errinfo)) {
error_print();
}
|
.detach(pid) ⇒ Object
Some operating systems retain the status of terminated child processes until the parent collects that status (normally using some variant of wait()
. If the parent never collects this status, the child stays around as a zombie process. Process::detach
prevents this by setting up a separate Ruby thread whose sole job is to reap the status of the process pid when it terminates. Use detach
only when you do not intent to explicitly wait for the child to terminate. detach
only checks the status periodically (currently once each second).
The waiting thread returns the exit status of the detached process when it terminates, so you can use Thread#join
to know the result. If specified pid is not a valid child process ID, the thread returns nil
immediately.
In this first example, we don't reap the first child process, so it appears as a zombie in the process status display.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
produces:
27389 Z
In the next example, Process::detach
is used to reap the child automatically.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
(produces no output)
|
# File 'process.c'
static VALUE
proc_detach(VALUE obj, VALUE pid)
{
rb_secure(2);
return rb_detach_process(NUM2INT(pid));
}
|
.egid ⇒ Fixnum .Process::GID.eid ⇒ Fixnum .Process::Sys.geteid ⇒ Fixnum
Returns the effective group ID for this process. Not available on all platforms.
Process.egid #=> 500
|
# File 'process.c'
static VALUE
proc_getegid(obj)
VALUE obj;
{
int egid = getegid();
return INT2FIX(egid);
}
|
.egid=(fixnum) ⇒ Fixnum
Sets the effective group ID for this process. Not available on all platforms.
|
# File 'process.c'
static VALUE
proc_setegid(obj, egid)
VALUE obj, egid;
{
check_gid_switch();
#if defined(HAVE_SETRESGID) && !defined(__CHECKER__)
if (setresgid(-1, NUM2INT(egid), -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREGID
if (setregid(-1, NUM2INT(egid)) < 0) rb_sys_fail(0);
#elif defined HAVE_SETEGID
if (setegid(NUM2INT(egid)) < 0) rb_sys_fail(0);
#elif defined HAVE_SETGID
egid = NUM2INT(egid);
if (egid == getgid()) {
if (setgid(egid) < 0) rb_sys_fail(0);
}
|
.euid ⇒ Fixnum .Process::UID.eid ⇒ Fixnum .Process::Sys.geteuid ⇒ Fixnum
Returns the effective user ID for this process.
Process.euid #=> 501
|
# File 'process.c'
static VALUE
proc_geteuid(obj)
VALUE obj;
{
int euid = geteuid();
return INT2FIX(euid);
}
|
.euid=(integer) ⇒ Object
Sets the effective user ID for this process. Not available on all platforms.
|
# File 'process.c'
static VALUE
proc_seteuid(obj, euid)
VALUE obj, euid;
{
check_uid_switch();
#if defined(HAVE_SETRESUID) && !defined(__CHECKER__)
if (setresuid(-1, NUM2INT(euid), -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREUID
if (setreuid(-1, NUM2INT(euid)) < 0) rb_sys_fail(0);
#elif defined HAVE_SETEUID
if (seteuid(NUM2INT(euid)) < 0) rb_sys_fail(0);
#elif defined HAVE_SETUID
euid = NUM2INT(euid);
if (euid == getuid()) {
if (setuid(euid) < 0) rb_sys_fail(0);
}
|
.exit(integer = 0) ⇒ Object .Kernel::exit(integer = 0) ⇒ Object .Process::exit(integer = 0) ⇒ Object
Initiates the termination of the Ruby script by raising the SystemExit
exception. This exception may be caught. The optional parameter is used to return a status code to the invoking environment.
begin
exit
puts "never get here"
rescue SystemExit
puts "rescued a SystemExit exception"
end
puts "after begin block"
produces:
rescued a SystemExit exception
after begin block
Just prior to termination, Ruby executes any at_exit
functions (see Kernel::at_exit) and runs any object finalizers (see ObjectSpace::define_finalizer).
at_exit { puts "at_exit function" }
ObjectSpace.define_finalizer("string", proc { puts "in finalizer" })
exit
produces:
at_exit function
in finalizer
|
# File 'process.c'
VALUE
rb_f_exit(argc, argv)
int argc;
VALUE *argv;
{
VALUE status;
int istatus;
rb_secure(4);
if (rb_scan_args(argc, argv, "01", &status) == 1) {
switch (status) {
case Qtrue:
istatus = EXIT_SUCCESS;
break;
case Qfalse:
istatus = EXIT_FAILURE;
break;
default:
istatus = NUM2INT(status);
#if EXIT_SUCCESS != 0
if (istatus == 0) istatus = EXIT_SUCCESS;
#endif
break;
}
|
.exit!(fixnum = -1) ⇒ Object
Exits the process immediately. No exit handlers are run. fixnum is returned to the underlying system as the exit status.
Process.exit!(0)
|
# File 'process.c'
static VALUE
rb_f_exit_bang(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE status;
int istatus;
rb_secure(4);
if (rb_scan_args(argc, argv, "01", &status) == 1) {
switch (status) {
case Qtrue:
istatus = EXIT_SUCCESS;
break;
case Qfalse:
istatus = EXIT_FAILURE;
break;
default:
istatus = NUM2INT(status);
break;
}
|
.fork { ... } ⇒ Fixnum? .fork { ... } ⇒ Fixnum?
Creates a subprocess. If a block is specified, that block is run in the subprocess, and the subprocess terminates with a status of zero. Otherwise, the fork
call returns twice, once in the parent, returning the process ID of the child, and once in the child, returning nil. The child process can exit using Kernel.exit!
to avoid running any at_exit
functions. The parent process should use Process.wait
to collect the termination statuses of its children or use Process.detach
to register disinterest in their status; otherwise, the operating system may accumulate zombie processes.
The thread calling fork is the only thread in the created child process. fork doesn't copy other threads.
|
# File 'process.c'
static VALUE
rb_f_fork(obj)
VALUE obj;
{
#if !defined(__human68k__) && !defined(_WIN32) && !defined(__MACOS__) && !defined(__EMX__) && !defined(__VMS)
int pid;
rb_secure(2);
#ifndef __VMS
fflush(stdout);
fflush(stderr);
#endif
switch (pid = fork()) {
case 0:
#ifdef linux
after_exec();
#endif
rb_thread_atfork();
if (rb_block_given_p()) {
int status;
rb_protect(rb_yield, Qundef, &status);
ruby_stop(status);
}
|
.getpgid(pid) ⇒ Integer
Returns the process group ID for the given process id. Not available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527
|
# File 'process.c'
static VALUE
proc_getpgid(obj, pid)
VALUE obj, pid;
{
#if defined(HAVE_GETPGID) && !defined(__CHECKER__)
int i;
rb_secure(2);
i = getpgid(NUM2INT(pid));
if (i < 0) rb_sys_fail(0);
return INT2NUM(i);
#else
rb_notimplement();
#endif
}
|
.getpgrp ⇒ Object
.getpriority(kind, integer) ⇒ Fixnum
Gets the scheduling priority for specified process, process group, or user. kind indicates the kind of entity to find: one of Process::PRIO_PGRP
, Process::PRIO_USER
, or Process::PRIO_PROCESS
. integer is an id indicating the particular process, process group, or user (an id of 0 means current). Lower priorities are more favorable for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
|
# File 'process.c'
static VALUE
proc_getpriority(obj, which, who)
VALUE obj, which, who;
{
#ifdef HAVE_GETPRIORITY
int prio, iwhich, iwho;
rb_secure(2);
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
errno = 0;
prio = getpriority(iwhich, iwho);
if (errno) rb_sys_fail(0);
return INT2FIX(prio);
#else
rb_notimplement();
#endif
}
|
.getrlimit(resource) ⇒ Array
Gets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit.
resource indicates the kind of resource to limit: such as Process::RLIMIT_CORE
, Process::RLIMIT_CPU
, etc. See Process.setrlimit for details.
cur_limit and max_limit may be Process::RLIM_INFINITY
, Process::RLIM_SAVED_MAX
or Process::RLIM_SAVED_CUR
. See Process.setrlimit and the system getrlimit(2) manual for details.
|
# File 'process.c'
static VALUE
proc_getrlimit(VALUE obj, VALUE resource)
{
#if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM)
struct rlimit rlim;
rb_secure(2);
if (getrlimit(NUM2INT(resource), &rlim) < 0) {
rb_sys_fail("getrlimit");
}
|
.gid ⇒ Fixnum .Process::GID.rid ⇒ Fixnum .Process::Sys.getgid ⇒ Fixnum
Returns the (real) group ID for this process.
Process.gid #=> 500
|
# File 'process.c'
static VALUE
proc_getgid(obj)
VALUE obj;
{
int gid = getgid();
return INT2FIX(gid);
}
|
.gid=(fixnum) ⇒ Fixnum
Sets the group ID for this process.
|
# File 'process.c'
static VALUE
proc_setgid(obj, id)
VALUE obj, id;
{
int gid = NUM2INT(id);
check_gid_switch();
#if defined(HAVE_SETRESGID) && !defined(__CHECKER__)
if (setresgid(gid, -1, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREGID
if (setregid(gid, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETRGID
if (setrgid(gid) < 0) rb_sys_fail(0);
#elif defined HAVE_SETGID
{
if (getegid() == gid) {
if (setgid(gid) < 0) rb_sys_fail(0);
}
|
.groups ⇒ Array
Get an Array
of the gids of groups in the supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
|
# File 'process.c'
static VALUE
proc_getgroups(VALUE obj)
{
#ifdef HAVE_GETGROUPS
VALUE ary;
size_t ngroups;
rb_gid_t *groups;
int i;
groups = ALLOCA_N(rb_gid_t, maxgroups);
ngroups = getgroups(maxgroups, groups);
if (ngroups == -1)
rb_sys_fail(0);
ary = rb_ary_new();
for (i = 0; i < ngroups; i++)
rb_ary_push(ary, INT2NUM(groups[i]));
return ary;
#else
rb_notimplement();
return Qnil;
#endif
}
|
.groups=(array) ⇒ Array
Set the supplemental group access list to the given Array
of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11]
Process.groups #=> [27, 6, 10, 11]
|
# File 'process.c'
static VALUE
proc_setgroups(VALUE obj, VALUE ary)
{
#ifdef HAVE_SETGROUPS
size_t ngroups;
rb_gid_t *groups;
int i;
struct group *gr;
Check_Type(ary, T_ARRAY);
ngroups = RARRAY(ary)->len;
if (ngroups > maxgroups)
rb_raise(rb_eArgError, "too many groups, %d max", maxgroups);
groups = ALLOCA_N(rb_gid_t, ngroups);
for (i = 0; i < ngroups && i < RARRAY(ary)->len; i++) {
VALUE g = RARRAY(ary)->ptr[i];
if (FIXNUM_P(g)) {
groups[i] = FIX2INT(g);
}
|
.initgroups(username, gid) ⇒ Array
Initializes the supplemental group access list by reading the system group database and using all groups of which the given user is a member. The group with the specified gid is also added to the list. Returns the resulting Array
of the gids of all the groups in the supplementary group access list. Not available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11]
Process.groups #=> [30, 6, 10, 11]
|
# File 'process.c'
static VALUE
proc_initgroups(obj, uname, base_grp)
VALUE obj, uname, base_grp;
{
#ifdef HAVE_INITGROUPS
if (initgroups(StringValuePtr(uname), (rb_gid_t)NUM2INT(base_grp)) != 0) {
rb_sys_fail(0);
}
|
.kill(signal, pid, ...) ⇒ Fixnum
Sends the given signal to the specified process id(s), or to the current process if pid is zero. signal may be an integer signal number or a POSIX signal name (either with or without a SIG
prefix). If signal is negative (or starts with a minus sign), kills process groups instead of processes. Not all signals are available on all platforms.
pid = fork do
Signal.trap("HUP") { puts "Ouch!"; exit }
# ... do some work ...
end
# ...
Process.kill("HUP", pid)
Process.wait
produces:
Ouch!
|
# File 'process.c'
VALUE
rb_f_kill(argc, argv)
int argc;
VALUE *argv;
{
int negative = 0;
int sig;
int i;
char *s;
rb_secure(2);
if (argc < 2)
rb_raise(rb_eArgError, "wrong number of arguments -- kill(sig, pid...)");
switch (TYPE(argv[0])) {
case T_FIXNUM:
sig = FIX2INT(argv[0]);
break;
case T_SYMBOL:
s = rb_id2name(SYM2ID(argv[0]));
if (!s) rb_raise(rb_eArgError, "bad signal");
goto str_signal;
case T_STRING:
s = RSTRING(argv[0])->ptr;
if (s[0] == '-') {
negative++;
s++;
}
|
.maxgroups ⇒ Fixnum
Returns the maximum number of gids allowed in the supplemental group access list.
Process.maxgroups #=> 32
|
# File 'process.c'
static VALUE
proc_getmaxgroups(obj)
VALUE obj;
{
return INT2FIX(maxgroups);
}
|
.maxgroups=(fixnum) ⇒ Fixnum
Sets the maximum number of gids allowed in the supplemental group access list.
|
# File 'process.c'
static VALUE
proc_setmaxgroups(VALUE obj, VALUE val)
{
size_t ngroups = FIX2INT(val);
if (ngroups > 4096)
ngroups = 4096;
maxgroups = ngroups;
return INT2FIX(maxgroups);
}
|
.pid ⇒ Fixnum
Returns the process id of this process. Not available on all platforms.
Process.pid #=> 27415
|
# File 'process.c'
static VALUE
get_pid()
{
rb_secure(2);
return INT2FIX(getpid());
}
|
.ppid ⇒ Fixnum
Returns the process id of the parent of this process. Always returns 0 on NT. Not available on all platforms.
puts "I am #{Process.pid}"
Process.fork { puts "Dad is #{Process.ppid}" }
produces:
I am 27417
Dad is 27417
|
# File 'process.c'
static VALUE
get_ppid()
{
rb_secure(2);
#ifdef _WIN32
return INT2FIX(0);
#else
return INT2FIX(getppid());
#endif
}
|
.setpgid(pid, integer) ⇒ 0
Sets the process group ID of pid (0 indicates this process) to integer. Not available on all platforms.
|
# File 'process.c'
static VALUE
proc_setpgid(obj, pid, pgrp)
VALUE obj, pid, pgrp;
{
#ifdef HAVE_SETPGID
int ipid, ipgrp;
rb_secure(2);
ipid = NUM2INT(pid);
ipgrp = NUM2INT(pgrp);
if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0);
return INT2FIX(0);
#else
rb_notimplement();
#endif
}
|
.setpgrp ⇒ 0
Equivalent to setpgid(0,0)
. Not available on all platforms.
|
# File 'process.c'
static VALUE
proc_setpgrp()
{
rb_secure(2);
/* check for posix setpgid() first; this matches the posix */
/* getpgrp() above. It appears that configure will set SETPGRP_VOID */
/* even though setpgrp(0,0) would be prefered. The posix call avoids */
/* this confusion. */
#ifdef HAVE_SETPGID
if (setpgid(0,0) < 0) rb_sys_fail(0);
#elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)
if (setpgrp() < 0) rb_sys_fail(0);
#else
rb_notimplement();
#endif
return INT2FIX(0);
}
|
.setpriority(kind, integer, priority) ⇒ 0
See Process#getpriority
.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
|
# File 'process.c'
static VALUE
proc_setpriority(obj, which, who, prio)
VALUE obj, which, who, prio;
{
#ifdef HAVE_GETPRIORITY
int iwhich, iwho, iprio;
rb_secure(2);
iwhich = NUM2INT(which);
iwho = NUM2INT(who);
iprio = NUM2INT(prio);
if (setpriority(iwhich, iwho, iprio) < 0)
rb_sys_fail(0);
return INT2FIX(0);
#else
rb_notimplement();
#endif
}
|
.setrlimit(resource, cur_limit, max_limit) ⇒ nil .setrlimit(resource, cur_limit) ⇒ nil
Sets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit.
If max_limit is not given, cur_limit is used.
resource indicates the kind of resource to limit. The list of resources are OS dependent. Ruby may support following resources.
- Process::RLIMIT_CORE
-
core size (bytes) (SUSv3)
- Process::RLIMIT_CPU
-
CPU time (seconds) (SUSv3)
- Process::RLIMIT_DATA
-
data segment (bytes) (SUSv3)
- Process::RLIMIT_FSIZE
-
file size (bytes) (SUSv3)
- Process::RLIMIT_NOFILE
-
file descriptors (number) (SUSv3)
- Process::RLIMIT_STACK
-
stack size (bytes) (SUSv3)
- Process::RLIMIT_AS
-
total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
- Process::RLIMIT_MEMLOCK
-
total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
- Process::RLIMIT_NPROC
-
number of processes for the user (number) (4.4BSD, GNU/Linux)
- Process::RLIMIT_RSS
-
resident memory size (bytes) (4.2BSD, GNU/Linux)
- Process::RLIMIT_SBSIZE
-
all socket buffers (bytes) (NetBSD, FreeBSD)
Other Process::RLIMIT_???
constants may be defined.
cur_limit and max_limit may be Process::RLIM_INFINITY
, which means that the resource is not limited. They may be Process::RLIM_SAVED_MAX
or Process::RLIM_SAVED_CUR
too. See system setrlimit(2) manual for details.
|
# File 'process.c'
static VALUE
proc_setrlimit(int argc, VALUE *argv, VALUE obj)
{
#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
VALUE resource, rlim_cur, rlim_max;
struct rlimit rlim;
rb_secure(2);
rb_scan_args(argc, argv, "21", &resource, &rlim_cur, &rlim_max);
if (rlim_max == Qnil)
rlim_max = rlim_cur;
rlim.rlim_cur = NUM2RLIM(rlim_cur);
rlim.rlim_max = NUM2RLIM(rlim_max);
if (setrlimit(NUM2INT(resource), &rlim) < 0) {
rb_sys_fail("setrlimit");
}
|
.setsid ⇒ Fixnum
Establishes this process as a new session and process group leader, with no controlling tty. Returns the session id. Not available on all platforms.
Process.setsid #=> 27422
|
# File 'process.c'
static VALUE
proc_setsid()
{
#if defined(HAVE_SETSID)
int pid;
rb_secure(2);
pid = setsid();
if (pid < 0) rb_sys_fail(0);
return INT2FIX(pid);
#elif defined(HAVE_SETPGRP) && defined(TIOCNOTTY)
rb_pid_t pid;
int ret;
rb_secure(2);
pid = getpid();
#if defined(SETPGRP_VOID)
ret = setpgrp();
/* If `pid_t setpgrp(void)' is equivalent to setsid(),
`ret' will be the same value as `pid', and following open() will fail.
In Linux, `int setpgrp(void)' is equivalent to setpgid(0, 0). */
#else
ret = setpgrp(0, pid);
#endif
if (ret == -1) rb_sys_fail(0);
if ((fd = open("/dev/tty", O_RDWR)) >= 0) {
ioctl(fd, TIOCNOTTY, NULL);
close(fd);
}
|
.times ⇒ aStructTms
Returns a Tms
structure (see Struct::Tms
on page 388) that contains user and system CPU times for this process.
t = Process.times
[ t.utime, t.stime ] #=> [0.0, 0.02]
|
# File 'process.c'
VALUE
rb_proc_times(obj)
VALUE obj;
{
#if defined(HAVE_TIMES) && !defined(__CHECKER__)
const double hertz =
#ifdef HAVE__SC_CLK_TCK
(double)sysconf(_SC_CLK_TCK);
#else
#ifndef HZ
# ifdef CLK_TCK
# define HZ CLK_TCK
# else
# define HZ 60
# endif
#endif /* HZ */
HZ;
#endif
struct tms buf;
volatile VALUE utime, stime, cutime, sctime;
times(&buf);
return rb_struct_new(S_Tms,
utime = rb_float_new(buf.tms_utime / hertz),
stime = rb_float_new(buf.tms_stime / hertz),
cutime = rb_float_new(buf.tms_cutime / hertz),
sctime = rb_float_new(buf.tms_cstime / hertz));
#else
rb_notimplement();
#endif
}
|
.uid ⇒ Fixnum .Process::UID.rid ⇒ Fixnum .Process::Sys.getuid ⇒ Fixnum
Returns the (real) user ID of this process.
Process.uid #=> 501
|
# File 'process.c'
static VALUE
proc_getuid(obj)
VALUE obj;
{
int uid = getuid();
return INT2FIX(uid);
}
|
.uid=(integer) ⇒ Numeric
Sets the (integer) user ID for this process. Not available on all platforms.
|
# File 'process.c'
static VALUE
proc_setuid(obj, id)
VALUE obj, id;
{
int uid = NUM2INT(id);
check_uid_switch();
#if defined(HAVE_SETRESUID) && !defined(__CHECKER__)
if (setresuid(uid, -1, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREUID
if (setreuid(uid, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETRUID
if (setruid(uid) < 0) rb_sys_fail(0);
#elif defined HAVE_SETUID
{
if (geteuid() == uid) {
if (setuid(uid) < 0) rb_sys_fail(0);
}
|
.wait ⇒ Fixnum .wait(pid = -1, flags = 0) ⇒ Fixnum .waitpid(pid = -1, flags = 0) ⇒ Fixnum
Waits for a child process to exit, returns its process id, and sets $?
to a Process::Status
object containing information on that process. Which child it waits on depends on the value of pid:
- > 0
-
Waits for the child whose process ID equals pid.
- 0
-
Waits for any child whose process group ID equals that of the calling process.
- -1
-
Waits for any child process (the default if no pid is given).
- < -1
-
Waits for any child whose process group ID equals the absolute value of pid.
The flags argument may be a logical or of the flag values Process::WNOHANG
(do not block if no child available) or Process::WUNTRACED
(return stopped children that haven't been reported). Not all flags are available on all platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemError
if there are no child processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, 0) #=> 27440
Time.now #=> Wed Apr 09 08:57:12 CDT 2003
|
# File 'process.c'
static VALUE
proc_wait(argc, argv)
int argc;
VALUE *argv;
{
VALUE vpid, vflags;
int pid, flags, status;
rb_secure(2);
flags = 0;
rb_scan_args(argc, argv, "02", &vpid, &vflags);
if (argc == 0) {
pid = -1;
}
|
.wait2(pid = -1, flags = 0) ⇒ Array .waitpid2(pid = -1, flags = 0) ⇒ Array
Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a Process::Status
object) of that child. Raises a SystemError
if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
|
# File 'process.c'
static VALUE
proc_wait2(argc, argv)
int argc;
VALUE *argv;
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status);
}
|
.waitall ⇒ Array
Waits for all children, returning an array of pid/status pairs (where status is a Process::Status
object).
fork { sleep 0.2; exit 2 } #=> 27432
fork { sleep 0.1; exit 1 } #=> 27433
fork { exit 0 } #=> 27434
p Process.waitall
produces:
[[27434, #<Process::Status: pid=27434,exited(0)>],
[27433, #<Process::Status: pid=27433,exited(1)>],
[27432, #<Process::Status: pid=27432,exited(2)>]]
|
# File 'process.c'
static VALUE
proc_waitall()
{
VALUE result;
int pid, status;
rb_secure(2);
result = rb_ary_new();
#ifdef NO_WAITPID
if (pid_tbl) {
st_foreach(pid_tbl, waitall_each, result);
}
|
.wait ⇒ Fixnum .wait(pid = -1, flags = 0) ⇒ Fixnum .waitpid(pid = -1, flags = 0) ⇒ Fixnum
Waits for a child process to exit, returns its process id, and sets $?
to a Process::Status
object containing information on that process. Which child it waits on depends on the value of pid:
- > 0
-
Waits for the child whose process ID equals pid.
- 0
-
Waits for any child whose process group ID equals that of the calling process.
- -1
-
Waits for any child process (the default if no pid is given).
- < -1
-
Waits for any child whose process group ID equals the absolute value of pid.
The flags argument may be a logical or of the flag values Process::WNOHANG
(do not block if no child available) or Process::WUNTRACED
(return stopped children that haven't been reported). Not all flags are available on all platforms, but a flag value of zero will work on all platforms.
Calling this method raises a SystemError
if there are no child processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, 0) #=> 27440
Time.now #=> Wed Apr 09 08:57:12 CDT 2003
|
# File 'process.c'
static VALUE
proc_wait(argc, argv)
int argc;
VALUE *argv;
{
VALUE vpid, vflags;
int pid, flags, status;
rb_secure(2);
flags = 0;
rb_scan_args(argc, argv, "02", &vpid, &vflags);
if (argc == 0) {
pid = -1;
}
|
.wait2(pid = -1, flags = 0) ⇒ Array .waitpid2(pid = -1, flags = 0) ⇒ Array
Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a Process::Status
object) of that child. Raises a SystemError
if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
|
# File 'process.c'
static VALUE
proc_wait2(argc, argv)
int argc;
VALUE *argv;
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status);
}
|