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 * 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
print_struct_flock64(const struct_kernel_flock64 * fl,const int getlk)43 print_struct_flock64(const struct_kernel_flock64 *fl, const int getlk)
44 {
45 tprints("{l_type=");
46 printxval(lockfcmds, (unsigned short) fl->l_type, "F_???");
47 tprints(", l_whence=");
48 printxval(whence_codes, (unsigned short) fl->l_whence, "SEEK_???");
49 tprintf(", l_start=%" PRId64 ", l_len=%" PRId64,
50 (int64_t) fl->l_start, (int64_t) fl->l_len);
51 if (getlk)
52 tprintf(", l_pid=%lu", (unsigned long) fl->l_pid);
53 tprints("}");
54 }
55
56 static void
printflock64(struct tcb * const tcp,const kernel_ulong_t addr,const int getlk)57 printflock64(struct tcb *const tcp, const kernel_ulong_t 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
printflock(struct tcb * const tcp,const kernel_ulong_t addr,const int getlk)66 printflock(struct tcb *const tcp, const kernel_ulong_t 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
print_f_owner_ex(struct tcb * const tcp,const kernel_ulong_t addr)75 print_f_owner_ex(struct tcb *const tcp, const kernel_ulong_t 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
print_fcntl(struct tcb * tcp)88 print_fcntl(struct tcb *tcp)
89 {
90 const unsigned int cmd = tcp->u_arg[1];
91
92 switch (cmd) {
93 case F_SETFD:
94 tprints(", ");
95 printflags(fdflags, tcp->u_arg[2], "FD_???");
96 break;
97 case F_SETOWN:
98 case F_SETPIPE_SZ:
99 tprintf(", %" PRI_kld, tcp->u_arg[2]);
100 break;
101 case F_DUPFD:
102 case F_DUPFD_CLOEXEC:
103 tprintf(", %" PRI_kld, tcp->u_arg[2]);
104 return RVAL_DECODED | RVAL_FD;
105 case F_SETFL:
106 tprints(", ");
107 tprint_open_modes(tcp->u_arg[2]);
108 break;
109 case F_SETLK:
110 case F_SETLKW:
111 tprints(", ");
112 printflock(tcp, tcp->u_arg[2], 0);
113 break;
114 case F_OFD_SETLK:
115 case F_OFD_SETLKW:
116 tprints(", ");
117 printflock64(tcp, tcp->u_arg[2], 0);
118 break;
119 case F_SETOWN_EX:
120 tprints(", ");
121 print_f_owner_ex(tcp, tcp->u_arg[2]);
122 break;
123 case F_NOTIFY:
124 tprints(", ");
125 printflags64(notifyflags, tcp->u_arg[2], "DN_???");
126 break;
127 case F_SETLEASE:
128 tprints(", ");
129 printxval64(lockfcmds, tcp->u_arg[2], "F_???");
130 break;
131 case F_ADD_SEALS:
132 tprints(", ");
133 printflags64(f_seals, tcp->u_arg[2], "F_SEAL_???");
134 break;
135 case F_SETSIG:
136 tprints(", ");
137 tprints(signame(tcp->u_arg[2]));
138 break;
139 case F_GETOWN:
140 case F_GETPIPE_SZ:
141 break;
142 case F_GETFD:
143 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
144 return 0;
145 tcp->auxstr = sprintflags("flags ", fdflags,
146 (kernel_ulong_t) tcp->u_rval);
147 return RVAL_HEX | RVAL_STR;
148 case F_GETFL:
149 if (entering(tcp) || syserror(tcp))
150 return 0;
151 tcp->auxstr = sprint_open_modes(tcp->u_rval);
152 return RVAL_HEX | RVAL_STR;
153 case F_GETLK:
154 if (entering(tcp))
155 return 0;
156 tprints(", ");
157 printflock(tcp, tcp->u_arg[2], 1);
158 break;
159 case F_OFD_GETLK:
160 if (entering(tcp))
161 return 0;
162 tprints(", ");
163 printflock64(tcp, tcp->u_arg[2], 1);
164 break;
165 case F_GETOWN_EX:
166 if (entering(tcp))
167 return 0;
168 tprints(", ");
169 print_f_owner_ex(tcp, tcp->u_arg[2]);
170 break;
171 case F_GETLEASE:
172 if (entering(tcp) || syserror(tcp))
173 return 0;
174 tcp->auxstr = xlookup(lockfcmds, (kernel_ulong_t) tcp->u_rval);
175 return RVAL_HEX | RVAL_STR;
176 case F_GET_SEALS:
177 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
178 return 0;
179 tcp->auxstr = sprintflags("seals ", f_seals,
180 (kernel_ulong_t) tcp->u_rval);
181 return RVAL_HEX | RVAL_STR;
182 case F_GETSIG:
183 if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
184 return 0;
185 tcp->auxstr = signame(tcp->u_rval);
186 return RVAL_STR;
187 default:
188 tprintf(", %#" PRI_klx, tcp->u_arg[2]);
189 break;
190 }
191 return RVAL_DECODED;
192 }
193
SYS_FUNC(fcntl)194 SYS_FUNC(fcntl)
195 {
196 if (entering(tcp)) {
197 printfd(tcp, tcp->u_arg[0]);
198 tprints(", ");
199 const unsigned int cmd = tcp->u_arg[1];
200 const char *str = xlookup(fcntlcmds, cmd);
201 if (str) {
202 tprints(str);
203 } else {
204 /*
205 * fcntl syscall does not recognize these
206 * constants, but we would like to show them
207 * for better debugging experience.
208 */
209 printxval(fcntl64cmds, cmd, "F_???");
210 }
211 }
212 return print_fcntl(tcp);
213 }
214
SYS_FUNC(fcntl64)215 SYS_FUNC(fcntl64)
216 {
217 const unsigned int cmd = tcp->u_arg[1];
218 if (entering(tcp)) {
219 printfd(tcp, tcp->u_arg[0]);
220 tprints(", ");
221 const char *str = xlookup(fcntl64cmds, cmd);
222 if (str) {
223 tprints(str);
224 } else {
225 printxval(fcntlcmds, cmd, "F_???");
226 }
227 }
228 switch (cmd) {
229 case F_SETLK64:
230 case F_SETLKW64:
231 tprints(", ");
232 printflock64(tcp, tcp->u_arg[2], 0);
233 return RVAL_DECODED;
234 case F_GETLK64:
235 if (exiting(tcp)) {
236 tprints(", ");
237 printflock64(tcp, tcp->u_arg[2], 1);
238 }
239 return 0;
240 }
241 return print_fcntl(tcp);
242 }
243