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

   1 /*
   2  * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
   3  * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
   4  * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
   5  * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
   6  * Copyright (c) 1999-2018 The strace developers.
   7  * All rights reserved.
   8  *
   9  * SPDX-License-Identifier: LGPL-2.1-or-later
  10  */
  11
  12 #include "defs.h"
  13 #include "flock.h"
  14
  15 #include "xlat/f_owner_types.h"
  16 #include "xlat/f_seals.h"
  17 #include "xlat/fcntlcmds.h"
  18 #include "xlat/fdflags.h"
  19 #include "xlat/lockfcmds.h"
  20 #include "xlat/notifyflags.h"
  21
  22 static void
  23 print_struct_flock64(const struct_kernel_flock64 *fl, const int getlk)
  24 {
  25         tprints("{l_type=");
  26         printxval(lockfcmds, (unsigned short) fl->l_type, "F_???");
  27         tprints(", l_whence=");
  28         printxval(whence_codes, (unsigned short) fl->l_whence, "SEEK_???");
  29         tprintf(", l_start=%" PRId64 ", l_len=%" PRId64,
  30                 (int64_t) fl->l_start, (int64_t) fl->l_len);
  31         if (getlk)
  32                 tprintf(", l_pid=%lu", (unsigned long) fl->l_pid);
  33         tprints("}");
  34 }
  35
  36 static void
  37 printflock64(struct tcb *const tcp, const kernel_ulong_t addr, const int getlk)
  38 {
  39         struct_kernel_flock64 fl;
  40
  41         if (fetch_struct_flock64(tcp, addr, &fl))
  42                 print_struct_flock64(&fl, getlk);
  43 }
  44
  45 static void
  46 printflock(struct tcb *const tcp, const kernel_ulong_t addr, const int getlk)
  47 {
  48         struct_kernel_flock64 fl;
  49
  50         if (fetch_struct_flock(tcp, addr, &fl))
  51                 print_struct_flock64(&fl, getlk);
  52 }
  53
  54 static void
  55 print_f_owner_ex(struct tcb *const tcp, const kernel_ulong_t addr)
  56 {
  57         struct { int type, pid; } owner;
  58
  59         if (umove_or_printaddr(tcp, addr, &owner))
  60                 return;
  61
  62         tprints("{type=");
  63         printxval(f_owner_types, owner.type, "F_OWNER_???");
  64         tprintf(", pid=%d}", owner.pid);
  65 }
  66
  67 static int
  68 print_fcntl(struct tcb *tcp)
  69 {
  70         const unsigned int cmd = tcp->u_arg[1];
  71
  72         switch (cmd) {
  73         case F_SETFD:
  74                 tprints(", ");
  75                 printflags(fdflags, tcp->u_arg[2], "FD_???");
  76                 break;
  77         case F_SETOWN:
  78         case F_SETPIPE_SZ:
  79                 tprintf(", %" PRI_kld, tcp->u_arg[2]);
  80                 break;
  81         case F_DUPFD:
  82         case F_DUPFD_CLOEXEC:
  83                 tprintf(", %" PRI_kld, tcp->u_arg[2]);
  84                 return RVAL_DECODED | RVAL_FD;
  85         case F_SETFL:
  86                 tprints(", ");
  87                 tprint_open_modes(tcp->u_arg[2]);
  88                 break;
  89         case F_SETLK:
  90         case F_SETLKW:
  91                 tprints(", ");
  92                 printflock(tcp, tcp->u_arg[2], 0);
  93                 break;
  94         case F_OFD_SETLK:
  95         case F_OFD_SETLKW:
  96                 tprints(", ");
  97                 printflock64(tcp, tcp->u_arg[2], 0);
  98                 break;
  99         case F_SETOWN_EX:
 100                 tprints(", ");
 101                 print_f_owner_ex(tcp, tcp->u_arg[2]);
 102                 break;
 103         case F_NOTIFY:
 104                 tprints(", ");
 105                 printflags64(notifyflags, tcp->u_arg[2], "DN_???");
 106                 break;
 107         case F_SETLEASE:
 108                 tprints(", ");
 109                 printxval64(lockfcmds, tcp->u_arg[2], "F_???");
 110                 break;
 111         case F_ADD_SEALS:
 112                 tprints(", ");
 113                 printflags64(f_seals, tcp->u_arg[2], "F_SEAL_???");
 114                 break;
 115         case F_SETSIG:
 116                 tprints(", ");
 117                 printsignal(tcp->u_arg[2]);
 118                 break;
 119         case F_GETOWN:
 120         case F_GETPIPE_SZ:
 121                 break;
 122         case F_GETFD:
 123                 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
 124                         return 0;
 125                 tcp->auxstr = sprintflags("flags ", fdflags,
 126                                           (kernel_ulong_t) tcp->u_rval);
 127                 return RVAL_HEX | RVAL_STR;
 128         case F_GETFL:
 129                 if (entering(tcp) || syserror(tcp))
 130                         return 0;
 131                 tcp->auxstr = sprint_open_modes(tcp->u_rval);
 132                 return RVAL_HEX | RVAL_STR;
 133         case F_GETLK:
 134                 if (entering(tcp))
 135                         return 0;
 136                 tprints(", ");
 137                 printflock(tcp, tcp->u_arg[2], 1);
 138                 break;
 139         case F_OFD_GETLK:
 140                 if (entering(tcp))
 141                         return 0;
 142                 tprints(", ");
 143                 printflock64(tcp, tcp->u_arg[2], 1);
 144                 break;
 145         case F_GETOWN_EX:
 146                 if (entering(tcp))
 147                         return 0;
 148                 tprints(", ");
 149                 print_f_owner_ex(tcp, tcp->u_arg[2]);
 150                 break;
 151         case F_GETLEASE:
 152                 if (entering(tcp) || syserror(tcp))
 153                         return 0;
 154                 tcp->auxstr = xlookup(lockfcmds, (kernel_ulong_t) tcp->u_rval);
 155                 return RVAL_HEX | RVAL_STR;
 156         case F_GET_SEALS:
 157                 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
 158                         return 0;
 159                 tcp->auxstr = sprintflags("seals ", f_seals,
 160                                           (kernel_ulong_t) tcp->u_rval);
 161                 return RVAL_HEX | RVAL_STR;
 162         case F_GETSIG:
 163                 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
 164                         return 0;
 165                 tcp->auxstr = signame(tcp->u_rval);
 166                 return RVAL_STR;
 167         default:
 168                 tprintf(", %#" PRI_klx, tcp->u_arg[2]);
 169                 break;
 170         }
 171         return RVAL_DECODED;
 172 }
 173
 174 SYS_FUNC(fcntl)
 175 {
 176         if (entering(tcp)) {
 177                 printfd(tcp, tcp->u_arg[0]);
 178                 tprints(", ");
 179                 printxval(fcntlcmds, tcp->u_arg[1], "F_???");
 180         }
 181         return print_fcntl(tcp);
 182 }
 183
 184 SYS_FUNC(fcntl64)
 185 {
 186         const unsigned int cmd = tcp->u_arg[1];
 187         if (entering(tcp)) {
 188                 printfd(tcp, tcp->u_arg[0]);
 189                 tprints(", ");
 190                 printxval(fcntlcmds, cmd, "F_???");
 191         }
 192         switch (cmd) {
 193                 case F_SETLK64:
 194                 case F_SETLKW64:
 195                         tprints(", ");
 196                         printflock64(tcp, tcp->u_arg[2], 0);
 197                         return RVAL_DECODED;
 198                 case F_GETLK64:
 199                         if (exiting(tcp)) {
 200                                 tprints(", ");
 201                                 printflock64(tcp, tcp->u_arg[2], 1);
 202                         }
 203                         return 0;
 204         }
 205         return print_fcntl(tcp);
 206 }