#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#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
#ifdef HAVE_TIME_H
#include <time.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_LIBGEN_H
#include <libgen.h>
#endif
#ifdef ENABLE_UUID
#include <uuid/uuid.h>
#endif
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
extern char *optarg;
extern int optind;
#endif
#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 "security.h"
#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"
#include "ntfstime.h"
#include "sd.h"
#include "boot.h"
#include "attrdef.h"
#include "logging.h"
#include "support.h"
#include "unistr.h"
#include "misc.h"
int mkntfs_main(const char *devpath, const char *label);
typedef enum { WRITE_STANDARD, WRITE_BITMAP, WRITE_LOGFILE } WRITE_TYPE;
#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
#define NTFS_PAGE_SIZE 4096
struct BITMAP_ALLOCATION {
struct BITMAP_ALLOCATION *next;
LCN lcn;
s64 length;
} ;
struct UPCASEINFO {
le32 len;
le32 filler;
le64 crc;
le32 osmajor;
le32 osminor;
le32 build;
le16 packmajor;
le16 packminor;
} ;
static u8 *g_buf = NULL;
static int g_mft_bitmap_byte_size = 0;
static u8 *g_mft_bitmap = NULL;
static int g_lcn_bitmap_byte_size = 0;
static int g_dynamic_buf_size = 0;
static u8 *g_dynamic_buf = NULL;
static struct UPCASEINFO *g_upcaseinfo = NULL;
static runlist *g_rl_mft = NULL;
static runlist *g_rl_mft_bmp = NULL;
static runlist *g_rl_mftmirr = NULL;
static runlist *g_rl_logfile = NULL;
static runlist *g_rl_boot = NULL;
static runlist *g_rl_bad = NULL;
static INDEX_ALLOCATION *g_index_block = NULL;
static ntfs_volume *g_vol = NULL;
static int g_mft_size = 0;
static long long g_mft_lcn = 0;
static long long g_mftmirr_lcn = 0;
static long long g_logfile_lcn = 0;
static int g_logfile_size = 0;
static long long g_mft_zone_end = 0;
static long long g_num_bad_blocks = 0;
static long long *g_bad_blocks = NULL;
static struct BITMAP_ALLOCATION *g_allocation = NULL;
static struct mkntfs_options {
char *dev_name;
BOOL enable_compression;
BOOL quick_format;
BOOL force;
long heads;
BOOL disable_indexing;
BOOL no_action;
long long part_start_sect;
long sector_size;
long sectors_per_track;
BOOL use_epoch_time;
long mft_zone_multiplier;
long long num_sectors;
long cluster_size;
BOOL with_uuid;
char *label;
} opts;
#undef byte
#undef uint32_t
#undef uint64_t
#define byte u8
#define uint32_t u32
#define uint64_t u64
static uint64_t crc64(uint64_t crc, const byte * data, size_t size)
{
static uint64_t polynomial = 0x9a6c9329ac4bc9b5ULL;
static uint64_t xorout = 0xffffffffffffffffULL;
static uint64_t table[256];
crc ^= xorout;
if (data == NULL) {
uint64_t c;
uint32_t i, j;
for (i = 0; i < 256; i++) {
c = i;
for (j = 0; j < 8; j++) {
if (c & 1)
c = polynomial ^ (c >> 1);
else
c = (c >> 1);
}
table[i] = c;
}
} else
while (size) {
crc = table[(crc ^ *data) & 0xff] ^ (crc >> 8);
size--;
data++;
}
crc ^= xorout;
return crc;
}
static BOOL bitmap_allocate(LCN lcn, s64 length)
{
BOOL done;
struct BITMAP_ALLOCATION *p;
struct BITMAP_ALLOCATION *q;
struct BITMAP_ALLOCATION *newall;
done = TRUE;
if (length) {
p = g_allocation;
q = (struct BITMAP_ALLOCATION*)NULL;
while (p && (p->lcn <= lcn)) {
q = p;
p = p->next;
}
if ((q && ((q->lcn + q->length) > lcn))
|| (p && ((lcn + length) > p->lcn))) {
ntfs_log_error("Bitmap allocation error\n");
done = FALSE;
}
if (q && ((q->lcn + q->length) == lcn)) {
q->length += length;
} else {
newall = (struct BITMAP_ALLOCATION*)
ntfs_malloc(sizeof(struct BITMAP_ALLOCATION));
if (newall) {
newall->lcn = lcn;
newall->length = length;
newall->next = p;
if (q) q->next = newall;
else g_allocation = newall;
} else {
done = FALSE;
ntfs_log_perror("Not enough memory");
}
}
}
return (done);
}
static BOOL bitmap_deallocate(LCN lcn, s64 length)
{
BOOL done;
struct BITMAP_ALLOCATION *p;
struct BITMAP_ALLOCATION *q;
LCN first, last;
s64 begin_length, end_length;
done = TRUE;
if (length) {
p = g_allocation;
q = (struct BITMAP_ALLOCATION*)NULL;
while (p) {
first = (p->lcn > lcn ? p->lcn : lcn);
last = ((p->lcn + p->length) < (lcn + length)
? p->lcn + p->length : lcn + length);
if (first < last) {
begin_length = first - p->lcn;
end_length = p->lcn + p->length - last;
if (q)
q->next = p->next;
else
g_allocation = p->next;
free(p);
if (begin_length
&& !bitmap_allocate(first - begin_length,
begin_length))
done = FALSE;
if (end_length
&& !bitmap_allocate(last, end_length))
done = FALSE;
p = g_allocation;
q = (struct BITMAP_ALLOCATION*)NULL;
} else {
q = p;
p = p->next;
}
}
}
return (done);
}
static int bitmap_get_and_set(LCN lcn, unsigned long length)
{
struct BITMAP_ALLOCATION *p;
struct BITMAP_ALLOCATION *q;
int bit;
if (length == 1) {
p = g_allocation;
q = (struct BITMAP_ALLOCATION*)NULL;
while (p && (p->lcn <= lcn)) {
q = p;
p = p->next;
}
if (q && (q->lcn <= lcn) && ((q->lcn + q->length) > lcn))
bit = 1;
else {
bitmap_allocate(lcn, length);
bit = 0;
}
} else {
ntfs_log_error("Can only allocate a single cluster at a time\n");
bit = 0;
}
return (bit);
}
static void bitmap_build(u8 *buf, LCN lcn, s64 length)
{
struct BITMAP_ALLOCATION *p;
LCN first, last;
int j;
int bn;
for (j=0; (8*j)<length; j++)
buf[j] = 0;
for (p=g_allocation; p; p=p->next) {
first = (p->lcn > lcn ? p->lcn : lcn);
last = ((p->lcn + p->length) < (lcn + length)
? p->lcn + p->length : lcn + length);
if (first < last) {
bn = first - lcn;
while ((bn < (last - lcn)) && (bn & 7)) {
buf[bn >> 3] |= 1 << (bn & 7);
bn++;
}
while (bn < (last - lcn - 7)) {
buf[bn >> 3] = 255;
bn += 8;
}
while (bn < (last - lcn)) {
buf[bn >> 3] |= 1 << (bn & 7);
bn++;
}
}
}
}
static void mkntfs_init_options(struct mkntfs_options *opts2)
{
if (!opts2)
return;
memset(opts2, 0, sizeof(*opts2));
opts2->cluster_size = -1;
opts2->heads = -1;
opts2->mft_zone_multiplier = -1;
opts2->num_sectors = -1;
opts2->part_start_sect = -1;
opts2->sector_size = -1;
opts2->sectors_per_track = -1;
}
static ntfs_time mkntfs_time(void)
{
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 0;
if (!opts.use_epoch_time)
ts.tv_sec = time(NULL);
return timespec2ntfs(ts);
}
static BOOL append_to_bad_blocks(unsigned long long block)
{
long long *new_buf;
if (!(g_num_bad_blocks & 15)) {
new_buf = realloc(g_bad_blocks, (g_num_bad_blocks + 16) *
sizeof(long long));
if (!new_buf) {
ntfs_log_perror("Reallocating memory for bad blocks "
"list failed");
return FALSE;
}
g_bad_blocks = new_buf;
}
g_bad_blocks[g_num_bad_blocks++] = block;
return TRUE;
}
static 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;
ntfs_log_perror("Error writing to %s", dev->d_name);
errno = retry;
return bytes_written;
} else if (!bytes_written) {
retry++;
} else {
count -= bytes_written;
total += bytes_written;
}
} while (count && retry < 3);
if (count)
ntfs_log_error("Failed to complete writing to %s after three retries."
"\n", dev->d_name);
return total;
}
static s64 mkntfs_bitmap_write(struct ntfs_device *dev,
s64 offset, s64 length)
{
s64 partial_length;
s64 written;
partial_length = length;
if (partial_length > g_dynamic_buf_size)
partial_length = g_dynamic_buf_size;
bitmap_build(g_dynamic_buf,offset << 3,partial_length << 3);
written = dev->d_ops->write(dev, g_dynamic_buf, partial_length);
return (written);
}
static s64 mkntfs_logfile_write(struct ntfs_device *dev,
s64 offset __attribute__((unused)), s64 length)
{
s64 partial_length;
s64 written;
partial_length = length;
if (partial_length > g_dynamic_buf_size)
partial_length = g_dynamic_buf_size;
memset(g_dynamic_buf, -1, partial_length);
written = dev->d_ops->write(dev, g_dynamic_buf, partial_length);
return (written);
}
static s64 ntfs_rlwrite(struct ntfs_device *dev, const runlist *rl,
const u8 *val, const s64 val_len, s64 *inited_size,
WRITE_TYPE write_type)
{
s64 bytes_written, total, length, delta;
int retry, i;
if (inited_size)
*inited_size = 0LL;
if (opts.no_action)
return val_len;
total = 0LL;
delta = 0LL;
for (i = 0; rl[i].length; i++) {
length = rl[i].length * g_vol->cluster_size;
if (rl[i].lcn == -1) {
total += length;
if (!val)
continue;
continue;
}
if (total + length > val_len) {
delta = length;
length = val_len - total;
delta -= length;
}
if (dev->d_ops->seek(dev, rl[i].lcn * g_vol->cluster_size,
SEEK_SET) == (off_t)-1)
return -1LL;
retry = 0;
do {
switch (write_type) {
case WRITE_BITMAP :
bytes_written = mkntfs_bitmap_write(dev,
total, length);
break;
case WRITE_LOGFILE :
bytes_written = mkntfs_logfile_write(dev,
total, length);
break;
default :
bytes_written = dev->d_ops->write(dev,
val + total, length);
break;
}
if (bytes_written == -1LL) {
retry = errno;
ntfs_log_perror("Error writing to %s",
dev->d_name);
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) {
ntfs_log_error("Failed to complete writing to %s after three "
"retries.\n", dev->d_name);
return total;
}
}
if (delta) {
int eo;
char *b = ntfs_calloc(delta);
if (!b)
return -1;
bytes_written = mkntfs_write(dev, b, delta);
eo = errno;
free(b);
errno = eo;
if (bytes_written == -1LL)
return bytes_written;
}
return total;
}
static int make_room_for_attribute(MFT_RECORD *m, char *pos, const u32 size)
{
u32 biu;
if (!size)
return 0;
#ifdef DEBUG
if (size != ((size + 7) & ~7)) {
ntfs_log_error("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;
if (pos - (char*)m > (int)le32_to_cpu(m->bytes_in_use) - 8)
return -EINVAL;
#endif
biu = le32_to_cpu(m->bytes_in_use);
if (biu + size > le32_to_cpu(m->bytes_allocated))
return -ENOSPC;
memmove(pos + size, pos, biu - (pos - (char*)m));
m->bytes_in_use = cpu_to_le32(biu + size);
return 0;
}
static void deallocate_scattered_clusters(const runlist *rl)
{
int i;
if (!rl)
return;
for (i = 0; rl[i].length; i++) {
if (rl[i].lcn == -1LL)
continue;
bitmap_deallocate(rl[i].lcn, rl[i].length);
}
}
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 = g_vol->nr_clusters;
while (clusters) {
for (lcn = g_mft_zone_end; lcn < end; lcn++) {
bit = bitmap_get_and_set(lcn,1);
if (bit)
continue;
if ((rlpos + 2) * (int)sizeof(runlist) >= rlsize) {
rlsize += 4096;
rlt = realloc(rl, rlsize);
if (!rlt)
goto err_end;
rl = rlt;
}
if (prev_lcn == lcn - prev_run_len) {
rl[rlpos - 1].length = ++prev_run_len;
vcn++;
} else {
rl[rlpos].vcn = vcn++;
rl[rlpos].lcn = lcn;
prev_lcn = lcn;
rl[rlpos].length = 1LL;
prev_run_len = 1LL;
rlpos++;
}
if (!--clusters) {
rl[rlpos].vcn = vcn;
rl[rlpos].lcn = 0LL;
rl[rlpos].length = 0LL;
return rl;
}
}
end = g_mft_zone_end;
g_mft_zone_end >>= 1;
if (g_mft_zone_end <= 0)
goto err_end;
}
return rl;
err_end:
if (rl) {
rl[rlpos].vcn = vcn;
rl[rlpos].lcn = -1LL;
rl[rlpos].length = 0LL;
deallocate_scattered_clusters(rl);
free(rl);
}
return NULL;
}
static int mkntfs_attr_find(const ATTR_TYPES type, const ntfschar *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const u8 *val, const u32 val_len, ntfs_attr_search_ctx *ctx)
{
ATTR_RECORD *a;
ntfschar *upcase = g_vol->upcase;
u32 upcase_len = g_vol->upcase_len;
if (ctx->is_first) {
a = ctx->attr;
ctx->is_first = FALSE;
} else {
a = (ATTR_RECORD*)((char*)ctx->attr +
le32_to_cpu(ctx->attr->length));
}
for (;; a = (ATTR_RECORD*)((char*)a + le32_to_cpu(a->length))) {
if (p2n(a) < p2n(ctx->mrec) || (char*)a > (char*)ctx->mrec +
le32_to_cpu(ctx->mrec->bytes_allocated))
break;
ctx->attr = a;
if (((type != AT_UNUSED) && (le32_to_cpu(a->type) >
le32_to_cpu(type))) ||
(a->type == AT_END)) {
errno = ENOENT;
return -1;
}
if (!a->length)
break;
if (type == AT_UNUSED)
return 0;
if (a->type != type)
continue;
if (name == AT_UNNAMED) {
if (a->name_length) {
errno = ENOENT;
return -1;
}
} else if (name && !ntfs_names_are_equal(name, name_len,
(ntfschar*)((char*)a + le16_to_cpu(a->name_offset)),
a->name_length, ic, upcase, upcase_len)) {
int rc;
rc = ntfs_names_full_collate(name, name_len,
(ntfschar*)((char*)a +
le16_to_cpu(a->name_offset)),
a->name_length, IGNORE_CASE,
upcase, upcase_len);
if (rc == -1) {
errno = ENOENT;
return -1;
}
if (rc)
continue;
rc = ntfs_names_full_collate(name, name_len,
(ntfschar*)((char*)a +
le16_to_cpu(a->name_offset)),
a->name_length, CASE_SENSITIVE,
upcase, upcase_len);
if (rc == -1) {
errno = ENOENT;
return -1;
}
if (rc)
continue;
}
if (!val) {
return 0;
} else {
int rc;
rc = memcmp(val, (char*)a +le16_to_cpu(a->value_offset),
min(val_len,
le32_to_cpu(a->value_length)));
if (!rc) {
u32 avl;
avl = le32_to_cpu(a->value_length);
if (val_len == avl)
return 0;
if (val_len < avl) {
errno = ENOENT;
return -1;
}
} else if (rc < 0) {
errno = ENOENT;
return -1;
}
}
}
ntfs_log_trace("File is corrupt. Run chkdsk.\n");
errno = EIO;
return -1;
}
static int mkntfs_attr_lookup(const ATTR_TYPES type, const ntfschar *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const VCN lowest_vcn __attribute__((unused)), const u8 *val,
const u32 val_len, ntfs_attr_search_ctx *ctx)
{
ntfs_inode *base_ni;
if (!ctx || !ctx->mrec || !ctx->attr) {
errno = EINVAL;
return -1;
}
if (ctx->base_ntfs_ino)
base_ni = ctx->base_ntfs_ino;
else
base_ni = ctx->ntfs_ino;
if (!base_ni || !NInoAttrList(base_ni) || type == AT_ATTRIBUTE_LIST)
return mkntfs_attr_find(type, name, name_len, ic, val, val_len,
ctx);
errno = EOPNOTSUPP;
return -1;
}
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 u8 *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 = NULL;
int uname_len = 0;
uname = ntfs_str2ucs(name, &uname_len);
if (!uname)
return -errno;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_error("Failed to allocate attribute search context.\n");
err = -ENOMEM;
goto err_out;
}
if (ic == IGNORE_CASE) {
ntfs_log_error("FIXME: Hit unimplemented code path #1.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (!mkntfs_attr_lookup(type, uname, uname_len, ic, 0, NULL, 0, ctx)) {
err = -EEXIST;
goto err_out;
}
if (errno != ENOENT) {
ntfs_log_error("Corrupt inode.\n");
err = -errno;
goto err_out;
}
a = ctx->attr;
if (flags & ATTR_COMPRESSION_MASK) {
ntfs_log_error("Compressed attributes not supported yet.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (flags & (ATTR_IS_ENCRYPTED | ATTR_IS_SPARSE)) {
ntfs_log_error("Encrypted/sparse attributes not supported.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (flags & ATTR_COMPRESSION_MASK) {
hdr_size = 72;
if (val_len)
mpa_size = 0;
else
mpa_size = 0;
} else {
hdr_size = 64;
if (val_len) {
mpa_size = ntfs_get_size_for_mapping_pairs(g_vol, rl, 0, INT_MAX);
if (mpa_size < 0) {
err = -errno;
ntfs_log_error("Failed to get size for mapping "
"pairs.\n");
goto err_out;
}
} else {
mpa_size = 0;
}
}
asize = (((int)hdr_size + ((name_len + 7) & ~7) + mpa_size) + 7) & ~7;
for (i = 0, highest_vcn = 0LL; rl[i].length; i++)
highest_vcn += rl[i].length;
if (highest_vcn * g_vol->cluster_size < val_len) {
ntfs_log_error("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) {
err = -EOPNOTSUPP;
goto err_out;
#ifdef DEBUG
} else if (err == -EINVAL) {
ntfs_log_error("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_sle64(highest_vcn - 1LL);
a->mapping_pairs_offset = cpu_to_le16(hdr_size + ((name_len + 7) & ~7));
memset(a->reserved1, 0, sizeof(a->reserved1));
a->allocated_size = cpu_to_sle64(highest_vcn * g_vol->cluster_size);
a->data_size = cpu_to_sle64(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) {
ntfs_log_error("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;
a->compressed_size = cpu_to_le64(0);
err = -EOPNOTSUPP;
} else {
a->compression_unit = 0;
if ((type == AT_DATA)
&& (m->mft_record_number
== const_cpu_to_le32(FILE_LogFile)))
bw = ntfs_rlwrite(g_vol->dev, rl, val, val_len,
&inited_size, WRITE_LOGFILE);
else
bw = ntfs_rlwrite(g_vol->dev, rl, val, val_len,
&inited_size, WRITE_STANDARD);
if (bw != val_len) {
ntfs_log_error("Error writing non-resident attribute "
"value.\n");
return -errno;
}
err = ntfs_mapping_pairs_build(g_vol, (u8*)a + hdr_size +
((name_len + 7) & ~7), mpa_size, rl, 0, NULL);
}
a->initialized_size = cpu_to_sle64(inited_size);
if (err < 0 || bw != val_len) {
if (err >= 0)
err = -EIO;
ntfs_log_error("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);
ntfs_ucsfree(uname);
return err;
}
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 u8 *val, const s64 val_len,
WRITE_TYPE write_type)
{
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 = NULL;
int uname_len = 0;
uname = ntfs_str2ucs(name, &uname_len);
if (!uname)
return -errno;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_error("Failed to allocate attribute search context.\n");
err = -ENOMEM;
goto err_out;
}
if (ic == IGNORE_CASE) {
ntfs_log_error("FIXME: Hit unimplemented code path #2.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (!mkntfs_attr_lookup(type, uname, uname_len, ic, 0, NULL, 0, ctx)) {
err = -EEXIST;
goto err_out;
}
if (errno != ENOENT) {
ntfs_log_error("Corrupt inode.\n");
err = -errno;
goto err_out;
}
a = ctx->attr;
if (flags & ATTR_COMPRESSION_MASK) {
ntfs_log_error("Compressed attributes not supported yet.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (flags & (ATTR_IS_ENCRYPTED | ATTR_IS_SPARSE)) {
ntfs_log_error("Encrypted/sparse attributes not supported.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (val_len) {
rl = allocate_scattered_clusters((val_len +
g_vol->cluster_size - 1) / g_vol->cluster_size);
if (!rl) {
err = -errno;
ntfs_log_perror("Failed to allocate scattered clusters");
goto err_out;
}
} else {
rl = NULL;
}
if (flags & ATTR_COMPRESSION_MASK) {
hdr_size = 72;
if (val_len)
mpa_size = 0;
else
mpa_size = 0;
} else {
hdr_size = 64;
if (val_len) {
mpa_size = ntfs_get_size_for_mapping_pairs(g_vol, rl, 0, INT_MAX);
if (mpa_size < 0) {
err = -errno;
ntfs_log_error("Failed to get size for mapping "
"pairs.\n");
goto err_out;
}
} else {
mpa_size = 0;
}
}
asize = (((int)hdr_size + ((name_len + 7) & ~7) + mpa_size) + 7) & ~7;
err = make_room_for_attribute(m, (char*)a, asize);
if (err == -ENOSPC) {
err = -EOPNOTSUPP;
goto err_out;
#ifdef DEBUG
} else if (err == -EINVAL) {
ntfs_log_error("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_sle64(rl[i].vcn - 1);
a->mapping_pairs_offset = cpu_to_le16(hdr_size + ((name_len + 7) & ~7));
memset(a->reserved1, 0, sizeof(a->reserved1));
a->allocated_size = cpu_to_sle64((val_len + (g_vol->cluster_size - 1)) &
~(g_vol->cluster_size - 1));
a->data_size = cpu_to_sle64(val_len);
a->initialized_size = cpu_to_sle64(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) {
ntfs_log_error("Unknown compression format. Reverting "
"to standard compression.\n");
a->flags &= ~ATTR_COMPRESSION_MASK;
a->flags |= ATTR_IS_COMPRESSED;
}
a->compression_unit = 4;
a->compressed_size = cpu_to_le64(0);
err = -EOPNOTSUPP;
} else {
a->compression_unit = 0;
bw = ntfs_rlwrite(g_vol->dev, rl, val, val_len, NULL,
write_type);
if (bw != val_len) {
ntfs_log_error("Error writing non-resident attribute "
"value.\n");
return -errno;
}
err = ntfs_mapping_pairs_build(g_vol, (u8*)a + hdr_size +
((name_len + 7) & ~7), mpa_size, rl, 0, NULL);
}
if (err < 0 || bw != val_len) {
if (err >= 0)
err = -EIO;
ntfs_log_error("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);
ntfs_ucsfree(uname);
free(rl);
return err;
}
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 u8 *val, const u32 val_len)
{
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
int asize, err;
ntfschar *uname = NULL;
int uname_len = 0;
uname = ntfs_str2ucs(name, &uname_len);
if (!uname)
return -errno;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_error("Failed to allocate attribute search context.\n");
err = -ENOMEM;
goto err_out;
}
if (ic == IGNORE_CASE) {
ntfs_log_error("FIXME: Hit unimplemented code path #3.\n");
err = -EOPNOTSUPP;
goto err_out;
}
if (!mkntfs_attr_lookup(type, uname, uname_len, ic, 0, val, val_len,
ctx)) {
err = -EEXIST;
goto err_out;
}
if (errno != ENOENT) {
ntfs_log_error("Corrupt inode.\n");
err = -errno;
goto err_out;
}
a = ctx->attr;
asize = ((24 + ((name_len*2 + 7) & ~7) + val_len) + 7) & ~7;
err = make_room_for_attribute(m, (char*)a, asize);
if (err == -ENOSPC) {
err = -EOPNOTSUPP;
goto err_out;
}
#ifdef DEBUG
if (err == -EINVAL) {
ntfs_log_error("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;
if (type == AT_OBJECT_ID)
a->name_offset = const_cpu_to_le16(0);
else
a->name_offset = const_cpu_to_le16(24);
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->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);
ntfs_ucsfree(uname);
return err;
}
static int add_attr_std_info(MFT_RECORD *m, const FILE_ATTR_FLAGS flags,
le32 security_id)
{
STANDARD_INFORMATION si;
int err, sd_size;
sd_size = 48;
si.creation_time = 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;
si.maximum_versions = cpu_to_le32(0);
si.version_number = cpu_to_le32(0);
si.class_id = cpu_to_le32(0);
si.security_id = security_id;
if (si.security_id != const_cpu_to_le32(0))
sd_size = 72;
si.owner_id = cpu_to_le32(0);
si.quota_charged = cpu_to_le64(0ULL);
si.usn = cpu_to_le64(0ULL);
err = insert_resident_attr_in_mft_record(m, AT_STANDARD_INFORMATION,
NULL, 0, CASE_SENSITIVE, const_cpu_to_le16(0),
0, (u8*)&si, sd_size);
if (err < 0)
ntfs_log_perror("add_attr_std_info failed");
return err;
}
static BOOL non_resident_unnamed_data(MFT_RECORD *m)
{
ATTR_RECORD *a;
ntfs_attr_search_ctx *ctx;
BOOL nonres;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (ctx && !mkntfs_attr_find(AT_DATA,
(const ntfschar*)NULL, 0, CASE_SENSITIVE,
(u8*)NULL, 0, ctx)) {
a = ctx->attr;
nonres = a->non_resident != 0;
} else {
ntfs_log_error("BUG: Unnamed data not found\n");
nonres = TRUE;
}
if (ctx)
ntfs_attr_put_search_ctx(ctx);
return (nonres);
}
static ntfs_time stdinfo_time(MFT_RECORD *m)
{
STANDARD_INFORMATION *si;
ntfs_attr_search_ctx *ctx;
ntfs_time info_time;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (ctx && !mkntfs_attr_find(AT_STANDARD_INFORMATION,
(const ntfschar*)NULL, 0, CASE_SENSITIVE,
(u8*)NULL, 0, ctx)) {
si = (STANDARD_INFORMATION*)((char*)ctx->attr +
le16_to_cpu(ctx->attr->value_offset));
info_time = si->creation_time;
} else {
ntfs_log_error("BUG: Standard information not found\n");
info_time = mkntfs_time();
}
if (ctx)
ntfs_attr_put_search_ctx(ctx);
return (info_time);
}
static int add_attr_file_name(MFT_RECORD *m, const leMFT_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;
ntfschar *uname;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_error("Failed to get attribute search context.\n");
return -ENOMEM;
}
if (mkntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED, 0,
CASE_SENSITIVE, 0, NULL, 0, ctx)) {
int eo = errno;
ntfs_log_error("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 = ntfs_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_sle64(allocated_size);
fn->data_size = cpu_to_sle64(data_size);
fn->file_attributes = flags;
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;
uname = fn->file_name;
i = ntfs_mbstoucs_libntfscompat(file_name, &uname, i);
if (i < 1) {
free(fn);
return -EINVAL;
}
if (i > 0xff) {
free(fn);
return -ENAMETOOLONG;
}
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,
CASE_SENSITIVE, const_cpu_to_le16(0),
RESIDENT_ATTR_IS_INDEXED, (u8*)fn, fn_size);
free(fn);
if (i < 0)
ntfs_log_error("add_attr_file_name failed: %s\n", strerror(-i));
return i;
}
static int add_attr_object_id(MFT_RECORD *m, const GUID *object_id)
{
OBJECT_ID_ATTR oi;
int err;
oi = (OBJECT_ID_ATTR) {
.object_id = *object_id,
};
err = insert_resident_attr_in_mft_record(m, AT_OBJECT_ID, NULL,
0, CASE_SENSITIVE, const_cpu_to_le16(0),
0, (u8*)&oi, sizeof(oi.object_id));
if (err < 0)
ntfs_log_error("add_attr_vol_info failed: %s\n", strerror(-err));
return err;
}
static int add_attr_sd(MFT_RECORD *m, const u8 *sd, const s64 sd_len)
{
int err;
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,
CASE_SENSITIVE, const_cpu_to_le16(0), sd,
sd_len, WRITE_STANDARD);
else
err = insert_resident_attr_in_mft_record(m,
AT_SECURITY_DESCRIPTOR, NULL, 0,
CASE_SENSITIVE, const_cpu_to_le16(0), 0, sd,
sd_len);
if (err < 0)
ntfs_log_error("add_attr_sd failed: %s\n", strerror(-err));
return err;
}
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 u8 *val, const s64 val_len)
{
int err;
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,
WRITE_STANDARD);
else
err = insert_resident_attr_in_mft_record(m, AT_DATA, name,
name_len, ic, flags, 0, val, val_len);
if (err < 0)
ntfs_log_error("add_attr_data failed: %s\n", strerror(-err));
return err;
}
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 u8 *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)
ntfs_log_error("add_attr_data_positioned failed: %s\n",
strerror(-err));
return err;
}
static int add_attr_vol_name(MFT_RECORD *m, const char *vol_name,
const int vol_name_len __attribute__((unused)))
{
ntfschar *uname = NULL;
int uname_len = 0;
int i;
if (vol_name) {
uname_len = ntfs_mbstoucs(vol_name, &uname);
if (uname_len < 0)
return -errno;
if (uname_len > 128) {
free(uname);
return -ENAMETOOLONG;
}
}
i = insert_resident_attr_in_mft_record(m, AT_VOLUME_NAME, NULL, 0,
CASE_SENSITIVE, const_cpu_to_le16(0),
0, (u8*)uname, uname_len*sizeof(ntfschar));
free(uname);
if (i < 0)
ntfs_log_error("add_attr_vol_name failed: %s\n", strerror(-i));
return i;
}
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, CASE_SENSITIVE, const_cpu_to_le16(0),
0, (u8*)&vi, sizeof(vi));
if (err < 0)
ntfs_log_error("add_attr_vol_info failed: %s\n", strerror(-err));
return err;
}
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 = ntfs_malloc(val_len);
if (!r)
return -errno;
r->type = (indexed_attr_type == AT_FILE_NAME)
? AT_FILE_NAME : const_cpu_to_le32(0);
if (indexed_attr_type == AT_FILE_NAME &&
collation_rule != COLLATION_FILE_NAME) {
free(r);
ntfs_log_error("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 >= g_vol->cluster_size) {
if (index_block_size % g_vol->cluster_size) {
ntfs_log_error("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 /
g_vol->cluster_size;
} else {
if (index_block_size & (index_block_size - 1)) {
ntfs_log_error("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) {
ntfs_log_error("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
>> NTFS_BLOCK_SIZE_BITS;
}
memset(&r->reserved, 0, sizeof(r->reserved));
r->index.entries_offset = const_cpu_to_le32(sizeof(INDEX_HEADER));
r->index.index_length = const_cpu_to_le32(sizeof(INDEX_HEADER) +
sizeof(INDEX_ENTRY_HEADER));
r->index.allocated_size = r->index.index_length;
r->index.ih_flags = SMALL_INDEX;
memset(&r->index.reserved, 0, sizeof(r->index.reserved));
e = (INDEX_ENTRY_HEADER*)((u8*)&r->index +
le32_to_cpu(r->index.entries_offset));
e->indexed_file = const_cpu_to_le64(0LL);
e->length = const_cpu_to_le16(sizeof(INDEX_ENTRY_HEADER));
e->key_length = const_cpu_to_le16(0);
e->flags = INDEX_ENTRY_END;
e->reserved = const_cpu_to_le16(0);
err = insert_resident_attr_in_mft_record(m, AT_INDEX_ROOT, name,
name_len, ic, const_cpu_to_le16(0), 0,
(u8*)r, val_len);
free(r);
if (err < 0)
ntfs_log_error("add_attr_index_root failed: %s\n", strerror(-err));
return err;
}
static int add_attr_index_alloc(MFT_RECORD *m, const char *name,
const u32 name_len, const IGNORE_CASE_BOOL ic,
const u8 *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, const_cpu_to_le16(0),
index_alloc_val, index_alloc_val_len, WRITE_STANDARD);
if (err < 0)
ntfs_log_error("add_attr_index_alloc failed: %s\n", strerror(-err));
return err;
}
static int add_attr_bitmap(MFT_RECORD *m, const char *name, const u32 name_len,
const IGNORE_CASE_BOOL ic, const u8 *bitmap,
const u32 bitmap_len)
{
int err;
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, const_cpu_to_le16(0), bitmap,
bitmap_len, WRITE_STANDARD);
else
err = insert_resident_attr_in_mft_record(m, AT_BITMAP, name,
name_len, ic, const_cpu_to_le16(0), 0,
bitmap, bitmap_len);
if (err < 0)
ntfs_log_error("add_attr_bitmap failed: %s\n", strerror(-err));
return err;
}
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 u8 *bitmap, const u32 bitmap_len)
{
int err;
err = insert_positioned_attr_in_mft_record(m, AT_BITMAP, name, name_len,
ic, const_cpu_to_le16(0), rl, bitmap, bitmap_len);
if (err < 0)
ntfs_log_error("add_attr_bitmap_positioned failed: %s\n",
strerror(-err));
return err;
}
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 = NULL;
int uname_len = 0;
u8 bmp[8];
char *re_start, *re_end;
int i, err, index_block_size;
uname = ntfs_str2ucs(name, &uname_len);
if (!uname)
return -errno;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_error("Failed to allocate attribute search context.\n");
ntfs_ucsfree(uname);
return -ENOMEM;
}
if (ic == IGNORE_CASE) {
ntfs_log_error("FIXME: Hit unimplemented code path #4.\n");
err = -EOPNOTSUPP;
ntfs_ucsfree(uname);
goto err_out;
}
err = mkntfs_attr_lookup(AT_INDEX_ROOT, uname, uname_len, ic, 0, NULL, 0,
ctx);
ntfs_ucsfree(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);
err = add_attr_bitmap(m, name, name_len, ic, bmp, sizeof(bmp));
if (err)
goto err_out;
ia_val = ntfs_calloc(index_block_size);
if (!ia_val) {
err = -errno;
goto err_out;
}
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);
ntfs_log_error("Sector size is bigger than index block size. "
"Setting usa_count to 1. If Windows chkdsk "
"reports this as corruption, please email %s "
"stating that you saw this message and that "
"the filesystem created was corrupt. "
"Thank you.", NTFS_DEV_LIST);
}
*(le16*)((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.ih_flags = LEAF_NODE;
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)));
while ((char*)re < re_end && !(re->ie_flags & INDEX_ENTRY_END)) {
re = (INDEX_ENTRY*)((char*)re + le16_to_cpu(re->length));
}
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);
ia_val->index.index_length = cpu_to_le32(i +
le32_to_cpu(ia_val->index.entries_offset));
if ((char*)re > re_start) {
memmove(re_start, (char*)re, le16_to_cpu(re->length));
re = (INDEX_ENTRY*)re_start;
}
r->index.ih_flags = LARGE_INDEX;
re->ie_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;
if (ntfs_resident_attr_value_resize(m, a, sizeof(INDEX_ROOT) -
sizeof(INDEX_HEADER) +
le32_to_cpu(r->index.allocated_size))) {
err = -errno;
goto err_out;
}
*(leVCN*)((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;
ntfs_log_error("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, (u8*)ia_val,
index_block_size);
ntfs_mst_post_write_fixup((NTFS_RECORD*)ia_val);
if (err) {
goto err_out;
}
*idx = ia_val;
ntfs_attr_put_search_ctx(ctx);
return 0;
err_out:
ntfs_attr_put_search_ctx(ctx);
free(ia_val);
return err;
}
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
if (size != ((size + 7) & ~7)) {
ntfs_log_error("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;
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);
if (biu + size > le32_to_cpu(idx->index.allocated_size))
return -ENOSPC;
memmove((char*)pos + size, (char*)pos, biu - ((char*)pos -
(char*)&idx->index));
idx->index.index_length = cpu_to_le32(biu + size);
return 0;
}
static int ntfs_index_keys_compare(u8 *key1, u8 *key2, int key1_length,
int key2_length, COLLATION_RULES collation_rule)
{
u32 u1, u2;
int i;
if (collation_rule == COLLATION_NTOFS_ULONG) {
u1 = le32_to_cpup((const le32*)key1);
u2 = le32_to_cpup((const le32*)key2);
if (u1 < u2)
return -1;
if (u1 > u2)
return 1;
return 0;
}
if (collation_rule == COLLATION_NTOFS_ULONGS) {
i = 0;
while (i < min(key1_length, key2_length)) {
u1 = le32_to_cpup((const le32*)(key1 + i));
u2 = le32_to_cpup((const le32*)(key2 + i));
if (u1 < u2)
return -1;
if (u1 > u2)
return 1;
i += sizeof(u32);
}
if (key1_length < key2_length)
return -1;
if (key1_length > key2_length)
return 1;
return 0;
}
if (collation_rule == COLLATION_NTOFS_SECURITY_HASH) {
u1 = le32_to_cpu(((SDH_INDEX_KEY*)key1)->hash);
u2 = le32_to_cpu(((SDH_INDEX_KEY*)key2)->hash);
if (u1 < u2)
return -1;
if (u1 > u2)
return 1;
u1 = le32_to_cpu(((SDH_INDEX_KEY*)key1)->security_id);
u2 = le32_to_cpu(((SDH_INDEX_KEY*)key2)->security_id);
if (u1 < u2)
return -1;
if (u1 > u2)
return 1;
return 0;
}
if (collation_rule == COLLATION_NTOFS_SID) {
i = memcmp(key1, key2, min(key1_length, key2_length));
if (!i) {
if (key1_length < key2_length)
return -1;
if (key1_length > key2_length)
return 1;
}
return i;
}
ntfs_log_critical("ntfs_index_keys_compare called without supported "
"collation rule.\n");
return 0;
}
static int insert_index_entry_in_res_dir_index(INDEX_ENTRY *idx, u32 idx_size,
MFT_RECORD *m, ntfschar *name, u32 name_size, ATTR_TYPES type)
{
ntfs_attr_search_ctx *ctx;
INDEX_HEADER *idx_header;
INDEX_ENTRY *idx_entry, *idx_end;
ATTR_RECORD *a;
COLLATION_RULES collation_rule;
int err, i;
err = 0;
if (g_vol->mft_record_size > idx_size + le32_to_cpu(m->bytes_allocated))
return -ENOSPC;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_error("Failed to allocate attribute search "
"context.\n");
err = -ENOMEM;
goto err_out;
}
if (mkntfs_attr_lookup(AT_INDEX_ROOT, name, name_size,
CASE_SENSITIVE, 0, NULL, 0, ctx)) {
err = -EEXIST;
goto err_out;
}
a = (ATTR_RECORD*)ctx->attr;
collation_rule = ((INDEX_ROOT*)((u8*)a +
le16_to_cpu(a->value_offset)))->collation_rule;
idx_header = (INDEX_HEADER*)((u8*)a + le16_to_cpu(a->value_offset)
+ 0x10);
idx_entry = (INDEX_ENTRY*)((u8*)idx_header +
le32_to_cpu(idx_header->entries_offset));
idx_end = (INDEX_ENTRY*)((u8*)idx_entry +
le32_to_cpu(idx_header->index_length));
if (type == AT_FILE_NAME) {
while (((u8*)idx_entry < (u8*)idx_end) &&
!(idx_entry->ie_flags & INDEX_ENTRY_END)) {
i = ntfs_names_full_collate(idx->key.file_name.file_name, idx->key.file_name.file_name_length,
idx_entry->key.file_name.file_name, idx_entry->key.file_name.file_name_length,
IGNORE_CASE, g_vol->upcase,
g_vol->upcase_len);
if (i == -1)
break;
if (i)
goto do_next;
if (idx->key.file_name.file_name_type !=
FILE_NAME_POSIX ||
idx_entry->key.file_name.file_name_type
!= FILE_NAME_POSIX)
return -EEXIST;
i = ntfs_names_full_collate(idx->key.file_name.file_name, idx->key.file_name.file_name_length,
idx_entry->key.file_name.file_name, idx_entry->key.file_name.file_name_length,
CASE_SENSITIVE, g_vol->upcase,
g_vol->upcase_len);
if (!i)
return -EEXIST;
if (i == -1)
break;
do_next:
idx_entry = (INDEX_ENTRY*)((u8*)idx_entry +
le16_to_cpu(idx_entry->length));
}
} else if (type == AT_UNUSED) {
while (((u8*)idx_entry < (u8*)idx_end) &&
!(idx_entry->ie_flags & INDEX_ENTRY_END)) {
i = ntfs_index_keys_compare((u8*)idx + 0x10,
(u8*)idx_entry + 0x10,
le16_to_cpu(idx->key_length),
le16_to_cpu(idx_entry->key_length),
collation_rule);
if (!i)
return -EEXIST;
if (i == -1)
break;
idx_entry = (INDEX_ENTRY*)((u8*)idx_entry +
le16_to_cpu(idx_entry->length));
}
} else
return -EINVAL;
memmove((u8*)idx_entry + idx_size, (u8*)idx_entry,
le32_to_cpu(m->bytes_in_use) -
((u8*)idx_entry - (u8*)m));
memcpy((u8*)idx_entry, (u8*)idx, idx_size);
m->bytes_in_use = cpu_to_le32(le32_to_cpu(m->bytes_in_use) + idx_size);
a->length = cpu_to_le32(le32_to_cpu(a->length) + idx_size);
a->value_length = cpu_to_le32(le32_to_cpu(a->value_length) + idx_size);
idx_header->index_length = cpu_to_le32(
le32_to_cpu(idx_header->index_length) + idx_size);
idx_header->allocated_size = cpu_to_le32(
le32_to_cpu(idx_header->allocated_size) + idx_size);
err_out:
if (ctx)
ntfs_attr_put_search_ctx(ctx);
return err;
}
static int initialize_secure(char *sds, u32 sds_size, MFT_RECORD *m)
{
int err, sdh_size, sii_size;
SECURITY_DESCRIPTOR_HEADER *sds_header;
INDEX_ENTRY *idx_entry_sdh, *idx_entry_sii;
SDH_INDEX_DATA *sdh_data;
SII_INDEX_DATA *sii_data;
sds_header = (SECURITY_DESCRIPTOR_HEADER*)sds;
sdh_size = sizeof(INDEX_ENTRY_HEADER);
sdh_size += sizeof(SDH_INDEX_KEY) + sizeof(SDH_INDEX_DATA);
sii_size = sizeof(INDEX_ENTRY_HEADER);
sii_size += sizeof(SII_INDEX_KEY) + sizeof(SII_INDEX_DATA);
idx_entry_sdh = ntfs_calloc(sizeof(INDEX_ENTRY));
if (!idx_entry_sdh)
return -errno;
idx_entry_sii = ntfs_calloc(sizeof(INDEX_ENTRY));
if (!idx_entry_sii) {
free(idx_entry_sdh);
return -errno;
}
err = 0;
while ((char*)sds_header < (char*)sds + sds_size) {
if (!sds_header->length)
break;
idx_entry_sdh->data_offset = const_cpu_to_le16(0x18);
idx_entry_sdh->data_length = const_cpu_to_le16(0x14);
idx_entry_sdh->reservedV = const_cpu_to_le32(0x00);
idx_entry_sdh->length = const_cpu_to_le16(0x30);
idx_entry_sdh->key_length = const_cpu_to_le16(0x08);
idx_entry_sdh->ie_flags = const_cpu_to_le16(0x00);
idx_entry_sdh->reserved = const_cpu_to_le16(0x00);
idx_entry_sdh->key.sdh.hash = sds_header->hash;
idx_entry_sdh->key.sdh.security_id = sds_header->security_id;
sdh_data = (SDH_INDEX_DATA*)((u8*)idx_entry_sdh +
le16_to_cpu(idx_entry_sdh->data_offset));
sdh_data->hash = sds_header->hash;
sdh_data->security_id = sds_header->security_id;
sdh_data->offset = sds_header->offset;
sdh_data->length = sds_header->length;
sdh_data->reserved_II = const_cpu_to_le32(0x00490049);
idx_entry_sii->data_offset = const_cpu_to_le16(0x14);
idx_entry_sii->data_length = const_cpu_to_le16(0x14);
idx_entry_sii->reservedV = const_cpu_to_le32(0x00);
idx_entry_sii->length = const_cpu_to_le16(0x28);
idx_entry_sii->key_length = const_cpu_to_le16(0x04);
idx_entry_sii->ie_flags = const_cpu_to_le16(0x00);
idx_entry_sii->reserved = const_cpu_to_le16(0x00);
idx_entry_sii->key.sii.security_id = sds_header->security_id;
sii_data = (SII_INDEX_DATA*)((u8*)idx_entry_sii +
le16_to_cpu(idx_entry_sii->data_offset));
sii_data->hash = sds_header->hash;
sii_data->security_id = sds_header->security_id;
sii_data->offset = sds_header->offset;
sii_data->length = sds_header->length;
if ((err = insert_index_entry_in_res_dir_index(idx_entry_sdh,
sdh_size, m, NTFS_INDEX_SDH, 4, AT_UNUSED)))
break;
if ((err = insert_index_entry_in_res_dir_index(idx_entry_sii,
sii_size, m, NTFS_INDEX_SII, 4, AT_UNUSED)))
break;
sds_header = (SECURITY_DESCRIPTOR_HEADER*)((u8*)sds_header +
((le32_to_cpu(sds_header->length) + 15) & ~15));
}
free(idx_entry_sdh);
free(idx_entry_sii);
return err;
}
static int initialize_quota(MFT_RECORD *m)
{
int o_size, q1_size, q2_size, err, i;
INDEX_ENTRY *idx_entry_o, *idx_entry_q1, *idx_entry_q2;
QUOTA_O_INDEX_DATA *idx_entry_o_data;
QUOTA_CONTROL_ENTRY *idx_entry_q1_data, *idx_entry_q2_data;
err = 0;
q1_size = 0x48;
idx_entry_q1 = ntfs_calloc(q1_size);
if (!idx_entry_q1)
return errno;
idx_entry_q1->data_offset = const_cpu_to_le16(0x14);
idx_entry_q1->data_length = const_cpu_to_le16(0x30);
idx_entry_q1->reservedV = const_cpu_to_le32(0x00);
idx_entry_q1->length = const_cpu_to_le16(0x48);
idx_entry_q1->key_length = const_cpu_to_le16(0x04);
idx_entry_q1->ie_flags = const_cpu_to_le16(0x00);
idx_entry_q1->reserved = const_cpu_to_le16(0x00);
idx_entry_q1->key.owner_id = const_cpu_to_le32(0x01);
idx_entry_q1_data = (QUOTA_CONTROL_ENTRY*)((char*)idx_entry_q1
+ le16_to_cpu(idx_entry_q1->data_offset));
idx_entry_q1_data->version = const_cpu_to_le32(0x02);
idx_entry_q1_data->flags = QUOTA_FLAG_DEFAULT_LIMITS;
idx_entry_q1_data->bytes_used = const_cpu_to_le64(0x00);
idx_entry_q1_data->change_time = mkntfs_time();
idx_entry_q1_data->threshold = cpu_to_sle64(-1);
idx_entry_q1_data->limit = cpu_to_sle64(-1);
idx_entry_q1_data->exceeded_time = const_cpu_to_le64(0);
err = insert_index_entry_in_res_dir_index(idx_entry_q1, q1_size, m,
NTFS_INDEX_Q, 2, AT_UNUSED);
free(idx_entry_q1);
if (err)
return err;
q2_size = 0x58;
idx_entry_q2 = ntfs_calloc(q2_size);
if (!idx_entry_q2)
return errno;
idx_entry_q2->data_offset = const_cpu_to_le16(0x14);
idx_entry_q2->data_length = const_cpu_to_le16(0x40);
idx_entry_q2->reservedV = const_cpu_to_le32(0x00);
idx_entry_q2->length = const_cpu_to_le16(0x58);
idx_entry_q2->key_length = const_cpu_to_le16(0x04);
idx_entry_q2->ie_flags = const_cpu_to_le16(0x00);
idx_entry_q2->reserved = const_cpu_to_le16(0x00);
idx_entry_q2->key.owner_id = QUOTA_FIRST_USER_ID;
idx_entry_q2_data = (QUOTA_CONTROL_ENTRY*)((char*)idx_entry_q2
+ le16_to_cpu(idx_entry_q2->data_offset));
idx_entry_q2_data->version = const_cpu_to_le32(0x02);
idx_entry_q2_data->flags = QUOTA_FLAG_DEFAULT_LIMITS;
idx_entry_q2_data->bytes_used = const_cpu_to_le64(0x00);
idx_entry_q2_data->change_time = mkntfs_time();
idx_entry_q2_data->threshold = cpu_to_sle64(-1);
idx_entry_q2_data->limit = cpu_to_sle64(-1);
idx_entry_q2_data->exceeded_time = const_cpu_to_le64(0);
idx_entry_q2_data->sid.revision = 1;
idx_entry_q2_data->sid.sub_authority_count = 2;
for (i = 0; i < 5; i++)
idx_entry_q2_data->sid.identifier_authority.value[i] = 0;
idx_entry_q2_data->sid.identifier_authority.value[5] = 0x05;
idx_entry_q2_data->sid.sub_authority[0] =
const_cpu_to_le32(SECURITY_BUILTIN_DOMAIN_RID);
idx_entry_q2_data->sid.sub_authority[1] =
const_cpu_to_le32(DOMAIN_ALIAS_RID_ADMINS);
err = insert_index_entry_in_res_dir_index(idx_entry_q2, q2_size, m,
NTFS_INDEX_Q, 2, AT_UNUSED);
free(idx_entry_q2);
if (err)
return err;
o_size = 0x28;
idx_entry_o = ntfs_calloc(o_size);
if (!idx_entry_o)
return errno;
idx_entry_o->data_offset = const_cpu_to_le16(0x20);
idx_entry_o->data_length = const_cpu_to_le16(0x04);
idx_entry_o->reservedV = const_cpu_to_le32(0x00);
idx_entry_o->length = const_cpu_to_le16(0x28);
idx_entry_o->key_length = const_cpu_to_le16(0x10);
idx_entry_o->ie_flags = const_cpu_to_le16(0x00);
idx_entry_o->reserved = const_cpu_to_le16(0x00);
idx_entry_o->key.sid.revision = 0x01;
idx_entry_o->key.sid.sub_authority_count = 0x02;
for (i = 0; i < 5; i++)
idx_entry_o->key.sid.identifier_authority.value[i] = 0;
idx_entry_o->key.sid.identifier_authority.value[5] = 0x05;
idx_entry_o->key.sid.sub_authority[0] =
const_cpu_to_le32(SECURITY_BUILTIN_DOMAIN_RID);
idx_entry_o->key.sid.sub_authority[1] =
const_cpu_to_le32(DOMAIN_ALIAS_RID_ADMINS);
idx_entry_o_data = (QUOTA_O_INDEX_DATA*)((char*)idx_entry_o
+ le16_to_cpu(idx_entry_o->data_offset));
idx_entry_o_data->owner_id = QUOTA_FIRST_USER_ID;
idx_entry_o_data->unknown = const_cpu_to_le32(32);
err = insert_index_entry_in_res_dir_index(idx_entry_o, o_size, m,
NTFS_INDEX_O, 2, AT_UNUSED);
free(idx_entry_o);
return err;
}
static int insert_file_link_in_dir_index(INDEX_BLOCK *idx, leMFT_REF file_ref,
FILE_NAME_ATTR *file_name, u32 file_name_size)
{
int err, i;
INDEX_ENTRY *ie;
char *index_end;
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));
while ((char*)ie < index_end && !(ie->ie_flags & INDEX_ENTRY_END)) {
#if 0
#ifdef DEBUG
ntfs_log_debug("file_name_attr1->file_name_length = %i\n",
file_name->file_name_length);
if (file_name->file_name_length) {
char *__buf = NULL;
i = ntfs_ucstombs((ntfschar*)&file_name->file_name,
file_name->file_name_length, &__buf, 0);
if (i < 0)
ntfs_log_debug("Name contains non-displayable "
"Unicode characters.\n");
ntfs_log_debug("file_name_attr1->file_name = %s\n",
__buf);
free(__buf);
}
ntfs_log_debug("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 = NULL;
i = ntfs_ucstombs(ie->key.file_name.file_name,
ie->key.file_name.file_name_length + 1, &__buf,
0);
if (i < 0)
ntfs_log_debug("Name contains non-displayable "
"Unicode characters.\n");
ntfs_log_debug("file_name_attr2->file_name = %s\n",
__buf);
free(__buf);
}
#endif
#endif
i = ntfs_names_full_collate(file_name->file_name, file_name->file_name_length,
((FILE_NAME_ATTR*)&ie->key.file_name)->file_name, ((FILE_NAME_ATTR*)&ie->key.file_name)->file_name_length,
IGNORE_CASE, g_vol->upcase, g_vol->upcase_len);
if (i == -1)
break;
if (i)
goto do_next;
if (file_name->file_name_type != FILE_NAME_POSIX ||
ie->key.file_name.file_name_type != FILE_NAME_POSIX)
return -EEXIST;
i = ntfs_names_full_collate(file_name->file_name, file_name->file_name_length,
((FILE_NAME_ATTR*)&ie->key.file_name)->file_name, ((FILE_NAME_ATTR*)&ie->key.file_name)->file_name_length,
CASE_SENSITIVE, g_vol->upcase, g_vol->upcase_len);
if (i == -1)
break;
if (!i)
return -EEXIST;
do_next:
#ifdef DEBUG
if (!ie->length) {
ntfs_log_debug("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) {
ntfs_log_error("make_room_for_index_entry_in_index_block "
"failed: %s\n", strerror(-err));
return err;
}
ie->indexed_file = file_ref;
ie->length = cpu_to_le16(i);
ie->key_length = cpu_to_le16(file_name_size);
ie->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;
}
static int create_hardlink_res(MFT_RECORD *m_parent, const leMFT_REF ref_parent,
MFT_RECORD *m_file, const leMFT_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, idx_size;
INDEX_ENTRY *idx_entry_new;
ntfschar *uname;
i = (strlen(file_name) + 1) * sizeof(ntfschar);
fn_size = sizeof(FILE_NAME_ATTR) + i;
fn = ntfs_malloc(fn_size);
if (!fn)
return -errno;
fn->parent_directory = ref_parent;
fn->creation_time = stdinfo_time(m_file);
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_sle64(allocated_size);
fn->data_size = cpu_to_sle64(data_size);
fn->file_attributes = flags;
if (packed_ea_size && reparse_point_tag) {
free(fn);
return -EINVAL;
}
if (packed_ea_size) {
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;
uname = fn->file_name;
i = ntfs_mbstoucs_libntfscompat(file_name, &uname, i);
if (i < 1) {
free(fn);
return -EINVAL;
}
if (i > 0xff) {
free(fn);
return -ENAMETOOLONG;
}
fn->file_name_length = i;
fn_size = sizeof(FILE_NAME_ATTR) + i * sizeof(ntfschar);
i = le16_to_cpu(m_file->link_count);
if (i == 0xffff) {
ntfs_log_error("Too many hardlinks present already.\n");
free(fn);
return -EINVAL;
}
m_file->link_count = cpu_to_le16(i + 1);
i = insert_resident_attr_in_mft_record(m_file, AT_FILE_NAME, NULL, 0,
CASE_SENSITIVE, const_cpu_to_le16(0),
RESIDENT_ATTR_IS_INDEXED, (u8*)fn, fn_size);
if (i < 0) {
ntfs_log_error("create_hardlink failed adding file name "
"attribute: %s\n", strerror(-i));
free(fn);
m_file->link_count = cpu_to_le16(
le16_to_cpu(m_file->link_count) - 1);
return i;
}
idx_size = (fn_size + 7) & ~7;
idx_entry_new = ntfs_calloc(idx_size + 0x10);
if (!idx_entry_new)
return -errno;
idx_entry_new->indexed_file = ref_file;
idx_entry_new->length = cpu_to_le16(idx_size + 0x10);
idx_entry_new->key_length = cpu_to_le16(fn_size);
memcpy((u8*)idx_entry_new + 0x10, (u8*)fn, fn_size);
i = insert_index_entry_in_res_dir_index(idx_entry_new, idx_size + 0x10,
m_parent, NTFS_INDEX_I30, 4, AT_FILE_NAME);
if (i < 0) {
ntfs_log_error("create_hardlink failed inserting index entry: "
"%s\n", strerror(-i));
free(idx_entry_new);
free(fn);
m_file->link_count = cpu_to_le16(
le16_to_cpu(m_file->link_count) - 1);
return i;
}
free(idx_entry_new);
free(fn);
return 0;
}
static int create_hardlink(INDEX_BLOCK *idx, const leMFT_REF ref_parent,
MFT_RECORD *m_file, const leMFT_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;
ntfschar *uname;
i = (strlen(file_name) + 1) * sizeof(ntfschar);
fn_size = sizeof(FILE_NAME_ATTR) + i;
fn = ntfs_malloc(fn_size);
if (!fn)
return -errno;
fn->parent_directory = ref_parent;
fn->creation_time = stdinfo_time(m_file);
fn->last_data_change_time = fn->creation_time;
fn->last_mft_change_time = fn->creation_time;
fn->last_access_time = fn->creation_time;
if (allocated_size && non_resident_unnamed_data(m_file))
fn->allocated_size = cpu_to_sle64(allocated_size);
else
fn->allocated_size = cpu_to_sle64((data_size + 7) & -8);
fn->data_size = cpu_to_sle64(data_size);
fn->file_attributes = flags;
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;
uname = fn->file_name;
i = ntfs_mbstoucs_libntfscompat(file_name, &uname, i);
if (i < 1) {
free(fn);
return -EINVAL;
}
if (i > 0xff) {
free(fn);
return -ENAMETOOLONG;
}
fn->file_name_length = i;
fn_size = sizeof(FILE_NAME_ATTR) + i * sizeof(ntfschar);
i = le16_to_cpu(m_file->link_count);
if (i == 0xffff) {
ntfs_log_error("Too many hardlinks present already.\n");
free(fn);
return -EINVAL;
}
m_file->link_count = cpu_to_le16(i + 1);
i = insert_resident_attr_in_mft_record(m_file, AT_FILE_NAME, NULL, 0,
CASE_SENSITIVE, cpu_to_le16(0),
RESIDENT_ATTR_IS_INDEXED, (u8*)fn, fn_size);
if (i < 0) {
ntfs_log_error("create_hardlink failed adding file name attribute: "
"%s\n", strerror(-i));
free(fn);
m_file->link_count = cpu_to_le16(
le16_to_cpu(m_file->link_count) - 1);
return i;
}
i = insert_file_link_in_dir_index(idx, ref_file, fn, fn_size);
if (i < 0) {
ntfs_log_error("create_hardlink failed inserting index entry: %s\n",
strerror(-i));
free(fn);
m_file->link_count = cpu_to_le16(
le16_to_cpu(m_file->link_count) - 1);
return i;
}
free(fn);
return 0;
}
static int index_obj_id_insert(MFT_RECORD *m, const GUID *guid,
const leMFT_REF ref)
{
INDEX_ENTRY *idx_entry_new;
int data_ofs, idx_size, err;
OBJ_ID_INDEX_DATA *oi;
data_ofs = (sizeof(INDEX_ENTRY_HEADER) + sizeof(GUID) + 7) & ~7;
idx_size = (data_ofs + sizeof(OBJ_ID_INDEX_DATA) + 7) & ~7;
idx_entry_new = ntfs_calloc(idx_size);
if (!idx_entry_new)
return -errno;
idx_entry_new->data_offset = cpu_to_le16(data_ofs);
idx_entry_new->data_length = cpu_to_le16(sizeof(OBJ_ID_INDEX_DATA));
idx_entry_new->length = cpu_to_le16(idx_size);
idx_entry_new->key_length = cpu_to_le16(sizeof(GUID));
idx_entry_new->key.object_id = *guid;
oi = (OBJ_ID_INDEX_DATA*)((u8*)idx_entry_new + data_ofs);
oi->mft_reference = ref;
err = insert_index_entry_in_res_dir_index(idx_entry_new, idx_size, m,
NTFS_INDEX_O, 2, AT_UNUSED);
free(idx_entry_new);
if (err < 0) {
ntfs_log_error("index_obj_id_insert failed inserting index "
"entry: %s\n", strerror(-err));
return err;
}
return 0;
}
static void mkntfs_cleanup(void)
{
struct BITMAP_ALLOCATION *p, *q;
if (g_vol) {
if (g_vol->dev) {
if (NDevOpen(g_vol->dev) && g_vol->dev->d_ops->close(g_vol->dev))
ntfs_log_perror("Warning: Could not close %s", g_vol->dev->d_name);
ntfs_device_free(g_vol->dev);
}
free(g_vol->vol_name);
free(g_vol->attrdef);
free(g_vol->upcase);
free(g_vol);
g_vol = NULL;
}
free(g_bad_blocks); g_bad_blocks = NULL;
free(g_buf); g_buf = NULL;
free(g_index_block); g_index_block = NULL;
free(g_dynamic_buf); g_dynamic_buf = NULL;
free(g_mft_bitmap); g_mft_bitmap = NULL;
free(g_rl_bad); g_rl_bad = NULL;
free(g_rl_boot); g_rl_boot = NULL;
free(g_rl_logfile); g_rl_logfile = NULL;
free(g_rl_mft); g_rl_mft = NULL;
free(g_rl_mft_bmp); g_rl_mft_bmp = NULL;
free(g_rl_mftmirr); g_rl_mftmirr = NULL;
p = g_allocation;
while (p) {
q = p->next;
free(p);
p = q;
}
}
static BOOL mkntfs_open_partition(ntfs_volume *vol)
{
BOOL result = FALSE;
int i;
struct stat sbuf;
unsigned long mnt_flags;
vol->dev = ntfs_device_alloc(opts.dev_name, 0, &ntfs_device_default_io_ops, NULL);
if (!vol->dev) {
ntfs_log_perror("Could not create device");
goto done;
}
if (opts.no_action) {
ntfs_log_quiet("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)
ntfs_log_error("The device doesn't exist; did you specify it correctly?\n");
else
ntfs_log_perror("Could not open %s", vol->dev->d_name);
goto done;
}
if (vol->dev->d_ops->stat(vol->dev, &sbuf)) {
ntfs_log_perror("Error getting information about %s", vol->dev->d_name);
goto done;
}
if (!S_ISBLK(sbuf.st_mode)) {
ntfs_log_error("%s is not a block device.\n", vol->dev->d_name);
if (!opts.force) {
ntfs_log_error("Refusing to make a filesystem here!\n");
goto done;
}
if (!opts.num_sectors) {
if (!sbuf.st_size && !sbuf.st_blocks) {
ntfs_log_error("You must specify the number of sectors.\n");
goto done;
}
if (opts.sector_size) {
if (sbuf.st_size)
opts.num_sectors = sbuf.st_size / opts.sector_size;
else
opts.num_sectors = ((s64)sbuf.st_blocks << 9) / opts.sector_size;
} else {
if (sbuf.st_size)
opts.num_sectors = sbuf.st_size / 512;
else
opts.num_sectors = sbuf.st_blocks;
opts.sector_size = 512;
}
}
ntfs_log_warning("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)) {
ntfs_log_error("%s is entire device, not just one partition.\n", vol->dev->d_name);
if (!opts.force) {
ntfs_log_error("Refusing to make a filesystem here!\n");
goto done;
}
ntfs_log_warning("mkntfs forced anyway.\n");
#endif
}
if (ntfs_check_if_mounted(vol->dev->d_name, &mnt_flags)) {
ntfs_log_perror("Failed to determine whether %s is mounted", vol->dev->d_name);
} else if (mnt_flags & NTFS_MF_MOUNTED) {
ntfs_log_error("%s is mounted.\n", vol->dev->d_name);
if (!opts.force) {
ntfs_log_error("Refusing to make a filesystem here!\n");
goto done;
}
ntfs_log_warning("mkntfs forced anyway. Hope /etc/mtab is incorrect.\n");
}
result = TRUE;
done:
return result;
}
static long mkntfs_get_page_size(void)
{
return NTFS_PAGE_SIZE;
}
static BOOL mkntfs_override_vol_params(ntfs_volume *vol)
{
s64 volume_size;
long page_size;
int i;
BOOL winboot = TRUE;
if (opts.sector_size < 0) {
opts.sector_size = ntfs_device_sector_size_get(vol->dev);
if (opts.sector_size < 0) {
ntfs_log_warning("The sector size was not specified "
"for %s and it could not be obtained "
"automatically. It has been set to 512 "
"bytes.\n", vol->dev->d_name);
opts.sector_size = 512;
}
}
if ((opts.sector_size - 1) & opts.sector_size) {
ntfs_log_error("The sector size is invalid. It must be a "
"power of two, e.g. 512, 1024.\n");
return FALSE;
}
if (opts.sector_size < 256 || opts.sector_size > 4096) {
ntfs_log_error("The sector size is invalid. The minimum size "
"is 256 bytes and the maximum is 4096 bytes.\n");
return FALSE;
}
ntfs_log_debug("sector size = %ld bytes\n", opts.sector_size);
if (ntfs_device_block_size_set(vol->dev, opts.sector_size))
ntfs_log_debug("Failed to set the device block size to the "
"sector size. This may cause problems when "
"creating the backup boot sector and also may "
"affect performance but should be harmless "
"otherwise. Error: %s\n", strerror(errno));
if (opts.num_sectors < 0) {
opts.num_sectors = ntfs_device_size_get(vol->dev,
opts.sector_size);
if (opts.num_sectors <= 0) {
ntfs_log_error("Couldn't determine the size of %s. "
"Please specify the number of sectors "
"manually.\n", vol->dev->d_name);
return FALSE;
}
}
ntfs_log_debug("number of sectors = %lld (0x%llx)\n", opts.num_sectors,
opts.num_sectors);
i = 1;
if (opts.sector_size < 512)
i = 512 / opts.sector_size;
opts.num_sectors -= i;
if (opts.part_start_sect < 0) {
opts.part_start_sect = ntfs_device_partition_start_sector_get(
vol->dev);
if (opts.part_start_sect < 0) {
ntfs_log_warning("The partition start sector was not "
"specified for %s and it could not be obtained "
"automatically. It has been set to 0.\n",
vol->dev->d_name);
opts.part_start_sect = 0;
winboot = FALSE;
} else if (opts.part_start_sect >> 32) {
ntfs_log_warning("The partition start sector specified "
"for %s and the automatically determined value "
"is too large. It has been set to 0.\n",
vol->dev->d_name);
opts.part_start_sect = 0;
winboot = FALSE;
}
} else if (opts.part_start_sect >> 32) {
ntfs_log_error("Invalid partition start sector. Maximum is "
"4294967295 (2^32-1).\n");
return FALSE;
}
if (opts.sectors_per_track < 0) {
opts.sectors_per_track = ntfs_device_sectors_per_track_get(
vol->dev);
if (opts.sectors_per_track < 0) {
ntfs_log_warning("The number of sectors per track was "
"not specified for %s and it could not be "
"obtained automatically. It has been set to "
"0.\n", vol->dev->d_name);
opts.sectors_per_track = 0;
winboot = FALSE;
} else if (opts.sectors_per_track > 65535) {
ntfs_log_warning("The number of sectors per track was "
"not specified for %s and the automatically "
"determined value is too large. It has been "
"set to 0.\n", vol->dev->d_name);
opts.sectors_per_track = 0;
winboot = FALSE;
}
} else if (opts.sectors_per_track > 65535) {
ntfs_log_error("Invalid number of sectors per track. Maximum "
"is 65535.\n");
return FALSE;
}
if (opts.heads < 0) {
opts.heads = ntfs_device_heads_get(vol->dev);
if (opts.heads < 0) {
ntfs_log_warning("The number of heads was not "
"specified for %s and it could not be obtained "
"automatically. It has been set to 0.\n",
vol->dev->d_name);
opts.heads = 0;
winboot = FALSE;
} else if (opts.heads > 65535) {
ntfs_log_warning("The number of heads was not "
"specified for %s and the automatically "
"determined value is too large. It has been "
"set to 0.\n", vol->dev->d_name);
opts.heads = 0;
winboot = FALSE;
}
} else if (opts.heads > 65535) {
ntfs_log_error("Invalid number of heads. Maximum is 65535.\n");
return FALSE;
}
volume_size = opts.num_sectors * opts.sector_size;
if (volume_size < (1 << 20)) {
ntfs_log_error("Device is too small (%llikiB). Minimum NTFS "
"volume size is 1MiB.\n",
(long long)(volume_size / 1024));
return FALSE;
}
ntfs_log_debug("volume size = %llikiB\n", volume_size / 1024);
if (!vol->cluster_size) {
vol->cluster_size = 4096;
if (vol->cluster_size < (u32)opts.sector_size)
vol->cluster_size = opts.sector_size;
while (volume_size >> (ffs(vol->cluster_size) - 1 + 32)) {
vol->cluster_size <<= 1;
if (vol->cluster_size > 65535) {
ntfs_log_error("Device is too large to hold an "
"NTFS volume (maximum size is "
"256TiB).\n");
return FALSE;
}
}
ntfs_log_quiet("Cluster size has been automatically set to %u "
"bytes.\n", (unsigned)vol->cluster_size);
}
if (vol->cluster_size & (vol->cluster_size - 1)) {
ntfs_log_error("The cluster size is invalid. It must be a "
"power of two, e.g. 1024, 4096.\n");
return FALSE;
}
if (vol->cluster_size < (u32)opts.sector_size) {
ntfs_log_error("The cluster size is invalid. It must be equal "
"to, or larger than, the sector size.\n");
return FALSE;
}
if (vol->cluster_size > 128 * (u32)opts.sector_size) {
ntfs_log_error("The cluster size is invalid. It cannot be "
"more that 128 times the size of the sector "
"size.\n");
return FALSE;
}
if (vol->cluster_size > 65536) {
ntfs_log_error("The cluster size is invalid. The maximum "
"cluster size is 65536 bytes (64kiB).\n");
return FALSE;
}
vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
ntfs_log_debug("cluster size = %u bytes\n",
(unsigned int)vol->cluster_size);
if (vol->cluster_size > 4096) {
if (opts.enable_compression) {
if (!opts.force) {
ntfs_log_error("Windows cannot use compression "
"when the cluster size is "
"larger than 4096 bytes.\n");
return FALSE;
}
opts.enable_compression = 0;
}
ntfs_log_warning("Windows cannot use compression when the "
"cluster size is larger than 4096 bytes. "
"Compression has been disabled for this "
"volume.\n");
}
vol->nr_clusters = volume_size / vol->cluster_size;
if ((vol->nr_clusters != ((opts.num_sectors * opts.sector_size) /
vol->cluster_size) ||
(volume_size / opts.sector_size) != opts.num_sectors ||
(volume_size / vol->cluster_size) !=
vol->nr_clusters)) {
ntfs_log_error("Illegal combination of volume/cluster/sector "
"size and/or cluster/sector number.\n");
return FALSE;
}
ntfs_log_debug("number of clusters = %llu (0x%llx)\n",
vol->nr_clusters, vol->nr_clusters);
if (vol->nr_clusters >> 32) {
if (vol->cluster_size >= 65536) {
ntfs_log_error("Device is too large to hold an NTFS "
"volume (maximum size is 256TiB).\n");
return FALSE;
}
ntfs_log_error("Number of clusters exceeds 32 bits. Please "
"try again with a larger\ncluster size or "
"leave the cluster size unspecified and the "
"smallest possible cluster size for the size "
"of the device will be used.\n");
return FALSE;
}
page_size = mkntfs_get_page_size();
vol->mft_record_size = 1024;
if (vol->mft_record_size < (u32)opts.sector_size)
vol->mft_record_size = opts.sector_size;
if (vol->mft_record_size > (unsigned long)page_size)
ntfs_log_warning("Mft record size (%u bytes) exceeds system "
"page size (%li bytes). You will not be able "
"to mount this volume using the NTFS kernel "
"driver.\n", (unsigned)vol->mft_record_size,
page_size);
vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
ntfs_log_debug("mft record size = %u bytes\n",
(unsigned)vol->mft_record_size);
vol->indx_record_size = 4096;
if (vol->indx_record_size < (u32)opts.sector_size)
vol->indx_record_size = opts.sector_size;
if (vol->indx_record_size > (unsigned long)page_size)
ntfs_log_warning("Index record size (%u bytes) exceeds system "
"page size (%li bytes). You will not be able "
"to mount this volume using the NTFS kernel "
"driver.\n", (unsigned)vol->indx_record_size,
page_size);
vol->indx_record_size_bits = ffs(vol->indx_record_size) - 1;
ntfs_log_debug("index record size = %u bytes\n",
(unsigned)vol->indx_record_size);
if (!winboot) {
ntfs_log_warning("To boot from a device, Windows needs the "
"'partition start sector', the 'sectors per "
"track' and the 'number of heads' to be "
"set.\n");
ntfs_log_warning("Windows will not be able to boot from this "
"device.\n");
}
return TRUE;
}
static BOOL mkntfs_initialize_bitmaps(void)
{
u64 i;
int mft_bitmap_size;
g_lcn_bitmap_byte_size = (g_vol->nr_clusters + 7) >> 3;
g_lcn_bitmap_byte_size = (g_lcn_bitmap_byte_size + 7) & ~7;
i = (g_lcn_bitmap_byte_size + g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1);
ntfs_log_debug("g_lcn_bitmap_byte_size = %i, allocated = %llu\n",
g_lcn_bitmap_byte_size, i);
g_dynamic_buf_size = mkntfs_get_page_size();
g_dynamic_buf = (u8*)ntfs_calloc(g_dynamic_buf_size);
if (!g_dynamic_buf)
return FALSE;
if (!bitmap_allocate(g_vol->nr_clusters,
((s64)g_lcn_bitmap_byte_size << 3) - g_vol->nr_clusters))
return (FALSE);
g_mft_size = 27;
g_mft_size *= g_vol->mft_record_size;
if (g_mft_size < (s32)g_vol->cluster_size)
g_mft_size = g_vol->cluster_size;
ntfs_log_debug("MFT size = %i (0x%x) bytes\n", g_mft_size, g_mft_size);
mft_bitmap_size = g_mft_size / g_vol->mft_record_size;
g_mft_bitmap_byte_size = (mft_bitmap_size + 7) >> 3;
g_mft_bitmap_byte_size = (g_mft_bitmap_byte_size + 7) & ~7;
ntfs_log_debug("mft_bitmap_size = %i, g_mft_bitmap_byte_size = %i\n",
mft_bitmap_size, g_mft_bitmap_byte_size);
g_mft_bitmap = ntfs_calloc(g_mft_bitmap_byte_size);
if (!g_mft_bitmap)
return FALSE;
g_rl_mft_bmp = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_mft_bmp)
return FALSE;
g_rl_mft_bmp[0].vcn = 0LL;
i = (8192 + g_vol->cluster_size - 1) / g_vol->cluster_size;
g_rl_mft_bmp[0].lcn = i;
g_rl_mft_bmp[1].vcn = 1LL;
g_rl_mft_bmp[0].length = 1LL;
g_rl_mft_bmp[1].lcn = -1LL;
g_rl_mft_bmp[1].length = 0LL;
return (bitmap_allocate(i,1));
}
static BOOL mkntfs_initialize_rl_mft(void)
{
int j;
BOOL done;
if (!g_mft_lcn) {
g_mft_lcn = g_rl_mft_bmp[0].lcn + g_rl_mft_bmp[0].length;
if (g_mft_lcn * g_vol->cluster_size < 16 * 1024)
g_mft_lcn = (16 * 1024 + g_vol->cluster_size - 1) /
g_vol->cluster_size;
}
ntfs_log_debug("$MFT logical cluster number = 0x%llx\n", g_mft_lcn);
g_mft_zone_end = g_vol->nr_clusters;
switch (opts.mft_zone_multiplier) {
case 4:
g_mft_zone_end = g_mft_zone_end >> 1;
break;
case 3:
g_mft_zone_end = g_mft_zone_end * 3 >> 3;
break;
case 2:
g_mft_zone_end = g_mft_zone_end >> 2;
break;
case 1:
default:
g_mft_zone_end = g_mft_zone_end >> 3;
break;
}
ntfs_log_debug("MFT zone size = %lldkiB\n", g_mft_zone_end <<
g_vol->cluster_size_bits >> 10 );
g_mft_zone_end += g_mft_lcn;
g_rl_mft = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_mft)
return FALSE;
g_rl_mft[0].vcn = 0LL;
g_rl_mft[0].lcn = g_mft_lcn;
j = (g_mft_size + g_vol->cluster_size - 1) / g_vol->cluster_size;
g_rl_mft[1].vcn = j;
g_rl_mft[0].length = j;
g_rl_mft[1].lcn = -1LL;
g_rl_mft[1].length = 0LL;
bitmap_allocate(g_mft_lcn,j);
g_mftmirr_lcn = (opts.num_sectors * opts.sector_size >> 1)
/ g_vol->cluster_size;
ntfs_log_debug("$MFTMirr logical cluster number = 0x%llx\n",
g_mftmirr_lcn);
g_rl_mftmirr = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_mftmirr)
return FALSE;
g_rl_mftmirr[0].vcn = 0LL;
g_rl_mftmirr[0].lcn = g_mftmirr_lcn;
j = (4 * g_vol->mft_record_size + g_vol->cluster_size - 1) / g_vol->cluster_size;
g_rl_mftmirr[1].vcn = j;
g_rl_mftmirr[0].length = j;
g_rl_mftmirr[1].lcn = -1LL;
g_rl_mftmirr[1].length = 0LL;
done = bitmap_allocate(g_mftmirr_lcn,j);
g_logfile_lcn = g_mftmirr_lcn + j;
ntfs_log_debug("$LogFile logical cluster number = 0x%llx\n",
g_logfile_lcn);
return (done);
}
static BOOL mkntfs_initialize_rl_logfile(void)
{
int j;
u64 volume_size;
g_rl_logfile = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_logfile)
return FALSE;
volume_size = g_vol->nr_clusters << g_vol->cluster_size_bits;
g_rl_logfile[0].vcn = 0LL;
g_rl_logfile[0].lcn = g_logfile_lcn;
if (volume_size < 2048LL * 1024)
g_logfile_size = 256LL * 1024;
else if (volume_size < 4000000LL)
g_logfile_size = 512LL * 1024;
else if (volume_size <= 200LL * 1024 * 1024)
g_logfile_size = 2048LL * 1024;
else {
if (volume_size >= 12LL << 30)
g_logfile_size = 64 << 20;
else
g_logfile_size = (volume_size / 200) &
~(g_vol->cluster_size - 1);
}
j = g_logfile_size / g_vol->cluster_size;
while (g_rl_logfile[0].lcn + j >= g_vol->nr_clusters) {
g_logfile_size >>= 1;
j = g_logfile_size / g_vol->cluster_size;
}
g_logfile_size = (g_logfile_size + g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1);
ntfs_log_debug("$LogFile (journal) size = %ikiB\n",
g_logfile_size / 1024);
if (g_logfile_size < 256 << 10) {
ntfs_log_error("$LogFile would be created with invalid size. "
"This is not allowed as it would cause Windows "
"to blue screen and during boot.\n");
return FALSE;
}
g_rl_logfile[1].vcn = j;
g_rl_logfile[0].length = j;
g_rl_logfile[1].lcn = -1LL;
g_rl_logfile[1].length = 0LL;
return (bitmap_allocate(g_logfile_lcn,j));
}
static BOOL mkntfs_initialize_rl_boot(void)
{
int j;
g_rl_boot = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_boot)
return FALSE;
g_rl_boot[0].vcn = 0LL;
g_rl_boot[0].lcn = 0LL;
j = (8192 + g_vol->cluster_size - 1) / g_vol->cluster_size;
g_rl_boot[1].vcn = j;
g_rl_boot[0].length = j;
g_rl_boot[1].lcn = -1LL;
g_rl_boot[1].length = 0LL;
return (bitmap_allocate(0,j));
}
static BOOL mkntfs_initialize_rl_bad(void)
{
g_rl_bad = ntfs_malloc(2 * sizeof(runlist));
if (!g_rl_bad)
return FALSE;
g_rl_bad[0].vcn = 0LL;
g_rl_bad[0].lcn = -1LL;
g_rl_bad[1].vcn = g_vol->nr_clusters;
g_rl_bad[0].length = g_vol->nr_clusters;
g_rl_bad[1].lcn = -1LL;
g_rl_bad[1].length = 0LL;
return TRUE;
}
static BOOL mkntfs_fill_device_with_zeroes(void)
{
int i;
ssize_t bw;
unsigned long long position;
float progress_inc = (float)g_vol->nr_clusters / 100;
u64 volume_size;
volume_size = g_vol->nr_clusters << g_vol->cluster_size_bits;
ntfs_log_progress("Initializing device with zeroes: 0%%");
for (position = 0; position < (unsigned long long)g_vol->nr_clusters;
position++) {
if (!(position % (int)(progress_inc+1))) {
ntfs_log_progress("\b\b\b\b%3.0f%%", position /
progress_inc);
}
bw = mkntfs_write(g_vol->dev, g_buf, g_vol->cluster_size);
if (bw != (ssize_t)g_vol->cluster_size) {
if (bw != -1 || errno != EIO) {
ntfs_log_error("This should not happen.\n");
return FALSE;
}
if (!position) {
ntfs_log_error("Error: Cluster zero is bad. "
"Cannot create NTFS file "
"system.\n");
return FALSE;
}
if (!append_to_bad_blocks(position))
return FALSE;
ntfs_log_quiet("\nFound bad cluster (%lld). Adding to "
"list of bad blocks.\nInitializing "
"device with zeroes: %3.0f%%", position,
position / progress_inc);
g_vol->dev->d_ops->seek(g_vol->dev,
((off_t)position + 1) *
g_vol->cluster_size, SEEK_SET);
}
}
ntfs_log_progress("\b\b\b\b100%%");
position = (volume_size & (g_vol->cluster_size - 1)) /
opts.sector_size;
for (i = 0; (unsigned long)i < position; i++) {
bw = mkntfs_write(g_vol->dev, g_buf, opts.sector_size);
if (bw != opts.sector_size) {
if (bw != -1 || errno != EIO) {
ntfs_log_error("This should not happen.\n");
return FALSE;
} else if (i + 1ull == position) {
ntfs_log_error("Error: Bad cluster found in "
"location reserved for system "
"file $Boot.\n");
return FALSE;
}
g_vol->dev->d_ops->seek(g_vol->dev,
opts.sector_size, SEEK_CUR);
}
}
ntfs_log_progress(" - Done.\n");
return TRUE;
}
static BOOL mkntfs_sync_index_record(INDEX_ALLOCATION* idx, MFT_RECORD* m,
ntfschar* name, u32 name_len)
{
int i, err;
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
long long lw;
runlist *rl_index = NULL;
i = 5 * sizeof(ntfschar);
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_perror("Failed to allocate attribute search context");
return FALSE;
}
if (mkntfs_attr_lookup(AT_INDEX_ALLOCATION, name, name_len,
CASE_SENSITIVE, 0, NULL, 0, ctx)) {
ntfs_attr_put_search_ctx(ctx);
ntfs_log_error("BUG: $INDEX_ALLOCATION attribute not found.\n");
return FALSE;
}
a = ctx->attr;
rl_index = ntfs_mapping_pairs_decompress(g_vol, a, NULL);
if (!rl_index) {
ntfs_attr_put_search_ctx(ctx);
ntfs_log_error("Failed to decompress runlist of $INDEX_ALLOCATION "
"attribute.\n");
return FALSE;
}
if (sle64_to_cpu(a->initialized_size) < i) {
ntfs_attr_put_search_ctx(ctx);
free(rl_index);
ntfs_log_error("BUG: $INDEX_ALLOCATION attribute too short.\n");
return FALSE;
}
ntfs_attr_put_search_ctx(ctx);
i = sizeof(INDEX_BLOCK) - sizeof(INDEX_HEADER) +
le32_to_cpu(idx->index.allocated_size);
err = ntfs_mst_pre_write_fixup((NTFS_RECORD*)idx, i);
if (err) {
free(rl_index);
ntfs_log_error("ntfs_mst_pre_write_fixup() failed while "
"syncing index block.\n");
return FALSE;
}
lw = ntfs_rlwrite(g_vol->dev, rl_index, (u8*)idx, i, NULL,
WRITE_STANDARD);
free(rl_index);
if (lw != i) {
ntfs_log_error("Error writing $INDEX_ALLOCATION.\n");
return FALSE;
}
return TRUE;
}
static BOOL create_file_volume(MFT_RECORD *m, leMFT_REF root_ref,
VOLUME_FLAGS fl, const GUID *volume_guid)
{
int i, err;
u8 *sd;
ntfs_log_verbose("Creating $Volume (mft record 3)\n");
m = (MFT_RECORD*)(g_buf + 3 * g_vol->mft_record_size);
err = create_hardlink(g_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, CASE_SENSITIVE,
const_cpu_to_le16(0), NULL, 0);
if (!err)
err = add_attr_vol_name(m, g_vol->vol_name, g_vol->vol_name ?
strlen(g_vol->vol_name) : 0);
if (!err) {
if (fl & VOLUME_IS_DIRTY)
ntfs_log_quiet("Setting the volume dirty so check "
"disk runs on next reboot into "
"Windows.\n");
err = add_attr_vol_info(m, fl, g_vol->major_ver,
g_vol->minor_ver);
}
if (!err && opts.with_uuid)
err = add_attr_object_id(m, volume_guid);
if (err < 0) {
ntfs_log_error("Couldn't create $Volume: %s\n",
strerror(-err));
return FALSE;
}
return TRUE;
}
static int create_backup_boot_sector(u8 *buff)
{
const char *s;
ssize_t bw;
int size, e;
ntfs_log_verbose("Creating backup boot sector.\n");
size = 512;
if (size < opts.sector_size)
size = opts.sector_size;
if (g_vol->dev->d_ops->seek(g_vol->dev, (opts.num_sectors + 1) *
opts.sector_size - size, SEEK_SET) == (off_t)-1) {
ntfs_log_perror("Seek failed");
goto bb_err;
}
if (size > 8192)
size = 8192;
bw = mkntfs_write(g_vol->dev, buff, size);
if (bw == size)
return 0;
e = errno;
if (bw == -1LL)
s = strerror(e);
else
s = "unknown error";
if (bw != -1LL || (bw == -1LL && e != ENOSPC && e != EIO)) {
ntfs_log_critical("Couldn't write backup boot sector: %s\n", s);
return -1;
}
bb_err:
ntfs_log_error("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\n"
"backup boot sector when it is run on your next boot "
"into Windows.\n");
return -1;
}
static BOOL mkntfs_create_root_structures(void)
{
NTFS_BOOT_SECTOR *bs;
MFT_RECORD *m;
leMFT_REF root_ref;
leMFT_REF extend_ref;
int i;
int j;
int err;
u8 *sd;
FILE_ATTR_FLAGS extend_flags;
VOLUME_FLAGS volume_flags = const_cpu_to_le16(0);
int nr_sysfiles;
int buf_sds_first_size;
char *buf_sds;
GUID vol_guid;
ntfs_log_quiet("Creating NTFS volume structures.\n");
nr_sysfiles = 27;
for (i = 0; i < nr_sysfiles; i++) {
if (ntfs_mft_record_layout(g_vol, 0, m = (MFT_RECORD *)(g_buf +
i * g_vol->mft_record_size))) {
ntfs_log_error("Failed to layout system mft records."
"\n");
return FALSE;
}
if (i == 0 || i > 23)
m->sequence_number = cpu_to_le16(1);
else
m->sequence_number = cpu_to_le16(i);
}
if (nr_sysfiles * (s32)g_vol->mft_record_size < g_mft_size) {
for (i = nr_sysfiles;
i * (s32)g_vol->mft_record_size < g_mft_size; i++) {
m = (MFT_RECORD *)(g_buf + i * g_vol->mft_record_size);
if (ntfs_mft_record_layout(g_vol, 0, m)) {
ntfs_log_error("Failed to layout mft record."
"\n");
return FALSE;
}
m->flags = cpu_to_le16(0);
m->sequence_number = cpu_to_le16(i);
}
}
for (i = 0; i < nr_sysfiles; i++) {
le32 file_attrs;
m = (MFT_RECORD*)(g_buf + i * g_vol->mft_record_size);
if (i < 16 || i > 23) {
m->mft_record_number = cpu_to_le32(i);
m->flags |= MFT_RECORD_IN_USE;
ntfs_bit_set(g_mft_bitmap, 0LL + i, 1);
}
file_attrs = FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM;
if (i == FILE_root) {
file_attrs |= FILE_ATTR_ARCHIVE;
if (opts.disable_indexing)
file_attrs |= FILE_ATTR_NOT_CONTENT_INDEXED;
if (opts.enable_compression)
file_attrs |= FILE_ATTR_COMPRESSED;
}
if (i == 0 || i == 1 || i == 2 || i == 6 || i == 8 ||
i == 10) {
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0100));
} else if (i == 9) {
file_attrs |= FILE_ATTR_VIEW_INDEX_PRESENT;
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0101));
} else if (i == 11) {
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0101));
} else if (i == 24 || i == 25 || i == 26) {
file_attrs |= FILE_ATTR_ARCHIVE;
file_attrs |= FILE_ATTR_VIEW_INDEX_PRESENT;
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x0101));
} else {
add_attr_std_info(m, file_attrs,
cpu_to_le32(0x00));
}
}
root_ref = MK_LE_MREF(FILE_root, FILE_root);
extend_ref = MK_LE_MREF(11,11);
ntfs_log_verbose("Creating root directory (mft record 5)\n");
m = (MFT_RECORD*)(g_buf + 5 * g_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_I30_INDEX_PRESENT, 0, 0, ".",
FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_root_sd(&sd, &i);
err = add_attr_sd(m, sd, i);
}
if (!err)
err = add_attr_index_root(m, "$I30", 4, CASE_SENSITIVE,
AT_FILE_NAME, COLLATION_FILE_NAME,
g_vol->indx_record_size);
if (!err)
err = upgrade_to_large_index(m, "$I30", 4, CASE_SENSITIVE,
&g_index_block);
if (!err) {
ntfs_attr_search_ctx *ctx;
ATTR_RECORD *a;
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_perror("Failed to allocate attribute search "
"context");
return FALSE;
}
if (mkntfs_attr_lookup(AT_FILE_NAME, AT_UNNAMED, 0,
CASE_SENSITIVE, 0, NULL, 0, ctx)) {
ntfs_attr_put_search_ctx(ctx);
ntfs_log_error("BUG: $FILE_NAME attribute not found."
"\n");
return FALSE;
}
a = ctx->attr;
err = insert_file_link_in_dir_index(g_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) {
ntfs_log_error("Couldn't create root directory: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $MFT (mft record 0)\n");
m = (MFT_RECORD*)g_buf;
err = add_attr_data_positioned(m, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), g_rl_mft, g_buf, g_mft_size);
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_MFT, 1),
((g_mft_size - 1)
| (g_vol->cluster_size - 1)) + 1,
g_mft_size, FILE_ATTR_HIDDEN |
FILE_ATTR_SYSTEM, 0, 0, "$MFT",
FILE_NAME_WIN32_AND_DOS);
if (!err)
err = add_attr_bitmap_positioned(m, NULL, 0, CASE_SENSITIVE,
g_rl_mft_bmp,
g_mft_bitmap, g_mft_bitmap_byte_size);
if (err < 0) {
ntfs_log_error("Couldn't create $MFT: %s\n", strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $MFTMirr (mft record 1)\n");
m = (MFT_RECORD*)(g_buf + 1 * g_vol->mft_record_size);
err = add_attr_data_positioned(m, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), g_rl_mftmirr, g_buf,
g_rl_mftmirr[0].length * g_vol->cluster_size);
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_MFTMirr, FILE_MFTMirr),
g_rl_mftmirr[0].length * g_vol->cluster_size,
g_rl_mftmirr[0].length * g_vol->cluster_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$MFTMirr", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $MFTMirr: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $LogFile (mft record 2)\n");
m = (MFT_RECORD*)(g_buf + 2 * g_vol->mft_record_size);
err = add_attr_data_positioned(m, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), g_rl_logfile,
(const u8*)NULL, g_logfile_size);
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_LogFile, FILE_LogFile),
g_logfile_size, g_logfile_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$LogFile", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $LogFile: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $AttrDef (mft record 4)\n");
m = (MFT_RECORD*)(g_buf + 4 * g_vol->mft_record_size);
err = add_attr_data(m, NULL, 0, CASE_SENSITIVE, const_cpu_to_le16(0),
(u8*)g_vol->attrdef, g_vol->attrdef_len);
if (!err)
err = add_attr_data(m, "$Info", 5, CASE_SENSITIVE,
const_cpu_to_le16(0),
(u8*)g_upcaseinfo, sizeof(struct UPCASEINFO));
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_AttrDef, FILE_AttrDef),
(g_vol->attrdef_len + g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1), g_vol->attrdef_len,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$AttrDef", FILE_NAME_WIN32_AND_DOS);
if (!err) {
init_system_file_sd(FILE_AttrDef, &sd, &i);
err = add_attr_sd(m, sd, i);
}
if (err < 0) {
ntfs_log_error("Couldn't create $AttrDef: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $Bitmap (mft record 6)\n");
m = (MFT_RECORD*)(g_buf + 6 * g_vol->mft_record_size);
if (!err)
err = insert_non_resident_attr_in_mft_record(m,
AT_DATA, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), (const u8*)NULL,
g_lcn_bitmap_byte_size, WRITE_BITMAP);
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_Bitmap, FILE_Bitmap),
(g_lcn_bitmap_byte_size + g_vol->cluster_size -
1) & ~(g_vol->cluster_size - 1),
g_lcn_bitmap_byte_size,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$Bitmap", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $Bitmap: %s\n", strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $Boot (mft record 7)\n");
m = (MFT_RECORD*)(g_buf + 7 * g_vol->mft_record_size);
bs = ntfs_calloc(8192);
if (!bs)
return FALSE;
memcpy(bs, boot_array, sizeof(boot_array));
bs->bpb.bytes_per_sector = cpu_to_le16(opts.sector_size);
bs->bpb.sectors_per_cluster = (u8)(g_vol->cluster_size /
opts.sector_size);
bs->bpb.media_type = 0xf8;
bs->bpb.sectors_per_track = cpu_to_le16(opts.sectors_per_track);
ntfs_log_debug("sectors per track = %ld (0x%lx)\n",
opts.sectors_per_track, opts.sectors_per_track);
bs->bpb.heads = cpu_to_le16(opts.heads);
ntfs_log_debug("heads = %ld (0x%lx)\n", opts.heads, opts.heads);
bs->bpb.hidden_sectors = cpu_to_le32(opts.part_start_sect);
ntfs_log_debug("hidden sectors = %llu (0x%llx)\n", opts.part_start_sect,
opts.part_start_sect);
bs->physical_drive = 0x80;
bs->extended_boot_signature = 0x80;
bs->number_of_sectors = cpu_to_sle64(opts.num_sectors);
bs->mft_lcn = cpu_to_sle64(g_mft_lcn);
bs->mftmirr_lcn = cpu_to_sle64(g_mftmirr_lcn);
if (g_vol->mft_record_size >= g_vol->cluster_size) {
bs->clusters_per_mft_record = g_vol->mft_record_size /
g_vol->cluster_size;
} else {
bs->clusters_per_mft_record = -(ffs(g_vol->mft_record_size) -
1);
if ((u32)(1 << -bs->clusters_per_mft_record) !=
g_vol->mft_record_size) {
ntfs_log_error("BUG: calculated clusters_per_mft_record"
" is wrong (= 0x%x)\n",
bs->clusters_per_mft_record);
free(bs);
return FALSE;
}
}
ntfs_log_debug("clusters per mft record = %i (0x%x)\n",
bs->clusters_per_mft_record,
bs->clusters_per_mft_record);
if (g_vol->indx_record_size >= g_vol->cluster_size) {
bs->clusters_per_index_record = g_vol->indx_record_size /
g_vol->cluster_size;
} else {
bs->clusters_per_index_record = -g_vol->indx_record_size_bits;
if ((1 << -bs->clusters_per_index_record) !=
(s32)g_vol->indx_record_size) {
ntfs_log_error("BUG: calculated "
"clusters_per_index_record is wrong "
"(= 0x%x)\n",
bs->clusters_per_index_record);
free(bs);
return FALSE;
}
}
ntfs_log_debug("clusters per index block = %i (0x%x)\n",
bs->clusters_per_index_record,
bs->clusters_per_index_record);
bs->volume_serial_number = cpu_to_le64(((u64)random() << 32) |
((u64)random() & 0xffffffff));
bs->checksum = cpu_to_le32(0);
if (!ntfs_boot_sector_is_ntfs(bs)) {
free(bs);
ntfs_log_error("FATAL: Generated boot sector is invalid!\n");
return FALSE;
}
err = add_attr_data_positioned(m, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), g_rl_boot, (u8*)bs, 8192);
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_Boot, FILE_Boot),
(8192 + g_vol->cluster_size - 1) &
~(g_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) {
free(bs);
ntfs_log_error("Couldn't create $Boot: %s\n", strerror(-err));
return FALSE;
}
if (create_backup_boot_sector((u8*)bs)) {
volume_flags |= VOLUME_IS_DIRTY;
}
free(bs);
if (!opts.use_epoch_time) {
#ifdef ENABLE_UUID
uuid_generate((void*)&vol_guid);
#else
ntfs_generate_guid(&vol_guid);
#endif
} else
memset(&vol_guid, 0, sizeof(vol_guid));
if (!create_file_volume(m, root_ref, volume_flags, &vol_guid))
return FALSE;
ntfs_log_verbose("Creating $BadClus (mft record 8)\n");
m = (MFT_RECORD*)(g_buf + 8 * g_vol->mft_record_size);
err = add_attr_data_positioned(m, "$Bad", 4, CASE_SENSITIVE,
const_cpu_to_le16(0), g_rl_bad, NULL,
g_vol->nr_clusters * g_vol->cluster_size);
if (!err) {
err = add_attr_data(m, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), NULL, 0);
}
if (!err) {
err = create_hardlink(g_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 < 0) {
ntfs_log_error("Couldn't create $BadClus: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $Secure (mft record 9)\n");
m = (MFT_RECORD*)(g_buf + 9 * g_vol->mft_record_size);
m->flags |= MFT_RECORD_IS_VIEW_INDEX;
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(9, 9), 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_VIEW_INDEX_PRESENT, 0, 0,
"$Secure", FILE_NAME_WIN32_AND_DOS);
buf_sds = NULL;
buf_sds_first_size = 0;
if (!err) {
int buf_sds_size;
buf_sds_first_size = 0xfc;
buf_sds_size = 0x40000 + buf_sds_first_size;
buf_sds = ntfs_calloc(buf_sds_size);
if (!buf_sds)
return FALSE;
init_secure_sds(buf_sds);
memcpy(buf_sds + 0x40000, buf_sds, buf_sds_first_size);
err = add_attr_data(m, "$SDS", 4, CASE_SENSITIVE,
const_cpu_to_le16(0), (u8*)buf_sds,
buf_sds_size);
}
if (!err)
err = add_attr_index_root(m, "$SDH", 4, CASE_SENSITIVE,
AT_UNUSED, COLLATION_NTOFS_SECURITY_HASH,
g_vol->indx_record_size);
if (!err)
err = add_attr_index_root(m, "$SII", 4, CASE_SENSITIVE,
AT_UNUSED, COLLATION_NTOFS_ULONG,
g_vol->indx_record_size);
if (!err)
err = initialize_secure(buf_sds, buf_sds_first_size, m);
free(buf_sds);
if (err < 0) {
ntfs_log_error("Couldn't create $Secure: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $UpCase (mft record 0xa)\n");
m = (MFT_RECORD*)(g_buf + 0xa * g_vol->mft_record_size);
err = add_attr_data(m, NULL, 0, CASE_SENSITIVE, const_cpu_to_le16(0),
(u8*)g_vol->upcase, g_vol->upcase_len << 1);
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(FILE_UpCase, FILE_UpCase),
((g_vol->upcase_len << 1) +
g_vol->cluster_size - 1) &
~(g_vol->cluster_size - 1),
g_vol->upcase_len << 1,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM, 0, 0,
"$UpCase", FILE_NAME_WIN32_AND_DOS);
if (err < 0) {
ntfs_log_error("Couldn't create $UpCase: %s\n", strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $Extend (mft record 11)\n");
m = (MFT_RECORD*)(g_buf + 11 * g_vol->mft_record_size);
m->flags |= MFT_RECORD_IS_DIRECTORY;
if (!err)
err = create_hardlink(g_index_block, root_ref, m,
MK_LE_MREF(11, 11), 0LL, 0LL,
FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_I30_INDEX_PRESENT, 0, 0,
"$Extend", FILE_NAME_WIN32_AND_DOS);
if (!err)
err = add_attr_index_root(m, "$I30", 4, CASE_SENSITIVE,
AT_FILE_NAME, COLLATION_FILE_NAME,
g_vol->indx_record_size);
if (err < 0) {
ntfs_log_error("Couldn't create $Extend: %s\n",
strerror(-err));
return FALSE;
}
for (i = 0xc; i < 0x10; i++) {
ntfs_log_verbose("Creating system file (mft record 0x%x)\n", i);
m = (MFT_RECORD*)(g_buf + i * g_vol->mft_record_size);
err = add_attr_data(m, NULL, 0, CASE_SENSITIVE,
const_cpu_to_le16(0), NULL, 0);
if (!err) {
init_system_file_sd(i, &sd, &j);
err = add_attr_sd(m, sd, j);
}
if (err < 0) {
ntfs_log_error("Couldn't create system file %i (0x%x): "
"%s\n", i, i, strerror(-err));
return FALSE;
}
}
extend_flags = FILE_ATTR_HIDDEN | FILE_ATTR_SYSTEM |
FILE_ATTR_ARCHIVE | FILE_ATTR_VIEW_INDEX_PRESENT;
ntfs_log_verbose("Creating $Quota (mft record 24)\n");
m = (MFT_RECORD*)(g_buf + 24 * g_vol->mft_record_size);
m->flags |= MFT_RECORD_IS_4;
m->flags |= MFT_RECORD_IS_VIEW_INDEX;
if (!err)
err = create_hardlink_res((MFT_RECORD*)(g_buf +
11 * g_vol->mft_record_size), extend_ref, m,
MK_LE_MREF(24, 1), 0LL, 0LL, extend_flags,
0, 0, "$Quota", FILE_NAME_WIN32_AND_DOS);
if (!err)
err = add_attr_index_root(m, "$Q", 2, CASE_SENSITIVE, AT_UNUSED,
COLLATION_NTOFS_ULONG, g_vol->indx_record_size);
if (!err)
err = add_attr_index_root(m, "$O", 2, CASE_SENSITIVE, AT_UNUSED,
COLLATION_NTOFS_SID, g_vol->indx_record_size);
if (!err)
err = initialize_quota(m);
if (err < 0) {
ntfs_log_error("Couldn't create $Quota: %s\n", strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $ObjId (mft record 25)\n");
m = (MFT_RECORD*)(g_buf + 25 * g_vol->mft_record_size);
m->flags |= MFT_RECORD_IS_4;
m->flags |= MFT_RECORD_IS_VIEW_INDEX;
if (!err)
err = create_hardlink_res((MFT_RECORD*)(g_buf +
11 * g_vol->mft_record_size), extend_ref,
m, MK_LE_MREF(25, 1), 0LL, 0LL,
extend_flags, 0, 0, "$ObjId",
FILE_NAME_WIN32_AND_DOS);
if (!err)
err = add_attr_index_root(m, "$O", 2, CASE_SENSITIVE, AT_UNUSED,
COLLATION_NTOFS_ULONGS,
g_vol->indx_record_size);
if (!err && opts.with_uuid)
err = index_obj_id_insert(m, &vol_guid,
MK_LE_MREF(FILE_Volume, FILE_Volume));
if (err < 0) {
ntfs_log_error("Couldn't create $ObjId: %s\n",
strerror(-err));
return FALSE;
}
ntfs_log_verbose("Creating $Reparse (mft record 26)\n");
m = (MFT_RECORD*)(g_buf + 26 * g_vol->mft_record_size);
m->flags |= MFT_RECORD_IS_4;
m->flags |= MFT_RECORD_IS_VIEW_INDEX;
if (!err)
err = create_hardlink_res((MFT_RECORD*)(g_buf +
11 * g_vol->mft_record_size),
extend_ref, m, MK_LE_MREF(26, 1),
0LL, 0LL, extend_flags, 0, 0,
"$Reparse", FILE_NAME_WIN32_AND_DOS);
if (!err)
err = add_attr_index_root(m, "$R", 2, CASE_SENSITIVE, AT_UNUSED,
COLLATION_NTOFS_ULONGS, g_vol->indx_record_size);
if (err < 0) {
ntfs_log_error("Couldn't create $Reparse: %s\n",
strerror(-err));
return FALSE;
}
return TRUE;
}
static int mkntfs_redirect(struct mkntfs_options *opts2)
{
u64 upcase_crc;
int result = 1;
ntfs_attr_search_ctx *ctx = NULL;
long long lw, pos;
ATTR_RECORD *a;
MFT_RECORD *m;
int i, err;
if (!opts2) {
ntfs_log_error("Internal error: invalid parameters to mkntfs_options.\n");
goto done;
}
srandom(le64_to_cpu(mkntfs_time())/10000000);
g_vol = ntfs_volume_alloc();
if (!g_vol) {
ntfs_log_perror("Could not create volume");
goto done;
}
g_vol->major_ver = 3;
g_vol->minor_ver = 1;
if (opts.label) {
g_vol->vol_name = strdup(opts.label);
if (!g_vol->vol_name) {
ntfs_log_perror("Could not copy volume name");
goto done;
}
}
if (opts.cluster_size >= 0)
g_vol->cluster_size = opts.cluster_size;
g_vol->upcase_len = ntfs_upcase_build_default(&g_vol->upcase);
g_upcaseinfo =
(struct UPCASEINFO*)ntfs_malloc(sizeof(struct UPCASEINFO));
if (!g_vol->upcase_len || !g_upcaseinfo)
goto done;
crc64(0,(byte*)NULL,0);
upcase_crc = crc64(0,(byte*)g_vol->upcase,
g_vol->upcase_len * sizeof(ntfschar));
memset(g_upcaseinfo, 0, sizeof(struct UPCASEINFO));
g_upcaseinfo->len = const_cpu_to_le32(sizeof(struct UPCASEINFO));
g_upcaseinfo->crc = cpu_to_le64(upcase_crc);
g_vol->attrdef = ntfs_malloc(sizeof(attrdef_ntfs3x_array));
if (!g_vol->attrdef) {
ntfs_log_perror("Could not create attrdef structure");
goto done;
}
memcpy(g_vol->attrdef, attrdef_ntfs3x_array,
sizeof(attrdef_ntfs3x_array));
g_vol->attrdef_len = sizeof(attrdef_ntfs3x_array);
if (!mkntfs_open_partition(g_vol))
goto done;
if (!mkntfs_override_vol_params(g_vol))
goto done;
if (!mkntfs_initialize_bitmaps())
goto done;
if (!mkntfs_initialize_rl_mft())
goto done;
if (!mkntfs_initialize_rl_logfile())
goto done;
if (!mkntfs_initialize_rl_boot())
goto done;
g_buf = ntfs_calloc(g_mft_size);
if (!g_buf)
goto done;
if (!mkntfs_initialize_rl_bad())
goto done;
if (!opts.quick_format) {
if (!mkntfs_fill_device_with_zeroes())
goto done;
}
if (!mkntfs_create_root_structures())
goto done;
ntfs_log_verbose("Syncing root directory index record.\n");
if (!mkntfs_sync_index_record(g_index_block, (MFT_RECORD*)(g_buf + 5 *
g_vol->mft_record_size), NTFS_INDEX_I30, 4))
goto done;
ntfs_log_verbose("Syncing $Bitmap.\n");
m = (MFT_RECORD*)(g_buf + 6 * g_vol->mft_record_size);
ctx = ntfs_attr_get_search_ctx(NULL, m);
if (!ctx) {
ntfs_log_perror("Could not create an attribute search context");
goto done;
}
if (mkntfs_attr_lookup(AT_DATA, AT_UNNAMED, 0, CASE_SENSITIVE,
0, NULL, 0, ctx)) {
ntfs_log_error("BUG: $DATA attribute not found.\n");
goto done;
}
a = ctx->attr;
if (a->non_resident) {
runlist *rl = ntfs_mapping_pairs_decompress(g_vol, a, NULL);
if (!rl) {
ntfs_log_error("ntfs_mapping_pairs_decompress() failed\n");
goto done;
}
lw = ntfs_rlwrite(g_vol->dev, rl, (const u8*)NULL,
g_lcn_bitmap_byte_size, NULL, WRITE_BITMAP);
err = errno;
free(rl);
if (lw != g_lcn_bitmap_byte_size) {
ntfs_log_error("ntfs_rlwrite: %s\n", lw == -1 ?
strerror(err) : "unknown error");
goto done;
}
} else {
ntfs_log_error("Error : the global bitmap is resident\n");
goto done;
}
ntfs_log_verbose("Syncing $MFT.\n");
pos = g_mft_lcn * g_vol->cluster_size;
lw = 1;
for (i = 0; i < g_mft_size / (s32)g_vol->mft_record_size; i++) {
if (!opts.no_action)
lw = ntfs_mst_pwrite(g_vol->dev, pos, 1, g_vol->mft_record_size, g_buf + i * g_vol->mft_record_size);
if (lw != 1) {
ntfs_log_error("ntfs_mst_pwrite: %s\n", lw == -1 ?
strerror(errno) : "unknown error");
goto done;
}
pos += g_vol->mft_record_size;
}
ntfs_log_verbose("Updating $MFTMirr.\n");
pos = g_mftmirr_lcn * g_vol->cluster_size;
lw = 1;
for (i = 0; i < g_rl_mftmirr[0].length * g_vol->cluster_size / g_vol->mft_record_size; i++) {
m = (MFT_RECORD*)(g_buf + i * g_vol->mft_record_size);
if (ntfs_mft_usn_dec(m)) {
ntfs_log_error("ntfs_mft_usn_dec");
goto done;
}
if (!opts.no_action)
lw = ntfs_mst_pwrite(g_vol->dev, pos, 1, g_vol->mft_record_size, g_buf + i * g_vol->mft_record_size);
if (lw != 1) {
ntfs_log_error("ntfs_mst_pwrite: %s\n", lw == -1 ?
strerror(errno) : "unknown error");
goto done;
}
pos += g_vol->mft_record_size;
}
ntfs_log_verbose("Syncing device.\n");
if (g_vol->dev->d_ops->sync(g_vol->dev)) {
ntfs_log_error("Syncing device. FAILED");
goto done;
}
ntfs_log_quiet("mkntfs completed successfully. Have a nice day.\n");
result = 0;
done:
ntfs_attr_put_search_ctx(ctx);
mkntfs_cleanup();
return result;
}
int mkntfs_main(const char *devpath, const char *label)
{
g_buf = NULL;
g_mft_bitmap_byte_size = 0;
g_mft_bitmap = NULL;
g_lcn_bitmap_byte_size = 0;
g_dynamic_buf_size = 0;
g_dynamic_buf = NULL;
g_rl_mft = NULL;
g_rl_mft_bmp = NULL;
g_rl_mftmirr = NULL;
g_rl_logfile = NULL;
g_rl_boot = NULL;
g_rl_bad = NULL;
g_index_block = NULL;
g_vol = NULL;
g_mft_size = 0;
g_mft_lcn = 0;
g_mftmirr_lcn = 0;
g_logfile_lcn = 0;
g_logfile_size = 0;
g_mft_zone_end = 0;
g_num_bad_blocks = 0;
g_bad_blocks = NULL;
g_allocation = NULL;
mkntfs_init_options(&opts);
opts.dev_name = devpath;
opts.label = label;
opts.force = TRUE;
opts.quick_format = TRUE;
return mkntfs_redirect(&opts);
}
