1 /*
2 * Copyright (c) 2016 Jeff Mahoney <jeffm@suse.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "defs.h"
29 #include <linux/ioctl.h>
30 #include <linux/fs.h>
31
32 #ifdef HAVE_LINUX_FIEMAP_H
33 # include <linux/fiemap.h>
34 # include "xlat/fiemap_flags.h"
35 # include "xlat/fiemap_extent_flags.h"
36 #endif
37
38 #ifndef FICLONE
39 # define FICLONE _IOW(0x94, 9, int)
40 #endif
41
42 #ifndef FICLONERANGE
43 # define FICLONERANGE _IOW(0x94, 13, struct file_clone_range)
44 struct file_clone_range {
45 int64_t src_fd;
46 uint64_t src_offset;
47 uint64_t src_length;
48 uint64_t dest_offset;
49 };
50 #endif
51
52 #ifndef FIDEDUPERANGE
53 # define FIDEDUPERANGE _IOWR(0x94, 54, struct file_dedupe_range)
54 struct file_dedupe_range_info {
55 int64_t dest_fd; /* in - destination file */
56 uint64_t dest_offset; /* in - start of extent in destination */
57 uint64_t bytes_deduped; /* out - total # of bytes we were able
58 * to dedupe from this file. */
59 /* status of this dedupe operation:
60 * < 0 for error
61 * == FILE_DEDUPE_RANGE_SAME if dedupe succeeds
62 * == FILE_DEDUPE_RANGE_DIFFERS if data differs
63 */
64 int32_t status; /* out - see above description */
65 uint32_t reserved; /* must be zero */
66 };
67
68 struct file_dedupe_range {
69 uint64_t src_offset; /* in - start of extent in source */
70 uint64_t src_length; /* in - length of extent */
71 uint16_t dest_count; /* in - total elements in info array */
72 uint16_t reserved1; /* must be zero */
73 uint32_t reserved2; /* must be zero */
74 struct file_dedupe_range_info info[0];
75 };
76 #endif
77
78 static bool
print_file_dedupe_range_info(struct tcb * tcp,void * elem_buf,size_t elem_size,void * data)79 print_file_dedupe_range_info(struct tcb *tcp, void *elem_buf,
80 size_t elem_size, void *data)
81 {
82 const struct file_dedupe_range_info *info = elem_buf;
83 unsigned int *count = data;
84
85 if (count) {
86 if (*count == 0) {
87 tprints("...");
88 return false;
89 }
90 --*count;
91 }
92
93 if (entering(tcp)) {
94 tprints("{dest_fd=");
95 printfd(tcp, info->dest_fd);
96 tprintf(", dest_offset=%" PRIu64 "}",
97 (uint64_t) info->dest_offset);
98 } else {
99 tprintf("{bytes_deduped=%" PRIu64 ", status=%d}",
100 (uint64_t) info->bytes_deduped, info->status);
101 }
102
103 return true;
104 }
105
106 #ifdef HAVE_LINUX_FIEMAP_H
107 static bool
print_fiemap_extent(struct tcb * tcp,void * elem_buf,size_t elem_size,void * data)108 print_fiemap_extent(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
109 {
110 const struct fiemap_extent *fe = elem_buf;
111
112 tprintf("{fe_logical=%" PRI__u64
113 ", fe_physical=%" PRI__u64
114 ", fe_length=%" PRI__u64 ", ",
115 fe->fe_logical, fe->fe_physical, fe->fe_length);
116
117 printflags64(fiemap_extent_flags, fe->fe_flags,
118 "FIEMAP_EXTENT_???");
119 tprints("}");
120
121 return true;
122 }
123 #endif /* HAVE_LINUX_FIEMAP_H */
124
125 int
file_ioctl(struct tcb * const tcp,const unsigned int code,const kernel_ulong_t arg)126 file_ioctl(struct tcb *const tcp, const unsigned int code,
127 const kernel_ulong_t arg)
128 {
129 switch (code) {
130 case FICLONE: /* W */
131 tprintf(", %d", (int) arg);
132 break;
133
134 case FICLONERANGE: { /* W */
135 struct file_clone_range args;
136
137 tprints(", ");
138 if (umove_or_printaddr(tcp, arg, &args))
139 break;
140
141 tprints("{src_fd=");
142 printfd(tcp, args.src_fd);
143 tprintf(", src_offset=%" PRIu64
144 ", src_length=%" PRIu64
145 ", dest_offset=%" PRIu64 "}",
146 (uint64_t) args.src_offset,
147 (uint64_t) args.src_length,
148 (uint64_t) args.dest_offset);
149 break;
150 }
151
152 case FIDEDUPERANGE: { /* RW */
153 struct file_dedupe_range args;
154 struct file_dedupe_range_info info;
155 unsigned int *limit = NULL;
156 unsigned int count = 2;
157 bool rc;
158
159 if (entering(tcp))
160 tprints(", ");
161 else if (syserror(tcp))
162 break;
163 else
164 tprints(" => ");
165
166 if (umove_or_printaddr(tcp, arg, &args))
167 break;
168
169 tprints("{");
170 if (entering(tcp)) {
171 tprintf("src_offset=%" PRIu64
172 ", src_length=%" PRIu64
173 ", dest_count=%hu, ",
174 (uint64_t) args.src_offset,
175 (uint64_t) args.src_length,
176 (uint16_t) args.dest_count);
177 }
178
179 tprints("info=");
180
181 /* Limit how many elements we print in abbrev mode. */
182 if (abbrev(tcp) && args.dest_count > count)
183 limit = &count;
184
185 rc = print_array(tcp, arg + offsetof(typeof(args), info),
186 args.dest_count, &info, sizeof(info),
187 umoven_or_printaddr,
188 print_file_dedupe_range_info, limit);
189
190 tprints("}");
191 if (!rc || exiting(tcp))
192 break;
193
194 return 0;
195 }
196
197 #ifdef HAVE_LINUX_FIEMAP_H
198 case FS_IOC_FIEMAP: {
199 struct fiemap args;
200
201 if (entering(tcp))
202 tprints(", ");
203 else if (syserror(tcp))
204 break;
205 else
206 tprints(" => ");
207
208 if (umove_or_printaddr(tcp, arg, &args))
209 break;
210
211 if (entering(tcp)) {
212 tprintf("{fm_start=%" PRI__u64 ", "
213 "fm_length=%" PRI__u64 ", "
214 "fm_flags=",
215 args.fm_start, args.fm_length);
216 printflags64(fiemap_flags, args.fm_flags,
217 "FIEMAP_FLAG_???");
218 tprintf(", fm_extent_count=%u}", args.fm_extent_count);
219 return 0;
220 }
221
222 tprints("{fm_flags=");
223 printflags64(fiemap_flags, args.fm_flags,
224 "FIEMAP_FLAG_???");
225 tprintf(", fm_mapped_extents=%u",
226 args.fm_mapped_extents);
227 tprints(", fm_extents=");
228 if (abbrev(tcp)) {
229 tprints("...");
230 } else {
231 struct fiemap_extent fe;
232 print_array(tcp,
233 arg + offsetof(typeof(args), fm_extents),
234 args.fm_mapped_extents, &fe, sizeof(fe),
235 umoven_or_printaddr,
236 print_fiemap_extent, 0);
237 }
238 tprints("}");
239
240 break;
241 }
242 #endif /* HAVE_LINUX_FIEMAP_H */
243
244 default:
245 return RVAL_DECODED;
246 };
247
248 return RVAL_DECODED | 1;
249 }
250