Branch data Line data Source code
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
43 : 37 : print_struct_flock64(const struct_kernel_flock64 *fl, const int getlk)
44 : : {
45 : 37 : tprints("{l_type=");
46 : 37 : printxval(lockfcmds, (unsigned short) fl->l_type, "F_???");
47 : 37 : tprints(", l_whence=");
48 : 37 : printxval(whence_codes, (unsigned short) fl->l_whence, "SEEK_???");
49 : 37 : tprintf(", l_start=%" PRId64 ", l_len=%" PRId64,
50 : 37 : (int64_t) fl->l_start, (int64_t) fl->l_len);
51 [ + + ]: 37 : if (getlk)
52 : 7 : tprintf(", l_pid=%lu", (unsigned long) fl->l_pid);
53 : 37 : tprints("}");
54 : 37 : }
55 : :
56 : : static void
57 : 7 : printflock64(struct tcb *const tcp, const kernel_ulong_t addr, const int getlk)
58 : : {
59 : : struct_kernel_flock64 fl;
60 : :
61 [ + - ]: 7 : if (fetch_struct_flock64(tcp, addr, &fl))
62 : 7 : print_struct_flock64(&fl, getlk);
63 : 7 : }
64 : :
65 : : static void
66 : 30 : printflock(struct tcb *const tcp, const kernel_ulong_t addr, const int getlk)
67 : : {
68 : : struct_kernel_flock64 fl;
69 : :
70 [ + - ]: 30 : if (fetch_struct_flock(tcp, addr, &fl))
71 : 30 : print_struct_flock64(&fl, getlk);
72 : 30 : }
73 : :
74 : : static void
75 : 0 : print_f_owner_ex(struct tcb *const tcp, const kernel_ulong_t addr)
76 : : {
77 : : struct { int type, pid; } owner;
78 : :
79 [ # # ]: 0 : if (umove_or_printaddr(tcp, addr, &owner))
80 : 0 : return;
81 : :
82 : 0 : tprints("{type=");
83 : 0 : printxval(f_owner_types, owner.type, "F_OWNER_???");
84 : 0 : tprintf(", pid=%d}", owner.pid);
85 : : }
86 : :
87 : : static int
88 : 53 : print_fcntl(struct tcb *tcp)
89 : : {
90 : 53 : const unsigned int cmd = tcp->u_arg[1];
91 : :
92 [ - - - - : 53 : switch (cmd) {
+ + - - -
- - - - -
+ - - - -
- + ]
93 : : case F_SETFD:
94 : 0 : tprints(", ");
95 : 0 : printflags(fdflags, tcp->u_arg[2], "FD_???");
96 : 0 : break;
97 : : case F_SETOWN:
98 : : case F_SETPIPE_SZ:
99 : 0 : tprintf(", %" PRI_kld, tcp->u_arg[2]);
100 : 0 : break;
101 : : case F_DUPFD:
102 : : case F_DUPFD_CLOEXEC:
103 : 0 : tprintf(", %" PRI_kld, tcp->u_arg[2]);
104 : 0 : return RVAL_DECODED | RVAL_FD;
105 : : case F_SETFL:
106 : 0 : tprints(", ");
107 : 0 : tprint_open_modes(tcp->u_arg[2]);
108 : 0 : break;
109 : : case F_SETLK:
110 : : case F_SETLKW:
111 : 24 : tprints(", ");
112 : 24 : printflock(tcp, tcp->u_arg[2], 0);
113 : 24 : break;
114 : : case F_OFD_SETLK:
115 : : case F_OFD_SETLKW:
116 : 2 : tprints(", ");
117 : 2 : printflock64(tcp, tcp->u_arg[2], 0);
118 : 2 : break;
119 : : case F_SETOWN_EX:
120 : 0 : tprints(", ");
121 : 0 : print_f_owner_ex(tcp, tcp->u_arg[2]);
122 : 0 : break;
123 : : case F_NOTIFY:
124 : 0 : tprints(", ");
125 : 0 : printflags64(notifyflags, tcp->u_arg[2], "DN_???");
126 : 0 : break;
127 : : case F_SETLEASE:
128 : 0 : tprints(", ");
129 : 0 : printxval64(lockfcmds, tcp->u_arg[2], "F_???");
130 : 0 : break;
131 : : case F_ADD_SEALS:
132 : 0 : tprints(", ");
133 : 0 : printflags64(f_seals, tcp->u_arg[2], "F_SEAL_???");
134 : 0 : break;
135 : : case F_SETSIG:
136 : 0 : tprints(", ");
137 : 0 : tprints(signame(tcp->u_arg[2]));
138 : 0 : break;
139 : : case F_GETOWN:
140 : : case F_GETPIPE_SZ:
141 : 0 : break;
142 : : case F_GETFD:
143 [ # # ][ # # ]: 0 : if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
[ # # ]
144 : 0 : return 0;
145 : 0 : tcp->auxstr = sprintflags("flags ", fdflags,
146 : 0 : (kernel_ulong_t) tcp->u_rval);
147 : 0 : return RVAL_HEX | RVAL_STR;
148 : : case F_GETFL:
149 [ # # ][ # # ]: 0 : if (entering(tcp) || syserror(tcp))
150 : 0 : return 0;
151 : 0 : tcp->auxstr = sprint_open_modes(tcp->u_rval);
152 : 0 : return RVAL_HEX | RVAL_STR;
153 : : case F_GETLK:
154 [ + + ]: 12 : if (entering(tcp))
155 : 6 : return 0;
156 : 6 : tprints(", ");
157 : 6 : printflock(tcp, tcp->u_arg[2], 1);
158 : 6 : break;
159 : : case F_OFD_GETLK:
160 [ # # ]: 0 : if (entering(tcp))
161 : 0 : return 0;
162 : 0 : tprints(", ");
163 : 0 : printflock64(tcp, tcp->u_arg[2], 1);
164 : 0 : break;
165 : : case F_GETOWN_EX:
166 [ # # ]: 0 : if (entering(tcp))
167 : 0 : return 0;
168 : 0 : tprints(", ");
169 : 0 : print_f_owner_ex(tcp, tcp->u_arg[2]);
170 : 0 : break;
171 : : case F_GETLEASE:
172 [ # # ][ # # ]: 0 : if (entering(tcp) || syserror(tcp))
173 : 0 : return 0;
174 : 0 : tcp->auxstr = xlookup(lockfcmds, (kernel_ulong_t) tcp->u_rval);
175 : 0 : return RVAL_HEX | RVAL_STR;
176 : : case F_GET_SEALS:
177 [ # # ][ # # ]: 0 : if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
[ # # ]
178 : 0 : return 0;
179 : 0 : tcp->auxstr = sprintflags("seals ", f_seals,
180 : 0 : (kernel_ulong_t) tcp->u_rval);
181 : 0 : return RVAL_HEX | RVAL_STR;
182 : : case F_GETSIG:
183 [ # # ][ # # ]: 0 : if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
[ # # ]
184 : 0 : return 0;
185 : 0 : tcp->auxstr = signame(tcp->u_rval);
186 : 0 : return RVAL_STR;
187 : : default:
188 : 15 : tprintf(", %#" PRI_klx, tcp->u_arg[2]);
189 : 15 : break;
190 : : }
191 : 47 : return RVAL_DECODED;
192 : : }
193 : :
194 : 45 : SYS_FUNC(fcntl)
195 : : {
196 [ + + ]: 45 : if (entering(tcp)) {
197 : 40 : printfd(tcp, tcp->u_arg[0]);
198 : 40 : tprints(", ");
199 : 40 : const unsigned int cmd = tcp->u_arg[1];
200 : 40 : const char *str = xlookup(fcntlcmds, cmd);
201 [ + + ]: 40 : if (str) {
202 : 25 : 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 : 15 : printxval(fcntl64cmds, cmd, "F_???");
210 : : }
211 : : }
212 : 45 : return print_fcntl(tcp);
213 : : }
214 : :
215 : 14 : SYS_FUNC(fcntl64)
216 : : {
217 : 14 : const unsigned int cmd = tcp->u_arg[1];
218 [ + + ]: 14 : if (entering(tcp)) {
219 : 12 : printfd(tcp, tcp->u_arg[0]);
220 : 12 : tprints(", ");
221 : 12 : const char *str = xlookup(fcntl64cmds, cmd);
222 [ + + ]: 12 : if (str) {
223 : 5 : tprints(str);
224 : : } else {
225 : 7 : printxval(fcntlcmds, cmd, "F_???");
226 : : }
227 : : }
228 [ + + + ]: 14 : switch (cmd) {
229 : : case F_SETLK64:
230 : : case F_SETLKW64:
231 : 4 : tprints(", ");
232 : 4 : printflock64(tcp, tcp->u_arg[2], 0);
233 : 4 : return RVAL_DECODED;
234 : : case F_GETLK64:
235 [ + + ]: 2 : if (exiting(tcp)) {
236 : 1 : tprints(", ");
237 : 1 : printflock64(tcp, tcp->u_arg[2], 1);
238 : : }
239 : 2 : return 0;
240 : : }
241 : 8 : return print_fcntl(tcp);
242 : : }
|
