First cut of ntfs_mft_record_alloc() ported from my old ntfs allocator that
I wrote several years ago. Note this is completely untested and there is no error handling at all yet. I will be porting/adding the error handling next. (Anton) (Logical change 1.551)edge.strict_endians
cantab.net!aia21
parent
ad7acfacc2
commit
8fdb6981ff
848
libntfs/mft.c
848
libntfs/mft.c
|
|
@ -36,6 +36,7 @@
|
|||
#include "inode.h"
|
||||
#include "volume.h"
|
||||
#include "layout.h"
|
||||
#include "lcnalloc.h"
|
||||
#include "mft.h"
|
||||
|
||||
/**
|
||||
|
|
@ -371,27 +372,231 @@ int ntfs_mft_record_format(const ntfs_volume *vol, const MFT_REF mref)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* ntfs_mft_bitmap_extend_and_allocate_one -
|
||||
*
|
||||
* Extend the mft bitmap attribute by one cluster.
|
||||
*
|
||||
* Note: Only updates allocated_size, i.e. does not update initialized_size or
|
||||
* data_size.
|
||||
*/
|
||||
static int ntfs_mft_bitmap_extend_by_one_cluster(ntfs_volume *vol,
|
||||
u8 *have_allocated_mftbmp)
|
||||
{
|
||||
LCN lcn;
|
||||
s64 ll;
|
||||
ntfs_attr *mftbmp_na, *lcnbmp_na;
|
||||
runlist_element *rl, *rl2;
|
||||
ntfs_attr_search_ctx *ctx;
|
||||
MFT_RECORD *m;
|
||||
ATTR_RECORD *a;
|
||||
int err, mp_size;
|
||||
u8 b;
|
||||
|
||||
mftbmp_na = vol->mftbmp_na;
|
||||
lcnbmp_na = vol->lcnbmp_na;
|
||||
/*
|
||||
* Determine the last lcn of the mft bitmap. The allocated size of the
|
||||
* mft bitmap cannot be zero so we are ok to do this.
|
||||
*/
|
||||
rl = ntfs_attr_find_vcn(mftbmp_na, (mftbmp_na->allocated_size - 1) >>
|
||||
vol->cluster_size);
|
||||
if (!rl || !rl->length || rl->lcn < 0) {
|
||||
ntfs_error(vol->sb, "Failed to determine last allocated "
|
||||
"cluster of mft bitmap attribute.");
|
||||
if (!rl->length || rl->lcn < 0)
|
||||
errno = EIO;
|
||||
return -1;
|
||||
}
|
||||
lcn = rl->lcn + rl->length;
|
||||
/*
|
||||
* Attempt to get the cluster following the last allocated cluster by
|
||||
* hand as it may be in the MFT zone so the allocator would not give it
|
||||
* to us.
|
||||
*/
|
||||
ll = ntfs_attr_pread(lcnbmp_na, lcn >> 3, 1, &b);
|
||||
if (ll < 0) {
|
||||
ntfs_error(vol->sb, "Failed to read from lcn bitmap.");
|
||||
return -1;
|
||||
}
|
||||
ntfs_debug("Read %llu byte%s.", (long long)ll, ll == 1 ? "" : "s");
|
||||
*have_allocated_mftbmp = 0;
|
||||
if (ll == 1 && b != 0xff) {
|
||||
u8 tb = 1 << (lcn & 7ull);
|
||||
if (!(b & tb)) {
|
||||
/* Next cluster is free, allocate it. */
|
||||
b |= tb;
|
||||
ll = ntfs_attr_pwrite(lcnbmp_na, lcn >> 3, 1, &b);
|
||||
if (ll < 1) {
|
||||
ntfs_error(vol->sb, "Failed to write to lcn "
|
||||
"bitmap.");
|
||||
if (!ll)
|
||||
errno = EIO;
|
||||
return -1;
|
||||
}
|
||||
/* Update the mft bitmap runlist. */
|
||||
rl->length++;
|
||||
rl[1].vcn++;
|
||||
*have_allocated_mftbmp |= 1;
|
||||
ntfs_debug("Appending one cluster to mft bitmap.");
|
||||
}
|
||||
}
|
||||
if (!have_allocated_mftbmp) {
|
||||
/* Allocate a cluster from the DATA_ZONE. */
|
||||
rl2 = ntfs_cluster_alloc(vol, 1, lcn, DATA_ZONE, rl[1].vcn);
|
||||
if (!rl2) {
|
||||
ntfs_error(vol->sb, "Failed to allocate a cluster for "
|
||||
"the mft bitmap.");
|
||||
return -1;
|
||||
}
|
||||
rl = ntfs_runlists_merge(mftbmp_na->rl, rl2);
|
||||
if (!rl) {
|
||||
err = errno;
|
||||
ntfs_error(vol->sb, "Failed to merge runlists for mft "
|
||||
"bitmap.");
|
||||
if (ntfs_cluster_free_from_rl(vol, rl2))
|
||||
ntfs_error(vol->sb, "Failed to dealocate "
|
||||
"cluster. Run chkdsk.");
|
||||
free(rl2);
|
||||
errno = err;
|
||||
return -1;
|
||||
}
|
||||
mftbmp_na->rl = rl;
|
||||
*have_allocated_mftbmp |= 2;
|
||||
ntfs_debug("Adding run to mft bitmap.");
|
||||
rl = ntfs_attr_find_vcn(mftbmp_na, mftbmp_na->allocated_size >>
|
||||
vol->cluster_size);
|
||||
if (!rl || !rl->length) {
|
||||
ntfs_error(vol->sb, "Failed to determine last "
|
||||
"allocated cluster of mft bitmap "
|
||||
"attribute.");
|
||||
if (!rl->length)
|
||||
errno = EIO;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
/* Update the attribute record as well. */
|
||||
ctx = ntfs_attr_get_search_ctx(mftbmp_na->ni, NULL);
|
||||
if (!ctx) {
|
||||
ntfs_error(vol->sb, "Failed to get search context.");
|
||||
return -1;
|
||||
}
|
||||
if (ntfs_attr_lookup(mftbmp_na->type, mftbmp_na->name,
|
||||
mftbmp_na->name_len, 0, rl[1].vcn, NULL, 0, ctx)) {
|
||||
ntfs_error(vol->sb, "Failed to find last attribute extent of "
|
||||
"mft bitmap attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
m = ctx->mrec;
|
||||
a = ctx->attr;
|
||||
ll = sle64_to_cpu(a->lowest_vcn);
|
||||
rl2 = ntfs_attr_find_vcn(mftbmp_na, ll);
|
||||
if (!rl2 || !rl2->length) {
|
||||
ntfs_error(vol->sb, "Failed to determine previous last "
|
||||
"allocated cluster of mft bitmap attribute.");
|
||||
if (!rl2->length)
|
||||
errno = EIO;
|
||||
goto put_err_out;
|
||||
}
|
||||
/* Get the size for the new mapping pairs array for this extent. */
|
||||
mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, ll);
|
||||
if (mp_size <= 0) {
|
||||
ntfs_error(vol->sb, "Get size for mapping pairs failed for "
|
||||
"mft bitmap attribute extent.");
|
||||
goto put_err_out;
|
||||
}
|
||||
/* Expand the attribute record if necessary. */
|
||||
if (ntfs_attr_record_resize(m, a, mp_size +
|
||||
le16_to_cpu(a->mapping_pairs_offset))) {
|
||||
if (errno != ENOSPC) {
|
||||
ntfs_error(vol->sb, "Failed to resize "
|
||||
"attribute record for mft "
|
||||
"bitmap attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
// TODO: Deal with this by moving this extent to a new mft
|
||||
// record or by starting a new extent in a new mft record.
|
||||
ntfs_error(vol->sb, "Not enough space in this mft record to "
|
||||
"accomodate extended mft bitmap attribute "
|
||||
"extent. Cannot handle this yet.");
|
||||
errno = ENOTSUP;
|
||||
goto put_err_out;
|
||||
}
|
||||
/* Generate the mapping pairs array directly into the attr record. */
|
||||
if (ntfs_mapping_pairs_build(vol, (u8*)a +
|
||||
le16_to_cpu(a->mapping_pairs_offset), mp_size, rl2,
|
||||
ll, NULL)) {
|
||||
ntfs_error(vol->sb, "Failed to build mapping pairs. Run "
|
||||
"chkdsk.");
|
||||
errno = EIO;
|
||||
goto put_err_out;
|
||||
}
|
||||
/* Update the highest_vcn. */
|
||||
a->highest_vcn = scpu_to_le64(rl[1].vcn - 1);
|
||||
/*
|
||||
* We now have extended the mft bitmap allocated_size by one cluster.
|
||||
* Reflect this in the ntfs_attr structure and the attribute record.
|
||||
* @rl is the last (non-terminator) runlist element of mft bitmap.
|
||||
*/
|
||||
mftbmp_na->allocated_size += vol->cluster_size;
|
||||
if (a->lowest_vcn) {
|
||||
/*
|
||||
* We are not in the first attribute extent, switch to it, but
|
||||
* first ensure the changes will make it to disk later.
|
||||
*/
|
||||
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||||
ntfs_attr_reinit_search_ctx(ctx);
|
||||
if (ntfs_attr_lookup(mftbmp_na->type, mftbmp_na->name,
|
||||
mftbmp_na->name_len, 0, 0, NULL, 0, ctx)) {
|
||||
ntfs_error(vol->sb, "Failed to find first attribute "
|
||||
"extent of mft bitmap attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
a = ctx->attr;
|
||||
}
|
||||
a->allocated_size = scpu_to_le64(mftbmp_na->allocated_size);
|
||||
/* Ensure the changes make it to disk. */
|
||||
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
return 0;
|
||||
put_err_out:
|
||||
err = errno;
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
errno = err;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static inline unsigned int ntfs_ffz(unsigned int word)
|
||||
{
|
||||
return ffs(~word) - 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* ntfs_mft_record_alloc - allocate an mft record on an ntfs volume
|
||||
* @vol: volume on which to allocate the mft record
|
||||
* @start: starting mft record at which to allocate (or -1 if none)
|
||||
* @base_ni: open base inode if allocating an extent mft record or NULL
|
||||
*
|
||||
* Allocate an mft record in $MFT/$DATA starting to search for a free record
|
||||
* at mft record number @start or at the current allocator position if @start
|
||||
* is -1, on the mounted ntfs volume @vol.
|
||||
* Allocate an mft record in $MFT/$DATA of an open ntfs volume @vol.
|
||||
*
|
||||
* On success return the now opened ntfs inode of the mft record.
|
||||
* If @base_ni is NULL make the mft record a base mft record and allocate it at
|
||||
* the default allocator position.
|
||||
*
|
||||
* If @base_ni is not NULL make the allocated mft record an extent record,
|
||||
* allocate it starting at the mft record after the base mft record and attach
|
||||
* the allocated and opened ntfs inode to the base inode @base_ni.
|
||||
*
|
||||
* On success return the now opened ntfs (extent) inode of the mft record.
|
||||
*
|
||||
* On error return NULL with errno set to the error code.
|
||||
*
|
||||
* To find a free mft record, we scan the mft bitmap for a zero bit. To
|
||||
* optimize this we start scanning at the place specified by @start or if
|
||||
* @start is -1 we start where we last stopped and we perform wrap around when
|
||||
* we reach the end. Note, we do not try to allocate mft records below number
|
||||
* 24 because numbers 0 to 15 are the defined system files anyway and 16 to 24
|
||||
* are special in that they are used for storing extension mft records for the
|
||||
* $DATA attribute of $MFT. This is required to avoid the possibility of
|
||||
* creating a run list with a circular dependence which once written to disk
|
||||
* optimize this we start scanning at the place specified by @base_ni or if
|
||||
* @base_ni is NULL we start where we last stopped and we perform wrap around
|
||||
* when we reach the end. Note, we do not try to allocate mft records below
|
||||
* number 24 because numbers 0 to 15 are the defined system files anyway and 16
|
||||
* to 24 are special in that they are used for storing extension mft records
|
||||
* for the $DATA attribute of $MFT. This is required to avoid the possibility
|
||||
* of creating a run list with a circular dependence which once written to disk
|
||||
* can never be read in again. Windows will only use records 16 to 24 for
|
||||
* normal files if the volume is completely out of space. We never use them
|
||||
* which means that when the volume is really out of space we cannot create any
|
||||
|
|
@ -452,14 +657,625 @@ int ntfs_mft_record_format(const ntfs_volume *vol, const MFT_REF mref)
|
|||
#ifndef PAGE_SIZE
|
||||
#define PAGE_SIZE 4096
|
||||
#endif
|
||||
ntfs_inode *ntfs_mft_record_alloc(ntfs_volume *vol, s64 start)
|
||||
ntfs_inode *ntfs_mft_record_alloc(ntfs_volume *vol, ntfs_inode *base_ni)
|
||||
{
|
||||
ntfs_debug("Entering (start 0x%llx).", (long long)start);
|
||||
if (!vol || !vol->mft_na || !vol->mftbmp_na || start < -1) {
|
||||
s64 nr_allocated_mft_records, pass_end, ll, ll2, buf_pos, pass_start;
|
||||
s64 last_read_pos, bit;
|
||||
LCN lcn;
|
||||
ntfs_attr *mft_na, *mftbmp_na, *lcnbmp_na;
|
||||
u8 *buf, *byte;
|
||||
runlist_element *rl, *rl2;
|
||||
ntfs_attr_search_ctx *ctx;
|
||||
MFT_RECORD *m;
|
||||
ATTR_RECORD *a;
|
||||
ntfs_inode *ni;
|
||||
unsigned long mft_rec_size;
|
||||
unsigned int size, buf_size;
|
||||
int err, mp_size;
|
||||
u16 seq_no;
|
||||
u8 pass, b, have_allocated_mftbmp = 0;
|
||||
|
||||
if (base_ni)
|
||||
ntfs_debug("Entering (allocating an extent mft record for "
|
||||
"base mft record 0x%llx).",
|
||||
(long long)base_ni->mft_no);
|
||||
else
|
||||
ntfs_debug("Entering (allocating a base mft record).");
|
||||
if (!vol || !vol->mft_na || !vol->mftbmp_na) {
|
||||
errno = EINVAL;
|
||||
return NULL;
|
||||
}
|
||||
errno = ENOTSUP;
|
||||
size = PAGE_SIZE;
|
||||
if (size < vol->mft_record_size)
|
||||
size = vol->mft_record_size;
|
||||
buf = (u8*)malloc(size);
|
||||
if (!buf)
|
||||
return NULL;
|
||||
mft_na = vol->mft_na;
|
||||
mftbmp_na = vol->mftbmp_na;
|
||||
lcnbmp_na = vol->lcnbmp_na;
|
||||
/* Determine the number of allocated mft records in the mft. */
|
||||
pass_end = nr_allocated_mft_records = mft_na->allocated_size >>
|
||||
vol->mft_record_size_bits;
|
||||
ntfs_debug("nr_allocated_mft_records 0x%llx.",
|
||||
(long long)nr_allocated_mft_records);
|
||||
/* Make sure we do not overflow the mft bitmap. */
|
||||
ll = mftbmp_na->initialized_size << 3;
|
||||
if (ll < nr_allocated_mft_records) {
|
||||
// FIXME: It might be better to extend the bitmap instead.
|
||||
pass_end = ll;
|
||||
}
|
||||
pass = 1;
|
||||
if (!base_ni)
|
||||
buf_pos = vol->mft_data_pos;
|
||||
else
|
||||
buf_pos = base_ni->mft_no + 1;
|
||||
if (buf_pos >= pass_end) {
|
||||
buf_pos = 24;
|
||||
pass = 2;
|
||||
}
|
||||
pass_start = buf_pos;
|
||||
ntfs_debug("Starting bitmap search: pass %u, pass_start 0x%llx, "
|
||||
"pass_end = 0x%llx.", pass, (long long)pass_start,
|
||||
(long long)pass_end);
|
||||
#ifdef DEBUG
|
||||
byte = NULL;
|
||||
b = 0;
|
||||
#endif
|
||||
/* Loop until a free mft record is found. */
|
||||
size = PAGE_SIZE;
|
||||
if (size > (ll = nr_allocated_mft_records >> 3))
|
||||
size = ll;
|
||||
for (;; size = PAGE_SIZE) {
|
||||
last_read_pos = buf_pos >> 3;
|
||||
ntfs_debug("Before read: mftbmp: allocated_size 0x%llx, "
|
||||
"data_size 0x%llx, initialized_size 0x%llx.",
|
||||
(long long)mftbmp_na->allocated_size,
|
||||
(long long)mftbmp_na->data_size,
|
||||
(long long)mftbmp_na->initialized_size);
|
||||
ll = ntfs_attr_pread(mftbmp_na, last_read_pos, size, buf);
|
||||
if (ll < 0) {
|
||||
ntfs_error(vol->sb, "Failed to read mft bitmap "
|
||||
"attribute.");
|
||||
goto err_out;
|
||||
}
|
||||
ntfs_debug("Read 0x%llx bytes.", (long long)ll);
|
||||
ntfs_debug("After read: mftbmp: allocated_size 0x%llx, "
|
||||
"data_size = 0x%llx, initialized_size 0x%llx.",
|
||||
(long long)mftbmp_na->allocated_size,
|
||||
(long long)mftbmp_na->data_size,
|
||||
(long long)mftbmp_na->initialized_size);
|
||||
if (!ll)
|
||||
goto pass_done;
|
||||
buf_size = ll << 3;
|
||||
bit = buf_pos & 7;
|
||||
buf_pos &= ~7ull;
|
||||
ntfs_debug("Before for loop: buf_size 0x%x, buf_pos 0x%llx, "
|
||||
"bit 0x%llx, *byte 0x%x, b %u.", buf_size,
|
||||
(long long)buf_pos, (long long)bit,
|
||||
byte ? *byte : -1, b);
|
||||
for (; bit < buf_size && buf_pos + bit < pass_end;
|
||||
bit &= ~7ull, bit += 8) {
|
||||
byte = buf + (bit >> 3);
|
||||
if (*byte == 0xff)
|
||||
continue;
|
||||
/* Note: ffz() result must be zero based. */
|
||||
b = ntfs_ffz((unsigned long)*byte);
|
||||
if (b < 8 && b >= (bit & 7)) {
|
||||
bit = buf_pos + (bit & ~7ull) + b;
|
||||
ntfs_debug("Found free rec in for loop, "
|
||||
"bit 0x%llx.", (long long)bit);
|
||||
goto found_free_rec;
|
||||
}
|
||||
}
|
||||
ntfs_debug("After for loop: buf_size 0x%x, buf_pos 0x%llx, "
|
||||
"bit 0x%llx, *byte 0x%x, b %u.", buf_size,
|
||||
(long long)buf_pos, (long long)bit,
|
||||
byte ? *byte : -1, b);
|
||||
buf_pos += buf_size;
|
||||
if (buf_pos < pass_end)
|
||||
continue;
|
||||
pass_done:
|
||||
/* Finished with the current pass. */
|
||||
ntfs_debug("At pass_done.");
|
||||
if (pass == 1) {
|
||||
/*
|
||||
* Now do pass 2, scanning the first part of the zone
|
||||
* we omitted in pass 1.
|
||||
*/
|
||||
ntfs_debug("Done pass 1, switching to pass 2.");
|
||||
pass = 2;
|
||||
pass_end = pass_start;
|
||||
buf_pos = pass_start = 24;
|
||||
ntfs_debug("pass %i, pass_start 0x%llx, "
|
||||
"pass_end 0x%llx.", pass,
|
||||
(long long)pass_start,
|
||||
(long long)pass_end);
|
||||
continue;
|
||||
} /* pass == 2 */
|
||||
/* No free records left. */
|
||||
if (mftbmp_na->initialized_size << 3 >
|
||||
nr_allocated_mft_records &&
|
||||
mftbmp_na->initialized_size > 3) {
|
||||
/*
|
||||
* The mft bitmap is already bigger but the space is
|
||||
* not covered by mft records, this implies that the
|
||||
* next records are all free, so we already have found
|
||||
* a free record.
|
||||
*/
|
||||
bit = nr_allocated_mft_records;
|
||||
if (bit < 24)
|
||||
bit = 24;
|
||||
ntfs_debug("Found free record bit (#1) 0x%llx.",
|
||||
(long long)bit);
|
||||
goto found_free_rec;
|
||||
}
|
||||
ntfs_debug("Done pass 2.");
|
||||
ntfs_debug("Status of mftbmp: allocated_size 0x%llx, "
|
||||
"data_size 0x%llx, initialized_size 0x%llx.",
|
||||
(long long)mftbmp_na->allocated_size,
|
||||
(long long)mftbmp_na->data_size,
|
||||
(long long)mftbmp_na->initialized_size);
|
||||
if (mftbmp_na->initialized_size + 8 >
|
||||
mftbmp_na->allocated_size) {
|
||||
/* Need to extend bitmap by one more cluster. */
|
||||
ntfs_debug("mftbmp: initialized_size + 8 > "
|
||||
"allocated_size.");
|
||||
if (ntfs_mft_bitmap_extend_by_one_cluster(vol,
|
||||
&have_allocated_mftbmp))
|
||||
goto err_out;
|
||||
ntfs_debug("New status of mftbmp: allocated_size "
|
||||
"0x%llx, data_size 0x%llx, "
|
||||
"initialized_size 0x%llx.",
|
||||
(long long)mftbmp_na->allocated_size,
|
||||
(long long)mftbmp_na->data_size,
|
||||
(long long)mftbmp_na->initialized_size);
|
||||
}
|
||||
/*
|
||||
* We now have sufficient allocated space, extend the
|
||||
* initialized_size as well as the data_size if necessary.
|
||||
*/
|
||||
ctx = ntfs_attr_get_search_ctx(mftbmp_na->ni, NULL);
|
||||
if (!ctx) {
|
||||
ntfs_error(vol->sb, "Failed to get search context.");
|
||||
goto err_out;
|
||||
}
|
||||
if (ntfs_attr_lookup(mftbmp_na->type, mftbmp_na->name,
|
||||
mftbmp_na->name_len, 0, 0, NULL, 0, ctx)) {
|
||||
ntfs_error(vol->sb, "Failed to find first attribute "
|
||||
"extent of mft bitmap attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
a = ctx->attr;
|
||||
buf_pos = mftbmp_na->initialized_size;
|
||||
mftbmp_na->initialized_size += 8;
|
||||
a->initialized_size = scpu_to_le64(mftbmp_na->initialized_size);
|
||||
if (mftbmp_na->initialized_size > mftbmp_na->data_size) {
|
||||
mftbmp_na->data_size = mftbmp_na->initialized_size;
|
||||
a->data_size = scpu_to_le64(mftbmp_na->data_size);
|
||||
}
|
||||
/* Ensure the changes make it to disk. */
|
||||
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
ntfs_debug("New status of mftbmp: allocated_size 0x%llx, "
|
||||
"data_size 0x%llx, initialized_size 0x%llx.",
|
||||
(long long)mftbmp_na->allocated_size,
|
||||
(long long)mftbmp_na->data_size,
|
||||
(long long)mftbmp_na->initialized_size);
|
||||
have_allocated_mftbmp |= 4;
|
||||
/* Initialize the mft bitmap attribute value with zeroes. */
|
||||
memset(buf, 0, 8);
|
||||
ll = ntfs_attr_pwrite(mftbmp_na, buf_pos, 8, buf);
|
||||
if (ll < 8) {
|
||||
ntfs_error(vol->sb, "Failed to write to mft bitmap.");
|
||||
if (ll >= 0)
|
||||
errno = EIO;
|
||||
goto shrink_mftbmp_err_out;
|
||||
}
|
||||
ntfs_debug("Wrote eight initialized bytes to mft bitmap.");
|
||||
bit = buf_pos << 3;
|
||||
ntfs_debug("Found free record bit (#2) 0x%llx.",
|
||||
(long long)bit);
|
||||
/* goto found_free_rec; */
|
||||
break;
|
||||
}
|
||||
found_free_rec:
|
||||
/* @bit is the found free mft record, allocate it in the mft bitmap. */
|
||||
vol->mft_data_pos = bit;
|
||||
ntfs_debug("At found_free_rec.");
|
||||
ll = ntfs_attr_pread(mftbmp_na, bit >> 3, 1, buf);
|
||||
if (ll < 1) {
|
||||
ntfs_error(vol->sb, "Failed to read from mft bitmap.");
|
||||
if (!ll)
|
||||
errno = EIO;
|
||||
goto shrink_mftbmp_err_out;
|
||||
}
|
||||
ntfs_debug("Read 1 byte from mft bitmap.");
|
||||
/* Check our bit is really zero and set it. */
|
||||
b = 1 << (bit & 7);
|
||||
//BUG_ON(*buf & b);
|
||||
if (*buf & b)
|
||||
NTFS_BUG("Bit in mft bitmap is not zero!");
|
||||
*buf |= b;
|
||||
ll = ntfs_attr_pwrite(mftbmp_na, bit >> 3, 1, buf);
|
||||
if (ll < 1) {
|
||||
if (!ll)
|
||||
errno = EIO;
|
||||
goto shrink_mftbmp_err_out;
|
||||
}
|
||||
ntfs_debug("Wrote 1 byte to mft bitmap.");
|
||||
/* The mft bitmap is now uptodate. Deal with mft data attribute now. */
|
||||
ll = (bit + 1) << vol->mft_record_size_bits;
|
||||
if (ll <= mft_na->initialized_size) {
|
||||
/* The allocated record is already initialized. We are done! */
|
||||
ntfs_debug("Allocated mft record already initialized!");
|
||||
goto mft_rec_already_initialized;
|
||||
}
|
||||
ntfs_debug("Allocated mft record needs to be initialized.");
|
||||
/* The mft record is outside the initialized data. */
|
||||
mft_rec_size = vol->mft_record_size;
|
||||
/* Preserve old values for undo purposes. */
|
||||
//FIXME:
|
||||
// s64 old_data_allocated;
|
||||
// LCN old_data_len;
|
||||
// int old_data_rlen;
|
||||
// old_data_allocated = mft_na->allocated_size;
|
||||
// old_data_rlen = mft_na->d.r.len - 1;
|
||||
// old_data_len = mft_na->d.r.runlist[old_data_rlen].len;
|
||||
/*
|
||||
* If necessary, extend the mft until it covers the allocated record.
|
||||
* The loop is only actually used when a freshly formatted volume is
|
||||
* first written to so it optimizes away nicely in the common case.
|
||||
*/
|
||||
while (ll > mft_na->allocated_size) {
|
||||
s64 nr, min_nr;
|
||||
|
||||
ntfs_debug("Extending mft data allocation, status of mft "
|
||||
"data: allocated_size 0x%llx, "
|
||||
"data_size 0x%llx, initialized_size 0x%llx.",
|
||||
(long long)mft_na->allocated_size,
|
||||
(long long)mft_na->data_size,
|
||||
(long long)mft_na->initialized_size);
|
||||
/*
|
||||
* Determine the preferred allocation location, i.e. the last
|
||||
* lcn of the mft data attribute. The allocated size of the
|
||||
* mft data attribute cannot be zero so we are ok to do this.
|
||||
*/
|
||||
rl = ntfs_attr_find_vcn(mft_na, (mft_na->allocated_size - 1) >>
|
||||
vol->cluster_size);
|
||||
if (!rl || !rl->length || rl->lcn < 0) {
|
||||
ntfs_error(vol->sb, "Failed to determine last "
|
||||
"allocated cluster of mft data "
|
||||
"attribute.");
|
||||
if (!rl->length || rl->lcn < 0)
|
||||
errno = EIO;
|
||||
goto undo_mftbmp_alloc_err_out;
|
||||
}
|
||||
lcn = rl->lcn + rl->length;
|
||||
ntfs_debug("Last lcn of mft data attribute is 0x%llx.",
|
||||
(long long)lcn);
|
||||
/* Minimum allocation is one mft record worth of clusters. */
|
||||
if (mft_rec_size <= vol->cluster_size)
|
||||
min_nr = 1;
|
||||
else
|
||||
min_nr = mft_rec_size >> vol->cluster_size_bits;
|
||||
/* Want to allocate 16 mft records worth of clusters. */
|
||||
nr = mft_rec_size << 4 >> vol->cluster_size_bits;
|
||||
if (!nr)
|
||||
nr = 1;
|
||||
ntfs_debug("Trying mft data allocation with default "
|
||||
"cluster count %lli.", (long long)nr);
|
||||
retry_mft_data_allocation:
|
||||
rl2 = ntfs_cluster_alloc(vol, nr, lcn, MFT_ZONE, rl[1].vcn);
|
||||
if (!rl2) {
|
||||
/*
|
||||
* There is not enough space to do the allocation, but
|
||||
* there might be enough space to do a minimal
|
||||
* allocation so try that before failing.
|
||||
*/
|
||||
if (errno == ENOSPC && nr > min_nr) {
|
||||
nr = min_nr;
|
||||
ntfs_debug("Retrying mft data allocation with "
|
||||
"minimal cluster count %lli.",
|
||||
(long long)nr);
|
||||
goto retry_mft_data_allocation;
|
||||
}
|
||||
ntfs_error(vol->sb, "Failed to allocate a cluster for "
|
||||
"the mft data attribute.");
|
||||
goto undo_mftbmp_alloc_err_out;
|
||||
}
|
||||
rl = ntfs_runlists_merge(mft_na->rl, rl2);
|
||||
if (!rl) {
|
||||
err = errno;
|
||||
ntfs_error(vol->sb, "Failed to merge runlists for mft "
|
||||
"data attribute.");
|
||||
if (ntfs_cluster_free_from_rl(vol, rl2))
|
||||
ntfs_error(vol->sb, "Failed to dealocate "
|
||||
"clusters. Run chkdsk.");
|
||||
free(rl2);
|
||||
errno = err;
|
||||
goto undo_mftbmp_alloc_err_out;
|
||||
}
|
||||
mft_na->rl = rl;
|
||||
ntfs_debug("Allocated %lli clusters starting.", nr);
|
||||
/* Determine the last lcn of the mft data attribute. */
|
||||
rl = ntfs_attr_find_vcn(mft_na, (mft_na->allocated_size - 1) >>
|
||||
vol->cluster_size);
|
||||
if (!rl || !rl->length || rl->lcn < 0) {
|
||||
ntfs_error(vol->sb, "Failed to determine last "
|
||||
"allocated cluster of mft data "
|
||||
"attribute.");
|
||||
if (!rl->length || rl->lcn < 0)
|
||||
errno = EIO;
|
||||
// FIXME: Truncate mft_na->rl back to the old state and
|
||||
// release the clusters.
|
||||
goto undo_mftbmp_alloc_err_out;
|
||||
}
|
||||
lcn = rl->lcn + rl->length;
|
||||
/* Update the attribute record as well. */
|
||||
ctx = ntfs_attr_get_search_ctx(mft_na->ni, NULL);
|
||||
if (!ctx) {
|
||||
ntfs_error(vol->sb, "Failed to get search context.");
|
||||
goto trunc_mft_rl_shrink_mftbmp_alloc_err_out;
|
||||
}
|
||||
if (ntfs_attr_lookup(mft_na->type, mft_na->name,
|
||||
mft_na->name_len, 0, rl[1].vcn, NULL, 0, ctx)) {
|
||||
ntfs_error(vol->sb, "Failed to find last attribute "
|
||||
"extent of mft data attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
m = ctx->mrec;
|
||||
a = ctx->attr;
|
||||
ll2 = sle64_to_cpu(a->lowest_vcn);
|
||||
rl2 = ntfs_attr_find_vcn(mft_na, ll2);
|
||||
if (!rl2 || !rl2->length) {
|
||||
ntfs_error(vol->sb, "Failed to determine previous "
|
||||
"last allocated cluster of mft data "
|
||||
"attribute.");
|
||||
if (!rl2->length)
|
||||
errno = EIO;
|
||||
goto put_err_out;
|
||||
}
|
||||
/*
|
||||
* Get the size for the new mapping pairs array for this
|
||||
* extent.
|
||||
*/
|
||||
mp_size = ntfs_get_size_for_mapping_pairs(vol, rl2, ll2);
|
||||
if (mp_size <= 0) {
|
||||
ntfs_error(vol->sb, "Get size for mapping pairs "
|
||||
"failed for mft bitmap attribute "
|
||||
"extent.");
|
||||
goto put_err_out;
|
||||
}
|
||||
/* Expand the attribute record if necessary. */
|
||||
if (ntfs_attr_record_resize(m, a, mp_size +
|
||||
le16_to_cpu(a->mapping_pairs_offset))) {
|
||||
if (errno != ENOSPC) {
|
||||
ntfs_error(vol->sb, "Failed to resize "
|
||||
"attribute record for mft "
|
||||
"data attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
// TODO: Deal with this by moving this extent to a new
|
||||
// mft record or by starting a new extent in a new mft
|
||||
// record. Note: Use the special reserved mft records
|
||||
// and ensure that this extent is not required to find
|
||||
// the mft record in question.
|
||||
ntfs_error(vol->sb, "Not enough space in this mft "
|
||||
"record to accomodate extended mft "
|
||||
"data attribute extent. Cannot "
|
||||
"handle this yet.");
|
||||
errno = ENOTSUP;
|
||||
goto put_err_out;
|
||||
}
|
||||
/*
|
||||
* Generate the mapping pairs array directly into the attribute
|
||||
* record.
|
||||
*/
|
||||
if (ntfs_mapping_pairs_build(vol, (u8*)a +
|
||||
le16_to_cpu(a->mapping_pairs_offset), mp_size,
|
||||
rl2, ll2, NULL)) {
|
||||
ntfs_error(vol->sb, "Failed to build mapping pairs. "
|
||||
"Run chkdsk.");
|
||||
errno = EIO;
|
||||
goto put_err_out;
|
||||
}
|
||||
/* Update the highest_vcn. */
|
||||
a->highest_vcn = scpu_to_le64(rl[1].vcn - 1);
|
||||
/*
|
||||
* We now have extended the mft data allocated_size by nr
|
||||
* clusters. Reflect this in the ntfs_attr structure and the
|
||||
* attribute record. @rl is the last (non-terminator) runlist
|
||||
* element of mft data attribute.
|
||||
*/
|
||||
mft_na->allocated_size += nr << vol->cluster_size_bits;
|
||||
if (a->lowest_vcn) {
|
||||
/*
|
||||
* We are not in the first attribute extent, switch to
|
||||
* it, but first ensure the changes will make it to
|
||||
* disk later.
|
||||
*/
|
||||
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||||
ntfs_attr_reinit_search_ctx(ctx);
|
||||
if (ntfs_attr_lookup(mft_na->type, mft_na->name,
|
||||
mft_na->name_len, 0, 0, NULL, 0, ctx)) {
|
||||
ntfs_error(vol->sb, "Failed to find first "
|
||||
"attribute extent of mft data "
|
||||
"attribute.");
|
||||
goto put_err_out;
|
||||
}
|
||||
a = ctx->attr;
|
||||
}
|
||||
a->allocated_size = scpu_to_le64(mft_na->allocated_size);
|
||||
/* Ensure the changes make it to disk. */
|
||||
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
ntfs_debug("After extending mft data allocation, status of "
|
||||
"mft data: allocated_size 0x%llx, "
|
||||
"data_size 0x%llx, initialized_size 0x%llx.",
|
||||
(long long)mft_na->allocated_size,
|
||||
(long long)mft_na->data_size,
|
||||
(long long)mft_na->initialized_size);
|
||||
}
|
||||
// s64 old_data_initialized, old_data_size;
|
||||
// old_data_initialized = mft_na->initialized_size;
|
||||
// old_data_size = mft_na->data_size;
|
||||
/*
|
||||
* Extend mft data initialized size (and data size of course) to reach
|
||||
* the allocated mft record formatting the mft records allong the way.
|
||||
*/
|
||||
while (ll > mft_na->initialized_size) {
|
||||
ll2 = mft_na->initialized_size >> vol->mft_record_size_bits;
|
||||
mft_na->initialized_size += vol->mft_record_size;
|
||||
if (mft_na->initialized_size > mft_na->data_size)
|
||||
mft_na->data_size = mft_na->initialized_size;
|
||||
ntfs_debug("Initializing mft record 0x%llx.", ll2);
|
||||
err = ntfs_mft_record_format(vol, ll2);
|
||||
if (err) {
|
||||
ntfs_error(vol->sb, "Failed to format mft record.");
|
||||
goto undo_data_init_err_out;
|
||||
}
|
||||
}
|
||||
/* Update the mft data attribute record to reflect the new sizes. */
|
||||
ctx = ntfs_attr_get_search_ctx(mft_na->ni, NULL);
|
||||
if (!ctx) {
|
||||
ntfs_error(vol->sb, "Failed to get search context.");
|
||||
goto undo_data_init_err_out;
|
||||
}
|
||||
if (ntfs_attr_lookup(mft_na->type, mft_na->name, mft_na->name_len, 0,
|
||||
0, NULL, 0, ctx)) {
|
||||
ntfs_error(vol->sb, "Failed to find first attribute extent of "
|
||||
"mft data attribute.");
|
||||
goto put_undo_data_init_err_out;
|
||||
}
|
||||
a = ctx->attr;
|
||||
a->initialized_size = scpu_to_le64(mft_na->initialized_size);
|
||||
a->data_size = scpu_to_le64(mft_na->data_size);
|
||||
/* Ensure the changes make it to disk. */
|
||||
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
ntfs_debug("After mft record initialization, status of mft data: "
|
||||
"allocated_size 0x%llx, data_size 0x%llx, "
|
||||
"initialized_size 0x%llx.",
|
||||
(long long)mft_na->allocated_size,
|
||||
(long long)mft_na->data_size,
|
||||
(long long)mft_na->initialized_size);
|
||||
/* Sanity checks. */
|
||||
if (mft_na->data_size > mft_na->allocated_size ||
|
||||
mft_na->initialized_size > mft_na->data_size)
|
||||
NTFS_BUG("mft_na sanity checks failed");
|
||||
// BUG_ON(mft_na->initialized_size > mft_na->data_size);
|
||||
// BUG_ON(mft_na->data_size > mft_na->allocated_size);
|
||||
mft_rec_already_initialized:
|
||||
/*
|
||||
* We now have allocated and initialized the mft record. Need to read
|
||||
* it from disk and re-format it.
|
||||
*/
|
||||
m = (MFT_RECORD*)malloc(vol->mft_record_size);
|
||||
if (!m) {
|
||||
ntfs_error(vol->sb, "Failed to allocate buffer for mft "
|
||||
"record.");
|
||||
goto undo_mrec_alloc_init_err_out;
|
||||
}
|
||||
if (ntfs_mft_record_read(vol, bit, m)) {
|
||||
ntfs_error(vol->sb, "Failed to read mft record.");
|
||||
goto undo_mrec_alloc_init_err_out;
|
||||
}
|
||||
/* Preserve the sequence number if it is not zero. */
|
||||
seq_no = m->sequence_number;
|
||||
if (ntfs_mft_record_layout(vol, bit, m)) {
|
||||
ntfs_error(vol->sb, "Failed to re-format mft record.");
|
||||
goto undo_mrec_alloc_init_err_out;
|
||||
}
|
||||
if (le16_to_cpu(seq_no))
|
||||
m->sequence_number = seq_no;
|
||||
/* Set the mft record itself in use. */
|
||||
m->flags |= MFT_RECORD_IN_USE;
|
||||
/* Now need to open an ntfs inode for the mft record. */
|
||||
ni = ntfs_inode_allocate(vol);
|
||||
if (!ni) {
|
||||
ntfs_error(vol->sb, "Failed to allocate buffer for inode.");
|
||||
goto undo_mrec_alloc_init_err_out;
|
||||
}
|
||||
ni->mft_no = bit;
|
||||
ni->mrec = m;
|
||||
/*
|
||||
* If we are allocating an extent mft record, make the opened inode an
|
||||
* extent inode and attach it to the base inode.
|
||||
*/
|
||||
if (base_ni) {
|
||||
ni->nr_extents = -1;
|
||||
ni->base_ni = base_ni;
|
||||
/*
|
||||
* Attach extent inode to base inode, reallocating memory if
|
||||
* needed.
|
||||
*/
|
||||
if (!(base_ni->nr_extents & 3)) {
|
||||
ntfs_inode **extent_nis;
|
||||
int i;
|
||||
|
||||
i = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
|
||||
extent_nis = (ntfs_inode**)malloc(i);
|
||||
if (!extent_nis)
|
||||
goto release_mrec_alloc_init_err_out;
|
||||
if (base_ni->extent_nis) {
|
||||
memcpy(extent_nis, base_ni->extent_nis,
|
||||
i - 4 * sizeof(ntfs_inode *));
|
||||
free(base_ni->extent_nis);
|
||||
}
|
||||
base_ni->extent_nis = extent_nis;
|
||||
}
|
||||
base_ni->extent_nis[base_ni->nr_extents++] = ni;
|
||||
}
|
||||
/* Make sure the allocated inode is written out to disk. */
|
||||
ntfs_inode_mark_dirty(ni);
|
||||
/* Update the default mft allocation position if it was used. */
|
||||
if (!base_ni)
|
||||
vol->mft_data_pos = bit + 1;
|
||||
/* Return the opened, allocated inode of the allocated mft record. */
|
||||
ntfs_debug("Returning opened, allocated %sinode 0x%llx.",
|
||||
base_ni ? "extent " : "", (long long)bit);
|
||||
free(buf);
|
||||
return ni;
|
||||
|
||||
release_mrec_alloc_init_err_out:
|
||||
err = errno;
|
||||
free(ni);
|
||||
errno = err;
|
||||
|
||||
undo_mrec_alloc_init_err_out:
|
||||
err = errno;
|
||||
free(m);
|
||||
errno = err;
|
||||
goto undo_data_init_err_out;
|
||||
|
||||
put_undo_data_init_err_out:
|
||||
err = errno;
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
errno = err;
|
||||
|
||||
undo_data_init_err_out:
|
||||
goto trunc_mft_rl_shrink_mftbmp_alloc_err_out;
|
||||
|
||||
put_err_out:
|
||||
err = errno;
|
||||
ntfs_attr_put_search_ctx(ctx);
|
||||
errno = err;
|
||||
|
||||
|
||||
trunc_mft_rl_shrink_mftbmp_alloc_err_out:
|
||||
|
||||
undo_mftbmp_alloc_err_out:
|
||||
|
||||
shrink_mftbmp_err_out:
|
||||
|
||||
err_out:
|
||||
err = errno;
|
||||
free(buf);
|
||||
if (err)
|
||||
errno = err;
|
||||
else
|
||||
errno = EIO;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue