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-2019, 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:- autoload(library(apply),[maplist/3]). 53:- autoload(library(error),[must_be/2,existence_error/2]). 54:- autoload(library(option),[select_option/3]). 55 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 * It is unclear what the detached(true) option is supposed to do. Disable 99 signals in the child? Use setsid() to detach from the session? The 100 current implementation uses setsid() on Unix systems. 101 102 * An extra option env([Name=Value, ...]) is added to 103 process_create/3. As of version 4.1 SICStus added 104 environment(List) which _modifies_ the environment. A 105 compatible option was added to SWI-Prolog 7.7.23. 106 107@tbd Implement detached option in process_create/3 108@compat SICStus 4 109*/ 110 111 112%! process_create(+Exe, +Args:list, +Options) is det. 113% 114% Create a new process running the file Exe and using arguments 115% from the given list. Exe is a file specification as handed to 116% absolute_file_name/3. Typically one use the =path= file alias to 117% specify an executable file on the current PATH. Args is a list 118% of arguments that are handed to the new process. On Unix 119% systems, each element in the list becomes a separate argument in 120% the new process. In Windows, the arguments are simply 121% concatenated to form the commandline. Each argument itself is 122% either a primitive or a list of primitives. A primitive is 123% either atomic or a term file(Spec). Using file(Spec), the system 124% inserts a filename using the OS filename conventions which is 125% properly quoted if needed. 126% 127% Options: 128% 129% * stdin(Spec) 130% * stdout(Spec) 131% * stderr(Spec) 132% Bind the standard streams of the new process. Spec is one of 133% the terms below. If pipe(Pipe) is used, the Prolog stream is 134% a stream in text-mode using the encoding of the default 135% locale. The encoding can be changed using set_stream/2, 136% or by using the two-argument form of =pipe=, which accepts an 137% encoding(Encoding) option. 138% The options =stdout= and =stderr= may use the same stream, 139% in which case both output streams are connected to the same 140% Prolog stream. 141% 142% * std 143% Just share with the Prolog I/O streams. On Unix, 144% if the `user_input`, etc. are bound to a file handle 145% but not to 0,1,2 the process I/O is bound to the file 146% handles of these streams. 147% * null 148% Bind to a _null_ stream. Reading from such a stream 149% returns end-of-file, writing produces no output 150% * pipe(-Stream) 151% * pipe(-Stream, +StreamOptions) 152% Attach input and/or output to a Prolog stream. 153% The optional StreamOptions argument is a list of options 154% that affect the stream. Currently only the options 155% type(+Type) and encoding(+Encoding) are supported, 156% which have the same meaning as the stream properties 157% of the same name (see stream_property/2). 158% StreamOptions is provided mainly for SICStus compatibility - 159% the SWI-Prolog predicate set_stream/2 can be used 160% for the same purpose. 161% * stream(+Stream) 162% Attach input or output to an existing Prolog stream. 163% This stream must be associated with an OS file 164% handle (see stream_property/2, property `file_no`). 165% This option is __not__ provided by the SICStus 166% implementation. 167% 168% * cwd(+Directory) 169% Run the new process in Directory. Directory can be a 170% compound specification, which is converted using 171% absolute_file_name/3. See also process_set_method/1. 172% * env(+List) 173% As environment(List), but _only_ the specified variables 174% are passed, i.e., no variables are _inherited_. 175% * environment(+List) 176% Specify _additional_ environment variables for the new process. 177% List is a list of `Name=Value` terms, where `Value` is expanded 178% the same way as the Args argument. If neither `env` nor 179% `environment` is passed the environment is inherited from the 180% Prolog process. 181% * process(-PID) 182% Unify PID with the process id of the created process. 183% * detached(+Bool) 184% In Unix: If =true=, detach the process from the terminal 185% Currently mapped to setsid(); 186% Also creates a new process group for the child 187% In Windows: If =true=, detach the process from the current 188% job via the CREATE_BREAKAWAY_FROM_JOB flag. In Vista and beyond, 189% processes launched from the shell directly have the 'compatibility 190% assistant' attached to them automatically unless they have a UAC 191% manifest embedded in them. This means that you will get a 192% permission denied error if you try and assign the newly-created 193% PID to a job you create yourself. 194% * window(+Bool) 195% If =true=, create a window for the process (Windows only) 196% * priority(+Priority) 197% In Unix: specifies the process priority for the newly 198% created process. Priority must be an integer between -20 199% and 19. Positive values are nicer to others, and negative 200% values are less so. The default is zero. Users are free to 201% lower their own priority. Only the super-user may _raise_ it 202% to less-than zero. 203% 204% If the user specifies the process(-PID) option, he *must* call 205% process_wait/2 to reclaim the process. Without this option, the 206% system will wait for completion of the process after the last 207% pipe stream is closed. 208% 209% If the process is not waited for, it must succeed with status 0. 210% If not, an process_error is raised. 211% 212% *|Windows notes|* 213% 214% On Windows this call is an interface to the CreateProcess() API. 215% The commandline consists of the basename of Exe and the 216% arguments formed from Args. Arguments are separated by a single 217% space. If all characters satisfy iswalnum() it is unquoted. If 218% the argument contains a double-quote it is quoted using single 219% quotes. If both single and double quotes appear a domain_error 220% is raised, otherwise double-quote are used. 221% 222% The CreateProcess() API has many options. Currently only the 223% =CREATE_NO_WINDOW= options is supported through the 224% window(+Bool) option. If omitted, the default is to use this 225% option if the application has no console. Future versions are 226% likely to support more window specific options and replace 227% win_exec/2. 228% 229% *Examples* 230% 231% First, a very simple example that behaves the same as 232% =|shell('ls -l')|=, except for error handling: 233% 234% == 235% ?- process_create(path(ls), ['-l'], []). 236% == 237% 238% The following example uses grep to find all matching lines in a 239% file. 240% 241% == 242% grep(File, Pattern, Lines) :- 243% setup_call_cleanup( 244% process_create(path(grep), [ Pattern, file(File) ], 245% [ stdout(pipe(Out)) 246% ]), 247% read_lines(Out, Lines), 248% close(Out)). 249% 250% read_lines(Out, Lines) :- 251% read_line_to_codes(Out, Line1), 252% read_lines(Line1, Out, Lines). 253% 254% read_lines(end_of_file, _, []) :- !. 255% read_lines(Codes, Out, [Line|Lines]) :- 256% atom_codes(Line, Codes), 257% read_line_to_codes(Out, Line2), 258% read_lines(Line2, Out, Lines). 259% == 260% 261% @error process_error(Exe, Status) where Status is one of 262% exit(Code) or killed(Signal). Raised if the process 263% is waited for (i.e., Options does not include 264% process(-PID)), and does not exit with status 0. 265% @bug On Windows, environment(List) is handled as env(List), 266% i.e., the environment is not inherited. 267 268process_create(Exe, Args, Options) :- 269 exe_options(ExeOptions), 270 absolute_file_name(Exe, PlProg, ExeOptions), 271 must_be(list, Args), 272 maplist(map_arg, Args, Av), 273 prolog_to_os_filename(PlProg, Prog), 274 Term =.. [Prog|Av], 275 expand_cwd_option(Options, Options1), 276 expand_env_option(env, Options1, Options2), 277 expand_env_option(environment, Options2, Options3), 278 process_create(Term, Options3). 279 280exe_options(Options) :- 281 current_prolog_flag(windows, true), 282 !, 283 Options = [ extensions(['',exe,com]), access(read) ]. 284exe_options(Options) :- 285 Options = [ access(execute) ]. 286 287expand_cwd_option(Options0, Options) :- 288 select_option(cwd(Spec), Options0, Options1), 289 !, 290 ( compound(Spec) 291 -> absolute_file_name(Spec, PlDir, [file_type(directory), access(read)]), 292 prolog_to_os_filename(PlDir, Dir), 293 Options = [cwd(Dir)|Options1] 294 ; exists_directory(Spec) 295 -> Options = Options0 296 ; existence_error(directory, Spec) 297 ). 298expand_cwd_option(Options, Options). 299 300expand_env_option(Name, Options0, Options) :- 301 Term =.. [Name,Value0], 302 select_option(Term, Options0, Options1), 303 !, 304 must_be(list, Value0), 305 maplist(map_env, Value0, Value), 306 NewOption =.. [Name,Value], 307 Options = [NewOption|Options1]. 308expand_env_option(_, Options, Options). 309 310map_env(Name=Value0, Name=Value) :- 311 map_arg(Value0, Value). 312 313%! map_arg(+ArgIn, -Arg) is det. 314% 315% Map an individual argument. Primitives are either file(Spec) or 316% an atomic value (atom, string, number). If ArgIn is a non-empty 317% list, all elements are converted and the results are 318% concatenated. 319 320map_arg([], []) :- !. 321map_arg(List, Arg) :- 322 is_list(List), 323 !, 324 maplist(map_arg_prim, List, Prims), 325 atomic_list_concat(Prims, Arg). 326map_arg(Prim, Arg) :- 327 map_arg_prim(Prim, Arg). 328 329map_arg_prim(file(Spec), File) :- 330 !, 331 ( compound(Spec) 332 -> absolute_file_name(Spec, PlFile) 333 ; PlFile = Spec 334 ), 335 prolog_to_os_filename(PlFile, File). 336map_arg_prim(Arg, Arg). 337 338 339%! process_id(-PID) is det. 340% 341% True if PID is the process id of the running Prolog process. 342% 343% @deprecated Use current_prolog_flag(pid, PID) 344 345process_id(PID) :- 346 current_prolog_flag(pid, PID). 347 348%! process_id(+Process, -PID) is det. 349% 350% PID is the process id of Process. Given that they are united in 351% SWI-Prolog, this is a simple unify. 352 353process_id(PID, PID). 354 355%! is_process(+PID) is semidet. 356% 357% True if PID might be a process. Succeeds for any positive 358% integer. 359 360is_process(PID) :- 361 integer(PID), 362 PID > 0. 363 364%! process_release(+PID) 365% 366% Release process handle. In this implementation this is the same 367% as process_wait(PID, _). 368 369process_release(PID) :- 370 process_wait(PID, _). 371 372%! process_wait(+PID, -Status) is det. 373%! process_wait(+PID, -Status, +Options) is det. 374% 375% True if PID completed with Status. This call normally blocks 376% until the process is finished. Options: 377% 378% * timeout(+Timeout) 379% Default: =infinite=. If this option is a number, the 380% waits for a maximum of Timeout seconds and unifies Status 381% with =timeout= if the process does not terminate within 382% Timeout. In this case PID is _not_ invalidated. On Unix 383% systems only timeout 0 and =infinite= are supported. A 384% 0-value can be used to poll the status of the process. 385% 386% * release(+Bool) 387% Do/do not release the process. We do not support this flag 388% and a domain_error is raised if release(false) is provided. 389% 390% @arg Status is one of exit(Code) or killed(Signal), where 391% Code and Signal are integers. If the `timeout` option 392% is used Status is unified with `timeout` after the wait 393% timed out. 394 395process_wait(PID, Status) :- 396 process_wait(PID, Status, []). 397 398%! process_kill(+PID) is det. 399%! process_kill(+PID, +Signal) is det. 400% 401% Send signal to process PID. Default is =term=. Signal is an 402% integer, Unix signal name (e.g. =SIGSTOP=) or the more Prolog 403% friendly variation one gets after removing =SIG= and downcase 404% the result: =stop=. On Windows systems, Signal is ignored and 405% the process is terminated using the TerminateProcess() API. On 406% Windows systems PID must be obtained from process_create/3, 407% while any PID is allowed on Unix systems. 408% 409% @compat SICStus does not accept the prolog friendly version. We 410% choose to do so for compatibility with on_signal/3. 411 412process_kill(PID) :- 413 process_kill(PID, term). 414 415 416%! process_group_kill(+PID) is det. 417%! process_group_kill(+PID, +Signal) is det. 418% 419% Send signal to the group containing process PID. Default is 420% =term=. See process_wait/1 for a description of signal 421% handling. In Windows, the same restriction on PID applies: it 422% must have been created from process_create/3, and the the group 423% is terminated via the TerminateJobObject API. 424 425process_group_kill(PID) :- 426 process_group_kill(PID, term). 427 428 429%! process_set_method(+Method) is det. 430% 431% Determine how the process is created on Unix systems. Method is one 432% of `spawn` (default), `fork` or `vfork`. If the method is `spawn` 433% but this cannot be used because it is either not supported by the OS 434% or the cwd(Dir) option is given `fork` is used. 435% 436% The problem is to be understood as follows. The official portable 437% and safe method to create a process is using the fork() system call. 438% This call however copies the process page tables and get seriously 439% slow as the (Prolog) process is multiple giga bytes large. 440% Alternatively, we may use vfork() which avoids copying the process 441% space. But, the safe usage as guaranteed by the POSIX standard of 442% vfork() is insufficient for our purposes. On practical systems your 443% mileage may vary. Modern posix systems also provide posix_spawn(), 444% which provides a safe and portable alternative for the fork() and 445% exec() sequence that may be implemented using fork() or may use a 446% fast but safe alternative. Unfortunately posix_spawn() doesn't 447% support the option to specify the working directory for the child 448% and we cannot use working_directory/2 as the working directory is 449% shared between threads. 450% 451% Summarizing, the default is safe and tries to be as fast as 452% possible. On some scenarios and on some OSes it is possible to do 453% better. It is generally a good idea to avoid using the cwd(Dir) 454% option of process_create/3 as without we can use posix_spawn(). 455 456 457 /******************************* 458 * MESSAGES * 459 *******************************/ 460 461:- multifile 462 prolog:error_message/3. 463 464prologerror_message(process_error(File, exit(Status))) --> 465 [ 'Process "~w": exit status: ~w'-[File, Status] ]. 466prologerror_message(process_error(File, killed(Signal))) --> 467 [ 'Process "~w": killed by signal ~w'-[File, Signal] ]