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