Source file proc.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
(* [execve] doesn't exist on Windows, so instead we do a
   [Unix.create_process_env] followed by [Unix.waitpid] and finally [sys_exit].
   We use [sys_exit] rather than [exit] so that [at_exit] functions are not
   invoked. We don't want [at_exit] functions to be invoked to match the
   behaviour of [Unix.execve] on Unix. *)
external sys_exit : int -> 'a = "caml_sys_exit"

let restore_cwd_and_execve prog argv ~env =
  let env = Env.to_unix env |> Array.of_list in
  let argv = Array.of_list (prog :: argv) in
  (* run at_exit before changing the working directory *)
  Stdlib.do_at_exit ();
  Sys.chdir (Path.External.to_string Path.External.initial_cwd);
  if Sys.win32 || Platform.OS.value = Platform.OS.Haiku
  then (
    let pid = Unix.create_process_env prog argv env Unix.stdin Unix.stdout Unix.stderr in
    match snd (Unix.waitpid [] pid) with
    | WEXITED n -> sys_exit n
    | WSIGNALED _ -> sys_exit 255
    | WSTOPPED _ -> assert false)
  else (
    ignore (Unix.sigprocmask SIG_SETMASK [] : int list);
    Unix.execve prog argv env)
;;

module Resource_usage = struct
  type t =
    { user_cpu_time : Time.Span.t
    ; system_cpu_time : Time.Span.t
    ; maxrss : int
    ; minflt : int
    ; majflt : int
    ; inblock : int
    ; oublock : int
    ; nvcsw : int
    ; nivcsw : int
    }

  let zero =
    { user_cpu_time = Time.Span.zero
    ; system_cpu_time = Time.Span.zero
    ; maxrss = 0
    ; minflt = 0
    ; majflt = 0
    ; inblock = 0
    ; oublock = 0
    ; nvcsw = 0
    ; nivcsw = 0
    }
  ;;
end

module Times = struct
  type t =
    { elapsed_time : Time.Span.t
    ; resource_usage : Resource_usage.t option
    }
end

module Process_info = struct
  type t =
    { pid : Pid.t
    ; status : Unix.process_status
    ; end_time : Time.t
    ; resource_usage : Resource_usage.t option
    }
end

external stub_wait4
  :  int
  -> Unix.wait_flag list
  -> (int * Unix.process_status * int * Resource_usage.t) option
  = "dune_wait4"

type wait =
  | Any
  | Pid of Pid.t

let wait wait flags =
  if Sys.win32
  then Code_error.raise "wait4 not available on windows" []
  else (
    let pid =
      match wait with
      | Any -> -1
      | Pid pid -> Pid.to_int pid
    in
    stub_wait4 pid flags
    |> Option.map ~f:(fun (pid, status, end_time, resource_usage) ->
      { Process_info.pid = Pid.of_int pid
      ; status
      ; end_time = Time.of_ns end_time
      ; resource_usage = Some resource_usage
      }))
;;