193 files changed, 80411 insertions, 44563 deletions
diff --git a/ntfsprogs/ntfsmove.c b/ntfsprogs/ntfsmove.c new file mode 100755 index 0000000..571808f --- a/dev/null +++ b/ntfsprogs/ntfsmove.c @@ -0,0 +1,923 @@ +/** + * ntfsmove - Part of the Linux-NTFS project. + * + * Copyright (c) 2003 Richard Russon + * Copyright (c) 2003-2005 Anton Altaparmakov + * + * This utility will move files on an NTFS volume. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program (in the main directory of the Linux-NTFS + * distribution in the file COPYING); if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" + +#ifdef HAVE_STDIO_H +#include <stdio.h> +#endif +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#endif +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_STRING_H +#include <string.h> +#endif + +#include "types.h" +#include "attrib.h" +#include "utils.h" +#include "volume.h" +#include "debug.h" +#include "dir.h" +#include "bitmap.h" +#include "ntfsmove.h" +/* #include "version.h" */ +#include "logging.h" + +static const char *EXEC_NAME = "ntfsmove"; +static struct options opts; + +/** + * version - Print version information about the program + * + * Print a copyright statement and a brief description of the program. + * + * Return: none + */ +static void version(void) +{ + ntfs_log_info("\n%s v%s (libntfs-3g) - Move files and directories on an " + "NTFS volume.\n\n", EXEC_NAME, VERSION); + ntfs_log_info("Copyright (c) 2003 Richard Russon\n"); + ntfs_log_info("\n%s\n%s%s\n", ntfs_gpl, ntfs_bugs, ntfs_home); +} + +/** + * usage - Print a list of the parameters to the program + * + * Print a list of the parameters and options for the program. + * + * Return: none + */ +static void usage(void) +{ + ntfs_log_info("\nUsage: %s [options] device file\n" + "\n" + " -S --start Move to the start of the volume\n" + " -B --best Move to the best place on the volume\n" + " -E --end Move to the end of the volume\n" + " -C num --cluster num Move to this cluster offset\n" + "\n" + " -D --no-dirty Do not mark volume dirty (require chkdsk)\n" + " -n --no-action Do not write to disk\n" + " -f --force Use less caution\n" + " -h --help Print this help\n" + " -q --quiet Less output\n" + " -V --version Version information\n" + " -v --verbose More output\n\n", + EXEC_NAME); + ntfs_log_info("%s%s\n", ntfs_bugs, ntfs_home); +} + +/** + * parse_options - Read and validate the programs command line + * + * Read the command line, verify the syntax and parse the options. + * This function is very long, but quite simple. + * + * Return: 1 Success + * 0 Error, one or more problems + */ +static int parse_options(int argc, char **argv) +{ + static const char *sopt = "-BC:DEfh?nqSVv"; + static const struct option lopt[] = { + { "best", no_argument, NULL, 'B' }, + { "cluster", required_argument, NULL, 'C' }, + { "end", no_argument, NULL, 'E' }, + { "force", no_argument, NULL, 'f' }, + { "help", no_argument, NULL, 'h' }, + { "no-action", no_argument, NULL, 'n' }, + { "no-dirty", no_argument, NULL, 'D' }, + { "quiet", no_argument, NULL, 'q' }, + { "start", no_argument, NULL, 'S' }, + { "verbose", no_argument, NULL, 'v' }, + { "version", no_argument, NULL, 'V' }, + { NULL, 0, NULL, 0 } + }; + + int c = -1; + int err = 0; + int ver = 0; + int help = 0; + int levels = 0; + char *end = NULL; + + opterr = 0; /* We'll handle the errors, thank you. */ + + while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) { + switch (c) { + case 1: /* A non-option argument */ + if (!opts.device) { + opts.device = argv[optind-1]; + } else if (!opts.file) { + opts.file = argv[optind-1]; + } else { + opts.device = NULL; + opts.file = NULL; + err++; + } + break; + case 'B': + if (opts.location == 0) + opts.location = NTFS_MOVE_LOC_BEST; + else + opts.location = -1; + break; + case 'C': + if (opts.location == 0) { + opts.location = strtoll(optarg, &end, 0); + if (end && *end) + err++; + } else { + opts.location = -1; + } + break; + case 'D': + opts.nodirty++; + break; + case 'E': + if (opts.location == 0) + opts.location = NTFS_MOVE_LOC_END; + else + opts.location = -1; + break; + case 'f': + opts.force++; + break; + case 'h': + case '?': + if (strncmp (argv[optind-1], "--log-", 6) == 0) { + if (!ntfs_log_parse_option (argv[optind-1])) + err++; + break; + } + help++; + break; + case 'n': + opts.noaction++; + break; + case 'q': + opts.quiet++; + ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET); + break; + case 'S': + if (opts.location == 0) + opts.location = NTFS_MOVE_LOC_START; + else + opts.location = -1; + break; + case 'V': + ver++; + break; + case 'v': + opts.verbose++; + ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE); + break; + default: + ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]); + err++; + break; + } + } + + /* Make sure we're in sync with the log levels */ + levels = ntfs_log_get_levels(); + if (levels & NTFS_LOG_LEVEL_VERBOSE) + opts.verbose++; + if (!(levels & NTFS_LOG_LEVEL_QUIET)) + opts.quiet++; + + if (help || ver) { + opts.quiet = 0; + } else { + if ((opts.device == NULL) || + (opts.file == NULL)) { + if (argc > 1) + ntfs_log_error("You must specify one device and one file.\n"); + err++; + } + + if (opts.quiet && opts.verbose) { + ntfs_log_error("You may not use --quiet and --verbose at the " + "same time.\n"); + err++; + } + + if (opts.location == -1) { + ntfs_log_error("You may only specify one location option: " + "--start, --best, --end or --cluster\n"); + err++; + } else if (opts.location == 0) { + opts.location = NTFS_MOVE_LOC_BEST; + } + } + + if (ver) + version(); + if (help || err) + usage(); + + return (!err && !help && !ver); +} + +#if 0 + +/** + * ntfs_debug_runlist_dump2 - Dump a runlist. + */ +static int ntfs_debug_runlist_dump2(const runlist *rl, int abbr, char *prefix) +{ + //int abbr = 3; /* abbreviate long lists */ + int len = 0; + int i; + int res = 0; + u64 total = 0; + const char *lcn_str[5] = { "HOLE", "NOTMAP", "ENOENT", "EINVAL", "XXXX" }; + + if (!rl) { + ntfs_log_info(" Run list not present.\n"); + return 0; + } + + if (!prefix) + prefix = ""; + + if (abbr) + for (len = 0; rl[len].length; len++) ; + + ntfs_log_info("%s VCN LCN len\n", prefix); + for (i = 0; rl->length; i++, rl++) { + LCN lcn = rl->lcn; + + total += rl->length; + if (abbr) + if (len > 20) { + if ((i == abbr) && (len > (abbr*2))) + ntfs_log_info("%s ... ... ...\n", prefix); + if ((i > (abbr-1)) && (i < (len - (abbr-1)))) + continue; + } + + if (rl->vcn < -1) + res = -1; + + if (lcn < (LCN)0) { + int j = -lcn - 1; + + if ((j < 0) || (j > 4)) { + j = 4; + res = -1; + } + ntfs_log_info("%s%8lld %8s %8lld\n", prefix, + rl->vcn, lcn_str[j], rl->length); + } else + ntfs_log_info("%s%8lld %8lld %8lld\n", prefix, + rl->vcn, rl->lcn, rl->length); + } + ntfs_log_info("%s --------\n", prefix); + ntfs_log_info("%s %8lld\n", prefix, total); + ntfs_log_info("\n"); + return res; +} + +#endif /* if 0 */ + +/** + * resize_nonres_attr + */ +static int resize_nonres_attr(MFT_RECORD *m, ATTR_RECORD *a, const u32 new_size) +{ + int this_attr; + int next_attr; + int tail_size; + int file_size; + int old_size; + u8 *ptr; + + old_size = a->length; + file_size = m->bytes_in_use; + this_attr = p2n(a)-p2n(m); + next_attr = this_attr + a->length; + tail_size = file_size - next_attr; + ptr = (u8*) m; + + /* + ntfs_log_info("old_size = %d\n", old_size); + ntfs_log_info("new_size = %d\n", new_size); + ntfs_log_info("file_size = %d\n", file_size); + ntfs_log_info("this_attr = %d\n", this_attr); + ntfs_log_info("next_attr = %d\n", next_attr); + ntfs_log_info("tail_size = %d\n", tail_size); + */ + + memmove(ptr + this_attr + new_size, ptr + next_attr, tail_size); + + a->length = new_size; + m->bytes_in_use += new_size - old_size; + + return 0; +} + +/** + * calc_attr_length + */ +static int calc_attr_length(ATTR_RECORD *rec, int runlength) +{ + int size; + + if (!rec) + return -1; + if (!rec->non_resident) + return -1; + + size = rec->mapping_pairs_offset + runlength + 7; + size &= 0xFFF8; + return size; +} + +#if 0 + +/** + * dump_runs + */ +static void dump_runs(u8 *buffer, int len) +{ + int i; + ntfs_log_info("RUN: \e[01;31m"); + + for (i = 0; i < len; i++) { + ntfs_log_info(" %02x", buffer[i]); + } + ntfs_log_info("\e[0m\n"); +} + +#endif /* if 0 */ + +/** + * find_unused + */ +static runlist * find_unused(ntfs_volume *vol, s64 size, u64 loc + __attribute__((unused)), int flags __attribute__((unused))) +{ + const int bufsize = 8192; + u8 *buffer; + int clus; + int i; + int curr = 0; + int count = 0; + s64 start = 0; + int bit = 0; + runlist *res = NULL; + + //ntfs_log_info("find_unused\n"); + buffer = malloc(bufsize); + if (!buffer) { + ntfs_log_info("!buffer\n"); + return NULL; + } + + //ntfs_log_info("looking for space for %lld clusters\n", size); + + clus = vol->lcnbmp_na->allocated_size / bufsize; + //ntfs_log_info("clus = %d\n", clus); + + for (i = 0; i < clus; i++) { + int bytes_read, j; + + bytes_read = ntfs_attr_pread(vol->lcnbmp_na, i*bufsize, + bufsize, buffer); + if (bytes_read != bufsize) { + ntfs_log_info("!read\n"); + return NULL; + } + for (j = 0; j < bufsize*8; j++) { + bit = !!test_bit(j & 7, buffer[j>>3]); + if (curr == bit) { + count++; + if ((!bit) && (count >= size)) { + //res = calloc(2, sizeof(*res)); + res = calloc(1, 4096); + if (res) { + res[0].vcn = 0; + res[0].lcn = start; + res[0].length = size; + res[1].lcn = LCN_ENOENT; + } + goto done; + } + } else { + //ntfs_log_info("%d * %d\n", curr, count); + curr = bit; + count = 1; + start = i*bufsize*8 + j; + } + } + } +done: + //ntfs_log_info("%d * %d\n", curr, count); + + free(buffer); + + if (res) { + for (i = 0; i < size; i++) { + if (utils_cluster_in_use(vol, res->lcn + i)) { + ntfs_log_info("ERROR cluster %lld in use\n", + (long long)res->lcn + i); + } + } + } else { + ntfs_log_info("failed\n"); + } + + return res; +} + +/** + * dont_move + * + * Don't let the user move: + * ANY metadata + * Any fragmented MFT records + * The boot file 'ntldr' + */ +static int dont_move(ntfs_inode *ino) +{ + static const ntfschar ntldr[6] = { + const_cpu_to_le16('n'), const_cpu_to_le16('t'), const_cpu_to_le16('l'), + const_cpu_to_le16('d'), const_cpu_to_le16('r'), const_cpu_to_le16('\0') + }; + + ATTR_RECORD *rec; + FILE_NAME_ATTR *name; + + if (utils_is_metadata(ino)) { + ntfs_log_error("metadata\n"); + return 1; + } + + rec = find_first_attribute(AT_ATTRIBUTE_LIST, ino->mrec); + if (rec) { + ntfs_log_error("attribute list\n"); + return 1; + } + + rec = find_first_attribute(AT_FILE_NAME, ino->mrec); + if (!rec) { + ntfs_log_error("extend inode\n"); + return 1; + } + + name = (FILE_NAME_ATTR*) ((u8*)rec + rec->value_offset); + if (ntfs_names_are_equal(ntldr, 5, name->file_name, name->file_name_length, + IGNORE_CASE, ino->vol->upcase, ino->vol->upcase_len)) { + ntfs_log_error("ntldr\n"); + return 1; + } + + return 0; +} + + +/** + * bitmap_alloc + */ +static int bitmap_alloc(ntfs_volume *vol, runlist_element *rl) +{ + int res; + + if (!rl) + return -1; + + res = ntfs_bitmap_set_run(vol->lcnbmp_na, rl->lcn, rl->length); + if (res < 0) { + ntfs_log_error("bitmap alloc returns %d\n", res); + } + + return res; +} + +/** + * bitmap_free + */ +static int bitmap_free(ntfs_volume *vol, runlist_element *rl) +{ + int res; + + if (!rl) + return -1; + + res = ntfs_bitmap_clear_run(vol->lcnbmp_na, rl->lcn, rl->length); + if (res < 0) { + ntfs_log_error("bitmap free returns %d\n", res); + } + + return res; +} + +/** + * data_copy + */ +static int data_copy(ntfs_volume *vol, runlist_element *from, runlist_element *to) +{ + int i; + u8 *buffer; + s64 res = 0; + + if (!vol || !from || !to) + return -1; + if ((from->length != to->length) || (from->lcn < 0) || (to->lcn < 0)) + return -1; + + //ntfs_log_info("data_copy: from 0x%llx to 0x%llx\n", from->lcn, to->lcn); + buffer = malloc(vol->cluster_size); + if (!buffer) { + ntfs_log_info("!buffer\n"); + return -1; + } + + for (i = 0; i < from->length; i++) { + //ntfs_log_info("read cluster at %8lld\n", from->lcn+i); + res = ntfs_pread(vol->dev, (from->lcn+i) * vol->cluster_size, + vol->cluster_size, buffer); + if (res != vol->cluster_size) { + ntfs_log_error("!read\n"); + res = -1; + break; + } + + //ntfs_log_info("write cluster to %8lld\n", to->lcn+i); + res = ntfs_pwrite(vol->dev, (to->lcn+i) * vol->cluster_size, + vol->cluster_size, buffer); + if (res != vol->cluster_size) { + ntfs_log_error("!write %lld\n", (long long)res); + res = -1; + break; + } + } + + free(buffer); + return res; +} + +/** + * move_runlist + * + * validate: + * runlists are the same size + * from in use + * to not in use + * allocate new space + * copy data + * deallocate old space + */ +static s64 move_runlist(ntfs_volume *vol, runlist_element *from, + runlist_element *to) +{ + int i; + + if (!vol || !from || !to) + return -1; + if (from->length != to->length) { + ntfs_log_error("diffsizes\n"); + return -1; + } + + if ((from->lcn < 0) || (to->lcn < 0)) { + ntfs_log_error("invalid runs\n"); + return -1; + } + + for (i = 0; i < from->length; i++) { + if (!utils_cluster_in_use(vol, from->lcn+i)) { + ntfs_log_error("from not in use\n"); + return -1; + } + } + + for (i = 0; i < to->length; i++) { + if (utils_cluster_in_use(vol, to->lcn+i)) { + ntfs_log_error("to is in use\n"); + return -1; + } + } + + if (bitmap_alloc(vol, to) < 0) { + ntfs_log_error("cannot bitmap_alloc\n"); + return -1; + } + + if (data_copy(vol, from, to) < 0) { + ntfs_log_error("cannot data_copy\n"); + return -1; + } + + if (bitmap_free(vol, from) < 0) { + ntfs_log_error("cannot bitmap_free\n"); + return -1; + } + + return 0; +} + + +/**original + * move_datarun + * > 0 Bytes moved / size to be moved + * = 0 Nothing to do + * < 0 Error + */ + +// get size of runlist +// find somewhere to put data +// backup original runlist +// move the data + +// got to get the runlist out of this function +// requires a mrec arg, not an ino (ino->mrec will do for now) +// check size of new runlist before allocating / moving +// replace one datarun with another (by hand) +static s64 move_datarun(ntfs_volume *vol, ntfs_inode *ino, ATTR_RECORD *rec, + runlist_element *run, u64 loc, int flags) +{ + runlist *from; + runlist *to; + int need_from; + int need_to; + int i; + s64 res = -1; + + // find empty space + to = find_unused(vol, run->length, loc, flags); + if (!to) { + ntfs_log_error("!to\n"); + return -1; + } + + to->vcn = run->vcn; + + // copy original runlist + from = ntfs_mapping_pairs_decompress(vol, rec, NULL); + if (!from) { + ntfs_log_info("!from\n"); + return -1; + } + + ntfs_log_info("move %lld,%lld,%lld to %lld,%lld,%lld\n", + (long long)run->vcn, (long long)run->lcn, (long long)run->length, + (long long)to->vcn, (long long)to->lcn, (long long)to->length); + + need_from = ntfs_get_size_for_mapping_pairs(vol, from, 0, INT_MAX); + ntfs_log_info("orig data run = %d bytes\n", need_from); + + //ntfs_debug_runlist_dump2(from, 5, "\t"); + + for (i = 0; to[i].length > 0; i++) { + if (from[i].vcn == run->vcn) { + from[i].lcn = to->lcn; + break; + } + } + + //ntfs_debug_runlist_dump2(from, 5, "\t"); + + need_to = ntfs_get_size_for_mapping_pairs(vol, from, 0, INT_MAX); + ntfs_log_info("new data run = %d bytes\n", need_to); + + need_from = calc_attr_length(rec, need_from); + need_to = calc_attr_length(rec, need_to); + + ntfs_log_info("Before %d, after %d\n", need_from, need_to); + + if (need_from != need_to) { + if (resize_nonres_attr(ino->mrec, rec, need_to) < 0) { + ntfs_log_info("!resize\n"); + return -1; + } + } + + res = move_runlist(vol, run, to); + if (res < 0) { + ntfs_log_error("!move_runlist\n"); + return -1; + } + + // wipe orig runs + memset(((u8*)rec) +rec->mapping_pairs_offset, 0, need_to - rec->mapping_pairs_offset); + + // update data runs + ntfs_mapping_pairs_build(vol, ((u8*)rec) + rec->mapping_pairs_offset, + need_to, from, 0, NULL); + + // commit + ntfs_inode_mark_dirty(ino); + + if (ntfs_inode_sync(ino) < 0) { + ntfs_log_info("!sync\n"); + return -1; + } + + free(from); + free(to); + return res; +} + +/** + * move_attribute - + * + * > 0 Bytes moved / size to be moved + * = 0 Nothing to do + * < 0 Error + */ +static s64 move_attribute(ntfs_volume *vol, ntfs_inode *ino, ATTR_RECORD *rec, + u64 loc, int flags) +{ + int i; + s64 res; + s64 count = 0; + runlist *runs; + + // NTFS_MOVE_LOC_BEST : assess how much space this attribute will need, + // find that space and pass the location to our children. + // Anything else we pass directly to move_datarun. + + runs = ntfs_mapping_pairs_decompress(vol, rec, NULL); + if (!runs) { + ntfs_log_error("!runs\n"); + return -1; + } + + //ntfs_debug_runlist_dump2(runs, 5, "\t"); + + //ntfs_log_info(" VCN LCN Length\n"); + for (i = 0; runs[i].length > 0; i++) { + if (runs[i].lcn == LCN_RL_NOT_MAPPED) { + continue; + } + + res = move_datarun(vol, ino, rec, runs+i, loc, flags); + //ntfs_log_info(" %8lld %8lld %8lld\n", runs[i].vcn, runs[i].lcn, runs[i].length); + if (res < 0) { + ntfs_log_error("!move_datarun\n"); + count = res; + break; + } + count += res; + } + + return count; +} + +/** + * move_file - + * + * > 0 Bytes moved / size to be moved + * = 0 Nothing to do + * < 0 Error + */ +static s64 move_file(ntfs_volume *vol, ntfs_inode *ino, u64 loc, int flags) +{ + char *buffer; + ntfs_attr_search_ctx *ctx; + ATTR_RECORD *rec; + s64 res; + s64 count = 0; + + buffer = malloc(MAX_PATH); + if (!buffer) { + ntfs_log_error("Out of memory\n"); + return -1; + } + + utils_inode_get_name(ino, buffer, MAX_PATH); + + if (dont_move(ino)) { + ntfs_log_error("can't move\n"); + return -1; + } + + ntfs_log_info("Moving %s\n", buffer); + + // NTFS_MOVE_LOC_BEST : assess how much space all the attributes will need, + // find that space and pass the location to our children. + // Anything else we pass directly to move_attribute. + + ctx = ntfs_attr_get_search_ctx(ino, NULL); + + while ((rec = find_attribute(AT_UNUSED, ctx))) { + utils_attr_get_name(vol, rec, buffer, MAX_PATH); + ntfs_log_info("\tAttribute 0x%02x %s is ", rec->type, buffer); + + if (rec->non_resident) { + ntfs_log_info("non-resident. Moving it.\n"); + + res = move_attribute(vol, ino, rec, loc, flags); + if (res < 0) { + count = res; + break; + } + count += res; + } else { + ntfs_log_info("resident.\n\t\tSkipping it.\n"); + } + } + + ntfs_attr_put_search_ctx(ctx); + free(buffer); + return count; +} + + +/** + * main - Begin here + * + * Start from here. + * + * Return: 0 Success, the program worked + * 1 Error, something went wrong + */ +int main(int argc, char *argv[]) +{ + ntfs_volume *vol; + ntfs_inode *inode; + int flags = 0; + int result = 1; + s64 count; + + ntfs_log_set_handler(ntfs_log_handler_outerr); + + if (!parse_options(argc, argv)) + return 1; + + utils_set_locale(); + + if (opts.noaction) + flags |= NTFS_MNT_RDONLY; + if (opts.force) + flags |= NTFS_MNT_RECOVER; + + vol = utils_mount_volume(opts.device, flags); + if (!vol) { + ntfs_log_info("!vol\n"); + return 1; + } + + inode = ntfs_pathname_to_inode(vol, NULL, opts.file); + if (!inode) { + ntfs_log_info("!inode\n"); + return 1; + } + + count = move_file(vol, inode, opts.location, 0); + if ((count > 0) && (!opts.nodirty)) { + + /* Porting note: libntfs-3g does not automatically set or clear + * dirty flags on mount/unmount. It always preserves them until + * they are explicitly changed with ntfs_volume_write_flags. + * This means that the dirty flag is possibly not set, but + * should be set. So we explicitly set it with a call to + * ntfs_volume_write_flags. */ + if(!(vol->flags & VOLUME_IS_DIRTY) && ntfs_volume_write_flags( + vol, vol->flags | VOLUME_IS_DIRTY)) { + ntfs_log_error("Error: Failed to set volume dirty " + "flag (%d (%s))!\n", errno, strerror(errno)); + } + + ntfs_log_info("Relocated %lld bytes\n", (long long)count); + } + if (count >= 0) + result = 0; + + if (result) + ntfs_log_info("failed\n"); + else + ntfs_log_info("success\n"); + + ntfs_inode_close(inode); + ntfs_umount(vol, FALSE); + return result; +} |