You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
249 lines
6.4 KiB
249 lines
6.4 KiB
/* |
|
* Copyright (c) 2016 Jeff Mahoney <jeffm@suse.com> |
|
* All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions |
|
* are met: |
|
* 1. Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* 2. Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in the |
|
* documentation and/or other materials provided with the distribution. |
|
* 3. The name of the author may not be used to endorse or promote products |
|
* derived from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
*/ |
|
|
|
#include "defs.h" |
|
#include <linux/ioctl.h> |
|
#include <linux/fs.h> |
|
|
|
#ifdef HAVE_LINUX_FIEMAP_H |
|
# include <linux/fiemap.h> |
|
# include "xlat/fiemap_flags.h" |
|
# include "xlat/fiemap_extent_flags.h" |
|
#endif |
|
|
|
#ifndef FICLONE |
|
# define FICLONE _IOW(0x94, 9, int) |
|
#endif |
|
|
|
#ifndef FICLONERANGE |
|
# define FICLONERANGE _IOW(0x94, 13, struct file_clone_range) |
|
struct file_clone_range { |
|
int64_t src_fd; |
|
uint64_t src_offset; |
|
uint64_t src_length; |
|
uint64_t dest_offset; |
|
}; |
|
#endif |
|
|
|
#ifndef FIDEDUPERANGE |
|
# define FIDEDUPERANGE _IOWR(0x94, 54, struct file_dedupe_range) |
|
struct file_dedupe_range_info { |
|
int64_t dest_fd; /* in - destination file */ |
|
uint64_t dest_offset; /* in - start of extent in destination */ |
|
uint64_t bytes_deduped; /* out - total # of bytes we were able |
|
* to dedupe from this file. */ |
|
/* status of this dedupe operation: |
|
* < 0 for error |
|
* == FILE_DEDUPE_RANGE_SAME if dedupe succeeds |
|
* == FILE_DEDUPE_RANGE_DIFFERS if data differs |
|
*/ |
|
int32_t status; /* out - see above description */ |
|
uint32_t reserved; /* must be zero */ |
|
}; |
|
|
|
struct file_dedupe_range { |
|
uint64_t src_offset; /* in - start of extent in source */ |
|
uint64_t src_length; /* in - length of extent */ |
|
uint16_t dest_count; /* in - total elements in info array */ |
|
uint16_t reserved1; /* must be zero */ |
|
uint32_t reserved2; /* must be zero */ |
|
struct file_dedupe_range_info info[0]; |
|
}; |
|
#endif |
|
|
|
static bool |
|
print_file_dedupe_range_info(struct tcb *tcp, void *elem_buf, |
|
size_t elem_size, void *data) |
|
{ |
|
const struct file_dedupe_range_info *info = elem_buf; |
|
unsigned int *count = data; |
|
|
|
if (count) { |
|
if (*count == 0) { |
|
tprints("..."); |
|
return false; |
|
} |
|
--*count; |
|
} |
|
|
|
if (entering(tcp)) { |
|
tprints("{dest_fd="); |
|
printfd(tcp, info->dest_fd); |
|
tprintf(", dest_offset=%" PRIu64 "}", |
|
(uint64_t) info->dest_offset); |
|
} else { |
|
tprintf("{bytes_deduped=%" PRIu64 ", status=%d}", |
|
(uint64_t) info->bytes_deduped, info->status); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
#ifdef HAVE_LINUX_FIEMAP_H |
|
static bool |
|
print_fiemap_extent(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data) |
|
{ |
|
const struct fiemap_extent *fe = elem_buf; |
|
|
|
tprintf("{fe_logical=%" PRI__u64 |
|
", fe_physical=%" PRI__u64 |
|
", fe_length=%" PRI__u64 ", ", |
|
fe->fe_logical, fe->fe_physical, fe->fe_length); |
|
|
|
printflags64(fiemap_extent_flags, fe->fe_flags, |
|
"FIEMAP_EXTENT_???"); |
|
tprints("}"); |
|
|
|
return true; |
|
} |
|
#endif /* HAVE_LINUX_FIEMAP_H */ |
|
|
|
int |
|
file_ioctl(struct tcb *const tcp, const unsigned int code, |
|
const kernel_ulong_t arg) |
|
{ |
|
switch (code) { |
|
case FICLONE: /* W */ |
|
tprintf(", %d", (int) arg); |
|
break; |
|
|
|
case FICLONERANGE: { /* W */ |
|
struct file_clone_range args; |
|
|
|
tprints(", "); |
|
if (umove_or_printaddr(tcp, arg, &args)) |
|
break; |
|
|
|
tprints("{src_fd="); |
|
printfd(tcp, args.src_fd); |
|
tprintf(", src_offset=%" PRIu64 |
|
", src_length=%" PRIu64 |
|
", dest_offset=%" PRIu64 "}", |
|
(uint64_t) args.src_offset, |
|
(uint64_t) args.src_length, |
|
(uint64_t) args.dest_offset); |
|
break; |
|
} |
|
|
|
case FIDEDUPERANGE: { /* RW */ |
|
struct file_dedupe_range args; |
|
struct file_dedupe_range_info info; |
|
unsigned int *limit = NULL; |
|
unsigned int count = 2; |
|
bool rc; |
|
|
|
if (entering(tcp)) |
|
tprints(", "); |
|
else if (syserror(tcp)) |
|
break; |
|
else |
|
tprints(" => "); |
|
|
|
if (umove_or_printaddr(tcp, arg, &args)) |
|
break; |
|
|
|
tprints("{"); |
|
if (entering(tcp)) { |
|
tprintf("src_offset=%" PRIu64 |
|
", src_length=%" PRIu64 |
|
", dest_count=%hu, ", |
|
(uint64_t) args.src_offset, |
|
(uint64_t) args.src_length, |
|
(uint16_t) args.dest_count); |
|
} |
|
|
|
tprints("info="); |
|
|
|
/* Limit how many elements we print in abbrev mode. */ |
|
if (abbrev(tcp) && args.dest_count > count) |
|
limit = &count; |
|
|
|
rc = print_array(tcp, arg + offsetof(typeof(args), info), |
|
args.dest_count, &info, sizeof(info), |
|
umoven_or_printaddr, |
|
print_file_dedupe_range_info, limit); |
|
|
|
tprints("}"); |
|
if (!rc || exiting(tcp)) |
|
break; |
|
|
|
return 0; |
|
} |
|
|
|
#ifdef HAVE_LINUX_FIEMAP_H |
|
case FS_IOC_FIEMAP: { |
|
struct fiemap args; |
|
|
|
if (entering(tcp)) |
|
tprints(", "); |
|
else if (syserror(tcp)) |
|
break; |
|
else |
|
tprints(" => "); |
|
|
|
if (umove_or_printaddr(tcp, arg, &args)) |
|
break; |
|
|
|
if (entering(tcp)) { |
|
tprintf("{fm_start=%" PRI__u64 ", " |
|
"fm_length=%" PRI__u64 ", " |
|
"fm_flags=", |
|
args.fm_start, args.fm_length); |
|
printflags64(fiemap_flags, args.fm_flags, |
|
"FIEMAP_FLAG_???"); |
|
tprintf(", fm_extent_count=%u}", args.fm_extent_count); |
|
return 0; |
|
} |
|
|
|
tprints("{fm_flags="); |
|
printflags64(fiemap_flags, args.fm_flags, |
|
"FIEMAP_FLAG_???"); |
|
tprintf(", fm_mapped_extents=%u", |
|
args.fm_mapped_extents); |
|
tprints(", fm_extents="); |
|
if (abbrev(tcp)) { |
|
tprints("..."); |
|
} else { |
|
struct fiemap_extent fe; |
|
print_array(tcp, |
|
arg + offsetof(typeof(args), fm_extents), |
|
args.fm_mapped_extents, &fe, sizeof(fe), |
|
umoven_or_printaddr, |
|
print_fiemap_extent, 0); |
|
} |
|
tprints("}"); |
|
|
|
break; |
|
} |
|
#endif /* HAVE_LINUX_FIEMAP_H */ |
|
|
|
default: |
|
return RVAL_DECODED; |
|
}; |
|
|
|
return RVAL_DECODED | 1; |
|
}
|
|
|