Source file eio_fs_chaos.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
96
97
98
99
100
101
102
103
104
105
open! Hermetic

type env = Eio_chaos.env
type Eio.Exn.Backend.t += Injected_fault = Wrapper.Injected_fault

module Op = Op
module Fault = Fault

(* {1 Wrapper} *)

let wrap f base =
  let hook ~space:_ op = f op in
  (Wrapper.wrap (Wrapper.schedule hook) base :> Eio.Fs.dir_ty Eio.Path.t)

(* {1 Power} *)

module Power = struct
  type change = Crash.unsynced

  let pp_change = Crash.pp_unsynced

  type policy = Lose_unsynced | Keep of (change -> bool)
  type t = Crash.t

  (* A controller built by hand may wrap a directory other processes write,
     so its cut keeps their changes. *)
  let v ?os = function
    | Lose_unsynced -> Crash.v ?os ~policy:Drop_unsynced ~outside:Kept ()
    | Keep p -> Crash.v ?os ~policy:(Survive p) ~outside:Kept ()

  let wrap t base = (Crash.wrap t base :> Eio.Fs.dir_ty Eio.Path.t)
  let unsynced = Crash.unsynced
  let cut = Crash.post_crash
end

(* {1 The check} *)

let name = "Eio_fs_chaos.run"
let disk = Disk.device

let run ?os ?budget ?seed ?replay ?setup ?inspect app =
  Eio_chaos.run ~name ?os ?budget ?seed ?replay ?setup ?inspect [ disk () ] app

let ack env file =
  let name = "Eio_fs_chaos.ack" in
  Ack.add name (Disk.acks name env) file

let acked env = Ack.acked (Disk.acks "Eio_fs_chaos.acked" env)

(* The devices a filesystem is built over, and a quiet disk unless one is. *)
let below under =
  if List.exists (fun p -> Eio_chaos.Private.name p = Disk.name) under then
    under
  else under @ [ Eio_chaos.quiet (disk ()) ]

let conformance ?os ?user ?(under = []) ?budget ?seed ?replay dir =
  let devices = below under in
  let run f = Eio_chaos.Private.within ?os devices f in
  if replay = None then Conformance.check ?os ?user ~run dir;
  if under <> [] then
    Eio_chaos.Private.run ~name:"Eio_fs_chaos.conformance" ~args:"dir"
      ~passes:[ Errors ] ?os ?budget ?seed ?replay devices
      (Conformance.program ?os ?user dir)

module Private = struct
  let check_faults ?os ?budget ?seed ?replay ?setup run =
    Eio_chaos.Private.run ~name ~passes:[ Errors ] ?os ?budget ?seed ?replay
      ?setup
      [ disk () ]
      run

  let check_cuts ?os ?budget ?seed ?replay ?setup run ~recover =
    let acked = ref [] in
    let app env =
      if Eio_chaos.Private.restarted env then
        recover ~acked:(List.rev !acked) env
      else begin
        acked := [];
        run
          ~ack:(fun v -> if Disk.acknowledge env then acked := v :: !acked)
          env
      end
    in
    Eio_chaos.Private.run ~name ~passes:[ Cuts ] ?os ?budget ?seed ?replay
      ?setup
      [ disk () ]
      app

  let scenarios = Conformance.scenarios
  let eio_posix_differs = Conformance.eio_posix_differs

  let conformance_differing ?os ?user dir =
    let run f = Eio_chaos.Private.within ?os (below []) f in
    Conformance.differing ?os ?user ~run dir

  let expected = Conformance.expected

  module Crash = Crash
  module Law = Law

  module Internal = struct
    let replay_copied () = Atomic.get Blocks.copied
    let descriptors = Memfs.descriptors
  end
end