Module | Process |
In: |
process.c
|
The Process module is a collection of methods used to manipulate processes.
WNOHANG | = | INT2FIX(WNOHANG) |
WNOHANG | = | INT2FIX(0) |
WUNTRACED | = | INT2FIX(WUNTRACED) |
WUNTRACED | = | INT2FIX(0) |
PRIO_PROCESS | = | INT2FIX(PRIO_PROCESS) |
PRIO_PGRP | = | INT2FIX(PRIO_PGRP) |
PRIO_USER | = | INT2FIX(PRIO_USER) |
RLIM_INFINITY | = | inf |
RLIM_SAVED_MAX | = | v |
RLIM_SAVED_CUR | = | v |
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) |
Terminate execution immediately, effectively by calling Kernel.exit(1). If msg is given, it is written to STDERR prior to terminating.
/* * call-seq: * abort * Kernel::abort * Process::abort * * Terminate execution immediately, effectively by calling * <code>Kernel.exit(1)</code>. If _msg_ is given, it is written * to STDERR prior to terminating. */ VALUE rb_f_abort(argc, argv) int argc; VALUE *argv; { rb_secure(4); if (argc == 0) { if (!NIL_P(ruby_errinfo)) { error_print(); } rb_exit(EXIT_FAILURE); } else { VALUE mesg; rb_scan_args(argc, argv, "1", &mesg); StringValue(mesg); rb_io_puts(1, &mesg, rb_stderr); terminate_process(EXIT_FAILURE, mesg); } return Qnil; /* not reached */ }
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)
/* * call-seq: * Process.detach(pid) => thread * * Some operating systems retain the status of terminated child * processes until the parent collects that status (normally using * some variant of <code>wait()</code>. If the parent never collects * this status, the child stays around as a <em>zombie</em> process. * <code>Process::detach</code> 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 <code>detach</code> * only when you do not intent to explicitly wait for the child to * terminate. <code>detach</code> 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 <code>Thread#join</code> 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}") * * <em>produces:</em> * * 27389 Z * * In the next example, <code>Process::detach</code> 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}") * * <em>(produces no output)</em> */ static VALUE proc_detach(VALUE obj, VALUE pid) { rb_secure(2); return rb_detach_process(NUM2INT(pid)); }
Returns the effective group ID for this process. Not available on all platforms.
Process.egid #=> 500
/* * call-seq: * Process.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 */ static VALUE proc_getegid(obj) VALUE obj; { int egid = getegid(); return INT2FIX(egid); }
Sets the effective group ID for this process. Not available on all platforms.
/* * call-seq: * Process.egid = fixnum => fixnum * * Sets the effective group ID for this process. Not available on all * platforms. */ 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); } else { rb_notimplement(); } #else rb_notimplement(); #endif return egid; }
Returns the effective user ID for this process.
Process.euid #=> 501
/* * call-seq: * Process.euid => fixnum * Process::UID.eid => fixnum * Process::Sys.geteuid => fixnum * * Returns the effective user ID for this process. * * Process.euid #=> 501 */ static VALUE proc_geteuid(obj) VALUE obj; { int euid = geteuid(); return INT2FIX(euid); }
Sets the effective user ID for this process. Not available on all platforms.
/* * call-seq: * Process.euid= integer * * Sets the effective user ID for this process. Not available on all * platforms. */ 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); } else { rb_notimplement(); } #else rb_notimplement(); #endif return euid; }
Replaces the current process by running the given external command. If exec is given a single argument, that argument is taken as a line that is subject to shell expansion before being executed. If multiple arguments are given, the second and subsequent arguments are passed as parameters to command with no shell expansion. If the first argument is a two-element array, the first element is the command to be executed, and the second argument is used as the argv[0] value, which may show up in process listings. In MSDOS environments, the command is executed in a subshell; otherwise, one of the exec(2) system calls is used, so the running command may inherit some of the environment of the original program (including open file descriptors).
exec "echo *" # echoes list of files in current directory # never get here exec "echo", "*" # echoes an asterisk # never get here
/* * call-seq: * exec(command [, arg, ...]) * * Replaces the current process by running the given external _command_. * If +exec+ is given a single argument, that argument is * taken as a line that is subject to shell expansion before being * executed. If multiple arguments are given, the second and subsequent * arguments are passed as parameters to _command_ with no shell * expansion. If the first argument is a two-element array, the first * element is the command to be executed, and the second argument is * used as the <code>argv[0]</code> value, which may show up in process * listings. In MSDOS environments, the command is executed in a * subshell; otherwise, one of the <code>exec(2)</code> system calls is * used, so the running command may inherit some of the environment of * the original program (including open file descriptors). * * exec "echo *" # echoes list of files in current directory * # never get here * * * exec "echo", "*" # echoes an asterisk * # never get here */ VALUE rb_f_exec(argc, argv) int argc; VALUE *argv; { VALUE prog = 0; VALUE tmp; struct rb_exec_arg earg; if (argc == 0) { rb_last_status = Qnil; rb_raise(rb_eArgError, "wrong number of arguments"); } tmp = rb_check_array_type(argv[0]); if (!NIL_P(tmp)) { if (RARRAY(tmp)->len != 2) { rb_raise(rb_eArgError, "wrong first argument"); } prog = RARRAY(tmp)->ptr[0]; argv[0] = RARRAY(tmp)->ptr[1]; SafeStringValue(prog); } proc_prepare_args(&earg, argc, argv, prog); proc_exec_args((VALUE)&earg); rb_sys_fail(RSTRING(argv[0])->ptr); return Qnil; /* dummy */ }
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
/* * call-seq: * exit(integer=0) * Kernel::exit(integer=0) * Process::exit(integer=0) * * Initiates the termination of the Ruby script by raising the * <code>SystemExit</code> 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" * * <em>produces:</em> * * rescued a SystemExit exception * after begin block * * Just prior to termination, Ruby executes any <code>at_exit</code> 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 * * <em>produces:</em> * * at_exit function * in finalizer */ 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; } } else { istatus = EXIT_SUCCESS; } rb_exit(istatus); return Qnil; /* not reached */ }
Exits the process immediately. No exit handlers are run. fixnum is returned to the underlying system as the exit status.
Process.exit!(0)
/* * call-seq: * Process.exit!(fixnum=-1) * * Exits the process immediately. No exit handlers are * run. <em>fixnum</em> is returned to the underlying system as the * exit status. * * Process.exit!(0) */ 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; } } else { istatus = EXIT_FAILURE; } _exit(istatus); return Qnil; /* not reached */ }
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.
/* * call-seq: * Kernel.fork [{ block }] => fixnum or nil * Process.fork [{ block }] => fixnum or nil * * 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 * <code>Kernel.exit!</code> to avoid running any * <code>at_exit</code> functions. The parent process should * use <code>Process.wait</code> to collect the termination statuses * of its children or use <code>Process.detach</code> 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. */ 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); } return Qnil; case -1: rb_sys_fail("fork(2)"); return Qnil; default: return INT2FIX(pid); } #else rb_notimplement(); #endif }
Returns the process group ID for the given process id. Not available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527
/* * call-seq: * Process.getpgid(pid) => integer * * Returns the process group ID for the given process id. Not * available on all platforms. * * Process.getpgid(Process.ppid()) #=> 25527 */ 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 }
Returns the process group ID for this process. Not available on all platforms.
Process.getpgid(0) #=> 25527 Process.getpgrp #=> 25527
/* * call-seq: * Process.getpgrp => integer * * Returns the process group ID for this process. Not available on * all platforms. * * Process.getpgid(0) #=> 25527 * Process.getpgrp #=> 25527 */ static VALUE proc_getpgrp() { #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) int pgrp; #endif rb_secure(2); #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) pgrp = getpgrp(); if (pgrp < 0) rb_sys_fail(0); return INT2FIX(pgrp); #else # ifdef HAVE_GETPGID pgrp = getpgid(0); if (pgrp < 0) rb_sys_fail(0); return INT2FIX(pgrp); # else rb_notimplement(); # endif #endif }
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
/* * call-seq: * Process.getpriority(kind, integer) => fixnum * * Gets the scheduling priority for specified process, process group, * or user. <em>kind</em> indicates the kind of entity to find: one * of <code>Process::PRIO_PGRP</code>, * <code>Process::PRIO_USER</code>, or * <code>Process::PRIO_PROCESS</code>. _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 */ 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 }
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.
/* * call-seq: * Process.getrlimit(resource) => [cur_limit, max_limit] * * 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 <code>Process::RLIMIT_CORE</code>, * <code>Process::RLIMIT_CPU</code>, etc. * See Process.setrlimit for details. * * _cur_limit_ and _max_limit_ may be <code>Process::RLIM_INFINITY</code>, * <code>Process::RLIM_SAVED_MAX</code> or * <code>Process::RLIM_SAVED_CUR</code>. * See Process.setrlimit and the system getrlimit(2) manual for details. */ 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"); } return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max)); #else rb_notimplement(); #endif }
Returns the (real) group ID for this process.
Process.gid #=> 500
/* * call-seq: * Process.gid => fixnum * Process::GID.rid => fixnum * Process::Sys.getgid => fixnum * * Returns the (real) group ID for this process. * * Process.gid #=> 500 */ static VALUE proc_getgid(obj) VALUE obj; { int gid = getgid(); return INT2FIX(gid); }
Sets the group ID for this process.
/* * call-seq: * Process.gid= fixnum => fixnum * * Sets the group ID for this process. */ 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); } else { rb_notimplement(); } } #else rb_notimplement(); #endif return INT2FIX(gid); }
Get an Array of the gids of groups in the supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
/* * call-seq: * Process.groups => array * * Get an <code>Array</code> of the gids of groups in the * supplemental group access list for this process. * * Process.groups #=> [27, 6, 10, 11] * */ 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 }
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]
/* * call-seq: * Process.groups= array => array * * Set the supplemental group access list to the given * <code>Array</code> 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] * */ 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); } else { VALUE tmp = rb_check_string_type(g); if (NIL_P(tmp)) { groups[i] = NUM2INT(g); } else { gr = getgrnam(RSTRING(tmp)->ptr); if (gr == NULL) rb_raise(rb_eArgError, "can't find group for %s", RSTRING(tmp)->ptr); groups[i] = gr->gr_gid; } } } i = setgroups(ngroups, groups); if (i == -1) rb_sys_fail(0); return proc_getgroups(obj); #else rb_notimplement(); return Qnil; #endif }
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]
/* * call-seq: * Process.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 <em>gid</em> is also * added to the list. Returns the resulting <code>Array</code> 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] * */ 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); } return proc_getgroups(obj); #else rb_notimplement(); return Qnil; #endif }
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!
/* * call-seq: * Process.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 * * <em>produces:</em> * * Ouch! */ VALUE rb_f_kill(argc, argv) int argc; VALUE *argv; { int negative = 0; int sig; int i; const 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++; } str_signal: if (strncmp("SIG", s, 3) == 0) s += 3; if((sig = signm2signo(s)) == 0) rb_raise(rb_eArgError, "unsupported name `SIG%s'", s); if (negative) sig = -sig; break; default: { VALUE str; str = rb_check_string_type(argv[0]); if (!NIL_P(str)) { s = RSTRING(str)->ptr; goto str_signal; } rb_raise(rb_eArgError, "bad signal type %s", rb_obj_classname(argv[0])); } break; } if (sig < 0) { sig = -sig; for (i=1; i<argc; i++) { int pid = NUM2INT(argv[i]); #ifdef HAS_KILLPG if (killpg(pid, sig) < 0) #else if (kill(-pid, sig) < 0) #endif rb_sys_fail(0); } } else { for (i=1; i<argc; i++) { Check_Type(argv[i], T_FIXNUM); if (kill(FIX2INT(argv[i]), sig) < 0) rb_sys_fail(0); } } return INT2FIX(i-1); }
Returns the maximum number of gids allowed in the supplemental group access list.
Process.maxgroups #=> 32
/* * call-seq: * Process.maxgroups => fixnum * * Returns the maximum number of gids allowed in the supplemental * group access list. * * Process.maxgroups #=> 32 */ static VALUE proc_getmaxgroups(obj) VALUE obj; { return INT2FIX(maxgroups); }
Sets the maximum number of gids allowed in the supplemental group access list.
/* * call-seq: * Process.maxgroups= fixnum => fixnum * * Sets the maximum number of gids allowed in the supplemental group * access list. */ static VALUE proc_setmaxgroups(VALUE obj, VALUE val) { size_t ngroups = FIX2INT(val); if (ngroups > 4096) ngroups = 4096; maxgroups = ngroups; return INT2FIX(maxgroups); }
Returns the process id of this process. Not available on all platforms.
Process.pid #=> 27415
/* * call-seq: * Process.pid => fixnum * * Returns the process id of this process. Not available on all * platforms. * * Process.pid #=> 27415 */ static VALUE get_pid() { rb_secure(2); return INT2FIX(getpid()); }
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
/* * call-seq: * Process.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}" } * * <em>produces:</em> * * I am 27417 * Dad is 27417 */ static VALUE get_ppid() { rb_secure(2); #ifdef _WIN32 return INT2FIX(0); #else return INT2FIX(getppid()); #endif }
Sets the process group ID of pid (0 indicates this process) to integer. Not available on all platforms.
/* * call-seq: * Process.setpgid(pid, integer) => 0 * * Sets the process group ID of _pid_ (0 indicates this * process) to <em>integer</em>. Not available on all platforms. */ 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 }
Equivalent to setpgid(0,0). Not available on all platforms.
/* * call-seq: * Process.setpgrp => 0 * * Equivalent to <code>setpgid(0,0)</code>. Not available on all * platforms. */ 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); }
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
/* * call-seq: * Process.setpriority(kind, integer, priority) => 0 * * See <code>Process#getpriority</code>. * * 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 */ 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 }
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.
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.
/* * call-seq: * Process.setrlimit(resource, cur_limit, max_limit) => nil * Process.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 <code>Process::RLIMIT_???</code> constants may be defined. * * _cur_limit_ and _max_limit_ may be <code>Process::RLIM_INFINITY</code>, * which means that the resource is not limited. * They may be <code>Process::RLIM_SAVED_MAX</code> or * <code>Process::RLIM_SAVED_CUR</code> too. * See system setrlimit(2) manual for details. * */ 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"); } return Qnil; #else rb_notimplement(); #endif }
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
/* * call-seq: * Process.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 */ 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); } return INT2FIX(pid); #else rb_notimplement(); #endif }
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]
/* * call-seq: * Process.times => aStructTms * * Returns a <code>Tms</code> structure (see <code>Struct::Tms</code> * on page 388) that contains user and system CPU times for this * process. * * t = Process.times * [ t.utime, t.stime ] #=> [0.0, 0.02] */ 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 }
Returns the (real) user ID of this process.
Process.uid #=> 501
/* * call-seq: * Process.uid => fixnum * Process::UID.rid => fixnum * Process::Sys.getuid => fixnum * * Returns the (real) user ID of this process. * * Process.uid #=> 501 */ static VALUE proc_getuid(obj) VALUE obj; { int uid = getuid(); return INT2FIX(uid); }
Sets the (integer) user ID for this process. Not available on all platforms.
/* * call-seq: * Process.uid= integer => numeric * * Sets the (integer) user ID for this process. Not available on all * platforms. */ 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); } else { rb_notimplement(); } } #else rb_notimplement(); #endif return INT2FIX(uid); }
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
/* * call-seq: * Process.wait() => fixnum * Process.wait(pid=-1, flags=0) => fixnum * Process.waitpid(pid=-1, flags=0) => fixnum * * Waits for a child process to exit, returns its process id, and * sets <code>$?</code> to a <code>Process::Status</code> 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 * <code>Process::WNOHANG</code> (do not block if no child available) * or <code>Process::WUNTRACED</code> (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 <code>SystemError</code> 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 */ 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; } else { pid = NUM2INT(vpid); if (argc == 2 && !NIL_P(vflags)) { flags = NUM2UINT(vflags); } } if ((pid = rb_waitpid(pid, &status, flags)) < 0) rb_sys_fail(0); if (pid == 0) { return rb_last_status = Qnil; } return INT2FIX(pid); }
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
/* * call-seq: * Process.wait2(pid=-1, flags=0) => [pid, status] * Process.waitpid2(pid=-1, flags=0) => [pid, status] * * 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 <code>Process::Status</code> object) of that * child. Raises a <code>SystemError</code> if there are no child * processes. * * Process.fork { exit 99 } #=> 27437 * pid, status = Process.wait2 * pid #=> 27437 * status.exitstatus #=> 99 */ 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); }
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)>]]
/* * call-seq: * Process.waitall => [ [pid1,status1], ...] * * Waits for all children, returning an array of * _pid_/_status_ pairs (where _status_ is a * <code>Process::Status</code> object). * * fork { sleep 0.2; exit 2 } #=> 27432 * fork { sleep 0.1; exit 1 } #=> 27433 * fork { exit 0 } #=> 27434 * p Process.waitall * * <em>produces</em>: * * [[27434, #<Process::Status: pid=27434,exited(0)>], * [27433, #<Process::Status: pid=27433,exited(1)>], * [27432, #<Process::Status: pid=27432,exited(2)>]] */ 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); } for (pid = -1;;) { pid = wait(&status); if (pid == -1) { if (errno == ECHILD) break; if (errno == EINTR) { rb_thread_schedule(); continue; } rb_sys_fail(0); } last_status_set(status, pid); rb_ary_push(result, rb_assoc_new(INT2NUM(pid), rb_last_status)); } #else rb_last_status = Qnil; for (pid = -1;;) { pid = rb_waitpid(-1, &status, 0); if (pid == -1) { if (errno == ECHILD) break; rb_sys_fail(0); } rb_ary_push(result, rb_assoc_new(INT2NUM(pid), rb_last_status)); } #endif return result; }
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
/* * call-seq: * Process.wait() => fixnum * Process.wait(pid=-1, flags=0) => fixnum * Process.waitpid(pid=-1, flags=0) => fixnum * * Waits for a child process to exit, returns its process id, and * sets <code>$?</code> to a <code>Process::Status</code> 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 * <code>Process::WNOHANG</code> (do not block if no child available) * or <code>Process::WUNTRACED</code> (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 <code>SystemError</code> 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 */ 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; } else { pid = NUM2INT(vpid); if (argc == 2 && !NIL_P(vflags)) { flags = NUM2UINT(vflags); } } if ((pid = rb_waitpid(pid, &status, flags)) < 0) rb_sys_fail(0); if (pid == 0) { return rb_last_status = Qnil; } return INT2FIX(pid); }
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
/* * call-seq: * Process.wait2(pid=-1, flags=0) => [pid, status] * Process.waitpid2(pid=-1, flags=0) => [pid, status] * * 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 <code>Process::Status</code> object) of that * child. Raises a <code>SystemError</code> if there are no child * processes. * * Process.fork { exit 99 } #=> 27437 * pid, status = Process.wait2 * pid #=> 27437 * status.exitstatus #=> 99 */ 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); }