granicus.if.org Git - strace/blob - io_uring.c

   1 /*
   2  * Copyright (c) 2019 Dmitry V. Levin <ldv@altlinux.org>
   3  * All rights reserved.
   4  *
   5  * SPDX-License-Identifier: LGPL-2.1-or-later
   6  */
   7
   8 #include "defs.h"
   9
  10 #ifdef HAVE_LINUX_IO_URING_H
  11 # include "print_fields.h"
  12 # include <linux/io_uring.h>
  13 #endif
  14
  15 #include "xlat/uring_setup_flags.h"
  16 #include "xlat/uring_enter_flags.h"
  17 #include "xlat/uring_register_opcodes.h"
  18
  19 SYS_FUNC(io_uring_setup)
  20 {
  21         const uint32_t nentries = tcp->u_arg[0];
  22         const kernel_ulong_t params_addr = tcp->u_arg[1];
  23
  24 #ifdef HAVE_LINUX_IO_URING_H
  25         struct io_uring_params params;
  26
  27         if (entering(tcp)) {
  28                 tprintf("%u, ", nentries);
  29
  30                 if (umove_or_printaddr(tcp, params_addr, &params))
  31                         return RVAL_DECODED | RVAL_FD;
  32
  33                 PRINT_FIELD_FLAGS("{", params, flags, uring_setup_flags,
  34                                   "IORING_SETUP_???");
  35                 PRINT_FIELD_X(", ", params, sq_thread_cpu);
  36                 PRINT_FIELD_U(", ", params, sq_thread_idle);
  37                 for (unsigned int i = 0; i < ARRAY_SIZE(params.resv); ++i) {
  38                         if (params.resv[i]) {
  39                                 for (i = 0; i < ARRAY_SIZE(params.resv); ++i)
  40                                         tprintf("%s%#x",
  41                                                 (i ? ", " : ", resv={"),
  42                                                 params.resv[i]);
  43                                 tprints("}");
  44                                 break;
  45                         }
  46                 }
  47                 return 0;
  48         } else {
  49                 if (syserror(tcp)) {
  50                         /* The remaining part of params is irrelevant.  */
  51                 } else if (umove(tcp, params_addr, &params)) {
  52                         tprints(", ???");
  53                 } else {
  54                         PRINT_FIELD_U(", ", params, sq_entries);
  55                         PRINT_FIELD_U(", ", params, cq_entries);
  56                         PRINT_FIELD_U(", sq_off={", params.sq_off, head);
  57                         PRINT_FIELD_U(", ", params.sq_off, tail);
  58                         PRINT_FIELD_U(", ", params.sq_off, ring_mask);
  59                         PRINT_FIELD_U(", ", params.sq_off, ring_entries);
  60                         PRINT_FIELD_U(", ", params.sq_off, flags);
  61                         PRINT_FIELD_U(", ", params.sq_off, dropped);
  62                         PRINT_FIELD_U(", ", params.sq_off, array);
  63                         PRINT_FIELD_U("}, cq_off={", params.cq_off, head);
  64                         PRINT_FIELD_U(", ", params.cq_off, tail);
  65                         PRINT_FIELD_U(", ", params.cq_off, ring_mask);
  66                         PRINT_FIELD_U(", ", params.cq_off, ring_entries);
  67                         PRINT_FIELD_U(", ", params.cq_off, overflow);
  68                         PRINT_FIELD_U(", ", params.cq_off, cqes);
  69                         tprints("}");
  70                 }
  71                 tprints("}");
  72         }
  73 #else /* !HAVE_LINUX_IO_URING_H */
  74         tprintf("%u, ", nentries);
  75         printaddr(params_addr);
  76 #endif
  77
  78         return RVAL_DECODED | RVAL_FD;
  79 }
  80
  81 SYS_FUNC(io_uring_enter)
  82 {
  83         const int fd = tcp->u_arg[0];
  84         const uint32_t to_submit = tcp->u_arg[1];
  85         const uint32_t min_complete = tcp->u_arg[2];
  86         const uint32_t flags = tcp->u_arg[3];
  87         const kernel_ulong_t sigset_addr = tcp->u_arg[4];
  88         const kernel_ulong_t sigset_size = tcp->u_arg[5];
  89
  90         printfd(tcp, fd);
  91         tprintf(", %u, %u, ", to_submit, min_complete);
  92         printflags(uring_enter_flags, flags, "IORING_ENTER_???");
  93         tprints(", ");
  94         print_sigset_addr_len(tcp, sigset_addr, sigset_size);
  95         tprintf(", %" PRI_klu, sigset_size);
  96
  97         return RVAL_DECODED;
  98 }
  99
 100 static bool
 101 print_fd_array_member(struct tcb *tcp, void *elem_buf, size_t elem_size,
 102                       void *data)
 103 {
 104         printfd(tcp, *(int *) elem_buf);
 105         return true;
 106 }
 107
 108 SYS_FUNC(io_uring_register)
 109 {
 110         const int fd = tcp->u_arg[0];
 111         const unsigned int opcode = tcp->u_arg[1];
 112         const kernel_ulong_t arg = tcp->u_arg[2];
 113         const unsigned int nargs = tcp->u_arg[3];
 114         int buf;
 115
 116         printfd(tcp, fd);
 117         tprints(", ");
 118         printxval(uring_register_opcodes, opcode, "IORING_REGISTER_???");
 119         tprints(", ");
 120         switch (opcode) {
 121                 case IORING_REGISTER_BUFFERS:
 122                         tprint_iov(tcp, nargs, arg, IOV_DECODE_ADDR);
 123                         break;
 124                 case IORING_REGISTER_FILES:
 125                         print_array(tcp, arg, nargs, &buf, sizeof(buf),
 126                                     tfetch_mem, print_fd_array_member, NULL);
 127                         break;
 128                 default:
 129                         printaddr(arg);
 130                         break;
 131         }
 132         tprintf(", %u", nargs);
 133
 134         return RVAL_DECODED;
 135 }