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, 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
printflock64(struct tcb * tcp,const long addr,const int getlk)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
printflock(struct tcb * tcp,const long addr,const int getlk)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
print_f_owner_ex(struct tcb * tcp,const long addr)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
print_fcntl(struct tcb * tcp)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
SYS_FUNC(fcntl)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
SYS_FUNC(fcntl64)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