commit dbdee1417c83a22d1b09f1296cb2e9cb3d794f11 · patrick.sirref.org/opentrace

.gitignore

+11 -2

dune

···

       1
       1
       +
       (menhir

     

       2
       2
       +
        (modules parser))

     

       3
       3
       +
       

     

       4
       4
       +
       (ocamllex lexer)

     

       5
       5
       +
       

     

       1
       6
        
       (executable

     

       2
       7
        
        (name opentrace)

     

       3
       8
        
        (public_name opentrace)

     

       4
       4
       -
        (modules opentrace config)

     

       9
       9
       +
        (modules opentrace config parser filter lexer spawn)

     

       10
       10
       +
        (foreign_stubs

     

       11
       11
       +
         (language c)

     

       12
       12
       +
         (flags :standard -D_LARGEFILE64_SOURCE)

     

       13
       13
       +
         (names opentrace_stubs))

     

       5
       14
        
        (preprocess

     

       6
       15
        
         (pps ppx_blob))

     

       7
       16
        
        (preprocessor_deps

     

       8
       17
        
         (file opentrace.bpf.o))

     

       9
       9
       -
        (libraries eio_main jsonm cmdliner unix libbpf libbpf_maps))

     

       18
       18
       +
        (libraries eio_posix jsonm cmdliner unix libbpf libbpf_maps))

     

       10
       19
        
       

     

       11
       20
        
       (rule

     

       12
       21
        
        (mode

dune-project

···

       1
       1
        
       (lang dune 3.14)

     

       2
       2
       +
       (using menhir 3.0)

     

       2
       3
        
       

     

       3
       4
        
       (name opentrace)

     

       4
       5

example/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (name main)

     

       3
       3
       +
        (libraries eio_main))

example/main.ml

···

       1
       1
       +
       let () =

     

       2
       2
       +
         Eio_main.run @@ fun env ->

     

       3
       3
       +
         Eio.Path.(save ~create:(`Or_truncate 0o664) (env#fs / "hello.txt") "hello");

     

       4
       4
       +
         Eio.Process.run env#process_mgr

     

       5
       5
       +
           [ "/bin/bash"; "-c"; "echo 'heya' > heya.txt" ]

+18

filter.ml

···

       1
       1
       +
       type t = Flag of int | And of t * t | Or of t * t | Not of t

     

       2
       2
       +
       

     

       3
       3
       +
       let rec pp ppf = function

     

       4
       4
       +
         | Flag s -> Fmt.string ppf (Config.to_string s)

     

       5
       5
       +
         | And (e1, e2) -> Fmt.pf ppf "%a&%a" pp e1 pp e2

     

       6
       6
       +
         | Or (e1, e2) -> Fmt.pf ppf "%a|%a" pp e1 pp e2

     

       7
       7
       +
         | Not e1 -> Fmt.pf ppf "~%a" pp e1

     

       8
       8
       +
       

     

       9
       9
       +
       let check_flag i t = Int.equal (t land i) i

     

       10
       10
       +
       

     

       11
       11
       +
       let satisfies (expr : t) flags =

     

       12
       12
       +
         let rec loop = function

     

       13
       13
       +
           | Flag s -> check_flag s flags

     

       14
       14
       +
           | Not e -> not (loop e)

     

       15
       15
       +
           | And (e1, e2) -> loop e1 && loop e2

     

       16
       16
       +
           | Or (e1, e2) -> loop e1 || loop e2

     

       17
       17
       +
         in

     

       18
       18
       +
         loop expr

+20

lexer.mll

···

       1
       1
       +
       {

     

       2
       2
       +
       open Parser

     

       3
       3
       +
       

     

       4
       4
       +
       exception SyntaxError of string

     

       5
       5
       +
       }

     

       6
       6
       +
       

     

       7
       7
       +
       let white = [' ' '\t']+

     

       8
       8
       +
       let id = ['a'-'z' 'A'-'Z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']*

     

       9
       9
       +
       

     

       10
       10
       +
       rule read =

     

       11
       11
       +
         parse

     

       12
       12
       +
         | white    { read lexbuf }

     

       13
       13
       +
         | id as s  { FLAG s }

     

       14
       14
       +
         | '('      { LPAREN }

     

       15
       15
       +
         | ')'      { RPAREN }

     

       16
       16
       +
         | '&'      { AND }

     

       17
       17
       +
         | '|'      { OR }

     

       18
       18
       +
         | '~'      { NOT }

     

       19
       19
       +
         | _ { raise (SyntaxError ("Unexpected char: " ^ Lexing.lexeme lexbuf)) }

     

       20
       20
       +
         | eof      { EOF }

+101 -7

opentrace.bpf.c

···

       1
       1
        
       #include "vmlinux.h"

     

       2
       2
       +
       #include "uring.h"

     

       2
       3
        
       #include <bpf/bpf_helpers.h>

     

       4
       4
       +
       #include <bpf/bpf_tracing.h>

     

       5
       5
       +
       #include <bpf/bpf_core_read.h>

     

       3
       6
        
       

     

       4
       7
        
       char LICENSE[] SEC("license") = "Dual BSD/GPL";

     

       5
       8
        
       

     
···

       16
       19
        
       #define OPEN_KIND 0

     

       17
       20
        
       #define OPENAT_KIND 1

     

       18
       21
        
       #define OPENAT2_KIND 2

     

       22
       22
       +
       #define URING_KIND 3

     

       19
       23
        
       

     

       20
       24
        
       // An open event

     

       21
       25
        
       struct open_event

     
···

       35
       39
        
       struct {

     

       36
       40
        
       	__uint(type, BPF_MAP_TYPE_HASH);

     

       37
       41
        
       	__uint(max_entries, 10240);

     

       38
       38
       -
       	__type(key, u32);                   // PID

     

       42
       42
       +
       	__type(key, u32);                   // PID/User Data

     

       39
       43
        
       	__type(value, struct open_event);   // The event

     

       40
       44
        
       } tmpmap SEC(".maps");

     

       41
       45
        
       

     
···

       75
       79
        
       	

     

       76
       80
        
       	// Add it to the hash map

     

       77
       81
        
       	bpf_map_update_elem(&tmpmap, &pid, &oet, BPF_NOEXIST);

     

       78
       78
       -
       

     

       79
       82
        
           return 0;

     

       80
       83
        
       }

     

       81
       84
        
       

     
···

       99
       102
        
           return 0;

     

       100
       103
        
       }

     

       101
       104
        
       

     

       102
       102
       -
       // SEC("tracepoint/syscalls/sys_exit_open")

     

       103
       103
       -
       // int tracepoint__syscalls__sys_exit_open(struct syscall_trace_exit* ctx)

     

       104
       104
       -
       // {

     

       105
       105
       -
       // 	return complete_event(OPEN_KIND, ctx);

     

       106
       106
       -
       // }

     

       107
       105
        
       

     

       108
       106
        
       SEC("tracepoint/syscalls/sys_exit_openat")

     

       109
       107
        
       int tracepoint__syscalls__sys_exit_openat(struct syscall_trace_exit* ctx)

     
···

       147
       145
        
       SEC("tracepoint/syscalls/sys_exit_openat2")

     

       148
       146
        
       int tracepoint__syscalls__sys_exit_openat2(struct syscall_trace_exit* ctx)

     

       149
       147
        
       {

     

       148
       148
       +
       	struct open_event *ev;

     

       149
       149
       +
           u64 id = bpf_get_current_pid_tgid();

     

       150
       150
       +
           u32 pid = id >> 32;

     

       151
       151
       +
       

     

       152
       152
       +
       	struct open_event *oet;

     

       153
       153
       +
       	oet = bpf_ringbuf_reserve(&rb, sizeof(struct open_event), 0);

     

       154
       154
       +
       	if (!oet)

     

       155
       155
       +
       		return 0;

     

       156
       156
       +
       

     

       157
       157
       +
       	// Find our event

     

       158
       158
       +
       	ev = bpf_map_lookup_elem(&tmpmap, &pid);

     

       159
       159
       +
       	if (!ev) {

     

       160
       160
       +
       		// Tidy up

     

       161
       161
       +
       		bpf_ringbuf_discard(oet, 0);

     

       162
       162
       +
       		bpf_map_delete_elem(&tmpmap, &pid);

     

       163
       163
       +
       		return 0;

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	oet->e_ret = ctx->ret;

     

       167
       167
       +
       	oet->e_cgid = bpf_get_current_cgroup_id();

     

       168
       168
       +
       	bpf_probe_read_str(&oet->e_filename, sizeof(oet->e_filename), ev->e_filename);

     

       169
       169
       +
       	bpf_get_current_comm(oet->e_comm, TASK_COMM_LEN);

     

       170
       170
       +
       	oet->e_flags = ev->e_flags;

     

       171
       171
       +
       	oet->e_pid = pid;

     

       172
       172
       +
       	oet->e_mode = ev->e_mode;

     

       173
       173
       +
       	oet->e_kind = OPENAT2_KIND;

     

       174
       174
       +
       

     

       175
       175
       +
       	// Tidy up

     

       176
       176
       +
           bpf_map_delete_elem(&tmpmap, &pid);

     

       177
       177
       +
       	

     

       178
       178
       +
       	/* emit event */

     

       179
       179
       +
       	bpf_ringbuf_submit(oet, 0);

     

       180
       180
       +
       

     

       150
       181
        
       	return 0;

     

       151
       182
        
       }

     

       183
       183
       +
       

     

       184
       184
       +
       /* IO_URING is not so clean :S */

     

       185
       185
       +
       SEC("kprobe/io_openat2")

     

       186
       186
       +
       int BPF_KPROBE(trace_io_uring_openat_entry, struct io_kiocb *req, int issue_flags)

     

       187
       187
       +
       {

     

       188
       188
       +
           struct io_open open;

     

       189
       189
       +
       	int res = bpf_probe_read(&open, sizeof(open), req);

     

       190
       190
       +
       	if (res != 0) {

     

       191
       191
       +
       	  static const char fmt[] = "openat read failed %i\n"; 

     

       192
       192
       +
             bpf_trace_printk(fmt, sizeof(fmt), res);

     

       193
       193
       +
             return 0;

     

       194
       194
       +
       	}

     

       195
       195
       +
           struct task_struct *task = (struct task_struct *)bpf_get_current_task_btf();

     

       196
       196
       +
           char commit[TASK_COMM_LEN];

     

       197
       197
       +
       

     

       198
       198
       +
       	bpf_get_current_comm(&commit, TASK_COMM_LEN);

     

       199
       199
       +
       

     

       200
       200
       +
           u64 pid_tgid = bpf_get_current_pid_tgid();

     

       201
       201
       +
          

     

       202
       202
       +
       	struct open_event oet = {0};

     

       203
       203
       +
           struct open_how how = {0};

     

       204
       204
       +
       	bpf_probe_read_user(&how, sizeof(how), (void *)&open.how);

     

       205
       205
       +
       	oet.e_flags = (int)open.how.flags;

     

       206
       206
       +
       	oet.e_mode = (__u32)open.how.mode;

     

       207
       207
       +
       	oet.e_filename[0] = '\0';

     

       208
       208
       +
       

     

       209
       209
       +
       	bpf_map_update_elem(&tmpmap, &pid_tgid, &oet, BPF_ANY);

     

       210
       210
       +
           return 0;

     

       211
       211
       +
       }

     

       212
       212
       +
       

     

       213
       213
       +
       // Return probe

     

       214
       214
       +
       SEC("kretprobe/io_openat2")

     

       215
       215
       +
       int BPF_KRETPROBE(trace_io_uring_openat_ret)

     

       216
       216
       +
       {

     

       217
       217
       +
           u64 pid_tgid = bpf_get_current_pid_tgid();

     

       218
       218
       +
           

     

       219
       219
       +
           struct open_event *ev = bpf_map_lookup_elem(&tmpmap, &pid_tgid);

     

       220
       220
       +
           if (!ev) {

     

       221
       221
       +
       		static const char fmt[] = "no event\n"; 

     

       222
       222
       +
               bpf_trace_printk(fmt, sizeof(fmt));

     

       223
       223
       +
               return 0;

     

       224
       224
       +
       	}

     

       225
       225
       +
       

     

       226
       226
       +
           struct open_event *oet = bpf_ringbuf_reserve(&rb, sizeof(struct open_event), 0);

     

       227
       227
       +
           if (!oet)

     

       228
       228
       +
               return 0;

     

       229
       229
       +
       

     

       230
       230
       +
       	bpf_get_current_comm(oet->e_comm, TASK_COMM_LEN);

     

       231
       231
       +
       	static const char fmt[] = "opening %s\n"; 

     

       232
       232
       +
       	bpf_trace_printk(fmt, sizeof(fmt), ev->e_filename);

     

       233
       233
       +
       

     

       234
       234
       +
       	oet->e_ret = 0; // TODO: PT_REGS_RC(ctx); 

     

       235
       235
       +
       	oet->e_cgid = bpf_get_current_cgroup_id();

     

       236
       236
       +
       	bpf_probe_read_str(&oet->e_filename, sizeof(oet->e_filename), ev->e_filename);

     

       237
       237
       +
       	oet->e_flags = ev->e_flags;

     

       238
       238
       +
       	oet->e_mode = ev->e_mode;

     

       239
       239
       +
       	oet->e_kind = URING_KIND;

     

       240
       240
       +
           oet->e_pid = pid_tgid >> 32;

     

       241
       241
       +
       

     

       242
       242
       +
           bpf_ringbuf_submit(oet, 0);

     

       243
       243
       +
           bpf_map_delete_elem(&tmpmap, &pid_tgid);

     

       244
       244
       +
           return 0;

     

       245
       245
       +
       }

+79 -31

opentrace.ml

···

       12
       12
        
           "tracepoint__syscalls__sys_enter_openat2";

     

       13
       13
        
           "tracepoint__syscalls__sys_exit_openat";

     

       14
       14
        
           "tracepoint__syscalls__sys_exit_openat2";

     

       15
       15
       +
           "trace_io_uring_openat_entry";

     

       16
       16
       +
           "trace_io_uring_openat_ret";

     

       15
       17
        
         ]

     

       16
       18
        
       

     

       17
       19
        
       let json_to_lexemes json : Jsonm.lexeme list =

     
···

       29
       31
        
         loop [] json |> List.rev

     

       30
       32
        
       

     

       31
       33
        
       module Flags = struct

     

       32
       32
       -
         type t = int

     

       33
       33
       -
       

     

       34
       34
        
         include Config

     

       35
       35
       -
       

     

       36
       36
       -
         let mem (v : t) i = Int.equal (i land (v :> int)) (v :> int)

     

       37
       35
        
       end

     

       38
       36
        
       

     

       37
       37
       +
       let print_position ppf lexbuf =

     

       38
       38
       +
         let open Lexing in

     

       39
       39
       +
         let pos = lexbuf.lex_curr_p in

     

       40
       40
       +
         Fmt.pf ppf "%s:%d:%d" pos.pos_fname pos.pos_lnum

     

       41
       41
       +
           (pos.pos_cnum - pos.pos_bol + 1)

     

       42
       42
       +
       

     

       43
       43
       +
       let parse_with_error lexbuf =

     

       44
       44
       +
         try Ok (Parser.filter Lexer.read lexbuf) with

     

       45
       45
       +
         | Lexer.SyntaxError msg ->

     

       46
       46
       +
             Error (Fmt.str "%a: %s\n" print_position lexbuf msg)

     

       47
       47
       +
         | Parser.Error -> Error (Fmt.str "%a: syntax error\n" print_position lexbuf)

     

       48
       48
       +
       

     

       49
       49
       +
       let filter_of_string s =

     

       50
       50
       +
         let lex = Lexing.from_string s in

     

       51
       51
       +
         let filter = parse_with_error lex in

     

       52
       52
       +
         Result.iter (Fmt.pr "filter: %a\n%!" Filter.pp) filter;

     

       53
       53
       +
         filter

     

       54
       54
       +
       

     

       39
       55
        
       module Open_event = struct

     

       40
       56
        
         open Ctypes

     

       41
       57
        
       

     

       42
       58
        
         type t

     

       43
       43
       -
         type kind = Open_ | Openat | Openat2

     

       59
       59
       +
         type kind = Open_ | Openat | Openat2 | Uring

     

       44
       60
        
       

     

       45
       61
        
         let kind_to_string = function

     

       46
       62
        
           | Open_ -> "open"

     

       47
       63
        
           | Openat -> "openat"

     

       48
       64
        
           | Openat2 -> "openat2"

     

       65
       65
       +
           | Uring -> "Uring"

     

       49
       66
        
       

     

       50
       67
        
         let kind_of_int = function

     

       51
       68
        
           | 0 -> Open_

     

       52
       69
        
           | 1 -> Openat

     

       53
       70
        
           | 2 -> Openat2

     

       71
       71
       +
           | 3 -> Uring

     

       54
       72
        
           | n -> failwith ("Invalid kind of open syscall: " ^ string_of_int n)

     

       55
       73
        
       

     

       56
       74
        
         let t : t structure typ = Ctypes.structure "event"

     
···

       138
       156
        
         bpf_callback

     

       139
       157
        
       

     

       140
       158
        
       let filter_event_by_flag event flags =

     

       141
       141
       -
         flags = []

     

       142
       142
       -
         ||

     

       143
       143
       -
         let fs = Open_event.get_flags event in

     

       144
       144
       -
         List.for_all (fun flag -> Flags.mem flag fs) flags

     

       159
       159
       +
         match flags with

     

       160
       160
       +
         | None -> true

     

       161
       161
       +
         | Some f -> Filter.satisfies f (Open_event.get_flags event)

     

       145
       162
        
       

     

       146
       163
        
       let all poll no_header open_flags =

     

       147
       164
        
         if no_header then () else Format.printf "%s" Open_event.csv_header;

     
···

       153
       170
        
         let bpf_callback = ringbuffer_polling_callback ~poll callback (fun _ -> ()) in

     

       154
       171
        
         run_ring_buffer bpf_callback

     

       155
       172
        
       

     

       156
       156
       -
       let exec format output user poll (prog, args) open_flags_filter =

     

       173
       173
       +
       let with_cgroup flag fn =

     

       174
       174
       +
         if not flag then fn None

     

       175
       175
       +
         else

     

       176
       176
       +
           let filename =

     

       177
       177
       +
             Filename.temp_dir ~temp_dir:"/sys/fs/cgroup" "opentrace-" ""

     

       178
       178
       +
           in

     

       179
       179
       +
           Fun.protect

     

       180
       180
       +
             ~finally:(fun () -> Sys.rmdir filename)

     

       181
       181
       +
             (fun () -> fn (Some (Filename.concat filename "cgroup.procs")))

     

       182
       182
       +
       

     

       183
       183
       +
       let exec format output user poll (prog, args) open_flags_filter cgroups =

     

       157
       184
        
         let output =

     

       158
       185
        
           match output with

     

       159
       186
        
           | Some file -> file

     
···

       174
       201
        
         let mutex = Mutex.create () in

     

       175
       202
        
         let pid = Atomic.make None in

     

       176
       203
        
         let exit_status = Atomic.make None in

     

       204
       204
       +
         let cgroup = Atomic.make None in

     

       177
       205
        
         let _domain =

     

       178
       206
        
           Domain.spawn @@ fun () ->

     

       179
       179
       -
           Eio_main.run @@ fun env ->

     

       180
       180
       -
           Mutex.lock mutex;

     

       181
       181
       -
           Condition.wait start_process mutex;

     

       182
       182
       -
           Eio.Switch.run @@ fun sw ->

     

       183
       183
       -
           let p =

     

       184
       184
       -
             Eio.Process.spawn ~sw ~uid (Eio.Stdenv.process_mgr env) (prog :: args)

     

       185
       185
       -
           in

     

       186
       186
       -
           Atomic.set pid (Some (Eio.Process.pid p));

     

       187
       187
       -
           let status = Eio.Process.await p in

     

       188
       188
       -
           Atomic.set exit_status (Some status)

     

       207
       207
       +
           Eio_posix.run @@ fun env ->

     

       208
       208
       +
           try

     

       209
       209
       +
             Mutex.lock mutex;

     

       210
       210
       +
             Condition.wait start_process mutex;

     

       211
       211
       +
             Eio.Switch.run @@ fun sw ->

     

       212
       212
       +
             with_cgroup cgroups @@ fun group ->

     

       213
       213
       +
             let process = Spawn.make_process group (Some uid) in

     

       214
       214
       +
             let p = Eio.Process.spawn process ~sw (prog :: args) in

     

       215
       215
       +
             Atomic.set pid (Some (Eio.Process.pid p));

     

       216
       216
       +
             let stat =

     

       217
       217
       +
               Option.map

     

       218
       218
       +
                 (fun c ->

     

       219
       219
       +
                   Eio.Path.stat ~follow:true Eio.Path.(env#fs / Filename.dirname c))

     

       220
       220
       +
                 group

     

       221
       221
       +
             in

     

       222
       222
       +
             Option.iter (fun v -> Fmt.pr "INO %Ld\n" v.Eio.File.Stat.ino) stat;

     

       223
       223
       +
             Atomic.set cgroup (Option.map (fun v -> v.Eio.File.Stat.ino) stat);

     

       224
       224
       +
             let status = Eio.Process.await p in

     

       225
       225
       +
             Atomic.set exit_status (Some status)

     

       226
       226
       +
           with e ->

     

       227
       227
       +
             Mutex.unlock mutex;

     

       228
       228
       +
             Fmt.epr "Error creating process %s\n" (Printexc.to_string e);

     

       229
       229
       +
             Atomic.set exit_status (Some (`Exited (-1)))

     

       189
       230
        
         in

     

       190
       231
        
         Out_channel.with_open_bin output @@ fun oc ->

     

       191
       232
        
         let encoder = Jsonm.encoder ~minify:false (`Channel oc) in

     
···

       202
       243
        
           | Json -> encode `As

     

       203
       244
        
         in

     

       204
       245
        
         let callback event =

     

       205
       205
       -
           match Atomic.get pid with

     

       206
       206
       -
           | None -> 0

     

       207
       207
       -
           | Some pid ->

     

       246
       246
       +
           match (Atomic.get cgroup, Atomic.get pid) with

     

       247
       247
       +
           | _, None -> 0

     

       248
       248
       +
           | _, Some pid ->

     

       208
       249
        
               (if

     

       209
       209
       -
                  Int.equal (Open_event.get_pid event) pid

     

       250
       250
       +
                  (if cgroups then

     

       251
       251
       +
                     Int64.equal

     

       252
       252
       +
                       (Open_event.get_cgid event)

     

       253
       253
       +
                       (Option.get (Atomic.get cgroup))

     

       254
       254
       +
                   else Int.equal (Open_event.get_pid event) pid)

     

       210
       255
        
                  && filter_event_by_flag event open_flags_filter

     

       211
       256
        
                then

     

       212
       257
        
                  match format with

     
···

       245
       290
        
       let no_header =

     

       246
       291
        
         let doc = "Disable printing the CSV header" in

     

       247
       292
        
         Arg.(value & flag & info [ "no-header" ] ~doc)

     

       293
       293
       +
       

     

       294
       294
       +
       let cgroups =

     

       295
       295
       +
         let doc = "Enable cgroup creation and tracing" in

     

       296
       296
       +
         Arg.(value & flag & info [ "cgroups" ] ~doc)

     

       248
       297
        
       

     

       249
       298
        
       let flag_conv =

     

       250
       250
       -
         let of_string s =

     

       251
       251
       -
           try Ok (Flags.of_string s) with Invalid_argument m -> Error (`Msg m)

     

       252
       252
       -
         in

     

       253
       253
       -
         let pp ppf v = Format.pp_print_string ppf (Flags.to_string v) in

     

       254
       254
       -
         Arg.conv (of_string, pp)

     

       299
       299
       +
         let of_string s = filter_of_string s in

     

       300
       300
       +
         let pp = Filter.pp in

     

       301
       301
       +
         Arg.conv' (of_string, pp)

     

       255
       302
        
       

     

       256
       303
        
       let open_flags_filter =

     

       257
       304
        
         let doc =

     
···

       259
       306
        
            Note the filter wants ALL of the flags to be present not just one of \

     

       260
       307
        
            them."

     

       261
       308
        
         in

     

       262
       262
       -
         Arg.(value & opt (list flag_conv) [] & info [ "flags" ] ~doc)

     

       309
       309
       +
         Arg.(value & opt (some flag_conv) None & info [ "flags" ] ~doc)

     

       263
       310
        
       

     

       264
       311
        
       let user =

     

       265
       312
        
         let doc = "Username or UID to execute program as" in

     
···

       323
       370
        
         and+ output = output

     

       324
       371
        
         and+ args = Arg.(value & pos_right 0 string [] & Arg.info [] ~docv:"ARGS")

     

       325
       372
        
         and+ open_flags_filter = open_flags_filter

     

       373
       373
       +
         and+ cgroups = cgroups

     

       326
       374
        
         and+ poll = polling in

     

       327
       327
       -
         exec format output user poll (prog, args) open_flags_filter

     

       375
       375
       +
         exec format output user poll (prog, args) open_flags_filter cgroups

     

       328
       376
        
       

     

       329
       377
        
       let opentrace_cmd =

     

       330
       378
        
         let doc = "Trace all open system calls" in

+56

opentrace_stubs.c

···

       1
       1
       +
       #include <stdlib.h>

     

       2
       2
       +
       #include <unistd.h>

     

       3
       3
       +
       #include <fcntl.h>

     

       4
       4
       +
       #include <string.h>

     

       5
       5
       +
       #include <errno.h>

     

       6
       6
       +
       

     

       7
       7
       +
       #include <caml/mlvalues.h>

     

       8
       8
       +
       #include <caml/unixsupport.h>

     

       9
       9
       +
       #include <caml/memory.h>

     

       10
       10
       +
       #include <caml/custom.h>

     

       11
       11
       +
       #include <caml/fail.h>

     

       12
       12
       +
       

     

       13
       13
       +
       #include "include/fork_action.h"

     

       14
       14
       +
       

     

       15
       15
       +
       static void action_setuid(int errors, value v_config) {

     

       16
       16
       +
         #ifdef _WIN32

     

       17
       17
       +
         eio_unix_fork_error(errors, "action_setuid", "Unsupported operation on windows");

     

       18
       18
       +
         #else

     

       19
       19
       +
         value v_uid = Field(v_config, 1);

     

       20
       20
       +
         int r;

     

       21
       21
       +
         r = setuid(Int_val(v_uid));

     

       22
       22
       +
         if (r != 0) {

     

       23
       23
       +
           eio_unix_fork_error(errors, "setuid", strerror(errno));

     

       24
       24
       +
           _exit(1);

     

       25
       25
       +
         }

     

       26
       26
       +
         #endif

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       CAMLprim value eio_unix_fork_setuid(value v_unit) {

     

       30
       30
       +
         return Val_fork_fn(action_setuid);

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       static void action_setcgroup(int errors, value v_config) {

     

       34
       34
       +
         value v_path = Field(v_config, 1);

     

       35
       35
       +
       

     

       36
       36
       +
         int r;

     

       37
       37
       +
         pid_t pid = getpid();

     

       38
       38
       +
         FILE *f = fopen(String_val(v_path), "w");

     

       39
       39
       +
         if (f == NULL) {

     

       40
       40
       +
       	  eio_unix_fork_error(errors, "cgroup", strerror(errno));

     

       41
       41
       +
       	  _exit(1);

     

       42
       42
       +
         }

     

       43
       43
       +
       

     

       44
       44
       +
         if (fprintf(f, "%d\n", pid) < 0) {

     

       45
       45
       +
       	fclose(f);

     

       46
       46
       +
       	eio_unix_fork_error(errors, "cgroup", strerror(errno));

     

       47
       47
       +
       	_exit(1);

     

       48
       48
       +
         }

     

       49
       49
       +
       

     

       50
       50
       +
         fclose(f);

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       CAMLprim value eio_unix_fork_setcgroup(value v_unit) {

     

       54
       54
       +
         return Val_fork_fn(action_setcgroup);

     

       55
       55
       +
       }

     

       56
       56
       +

+21

parser.mly

···

       1
       1
       +
       %token <string> FLAG

     

       2
       2
       +
       %token LPAREN RPAREN

     

       3
       3
       +
       %token OR AND

     

       4
       4
       +
       %token NOT

     

       5
       5
       +
       %token EOF

     

       6
       6
       +
       %left OR

     

       7
       7
       +
       %left AND

     

       8
       8
       +
       %nonassoc NOT

     

       9
       9
       +
       

     

       10
       10
       +
       %start <Filter.t> filter

     

       11
       11
       +
       %%

     

       12
       12
       +
       

     

       13
       13
       +
       filter:

     

       14
       14
       +
         | f = expr; EOF { f }

     

       15
       15
       +
       

     

       16
       16
       +
       expr:

     

       17
       17
       +
         | f = FLAG                   { Filter.Flag (Config.of_string f) }

     

       18
       18
       +
         | LPAREN; e = expr; RPAREN   { e }

     

       19
       19
       +
         | e1 = expr; AND; e2 = expr  { Filter.And (e1, e2) }

     

       20
       20
       +
         | e1 = expr; OR; e2 = expr   { Filter.Or (e1, e2) }

     

       21
       21
       +
         | NOT; e = expr              { Filter.Not e }

+88

spawn.ml

···

       1
       1
       +
       open Eio_posix

     

       2
       2
       +
       open Eio.Std

     

       3
       3
       +
       

     

       4
       4
       +
       type (_, _, _) Eio.Resource.pi +=

     

       5
       5
       +
         | Posix_dir : ('t, 't -> Low_level.dir_fd, [> `Posix_dir ]) Eio.Resource.pi

     

       6
       6
       +
       

     

       7
       7
       +
       let as_posix_dir (Eio.Resource.T (t, ops)) =

     

       8
       8
       +
         match Eio.Resource.get_opt ops Posix_dir with

     

       9
       9
       +
         | None -> None

     

       10
       10
       +
         | Some fn -> Some (fn t)

     

       11
       11
       +
       

     

       12
       12
       +
       module Process_impl = struct

     

       13
       13
       +
         type t = Low_level.Process.t

     

       14
       14
       +
         type tag = [ `Generic | `Unix ]

     

       15
       15
       +
       

     

       16
       16
       +
         let pid = Low_level.Process.pid

     

       17
       17
       +
       

     

       18
       18
       +
         let await t =

     

       19
       19
       +
           match Eio.Promise.await @@ Low_level.Process.exit_status t with

     

       20
       20
       +
           | Unix.WEXITED i -> `Exited i

     

       21
       21
       +
           | Unix.WSIGNALED i -> `Signaled i

     

       22
       22
       +
           | Unix.WSTOPPED _ -> assert false

     

       23
       23
       +
       

     

       24
       24
       +
         let signal = Low_level.Process.signal

     

       25
       25
       +
       end

     

       26
       26
       +
       

     

       27
       27
       +
       let process =

     

       28
       28
       +
         let handler = Eio.Process.Pi.process (module Process_impl) in

     

       29
       29
       +
         fun proc -> Eio.Resource.T (proc, handler)

     

       30
       30
       +
       

     

       31
       31
       +
       module T = struct

     

       32
       32
       +
         type t = unit

     

       33
       33
       +
       

     

       34
       34
       +
         external action_setuid : unit -> Eio_unix.Private.Fork_action.fork_fn

     

       35
       35
       +
           = "eio_unix_fork_setuid"

     

       36
       36
       +
       

     

       37
       37
       +
         let action_setuid = action_setuid ()

     

       38
       38
       +
       

     

       39
       39
       +
         let setuid (uid : int) =

     

       40
       40
       +
           Eio_unix.Private.Fork_action.

     

       41
       41
       +
             { run = (fun k -> k (Obj.repr (action_setuid, uid))) }

     

       42
       42
       +
       

     

       43
       43
       +
         external action_setcgroup : unit -> Eio_unix.Private.Fork_action.fork_fn

     

       44
       44
       +
           = "eio_unix_fork_setcgroup"

     

       45
       45
       +
       

     

       46
       46
       +
         let action_setcgroup = action_setcgroup ()

     

       47
       47
       +
       

     

       48
       48
       +
         let setcgroup group =

     

       49
       49
       +
           Eio_unix.Private.Fork_action.

     

       50
       50
       +
             { run = (fun k -> k (Obj.repr (action_setcgroup, group))) }

     

       51
       51
       +
       

     

       52
       52
       +
         let spawn_unix () ~group ~uid ~sw ?cwd ~env ~fds ~executable args =

     

       53
       53
       +
           let actions =

     

       54
       54
       +
             Low_level.Process.Fork_action.

     

       55
       55
       +
               [ inherit_fds fds; execve executable ~argv:(Array.of_list args) ~env ]

     

       56
       56
       +
           in

     

       57
       57
       +
           let actions =

     

       58
       58
       +
             match uid with None -> actions | Some uid -> setuid uid :: actions

     

       59
       59
       +
           in

     

       60
       60
       +
           let actions =

     

       61
       61
       +
             match group with None -> actions | Some g -> setcgroup g :: actions

     

       62
       62
       +
           in

     

       63
       63
       +
           let with_actions cwd fn =

     

       64
       64
       +
             match cwd with

     

       65
       65
       +
             | None -> fn actions

     

       66
       66
       +
             | Some ((dir, path) : Eio.Fs.dir_ty Eio.Path.t) -> (

     

       67
       67
       +
                 match as_posix_dir dir with

     

       68
       68
       +
                 | None -> Fmt.invalid_arg "cwd is not an OS directory!"

     

       69
       69
       +
                 | Some dirfd ->

     

       70
       70
       +
                     Switch.run ~name:"spawn_unix" @@ fun launch_sw ->

     

       71
       71
       +
                     let cwd =

     

       72
       72
       +
                       Low_level.openat ~sw:launch_sw ~mode:0 dirfd path

     

       73
       73
       +
                         Low_level.Open_flags.(rdonly + directory)

     

       74
       74
       +
                     in

     

       75
       75
       +
                     fn (Low_level.Process.Fork_action.fchdir cwd :: actions))

     

       76
       76
       +
           in

     

       77
       77
       +
           with_actions cwd @@ fun actions ->

     

       78
       78
       +
           process (Low_level.Process.spawn ~sw actions)

     

       79
       79
       +
       end

     

       80
       80
       +
       

     

       81
       81
       +
       let make_process group uid =

     

       82
       82
       +
         let module T = struct

     

       83
       83
       +
           type t = unit

     

       84
       84
       +
       

     

       85
       85
       +
           let spawn_unix = T.spawn_unix ~group ~uid

     

       86
       86
       +
         end in

     

       87
       87
       +
         let h = Eio_unix.Process.Pi.mgr_unix (module Eio_unix.Process.Make_mgr (T)) in

     

       88
       88
       +
         Eio.Resource.T ((), h)

+280

uring.h

···

       1
       1
       +
       #ifndef __URING_IO_H

     

       2
       2
       +
       #define __URING_IO_H

     

       3
       3
       +
       

     

       4
       4
       +
       #include <stdbool.h>

     

       5
       5
       +
       #define TASK_COMM_LEN 16

     

       6
       6
       +
       #define MAX_OP_STR_LEN 127

     

       7
       7
       +
       

     

       8
       8
       +
       enum tracepoint_t {

     

       9
       9
       +
         IO_URING_CREATE,

     

       10
       10
       +
         IO_URING_REGISTER,

     

       11
       11
       +
         IO_URING_FILE_GET,

     

       12
       12
       +
         IO_URING_SUBMIT_SQE,

     

       13
       13
       +
         IO_URING_QUEUE_ASYNC_WORK,

     

       14
       14
       +
         IO_URING_POLL_ARM,

     

       15
       15
       +
         IO_URING_TASK_ADD,

     

       16
       16
       +
         IO_URING_TASK_WORK_RUN,

     

       17
       17
       +
         IO_URING_SHORT_WRITE,

     

       18
       18
       +
         IO_URING_LOCAL_WORK_RUN,

     

       19
       19
       +
         IO_URING_DEFER,

     

       20
       20
       +
         IO_URING_LINK,

     

       21
       21
       +
         IO_URING_FAIL_LINK,

     

       22
       22
       +
         IO_URING_CQRING_WAIT,

     

       23
       23
       +
         IO_URING_REQ_FAILED,

     

       24
       24
       +
         IO_URING_CQE_OVERFLOW,

     

       25
       25
       +
         IO_URING_COMPLETE,

     

       26
       26
       +
         KPROBE_IO_INIT_NEW_WORKER,

     

       27
       27
       +
         SYS_ENTER_IO_URING_SETUP,

     

       28
       28
       +
         SYS_EXIT_IO_URING_SETUP,

     

       29
       29
       +
         SYS_ENTER_IO_URING_REGISTER,

     

       30
       30
       +
         SYS_EXIT_IO_URING_REGISTER,

     

       31
       31
       +
         SYS_ENTER_IO_URING_ENTER,

     

       32
       32
       +
         SYS_EXIT_IO_URING_ENTER

     

       33
       33
       +
       };

     

       34
       34
       +
       

     

       35
       35
       +
       struct io_uring_create {

     

       36
       36
       +
         int fd;

     

       37
       37
       +
         void *ctx;

     

       38
       38
       +
         unsigned long sq_entries;

     

       39
       39
       +
         unsigned long cq_entries;

     

       40
       40
       +
         unsigned long flags;

     

       41
       41
       +
       };

     

       42
       42
       +
       

     

       43
       43
       +
       struct io_uring_register {

     

       44
       44
       +
         void *ctx;

     

       45
       45
       +
         unsigned opcode;

     

       46
       46
       +
         unsigned nr_files;

     

       47
       47
       +
         unsigned nr_bufs;

     

       48
       48
       +
         long ret;

     

       49
       49
       +
       };

     

       50
       50
       +
       

     

       51
       51
       +
       struct io_uring_file_get {

     

       52
       52
       +
         void *ctx;

     

       53
       53
       +
         void *req;

     

       54
       54
       +
         /* unsigned long long user_data; */

     

       55
       55
       +
         int fd;

     

       56
       56
       +
       };

     

       57
       57
       +
       

     

       58
       58
       +
       struct io_uring_submit_sqe {

     

       59
       59
       +
         void *ctx;

     

       60
       60
       +
         void *req;

     

       61
       61
       +
         /* unsigned long long user_data; */

     

       62
       62
       +
         unsigned char opcode;

     

       63
       63
       +
         unsigned long flags;

     

       64
       64
       +
         bool force_nonblock;

     

       65
       65
       +
         bool sq_thread;

     

       66
       66
       +
         /* unsigned long __data_loc_op_str; */

     

       67
       67
       +
         char op_str[MAX_OP_STR_LEN];

     

       68
       68
       +
       };

     

       69
       69
       +
       

     

       70
       70
       +
       struct io_uring_queue_async_work {

     

       71
       71
       +
         void *ctx;

     

       72
       72
       +
         void *req;

     

       73
       73
       +
         /* unsigned long long user_data; */

     

       74
       74
       +
         unsigned char opcode;

     

       75
       75
       +
         unsigned int flags;

     

       76
       76
       +
         void *work;

     

       77
       77
       +
         /* int rw; */

     

       78
       78
       +
         /* unsigned long __data_loc_op_str; */

     

       79
       79
       +
         char op_str[MAX_OP_STR_LEN];

     

       80
       80
       +
       };

     

       81
       81
       +
       

     

       82
       82
       +
       struct io_uring_poll_arm {

     

       83
       83
       +
         void *ctx;

     

       84
       84
       +
         void *req;

     

       85
       85
       +
         /* unsigned long long user_data; */

     

       86
       86
       +
         unsigned char opcode;

     

       87
       87
       +
         int mask;

     

       88
       88
       +
         int events;

     

       89
       89
       +
         char op_str[MAX_OP_STR_LEN];

     

       90
       90
       +
       };

     

       91
       91
       +
       

     

       92
       92
       +
       struct io_uring_task_add {

     

       93
       93
       +
         void *ctx;

     

       94
       94
       +
         void *req;

     

       95
       95
       +
         /* unsigned long long user_data; */

     

       96
       96
       +
         unsigned char opcode;

     

       97
       97
       +
         int mask;

     

       98
       98
       +
         char op_str[MAX_OP_STR_LEN];

     

       99
       99
       +
       };

     

       100
       100
       +
       

     

       101
       101
       +
       struct io_uring_task_work_run {

     

       102
       102
       +
         void *tctx;

     

       103
       103
       +
         unsigned int count;

     

       104
       104
       +
         unsigned int loops;

     

       105
       105
       +
       };

     

       106
       106
       +
       

     

       107
       107
       +
       struct io_uring_short_write {

     

       108
       108
       +
         void *ctx;

     

       109
       109
       +
         unsigned long long fpos;

     

       110
       110
       +
         unsigned long long wanted;

     

       111
       111
       +
         unsigned long long got;

     

       112
       112
       +
       };

     

       113
       113
       +
       

     

       114
       114
       +
       struct io_uring_local_work_run {

     

       115
       115
       +
         void *ctx;

     

       116
       116
       +
         int count;

     

       117
       117
       +
         unsigned int loops;

     

       118
       118
       +
       };

     

       119
       119
       +
       

     

       120
       120
       +
       struct io_uring_defer {

     

       121
       121
       +
         void *ctx;

     

       122
       122
       +
         void *req;

     

       123
       123
       +
         /* unsigned long long data; */

     

       124
       124
       +
         unsigned char opcode;

     

       125
       125
       +
         char op_str[MAX_OP_STR_LEN];

     

       126
       126
       +
       };

     

       127
       127
       +
       

     

       128
       128
       +
       struct io_uring_link {

     

       129
       129
       +
       

     

       130
       130
       +
         void *ctx;

     

       131
       131
       +
         void *req;

     

       132
       132
       +
         void *target_req;

     

       133
       133
       +
       };

     

       134
       134
       +
       

     

       135
       135
       +
       struct io_uring_fail_link {

     

       136
       136
       +
         void *ctx;

     

       137
       137
       +
         void *req;

     

       138
       138
       +
         /* unsigned long long user_data; */

     

       139
       139
       +
         unsigned char opcode;

     

       140
       140
       +
         void *link;

     

       141
       141
       +
         char op_str[MAX_OP_STR_LEN];

     

       142
       142
       +
       };

     

       143
       143
       +
       

     

       144
       144
       +
       struct io_uring_cqring_wait {

     

       145
       145
       +
         void *ctx;

     

       146
       146
       +
         int min_events;

     

       147
       147
       +
       };

     

       148
       148
       +
       

     

       149
       149
       +
       struct io_uring_req_failed {

     

       150
       150
       +
         void *ctx;

     

       151
       151
       +
         void *req;

     

       152
       152
       +
         /* unsigned long long user_data; */

     

       153
       153
       +
         unsigned char opcode;

     

       154
       154
       +
         unsigned char flags;

     

       155
       155
       +
         unsigned char ioprio;

     

       156
       156
       +
         unsigned long long off;

     

       157
       157
       +
         unsigned long long addr;

     

       158
       158
       +
         unsigned long len;

     

       159
       159
       +
         unsigned long op_flags;

     

       160
       160
       +
         unsigned int buf_index;

     

       161
       161
       +
         unsigned int personality;

     

       162
       162
       +
         unsigned long file_index;

     

       163
       163
       +
         unsigned long long pad1;

     

       164
       164
       +
         unsigned long long addr3;

     

       165
       165
       +
         int error;

     

       166
       166
       +
         char op_str[MAX_OP_STR_LEN];

     

       167
       167
       +
       };

     

       168
       168
       +
       

     

       169
       169
       +
       struct io_uring_cqe_overflow {

     

       170
       170
       +
         void *ctx;

     

       171
       171
       +
         unsigned long long user_data;

     

       172
       172
       +
         long res;

     

       173
       173
       +
         unsigned long cflags;

     

       174
       174
       +
         void *ocqe;

     

       175
       175
       +
       };

     

       176
       176
       +
       

     

       177
       177
       +
       struct io_uring_complete {

     

       178
       178
       +
         void *ctx;

     

       179
       179
       +
         void *req;

     

       180
       180
       +
         /* unsigned long long user_data; */

     

       181
       181
       +
         int res;

     

       182
       182
       +
         unsigned int cflags;

     

       183
       183
       +
         /* unsigned long long extra1; */

     

       184
       184
       +
         /* unsigned long long extra2; */

     

       185
       185
       +
       };

     

       186
       186
       +
       

     

       187
       187
       +
       struct io_init_new_worker {

     

       188
       188
       +
         int io_worker_tid;

     

       189
       189
       +
       };

     

       190
       190
       +
       

     

       191
       191
       +
       /* struct sys_enter_io_uring_enter { */

     

       192
       192
       +
       /*     unsigned int fd; */

     

       193
       193
       +
       /*     unsigned long to_submit; */

     

       194
       194
       +
       /*     unsigned long min_complete; */

     

       195
       195
       +
       /*     unsigned long flags; */

     

       196
       196
       +
       /*     unsigned */

     

       197
       197
       +
       /* } */

     

       198
       198
       +
       

     

       199
       199
       +
       struct event {

     

       200
       200
       +
         enum tracepoint_t ty;

     

       201
       201
       +
         int pid;

     

       202
       202
       +
         int tid;

     

       203
       203
       +
         unsigned long long ts;

     

       204
       204
       +
         char comm[TASK_COMM_LEN];

     

       205
       205
       +
         union {

     

       206
       206
       +
           struct io_uring_create io_uring_create;

     

       207
       207
       +
           struct io_uring_register io_uring_register;

     

       208
       208
       +
           struct io_uring_file_get io_uring_file_get;

     

       209
       209
       +
           struct io_uring_submit_sqe io_uring_submit_sqe;

     

       210
       210
       +
           struct io_uring_queue_async_work io_uring_queue_async_work;

     

       211
       211
       +
           struct io_uring_poll_arm io_uring_poll_arm;

     

       212
       212
       +
           struct io_uring_task_add io_uring_task_add;

     

       213
       213
       +
           struct io_uring_task_work_run io_uring_task_work_run;

     

       214
       214
       +
           struct io_uring_short_write io_uring_short_write;

     

       215
       215
       +
           struct io_uring_local_work_run io_uring_local_work_run;

     

       216
       216
       +
           struct io_uring_defer io_uring_defer;

     

       217
       217
       +
           struct io_uring_link io_uring_link;

     

       218
       218
       +
           struct io_uring_fail_link io_uring_fail_link;

     

       219
       219
       +
           struct io_uring_cqring_wait io_uring_cqring_wait;

     

       220
       220
       +
           struct io_uring_req_failed io_uring_req_failed;

     

       221
       221
       +
           struct io_uring_cqe_overflow io_uring_cqe_overflow;

     

       222
       222
       +
           struct io_uring_complete io_uring_complete;

     

       223
       223
       +
           struct io_init_new_worker io_init_new_worker;

     

       224
       224
       +
         };

     

       225
       225
       +
       };

     

       226
       226
       +
       

     

       227
       227
       +
       /* enum io_uring_op { */

     

       228
       228
       +
       /* 	IORING_OP_NOP = 0, */

     

       229
       229
       +
       /* 	IORING_OP_READV = 1, */

     

       230
       230
       +
       /* 	IORING_OP_WRITEV = 2, */

     

       231
       231
       +
       /* 	IORING_OP_FSYNC = 3, */

     

       232
       232
       +
       /* 	IORING_OP_READ_FIXED = 4, */

     

       233
       233
       +
       /* 	IORING_OP_WRITE_FIXED = 5, */

     

       234
       234
       +
       /* 	IORING_OP_POLL_ADD = 6, */

     

       235
       235
       +
       /* 	IORING_OP_POLL_REMOVE = 7, */

     

       236
       236
       +
       /* 	IORING_OP_SYNC_FILE_RANGE = 8, */

     

       237
       237
       +
       /* 	IORING_OP_SENDMSG = 9, */

     

       238
       238
       +
       /* 	IORING_OP_RECVMSG = 10, */

     

       239
       239
       +
       /* 	IORING_OP_TIMEOUT = 11, */

     

       240
       240
       +
       /* 	IORING_OP_TIMEOUT_REMOVE = 12, */

     

       241
       241
       +
       /* 	IORING_OP_ACCEPT = 13, */

     

       242
       242
       +
       /* 	IORING_OP_ASYNC_CANCEL = 14, */

     

       243
       243
       +
       /* 	IORING_OP_LINK_TIMEOUT = 15, */

     

       244
       244
       +
       /* 	IORING_OP_CONNECT = 16, */

     

       245
       245
       +
       /* 	IORING_OP_FALLOCATE = 17, */

     

       246
       246
       +
       /* 	IORING_OP_OPENAT = 18, */

     

       247
       247
       +
       /* 	IORING_OP_CLOSE = 19, */

     

       248
       248
       +
       /* 	IORING_OP_FILES_UPDATE = 20, */

     

       249
       249
       +
       /* 	IORING_OP_STATX = 21, */

     

       250
       250
       +
       /* 	IORING_OP_READ = 22, */

     

       251
       251
       +
       /* 	IORING_OP_WRITE = 23, */

     

       252
       252
       +
       /* 	IORING_OP_FADVISE = 24, */

     

       253
       253
       +
       /* 	IORING_OP_MADVISE = 25, */

     

       254
       254
       +
       /* 	IORING_OP_SEND = 26, */

     

       255
       255
       +
       /* 	IORING_OP_RECV = 27, */

     

       256
       256
       +
       /* 	IORING_OP_OPENAT2 = 28, */

     

       257
       257
       +
       /* 	IORING_OP_EPOLL_CTL = 29, */

     

       258
       258
       +
       /* 	IORING_OP_SPLICE = 30, */

     

       259
       259
       +
       /* 	IORING_OP_PROVIDE_BUFFERS = 31, */

     

       260
       260
       +
       /* 	IORING_OP_REMOVE_BUFFERS = 32, */

     

       261
       261
       +
       /* 	IORING_OP_TEE = 33, */

     

       262
       262
       +
       /* 	IORING_OP_SHUTDOWN = 34, */

     

       263
       263
       +
       /* 	IORING_OP_RENAMEAT = 35, */

     

       264
       264
       +
       /* 	IORING_OP_UNLINKAT = 36, */

     

       265
       265
       +
       /* 	IORING_OP_MKDIRAT = 37, */

     

       266
       266
       +
       /* 	IORING_OP_SYMLINKAT = 38, */

     

       267
       267
       +
       /* 	IORING_OP_LINKAT = 39, */

     

       268
       268
       +
       /* 	IORING_OP_MSG_RING = 40, */

     

       269
       269
       +
       /* 	IORING_OP_FSETXATTR = 41, */

     

       270
       270
       +
       /* 	IORING_OP_SETXATTR = 42, */

     

       271
       271
       +
       /* 	IORING_OP_FGETXATTR = 43, */

     

       272
       272
       +
       /* 	IORING_OP_GETXATTR = 44, */

     

       273
       273
       +
       /* 	IORING_OP_SOCKET = 45, */

     

       274
       274
       +
       /* 	IORING_OP_URING_CMD = 46, */

     

       275
       275
       +
       /* 	IORING_OP_SEND_ZC = 47, */

     

       276
       276
       +
       /* 	IORING_OP_SENDMSG_ZC = 48, */

     

       277
       277
       +
       /* 	IORING_OP_LAST = 49, */

     

       278
       278
       +
       /* }; */

     

       279
       279
       +
       

     

       280
       280
       +
       #endif