mirrors/ntfs-3g
0
0
Fork 0
mirror of https://git.code.sf.net/p/ntfs-3g/ntfs-3g.git synced 2024-11-24 02:25:02 +08:00
Code Issues Packages Projects Releases Wiki Activity
dd0b3bdc7e
ntfs-3g/ntfsprogs/mkntfs.c
antona b10eb4cb2d Minor cleanup
2005-06-06 14:29:47 +00:00

3880 lines
115 KiB
C
Raw Blame History

/**
* mkntfs - Part of the Linux-NTFS project.
*
* Copyright (c) 2000-2005 Anton Altaparmakov
* Copyright (c) 2001-2003 Richard Russon
*
* This utility will create an NTFS 1.2 (Windows NT 4.0) volume on a user
* specified (block) device.
*
* Some things (option handling and determination of mount status) have been
* adapted from e2fsprogs-1.19 and lib/ext2fs/ismounted.c and misc/mke2fs.c in
* particular.
*
* 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 source
* in the file COPYING); if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* WARNING: This program might not work on architectures which do not allow
* unaligned access. For those, the program would need to start using
* get/put_unaligned macros (#include <asm/unaligned.h>), but not doing it yet,
* since NTFS really mostly applies to ia32 only, which does allow unaligned
* accesses. We might not actually have a problem though, since the structs are
* defined as being packed so that might be enough for gcc to insert the
* correct code.
*
* If anyone using a non-little endian and/or an aligned access only CPU tries
* this program please let me know whether it works or not!
*
* Anton Altaparmakov <aia21@cantab.net>
*/
#include "config.h"
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif
#ifdef HAVE_STDIO_H
# include <stdio.h>
#endif
#ifdef HAVE_STDARG_H
# include <stdarg.h>
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_ERRNO_H
# include <errno.h>
#endif
#include <time.h>
#ifdef HAVE_GETOPT_H
# include <getopt.h>
#else
extern char *optarg;
extern int optind;
#endif
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#ifdef HAVE_LINUX_MAJOR_H
# include <linux/major.h>
# ifndef MAJOR
# define MAJOR(dev) ((dev) >> 8)
# define MINOR(dev) ((dev) & 0xff)
# endif
# ifndef IDE_DISK_MAJOR
# ifndef IDE0_MAJOR
# define IDE0_MAJOR 3
# define IDE1_MAJOR 22
# define IDE2_MAJOR 33
# define IDE3_MAJOR 34
# define IDE4_MAJOR 56
# define IDE5_MAJOR 57
# define IDE6_MAJOR 88
# define IDE7_MAJOR 89
# define IDE8_MAJOR 90
# define IDE9_MAJOR 91
# endif
# define IDE_DISK_MAJOR(M) \
((M) == IDE0_MAJOR || (M) == IDE1_MAJOR || \
(M) == IDE2_MAJOR || (M) == IDE3_MAJOR || \
(M) == IDE4_MAJOR || (M) == IDE5_MAJOR || \
(M) == IDE6_MAJOR || (M) == IDE7_MAJOR || \
(M) == IDE8_MAJOR || (M) == IDE9_MAJOR)
# endif
# ifndef SCSI_DISK_MAJOR
# ifndef SCSI_DISK0_MAJOR
# define SCSI_DISK0_MAJOR 8
# define SCSI_DISK1_MAJOR 65
# define SCSI_DISK7_MAJOR 71
# endif
# define SCSI_DISK_MAJOR(M) \
((M) == SCSI_DISK0_MAJOR || \
((M) >= SCSI_DISK1_MAJOR && \
(M) <= SCSI_DISK7_MAJOR))
# endif
#endif
#include <limits.h>
#if defined(linux) && defined(_IO) && !defined(BLKSSZGET)
# define BLKSSZGET _IO(0x12,104) /* Get device sector size in bytse. */
#endif
#include "types.h"
#include "attrib.h"
#include "bitmap.h"
#include "bootsect.h"
#include "device.h"
#include "dir.h"
#include "mft.h"
#include "mst.h"
#include "runlist.h"
#include "utils.h"
#ifdef NO_NTFS_DEVICE_DEFAULT_IO_OPS
# error "No default device io operations! Cannot build mkntfs. \
You need to run ./configure without the --disable-default-device-io-ops \
switch if you want to be able to build the NTFS utilities."
#endif
extern const unsigned char attrdef_ntfs12_array[2400];
extern const unsigned char boot_array[3429];
extern void init_system_file_sd(int sys_file_no, char **sd_val,
int *sd_val_len);
extern void init_upcase_table(ntfschar *uc, u32 uc_len);
/* Page size on ia32. Can change to 8192 on Alpha. */
#define NTFS_PAGE_SIZE 4096
const char *EXEC_NAME = "mkntfs";
/* Need these global so mkntfs_exit can access them. */
char *buf = NULL;
char *buf2 = NULL;
int buf2_size = 0;
int mft_bitmap_size, mft_bitmap_byte_size;
unsigned char *mft_bitmap = NULL;
int lcn_bitmap_byte_size;
unsigned char *lcn_bitmap = NULL;
runlist *rl_mft = NULL, *rl_mft_bmp = NULL, *rl_mftmirr = NULL;
runlist *rl_logfile = NULL, *rl_boot = NULL, *rl_bad = NULL, *rl_index;
INDEX_ALLOCATION *index_block = NULL;
ntfs_volume *vol;
char *dev_name;
struct {
long long part_start_sect; /* start sector of partition on parent
device */
long long nr_sectors; /* size of device in sectors */
long long nr_clusters; /* Note: Win2k treats clusters as
32-bit entities! */
long long volume_size; /* in bytes, or suffixed
with k for kB, m or M for MB, or
g or G for GB, or t or T for TB */
int index_block_size; /* in bytes. */
int mft_size; /* The bigger of 16kB & one cluster. */
long long mft_lcn; /* lcn of $MFT, $DATA attribute. */
long long mftmirr_lcn; /* lcn of $MFTMirr, $DATA. */
long long logfile_lcn; /* lcn of $LogFile, $DATA. */
int logfile_size; /* in bytes, determined from
volume_size. */
int mft_zone_multiplier; /* -z, value from 1 to 4. Default is
1. */
long long mft_zone_end; /* Determined from volume_size and
mft_zone_multiplier, in clusters. */
long long nr_bad_blocks; /* Number of bad clusters. */
long long *bad_blocks; /* Array of bad clusters. */
char *bad_blocks_filename; /* filename, file to read list of
bad clusters from. */
ATTR_DEF *attr_defs; /* filename, attribute defs. */
int attr_defs_len; /* in bytes */
ntfschar *upcase; /* filename, upcase table. */
u32 upcase_len; /* Determined automatically. */
int sector_size; /* -s, in bytes, power of 2, default is
512 bytes. */
int sectors_per_track; /* number of sectors per track on
device */
int heads; /* number of heads on device */
int quiet; /* -q, quiet execution. */
int verbose; /* -v, verbose execution, given twice,
* really verbose execution (debug
* mode). */
int force; /* -F, force fs creation. */
int no_action; /* -n, do not write to device, only
display what would be done. */
char check_bad_blocks; /* read-only test for bad
clusters. */
char quick_format; /* -f or -Q, fast format, don't zero
the volume first. */
char enable_compression; /* -C, enables compression of all files
on the volume by default. */
char disable_indexing; /* -I, disables indexing of file
contents on the volume by default. */
/* -V, print version and exit. */
char use_epoch_time; /* -T, fake the time to be
00:00:00 UTC, Jan 1, 1970. */
} opts;
/**
* mkDprintf - debugging output (-vv); overriden by quiet (-q)
*/
static void mkDprintf(const char *fmt, ...)
__attribute__((format(printf, 1, 2)));
static void mkDprintf(const char *fmt, ...)
{
va_list ap;
if (!opts.quiet && opts.verbose > 1) {
printf("DEBUG: ");
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
}
}
/**
* Eprintf - error output; ignores quiet (-q)
*/
int Eprintf(const char *fmt, ...)
{
va_list ap;
fprintf(stderr, "ERROR: ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
return 0;
}
/* Generate code for Vprintf() function: Verbose output (-v). */
GEN_PRINTF(Vprintf, stdout, &opts.verbose, TRUE)
/* Generate code for Qprintf() function: Quietable output (if not -q). */
GEN_PRINTF(Qprintf, stdout, &opts.quiet, FALSE)
/**
* err_exit - error output and terminate; ignores quiet (-q)
*/
static void err_exit(const char *fmt, ...)
__attribute__((noreturn))
__attribute__((format(printf, 1, 2)));
static void err_exit(const char *fmt, ...)
{
va_list ap;
fprintf(stderr, "ERROR: ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "Aborting...\n");
exit(1);
}
/**
* copyright - print copyright statements
*/
static void copyright(void)
{
fprintf(stderr, "Copyright (c) 2000-2004 Anton Altaparmakov\n"
"Copyright (c) 2001-2003 Richard Russon\n"
"Create an NTFS volume on a user specified (block) "
"device.\n");
}
/**
* license - print license statement
*/
static void license(void)
{
fprintf(stderr, "%s", ntfs_gpl);
}
/**
* usage - print a list of the parameters to the program
*/
static void usage(void) __attribute__ ((noreturn));
static void usage(void)
{
copyright();
fprintf(stderr, "Usage: %s [options] device "
"[number-of-sectors]\n"
" -s sector-size Specify the sector size "
"for the device\n"
" -p part-start-sect Specify the partition "
"start sector\n"
" -H heads Specify the number of "
"heads\n"
" -S sectors-per-track Specify the number of "
"sectors per track\n"
" -c cluster-size Specify the cluster "
"size for the volume\n"
" -L volume-label Set the volume label\n"
" -z mft-zone-multiplier Set the MFT zone "
"multiplier\n"
" -f Perform a quick format\n"
" -Q Perform a quick format\n"
" -C Enable compression on "
"the volume\n"
" -I Disable indexing on the "
"volume\n"
" -n Do not write to disk\n"
" -F Force execution despite "
"errors\n"
" -T Fake the time to be "
"00:00:00 UTC, Jan 1, 1970\n"
" -q Quiet execution\n"
" -v Verbose execution\n"
" -vv Very verbose execution\n"
" -V Display version "
"information\n"
" -l Display licensing "
"information\n"
" -h Display this help\n",
EXEC_NAME);
fprintf(stderr, "%s%s", ntfs_bugs, ntfs_home);
exit(1);
}
/**
* parse_options
*/
static void parse_options(int argc, char *argv[])
{
int c;
long l;
unsigned long u;
char *s;
// Need to have: mft record size, index record size, ntfs version, mft size,
// logfile size, list of bad blocks, check for bad blocks, ...
if (argc && *argv)
EXEC_NAME = *argv;
fprintf(stderr, "%s v%s\n", EXEC_NAME, VERSION);
while ((c = getopt(argc, argv, "c:fh?np:qs:vz:CFTIL:QVl")) != EOF)
switch (c) {
case 'n':
opts.no_action = 1;
break;
case 'c':
l = strtol(optarg, &s, 0);
if (l <= 0 || l > INT_MAX || *s)
err_exit("Invalid cluster size.\n");
vol->cluster_size = l;
break;
case 'f':
case 'Q':
opts.quick_format = 1;
break;
case 'p':
u = strtoul(optarg, &s, 0);
if ((u >= ULONG_MAX && errno == ERANGE) || *s)
err_exit("Invalid partition start sector.\n");
opts.part_start_sect = u;
break;
case 'H':
l = strtol(optarg, &s, 0);
if (l <= 0 || l > INT_MAX || *s)
err_exit("Invalid number of heads.\n");
opts.heads = l;
break;
case 'S':
l = strtol(optarg, &s, 0);
if (l <= 0 || l > INT_MAX || *s)
err_exit("Invalid number of sectors per "
"track.\n");
opts.sectors_per_track = l;
break;
case 'q':
opts.quiet = 1;
break;
case 's':
l = strtol(optarg, &s, 0);
if (l <= 0 || l > INT_MAX || *s)
err_exit("Invalid sector size.\n");
opts.sector_size = l;
break;
case 'v':
opts.verbose++;
break;
case 'z':
l = strtol(optarg, &s, 0);
if (l < 1 || l > 4 || *s)
err_exit("Invalid MFT zone multiplier.\n");
opts.mft_zone_multiplier = l;
break;
case 'C':
opts.enable_compression = 1;
break;
case 'F':
opts.force = 1;
break;
case 'T':
opts.use_epoch_time = 1;
break;
case 'I':
opts.disable_indexing = 1;
break;
case 'L':
vol->vol_name = optarg;
break;
case 'V':
/* Version number already printed, so just exit. */
exit(0);
case 'l':
copyright();
license();
exit(0);
case 'h':
case '?':
default:
usage();
}
if (optind == argc)
usage();
dev_name = argv[optind++];
if (optind < argc) {
u = strtoul(argv[optind++], &s, 0);
if (*s || !u || (u >= ULONG_MAX && errno == ERANGE))
err_exit("Invalid number of sectors: %s\n",
argv[optind - 1]);
opts.nr_sectors = u;
}
if (optind < argc)
usage();
}
/**
* mkntfs_time
*/
static time_t mkntfs_time(void)
{
if (!opts.use_epoch_time)
return time(NULL);
return 0;
}
/**
* append_to_bad_blocks
*
* Note: Might not return.
*/
static void append_to_bad_blocks(unsigned long long block)
{
long long *new_buf;
if (!(opts.nr_bad_blocks & 15)) {
new_buf = realloc(opts.bad_blocks, (opts.nr_bad_blocks + 16) *
sizeof(long long));
if (!new_buf)
err_exit("Reallocating memory for bad blocks list "
"failed: %s\n", strerror(errno));
opts.bad_blocks = new_buf;
}
opts.bad_blocks[opts.nr_bad_blocks++] = block;
}
/**
* mkntfs_write
*/
static __inline__ long long mkntfs_write(struct ntfs_device *dev,
const void *b, long long count)
{
long long bytes_written, total;
int retry;
if (opts.no_action)
return count;
total = 0LL;
retry = 0;
do {
bytes_written = dev->d_ops->write(dev, b, count);
if (bytes_written == -1LL) {
retry = errno;
Eprintf("Error writing to %s: %s\n", vol->dev->d_name,
strerror(errno));
errno = retry;
return bytes_written;
} else if (!bytes_written)
++retry;
else {
count -= bytes_written;
total += bytes_written;
}
} while (count && retry < 3);
if (count)
Eprintf("Failed to complete writing to %s after three retries."
"\n", vol->dev->d_name);
return total;
}
/**
* Write to disk the clusters contained in the runlist @rl taking the data
* from @val. Take @val_len bytes from @val and pad the rest with zeroes.
*
* If the @rl specifies a completely sparse file, @val is allowed to be NULL.
*
* @inited_size if not NULL points to an output variable which will contain
* the actual number of bytes written to disk. I.e. this will not include
* sparse bytes for example.
*
* Return the number of bytes written (minus padding) or -1 on error. Errno
* will be set to the error code.
*
* Note: Might not return.
*/
static s64 ntfs_rlwrite(struct ntfs_device *dev, const runlist *rl,
const char *val, const s64 val_len, s64 *inited_size)
{
s64 bytes_written, total, length, delta;
int retry, i;
if (inited_size)
*inited_size = 0LL;
if (opts.no_action)
return val_len;
total = delta = 0LL;
for (i = 0; rl[i].length; i++) {
length = rl[i].length * vol->cluster_size;
/* Don't write sparse runs. */
if (rl[i].lcn == -1) {
total += length;
if (!val)
continue;
// TODO: Check that *val is really zero at pos and len.
continue;
}
/*
* Break up the write into the real data write and then a write
* of zeroes between the end of the real data and the end of
* the (last) run.
*/
if (total + length > val_len) {
delta = length;
length = val_len - total;
delta -= length;
}
if (dev->d_ops->seek(dev, rl[i].lcn * vol->cluster_size,
SEEK_SET) == (off_t)-1)
return -1LL;
retry = 0;
do {
bytes_written = dev->d_ops->write(dev, val + total,
length);
if (bytes_written == -1LL) {
retry = errno;
Eprintf("Error writing to %s: %s\n",
vol->dev->d_name,
strerror(errno));
errno = retry;
return bytes_written;
}
if (bytes_written) {
length -= bytes_written;
total += bytes_written;
if (inited_size)
*inited_size += bytes_written;
} else
++retry;
} while (length && retry < 3);
if (length) {
Eprintf("Failed to complete writing to %s after three "
"retries.\n", vol->dev->d_name);
return total;
}
}
if (delta) {
int eo;
char *b = (char*)calloc(1, delta);
if (!b)
err_exit("Error allocating internal buffer: "
"%s\n", strerror(errno));
bytes_written = mkntfs_write(dev, b, delta);
eo = errno;
free(b);
errno = eo;
if (bytes_written == -1LL)
return bytes_written;
}
return total;
}
/**
* ucstos - convert unicode-character string to ASCII
* @dest: points to buffer to receive the converted string
* @src: points to string to convert
* @maxlen: size of @dest buffer in bytes
*
* Return the number of characters written to @dest, not including the
* terminating null byte. If a unicode character was encountered which could
* not be converted -1 is returned.
*/
static int ucstos(char *dest, const ntfschar *src, int maxlen)
{
ntfschar u;
int i;
/* Need one byte for null terminator. */
maxlen--;
for (i = 0; i < maxlen; i++) {
u = le16_to_cpu(src[i]);
if (!u)
break;
if (u & 0xff00)
return -1;
dest[i] = u & 0xff;
}
dest[i] = 0;
return i;
}
/**
* stoucs - convert ASCII string to unicode-character string
* @dest: points to buffer to receive the converted string
* @src: points to string to convert
* @maxlen: size of @dest buffer in bytes
*
* Return the number of characters written to @dest, not including the
* terminating null unicode character.
*
* If @maxlen is less than the size of a single unicode character we cannot
* write the terminating null unicode character and hence return -1 with errno
* set to EINVAL.
*/
static int stoucs(ntfschar *dest, const char *src, int maxlen)
{
char c;
int i;
if (maxlen < (int)sizeof(ntfschar)) {
errno = EINVAL;
return -1;
}
/* Convert maxlen from bytes to unicode characters. */
maxlen /= sizeof(ntfschar);
/* Need space for null terminator. */
maxlen--;
for (i = 0; i < maxlen; i++) {
c = src[i];
if (!c)
break;
dest[i] = cpu_to_le16(c);
}
dest[i] = cpu_to_le16('\0');
return i;
}
/**
* dump_resident_attr_val
*
* Note: Might not return.
*/
static void dump_resident_attr_val(ATTR_TYPES type, char *val, u32 val_len)
{
const char *don_t_know = "Don't know what to do with this attribute "
"type yet.";
const char *skip = "Skipping display of $%s attribute value.\n";
const char *todo = "This is still work in progress.";
char *b;
int i, j;
switch (type) {
case AT_STANDARD_INFORMATION:
// TODO
printf("%s\n", todo);
return;
case AT_ATTRIBUTE_LIST:
// TODO
printf("%s\n", todo);
return;
case AT_FILE_NAME:
// TODO
printf("%s\n", todo);
return;
case AT_OBJECT_ID:
// TODO
printf("%s\n", todo);
return;
case AT_SECURITY_DESCRIPTOR:
// TODO
printf("%s\n", todo);
return;
case AT_VOLUME_NAME:
printf("Volume name length = %i\n", (unsigned int)val_len);
if (val_len) {
b = calloc(1, val_len);
if (!b)
err_exit("Failed to allocate internal buffer: "
"%s\n", strerror(errno));
i = ucstos(b, (ntfschar*)val, val_len);
if (i == -1)
printf("Volume name contains non-displayable "
"Unicode characters.\n");
printf("Volume name = %s\n", b);
free(b);
}
return;
case AT_VOLUME_INFORMATION:
#define VOL_INF(x) ((VOLUME_INFORMATION *)(x))
printf("NTFS version %i.%i\n", VOL_INF(val)->major_ver,
VOL_INF(val)->minor_ver);
i = VOL_INF(val)->flags;
#undef VOL_INF
printf("Volume flags = 0x%x: ", i);
if (!i) {
printf("NONE\n");
return;
}
j = 0;
if (i & VOLUME_MODIFIED_BY_CHKDSK) {
printf("VOLUME_MODIFIED_BY_CHKDSK");
j = 1;
}
if (i & VOLUME_REPAIR_OBJECT_ID) {
if (j)
printf(" | ");
printf("VOLUME_REPAIR_OBJECT_ID");
j = 1;
}
if (i & VOLUME_DELETE_USN_UNDERWAY) {
if (j)
printf(" | ");
printf("VOLUME_DELETE_USN_UNDERWAY");
j = 1;
}
if (i & VOLUME_MOUNTED_ON_NT4) {
if (j)
printf(" | ");
printf("VOLUME_MOUNTED_ON_NT4");
j = 1;
}
if (i & VOLUME_UPGRADE_ON_MOUNT) {
if (j)
printf(" | ");
printf("VOLUME_UPGRADE_ON_MOUNT");
j = 1;
}
if (i & VOLUME_RESIZE_LOG_FILE) {
if (j)
printf(" | ");
printf("VOLUME_RESIZE_LOG_FILE");
j = 1;
}
if (i & VOLUME_IS_DIRTY) {
if (j)
printf(" | ");
printf("VOLUME_IS_DIRTY");
j = 1;
}
printf("\n");
return;
case AT_DATA:
printf(skip, "DATA");
return;
case AT_INDEX_ROOT:
// TODO
printf("%s\n", todo);
return;
case AT_INDEX_ALLOCATION:
// TODO
printf("%s\n", todo);
return;
case AT_BITMAP:
printf(skip, "BITMAP");
return;
case AT_REPARSE_POINT:
// TODO
printf("%s\n", todo);
return;
case AT_EA_INFORMATION:
// TODO
printf("%s\n", don_t_know);
return;
case AT_EA:
// TODO
printf("%s\n", don_t_know);
return;
case AT_LOGGED_UTILITY_STREAM:
// TODO
printf("%s\n", don_t_know);
return;
default:
i = le32_to_cpu(type);
printf("Cannot display unknown %s defined attribute type 0x%x"
".\n", (u32)i >=
le32_to_cpu(AT_FIRST_USER_DEFINED_ATTRIBUTE) ?
"user" : "system", i);
}
}
/**
* dump_resident_attr
*/
static void dump_resident_attr(ATTR_RECORD *a)
{
int i;
i = le32_to_cpu(a->value_length);
printf("Attribute value length = %u (0x%x)\n", i, i);
i = le16_to_cpu(a->value_offset);
printf("Attribute value offset = %u (0x%x)\n", i, i);
i = a->resident_flags;
printf("Resident flags = 0x%x: ", i);
if (!i)
printf("NONE\n");
else if (i & ~RESIDENT_ATTR_IS_INDEXED)
printf("UNKNOWN FLAG(S)\n");
else
printf("RESIDENT_ATTR_IS_INDEXED\n");
dump_resident_attr_val(a->type, (char*)a + le16_to_cpu(a->value_offset),
le32_to_cpu(a->value_length));
}
/**
* dump_mapping_pairs_array
*/
static void dump_mapping_pairs_array(char *b __attribute__((unused)),
unsigned int max_len __attribute__((unused)))
{
// TODO
return;
}
/**
* dump_non_resident_attr
*/
static void dump_non_resident_attr(ATTR_RECORD *a)
{
s64 l;
int i;
l = sle64_to_cpu(a->lowest_vcn);
printf("Lowest VCN = %lli (0x%llx)\n", (long long)l,
(unsigned long long)l);
l = sle64_to_cpu(a->highest_vcn);
printf("Highest VCN = %lli (0x%llx)\n", (long long)l,
(unsigned long long)l);
printf("Mapping pairs array offset = 0x%x\n",
le16_to_cpu(a->mapping_pairs_offset));
printf("Compression unit = 0x%x: %sCOMPRESSED\n", a->compression_unit,
a->compression_unit ? "" : "NOT ");
if (sle64_to_cpu(a->lowest_vcn))
printf("Attribute is not the first extent. The following "
"sizes are meaningless:\n");
l = sle64_to_cpu(a->allocated_size);
printf("Allocated size = %lli (0x%llx)\n", (long long)l,
(unsigned long long)l);
l = sle64_to_cpu(a->data_size);
printf("Data size = %lli (0x%llx)\n", (long long)l,
(unsigned long long)l);
l = sle64_to_cpu(a->initialized_size);
printf("Initialized size = %lli (0x%llx)\n",
(long long)l, (unsigned long long)l);
if (a->flags & ATTR_COMPRESSION_MASK) {
l = sle64_to_cpu(a->compressed_size);
printf("Compressed size = %lli (0x%llx)\n",
(long long)l, (unsigned long long)l);
}
i = le16_to_cpu(a->mapping_pairs_offset);
dump_mapping_pairs_array((char*)a + i, le32_to_cpu(a->length) - i);
}
/**
* dump_attr_record
*/
static void dump_attr_record(ATTR_RECORD *a)
{
unsigned int u;
char s[0x200];
int i;
printf("-- Beginning dump of attribute record. --\n");
if (a->type == AT_END) {
printf("Attribute type = 0x%x ($END)\n",
(unsigned int)le32_to_cpu(AT_END));
u = le32_to_cpu(a->length);
printf("Length of resident part = %u (0x%x)\n", u, u);
return;
}
u = le32_to_cpu(a->type);
for (i = 0; opts.attr_defs[i].type; i++)
if (le32_to_cpu(opts.attr_defs[i].type) >= u)
break;
if (opts.attr_defs[i].type) {
// printf("type = 0x%x\n", le32_to_cpu(opts.attr_defs[i].type));
// { char *p = (char*)opts.attr_defs[i].name;
// printf("name = %c%c%c%c%c\n", *p, p[1], p[2], p[3], p[4]);
// }
if (ucstos(s, opts.attr_defs[i].name, sizeof(s)) == -1) {
Eprintf("Could not convert Unicode string to single "
"byte string in current locale.\n");
strncpy(s, "Error converting Unicode string",
sizeof(s));
}
} else
strncpy(s, "UNKNOWN_TYPE", sizeof(s));
printf("Attribute type = 0x%x (%s)\n", u, s);
u = le32_to_cpu(a->length);
printf("Length of resident part = %u (0x%x)\n", u, u);
printf("Attribute is %sresident\n", a->non_resident ? "non-" : "");
printf("Name length = %u unicode characters\n", a->name_length);
printf("Name offset = %u (0x%x)\n", cpu_to_le16(a->name_offset),
cpu_to_le16(a->name_offset));
u = a->flags;
if (a->name_length) {
if (ucstos(s, (ntfschar*)((char*)a +
cpu_to_le16(a->name_offset)),
min(sizeof(s), a->name_length + 1U)) == -1) {
Eprintf("Could not convert Unicode string to single "
"byte string in current locale.\n");
strncpy(s, "Error converting Unicode string",
sizeof(s));
}
printf("Name = %s\n", s);
}
printf("Attribute flags = 0x%x: ", le16_to_cpu(u));
if (!u)
printf("NONE");
else {
int first = TRUE;
if (u & ATTR_COMPRESSION_MASK) {
if (u & ATTR_IS_COMPRESSED) {
printf("ATTR_IS_COMPRESSED");
first = FALSE;
}
if ((u & ATTR_COMPRESSION_MASK) & ~ATTR_IS_COMPRESSED) {
if (!first)
printf(" | ");
else
first = FALSE;
printf("ATTR_UNKNOWN_COMPRESSION");
}
}
if (u & ATTR_IS_ENCRYPTED) {
if (!first)
printf(" | ");
else
first = FALSE;
printf("ATTR_IS_ENCRYPTED");
}
if (u & ATTR_IS_SPARSE) {
if (!first)
printf(" | ");
else
first = FALSE;
printf("ATTR_IS_SPARSE");
}
}
printf("\n");
printf("Attribute instance = %u\n", le16_to_cpu(a->instance));
if (a->non_resident) {
dump_non_resident_attr(a);
} else {
dump_resident_attr(a);
}
}
/**
* dump_mft_record
*/
static void dump_mft_record(MFT_RECORD *m) __attribute__((unused));
static void dump_mft_record(MFT_RECORD *m)
{
ATTR_RECORD *a;
unsigned int u;
MFT_REF r;
printf("-- Beginning dump of mft record. --\n");
u = le32_to_cpu(m->magic);
printf("Mft record signature (magic) = %c%c%c%c\n", u & 0xff,
u >> 8 & 0xff, u >> 16 & 0xff, u >> 24 & 0xff);
u = le16_to_cpu(m->usa_ofs);
printf("Update sequence array offset = %u (0x%x)\n", u, u);
printf("Update sequence array size = %u\n", le16_to_cpu(m->usa_count));
printf("$LogFile sequence number (lsn) = %llu\n",
(unsigned long long)le64_to_cpu(m->lsn));
printf("Sequence number = %u\n", le16_to_cpu(m->sequence_number));
printf("Reference (hard link) count = %u\n",
le16_to_cpu(m->link_count));
u = le16_to_cpu(m->attrs_offset);
printf("First attribute offset = %u (0x%x)\n", u, u);
printf("Flags = %u: ", le16_to_cpu(m->flags));
if (m->flags & MFT_RECORD_IN_USE)
printf("MFT_RECORD_IN_USE");
else
printf("MFT_RECORD_NOT_IN_USE");
if (m->flags & MFT_RECORD_IS_DIRECTORY)
printf(" | MFT_RECORD_IS_DIRECTORY");
printf("\n");
u = le32_to_cpu(m->bytes_in_use);
printf("Bytes in use = %u (0x%x)\n", u, u);
u = le32_to_cpu(m->bytes_allocated);
printf("Bytes allocated = %u (0x%x)\n", u, u);
r = le64_to_cpu(m->base_mft_record);
printf("Base mft record reference:\n\tMft record number = %llu\n\t"
"Sequence number = %u\n", (unsigned long long)MREF(r),
MSEQNO(r));
printf("Next attribute instance = %u\n",
le16_to_cpu(m->next_attr_instance));
a = (ATTR_RECORD*)((char*)m + le16_to_cpu(m->attrs_offset));
printf("-- Beginning dump of attributes within mft record. --\n");
while ((char*)a < (char*)m + le32_to_cpu(m->bytes_in_use)) {
dump_attr_record(a);
if (a->type == AT_END)
break;
a = (ATTR_RECORD*)((char*)a + le32_to_cpu(a->length));
};
printf("-- End of attributes. --\n");
}
/**
* make_room_for_attribute - make room for an attribute inside an mft record
* @m: mft record
* @pos: position at which to make space
* @size: byte size to make available at this position
*
* @pos points to the attribute in front of which we want to make space.
*
* Return 0 on success or -errno on error. Possible error codes are:
*
* -ENOSPC There is not enough space available to complete
* operation. The caller has to make space before calling
* this.
* -EINVAL Can only occur if mkntfs was compiled with -DEBUG. Means
* the input parameters were faulty.
*/
static int make_room_for_attribute(MFT_RECORD *m, char *pos, const u32 size)
{
u32 biu;
if (!size)
return 0;
#ifdef DEBUG
/*
* Rigorous consistency checks. Always return -EINVAL even if more
* appropriate codes exist for simplicity of parsing the return value.
*/
if (size != ((size + 7) & ~7)) {
Eprintf("make_room_for_attribute() received non 8-byte aligned"
"size.\n");
return -EINVAL;
}
if (!m || !pos)
return -EINVAL;
if (pos < (char*)m || pos + size < (char*)m ||
pos > (char*)m + le32_to_cpu(m->bytes_allocated) ||
pos + size > (char*)m + le32_to_cpu(m->bytes_allocated))
return -EINVAL;
/* The -8 is for the attribute terminator. */
if (pos - (char*)m > (int)le32_to_cpu(m->bytes_in_use) - 8)
return -EINVAL;
#endif
biu = le32_to_cpu(m->bytes_in_use);
/* Do we have enough space? */
if (biu + size > le32_to_cpu(m->bytes_allocated))
return -ENOSPC;
/* Move everything after pos to pos + size. */
memmove(pos + size, pos, biu - (pos - (char*)m));
/* Update mft record. */
m->bytes_in_use = cpu_to_le32(biu + size);
return 0;
}
/**
* deallocate_scattered_clusters
*/
static void deallocate_scattered_clusters(const runlist *rl)
{
LCN j;
int i;
if (!rl)
return;
/* Iterate over all runs in the runlist @rl. */
for (i = 0; rl[i].length; i++) {
/* Skip sparse runs. */
if (rl[i].lcn == -1LL)
continue;
/* Deallocate the current run. */
for (j = rl[i].lcn; j < rl[i].lcn + rl[i].length; j++)
ntfs_bit_set(lcn_bitmap, j, 0);
}
}
/**
* allocate_scattered_clusters
* Allocate @clusters and create a runlist of the allocated clusters.
*
* Return the allocated runlist. Caller has to free the runlist when finished
* with it.
*
* On error return NULL and errno is set to the error code.
*
* TODO: We should be returning the size as well, but for mkntfs this is not
* necessary.
*/
static runlist *allocate_scattered_clusters(s64 clusters)
{
runlist *rl = NULL, *rlt;
VCN vcn = 0LL;
LCN lcn, end, prev_lcn = 0LL;
int rlpos = 0;
int rlsize = 0;
s64 prev_run_len = 0LL;
char bit;
end = opts.nr_clusters;
/* Loop until all clusters are allocated. */
while (clusters) {
/* Loop in current zone until we run out of free clusters. */
for (lcn = opts.mft_zone_end; lcn < end; lcn++) {
bit = ntfs_bit_get_and_set(lcn_bitmap, lcn, 1);
if (bit)
continue;
/*
* Reallocate memory if necessary. Make sure we have
* enough for the terminator entry as well.
*/
if ((rlpos + 2) * (int)sizeof(runlist) >= rlsize) {
rlsize += 4096; /* PAGE_SIZE */
rlt = realloc(rl, rlsize);
if (!rlt)
goto err_end;
rl = rlt;
}
/* Coalesce with previous run if adjacent LCNs. */
if (prev_lcn == lcn - prev_run_len) {
rl[rlpos - 1].length = ++prev_run_len;
vcn++;
} else {
rl[rlpos].vcn = vcn++;
rl[rlpos].lcn = prev_lcn = lcn;
rl[rlpos].length = prev_run_len = 1LL;
rlpos++;
}
/* Done? */
if (!--clusters) {
/* Add terminator element and return. */
rl[rlpos].vcn = vcn;
rl[rlpos].lcn = rl[rlpos].length = 0LL;
return rl;
}
}
/* Switch to next zone, decreasing mft zone by factor 2. */
end = opts.mft_zone_end;
opts.mft_zone_end >>= 1;
/* Have we run out of space on the volume? */
if (opts.mft_zone_end <= 0)
goto err_end;
}
return rl;
err_end:
if (rl) {
/* Add terminator element. */
rl[rlpos].vcn = vcn;
rl[rlpos].lcn = -1LL;
rl[rlpos].length = 0LL;
/* Deallocate all allocated clusters. */
deallocate_scattered_clusters(rl);
/* Free the runlist. */
free(rl);
}
return NULL;
}
/**
* insert_positioned_attr_in_mft_record
* Create a non-resident attribute with a predefined on disk location
* specified by the runlist @rl. The clusters specified by @rl are assumed to
* be allocated already.
*
* Return 0 on success and -errno on error.
*/
static int insert_positioned_attr_in_mft_record(MFT_RECORD *m,
const ATTR_TYPES type, const char *name, u32 name_len,
const IGNORE_CASE_BOOL ic, const ATTR_FLAGS flags,
const runlist *rl, const char *val, const s64 val_len)
{
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
u16 hdr_size;
int asize, mpa_size, err, i;
s64 bw = 0, inited_size;
VCN highest_vcn;
ntfschar *uname;
/*
if (base record)
attr_lookup();
else
*/
if (name_len) {
i = (name_len + 1) * sizeof(ntfschar);
uname = (ntfschar*)calloc(1, i);
if (!uname)
return -errno;
name_len = stoucs(uname, name, i);
if (name_len > 0xff) {
free(uname);
return -ENAMETOOLONG;
}
} else
uname = NULL;
/* Check if the attribute is already there. */
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
Eprintf("Failed to allocate attribute search context.\n");
err = -ENOMEM;
goto err_out;
}
if (ic == IGNORE_CASE) {
Eprintf("FIXME: Hit unimplemented code path #1.\n");
err = -ENOTSUP;
goto err_out;
}
if (!ntfs_attr_lookup(type, uname, name_len, ic, 0, NULL, 0, ctx)) {
err = -EEXIST;
goto err_out;
}
if (errno != ENOENT) {
Eprintf("Corrupt inode.\n");
err = -errno;
goto err_out;
}
a = ctx->attr;
if (flags & ATTR_COMPRESSION_MASK) {
Eprintf("Compressed attributes not supported yet.\n");
// FIXME: Compress attribute into a temporary buffer, set
// val accordingly and save the compressed size.
err = -ENOTSUP;
goto err_out;
}
if (flags & (ATTR_IS_ENCRYPTED || ATTR_IS_SPARSE)) {
Eprintf("Encrypted/sparse attributes not supported yet.\n");
err = -ENOTSUP;
goto err_out;
}
if (flags & ATTR_COMPRESSION_MASK) {
hdr_size = 72;
// FIXME: This compression stuff is all wrong. Never mind for
// now. (AIA)
if (val_len)
mpa_size = 0; //get_size_for_compressed_mapping_pairs(rl);
else
mpa_size = 0;
} else {
hdr_size = 64;
if (val_len) {
mpa_size = ntfs_get_size_for_mapping_pairs(vol, rl, 0);
if (mpa_size < 0) {
err = -errno;
Eprintf("Failed to get size for mapping "
"pairs.\n");
goto err_out;
}
} else
mpa_size = 0;
}
/* Mapping pairs array and next attribute must be 8-byte aligned. */
asize = (((int)hdr_size + ((name_len + 7) & ~7) + mpa_size) + 7) & ~7;
/* Get the highest vcn. */
for (i = 0, highest_vcn = 0LL; rl[i].length; i++)
highest_vcn += rl[i].length;
/* Does the value fit inside the allocated size? */
if (highest_vcn * vol->cluster_size < val_len) {
Eprintf("BUG: Allocated size is smaller than data size!\n");
err = -EINVAL;
goto err_out;
}
err = make_room_for_attribute(m, (char*)a, asize);
if (err == -ENOSPC) {
// FIXME: Make space! (AIA)
// can we make it non-resident? if yes, do that.
// does it fit now? yes -> do it.
// m's $DATA or $BITMAP+$INDEX_ALLOCATION resident?
// yes -> make non-resident
// does it fit now? yes -> do it.
// make all attributes non-resident
// does it fit now? yes -> do it.
// m is a base record? yes -> allocate extension record
// does the new attribute fit in there? yes -> do it.
// split up runlist into extents and place each in an extension
// record.
// FIXME: the check for needing extension records should be
// earlier on as it is very quick: asize > m->bytes_allocated?
err = -ENOTSUP;
goto err_out;
}
#ifdef DEBUG
else if (err == -EINVAL) {
fprintf(stderr, "BUG(): in insert_positioned_attribute_in_mft_"
"record(): make_room_for_attribute() returned "
"error: EINVAL!\n");
goto err_out;
}
#endif
a->type = type;
a->length = cpu_to_le32(asize);
a->non_resident = 1;
a->name_length = name_len;
a->name_offset = cpu_to_le16(hdr_size);
a->flags = flags;
a->instance = m->next_attr_instance;
m->next_attr_instance = cpu_to_le16((le16_to_cpu(m->next_attr_instance)
+ 1) & 0xffff);
a->lowest_vcn = cpu_to_le64(0);
a->highest_vcn = cpu_to_le64(highest_vcn - 1LL);
a->mapping_pairs_offset = cpu_to_le16(hdr_size + ((name_len + 7) & ~7));
memset(a->reserved1, 0, sizeof(a->reserved1));
// FIXME: Allocated size depends on compression.
a->allocated_size = cpu_to_le64(highest_vcn * vol->cluster_size);
a->data_size = cpu_to_le64(val_len);
if (name_len)
memcpy((char*)a + hdr_size, uname, name_len << 1);
if (flags & ATTR_COMPRESSION_MASK) {
if (flags & ATTR_COMPRESSION_MASK & ~ATTR_IS_COMPRESSED) {
Eprintf("Unknown compression format. Reverting to "
"standard compression.\n");
a->flags &= ~ATTR_COMPRESSION_MASK;
a->flags |= ATTR_IS_COMPRESSED;
}
a->compression_unit = 4;
inited_size = val_len;
// FIXME: Set the compressed size.
a->compressed_size = cpu_to_le64(0);
// FIXME: Write out the compressed data.
// FIXME: err = build_mapping_pairs_compressed();
err = -ENOTSUP;
} else {
a->compression_unit = 0;
bw = ntfs_rlwrite(vol->dev, rl, val, val_len, &inited_size);
if (bw != val_len)
Eprintf("Error writing non-resident attribute value."
"\n");
err = ntfs_mapping_pairs_build(vol, (u8*)a + hdr_size +
((name_len + 7) & ~7), mpa_size, rl, 0, NULL);
}
a->initialized_size = cpu_to_le64(inited_size);
if (err < 0 || bw != val_len) {
// FIXME: Handle error.
// deallocate clusters
// remove attribute
if (err >= 0)
err = -EIO;
Eprintf("insert_positioned_attr_in_mft_record failed with "
"error %i.\n", err < 0 ? err : (int)bw);
}
err_out:
if (ctx)
ntfs_attr_put_search_ctx(ctx);
if (uname)
free(uname);
return err;
}
/**
* insert_non_resident_attr_in_mft_record
* Return 0 on success and -errno on error.
*/
static int insert_non_resident_attr_in_mft_record(MFT_RECORD *m,
const ATTR_TYPES type, const char *name, u32 name_len,
const IGNORE_CASE_BOOL ic, const ATTR_FLAGS flags,
const char *val, const s64 val_len)
{
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
u16 hdr_size;
int asize, mpa_size, err, i;
runlist *rl = NULL;
s64 bw = 0;
ntfschar *uname;
/*
if (base record)
attr_lookup();
else
*/
if (name_len) {
i = (name_len + 1) * sizeof(ntfschar);
uname = (ntfschar*)calloc(1, i);
if (!uname)
return -errno;
name_len = stoucs(uname, name, i);
if (name_len > 0xff) {
free(uname);
return -ENAMETOOLONG;
}
} else
uname = AT_UNNAMED;
/* Check if the attribute is already there. */
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
Eprintf("Failed to allocate attribute search context.\n");
err = -ENOMEM;
goto err_out;
}
if (ic == IGNORE_CASE) {
Eprintf("FIXME: Hit unimplemented code path #2.\n");
err = -ENOTSUP;
goto err_out;
}
if (!ntfs_attr_lookup(type, uname, name_len, ic, 0, NULL, 0, ctx)) {
err = -EEXIST;
goto err_out;
}
if (errno != ENOENT) {
Eprintf("Corrupt inode.\n");
err = -errno;
goto err_out;
}
a = ctx->attr;
if (flags & ATTR_COMPRESSION_MASK) {
Eprintf("Compressed attributes not supported yet.\n");
// FIXME: Compress attribute into a temporary buffer, set
// val accordingly and save the compressed size.
err = -ENOTSUP;
goto err_out;
}
if (flags & (ATTR_IS_ENCRYPTED || ATTR_IS_SPARSE)) {
Eprintf("Encrypted/sparse attributes not supported yet.\n");
err = -ENOTSUP;
goto err_out;
}
if (val_len) {
rl = allocate_scattered_clusters((val_len +
vol->cluster_size - 1) / vol->cluster_size);
if (!rl) {
err = -errno;
Eprintf("Failed to allocate scattered clusters: %s\n",
strerror(-err));
goto err_out;
}
} else
rl = NULL;
if (flags & ATTR_COMPRESSION_MASK) {
hdr_size = 72;
// FIXME: This compression stuff is all wrong. Never mind for
// now. (AIA)
if (val_len)
mpa_size = 0; //get_size_for_compressed_mapping_pairs(rl);
else
mpa_size = 0;
} else {
hdr_size = 64;
if (val_len) {
mpa_size = ntfs_get_size_for_mapping_pairs(vol, rl, 0);
if (mpa_size < 0) {
err = -errno;
Eprintf("Failed to get size for mapping "
"pairs.\n");
goto err_out;
}
} else
mpa_size = 0;
}
/* Mapping pairs array and next attribute must be 8-byte aligned. */
asize = (((int)hdr_size + ((name_len + 7) & ~7) + mpa_size) + 7) & ~7;
err = make_room_for_attribute(m, (char*)a, asize);
if (err == -ENOSPC) {
// FIXME: Make space! (AIA)
// can we make it non-resident? if yes, do that.
// does it fit now? yes -> do it.
// m's $DATA or $BITMAP+$INDEX_ALLOCATION resident?
// yes -> make non-resident
// does it fit now? yes -> do it.
// make all attributes non-resident
// does it fit now? yes -> do it.
// m is a base record? yes -> allocate extension record
// does the new attribute fit in there? yes -> do it.
// split up runlist into extents and place each in an extension
// record.
// FIXME: the check for needing extension records should be
// earlier on as it is very quick: asize > m->bytes_allocated?
err = -ENOTSUP;
goto err_out;
}
#ifdef DEBUG
else if (err == -EINVAL) {
fprintf(stderr, "BUG(): in insert_non_resident_attribute_in_"
"mft_record(): make_room_for_attribute() "
"returned error: EINVAL!\n");
goto err_out;
}
#endif
a->type = type;
a->length = cpu_to_le32(asize);
a->non_resident = 1;
a->name_length = name_len;
a->name_offset = cpu_to_le16(hdr_size);
a->flags = flags;
a->instance = m->next_attr_instance;
m->next_attr_instance = cpu_to_le16((le16_to_cpu(m->next_attr_instance)
+ 1) & 0xffff);
a->lowest_vcn = cpu_to_le64(0);
for (i = 0; rl[i].length; i++)
;
a->highest_vcn = cpu_to_le64(rl[i].vcn - 1);
a->mapping_pairs_offset = cpu_to_le16(hdr_size + ((name_len + 7) & ~7));
memset(a->reserved1, 0, sizeof(a->reserved1));
// FIXME: Allocated size depends on compression.
a->allocated_size = cpu_to_le64((val_len + (vol->cluster_size - 1)) &
~(vol->cluster_size - 1));
a->data_size = cpu_to_le64(val_len);
a->initialized_size = cpu_to_le64(val_len);
if (name_len)
memcpy((char*)a + hdr_size, uname, name_len << 1);
if (flags & ATTR_COMPRESSION_MASK) {
if (flags & ATTR_COMPRESSION_MASK & ~ATTR_IS_COMPRESSED) {
Eprintf("Unknown compression format. Reverting to "
"standard compression.\n");
a->flags &= ~ATTR_COMPRESSION_MASK;
a->flags |= ATTR_IS_COMPRESSED;
}
a->compression_unit = 4;
// FIXME: Set the compressed size.
a->compressed_size = cpu_to_le64(0);
// FIXME: Write out the compressed data.
// FIXME: err = build_mapping_pairs_compressed();
err = -ENOTSUP;
} else {
a->compression_unit = 0;
bw = ntfs_rlwrite(vol->dev, rl, val, val_len, NULL);
if (bw != val_len)
Eprintf("Error writing non-resident attribute value."
"\n");
err = ntfs_mapping_pairs_build(vol, (u8*)a + hdr_size +
((name_len + 7) & ~7), mpa_size, rl, 0, NULL);
}
if (err < 0 || bw != val_len) {
// FIXME: Handle error.
// deallocate clusters
// remove attribute
if (err >= 0)
err = -EIO;
Eprintf("insert_non_resident_attr_in_mft_record failed with "
"error %lld.\n", (long long) (err < 0 ? err : bw));
}
err_out:
if (ctx)
ntfs_attr_put_search_ctx(ctx);
if (uname && (uname != AT_UNNAMED))
free(uname);
if (rl)
free(rl);
return err;
}
/**
* insert_resident_attr_in_mft_record
* Return 0 on success and -errno on error.
*/
static int insert_resident_attr_in_mft_record(MFT_RECORD *m,
const ATTR_TYPES type, const char *name, u32 name_len,
const IGNORE_CASE_BOOL ic, const ATTR_FLAGS flags,
const RESIDENT_ATTR_FLAGS res_flags,
const char *val, const u32 val_len)
{
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
int asize, err, i;
ntfschar *uname;
/*
if (base record)
ntfs_attr_lookup();
else
*/
if (name_len) {
i = (name_len + 1) * sizeof(ntfschar);
uname = (ntfschar*)calloc(1, i);
if (!uname)
return -errno;
name_len = stoucs(uname, name, i);
if (name_len > 0xff) {
free(uname);
return -ENAMETOOLONG;
}
} else
uname = AT_UNNAMED;
/* Check if the attribute is already there. */
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
Eprintf("Failed to allocate attribute search context.\n");
err = -ENOMEM;
goto err_out;
}
if (ic == IGNORE_CASE) {
Eprintf("FIXME: Hit unimplemented code path #3.\n");
err = -ENOTSUP;
goto err_out;
}
if (!ntfs_attr_lookup(type, uname, name_len, ic, 0, val, val_len,
ctx)) {
err = -EEXIST;
goto err_out;
}
if (errno != ENOENT) {
Eprintf("Corrupt inode.\n");
err = -errno;
goto err_out;
}
a = ctx->attr;
/* sizeof(resident attribute record header) == 24 */
asize = ((24 + ((name_len + 7) & ~7) + val_len) + 7) & ~7;
err = make_room_for_attribute(m, (char*)a, asize);
if (err == -ENOSPC) {
// FIXME: Make space! (AIA)
// can we make it non-resident? if yes, do that.
// does it fit now? yes -> do it.
// m's $DATA or $BITMAP+$INDEX_ALLOCATION resident?
// yes -> make non-resident
// does it fit now? yes -> do it.
// make all attributes non-resident
// does it fit now? yes -> do it.
// m is a base record? yes -> allocate extension record
// does the new attribute fit in there? yes -> do it.
// split up runlist into extents and place each in an extension
// record.
// FIXME: the check for needing extension records should be
// earlier on as it is very quick: asize > m->bytes_allocated?
err = -ENOTSUP;
goto err_out;
}
#ifdef DEBUG
if (err == -EINVAL) {
fprintf(stderr, "BUG(): in insert_resident_attribute_in_mft_"
"record(): make_room_for_attribute() returned "
"error: EINVAL!\n");
goto err_out;
}
#endif
a->type = type;
a->length = cpu_to_le32(asize);
a->non_resident = 0;
a->name_length = name_len;
a->name_offset = cpu_to_le16(24);
a->flags = cpu_to_le16(flags);
a->instance = m->next_attr_instance;
m->next_attr_instance = cpu_to_le16((le16_to_cpu(m->next_attr_instance)
+ 1) & 0xffff);
a->value_length = cpu_to_le32(val_len);
a->value_offset = cpu_to_le16(24 + ((name_len + 7) & ~7));
a->resident_flags = res_flags;
a->reservedR = 0;
if (name_len)
memcpy((char*)a + 24, uname, name_len << 1);
if (val_len)
memcpy((char*)a + le16_to_cpu(a->value_offset), val, val_len);
err_out:
if (ctx)
ntfs_attr_put_search_ctx(ctx);
if (uname && (uname != AT_UNNAMED))
free(uname);
return err;
}
/**
* add_attr_std_info
* Return 0 on success or -errno on error.
*/
static int add_attr_std_info(MFT_RECORD *m, const FILE_ATTR_FLAGS flags)
{
STANDARD_INFORMATION si;
int err;
si.creation_time = utc2ntfs(mkntfs_time());
si.last_data_change_time = si.creation_time;
si.last_mft_change_time = si.creation_time;
si.last_access_time = si.creation_time;
si.file_attributes = flags; /* already LE */
if (vol->major_ver < 3)
memset(&si.reserved12, 0, sizeof(si.reserved12));
else {
si.maximum_versions = cpu_to_le32(0);
si.version_number = cpu_to_le32(0);
si.class_id = cpu_to_le32(0);
/* FIXME: $Secure support... */
si.security_id = cpu_to_le32(0);
/* FIXME: $Quota support... */
si.owner_id = cpu_to_le32(0);
si.quota_charged = cpu_to_le64(0ULL);
/* FIXME: $UsnJrnl support... */
si.usn = cpu_to_le64(0ULL);
}
/* NTFS 1.2: size of si = 48, NTFS 3.0: size of si = 72 */
err = insert_resident_attr_in_mft_record(m, AT_STANDARD_INFORMATION,
NULL, 0, 0, 0, 0, (char*)&si,
vol->major_ver < 3 ? 48 : 72);
if (err < 0)
Eprintf("add_attr_std_info failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_file_name
* Return 0 on success or -errno on error.
*/
static int add_attr_file_name(MFT_RECORD *m, const MFT_REF parent_dir,
const s64 allocated_size, const s64 data_size,
const FILE_ATTR_FLAGS flags, const u16 packed_ea_size,
const u32 reparse_point_tag, const char *file_name,
const FILE_NAME_TYPE_FLAGS file_name_type)
{
ntfs_attr_search_ctx *ctx;
STANDARD_INFORMATION *si;
FILE_NAME_ATTR *fn;
int i, fn_size;
/* Check if the attribute is already there. */
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
Eprintf("Failed to allocate attribute search context.\n");
return -ENOMEM;
}
if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED, 0, 0, 0, NULL, 0,
ctx)) {
int eo = errno;
Eprintf("BUG: Standard information attribute not present in "
"file record\n");
ntfs_attr_put_search_ctx(ctx);
return -eo;
}
si = (STANDARD_INFORMATION*)((char*)ctx->attr +
le16_to_cpu(ctx->attr->value_offset));
i = (strlen(file_name) + 1) * sizeof(ntfschar);
fn_size = sizeof(FILE_NAME_ATTR) + i;
fn = (FILE_NAME_ATTR*)malloc(fn_size);
if (!fn) {
ntfs_attr_put_search_ctx(ctx);
return -errno;
}
fn->parent_directory = parent_dir;
fn->creation_time = si->creation_time;
fn->last_data_change_time = si->last_data_change_time;
fn->last_mft_change_time = si->last_mft_change_time;
fn->last_access_time = si->last_access_time;
ntfs_attr_put_search_ctx(ctx);
fn->allocated_size = cpu_to_le64(allocated_size);
fn->data_size = cpu_to_le64(data_size);
fn->file_attributes = flags;
/* These are in a union so can't have both. */
if (packed_ea_size && reparse_point_tag) {
free(fn);
return -EINVAL;
}
if (packed_ea_size) {
fn->packed_ea_size = cpu_to_le16(packed_ea_size);
fn->reserved = cpu_to_le16(0);
} else
fn->reparse_point_tag = cpu_to_le32(reparse_point_tag);
fn->file_name_type = file_name_type;
i = stoucs(fn->file_name, file_name, i);
if (i < 1) {
free(fn);
return -EINVAL;
}
if (i > 0xff) {
free(fn);
return -ENAMETOOLONG;
}
/* No terminating null in file names. */
fn->file_name_length = i;
fn_size = sizeof(FILE_NAME_ATTR) + i * sizeof(ntfschar);
i = insert_resident_attr_in_mft_record(m, AT_FILE_NAME, NULL, 0, 0,
0, RESIDENT_ATTR_IS_INDEXED, (char*)fn, fn_size);
free(fn);
if (i < 0)
Eprintf("add_attr_file_name failed: %s\n", strerror(-i));
return i;
}
/**
* add_attr_sd
* Create the security descriptor attribute adding the security descriptor @sd
* of length @sd_len to the mft record @m.
*
* Return 0 on success or -errno on error.
*/
static int add_attr_sd(MFT_RECORD *m, const char *sd, const s64 sd_len)
{
int err;
/* Does it fit? NO: create non-resident. YES: create resident. */
if (le32_to_cpu(m->bytes_in_use) + 24 + sd_len >
le32_to_cpu(m->bytes_allocated))
err = insert_non_resident_attr_in_mft_record(m,
AT_SECURITY_DESCRIPTOR, NULL, 0, 0, 0, sd,
sd_len);
else
err = insert_resident_attr_in_mft_record(m,
AT_SECURITY_DESCRIPTOR, NULL, 0, 0, 0, 0, sd,
sd_len);
if (err < 0)
Eprintf("add_attr_sd failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_data
* Return 0 on success or -errno on error.
*/
static int add_attr_data(MFT_RECORD *m, const char *name, const u32 name_len,
const IGNORE_CASE_BOOL ic, const ATTR_FLAGS flags,
const char *val, const s64 val_len)
{
int err;
/*
* Does it fit? NO: create non-resident. YES: create resident.
*
* FIXME: Introduced arbitrary limit of mft record allocated size - 512.
* This is to get around the problem that if $Bitmap/$DATA becomes too
* big, but is just small enough to be resident, we would make it
* resident, and later run out of space when creating the other
* attributes and this would cause us to abort as making resident
* attributes non-resident is not supported yet.
* The proper fix is to support making resident attribute non-resident.
*/
if (le32_to_cpu(m->bytes_in_use) + 24 + val_len >
min(le32_to_cpu(m->bytes_allocated),
le32_to_cpu(m->bytes_allocated) - 512))
err = insert_non_resident_attr_in_mft_record(m, AT_DATA, name,
name_len, ic, flags, val, val_len);
else
err = insert_resident_attr_in_mft_record(m, AT_DATA, name,
name_len, ic, flags, 0, val, val_len);
if (err < 0)
Eprintf("add_attr_data failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_data_positioned
* Create a non-resident data attribute with a predefined on disk location
* specified by the runlist @rl. The clusters specified by @rl are assumed to
* be allocated already.
*
* Return 0 on success or -errno on error.
*/
static int add_attr_data_positioned(MFT_RECORD *m, const char *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const ATTR_FLAGS flags, const runlist *rl,
const char *val, const s64 val_len)
{
int err;
err = insert_positioned_attr_in_mft_record(m, AT_DATA, name, name_len,
ic, flags, rl, val, val_len);
if (err < 0)
Eprintf("add_attr_data_positioned failed: %s\n",
strerror(-err));
return err;
}
/**
* add_attr_vol_name
* Create volume name attribute specifying the volume name @vol_name as a null
* terminated char string of length @vol_name_len (number of characters not
* including the terminating null), which is converted internally to a little
* endian ntfschar string. The name is at least 1 character long and at most
* 0xff characters long (not counting the terminating null).
*
* Return 0 on success or -errno on error.
*/
static int add_attr_vol_name(MFT_RECORD *m, const char *vol_name,
const int vol_name_len)
{
ntfschar *uname;
int i, len;
if (vol_name_len) {
len = (vol_name_len + 1) * sizeof(ntfschar);
uname = calloc(1, len);
if (!uname)
return -errno;
i = (stoucs(uname, vol_name, len) + 1) * sizeof(ntfschar);
if (!i) {
free(uname);
return -EINVAL;
}
if (i > 0xff) {
free(uname);
return -ENAMETOOLONG;
}
} else {
uname = NULL;
len = 0;
}
i = insert_resident_attr_in_mft_record(m, AT_VOLUME_NAME, NULL, 0, 0,
0, 0, (char*)uname, len);
if (uname)
free(uname);
if (i < 0)
Eprintf("add_attr_vol_name failed: %s\n", strerror(-i));
return i;
}
/**
* add_attr_vol_info
* Return 0 on success or -errno on error.
*/
static int add_attr_vol_info(MFT_RECORD *m, const VOLUME_FLAGS flags,
const u8 major_ver, const u8 minor_ver)
{
VOLUME_INFORMATION vi;
int err;
memset(&vi, 0, sizeof(vi));
vi.major_ver = major_ver;
vi.minor_ver = minor_ver;
vi.flags = flags & VOLUME_FLAGS_MASK;
err = insert_resident_attr_in_mft_record(m, AT_VOLUME_INFORMATION, NULL,
0, 0, 0, 0, (char*)&vi, sizeof(vi));
if (err < 0)
Eprintf("add_attr_vol_info failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_index_root
* Return 0 on success or -errno on error.
*/
static int add_attr_index_root(MFT_RECORD *m, const char *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const ATTR_TYPES indexed_attr_type,
const COLLATION_RULES collation_rule,
const u32 index_block_size)
{
INDEX_ROOT *r;
INDEX_ENTRY_HEADER *e;
int err, val_len;
val_len = sizeof(INDEX_ROOT) + sizeof(INDEX_ENTRY_HEADER);
r = (INDEX_ROOT*)malloc(val_len);
if (!r)
return -errno;
r->type = indexed_attr_type == AT_FILE_NAME ? AT_FILE_NAME : 0;
if (indexed_attr_type == AT_FILE_NAME &&
collation_rule != COLLATION_FILE_NAME) {
free(r);
Eprintf("add_attr_index_root: indexed attribute is $FILE_NAME "
"but collation rule is not COLLATION_FILE_NAME.\n");
return -EINVAL;
}
r->collation_rule = collation_rule;
r->index_block_size = cpu_to_le32(index_block_size);
if (index_block_size >= vol->cluster_size) {
if (index_block_size % vol->cluster_size) {
Eprintf("add_attr_index_root: index block size is not "
"a multiple of the cluster size.\n");
free(r);
return -EINVAL;
}
r->clusters_per_index_block = index_block_size /
vol->cluster_size;
} else /* if (vol->cluster_size > index_block_size) */ {
if (index_block_size & (index_block_size - 1)) {
Eprintf("add_attr_index_root: index block size is not "
"a power of 2.\n");
free(r);
return -EINVAL;
}
if (index_block_size < (u32)opts.sector_size) {
Eprintf("add_attr_index_root: index block size is "
"smaller than the sector size.\n");
free(r);
return -EINVAL;
}
r->clusters_per_index_block = index_block_size /
opts.sector_size;
}
memset(&r->reserved, 0, sizeof(r->reserved));
r->index.entries_offset = cpu_to_le32(sizeof(INDEX_HEADER));
r->index.index_length = cpu_to_le32(sizeof(INDEX_HEADER) +
sizeof(INDEX_ENTRY_HEADER));
r->index.allocated_size = r->index.index_length;
r->index.flags = SMALL_INDEX;
memset(&r->index.reserved, 0, sizeof(r->index.reserved));
e = (INDEX_ENTRY_HEADER*)((char*)&r->index +
le32_to_cpu(r->index.entries_offset));
/*
* No matter whether this is a file index or a view as this is a
* termination entry, hence no key value / data is associated with it
* at all. Thus, we just need the union to be all zero.
*/
e->indexed_file = cpu_to_le64(0LL);
e->length = cpu_to_le16(sizeof(INDEX_ENTRY_HEADER));
e->key_length = cpu_to_le16(0);
e->flags = INDEX_ENTRY_END;
e->reserved = cpu_to_le16(0);
err = insert_resident_attr_in_mft_record(m, AT_INDEX_ROOT, name,
name_len, ic, 0, 0, (char*)r, val_len);
free(r);
if (err < 0)
Eprintf("add_attr_index_root failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_index_alloc
* Return 0 on success or -errno on error.
*/
static int add_attr_index_alloc(MFT_RECORD *m, const char *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const char *index_alloc_val, const u32 index_alloc_val_len)
{
int err;
err = insert_non_resident_attr_in_mft_record(m, AT_INDEX_ALLOCATION,
name, name_len, ic, 0, index_alloc_val,
index_alloc_val_len);
if (err < 0)
Eprintf("add_attr_index_alloc failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_bitmap
* Return 0 on success or -errno on error.
*/
static int add_attr_bitmap(MFT_RECORD *m, const char *name, const u32 name_len,
const IGNORE_CASE_BOOL ic, const char *bitmap,
const u32 bitmap_len)
{
int err;
/* Does it fit? NO: create non-resident. YES: create resident. */
if (le32_to_cpu(m->bytes_in_use) + 24 + bitmap_len >
le32_to_cpu(m->bytes_allocated))
err = insert_non_resident_attr_in_mft_record(m, AT_BITMAP, name,
name_len, ic, 0, bitmap, bitmap_len);
else
err = insert_resident_attr_in_mft_record(m, AT_BITMAP, name,
name_len, ic, 0, 0, bitmap, bitmap_len);
if (err < 0)
Eprintf("add_attr_bitmap failed: %s\n", strerror(-err));
return err;
}
/**
* add_attr_bitmap_positioned
* Create a non-resident bitmap attribute with a predefined on disk location
* specified by the runlist @rl. The clusters specified by @rl are assumed to
* be allocated already.
*
* Return 0 on success or -errno on error.
*/
static int add_attr_bitmap_positioned(MFT_RECORD *m, const char *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const runlist *rl, const char *bitmap, const u32 bitmap_len)
{
int err;
err = insert_positioned_attr_in_mft_record(m, AT_BITMAP, name, name_len,
ic, 0, rl, bitmap, bitmap_len);
if (err < 0)
Eprintf("add_attr_bitmap_positioned failed: %s\n",
strerror(-err));
return err;
}
/**
* upgrade_to_large_index
* Create bitmap and index allocation attributes, modify index root
* attribute accordingly and move all of the index entries from the index root
* into the index allocation.
*
* Return 0 on success or -errno on error.
*/
static int upgrade_to_large_index(MFT_RECORD *m, const char *name,
u32 name_len, const IGNORE_CASE_BOOL ic,
INDEX_ALLOCATION **idx)
{
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
INDEX_ROOT *r;
INDEX_ENTRY *re;
INDEX_ALLOCATION *ia_val = NULL;
ntfschar *uname;
char bmp[8];
char *re_start, *re_end;
int i, err, index_block_size;
if (name_len) {
i = (name_len + 1) * sizeof(ntfschar);
uname = (ntfschar*)calloc(1, i);
if (!uname)
return -errno;
name_len = stoucs(uname, name, i);
if (name_len > 0xff) {
free(uname);
return -ENAMETOOLONG;
}
} else
uname = NULL;
/* Find the index root attribute. */
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
Eprintf("Failed to allocate attribute search context.\n");
if (uname)
free(uname);
return -ENOMEM;
}
if (ic == IGNORE_CASE) {
Eprintf("FIXME: Hit unimplemented code path #4.\n");
err = -ENOTSUP;
if (uname)
free(uname);
goto err_out;
}
err = ntfs_attr_lookup(AT_INDEX_ROOT, uname, name_len, ic, 0, NULL, 0,
ctx);
if (uname)
free(uname);
if (err) {
err = -ENOTDIR;
goto err_out;
}
a = ctx->attr;
if (a->non_resident || a->flags) {
err = -EINVAL;
goto err_out;
}
r = (INDEX_ROOT*)((char*)a + le16_to_cpu(a->value_offset));
re_end = (char*)r + le32_to_cpu(a->value_length);
re_start = (char*)&r->index + le32_to_cpu(r->index.entries_offset);
re = (INDEX_ENTRY*)re_start;
index_block_size = le32_to_cpu(r->index_block_size);
memset(bmp, 0, sizeof(bmp));
ntfs_bit_set(bmp, 0ULL, 1);
/* Bitmap has to be at least 8 bytes in size. */
err = add_attr_bitmap(m, name, name_len, ic, (char*)&bmp, sizeof(bmp));
if (err)
goto err_out;
ia_val = calloc(1, index_block_size);
if (!ia_val) {
err = -errno;
goto err_out;
}
/* Setup header. */
ia_val->magic = magic_INDX;
ia_val->usa_ofs = cpu_to_le16(sizeof(INDEX_ALLOCATION));
if (index_block_size >= NTFS_BLOCK_SIZE)
ia_val->usa_count = cpu_to_le16(index_block_size /
NTFS_BLOCK_SIZE + 1);
else {
ia_val->usa_count = cpu_to_le16(1);
Qprintf("Sector size is bigger than index block size. Setting "
"usa_count to 1. If Windows\nchkdsk reports this as "
"corruption, please email linux-ntfs-dev@lists.sf.net\n"
"stating that you saw this message and that the file "
"system created was corrupt.\nThank you.");
}
/* Set USN to 1. */
*(u16*)((char*)ia_val + le16_to_cpu(ia_val->usa_ofs)) =
cpu_to_le16(1);
ia_val->lsn = cpu_to_le64(0);
ia_val->index_block_vcn = cpu_to_le64(0);
ia_val->index.flags = LEAF_NODE;
/* Align to 8-byte boundary. */
ia_val->index.entries_offset = cpu_to_le32((sizeof(INDEX_HEADER) +
le16_to_cpu(ia_val->usa_count) * 2 + 7) & ~7);
ia_val->index.allocated_size = cpu_to_le32(index_block_size -
(sizeof(INDEX_ALLOCATION) - sizeof(INDEX_HEADER)));
/* Find the last entry in the index root and save it in re. */
while ((char*)re < re_end && !(re->flags & INDEX_ENTRY_END)) {
/* Next entry in index root. */
re = (INDEX_ENTRY*)((char*)re + le16_to_cpu(re->length));
}
/* Copy all the entries including the termination entry. */
i = (char*)re - re_start + le16_to_cpu(re->length);
memcpy((char*)&ia_val->index +
le32_to_cpu(ia_val->index.entries_offset), re_start, i);
/* Finish setting up index allocation. */
ia_val->index.index_length = cpu_to_le32(i +
le32_to_cpu(ia_val->index.entries_offset));
/* Move the termination entry forward to the beginning if necessary. */
if ((char*)re > re_start) {
memmove(re_start, (char*)re, le16_to_cpu(re->length));
re = (INDEX_ENTRY*)re_start;
}
/* Now fixup empty index root with pointer to index allocation VCN 0. */
r->index.flags = LARGE_INDEX;
re->flags |= INDEX_ENTRY_NODE;
if (le16_to_cpu(re->length) < sizeof(INDEX_ENTRY_HEADER) + sizeof(VCN))
re->length = cpu_to_le16(le16_to_cpu(re->length) + sizeof(VCN));
r->index.index_length = cpu_to_le32(le32_to_cpu(r->index.entries_offset)
+ le16_to_cpu(re->length));
r->index.allocated_size = r->index.index_length;
/* Resize index root attribute. */
if (ntfs_resident_attr_value_resize(m, a, sizeof(INDEX_ROOT) -
sizeof(INDEX_HEADER) +
le32_to_cpu(r->index.allocated_size))) {
// TODO: Remove the added bitmap!
// Revert index root from index allocation.
err = -errno;
goto err_out;
}
/* Set VCN pointer to 0LL. */
*(VCN*)((char*)re + cpu_to_le16(re->length) - sizeof(VCN)) =
cpu_to_le64(0);
err = ntfs_mst_pre_write_fixup((NTFS_RECORD*)ia_val, index_block_size);
if (err) {
err = -errno;
Eprintf("ntfs_mst_pre_write_fixup() failed in "
"upgrade_to_large_index.\n");
goto err_out;
}
err = add_attr_index_alloc(m, name, name_len, ic, (char*)ia_val,
index_block_size);
ntfs_mst_post_write_fixup((NTFS_RECORD*)ia_val);
if (err) {
// TODO: Remove the added bitmap!
// Revert index root from index allocation.
goto err_out;
}
*idx = ia_val;
return 0;
err_out:
if (ctx)
ntfs_attr_put_search_ctx(ctx);
if (ia_val)
free(ia_val);
return err;
}
/**
* make_room_for_index_entry_in_index_block
* Create space of @size bytes at position @pos inside the index block @idx.
*
* Return 0 on success or -errno on error.
*/
static int make_room_for_index_entry_in_index_block(INDEX_BLOCK *idx,
INDEX_ENTRY *pos, u32 size)
{
u32 biu;
if (!size)
return 0;
#ifdef DEBUG
/*
* Rigorous consistency checks. Always return -EINVAL even if more
* appropriate codes exist for simplicity of parsing the return value.
*/
if (size != ((size + 7) & ~7)) {
Eprintf("make_room_for_index_entry_in_index_block() received "
"non 8-byte aligned size.\n");
return -EINVAL;
}
if (!idx || !pos)
return -EINVAL;
if ((char*)pos < (char*)idx || (char*)pos + size < (char*)idx ||
(char*)pos > (char*)idx + sizeof(INDEX_BLOCK) -
sizeof(INDEX_HEADER) +
le32_to_cpu(idx->index.allocated_size) ||
(char*)pos + size > (char*)idx + sizeof(INDEX_BLOCK) -
sizeof(INDEX_HEADER) +
le32_to_cpu(idx->index.allocated_size))
return -EINVAL;
/* The - sizeof(INDEX_ENTRY_HEADER) is for the index terminator. */
if ((char*)pos - (char*)&idx->index >
(int)le32_to_cpu(idx->index.index_length)
- (int)sizeof(INDEX_ENTRY_HEADER))
return -EINVAL;
#endif
biu = le32_to_cpu(idx->index.index_length);
/* Do we have enough space? */
if (biu + size > le32_to_cpu(idx->index.allocated_size))
return -ENOSPC;
/* Move everything after pos to pos + size. */
memmove((char*)pos + size, (char*)pos, biu - ((char*)pos -
(char*)&idx->index));
/* Update index block. */
idx->index.index_length = cpu_to_le32(biu + size);
return 0;
}
/**
* insert_file_link_in_dir_index
* Insert the fully completed FILE_NAME_ATTR @file_name which is inside
* the file with mft reference @file_ref into the index (allocation) block
* @idx (which belongs to @file_ref's parent directory).
*
* Return 0 on success or -errno on error.
*/
static int insert_file_link_in_dir_index(INDEX_BLOCK *idx, MFT_REF file_ref,
FILE_NAME_ATTR *file_name, u32 file_name_size)
{
int err, i;
INDEX_ENTRY *ie;
char *index_end;
/*
* Lookup dir entry @file_name in dir @idx to determine correct
* insertion location. FIXME: Using a very oversimplified lookup
* method which is sufficient for mkntfs but no good whatsoever in
* real world scenario. (AIA)
*/
index_end = (char*)&idx->index + le32_to_cpu(idx->index.index_length);
ie = (INDEX_ENTRY*)((char*)&idx->index +
le32_to_cpu(idx->index.entries_offset));
/*
* Loop until we exceed valid memory (corruption case) or until we
* reach the last entry.
*/
while ((char*)ie < index_end && !(ie->flags & INDEX_ENTRY_END)) {
/*
#ifdef DEBUG
mkDprintf("file_name_attr1->file_name_length = %i\n",
file_name->file_name_length);
if (file_name->file_name_length) {
char *__buf;
__buf = (char*)calloc(1, file_name->file_name_length +
1);
if (!__buf)
err_exit("Failed to allocate internal buffer: "
"%s\n", strerror(errno));
i = ucstos(__buf, (ntfschar*)&file_name->file_name,
file_name->file_name_length + 1);
if (i == -1)
mkDprintf("Name contains non-displayable "
"Unicode characters.\n");
mkDprintf("file_name_attr1->file_name = %s\n", __buf);
free(__buf);
}
mkDprintf("file_name_attr2->file_name_length = %i\n",
ie->key.file_name.file_name_length);
if (ie->key.file_name.file_name_length) {
char *__buf;
__buf = (char*)calloc(1,
ie->key.file_name.file_name_length + 1);
if (!__buf)
err_exit("Failed to allocate internal buffer: "
"%s\n", strerror(errno));
i = ucstos(__buf, ie->key.file_name.file_name,
ie->key.file_name.file_name_length + 1);
if (i == -1)
mkDprintf("Name contains non-displayable "
"Unicode characters.\n");
mkDprintf("file_name_attr2->file_name = %s\n", __buf);
free(__buf);
}
#endif
*/
i = ntfs_file_values_compare(file_name,
(FILE_NAME_ATTR*)&ie->key.file_name, 1,
IGNORE_CASE, vol->upcase, vol->upcase_len);
/*
* If @file_name collates before ie->key.file_name, there is no
* matching index entry.
*/
if (i == -1)
break;
/* If file names are not equal, continue search. */
if (i)
goto do_next;
/* File names are equal when compared ignoring case. */
/*
* If BOTH file names are in the POSIX namespace, do a case
* sensitive comparison as well. Otherwise the names match so
* we return -EEXIST. FIXME: There are problems with this in a
* real world scenario, when one is POSIX and one isn't, but
* fine for mkntfs where we don't use POSIX namespace at all
* and hence this following code is luxury. (AIA)
*/
if (file_name->file_name_type != FILE_NAME_POSIX ||
ie->key.file_name.file_name_type != FILE_NAME_POSIX)
return -EEXIST;
i = ntfs_file_values_compare(file_name,
(FILE_NAME_ATTR*)&ie->key.file_name, 1,
CASE_SENSITIVE, vol->upcase, vol->upcase_len);
if (i == -1)
break;
/* Complete match. Bugger. Can't insert. */
if (!i)
return -EEXIST;
do_next:
#ifdef DEBUG
/* Next entry. */
if (!ie->length) {
mkDprintf("BUG: ie->length is zero, breaking out of "
"loop.\n");
break;
}
#endif
ie = (INDEX_ENTRY*)((char*)ie + le16_to_cpu(ie->length));
};
i = (sizeof(INDEX_ENTRY_HEADER) + file_name_size + 7) & ~7;
err = make_room_for_index_entry_in_index_block(idx, ie, i);
if (err) {
Eprintf("make_room_for_index_entry_in_index_block failed: "
"%s\n", strerror(-err));
return err;
}
/* Create entry in place and copy file name attribute value. */
ie->indexed_file = file_ref;
ie->length = cpu_to_le16(i);
ie->key_length = cpu_to_le16(file_name_size);
ie->flags = cpu_to_le16(0);
ie->reserved = cpu_to_le16(0);
memcpy((char*)&ie->key.file_name, (char*)file_name, file_name_size);
return 0;
}
/**
* create_hardlink
* Create a file_name_attribute in the mft record @m_file which points to the
* parent directory with mft reference @ref_parent.
*
* Then, insert an index entry with this file_name_attribute in the index
* block @idx of the index allocation attribute of the parent directory.
*
* @ref_file is the mft reference of @m_file.
*
* Return 0 on success or -errno on error.
*/
static int create_hardlink(INDEX_BLOCK *idx, const MFT_REF ref_parent,
MFT_RECORD *m_file, const MFT_REF ref_file,
const s64 allocated_size, const s64 data_size,
const FILE_ATTR_FLAGS flags, const u16 packed_ea_size,
const u32 reparse_point_tag, const char *file_name,
const FILE_NAME_TYPE_FLAGS file_name_type)
{
FILE_NAME_ATTR *fn;
int i, fn_size;
/* Create the file_name attribute. */
i = (strlen(file_name) + 1) * sizeof(ntfschar);
fn_size = sizeof(FILE_NAME_ATTR) + i;
fn = (FILE_NAME_ATTR*)malloc(fn_size);
if (!fn)
return -errno;
fn->parent_directory = ref_parent;
// FIXME: Is this correct? Or do we have to copy the creation_time
// from the std info?
fn->creation_time = utc2ntfs(mkntfs_time());
fn->last_data_change_time = fn->creation_time;
fn->last_mft_change_time = fn->creation_time;
fn->last_access_time = fn->creation_time;
fn->allocated_size = cpu_to_le64(allocated_size);
fn->data_size = cpu_to_le64(data_size);
fn->file_attributes = flags;
/* These are in a union so can't have both. */
if (packed_ea_size && reparse_point_tag) {
free(fn);
return -EINVAL;
}
if (packed_ea_size) {
fn->packed_ea_size = cpu_to_le16(packed_ea_size);
fn->reserved = cpu_to_le16(0);
} else
fn->reparse_point_tag = cpu_to_le32(reparse_point_tag);
fn->file_name_type = file_name_type;
i = stoucs(fn->file_name, file_name, i);
if (i < 1) {
free(fn);
return -EINVAL;
}
if (i > 0xff) {
free(fn);
return -ENAMETOOLONG;
}
/* No terminating null in file names. */
fn->file_name_length = i;
fn_size = sizeof(FILE_NAME_ATTR) + i * sizeof(ntfschar);
/* Increment the link count of @m_file. */
i = le16_to_cpu(m_file->link_count);
if (i == 0xffff) {
Eprintf("Too many hardlinks present already.\n");
free(fn);
return -EINVAL;
}
m_file->link_count = cpu_to_le16(i + 1);
/* Add the file_name to @m_file. */
i = insert_resident_attr_in_mft_record(m_file, AT_FILE_NAME, NULL, 0, 0,
0, RESIDENT_ATTR_IS_INDEXED, (char*)fn, fn_size);
if (i < 0) {
Eprintf("create_hardlink failed adding file name attribute: "
"%s\n", strerror(-i));
free(fn);
/* Undo link count increment. */
m_file->link_count = cpu_to_le16(
le16_to_cpu(m_file->link_count) - 1);
return i;
}
/* Insert the index entry for file_name in @idx. */
i = insert_file_link_in_dir_index(idx, ref_file, fn, fn_size);
if (i < 0) {
Eprintf("create_hardlink failed inserting index entry: %s\n",
strerror(-i));
/* FIXME: Remove the file name attribute from @m_file. */
free(fn);
/* Undo link count increment. */
m_file->link_count = cpu_to_le16(
le16_to_cpu(m_file->link_count) - 1);
return i;
}
free(fn);
return 0;
}
/**
* init_options
*/
static void init_options(void)
{
memset(&opts, 0, sizeof(opts));
opts.sectors_per_track = -1;
opts.heads = -1;
opts.part_start_sect = -1;
opts.index_block_size = 4096;
opts.attr_defs = (ATTR_DEF*)&attrdef_ntfs12_array;
opts.attr_defs_len = sizeof(attrdef_ntfs12_array);
//mkDprintf("Attr_defs table length = %u\n", opts.attr_defs_len);
}
/**
* mkntfs_exit
*/
static void mkntfs_exit(void)
{
if (index_block)
free(index_block);
if (buf)
free(buf);
if (buf2)
free(buf2);
if (lcn_bitmap)
free(lcn_bitmap);
if (mft_bitmap)
free(mft_bitmap);
if (rl_mft)
free(rl_mft);
if (rl_mft_bmp)
free(rl_mft_bmp);
if (rl_mftmirr)
free(rl_mftmirr);
if (rl_logfile)
free(rl_logfile);
if (rl_boot)
free(rl_boot);
if (rl_bad)
free(rl_bad);
if (rl_index)
free(rl_index);
if (opts.bad_blocks)
free(opts.bad_blocks);
if (opts.attr_defs != (const ATTR_DEF*)attrdef_ntfs12_array)
free(opts.attr_defs);
if (!vol)
return;
if (vol->upcase)
free(vol->upcase);
if (vol->dev) {
if (NDevOpen(vol->dev) && vol->dev->d_ops->close(vol->dev))
Eprintf("Warning: Could not close %s: %s\n",
vol->dev->d_name, strerror(errno));
ntfs_device_free(vol->dev);
}
free(vol);
}
/**
* mkntfs_open_partition -
*
* Note: Might not return.
*/
static void mkntfs_open_partition(void)
{
int i;
struct stat sbuf;
unsigned long mnt_flags;
/*
* Allocate and initialize an ntfs device structure and attach it to
* the volume.
*/
if (!(vol->dev = ntfs_device_alloc(dev_name, 0,
&ntfs_device_default_io_ops, NULL)))
err_exit("Could not allocate memory for internal buffer.\n");
/* Open the device for reading or reading and writing. */
if (opts.no_action) {
Qprintf("Running in READ-ONLY mode!\n");
i = O_RDONLY;
} else
i = O_RDWR;
if (vol->dev->d_ops->open(vol->dev, i)) {
if (errno == ENOENT)
err_exit("The device doesn't exist; did you specify "
"it correctly?\n");
err_exit("Could not open %s: %s\n", vol->dev->d_name,
strerror(errno));
}
/* Verify we are dealing with a block device. */
if (vol->dev->d_ops->stat(vol->dev, &sbuf)) {
err_exit("Error getting information about %s: %s\n",
vol->dev->d_name, strerror(errno));
}
if (!S_ISBLK(sbuf.st_mode)) {
Eprintf("%s is not a block device.\n", vol->dev->d_name);
if (!opts.force)
err_exit("Refusing to make a filesystem here!\n");
if (!opts.nr_sectors) {
if (!sbuf.st_size && !sbuf.st_blocks)
err_exit("You must specify the number of "
"sectors.\n");
if (opts.sector_size) {
if (sbuf.st_size)
opts.nr_sectors = sbuf.st_size /
opts.sector_size;
else
opts.nr_sectors = ((s64)sbuf.st_blocks
<< 9) / opts.sector_size;
} else {
if (sbuf.st_size)
opts.nr_sectors = sbuf.st_size / 512;
else
opts.nr_sectors = sbuf.st_blocks;
opts.sector_size = 512;
}
}
fprintf(stderr, "mkntfs forced anyway.\n");
}
#ifdef HAVE_LINUX_MAJOR_H
else if ((IDE_DISK_MAJOR(MAJOR(sbuf.st_rdev)) &&
MINOR(sbuf.st_rdev) % 64 == 0) ||
(SCSI_DISK_MAJOR(MAJOR(sbuf.st_rdev)) &&
MINOR(sbuf.st_rdev) % 16 == 0)) {
Eprintf("%s is entire device, not just one partition.\n",
vol->dev->d_name);
if (!opts.force)
err_exit("Refusing to make a filesystem here!\n");
fprintf(stderr, "mkntfs forced anyway.\n");
}
#endif
/* Make sure the file system is not mounted. */
if (ntfs_check_if_mounted(vol->dev->d_name, &mnt_flags))
Eprintf("Failed to determine whether %s is mounted: %s\n",
vol->dev->d_name, strerror(errno));
else if (mnt_flags & NTFS_MF_MOUNTED) {
Eprintf("%s is mounted.\n", vol->dev->d_name);
if (!opts.force)
err_exit("Refusing to make a filesystem here!\n");
fprintf(stderr, "mkntfs forced anyway. Hope /etc/mtab is "
"incorrect.\n");
}
}
/**
* mkntfs_override_phys_params -
*
* Note: Might not return.
*/
static void mkntfs_override_phys_params(void)
{
/* If user didn't specify the sector size, determine it now. */
if (!opts.sector_size) {
#ifdef BLKSSZGET
int _sect_size = 0;
if (vol->dev->d_ops->ioctl(vol->dev, BLKSSZGET, &_sect_size)
>= 0)
opts.sector_size = _sect_size;
else
#endif
{
Eprintf("No sector size specified for %s and it could "
"not be obtained automatically.\n"
"Assuming sector size is 512 bytes.\n",
vol->dev->d_name);
opts.sector_size = 512;
}
}
/* Validate sector size. */
if ((opts.sector_size - 1) & opts.sector_size ||
opts.sector_size < 256 || opts.sector_size > 4096)
err_exit("sector_size is invalid. It must be a power "
"of two, and it must be\n greater or equal 256 and "
"less than or equal 4096 bytes.\n");
mkDprintf("sector size = %i bytes\n", opts.sector_size);
/* If user didn't specify the number of sectors, determine it now. */
if (!opts.nr_sectors) {
opts.nr_sectors = ntfs_device_size_get(vol->dev,
opts.sector_size);
if (opts.nr_sectors <= 0)
err_exit("ntfs_device_size_get(%s) failed. Please "
"specify it manually.\n",
vol->dev->d_name);
}
mkDprintf("number of sectors = %lld (0x%llx)\n", opts.nr_sectors,
opts.nr_sectors);
/* Reserve the last sector for the backup boot sector. */
opts.nr_sectors--;
/* If user didn't specify the partition start sector, determine it. */
if (opts.part_start_sect < 0) {
opts.part_start_sect = ntfs_device_partition_start_sector_get(
vol->dev);
if (opts.part_start_sect < 0) {
Eprintf("No partition start sector specified for %s "
"and it could not\nbe obtained "
"automatically. Setting it to 0.\n"
"This will cause Windows not to be "
"able to boot from this volume.\n",
vol->dev->d_name);
opts.part_start_sect = 0;
} else if (opts.part_start_sect >> 32) {
Eprintf("No partition start sector specified for %s "
"and the automatically\ndetermined "
"value is too large. Setting it to 0."
" This will cause Windows not\nto be "
"able to boot from this volume.\n",
vol->dev->d_name);
opts.part_start_sect = 0;
}
} else if (opts.part_start_sect >> 32)
err_exit("Invalid partition start sector specified: %lli "
"Maximum is 4294967295 (2^32-1).\n",
opts.part_start_sect);
/* If user didn't specify the sectors per track, determine it now. */
if (opts.sectors_per_track < 0) {
opts.sectors_per_track =
ntfs_device_sectors_per_track_get(vol->dev);
if (opts.sectors_per_track < 0) {
Eprintf("No number of sectors per track specified for "
"%s and\nit could not be obtained "
"automatically. Setting it to 0. "
"This will cause\nWindows not to be "
"able to boot from this volume.\n",
vol->dev->d_name);
opts.sectors_per_track = 0;
} else if (opts.sectors_per_track > 0xffff) {
Eprintf("No number of sectors per track specified for "
"%s and the automatically\ndetermined "
"value is too large. Setting it to 0."
" This will cause Windows not\nto be "
"able to boot from this volume.\n",
vol->dev->d_name);
opts.sectors_per_track = 0;
}
} else if (opts.sectors_per_track > 0xffff)
err_exit("Invalid number of sectors per track specified: %i "
"Maximum is 65535 (0xffff).\n",
opts.sectors_per_track);
/* If user didn't specify the number of heads, determine it now. */
if (opts.heads < 0) {
opts.heads = ntfs_device_heads_get(vol->dev);
if (opts.heads < 0) {
Eprintf("No number of heads specified for %s and it "
"could not\nbe obtained automatically."
" Setting it to 0. This will cause "
"Windows not to\nbe able to boot from "
"this volume.\n", vol->dev->d_name);
opts.heads = 0;
} else if (opts.heads > 0xffff) {
Eprintf("No number of heads specified for %s and the "
"automatically\ndetermined value is "
"too large. Setting it to 0. This "
"will cause Windows not\nto be able "
"to boot from this volume.\n",
vol->dev->d_name);
opts.heads = 0;
}
} else if (opts.heads > 0xffff)
err_exit("Invalid number of heads specified: %i Maximum is "
"65535 (0xffff).\n", opts.heads);
/* If user didn't specify the volume size, determine it now. */
if (!opts.volume_size)
opts.volume_size = opts.nr_sectors * opts.sector_size;
else if (opts.volume_size & (opts.sector_size - 1))
err_exit("volume_size is not a multiple of sector_size.\n");
/* Validate volume size. */
if (opts.volume_size < 1 << 20 /* 1MiB */)
err_exit("Device is too small (%llikiB). Minimum NTFS volume "
"size is 1MiB.\n", opts.volume_size / 1024);
mkDprintf("volume size = %llikiB\n", opts.volume_size / 1024);
/* If user didn't specify the cluster size, determine it now. */
if (!vol->cluster_size) {
if (opts.volume_size <= 512LL << 20) /* <= 512MB */
vol->cluster_size = 512;
else if (opts.volume_size <= 1LL << 30) /* ]512MB-1GB] */
vol->cluster_size = 1024;
else if (opts.volume_size <= 2LL << 30) /* ]1GB-2GB] */
vol->cluster_size = 2048;
else
vol->cluster_size = 4096;
/* For small volumes on devices with large sector sizes. */
if (vol->cluster_size < (u32)opts.sector_size)
vol->cluster_size = opts.sector_size;
/*
* For huge volumes, grow the cluster size until the number of
* clusters fits into 32 bits or the cluster size exceeds the
* maximum limit of 64kiB.
*/
while (opts.volume_size >> (ffs(vol->cluster_size) - 1 + 32)) {
vol->cluster_size <<= 1;
if (vol->cluster_size > 65536)
err_exit("Device is too large to hold an NTFS "
"volume (maximum size is "
"256TiB).\n");
}
}
/* Validate cluster size. */
if (vol->cluster_size & (vol->cluster_size - 1) ||
vol->cluster_size < (u32)opts.sector_size ||
vol->cluster_size > 128 * (u32)opts.sector_size ||
vol->cluster_size > 65536)
err_exit("Cluster_size is invalid. It must be a power of two, "
"be at least\nthe same as sector_size, be maximum "
"64kiB, and the sectors per cluster value has\n"
"to fit inside eight bits. (We do not support larger "
"cluster sizes yet.)\n");
vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
mkDprintf("cluster size = %u bytes\n", (unsigned int)vol->cluster_size);
if (vol->cluster_size > 4096) {
if (opts.enable_compression) {
if (!opts.force)
err_exit("Cluster_size is above 4096 bytes "
"and compression is "
"requested.\nThis is not "
"possible due to limitations "
"in the compression algorithm "
"used by\nWindows.\n");
opts.enable_compression = 0;
}
Qprintf("Warning: compression will be disabled on this volume "
"because it is not\nsupported when the cluster "
"size is above 4096 bytes. This is due to \n"
"limitations in the compression algorithm used "
"by Windows.\n");
}
/* If user didn't specify the number of clusters, determine it now. */
if (!opts.nr_clusters)
opts.nr_clusters = opts.volume_size / vol->cluster_size;
/*
* Check the cluster_size and nr_sectors for consistency with
* sector_size and nr_sectors. And check both of these for consistency
* with volume_size.
*/
if (opts.nr_clusters != (opts.nr_sectors * opts.sector_size) /
vol->cluster_size ||
opts.volume_size / opts.sector_size != opts.nr_sectors ||
opts.volume_size / vol->cluster_size != opts.nr_clusters)
err_exit("Illegal combination of volume/cluster/sector size "
"and/or cluster/sector number.\n");
mkDprintf("number of clusters = %llu (0x%llx)\n", opts.nr_clusters,
opts.nr_clusters);
/* Number of clusters must fit within 32 bits (Win2k limitation). */
if (opts.nr_clusters >> 32) {
if (vol->cluster_size >= 65536)
err_exit("Device is too large to hold an NTFS volume "
"(maximum size is 256TiB).\n");
err_exit("Number of clusters exceeds 32 bits. Please try "
"again with a larger\ncluster size or leave "
"the cluster size unspecified and the "
"smallest possible\ncluster size for the size "
"of the device will be used.\n");
}
}
/**
* mkntfs_initialize_bitmaps -
*
* Note: Might not return.
*/
static void mkntfs_initialize_bitmaps(void)
{
int i, j;
/* Determine lcn bitmap byte size and allocate it. */
lcn_bitmap_byte_size = (opts.nr_clusters + 7) >> 3;
/* Needs to be multiple of 8 bytes. */
lcn_bitmap_byte_size = (lcn_bitmap_byte_size + 7) & ~7;
i = (lcn_bitmap_byte_size + vol->cluster_size - 1) &
~(vol->cluster_size - 1);
mkDprintf("lcn_bitmap_byte_size = %i, allocated = %i\n",
lcn_bitmap_byte_size, i);
lcn_bitmap = (unsigned char *)calloc(1, lcn_bitmap_byte_size);
if (!lcn_bitmap)
err_exit("Failed to allocate internal buffer: %s",
strerror(errno));
/*
* $Bitmap can overlap the end of the volume. Any bits in this region
* must be set. This region also encompasses the backup boot sector.
*/
for (i = opts.nr_clusters; i < lcn_bitmap_byte_size << 3; i++)
ntfs_bit_set(lcn_bitmap, (u64)i, 1);
/*
* Determine mft_size: 16 mft records or 1 cluster, which ever is
* bigger, rounded to multiples of cluster size.
*/
opts.mft_size = (16 * vol->mft_record_size + vol->cluster_size - 1)
& ~(vol->cluster_size - 1);
mkDprintf("MFT size = %i (0x%x) bytes\n", opts.mft_size, opts.mft_size);
/* Determine mft bitmap size and allocate it. */
mft_bitmap_size = opts.mft_size / vol->mft_record_size;
/* Convert to bytes, at least one. */
mft_bitmap_byte_size = (mft_bitmap_size + 7) >> 3;
/* Mft bitmap is allocated in multiples of 8 bytes. */
mft_bitmap_byte_size = (mft_bitmap_byte_size + 7) & ~7;
mkDprintf("mft_bitmap_size = %i, mft_bitmap_byte_size = %i\n",
mft_bitmap_size, mft_bitmap_byte_size);
mft_bitmap = (unsigned char *)calloc(1, mft_bitmap_byte_size);
if (!mft_bitmap)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
/* Create runlist for mft bitmap. */
rl_mft_bmp = (runlist *)malloc(2 * sizeof(runlist));
if (!rl_mft_bmp)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
rl_mft_bmp[0].vcn = 0LL;
/* Mft bitmap is right after $Boot's data. */
j = (8192 + vol->cluster_size - 1) / vol->cluster_size;
rl_mft_bmp[0].lcn = j;
/*
* Size is always one cluster, even though valid data size and
* initialized data size are only 8 bytes.
*/
rl_mft_bmp[1].vcn = rl_mft_bmp[0].length = 1LL;
rl_mft_bmp[1].lcn = -1LL;
rl_mft_bmp[1].length = 0LL;
/* Allocate cluster for mft bitmap. */
ntfs_bit_set(lcn_bitmap, (s64)j, 1);
}
/**
* mkntfs_initialize_rl_mft -
*
* Note: Might not return.
*/
static void mkntfs_initialize_rl_mft(void)
{
int i, j;
/* If user didn't specify the mft lcn, determine it now. */
if (!opts.mft_lcn) {
/*
* We start at the higher value out of 16kiB and just after the
* mft bitmap.
*/
opts.mft_lcn = rl_mft_bmp[0].lcn + rl_mft_bmp[0].length;
if (opts.mft_lcn * vol->cluster_size < 16 * 1024)
opts.mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
vol->cluster_size;
}
mkDprintf("$MFT logical cluster number = 0x%llx\n", opts.mft_lcn);
/* Determine MFT zone size. */
opts.mft_zone_end = opts.nr_clusters;
switch (opts.mft_zone_multiplier) { /* % of volume size in clusters */
case 4:
opts.mft_zone_end = opts.mft_zone_end >> 1; /* 50% */
break;
case 3:
opts.mft_zone_end = opts.mft_zone_end * 3 >> 3; /* 37.5% */
break;
case 2:
opts.mft_zone_end = opts.mft_zone_end >> 2; /* 25% */
break;
/* case 1: */
default:
opts.mft_zone_end = opts.mft_zone_end >> 3; /* 12.5% */
break;
}
mkDprintf("MFT zone size = %lldkiB\n", opts.mft_zone_end / 1024);
/*
* The mft zone begins with the mft data attribute, not at the beginning
* of the device.
*/
opts.mft_zone_end += opts.mft_lcn;
/* Create runlist for mft. */
rl_mft = (runlist *)malloc(2 * sizeof(runlist));
if (!rl_mft)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
rl_mft[0].vcn = 0LL;
rl_mft[0].lcn = opts.mft_lcn;
/* We already rounded mft size up to a cluster. */
j = opts.mft_size / vol->cluster_size;
rl_mft[1].vcn = rl_mft[0].length = j;
rl_mft[1].lcn = -1LL;
rl_mft[1].length = 0LL;
/* Allocate clusters for mft. */
for (i = 0; i < j; i++)
ntfs_bit_set(lcn_bitmap, opts.mft_lcn + i, 1);
/* Determine mftmirr_lcn (middle of volume). */
opts.mftmirr_lcn = (opts.nr_sectors * opts.sector_size >> 1)
/ vol->cluster_size;
mkDprintf("$MFTMirr logical cluster number = 0x%llx\n",
opts.mftmirr_lcn);
/* Create runlist for mft mirror. */
rl_mftmirr = (runlist *)malloc(2 * sizeof(runlist));
if (!rl_mftmirr)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
rl_mftmirr[0].vcn = 0LL;
rl_mftmirr[0].lcn = opts.mftmirr_lcn;
/*
* The mft mirror is either 4kb (the first four records) or one cluster
* in size, which ever is bigger. In either case, it contains a
* byte-for-byte identical copy of the beginning of the mft (i.e. either
* ther first four records (4kb) or the first cluster worth of records,
* whichever is bigger).
*/
j = (4 * vol->mft_record_size + vol->cluster_size - 1) / vol->cluster_size;
rl_mftmirr[1].vcn = rl_mftmirr[0].length = j;
rl_mftmirr[1].lcn = -1LL;
rl_mftmirr[1].length = 0LL;
/* Allocate clusters for mft mirror. */
for (i = 0; i < j; i++)
ntfs_bit_set(lcn_bitmap, opts.mftmirr_lcn + i, 1);
opts.logfile_lcn = opts.mftmirr_lcn + j;
mkDprintf("$LogFile logical cluster number = 0x%llx\n",
opts.logfile_lcn);
}
/**
* mkntfs_initialize_rl_logfile -
*
* Note: Might not return.
*/
static void mkntfs_initialize_rl_logfile(void)
{
int i, j;
/* Create runlist for log file. */
rl_logfile = (runlist *)malloc(2 * sizeof(runlist));
if (!rl_logfile)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
rl_logfile[0].vcn = 0LL;
rl_logfile[0].lcn = opts.logfile_lcn;
/*
* Determine logfile_size from volume_size (rounded up to a cluster),
* making sure it does not overflow the end of the volume.
*/
if (opts.volume_size < 2048LL * 1024) /* < 2MiB */
opts.logfile_size = 256LL * 1024; /* -> 256kiB */
else if (opts.volume_size < 4000000LL) /* < 4MB */
opts.logfile_size = 512LL * 1024; /* -> 512kiB */
else if (opts.volume_size <= 200LL * 1024 * 1024)/* < 200MiB */
opts.logfile_size = 2048LL * 1024; /* -> 2MiB */
else if (opts.volume_size >= 400LL << 20) /* > 400MiB */
opts.logfile_size = 4 << 20; /* -> 4MiB */
else
opts.logfile_size = (opts.volume_size / 100) &
~(vol->cluster_size - 1);
j = opts.logfile_size / vol->cluster_size;
while (rl_logfile[0].lcn + j >= opts.nr_clusters) {
/*
* $Logfile would overflow volume. Need to make it smaller than
* the standard size. It's ok as we are creating a non-standard
* volume anyway if it is that small.
*/
opts.logfile_size >>= 1;
j = opts.logfile_size / vol->cluster_size;
}
opts.logfile_size = (opts.logfile_size + vol->cluster_size - 1) &
~(vol->cluster_size - 1);
mkDprintf("$LogFile (journal) size = %ikiB\n",
opts.logfile_size / 1024);
/*
* FIXME: The 256kiB limit is arbitrary. Should find out what the real
* minimum requirement for Windows is so it doesn't blue screen.
*/
if (opts.logfile_size < 256 << 10)
err_exit("$LogFile would be created with invalid size. This "
"is not allowed as it would cause Windows to "
"blue screen and during boot.\n");
rl_logfile[1].vcn = rl_logfile[0].length = j;
rl_logfile[1].lcn = -1LL;
rl_logfile[1].length = 0LL;
/* Allocate clusters for log file. */
for (i = 0; i < j; i++)
ntfs_bit_set(lcn_bitmap, opts.logfile_lcn + i, 1);
}
/**
* mkntfs_initialize_rl_boot -
*
* Note: Might not return.
*/
static void mkntfs_initialize_rl_boot(void)
{
int i, j;
/* Create runlist for $Boot. */
rl_boot = (runlist *)malloc(2 * sizeof(runlist));
if (!rl_boot)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
rl_boot[0].vcn = 0LL;
rl_boot[0].lcn = 0LL;
/*
* $Boot is always 8192 (0x2000) bytes or 1 cluster, whichever is
* bigger.
*/
j = (8192 + vol->cluster_size - 1) / vol->cluster_size;
rl_boot[1].vcn = rl_boot[0].length = j;
rl_boot[1].lcn = -1LL;
rl_boot[1].length = 0LL;
/* Allocate clusters for $Boot. */
for (i = 0; i < j; i++)
ntfs_bit_set(lcn_bitmap, 0LL + i, 1);
}
/**
* mkntfs_initialize_rl_bad -
*
* Note: Might not return.
*/
static void mkntfs_initialize_rl_bad(void)
{
/* Create runlist for $BadClus, $DATA named stream $Bad. */
rl_bad = (runlist *)malloc(2 * sizeof(runlist));
if (!rl_bad)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
rl_bad[0].vcn = 0LL;
rl_bad[0].lcn = -1LL;
/*
* $BadClus named stream $Bad contains the whole volume as a single
* sparse runlist entry.
*/
rl_bad[1].vcn = rl_bad[0].length = opts.nr_clusters;
rl_bad[1].lcn = -1LL;
rl_bad[1].length = 0LL;
// TODO: Mark bad blocks as such.
}
/**
* mkntfs_fill_device_with_zeroes -
*
* Note: Might not return.
*/
static void mkntfs_fill_device_with_zeroes(void)
{
/*
* If not quick format, fill the device with 0s.
* FIXME: Except bad blocks! (AIA)
*/
int i;
ssize_t bw;
unsigned long long position, mid_clust;
float progress_inc = (float)opts.nr_clusters / 100;
Qprintf("Initialising device with zeroes: 0%%");
fflush(stdout);
mid_clust = (opts.volume_size >> 1) / vol->cluster_size;
for (position = 0; position < (unsigned long long)opts.nr_clusters;
position++) {
if (!(position % (int)(progress_inc+1))) {
Qprintf("\b\b\b\b%3.0f%%", position /
progress_inc);
fflush(stdout);
}
bw = mkntfs_write(vol->dev, buf, vol->cluster_size);
if (bw != (ssize_t)vol->cluster_size) {
if (bw != -1 || errno != EIO)
err_exit("This should not happen.\n");
if (!position)
err_exit("Error: Cluster zero is bad. "
"Cannot create NTFS file "
"system.\n");
if (position == mid_clust &&
(vol->major_ver < 1 ||
(vol->major_ver == 1 &&
vol->minor_ver < 2)))
err_exit("Error: Bad cluster found in "
"location reserved for system "
"file $Boot.\n");
/* Add the baddie to our bad blocks list. */
append_to_bad_blocks(position);
Qprintf("\nFound bad cluster (%lld). Adding to "
"list of bad blocks.\nInitialising "
"device with zeroes: %3.0f%%", position,
position / progress_inc);
/* Seek to next cluster. */
vol->dev->d_ops->seek(vol->dev,
((off_t)position + 1) *
vol->cluster_size, SEEK_SET);
}
}
Qprintf("\b\b\b\b100%%");
position = (opts.volume_size & (vol->cluster_size - 1)) /
opts.sector_size;
for (i = 0; (unsigned long)i < position; i++) {
bw = mkntfs_write(vol->dev, buf, opts.sector_size);
if (bw != opts.sector_size) {
if (bw != -1 || errno != EIO)
err_exit("This should not happen.\n");
else if (i + 1ull == position &&
(vol->major_ver >= 2 ||
(vol->major_ver == 1 &&
vol->minor_ver >= 2)))
err_exit("Error: Bad cluster found in "
"location reserved for system "
"file $Boot.\n");
/* Seek to next sector. */
vol->dev->d_ops->seek(vol->dev,
opts.sector_size, SEEK_CUR);
}
}
Qprintf(" - Done.\n");
}
static void create_file_volume(MFT_RECORD *m, MFT_REF root_ref, VOLUME_FLAGS fl)
{
int i, err;
char *sd;
Vprintf("Creating $Volume (mft record 3)\n");
m = (MFT_RECORD*)(buf + 3 * vol->mft_record_size);
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_Volume, FILE_Volume), 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$Volume", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_Volume, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (!err)
err = add_attr_data(m, NULL, 0, 0, 0, NULL, 0);
if (!err)
err = add_attr_vol_name(m, vol->vol_name, vol->vol_name ?
strlen(vol->vol_name) : 0);
if (!err) {
if (fl & VOLUME_IS_DIRTY)
Qprintf("Setting the volume dirty so check disk runs "
"on next reboot into Windows.\n");
err = add_attr_vol_info(m, fl, vol->major_ver, vol->minor_ver);
}
if (err < 0)
err_exit("Couldn't create $Volume: %s\n", strerror(-err));
}
/**
* create_backup_boot_sector
*
* Return 0 on success or 1 if it couldn't be created.
*/
static int create_backup_boot_sector(char *buff, int size)
{
ssize_t bw;
int _e = errno;
const char *_s;
Vprintf("Creating backup boot sector.\n");
/*
* Write the first max(512, opts.sector_size) bytes from buf to the
* last sector.
*/
if (vol->dev->d_ops->seek(vol->dev, (opts.nr_sectors + 1) *
opts.sector_size - size, SEEK_SET) == (off_t)-1)
goto bb_err;
bw = mkntfs_write(vol->dev, buff, size);
if (bw == size)
return 0;
if (bw == -1LL)
_s = strerror(_e);
else
_s = "unknown error";
if (bw != -1LL || (bw == -1LL && _e != ENOSPC)) {
err_exit("Couldn't write backup boot sector: %s\n", _s);
bb_err:
Eprintf("Seek failed: %s\n", strerror(errno));
}
Eprintf("Couldn't write backup boot sector. This is due to a "
"limitation in the\nLinux kernel. This is not "
"a major problem as Windows check disk will "
"create the\nbackup boot sector when it "
"is run on your next boot into Windows.\n");
return 1;
}
/**
* mkntfs_create_root_structures -
*
* Note: Might not return.
*/
static void mkntfs_create_root_structures(void)
{
NTFS_BOOT_SECTOR *bs;
ATTR_RECORD *a;
MFT_RECORD *m;
MFT_REF root_ref;
int i, j, err;
char *sd;
VOLUME_FLAGS volume_flags = 0;
Qprintf("Creating NTFS volume structures.\n");
/*
* Setup an empty mft record. Note, we can just give 0 as the mft
* reference as we are creating an NTFS 1.2 volume for which the mft
* reference is ignored by ntfs_mft_record_layout().
*/
if (ntfs_mft_record_layout(vol, 0, (MFT_RECORD *)buf))
err_exit("Error: Failed to layout mft record.\n");
#if 0
if (!opts.quiet && opts.verbose > 1)
dump_mft_record((MFT_RECORD*)buf);
#endif
/*
* Copy the mft record onto all 16 records in the buffer and setup the
* sequence numbers of each system file to equal the mft record number
* of that file (only for $MFT is the sequence number 1 rather than 0).
*/
for (i = 1; i < 16; i++) {
m = (MFT_RECORD*)(buf + i * vol->mft_record_size);
memcpy(m, buf, vol->mft_record_size);
m->sequence_number = cpu_to_le16(i);
}
/*
* If a cluster contains more than the 16 system files, fill the rest
* with empty, formatted records.
*/
if (vol->cluster_size > 16 * vol->mft_record_size) {
for (i = 16; i * vol->mft_record_size < vol->cluster_size; i++)
memcpy(buf + i * vol->mft_record_size, buf,
vol->mft_record_size);
}
/*
* Create the 16 system files, adding the system information attribute
* to each as well as marking them in use in the mft bitmap.
*/
for (i = 0; i < 16; i++) {
u32 file_attrs;
m = (MFT_RECORD*)(buf + i * vol->mft_record_size);
m->flags |= MFT_RECORD_IN_USE;
ntfs_bit_set(mft_bitmap, 0LL + i, 1);
file_attrs = FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM;
if (i == FILE_root) {
if (opts.disable_indexing)
file_attrs |= FILE_ATTR_NOT_CONTENT_INDEXED;
if (opts.enable_compression)
file_attrs |= FILE_ATTR_COMPRESSED;
}
add_attr_std_info(m, file_attrs);
// dump_mft_record(m);
}
/* The root directory mft reference. */
root_ref = MK_LE_MREF(FILE_root, FILE_root);
Vprintf("Creating root directory (mft record 5)\n");
m = (MFT_RECORD*)(buf + 5 * vol->mft_record_size);
m->flags |= MFT_RECORD_IS_DIRECTORY;
m->link_count = cpu_to_le16(le16_to_cpu(m->link_count) + 1);
err = add_attr_file_name(m, root_ref, 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_DUP_FILE_NAME_INDEX_PRESENT, 0, 0,
".", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_root, &sd, &i);
err = add_attr_sd(m, sd, i);
}
// FIXME: This should be IGNORE_CASE
if (!err)
err = add_attr_index_root(m, "$I30", 4, 0, AT_FILE_NAME,
COLLATION_FILE_NAME, opts.index_block_size);
// FIXME: This should be IGNORE_CASE
if (!err)
err = upgrade_to_large_index(m, "$I30", 4, 0, &index_block);
if (!err) {
ntfs_attr_search_ctx *ctx;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx)
err_exit("Failed to allocate attribute search "
"context: %s\n", strerror(errno));
/* There is exactly one file name so this is ok. */
if (ntfs_attr_lookup(AT_FILE_NAME, AT_UNNAMED, 0, 0, 0, NULL, 0,
ctx)) {
ntfs_attr_put_search_ctx(ctx);
err_exit("BUG: $FILE_NAME attribute not found.\n");
}
a = ctx->attr;
err = insert_file_link_in_dir_index(index_block, root_ref,
(FILE_NAME_ATTR*)((char*)a +
le16_to_cpu(a->value_offset)),
le32_to_cpu(a->value_length));
ntfs_attr_put_search_ctx(ctx);
}
if (err)
err_exit("Couldn't create root directory: %s\n",
strerror(-err));
// dump_mft_record(m);
/* Add all other attributes, on a per-file basis for clarity. */
Vprintf("Creating $MFT (mft record 0)\n");
m = (MFT_RECORD*)buf;
err = add_attr_data_positioned(m, NULL, 0, 0, 0, rl_mft, buf,
opts.mft_size);
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_MFT, 1), opts.mft_size,
opts.mft_size, FILE_ATTR_HIDDEN |
FILE_ATTR_SYSTEM, 0, 0, "$MFT",
FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_MFT, &sd, &i);
err = add_attr_sd(m, sd, i);
}
/* mft_bitmap is not modified in mkntfs; no need to sync it later. */
if (!err)
err = add_attr_bitmap_positioned(m, NULL, 0, 0, rl_mft_bmp,
mft_bitmap, mft_bitmap_byte_size);
if (err < 0)
err_exit("Couldn't create $MFT: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $MFTMirr (mft record 1)\n");
m = (MFT_RECORD*)(buf + 1 * vol->mft_record_size);
err = add_attr_data_positioned(m, NULL, 0, 0, 0, rl_mftmirr, buf,
rl_mftmirr[0].length * vol->cluster_size);
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_MFTMirr, FILE_MFTMirr),
rl_mftmirr[0].length * vol->cluster_size,
rl_mftmirr[0].length * vol->cluster_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$MFTMirr", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_MFTMirr, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $MFTMirr: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $LogFile (mft record 2)\n");
m = (MFT_RECORD*)(buf + 2 * vol->mft_record_size);
buf2 = malloc(opts.logfile_size);
if (!buf2)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
memset(buf2, -1, opts.logfile_size);
err = add_attr_data_positioned(m, NULL, 0, 0, 0, rl_logfile, buf2,
opts.logfile_size);
free(buf2);
buf2 = NULL;
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_LogFile, FILE_LogFile),
opts.logfile_size, opts.logfile_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$LogFile", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_LogFile, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $LogFile: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $AttrDef (mft record 4)\n");
m = (MFT_RECORD*)(buf + 4 * vol->mft_record_size);
if (vol->major_ver < 3)
buf2_size = 36000;
else
buf2_size = opts.attr_defs_len;
buf2 = (char*)calloc(1, buf2_size);
if (!buf2)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
memcpy(buf2, opts.attr_defs, opts.attr_defs_len);
err = add_attr_data(m, NULL, 0, 0, 0, buf2, buf2_size);
free(buf2);
buf2 = NULL;
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_AttrDef, FILE_AttrDef),
(buf2_size + vol->cluster_size - 1) &
~(vol->cluster_size - 1), buf2_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$AttrDef", FILE_NAME_WIN32_AND_DOS);
buf2_size = 0;
if (!err) {
init_system_file_sd(FILE_AttrDef, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $AttrDef: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $Bitmap (mft record 6)\n");
m = (MFT_RECORD*)(buf + 6 * vol->mft_record_size);
err = add_attr_data(m, NULL, 0, 0, 0, lcn_bitmap, lcn_bitmap_byte_size);
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_Bitmap, FILE_Bitmap),
(lcn_bitmap_byte_size + vol->cluster_size - 1) &
~(vol->cluster_size - 1), lcn_bitmap_byte_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$Bitmap", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_Bitmap, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $Bitmap: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $Boot (mft record 7)\n");
m = (MFT_RECORD*)(buf + 7 * vol->mft_record_size);
buf2 = calloc(1, 8192);
if (!buf2)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
memcpy(buf2, boot_array, sizeof(boot_array));
/*
* Create the boot sector into buf2. Note, that buf2 already is zeroed
* in the boot sector section and that it has the NTFS OEM id/magic
* already inserted, so no need to worry about these things.
*/
bs = (NTFS_BOOT_SECTOR*)buf2;
bs->bpb.bytes_per_sector = cpu_to_le16(opts.sector_size);
bs->bpb.sectors_per_cluster = (u8)(vol->cluster_size /
opts.sector_size);
bs->bpb.media_type = 0xf8; /* hard disk */
bs->bpb.sectors_per_track = cpu_to_le16(opts.sectors_per_track);
mkDprintf("sectors per track = %u (0x%x)\n", opts.sectors_per_track,
opts.sectors_per_track);
bs->bpb.heads = cpu_to_le16(opts.heads);
mkDprintf("heads = %u (0x%x)\n", opts.heads, opts.heads);
bs->bpb.hidden_sectors = cpu_to_le32(opts.part_start_sect);
mkDprintf("hidden sectors = %llu (0x%llx)\n", opts.part_start_sect,
opts.part_start_sect);
/*
* If there are problems go back to bs->unused[0-3] and set them. See
* ../include/layout.h for details.
*/
bs->number_of_sectors = cpu_to_sle64(opts.nr_sectors);
bs->mft_lcn = cpu_to_sle64(opts.mft_lcn);
bs->mftmirr_lcn = cpu_to_sle64(opts.mftmirr_lcn);
if (vol->mft_record_size >= vol->cluster_size)
bs->clusters_per_mft_record = vol->mft_record_size /
vol->cluster_size;
else {
bs->clusters_per_mft_record = -(ffs(vol->mft_record_size) - 1);
if ((u32)(1 << -bs->clusters_per_mft_record) !=
vol->mft_record_size)
err_exit("BUG: calculated clusters_per_mft_record "
"is wrong (= 0x%x)\n",
bs->clusters_per_mft_record);
}
mkDprintf("clusters per mft record = %i (0x%x)\n",
bs->clusters_per_mft_record,
bs->clusters_per_mft_record);
if (opts.index_block_size >= (int)vol->cluster_size)
bs->clusters_per_index_record = opts.index_block_size /
vol->cluster_size;
else {
bs->clusters_per_index_record = -(ffs(opts.index_block_size) - 1);
if ((1 << -bs->clusters_per_index_record) !=
opts.index_block_size)
err_exit("BUG: calculated clusters_per_index_record "
"is wrong (= 0x%x)\n",
bs->clusters_per_index_record);
}
mkDprintf("clusters per index block = %i (0x%x)\n",
bs->clusters_per_index_record,
bs->clusters_per_index_record);
/* Generate a 64-bit random number for the serial number. */
bs->volume_serial_number = cpu_to_sle64(((s64)random() << 32) |
((s64)random() & 0xffffffff));
/*
* Leave zero for now as NT4 leaves it zero, too. If want it later, see
* ../libntfs/bootsect.c for how to calculate it.
*/
bs->checksum = cpu_to_le32(0);
/* Make sure the bootsector is ok. */
if (!ntfs_boot_sector_is_ntfs(bs, opts.verbose > 0 ? 0 : 1))
err_exit("FATAL: Generated boot sector is invalid!\n");
err = add_attr_data_positioned(m, NULL, 0, 0, 0, rl_boot, buf2, 8192);
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_Boot, FILE_Boot),
(8192 + vol->cluster_size - 1) &
~(vol->cluster_size - 1), 8192,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$Boot", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_Boot, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $Boot: %s\n", strerror(-err));
if (create_backup_boot_sector(buf2, i) != 0) {
/*
* Pre-2.6 kernels couldn't access the last sector
* if it was odd hence we schedule chkdsk to create it.
*/
volume_flags |= VOLUME_IS_DIRTY;
}
free(buf2);
buf2 = NULL;
create_file_volume(m, root_ref, volume_flags);
Vprintf("Creating $BadClus (mft record 8)\n");
m = (MFT_RECORD*)(buf + 8 * vol->mft_record_size);
// FIXME: This should be IGNORE_CASE
/* Create a sparse named stream of size equal to the volume size. */
err = add_attr_data_positioned(m, "$Bad", 4, 0, 0, rl_bad, NULL,
opts.nr_clusters * vol->cluster_size);
if (!err) {
err = add_attr_data(m, NULL, 0, 0, 0, NULL, 0);
}
if (!err) {
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_BadClus, FILE_BadClus),
0LL, 0LL, FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM,
0, 0, "$BadClus", FILE_NAME_WIN32_AND_DOS);
}
if (!err) {
init_system_file_sd(FILE_BadClus, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $BadClus: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $Quota (mft record 9)\n");
m = (MFT_RECORD*)(buf + 9 * vol->mft_record_size);
err = add_attr_data(m, NULL, 0, 0, 0, NULL, 0);
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(9, 9), 0LL, 0LL, FILE_ATTR_HIDDEN
| FILE_ATTR_SYSTEM, 0, 0, "$Quota",
FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_Secure, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $Quota: %s\n", strerror(-err));
//dump_mft_record(m);
Vprintf("Creating $UpCase (mft record 0xa)\n");
m = (MFT_RECORD*)(buf + 0xa * vol->mft_record_size);
err = add_attr_data(m, NULL, 0, 0, 0, (char*)vol->upcase,
vol->upcase_len << 1);
if (!err)
err = create_hardlink(index_block, root_ref, m,
MK_LE_MREF(FILE_UpCase, FILE_UpCase),
((vol->upcase_len << 1) + vol->cluster_size - 1) &
~(vol->cluster_size - 1), vol->upcase_len << 1,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$UpCase", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_UpCase, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0)
err_exit("Couldn't create $UpCase: %s\n", strerror(-err));
//dump_mft_record(m);
/* NTFS 1.2 reserved system files (mft records 0xb-0xf) */
for (i = 0xb; i < 0x10; i++) {
Vprintf("Creating system file (mft record 0x%x)\n", i);
m = (MFT_RECORD*)(buf + i * vol->mft_record_size);
err = add_attr_data(m, NULL, 0, 0, 0, NULL, 0);
if (!err) {
init_system_file_sd(i, &sd, &j);
err = add_attr_sd(m, sd, j);
}
if (err < 0)
err_exit("Couldn't create system file %i (0x%x): %s\n",
i, i, strerror(-err));
//dump_mft_record(m);
}
}
/**
* main
*/
int main(int argc, char **argv)
{
ntfs_attr_search_ctx *ctx;
long long lw, pos;
ATTR_RECORD *a;
MFT_RECORD *m;
int i, err;
/* Setup the correct locale for string output and conversion. */
utils_set_locale();
/* Initialize the random number generator with the current time. */
srandom(mkntfs_time());
/* Allocate and initialize ntfs_volume structure vol. */
vol = ntfs_volume_alloc();
if (!vol)
err_exit("Could not allocate memory for internal buffer.\n");
/* Register our exit function which will cleanup everything. */
err = atexit(&mkntfs_exit);
if (err == -1) {
Eprintf("Could not set up exit() function because atexit() "
"failed. Aborting...\n");
mkntfs_exit();
exit(1);
}
vol->major_ver = 1;
vol->minor_ver = 2;
vol->mft_record_size = 1024;
vol->mft_record_size_bits = 10;
/* Length is in unicode characters. */
vol->upcase_len = 65536;
vol->upcase = (ntfschar*)malloc(vol->upcase_len * sizeof(ntfschar));
if (!vol->upcase)
err_exit("Could not allocate memory for internal buffer.\n");
init_upcase_table(vol->upcase, vol->upcase_len * sizeof(ntfschar));
/* Initialize opts to zero / required values. */
init_options();
/* Parse command line options. */
parse_options(argc, argv);
/* Open the partition. */
mkntfs_open_partition();
/* Decide on the sectors/tracks/heads/size, etc. */
mkntfs_override_phys_params();
/* Initialize $Bitmap and $MFT/$BITMAP related stuff. */
mkntfs_initialize_bitmaps();
/* Initialize MFT & set opts.logfile_lcn. */
mkntfs_initialize_rl_mft();
/* Initlialize $LogFile. */
mkntfs_initialize_rl_logfile();
/* Initialize $Boot. */
mkntfs_initialize_rl_boot();
/* Allocate a buffer large enough to hold the mft. */
buf = calloc(1, opts.mft_size);
if (!buf)
err_exit("Failed to allocate internal buffer: %s\n",
strerror(errno));
/* Create runlist for $BadClus, $DATA named stream $Bad. */
mkntfs_initialize_rl_bad();
/* If not quick format, fill the device with 0s. */
if (!opts.quick_format)
mkntfs_fill_device_with_zeroes();
/* Create NTFS volume structures. */
mkntfs_create_root_structures();
// - Do not step onto bad blocks!!!
// - If any bad blocks were specified or found, modify $BadClus, allocating the
// bad clusters in $Bitmap.
// - C&w bootsector backup bootsector (backup in last sector of the
// partition).
// - If NTFS 3.0+, c&w $Secure file and $Extend directory with the
// corresponding special files in it, i.e. $ObjId, $Quota, $Reparse, and
// $UsnJrnl. And others? Or not all necessary?
// - RE: Populate $root with the system files (and $Extend directory if
// applicable). Possibly should move this as far to the top as possible and
// update during each subsequent c&w of each system file.
Vprintf("Syncing root directory index record.\n");
m = (MFT_RECORD*)(buf + 5 * vol->mft_record_size);
i = 5 * sizeof(ntfschar);
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx)
err_exit("Failed to allocate attribute search context: %s\n",
strerror(errno));
// FIXME: This should be IGNORE_CASE!
if (ntfs_attr_lookup(AT_INDEX_ALLOCATION, I30, 4, 0, 0,
NULL, 0, ctx)) {
ntfs_attr_put_search_ctx(ctx);
err_exit("BUG: $INDEX_ALLOCATION attribute not found.\n");
}
a = ctx->attr;
rl_index = ntfs_mapping_pairs_decompress(vol, a, NULL);
if (!rl_index) {
ntfs_attr_put_search_ctx(ctx);
err_exit("Failed to decompress runlist of $INDEX_ALLOCATION "
"attribute.\n");
}
if (sle64_to_cpu(a->initialized_size) < i) {
ntfs_attr_put_search_ctx(ctx);
err_exit("BUG: $INDEX_ALLOCATION attribute too short.\n");
}
ntfs_attr_put_search_ctx(ctx);
i = sizeof(INDEX_BLOCK) - sizeof(INDEX_HEADER) +
le32_to_cpu(index_block->index.allocated_size);
err = ntfs_mst_pre_write_fixup((NTFS_RECORD*)index_block, i);
if (err)
err_exit("ntfs_mst_pre_write_fixup() failed while syncing "
"root directory index block.\n");
lw = ntfs_rlwrite(vol->dev, rl_index, (char*)index_block, i, NULL);
if (lw != i)
err_exit("Error writing $INDEX_ALLOCATION.\n");
/* No more changes to @index_block below here so no need for fixup: */
// ntfs_mst_post_write_fixup((NTFS_RECORD*)index_block);
Vprintf("Syncing $Bitmap.\n");
m = (MFT_RECORD*)(buf + 6 * vol->mft_record_size);
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx)
err_exit("Failed to allocate attribute search context: %s\n",
strerror(errno));
if (ntfs_attr_lookup(AT_DATA, AT_UNNAMED, 0, 0, 0, NULL, 0, ctx)) {
ntfs_attr_put_search_ctx(ctx);
err_exit("BUG: $DATA attribute not found.\n");
}
a = ctx->attr;
if (a->non_resident) {
runlist *rl = ntfs_mapping_pairs_decompress(vol, a, NULL);
ntfs_attr_put_search_ctx(ctx);
if (!rl)
err_exit("ntfs_mapping_pairs_decompress() failed\n");
lw = ntfs_rlwrite(vol->dev, rl, lcn_bitmap,
lcn_bitmap_byte_size, NULL);
err = errno;
free(rl);
if (lw != lcn_bitmap_byte_size)
err_exit("%s\n", lw == -1 ? strerror(err) :
"unknown error");
} else {
memcpy((char*)a + le16_to_cpu(a->value_offset), lcn_bitmap,
le32_to_cpu(a->value_length));
ntfs_attr_put_search_ctx(ctx);
}
/*
* No need to sync $MFT/$BITMAP as that has never been modified since
* its creation.
*/
Vprintf("Syncing $MFT.\n");
pos = opts.mft_lcn * vol->cluster_size;
lw = 1;
for (i = 0; i < opts.mft_size / (s32)vol->mft_record_size; i++) {
if (!opts.no_action)
lw = ntfs_mst_pwrite(vol->dev, pos, 1,
vol->mft_record_size,
buf + i * vol->mft_record_size);
if (lw != 1)
err_exit("%s\n", lw == -1 ? strerror(errno) :
"unknown error");
pos += vol->mft_record_size;
}
Vprintf("Updating $MFTMirr.\n");
pos = opts.mftmirr_lcn * vol->cluster_size;
lw = 1;
for (i = 0; i < rl_mftmirr[0].length * vol->cluster_size /
vol->mft_record_size; i++) {
u16 usn, *usnp;
m = (MFT_RECORD*)(buf + i * vol->mft_record_size);
/*
* Decrement the usn by one, so it becomes the same as the one
* in $MFT once it is mst protected. - This is as we need the
* $MFTMirr to have the exact same byte by byte content as
* $MFT, rather than just equivalent meaning content.
*/
usnp = (u16*)((char*)m + le16_to_cpu(m->usa_ofs));
usn = le16_to_cpup(usnp);
if (usn-- <= 1)
usn = 0xfffe;
*usnp = cpu_to_le16(usn);
if (!opts.no_action)
lw = ntfs_mst_pwrite(vol->dev, pos, 1,
vol->mft_record_size,
buf + i * vol->mft_record_size);
if (lw != 1)
err_exit("%s\n", lw == -1 ? strerror(errno) :
"unknown error");
pos += vol->mft_record_size;
}
Vprintf("Syncing device.\n");
if (vol->dev->d_ops->sync(vol->dev))
err_exit("Syncing device. FAILED: %s", strerror(errno));
Qprintf("mkntfs completed successfully. Have a nice day.\n");
/*
* Device is unlocked and closed by the registered exit function
* mkntfs_exit().
*/
return 0;
}
Reference in New Issue View Git Blame Copy Permalink