1 /* 2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk (at) cs.few.eur.nl> 3 * Copyright (c) 1993 Branko Lankester <branko (at) hacktic.nl> 4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs (at) world.std.com> 5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert (at) cistron.nl> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include "defs.h" 32 #include "flock.h" 33 34 #include "xlat/f_owner_types.h" 35 #include "xlat/f_seals.h" 36 #include "xlat/fcntlcmds.h" 37 #include "xlat/fcntl64cmds.h" 38 #include "xlat/fdflags.h" 39 #include "xlat/lockfcmds.h" 40 #include "xlat/notifyflags.h" 41 42 static void 43 print_struct_flock64(const struct_kernel_flock64 *fl, const int getlk) 44 { 45 tprints("{l_type="); 46 printxval(lockfcmds, fl->l_type, "F_???"); 47 tprints(", l_whence="); 48 printxval(whence_codes, fl->l_whence, "SEEK_???"); 49 tprintf(", l_start=%lld, l_len=%lld", 50 (long long) fl->l_start, (long long) fl->l_len); 51 if (getlk) 52 tprintf(", l_pid=%lu", (unsigned long) fl->l_pid); 53 tprints("}"); 54 } 55 56 static void 57 printflock64(struct tcb *tcp, const long addr, const int getlk) 58 { 59 struct_kernel_flock64 fl; 60 61 if (fetch_struct_flock64(tcp, addr, &fl)) 62 print_struct_flock64(&fl, getlk); 63 } 64 65 static void 66 printflock(struct tcb *tcp, const long addr, const int getlk) 67 { 68 struct_kernel_flock64 fl; 69 70 if (fetch_struct_flock(tcp, addr, &fl)) 71 print_struct_flock64(&fl, getlk); 72 } 73 74 static void 75 print_f_owner_ex(struct tcb *tcp, const long addr) 76 { 77 struct { int type, pid; } owner; 78 79 if (umove_or_printaddr(tcp, addr, &owner)) 80 return; 81 82 tprints("{type="); 83 printxval(f_owner_types, owner.type, "F_OWNER_???"); 84 tprintf(", pid=%d}", owner.pid); 85 } 86 87 static int 88 print_fcntl(struct tcb *tcp) 89 { 90 switch (tcp->u_arg[1]) { 91 case F_SETFD: 92 tprints(", "); 93 printflags(fdflags, tcp->u_arg[2], "FD_???"); 94 break; 95 case F_SETOWN: 96 case F_SETPIPE_SZ: 97 tprintf(", %ld", tcp->u_arg[2]); 98 break; 99 case F_DUPFD: 100 case F_DUPFD_CLOEXEC: 101 tprintf(", %ld", tcp->u_arg[2]); 102 return RVAL_DECODED | RVAL_FD; 103 case F_SETFL: 104 tprints(", "); 105 tprint_open_modes(tcp->u_arg[2]); 106 break; 107 case F_SETLK: 108 case F_SETLKW: 109 tprints(", "); 110 printflock(tcp, tcp->u_arg[2], 0); 111 break; 112 case F_OFD_SETLK: 113 case F_OFD_SETLKW: 114 tprints(", "); 115 printflock64(tcp, tcp->u_arg[2], 0); 116 break; 117 case F_SETOWN_EX: 118 tprints(", "); 119 print_f_owner_ex(tcp, tcp->u_arg[2]); 120 break; 121 case F_NOTIFY: 122 tprints(", "); 123 printflags(notifyflags, tcp->u_arg[2], "DN_???"); 124 break; 125 case F_SETLEASE: 126 tprints(", "); 127 printxval(lockfcmds, tcp->u_arg[2], "F_???"); 128 break; 129 case F_ADD_SEALS: 130 tprints(", "); 131 printflags(f_seals, tcp->u_arg[2], "F_SEAL_???"); 132 break; 133 case F_SETSIG: 134 tprints(", "); 135 tprints(signame(tcp->u_arg[2])); 136 break; 137 case F_GETOWN: 138 case F_GETPIPE_SZ: 139 break; 140 case F_GETFD: 141 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0) 142 return 0; 143 tcp->auxstr = sprintflags("flags ", fdflags, tcp->u_rval); 144 return RVAL_HEX | RVAL_STR; 145 case F_GETFL: 146 if (entering(tcp) || syserror(tcp)) 147 return 0; 148 tcp->auxstr = sprint_open_modes(tcp->u_rval); 149 return RVAL_HEX | RVAL_STR; 150 case F_GETLK: 151 if (entering(tcp)) 152 return 0; 153 tprints(", "); 154 printflock(tcp, tcp->u_arg[2], 1); 155 break; 156 case F_OFD_GETLK: 157 if (entering(tcp)) 158 return 0; 159 tprints(", "); 160 printflock64(tcp, tcp->u_arg[2], 1); 161 break; 162 case F_GETOWN_EX: 163 if (entering(tcp)) 164 return 0; 165 tprints(", "); 166 print_f_owner_ex(tcp, tcp->u_arg[2]); 167 break; 168 case F_GETLEASE: 169 if (entering(tcp) || syserror(tcp)) 170 return 0; 171 tcp->auxstr = xlookup(lockfcmds, tcp->u_rval); 172 return RVAL_HEX | RVAL_STR; 173 case F_GET_SEALS: 174 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0) 175 return 0; 176 tcp->auxstr = sprintflags("seals ", f_seals, tcp->u_rval); 177 return RVAL_HEX | RVAL_STR; 178 case F_GETSIG: 179 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0) 180 return 0; 181 tcp->auxstr = signame(tcp->u_rval); 182 return RVAL_STR; 183 default: 184 tprintf(", %#lx", tcp->u_arg[2]); 185 break; 186 } 187 return RVAL_DECODED; 188 } 189 190 SYS_FUNC(fcntl) 191 { 192 if (entering(tcp)) { 193 printfd(tcp, tcp->u_arg[0]); 194 tprints(", "); 195 const char *str = xlookup(fcntlcmds, tcp->u_arg[1]); 196 if (str) { 197 tprints(str); 198 } else { 199 /* 200 * fcntl syscall does not recognize these 201 * constants, but we would like to show them 202 * for better debugging experience. 203 */ 204 printxval(fcntl64cmds, tcp->u_arg[1], "F_???"); 205 } 206 } 207 return print_fcntl(tcp); 208 } 209 210 SYS_FUNC(fcntl64) 211 { 212 if (entering(tcp)) { 213 printfd(tcp, tcp->u_arg[0]); 214 tprints(", "); 215 const char *str = xlookup(fcntl64cmds, tcp->u_arg[1]); 216 if (str) { 217 tprints(str); 218 } else { 219 printxval(fcntlcmds, tcp->u_arg[1], "F_???"); 220 } 221 } 222 switch (tcp->u_arg[1]) { 223 case F_SETLK64: 224 case F_SETLKW64: 225 tprints(", "); 226 printflock64(tcp, tcp->u_arg[2], 0); 227 return RVAL_DECODED; 228 case F_GETLK64: 229 if (exiting(tcp)) { 230 tprints(", "); 231 printflock64(tcp, tcp->u_arg[2], 1); 232 } 233 return 0; 234 } 235 return print_fcntl(tcp); 236 } 237
