1/* Part of SWI-Prolog 2 3 Author: Jan Wielemaker 4 E-mail: J.Wielemaker@vu.nl 5 WWW: http://www.swi-prolog.org 6 Copyright (c) 2008-2018, University of Amsterdam 7 VU University Amsterdam 8 CWI, Amsterdam 9 All rights reserved. 10 11 Redistribution and use in source and binary forms, with or without 12 modification, are permitted provided that the following conditions 13 are met: 14 15 1. Redistributions of source code must retain the above copyright 16 notice, this list of conditions and the following disclaimer. 17 18 2. Redistributions in binary form must reproduce the above copyright 19 notice, this list of conditions and the following disclaimer in 20 the documentation and/or other materials provided with the 21 distribution. 22 23 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 26 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 27 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 28 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 29 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 31 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 33 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 POSSIBILITY OF SUCH DAMAGE. 35*/ 36 37:- module(process, 38 [ process_create/3, % +Exe, +Args, +Options 39 process_wait/2, % +PID, -Status 40 process_wait/3, % +PID, -Status, +Options 41 process_id/1, % -PID 42 process_id/2, % +Process, -PID 43 is_process/1, % +PID 44 process_release/1, % +PID 45 process_kill/1, % +PID 46 process_group_kill/1, % +PID 47 process_group_kill/2, % +PID, +Signal 48 process_kill/2, % +PID, +Signal 49 50 process_set_method/1 % +CreateMethod 51 ]). 52:- use_module(library(shlib)). 53:- use_module(library(option)). 54:- use_module(library(error)). 55:- use_module(library(apply)). 56 57:- use_foreign_library(foreign(process)). 58 59:- predicate_options(process_create/3, 3, 60 [ stdin(any), 61 stdout(any), 62 stderr(any), 63 cwd(atom), 64 env(list(any)), 65 environment(list(any)), 66 priority(+integer), 67 process(-integer), 68 detached(+boolean), 69 window(+boolean) 70 ]). 71 72/** <module> Create processes and redirect I/O 73 74The module library(process) implements interaction with child processes 75and unifies older interfaces such as shell/[1,2], open(pipe(command), 76...) etc. This library is modelled after SICStus 4. 77 78The main interface is formed by process_create/3. If the process id is 79requested the process must be waited for using process_wait/2. Otherwise 80the process resources are reclaimed automatically. 81 82In addition to the predicates, this module defines a file search path 83(see user:file_search_path/2 and absolute_file_name/3) named =path= that 84locates files on the system's search path for executables. E.g. the 85following finds the executable for =ls=: 86 87 == 88 ?- absolute_file_name(path(ls), Path, [access(execute)]). 89 == 90 91*|Incompatibilities and current limitations|* 92 93 * Where SICStus distinguishes between an internal process id and 94 the OS process id, this implementation does not make this 95 distinction. This implies that is_process/1 is incomplete and 96 unreliable. 97 98 * SICStus only supports ISO 8859-1 (latin-1). This implementation 99 supports arbitrary OS multibyte interaction using the default 100 locale. 101 102 * It is unclear what the detached(true) option is supposed to do. Disable 103 signals in the child? Use setsid() to detach from the session? The 104 current implementation uses setsid() on Unix systems. 105 106 * An extra option env([Name=Value, ...]) is added to 107 process_create/3. As of version 4.1 SICStus added 108 environment(List) which _modifies_ the environment. A 109 compatible option was added to SWI-Prolog 7.7.23. 110 111@tbd Implement detached option in process_create/3 112@compat SICStus 4 113*/ 114 115 116%! process_create(+Exe, +Args:list, +Options) is det. 117% 118% Create a new process running the file Exe and using arguments 119% from the given list. Exe is a file specification as handed to 120% absolute_file_name/3. Typically one use the =path= file alias to 121% specify an executable file on the current PATH. Args is a list 122% of arguments that are handed to the new process. On Unix 123% systems, each element in the list becomes a seperate argument in 124% the new process. In Windows, the arguments are simply 125% concatenated to form the commandline. Each argument itself is 126% either a primitive or a list of primitives. A primitive is 127% either atomic or a term file(Spec). Using file(Spec), the system 128% inserts a filename using the OS filename conventions which is 129% properly quoted if needed. 130% 131% Options: 132% 133% * stdin(Spec) 134% * stdout(Spec) 135% * stderr(Spec) 136% Bind the standard streams of the new process. Spec is one of 137% the terms below. If pipe(Pipe) is used, the Prolog stream is 138% a stream in text-mode using the encoding of the default 139% locale. The encoding can be changed using set_stream/2. 140% The options =stdout= and =stderr= may use the same stream, 141% in which case both output streams are connected to the same 142% Prolog stream. 143% 144% * std 145% Just share with the Prolog I/O streams 146% * null 147% Bind to a _null_ stream. Reading from such a stream 148% returns end-of-file, writing produces no output 149% * pipe(-Stream) 150% Attach input and/or output to a Prolog stream. 151% 152% * cwd(+Directory) 153% Run the new process in Directory. Directory can be a 154% compound specification, which is converted using 155% absolute_file_name/3. 156% * env(+List) 157% As environment(List), but _only_ the specified variables 158% are passed, i.e., no variables are _inherited_. 159% * environment(+List) 160% Specify _additional_ environment variables for the new process. 161% List is a list of `Name=Value` terms, where `Value` is expanded 162% the same way as the Args argument. If neither `env` nor 163% `environment` is passed the environment is inherited from the 164% Prolog process. 165% * process(-PID) 166% Unify PID with the process id of the created process. 167% * detached(+Bool) 168% In Unix: If =true=, detach the process from the terminal 169% Currently mapped to setsid(); 170% Also creates a new process group for the child 171% In Windows: If =true=, detach the process from the current 172% job via the CREATE_BREAKAWAY_FROM_JOB flag. In Vista and beyond, 173% processes launched from the shell directly have the 'compatibility 174% assistant' attached to them automatically unless they have a UAC 175% manifest embedded in them. This means that you will get a 176% permission denied error if you try and assign the newly-created 177% PID to a job you create yourself. 178% * window(+Bool) 179% If =true=, create a window for the process (Windows only) 180% * priority(+Priority) 181% In Unix: specifies the process priority for the newly 182% created process. Priority must be an integer between -20 183% and 19. Positive values are nicer to others, and negative 184% values are less so. The default is zero. Users are free to 185% lower their own priority. Only the super-user may _raise_ it 186% to less-than zero. 187% 188% If the user specifies the process(-PID) option, he *must* call 189% process_wait/2 to reclaim the process. Without this option, the 190% system will wait for completion of the process after the last 191% pipe stream is closed. 192% 193% If the process is not waited for, it must succeed with status 0. 194% If not, an process_error is raised. 195% 196% *|Windows notes|* 197% 198% On Windows this call is an interface to the CreateProcess() API. 199% The commandline consists of the basename of Exe and the 200% arguments formed from Args. Arguments are separated by a single 201% space. If all characters satisfy iswalnum() it is unquoted. If 202% the argument contains a double-quote it is quoted using single 203% quotes. If both single and double quotes appear a domain_error 204% is raised, otherwise double-quote are used. 205% 206% The CreateProcess() API has many options. Currently only the 207% =CREATE_NO_WINDOW= options is supported through the 208% window(+Bool) option. If omitted, the default is to use this 209% option if the application has no console. Future versions are 210% likely to support more window specific options and replace 211% win_exec/2. 212% 213% *Examples* 214% 215% First, a very simple example that behaves the same as 216% =|shell('ls -l')|=, except for error handling: 217% 218% == 219% ?- process_create(path(ls), ['-l'], []). 220% == 221% 222% The following example uses grep to find all matching lines in a 223% file. 224% 225% == 226% grep(File, Pattern, Lines) :- 227% setup_call_cleanup( 228% process_create(path(grep), [ Pattern, file(File) ], 229% [ stdout(pipe(Out)) 230% ]), 231% read_lines(Out, Lines), 232% close(Out)). 233% 234% read_lines(Out, Lines) :- 235% read_line_to_codes(Out, Line1), 236% read_lines(Line1, Out, Lines). 237% 238% read_lines(end_of_file, _, []) :- !. 239% read_lines(Codes, Out, [Line|Lines]) :- 240% atom_codes(Line, Codes), 241% read_line_to_codes(Out, Line2), 242% read_lines(Line2, Out, Lines). 243% == 244% 245% @error process_error(Exe, Status) where Status is one of 246% exit(Code) or killed(Signal). Raised if the process 247% is waited for (i.e., Options does not include 248% process(-PID)), and does not exit with status 0. 249% @bug On Windows, environment(List) is handled as env(List), 250% i.e., the environment is not inherited. 251 252process_create(Exe, Args, Options) :- 253 exe_options(ExeOptions), 254 absolute_file_name(Exe, PlProg, ExeOptions), 255 must_be(list, Args), 256 maplist(map_arg, Args, Av), 257 prolog_to_os_filename(PlProg, Prog), 258 Term =.. [Prog|Av], 259 expand_cwd_option(Options, Options1), 260 expand_env_option(env, Options1, Options2), 261 expand_env_option(environment, Options2, Options3), 262 process_create(Term, Options3). 263 264exe_options(Options) :- 265 current_prolog_flag(windows, true), 266 !, 267 Options = [ extensions(['',exe,com]), access(read) ]. 268exe_options(Options) :- 269 Options = [ access(execute) ]. 270 271expand_cwd_option(Options0, Options) :- 272 select_option(cwd(Spec), Options0, Options1), 273 !, 274 ( compound(Spec) 275 -> absolute_file_name(Spec, PlDir, [file_type(directory), access(read)]), 276 prolog_to_os_filename(PlDir, Dir), 277 Options = [cwd(Dir)|Options1] 278 ; exists_directory(Spec) 279 -> Options = Options0 280 ; existence_error(directory, Spec) 281 ). 282expand_cwd_option(Options, Options). 283 284expand_env_option(Name, Options0, Options) :- 285 Term =.. [Name,Value0], 286 select_option(Term, Options0, Options1), 287 !, 288 must_be(list, Value0), 289 maplist(map_env, Value0, Value), 290 NewOption =.. [Name,Value], 291 Options = [NewOption|Options1]. 292expand_env_option(_, Options, Options). 293 294map_env(Name=Value0, Name=Value) :- 295 map_arg(Value0, Value). 296 297%! map_arg(+ArgIn, -Arg) is det. 298% 299% Map an individual argument. Primitives are either file(Spec) or 300% an atomic value (atom, string, number). If ArgIn is a non-empty 301% list, all elements are converted and the results are 302% concatenated. 303 304map_arg([], []) :- !. 305map_arg(List, Arg) :- 306 is_list(List), 307 !, 308 maplist(map_arg_prim, List, Prims), 309 atomic_list_concat(Prims, Arg). 310map_arg(Prim, Arg) :- 311 map_arg_prim(Prim, Arg). 312 313map_arg_prim(file(Spec), File) :- 314 !, 315 ( compound(Spec) 316 -> absolute_file_name(Spec, PlFile) 317 ; PlFile = Spec 318 ), 319 prolog_to_os_filename(PlFile, File). 320map_arg_prim(Arg, Arg). 321 322 323%! process_id(-PID) is det. 324% 325% True if PID is the process id of the running Prolog process. 326% 327% @deprecated Use current_prolog_flag(pid, PID) 328 329process_id(PID) :- 330 current_prolog_flag(pid, PID). 331 332%! process_id(+Process, -PID) is det. 333% 334% PID is the process id of Process. Given that they are united in 335% SWI-Prolog, this is a simple unify. 336 337process_id(PID, PID). 338 339%! is_process(+PID) is semidet. 340% 341% True if PID might be a process. Succeeds for any positive 342% integer. 343 344is_process(PID) :- 345 integer(PID), 346 PID > 0. 347 348%! process_release(+PID) 349% 350% Release process handle. In this implementation this is the same 351% as process_wait(PID, _). 352 353process_release(PID) :- 354 process_wait(PID, _). 355 356%! process_wait(+PID, -Status) is det. 357%! process_wait(+PID, -Status, +Options) is det. 358% 359% True if PID completed with Status. This call normally blocks 360% until the process is finished. Options: 361% 362% * timeout(+Timeout) 363% Default: =infinite=. If this option is a number, the 364% waits for a maximum of Timeout seconds and unifies Status 365% with =timeout= if the process does not terminate within 366% Timeout. In this case PID is _not_ invalidated. On Unix 367% systems only timeout 0 and =infinite= are supported. A 368% 0-value can be used to poll the status of the process. 369% 370% * release(+Bool) 371% Do/do not release the process. We do not support this flag 372% and a domain_error is raised if release(false) is provided. 373% 374% @arg Status is one of exit(Code) or killed(Signal), where 375% Code and Signal are integers. If the `timeout` option 376% is used Status is unified with `timeout` after the wait 377% timed out. 378 379process_wait(PID, Status) :- 380 process_wait(PID, Status, []). 381 382%! process_kill(+PID) is det. 383%! process_kill(+PID, +Signal) is det. 384% 385% Send signal to process PID. Default is =term=. Signal is an 386% integer, Unix signal name (e.g. =SIGSTOP=) or the more Prolog 387% friendly variation one gets after removing =SIG= and downcase 388% the result: =stop=. On Windows systems, Signal is ignored and 389% the process is terminated using the TerminateProcess() API. On 390% Windows systems PID must be obtained from process_create/3, 391% while any PID is allowed on Unix systems. 392% 393% @compat SICStus does not accept the prolog friendly version. We 394% choose to do so for compatibility with on_signal/3. 395 396process_kill(PID) :- 397 process_kill(PID, term). 398 399 400%! process_group_kill(+PID) is det. 401%! process_group_kill(+PID, +Signal) is det. 402% 403% Send signal to the group containing process PID. Default is 404% =term=. See process_wait/1 for a description of signal 405% handling. In Windows, the same restriction on PID applies: it 406% must have been created from process_create/3, and the the group 407% is terminated via the TerminateJobObject API. 408 409process_group_kill(PID) :- 410 process_group_kill(PID, term). 411 412 413%! process_set_method(+Method) is det. 414% 415% Determine how the process is created on Unix systems. Method is one 416% of `spawn` (default), `fork` or `vfork`. If the method is `spawn` 417% but this cannot be used because it is either not supported by the OS 418% or the cwd(Dir) option is given `fork` is used. 419% 420% The problem is to be understood as follows. The official portable 421% and safe method to create a process is using the fork() system call. 422% This call however copies the process page tables and get seriously 423% slow as the (Prolog) process is multiple giga bytes large. 424% Alternatively, we may use vfork() which avoids copying the process 425% space. But, the safe usage as guaranteed by the POSIX standard of 426% vfork() is insufficient for our purposes. On practical systems your 427% mileage may vary. Modern posix systems also provide posix_spawn(), 428% which provides a safe and portable alternative for the fork() and 429% exec() sequence that may be implemented using fork() or may use a 430% fast but safe alternative. Unfortunately posix_spawn() doesn't 431% support the option to specify the working directory for the child 432% and we cannot use working_directory/2 as the working directory is 433% shared between threads. 434% 435% Summarizing, the default is safe and tries to be as fast as 436% possible. On some scenarios and on some OSes it is possible to do 437% better. It is generally a good idea to avoid using the cwd(Dir) 438% option of process_create/3 as without we can use posix_spawn(). 439 440 441 /******************************* 442 * MESSAGES * 443 *******************************/ 444 445:- multifile 446 prolog:error_message/3. 447 448prologerror_message(process_error(File, exit(Status))) --> 449 [ 'Process "~w": exit status: ~w'-[File, Status] ]. 450prologerror_message(process_error(File, killed(Signal))) --> 451 [ 'Process "~w": killed by signal ~w'-[File, Signal] ]