Viewing file:  inode.c (71.88 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* inode.c
*
* Copyright (C) 1995-1999 Martin von Löwis
* Copyright (C) 1996 Albert D. Cahalan
* Copyright (C) 1996-1997 Régis Duchesne
* Copyright (C) 1998 Joseph Malicki
* Copyright (C) 1999 Steve Dodd
* Copyright (C) 2000-2001 Anton Altaparmakov (AIA)
*/
#include "ntfstypes.h"
#include "ntfsendian.h"
#include "struct.h"
#include "inode.h"
#include <linux/errno.h>
#include "macros.h"
#include "attr.h"
#include "super.h"
#include "dir.h"
#include "support.h"
#include "util.h"
#include <linux/ntfs_fs.h>
#include <linux/smp_lock.h>
typedef struct {
int recno;
unsigned char *record;
} ntfs_mft_record;
typedef struct {
int size;
int count;
ntfs_mft_record *records;
} ntfs_disk_inode;
static void ntfs_fill_mft_header(ntfs_u8 *mft, int rec_size, int seq_no,
int links, int flags)
{
int fixup_ofs = 0x2a;
int fixup_cnt = rec_size / NTFS_SECTOR_SIZE + 1;
int attr_ofs = (fixup_ofs + 2 * fixup_cnt + 7) & ~7;
NTFS_PUTU32(mft + 0x00, 0x454c4946); /* FILE */
NTFS_PUTU16(mft + 0x04, fixup_ofs); /* Offset to fixup. */
NTFS_PUTU16(mft + 0x06, fixup_cnt); /* Number of fixups. */
NTFS_PUTU64(mft + 0x08, 0); /* Logical sequence number. */
NTFS_PUTU16(mft + 0x10, seq_no); /* Sequence number. */
NTFS_PUTU16(mft + 0x12, links); /* Hard link count. */
NTFS_PUTU16(mft + 0x14, attr_ofs); /* Offset to attributes. */
NTFS_PUTU16(mft + 0x16, flags); /* Flags: 1 = In use,
2 = Directory. */
NTFS_PUTU32(mft + 0x18, attr_ofs + 8); /* Bytes in use. */
NTFS_PUTU32(mft + 0x1c, rec_size); /* Total allocated size. */
NTFS_PUTU64(mft + 0x20, 0); /* Base mft record. */
NTFS_PUTU16(mft + 0x28, 0); /* Next attr instance. */
NTFS_PUTU16(mft + fixup_ofs, 1); /* Fixup word. */
NTFS_PUTU32(mft + attr_ofs, (__u32)-1); /* End of attributes marker. */
}
/*
* Search in an inode an attribute by type and name.
* FIXME: Check that when attributes are inserted all attribute list
* attributes are expanded otherwise need to modify this function to deal
* with attribute lists. (AIA)
*/
ntfs_attribute *ntfs_find_attr(ntfs_inode *ino, int type, char *name)
{
int i;
if (!ino) {
ntfs_error("ntfs_find_attr: NO INODE!\n");
return 0;
}
for (i = 0; i < ino->attr_count; i++) {
if (type < ino->attrs[i].type)
return 0;
if (type == ino->attrs[i].type) {
if (!name) {
if (!ino->attrs[i].name)
return ino->attrs + i;
} else if (ino->attrs[i].name &&
!ntfs_ua_strncmp(ino->attrs[i].name, name,
strlen(name)))
return ino->attrs + i;
}
}
return 0;
}
/*
* Insert all attributes from the record mftno of the MFT in the inode ino.
* If mftno is a base mft record we abort as soon as we find the attribute
* list, but only on the first pass. We will get called later when the attribute
* list attribute is being parsed so we need to distinguish the two cases.
* FIXME: We should be performing structural consistency checks. (AIA)
* Return 0 on success or -errno on error.
*/
static int ntfs_insert_mft_attributes(ntfs_inode* ino, char *mft, int mftno)
{
int i, error, type, len, present = 0;
char *it;
/* Check for duplicate extension record. */
for(i = 0; i < ino->record_count; i++)
if (ino->records[i] == mftno) {
if (i)
return 0;
present = 1;
break;
}
if (!present) {
/* (re-)allocate space if necessary. */
if (ino->record_count % 8 == 0) {
int *new;
new = ntfs_malloc((ino->record_count + 8) *
sizeof(int));
if (!new)
return -ENOMEM;
if (ino->records) {
for (i = 0; i < ino->record_count; i++)
new[i] = ino->records[i];
ntfs_free(ino->records);
}
ino->records = new;
}
ino->records[ino->record_count] = mftno;
ino->record_count++;
}
it = mft + NTFS_GETU16(mft + 0x14); /* mft->attrs_offset */
do {
type = NTFS_GETU32(it);
len = NTFS_GETU32(it + 4);
if (type != -1) {
error = ntfs_insert_attribute(ino, it);
if (error)
return error;
}
/* If we have just processed the attribute list and this is
* the first time we are parsing this (base) mft record then we
* are done so that the attribute list gets parsed before the
* entries in the base mft record. Otherwise we run into
* problems with encountering attributes out of order and when
* this happens with different attribute extents we die. )-:
* This way we are ok as the attribute list is always sorted
* fully and correctly. (-: */
if (type == 0x20 && !present)
return 0;
it += len;
} while (type != -1); /* Attribute listing ends with type -1. */
return 0;
}
/*
* Insert a single specific attribute from the record mftno of the MFT in the
* inode ino. We disregard the attribute list assuming we have already parsed
* it.
* FIXME: We should be performing structural consistency checks. (AIA)
* Return 0 on success or -errno on error.
*/
static int ntfs_insert_mft_attribute(ntfs_inode* ino, int mftno,
ntfs_u8 *attr)
{
int i, error, present = 0;
/* Check for duplicate extension record. */
for(i = 0; i < ino->record_count; i++)
if (ino->records[i] == mftno) {
present = 1;
break;
}
if (!present) {
/* (re-)allocate space if necessary. */
if (ino->record_count % 8 == 0) {
int *new;
new = ntfs_malloc((ino->record_count + 8) *
sizeof(int));
if (!new)
return -ENOMEM;
if (ino->records) {
for (i = 0; i < ino->record_count; i++)
new[i] = ino->records[i];
ntfs_free(ino->records);
}
ino->records = new;
}
ino->records[ino->record_count] = mftno;
ino->record_count++;
}
if (NTFS_GETU32(attr) == -1) {
ntfs_debug(DEBUG_FILE3, "ntfs_insert_mft_attribute: attribute "
"type is -1.\n");
return 0;
}
error = ntfs_insert_attribute(ino, attr);
if (error)
return error;
return 0;
}
/* Read and insert all the attributes of an 'attribute list' attribute.
* Return the number of remaining bytes in *plen. */
static int parse_attributes(ntfs_inode *ino, ntfs_u8 *alist, int *plen)
{
ntfs_u8 *mft, *attr;
int mftno, l, error;
int last_mft = -1;
int len = *plen;
int tries = 0;
if (!ino->attr) {
ntfs_error("parse_attributes: called on inode 0x%x without a "
"loaded base mft record.\n", ino->i_number);
return -EINVAL;
}
mft = ntfs_malloc(ino->vol->mft_record_size);
if (!mft)
return -ENOMEM;
while (len > 8) {
l = NTFS_GETU16(alist + 4);
if (l > len)
break;
/* Process an attribute description. */
mftno = NTFS_GETU32(alist + 0x10);
/* FIXME: The mft reference (alist + 0x10) is __s64.
* - Not a problem unless we encounter a huge partition.
* - Should be consistency checking the sequence numbers
* though! This should maybe happen in
* ntfs_read_mft_record() itself and a hotfix could
* then occur there or the user notified to run
* ntfsck. (AIA) */
if (mftno != ino->i_number && mftno != last_mft) {
continue_after_loading_mft_data:
last_mft = mftno;
error = ntfs_read_mft_record(ino->vol, mftno, mft);
if (error) {
if (error == -EINVAL && !tries)
goto force_load_mft_data;
failed_reading_mft_data:
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
"ntfs_read_mft_record(mftno = 0x%x) "
"failed\n", mftno);
ntfs_free(mft);
return error;
}
}
attr = ntfs_find_attr_in_mft_rec(
ino->vol, /* ntfs volume */
mftno == ino->i_number ?/* mft record is: */
ino->attr: /* base record */
mft, /* extension record */
NTFS_GETU32(alist + 0), /* type */
(wchar_t*)(alist + alist[7]), /* name */
alist[6], /* name length */
1, /* ignore case */
NTFS_GETU16(alist + 24) /* instance number */
);
if (!attr) {
ntfs_error("parse_attributes: mft records 0x%x and/or "
"0x%x corrupt!\n", ino->i_number, mftno);
ntfs_free(mft);
return -EINVAL; /* FIXME: Better error code? (AIA) */
}
error = ntfs_insert_mft_attribute(ino, mftno, attr);
if (error) {
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
"ntfs_insert_mft_attribute(mftno 0x%x, "
"attribute type 0x%x) failed\n", mftno,
NTFS_GETU32(alist + 0));
ntfs_free(mft);
return error;
}
len -= l;
alist += l;
}
ntfs_free(mft);
*plen = len;
return 0;
force_load_mft_data:
{
ntfs_u8 *mft2, *attr2;
int mftno2;
int last_mft2 = last_mft;
int len2 = len;
int error2;
int found2 = 0;
ntfs_u8 *alist2 = alist;
/*
* We only get here if $DATA wasn't found in $MFT which only happens
* on volume mount when $MFT has an attribute list and there are
* attributes before $DATA which are inside extent mft records. So
* we just skip forward to the $DATA attribute and read that. Then we
* restart which is safe as an attribute will not be inserted twice.
*
* This still will not fix the case where the attribute list is non-
* resident, larger than 1024 bytes, and the $DATA attribute list entry
* is not in the first 1024 bytes. FIXME: This should be implemented
* somehow! Perhaps by passing special error code up to
* ntfs_load_attributes() so it keeps going trying to get to $DATA
* regardless. Then it would have to restart just like we do here.
*/
mft2 = ntfs_malloc(ino->vol->mft_record_size);
if (!mft2) {
ntfs_free(mft);
return -ENOMEM;
}
ntfs_memcpy(mft2, mft, ino->vol->mft_record_size);
while (len2 > 8) {
l = NTFS_GETU16(alist2 + 4);
if (l > len2)
break;
if (NTFS_GETU32(alist2 + 0x0) < ino->vol->at_data) {
len2 -= l;
alist2 += l;
continue;
}
if (NTFS_GETU32(alist2 + 0x0) > ino->vol->at_data) {
if (found2)
break;
/* Uh-oh! It really isn't there! */
ntfs_error("Either the $MFT is corrupt or, equally "
"likely, the $MFT is too complex for "
"the current driver to handle. Please "
"email the ntfs maintainer that you "
"saw this message. Thank you.\n");
goto failed_reading_mft_data;
}
/* Process attribute description. */
mftno2 = NTFS_GETU32(alist2 + 0x10);
if (mftno2 != ino->i_number && mftno2 != last_mft2) {
last_mft2 = mftno2;
error2 = ntfs_read_mft_record(ino->vol, mftno2, mft2);
if (error2) {
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
"ntfs_read_mft_record(mftno2 = 0x%x) "
"failed\n", mftno2);
ntfs_free(mft2);
goto failed_reading_mft_data;
}
}
attr2 = ntfs_find_attr_in_mft_rec(
ino->vol, /* ntfs volume */
mftno2 == ino->i_number ?/* mft record is: */
ino->attr: /* base record */
mft2, /* extension record */
NTFS_GETU32(alist2 + 0), /* type */
(wchar_t*)(alist2 + alist2[7]), /* name */
alist2[6], /* name length */
1, /* ignore case */
NTFS_GETU16(alist2 + 24) /* instance number */
);
if (!attr2) {
ntfs_error("parse_attributes: mft records 0x%x and/or "
"0x%x corrupt!\n", ino->i_number,
mftno2);
ntfs_free(mft2);
goto failed_reading_mft_data;
}
error2 = ntfs_insert_mft_attribute(ino, mftno2, attr2);
if (error2) {
ntfs_debug(DEBUG_FILE3, "parse_attributes: "
"ntfs_insert_mft_attribute(mftno2 0x%x, "
"attribute2 type 0x%x) failed\n", mftno2,
NTFS_GETU32(alist2 + 0));
ntfs_free(mft2);
goto failed_reading_mft_data;
}
len2 -= l;
alist2 += l;
found2 = 1;
}
ntfs_free(mft2);
tries = 1;
goto continue_after_loading_mft_data;
}
}
static void ntfs_load_attributes(ntfs_inode *ino)
{
ntfs_attribute *alist;
int datasize;
int offset, len, delta;
char *buf;
ntfs_volume *vol = ino->vol;
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 1\n", ino->i_number);
if (ntfs_insert_mft_attributes(ino, ino->attr, ino->i_number))
return;
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 2\n", ino->i_number);
alist = ntfs_find_attr(ino, vol->at_attribute_list, 0);
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 3\n", ino->i_number);
if (!alist)
return;
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 4\n", ino->i_number);
datasize = alist->size;
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: alist->size = 0x%x\n",
ino->i_number, alist->size);
if (alist->resident) {
parse_attributes(ino, alist->d.data, &datasize);
return;
}
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 5\n", ino->i_number);
buf = ntfs_malloc(1024);
if (!buf) /* FIXME: Should be passing error code to caller. (AIA) */
return;
delta = 0;
for (offset = 0; datasize; datasize -= len, offset += len) {
ntfs_io io;
io.fn_put = ntfs_put;
io.fn_get = 0;
io.param = buf + delta;
len = 1024 - delta;
if (len > datasize)
len = datasize;
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: len = %i\n",
ino->i_number, len);
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: delta = %i\n",
ino->i_number, delta);
io.size = len;
if (ntfs_read_attr(ino, vol->at_attribute_list, 0, offset,
&io))
ntfs_error("error in load_attributes\n");
delta += len;
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: after += len, "
"delta = %i\n", ino->i_number, delta);
parse_attributes(ino, buf, &delta);
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x: after "
"parse_attr, delta = %i\n", ino->i_number,
delta);
if (delta)
/* Move remaining bytes to buffer start. */
ntfs_memmove(buf, buf + len - delta, delta);
}
ntfs_debug(DEBUG_FILE2, "load_attributes 0x%x 6\n", ino->i_number);
ntfs_free(buf);
}
int ntfs_init_inode(ntfs_inode *ino, ntfs_volume *vol, int inum)
{
char *buf;
int error;
ntfs_debug(DEBUG_FILE1, "Initializing inode 0x%x\n", inum);
ino->i_number = inum;
ino->vol = vol;
ino->attr = buf = ntfs_malloc(vol->mft_record_size);
if (!buf)
return -ENOMEM;
error = ntfs_read_mft_record(vol, inum, ino->attr);
if (error) {
ntfs_debug(DEBUG_OTHER, "Init inode: 0x%x failed\n", inum);
return error;
}
ntfs_debug(DEBUG_FILE2, "Init inode: got mft 0x%x\n", inum);
ino->sequence_number = NTFS_GETU16(buf + 0x10);
ino->attr_count = 0;
ino->record_count = 0;
ino->records = 0;
ino->attrs = 0;
ntfs_load_attributes(ino);
ntfs_debug(DEBUG_FILE2, "Init inode: done 0x%x\n", inum);
return 0;
}
void ntfs_clear_inode(ntfs_inode *ino)
{
int i;
if (!ino->attr) {
ntfs_error("ntfs_clear_inode: double free\n");
return;
}
ntfs_free(ino->attr);
ino->attr = 0;
ntfs_free(ino->records);
ino->records = 0;
for (i = 0; i < ino->attr_count; i++) {
if (ino->attrs[i].name)
ntfs_free(ino->attrs[i].name);
if (ino->attrs[i].resident) {
if (ino->attrs[i].d.data)
ntfs_free(ino->attrs[i].d.data);
} else {
if (ino->attrs[i].d.r.runlist)
ntfs_vfree(ino->attrs[i].d.r.runlist);
}
}
ntfs_free(ino->attrs);
ino->attrs = 0;
}
/* Check and fixup a MFT record. */
int ntfs_check_mft_record(ntfs_volume *vol, char *record)
{
return ntfs_fixup_record(record, "FILE", vol->mft_record_size);
}
/* Return (in result) the value indicating the next available attribute
* chunk number. Works for inodes w/o extension records only. */
int ntfs_allocate_attr_number(ntfs_inode *ino, int *result)
{
if (ino->record_count != 1)
return -EOPNOTSUPP;
*result = NTFS_GETU16(ino->attr + 0x28);
NTFS_PUTU16(ino->attr + 0x28, (*result) + 1);
return 0;
}
/* Find the location of an attribute in the inode. A name of NULL indicates
* unnamed attributes. Return pointer to attribute or NULL if not found. */
char *ntfs_get_attr(ntfs_inode *ino, int attr, char *name)
{
/* Location of first attribute. */
char *it = ino->attr + NTFS_GETU16(ino->attr + 0x14);
int type;
int len;
/* Only check for magic DWORD here, fixup should have happened before.*/
if (!IS_MFT_RECORD(ino->attr))
return 0;
do {
type = NTFS_GETU32(it);
len = NTFS_GETU16(it + 4);
/* We found the attribute type. Is the name correct, too? */
if (type == attr) {
int namelen = NTFS_GETU8(it + 9);
char *name_it, *n = name;
/* Match given name and attribute name if present.
Make sure attribute name is Unicode. */
if (!name) {
goto check_namelen;
} else if (namelen) {
for (name_it = it + NTFS_GETU16(it + 10);
namelen; n++, name_it += 2, namelen--)
if (*name_it != *n || name_it[1])
break;
check_namelen:
if (!namelen)
break;
}
}
it += len;
} while (type != -1); /* List of attributes ends with type -1. */
if (type == -1)
return 0;
return it;
}
__s64 ntfs_get_attr_size(ntfs_inode *ino, int type, char *name)
{
ntfs_attribute *attr = ntfs_find_attr(ino, type, name);
if (!attr)
return 0;
return
attr->size;
}
int ntfs_attr_is_resident(ntfs_inode *ino, int type, char *name)
{
ntfs_attribute *attr = ntfs_find_attr(ino, type, name);
if (!attr)
return 0;
return attr->resident;
}
/*
* A run is coded as a type indicator, an unsigned length, and a signed cluster
* offset.
* . To save space, length and offset are fields of variable length. The low
* nibble of the type indicates the width of the length :), the high nibble
* the width of the offset.
* . The first offset is relative to cluster 0, later offsets are relative to
* the previous cluster.
*
* This function decodes a run. Length is an output parameter, data and cluster
* are in/out parameters.
*/
int ntfs_decompress_run(unsigned char **data, int *length,
ntfs_cluster_t *cluster, int *ctype)
{
unsigned char type = *(*data)++;
*ctype = 0;
switch (type & 0xF) {
case 1:
*length = NTFS_GETS8(*data);
break;
case 2:
*length = NTFS_GETS16(*data);
break;
case 3:
*length = NTFS_GETS24(*data);
break;
case 4:
*length = NTFS_GETS32(*data);
break;
/* Note: cases 5-8 are probably pointless to code, since how
* many runs > 4GB of length are there? At the most, cases 5
* and 6 are probably necessary, and would also require making
* length 64-bit throughout. */
default:
ntfs_error("Can't decode run type field 0x%x\n", type);
return -1;
}
// ntfs_debug(DEBUG_FILE3, "ntfs_decompress_run: length = 0x%x\n",*length);
if (*length < 0)
{
ntfs_error("Negative run length decoded\n");
return -1;
}
*data += (type & 0xF);
switch (type & 0xF0) {
case 0:
*ctype = 2;
break;
case 0x10:
*cluster += NTFS_GETS8(*data);
break;
case 0x20:
*cluster += NTFS_GETS16(*data);
break;
case 0x30:
*cluster += NTFS_GETS24(*data);
break;
case 0x40:
*cluster += NTFS_GETS32(*data);
break;
#if 0 /* Keep for future, in case ntfs_cluster_t ever becomes 64bit. */
case 0x50:
*cluster += NTFS_GETS40(*data);
break;
case 0x60:
*cluster += NTFS_GETS48(*data);
break;
case 0x70:
*cluster += NTFS_GETS56(*data);
break;
case 0x80:
*cluster += NTFS_GETS64(*data);
break;
#endif
default:
ntfs_error("Can't decode run type field 0x%x\n", type);
return -1;
}
// ntfs_debug(DEBUG_FILE3, "ntfs_decompress_run: cluster = 0x%x\n",
// *cluster);
*data += (type >> 4);
return 0;
}
static void dump_runlist(const ntfs_runlist *rl, const int rlen);
/*
* FIXME: ntfs_readwrite_attr() has the effect of writing @dest to @offset of
* the attribute value of the attribute @attr in the in memory inode @ino.
* If the attribute value of @attr is non-resident the value's contents at
* @offset are actually written to disk (from @dest). The on disk mft record
* describing the non-resident attribute value is not updated!
* If the attribute value is resident then the value is written only in
* memory. The on disk mft record containing the value is not written to disk.
* A possible fix would be to call ntfs_update_inode() before returning. (AIA)
*/
/* Reads l bytes of the attribute (attr, name) of ino starting at offset on
* vol into buf. Returns the number of bytes read in the ntfs_io struct.
* Returns 0 on success, errno on failure */
int ntfs_readwrite_attr(ntfs_inode *ino, ntfs_attribute *attr, __s64 offset,
ntfs_io *dest)
{
int rnum, s_vcn, error, clustersizebits;
ntfs_cluster_t cluster, s_cluster, vcn, len;
__s64 l, chunk, copied;
ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): %s 0x%x bytes at offset "
"0x%Lx %s inode 0x%x, attr type 0x%x.\n",
dest->do_read ? "Read" : "Write", dest->size, offset,
dest->do_read ? "from" : "to", ino->i_number,
attr->type);
l = dest->size;
if (l == 0)
return 0;
if (dest->do_read) {
/* If read _starts_ beyond end of stream, return nothing. */
if (offset >= attr->size) {
dest->size = 0;
return 0;
}
/* If read _extends_ beyond end of stream, return as much
* initialised data as we have. */
if (offset + l >= attr->size)
l = dest->size = attr->size - offset;
} else {
/*
* If write extends beyond _allocated_ size, extend attribute,
* updating attr->allocated and attr->size in the process. (AIA)
*/
if ((!attr->resident && offset + l > attr->allocated) ||
(attr->resident && offset + l > attr->size)) {
error = ntfs_resize_attr(ino, attr, offset + l);
if (error)
return error;
}
if (!attr->resident) {
/* Has amount of data increased? */
if (offset + l > attr->size)
attr->size = offset + l;
/* Has amount of initialised data increased? */
if (offset + l > attr->initialized) {
/* FIXME: Clear the section between the old
* initialised length and the write start.
* (AIA) */
attr->initialized = offset + l;
}
}
}
if (attr->resident) {
if (dest->do_read)
dest->fn_put(dest, (ntfs_u8*)attr->d.data + offset, l);
else
dest->fn_get((ntfs_u8*)attr->d.data + offset, dest, l);
dest->size = l;
return 0;
}
if (dest->do_read) {
/* Read uninitialized data. */
if (offset >= attr->initialized)
return ntfs_read_zero(dest, l);
if (offset + l > attr->initialized) {
dest->size = chunk = attr->initialized - offset;
error = ntfs_readwrite_attr(ino, attr, offset, dest);
if (error || (dest->size != chunk && (error = -EIO, 1)))
return error;
dest->size += l - chunk;
return ntfs_read_zero(dest, l - chunk);
}
if (attr->flags & ATTR_IS_COMPRESSED)
return ntfs_read_compressed(ino, attr, offset, dest);
} else {
if (attr->flags & ATTR_IS_COMPRESSED)
return ntfs_write_compressed(ino, attr, offset, dest);
}
vcn = 0;
clustersizebits = ino->vol->cluster_size_bits;
s_vcn = offset >> clustersizebits;
for (rnum = 0; rnum < attr->d.r.len &&
vcn + attr->d.r.runlist[rnum].len <= s_vcn; rnum++)
vcn += attr->d.r.runlist[rnum].len;
if (rnum == attr->d.r.len) {
ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): EOPNOTSUPP: "
"inode = 0x%x, rnum = %i, offset = 0x%Lx, vcn = 0x%x, "
"s_vcn = 0x%x.\n", ino->i_number, rnum, offset, vcn,
s_vcn);
dump_runlist(attr->d.r.runlist, attr->d.r.len);
/*FIXME: Should extend runlist. */
return -EOPNOTSUPP;
}
copied = 0;
while (l) {
s_vcn = offset >> clustersizebits;
cluster = attr->d.r.runlist[rnum].lcn;
len = attr->d.r.runlist[rnum].len;
s_cluster = cluster + s_vcn - vcn;
chunk = ((__s64)(vcn + len) << clustersizebits) - offset;
if (chunk > l)
chunk = l;
dest->size = chunk;
error = ntfs_getput_clusters(ino->vol, s_cluster, offset -
((__s64)s_vcn << clustersizebits), dest);
if (error) {
ntfs_error("Read/write error.\n");
dest->size = copied;
return error;
}
l -= chunk;
copied += chunk;
offset += chunk;
if (l && offset >= ((__s64)(vcn + len) << clustersizebits)) {
rnum++;
vcn += len;
cluster = attr->d.r.runlist[rnum].lcn;
len = attr->d.r.runlist[rnum].len;
}
}
dest->size = copied;
return 0;
}
int ntfs_read_attr(ntfs_inode *ino, int type, char *name, __s64 offset,
ntfs_io *buf)
{
ntfs_attribute *attr;
buf->do_read = 1;
attr = ntfs_find_attr(ino, type, name);
if (!attr) {
ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): attr 0x%x not found "
"in inode 0x%x\n", type, ino->i_number);
return -EINVAL;
}
return ntfs_readwrite_attr(ino, attr, offset, buf);
}
int ntfs_write_attr(ntfs_inode *ino, int type, char *name, __s64 offset,
ntfs_io *buf)
{
ntfs_attribute *attr;
buf->do_read = 0;
attr = ntfs_find_attr(ino, type, name);
if (!attr) {
ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): attr 0x%x not found "
"in inode 0x%x\n", type, ino->i_number);
return -EINVAL;
}
return ntfs_readwrite_attr(ino, attr, offset, buf);
}
/* -2 = error, -1 = hole, >= 0 means real disk cluster (lcn). */
int ntfs_vcn_to_lcn(ntfs_inode *ino, int vcn)
{
int rnum;
ntfs_attribute *data;
data = ntfs_find_attr(ino, ino->vol->at_data, 0);
if (!data || data->resident || data->flags & (ATTR_IS_COMPRESSED |
ATTR_IS_ENCRYPTED))
return -2;
if (data->size <= (__s64)vcn << ino->vol->cluster_size_bits)
return -2;
if (data->initialized <= (__s64)vcn << ino->vol->cluster_size_bits)
return -1;
for (rnum = 0; rnum < data->d.r.len &&
vcn >= data->d.r.runlist[rnum].len; rnum++)
vcn -= data->d.r.runlist[rnum].len;
if (data->d.r.runlist[rnum].lcn >= 0)
return data->d.r.runlist[rnum].lcn + vcn;
return data->d.r.runlist[rnum].lcn + vcn;
}
static int allocate_store(ntfs_volume *vol, ntfs_disk_inode *store, int count)
{
int i;
if (store->count > count)
return 0;
if (store->size < count) {
ntfs_mft_record *n = ntfs_malloc((count + 4) *
sizeof(ntfs_mft_record));
if (!n)
return -ENOMEM;
if (store->size) {
for (i = 0; i < store->size; i++)
n[i] = store->records[i];
ntfs_free(store->records);
}
store->size = count + 4;
store->records = n;
}
for (i = store->count; i < count; i++) {
store->records[i].record = ntfs_malloc(vol->mft_record_size);
if (!store->records[i].record)
return -ENOMEM;
store->count++;
}
return 0;
}
static void deallocate_store(ntfs_disk_inode* store)
{
int i;
for (i = 0; i < store->count; i++)
ntfs_free(store->records[i].record);
ntfs_free(store->records);
store->count = store->size = 0;
store->records = 0;
}
/**
* layout_runs - compress runlist into mapping pairs array
* @attr: attribute containing the runlist to compress
* @rec: destination buffer to hold the mapping pairs array
* @offs: current position in @rec (in/out variable)
* @size: size of the buffer @rec
*
* layout_runs walks the runlist in @attr, compresses it and writes it out the
* resulting mapping pairs array into @rec (up to a maximum of @size bytes are
* written). On entry @offs is the offset in @rec at which to begin writing the
* mapping pairs array. On exit, it contains the offset in @rec of the first
* byte after the end of the mapping pairs array.
*/
static int layout_runs(ntfs_attribute *attr, char *rec, int *offs, int size)
{
int i, len, offset, coffs;
/* ntfs_cluster_t MUST be signed! (AIA) */
ntfs_cluster_t cluster, rclus;
ntfs_runlist *rl = attr->d.r.runlist;
cluster = 0;
offset = *offs;
for (i = 0; i < attr->d.r.len; i++) {
/*
* We cheat with this check on the basis that lcn will never
* be less than -1 and the lcn delta will fit in signed
* 32-bits (ntfs_cluster_t). (AIA)
*/
if (rl[i].lcn < (ntfs_cluster_t)-1) {
ntfs_error("layout_runs() encountered an out of bounds "
"cluster delta, lcn = %i.\n",
rl[i].lcn);
return -ERANGE;
}
rclus = rl[i].lcn - cluster;
len = rl[i].len;
rec[offset] = 0;
if (offset + 9 > size)
return -E2BIG; /* It might still fit, but this
* simplifies testing. */
/*
* Run length is stored as signed number, so deal with it
* properly, i.e. observe that a negative number will have all
* its most significant bits set to 1 but we don't store that
* in the mapping pairs array. We store the smallest type of
* negative number required, thus in the first if we check
* whether len fits inside a signed byte and if so we store it
* as such, the next ifs check for a signed short, then a signed
* 24-bit and finally the full blown signed 32-bit. Same goes
* for rlus below. (AIA)
*/
if (len >= -0x80 && len <= 0x7f) {
NTFS_PUTU8(rec + offset + 1, len & 0xff);
coffs = 1;
} else if (len >= -0x8000 && len <= 0x7fff) {
NTFS_PUTU16(rec + offset + 1, len & 0xffff);
coffs = 2;
} else if (len >= -0x800000 && len <= 0x7fffff) {
NTFS_PUTU24(rec + offset + 1, len & 0xffffff);
coffs = 3;
} else /* if (len >= -0x80000000LL && len <= 0x7fffffff */ {
NTFS_PUTU32(rec + offset + 1, len);
coffs = 4;
} /* else ... FIXME: When len becomes 64-bit we need to extend
* the else if () statements. (AIA) */
*(rec + offset) |= coffs++;
if (rl[i].lcn == (ntfs_cluster_t)-1) /* Compressed run. */
/* Nothing */;
else if (rclus >= -0x80 && rclus <= 0x7f) {
*(rec + offset) |= 0x10;
NTFS_PUTS8(rec + offset + coffs, rclus & 0xff);
coffs += 1;
} else if (rclus >= -0x8000 && rclus <= 0x7fff) {
*(rec + offset) |= 0x20;
NTFS_PUTS16(rec + offset + coffs, rclus & 0xffff);
coffs += 2;
} else if (rclus >= -0x800000 && rclus <= 0x7fffff) {
*(rec + offset) |= 0x30;
NTFS_PUTS24(rec + offset + coffs, rclus & 0xffffff);
coffs += 3;
} else /* if (rclus >= -0x80000000LL && rclus <= 0x7fffffff)*/ {
*(rec + offset) |= 0x40;
NTFS_PUTS32(rec + offset + coffs, rclus
/* & 0xffffffffLL */);
coffs += 4;
} /* FIXME: When rclus becomes 64-bit.
else if (rclus >= -0x8000000000 && rclus <= 0x7FFFFFFFFF) {
*(rec + offset) |= 0x50;
NTFS_PUTS40(rec + offset + coffs, rclus &
0xffffffffffLL);
coffs += 5;
} else if (rclus >= -0x800000000000 &&
rclus <= 0x7FFFFFFFFFFF) {
*(rec + offset) |= 0x60;
NTFS_PUTS48(rec + offset + coffs, rclus &
0xffffffffffffLL);
coffs += 6;
} else if (rclus >= -0x80000000000000 &&
rclus <= 0x7FFFFFFFFFFFFF) {
*(rec + offset) |= 0x70;
NTFS_PUTS56(rec + offset + coffs, rclus &
0xffffffffffffffLL);
coffs += 7;
} else {
*(rec + offset) |= 0x80;
NTFS_PUTS64(rec + offset + coffs, rclus);
coffs += 8;
} */
offset += coffs;
if (rl[i].lcn)
cluster = rl[i].lcn;
}
if (offset >= size)
return -E2BIG;
/* Terminating null. */
*(rec + offset++) = 0;
*offs = offset;
return 0;
}
static void count_runs(ntfs_attribute *attr, char *buf)
{
ntfs_u32 first, count, last, i;
first = 0;
for (i = 0, count = 0; i < attr->d.r.len; i++)
count += attr->d.r.runlist[i].len;
last = first + count - 1;
NTFS_PUTU64(buf + 0x10, first);
NTFS_PUTU64(buf + 0x18, last);
}
/**
* layout_attr - convert in memory attribute to on disk attribute record
* @attr: in memory attribute to convert
* @buf: destination buffer for on disk attribute record
* @size: size of the destination buffer
* @psize: size of converted on disk attribute record (out variable)
*
* layout_attr() takes the attribute @attr and converts it into the appropriate
* on disk structure, writing it into @buf (up to @size bytes are written).
*
* On success we return 0 and set @*psize to the actual byte size of the on-
* disk attribute that was written into @buf.
*/
static int layout_attr(ntfs_attribute *attr, char *buf, int size, int *psize)
{
int nameoff, hdrsize, asize;
if (attr->resident) {
nameoff = 0x18;
hdrsize = (nameoff + 2 * attr->namelen + 7) & ~7;
asize = (hdrsize + attr->size + 7) & ~7;
if (size < asize)
return -E2BIG;
NTFS_PUTU32(buf + 0x10, attr->size);
NTFS_PUTU8(buf + 0x16, attr->indexed);
NTFS_PUTU16(buf + 0x14, hdrsize);
if (attr->size)
ntfs_memcpy(buf + hdrsize, attr->d.data, attr->size);
} else {
int error;
if (attr->flags & ATTR_IS_COMPRESSED)
nameoff = 0x48;
else
nameoff = 0x40;
hdrsize = (nameoff + 2 * attr->namelen + 7) & ~7;
if (size < hdrsize)
return -E2BIG;
/* Make asize point at the end of the attribute record header,
i.e. at the beginning of the mapping pairs array. */
asize = hdrsize;
error = layout_runs(attr, buf, &asize, size);
/* Now, asize points one byte beyond the end of the mapping
pairs array. */
if (error)
return error;
/* The next attribute has to begin on 8-byte boundary. */
asize = (asize + 7) & ~7;
/* FIXME: fragments */
count_runs(attr, buf);
NTFS_PUTU16(buf + 0x20, hdrsize);
NTFS_PUTU16(buf + 0x22, attr->cengine);
NTFS_PUTU32(buf + 0x24, 0);
NTFS_PUTS64(buf + 0x28, attr->allocated);
NTFS_PUTS64(buf + 0x30, attr->size);
NTFS_PUTS64(buf + 0x38, attr->initialized);
if (attr->flags & ATTR_IS_COMPRESSED)
NTFS_PUTS64(buf + 0x40, attr->compsize);
}
NTFS_PUTU32(buf, attr->type);
NTFS_PUTU32(buf + 4, asize);
NTFS_PUTU8(buf + 8, attr->resident ? 0 : 1);
NTFS_PUTU8(buf + 9, attr->namelen);
NTFS_PUTU16(buf + 0xa, nameoff);
NTFS_PUTU16(buf + 0xc, attr->flags);
NTFS_PUTU16(buf + 0xe, attr->attrno);
if (attr->namelen)
ntfs_memcpy(buf + nameoff, attr->name, 2 * attr->namelen);
*psize = asize;
return 0;
}
/**
* layout_inode - convert an in-memory inode into on disk mft record(s)
* @ino: in memory inode to convert
* @store: on disk inode, contain buffers for the on disk mft record(s)
*
* layout_inode takes the in memory inode @ino, converts it into a (sequence of)
* mft record(s) and writes them to the appropriate buffers in the @store.
*
* Return 0 on success,
* the required mft record count (>0) if the inode does not fit,
* -ENOMEM if memory allocation problem, or
* -EOPNOTSUP if beyond our capabilities.
*
* TODO: We at the moment do not support extension mft records. (AIA)
*/
int layout_inode(ntfs_inode *ino, ntfs_disk_inode *store)
{
int offset, i, size, psize, error, count, recno;
ntfs_attribute *attr;
unsigned char *rec;
error = allocate_store(ino->vol, store, ino->record_count);
if (error)
return error;
size = ino->vol->mft_record_size;
count = i = 0;
do {
if (count < ino->record_count) {
recno = ino->records[count];
} else {
error = allocate_store(ino->vol, store, count + 1);
if (error)
return error;
recno = -1;
}
/*
* FIXME: We need to support extension records properly.
* At the moment they wouldn't work. Probably would "just" get
* corrupted if we write to them... (AIA)
*/
store->records[count].recno = recno;
rec = store->records[count].record;
count++;
/* Copy mft record header. */
offset = NTFS_GETU16(ino->attr + 0x14); /* attrs_offset */
ntfs_memcpy(rec, ino->attr, offset);
/* Copy attributes. */
while (i < ino->attr_count) {
attr = ino->attrs + i;
error = layout_attr(attr, rec + offset,
size - offset - 8, &psize);
if (error == -E2BIG && offset != NTFS_GETU16(ino->attr
+ 0x14))
break;
if (error)
return error;
offset += psize;
i++;
}
/* Terminating attribute. */
NTFS_PUTU32(rec + offset, 0xFFFFFFFF);
offset += 4;
NTFS_PUTU32(rec + offset, 0);
offset += 4;
NTFS_PUTU32(rec + 0x18, offset);
} while (i < ino->attr_count || count < ino->record_count);
return count - ino->record_count;
}
/*
* FIXME: ntfs_update_inode() calls layout_inode() to create the mft record on
* disk structure corresponding to the inode @ino. After that, ntfs_write_attr()
* is called to write out the created mft record to disk.
* We shouldn't need to re-layout every single time we are updating an mft
* record. No wonder the ntfs driver is slow like hell. (AIA)
*/
int ntfs_update_inode(ntfs_inode *ino)
{
int error, i;
ntfs_disk_inode store;
ntfs_io io;
ntfs_bzero(&store, sizeof(store));
error = layout_inode(ino, &store);
if (error == -E2BIG) {
i = ntfs_split_indexroot(ino);
if (i != -ENOTDIR) {
if (!i)
i = layout_inode(ino, &store);
error = i;
}
}
if (error == -E2BIG) {
error = ntfs_attr_allnonresident(ino);
if (!error)
error = layout_inode(ino, &store);
}
if (error > 0) {
/* FIXME: Introduce extension records. */
error = -E2BIG;
}
if (error) {
if (error == -E2BIG)
ntfs_error("Cannot handle saving inode 0x%x.\n",
ino->i_number);
deallocate_store(&store);
return error;
}
io.fn_get = ntfs_get;
io.fn_put = 0;
for (i = 0; i < store.count; i++) {
error = ntfs_insert_fixups(store.records[i].record,
ino->vol->mft_record_size);
if (error) {
printk(KERN_ALERT "NTFS: ntfs_update_inode() caught "
"corrupt %s mtf record ntfs record "
"header. Refusing to write corrupt "
"data to disk. Unmount and run chkdsk "
"immediately!\n", i ? "extension":
"base");
deallocate_store(&store);
return -EIO;
}
io.param = store.records[i].record;
io.size = ino->vol->mft_record_size;
error = ntfs_write_attr(ino->vol->mft_ino, ino->vol->at_data,
0, (__s64)store.records[i].recno <<
ino->vol->mft_record_size_bits, &io);
if (error || io.size != ino->vol->mft_record_size) {
/* Big trouble, partially written file. */
ntfs_error("Please unmount: Write error in inode "
"0x%x\n", ino->i_number);
deallocate_store(&store);
return error ? error : -EIO;
}
}
deallocate_store(&store);
return 0;
}
void ntfs_decompress(unsigned char *dest, unsigned char *src, ntfs_size_t l)
{
int head, comp;
int copied = 0;
unsigned char *stop;
int bits;
int tag = 0;
int clear_pos;
while (1) {
head = NTFS_GETU16(src) & 0xFFF;
/* High bit indicates that compression was performed. */
comp = NTFS_GETU16(src) & 0x8000;
src += 2;
stop = src + head;
bits = 0;
clear_pos = 0;
if (head == 0)
/* Block is not used. */
return;/* FIXME: copied */
if (!comp) { /* uncompressible */
ntfs_memcpy(dest, src, 0x1000);
dest += 0x1000;
copied += 0x1000;
src += 0x1000;
if (l == copied)
return;
continue;
}
while (src <= stop) {
if (clear_pos > 4096) {
ntfs_error("Error 1 in decompress\n");
return;
}
if (!bits) {
tag = NTFS_GETU8(src);
bits = 8;
src++;
if (src > stop)
break;
}
if (tag & 1) {
int i, len, delta, code, lmask, dshift;
code = NTFS_GETU16(src);
src += 2;
if (!clear_pos) {
ntfs_error("Error 2 in decompress\n");
return;
}
for (i = clear_pos - 1, lmask = 0xFFF,
dshift = 12; i >= 0x10; i >>= 1) {
lmask >>= 1;
dshift--;
}
delta = code >> dshift;
len = (code & lmask) + 3;
for (i = 0; i < len; i++) {
dest[clear_pos] = dest[clear_pos -
delta - 1];
clear_pos++;
copied++;
if (copied==l)
return;
}
} else {
dest[clear_pos++] = NTFS_GETU8(src);
src++;
copied++;
if (copied==l)
return;
}
tag >>= 1;
bits--;
}
dest += clear_pos;
}
}
/*
* NOTE: Neither of the ntfs_*_bit functions are atomic! But we don't need
* them atomic at present as we never operate on shared/cached bitmaps.
*/
static __inline__ int ntfs_test_bit(unsigned char *byte, const int bit)
{
return byte[bit >> 3] & (1 << (bit & 7)) ? 1 : 0;
}
static __inline__ void ntfs_set_bit(unsigned char *byte, const int bit)
{
byte[bit >> 3] |= 1 << (bit & 7);
}
static __inline__ void ntfs_clear_bit(unsigned char *byte, const int bit)
{
byte[bit >> 3] &= ~(1 << (bit & 7));
}
static __inline__ int ntfs_test_and_clear_bit(unsigned char *byte,
const int bit)
{
unsigned char *ptr = byte + (bit >> 3);
int b = 1 << (bit & 7);
int oldbit = *ptr & b ? 1 : 0;
*ptr &= ~b;
return oldbit;
}
static void dump_runlist(const ntfs_runlist *rl, const int rlen)
{
#ifdef DEBUG
int i;
ntfs_cluster_t ct;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rlen = %i.\n", rlen);
ntfs_debug(DEBUG_OTHER, "VCN LCN Run length\n");
for (i = 0, ct = 0; i < rlen; ct += rl[i++].len) {
if (rl[i].lcn == (ntfs_cluster_t)-1)
ntfs_debug(DEBUG_OTHER, "0x%-8x LCN_HOLE 0x%-8x "
"(%s)\n", ct, rl[i].len, rl[i].len ?
"sparse run" : "run list end");
else
ntfs_debug(DEBUG_OTHER, "0x%-8x 0x%-8x 0x%-8x%s\n", ct,
rl[i].lcn, rl[i].len, rl[i].len &&
i + 1 < rlen ? "" : " (run list end)");
if (!rl[i].len)
break;
}
#endif
}
/**
* splice_runlists - splice two run lists into one
* @rl1: pointer to address of first run list
* @r1len: number of elementfs in first run list
* @rl2: pointer to second run list
* @r2len: number of elements in second run list
*
* Append the run list @rl2 to the run list *@rl1 and return the result in
* *@rl1 and *@r1len.
*
* Return 0 on success or -errno on error, in which case *@rl1 and *@r1len are
* left untouched.
*
* The only possible error code at the moment is -ENOMEM and only happens if
* there is insufficient memory to allocate the new run list (only happens
* when size of (rl1 + rl2) > allocated size of rl1).
*/
int splice_runlists(ntfs_runlist **rl1, int *r1len, const ntfs_runlist *rl2,
int r2len)
{
ntfs_runlist *rl;
int rlen, rl_size, rl2_pos;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Entering with *r1len = %i, "
"r2len = %i.\n", *r1len, r2len);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Dumping 1st runlist.\n");
if (*rl1)
dump_runlist(*rl1, *r1len);
else
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Not present.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Dumping 2nd runlist.\n");
dump_runlist(rl2, r2len);
rlen = *r1len + r2len + 1;
rl_size = (rlen * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
PAGE_MASK;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rlen = %i, rl_size = %i.\n",
rlen, rl_size);
/* Do we have enough space? */
if (rl_size <= ((*r1len * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
PAGE_MASK)) {
/* Have enough space already. */
rl = *rl1;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Have enough space "
"already.\n");
} else {
/* Need more space. Reallocate. */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Need more space.\n");
rl = ntfs_vmalloc(rlen << sizeof(ntfs_runlist));
if (!rl)
return -ENOMEM;
/* Copy over rl1. */
ntfs_memcpy(rl, *rl1, *r1len * sizeof(ntfs_runlist));
ntfs_vfree(*rl1);
*rl1 = rl;
}
/* Reuse rl_size as the current position index into rl. */
rl_size = *r1len - 1;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rl_size = %i.\n");
/* Coalesce neighbouring elements, if present. */
rl2_pos = 0;
if (rl[rl_size].lcn + rl[rl_size].len == rl2[rl2_pos].lcn) {
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Coalescing adjacent "
"runs.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
"rl[rl_size].len = %i.\n", rl[rl_size].len);
rl[rl_size].len += rl2[rl2_pos].len;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
"rl[rl_size].len = %i.\n", rl[rl_size].len);
rl2_pos++;
r2len--;
rlen--;
}
rl_size++;
/* Copy over rl2. */
ntfs_memcpy(rl + rl_size, rl2 + rl2_pos, r2len * sizeof(ntfs_runlist));
rlen--;
rl[rlen].lcn = (ntfs_cluster_t)-1;
rl[rlen].len = (ntfs_cluster_t)0;
*r1len = rlen;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Dumping result runlist.\n");
dump_runlist(*rl1, *r1len);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Returning with *r1len = "
"%i.\n", rlen);
return 0;
}
/**
* ntfs_alloc_mft_record - allocate an mft record
* @vol: volume to allocate an mft record on
* @result: the mft record number allocated
*
* Allocate a new mft record on disk. Return 0 on success or -ERRNO on error.
* On success, *@result contains the allocated mft record number. On error,
* *@result is -1UL.
*
* Note, this function doesn't actually set the mft record to be in use. This
* is done by the caller, which at the moment is only ntfs_alloc_inode().
*
* To find a free mft record, we scan the mft bitmap for a zero bit. To
* optimize this we start scanning at the place 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 $MFT's $DATA attribute. 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 more files while Windows can still create up to 8 small files. We
* can start doing this at some later time, doesn't matter much for now.
*
* When scanning the mft bitmap, we only search up to the last allocated mft
* record. If there are no free records left in the range 24 to number of
* allocated mft records, then we extend the mft data in order to create free
* mft records. We extend the allocated size of $MFT/$DATA by 16 records at a
* time or one cluster, if cluster size is above 16kiB. If there isn't
* sufficient space to do this, we try to extend by a single mft record or one
* cluster, if cluster size is above mft record size, but we only do this if
* there is enough free space, which we know from the values returned by the
* failed cluster allocation function when we tried to do the first allocation.
*
* No matter how many mft records we allocate, we initialize only the first
* allocated mft record (incrementing mft data size and initialized size) and
* return its number to the caller in @*result, unless there are less than 24
* mft records, in which case we allocate and initialize mft records until we
* reach record 24 which we consider as the first free mft record for use by
* normal files.
*
* If during any stage we overflow the initialized data in the mft bitmap, we
* extend the initialized size (and data size) by 8 bytes, allocating another
* cluster if required. The bitmap data size has to be at least equal to the
* number of mft records in the mft, but it can be bigger, in which case the
* superflous bits are padded with zeroes.
*
* Thus, when we return successfully (return value 0), we will have:
* - initialized / extended the mft bitmap if necessary,
* - initialized / extended the mft data if necessary,
* - set the bit corresponding to the mft record being allocated in the
* mft bitmap, and we will
* - return the mft record number in @*result.
*
* On error (return value below zero), nothing will have changed. If we had
* changed anything before the error occured, we will have reverted back to
* the starting state before returning to the caller. Thus, except for bugs,
* we should always leave the volume in a consitents state when returning from
* this function. NOTE: Small exception to this is that we set the bit in the
* mft bitmap but we do not mark the mft record in use, which is inconsistent.
* However, the caller will immediately add the wanted attributes to the mft
* record, set it in use and write it out to disk, so there should be no
* problem.
*
* Note, this function cannot make use of most of the normal functions, like
* for example for attribute resizing, etc, because when the run list overflows
* the base mft record and an attribute list is used, it is very important
* that the extension mft records used to store the $DATA attribute of $MFT
* can be reached without having to read the information contained inside
* them, as this would make it impossible to find them in the first place
* after the volume is dismounted. $MFT/$BITMAP probably doesn't need to
* follow this rule because the bitmap is not essential for finding the mft
* records, but on the other hand, handling the bitmap in this special way
* would make life easier because otherwise there might be circular invocations
* of functions when reading the bitmap but if we are careful, we should be
* able to avoid all problems.
*
* FIXME: Don't forget $MftMirr, though this probably belongs in
* ntfs_update_inode() (or even deeper). (AIA)
*
* FIXME: Want finer grained locking. (AIA)
*/
static int ntfs_alloc_mft_record(ntfs_volume *vol, unsigned long *result)
{
unsigned long nr_mft_records, buf_size, buf_pos, pass_start, pass_end;
unsigned long last_read_pos, mft_rec_size, bit, l;
ntfs_attribute *data, *bmp;
__u8 *buf, *byte, pass, b, have_allocated_mftbmp = 0;
int rlen, rl_size = 0, r2len, rl2_size, old_data_rlen, err = 0;
ntfs_runlist *rl, *rl2;
ntfs_cluster_t lcn = 0, old_data_len;
ntfs_io io;
__s64 ll, old_data_allocated, old_data_initialized, old_data_size;
*result = -1UL;
/* Allocate a buffer and setup the io structure. */
buf = (__u8*)__get_free_page(GFP_NOFS);
if (!buf)
return -ENOMEM;
lock_kernel();
/* Get the $DATA and $BITMAP attributes of $MFT. */
data = ntfs_find_attr(vol->mft_ino, vol->at_data, 0);
bmp = ntfs_find_attr(vol->mft_ino, vol->at_bitmap, 0);
if (!data || !bmp) {
err = -EINVAL;
goto err_ret;
}
/* Determine the number of allocated mft records in the mft. */
pass_end = nr_mft_records = data->allocated >>
vol->mft_record_size_bits;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): nr_mft_records = %lu.\n",
nr_mft_records);
/* Make sure we don't overflow the bitmap. */
l = bmp->initialized << 3;
if (l < nr_mft_records)
// FIXME: It might be a good idea to extend the bitmap instead.
pass_end = l;
pass = 1;
buf_pos = vol->mft_data_pos;
if (buf_pos >= pass_end) {
buf_pos = 24UL;
pass = 2;
}
pass_start = buf_pos;
rl = bmp->d.r.runlist;
rlen = bmp->d.r.len - 1;
lcn = rl[rlen].lcn + rl[rlen].len;
io.fn_put = ntfs_put;
io.fn_get = ntfs_get;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Starting bitmap search.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): pass = %i, pass_start = %lu, "
"pass_end = %lu.\n", pass, pass_start, pass_end);
byte = NULL; // FIXME: For debugging only.
/* Loop until a free mft record is found. */
io.size = (nr_mft_records >> 3) & ~PAGE_MASK;
for (;; io.size = PAGE_SIZE) {
io.param = buf;
io.do_read = 1;
last_read_pos = buf_pos >> 3;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
err = ntfs_readwrite_attr(vol->mft_ino, bmp, last_read_pos,
&io);
if (err)
goto err_ret;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Read %lu bytes.\n",
(unsigned long)io.size);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
if (!io.size)
goto pass_done;
buf_size = io.size << 3;
bit = buf_pos & 7UL;
buf_pos &= ~7UL;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before loop: "
"buf_size = %lu, buf_pos = %lu, bit = %lu, "
"*byte = 0x%x, b = %u.\n",
buf_size, buf_pos, bit, byte ? *byte : -1, b);
for (; bit < buf_size && bit + buf_pos < pass_end;
bit &= ~7UL, bit += 8UL) {
byte = buf + (bit >> 3);
if (*byte == 0xff)
continue;
b = ffz((unsigned long)*byte);
if (b < (__u8)8 && b >= (bit & 7UL)) {
bit = b + (bit & ~7UL) + buf_pos;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
"Found free rec in for loop. "
"bit = %lu\n", bit);
goto found_free_rec;
}
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After loop: "
"buf_size = %lu, buf_pos = %lu, bit = %lu, "
"*byte = 0x%x, b = %u.\n",
buf_size, buf_pos, bit, byte ? *byte : -1, b);
buf_pos += buf_size;
if (buf_pos < pass_end)
continue;
pass_done: /* Finished with the current pass. */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At pass_done.\n");
if (pass == 1) {
/*
* Now do pass 2, scanning the first part of the zone
* we omitted in pass 1.
*/
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Done pass "
"1.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Pass = 2.\n");
pass = 2;
pass_end = pass_start;
buf_pos = pass_start = 24UL;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): pass = %i, "
"pass_start = %lu, pass_end = %lu.\n",
pass, pass_start, pass_end);
continue;
} /* pass == 2 */
/* No free records left. */
if (bmp->initialized << 3 > nr_mft_records &&
bmp->initialized > 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_mft_records;
if (bit < 24UL)
bit = 24UL;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Found free "
"record bit (#1) = 0x%lx.\n", bit);
goto found_free_rec;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Done pass 2.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
/* Need to extend the mft bitmap. */
if (bmp->initialized + 8LL > bmp->allocated) {
ntfs_io io2;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Initialized "
"> allocated.\n");
/* Need to extend bitmap by one more cluster. */
rl = bmp->d.r.runlist;
rlen = bmp->d.r.len - 1;
lcn = rl[rlen].lcn + rl[rlen].len;
io2.fn_put = ntfs_put;
io2.fn_get = ntfs_get;
io2.param = &b;
io2.size = 1;
io2.do_read = 1;
err = ntfs_readwrite_attr(vol->bitmap, data, lcn >> 3,
&io2);
if (err)
goto err_ret;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Read %lu "
"bytes.\n", (unsigned long)io2.size);
if (io2.size == 1 && b != 0xff) {
__u8 tb = 1 << (lcn & (ntfs_cluster_t)7);
if (!(b & tb)) {
/* Next cluster is free. Allocate it. */
b |= tb;
io2.param = &b;
io2.do_read = 0;
err = ntfs_readwrite_attr(vol->bitmap,
data, lcn >> 3, &io2);
if (err || io.size != 1) {
if (!err)
err = -EIO;
goto err_ret;
}
append_mftbmp_simple: rl[rlen].len++;
have_allocated_mftbmp |= 1;
ntfs_debug(DEBUG_OTHER, __FUNCTION__
"(): Appending one "
"cluster to mftbmp.\n");
}
}
if (!have_allocated_mftbmp) {
/* Allocate a cluster from the DATA_ZONE. */
ntfs_cluster_t lcn2 = lcn;
ntfs_cluster_t count = 1;
err = ntfs_allocate_clusters(vol, &lcn2,
&count, &rl2, &r2len,
DATA_ZONE);
if (err)
goto err_ret;
if (count != 1 || lcn2 <= 0) {
if (count > 0) {
rl2_dealloc_err_out: if (ntfs_deallocate_clusters(
vol, rl2, r2len))
ntfs_error(__FUNCTION__
"(): Cluster "
"deallocation in error "
"code path failed! You "
"should run chkdsk.\n");
}
ntfs_vfree(rl2);
if (!err)
err = -EINVAL;
goto err_ret;
}
if (lcn2 == lcn) {
ntfs_vfree(rl2);
goto append_mftbmp_simple;
}
/* We need to append a new run. */
rl_size = (rlen * sizeof(ntfs_runlist) +
PAGE_SIZE - 1) & PAGE_MASK;
/* Reallocate memory if necessary. */
if ((rlen + 2) * sizeof(ntfs_runlist) >=
rl_size) {
ntfs_runlist *rlt;
rl_size += PAGE_SIZE;
rlt = ntfs_vmalloc(rl_size);
if (!rlt) {
err = -ENOMEM;
goto rl2_dealloc_err_out;
}
ntfs_memcpy(rlt, rl, rl_size -
PAGE_SIZE);
ntfs_vfree(rl);
bmp->d.r.runlist = rl = rlt;
}
ntfs_vfree(rl2);
rl[rlen].lcn = lcn = lcn2;
rl[rlen].len = count;
bmp->d.r.len = ++rlen;
have_allocated_mftbmp |= 2;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
"Adding run to mftbmp. "
"LCN = %i, len = %i\n", lcn,
count);
}
/*
* We now have extended the mft bitmap allocated size
* by one cluster. Reflect this in the attribute.
*/
bmp->allocated += (__s64)vol->cluster_size;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
/* We now have sufficient allocated space. */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Now have sufficient "
"allocated space in mftbmp.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
buf_pos = bmp->initialized;
bmp->initialized += 8LL;
if (bmp->initialized > bmp->size)
bmp->size = bmp->initialized;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
have_allocated_mftbmp |= 4;
/* Update the mft bitmap attribute value. */
memset(buf, 0, 8);
io.param = buf;
io.size = 8;
io.do_read = 0;
err = ntfs_readwrite_attr(vol->mft_ino, bmp, buf_pos, &io);
if (err || io.size != 8) {
if (!err)
err = -EIO;
goto shrink_mftbmp_err_ret;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Wrote extended "
"mftbmp bytes %lu.\n", (unsigned long)io.size);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After write: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
bit = buf_pos << 3;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Found free record "
"bit (#2) = 0x%lx.\n", bit);
goto found_free_rec;
}
found_free_rec:
/* bit is the found free mft record. Allocate it in the mft bitmap. */
vol->mft_data_pos = bit;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At found_free_rec.\n");
io.param = buf;
io.size = 1;
io.do_read = 1;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Before update: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
if (err || io.size != 1) {
if (!err)
err = -EIO;
goto shrink_mftbmp_err_ret;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Read %lu bytes.\n",
(unsigned long)io.size);
#ifdef DEBUG
/* Check our bit is really zero! */
if (*buf & (1 << (bit & 7)))
BUG();
#endif
*buf |= 1 << (bit & 7);
io.param = buf;
io.do_read = 0;
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
if (err || io.size != 1) {
if (!err)
err = -EIO;
goto shrink_mftbmp_err_ret;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Wrote %lu bytes.\n",
(unsigned long)io.size);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After update: "
"bmp->allocated = 0x%Lx, bmp->size = 0x%Lx, "
"bmp->initialized = 0x%Lx.\n", bmp->allocated,
bmp->size, bmp->initialized);
/* The mft bitmap is now uptodate. Deal with mft data attribute now. */
ll = (__s64)(bit + 1) << vol->mft_record_size_bits;
if (ll <= data->initialized) {
/* The allocated record is already initialized. We are done! */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated mft record "
"already initialized!\n");
goto done_ret;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated mft record needs "
"to be initialized.\n");
/* The mft record is outside the initialized data. */
mft_rec_size = (unsigned long)vol->mft_record_size;
/* Preserve old values for undo purposes. */
old_data_allocated = data->allocated;
old_data_rlen = data->d.r.len - 1;
old_data_len = data->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. But it optimizes away nicely in the common case.
*/
while (ll > data->allocated) {
ntfs_cluster_t lcn2, nr_lcn2, nr, min_nr;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Extending mft "
"data allocation, data->allocated = 0x%Lx, "
"data->size = 0x%Lx, data->initialized = "
"0x%Lx.\n", data->allocated, data->size,
data->initialized);
/* Minimum allocation is one mft record worth of clusters. */
if (mft_rec_size <= vol->cluster_size)
min_nr = (ntfs_cluster_t)1;
else
min_nr = mft_rec_size >> vol->cluster_size_bits;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): min_nr = %i.\n",
min_nr);
/* Allocate 16 mft records worth of clusters. */
nr = mft_rec_size << 4 >> vol->cluster_size_bits;
if (!nr)
nr = (ntfs_cluster_t)1;
/* Determine the preferred allocation location. */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): nr = %i.\n", nr);
rl2 = data->d.r.runlist;
r2len = data->d.r.len;
lcn2 = rl2[r2len - 1].lcn + rl2[r2len - 1].len;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): rl2[r2len - 1].lcn "
"= %i, .len = %i.\n", rl2[r2len - 1].lcn,
rl2[r2len - 1].len);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): lcn2 = %i, r2len = "
"%i.\n", lcn2, r2len);
retry_mft_data_allocation:
nr_lcn2 = nr;
err = ntfs_allocate_clusters(vol, &lcn2, &nr_lcn2, &rl2,
&r2len, MFT_ZONE);
#ifdef DEBUG
if (!err && nr_lcn2 < min_nr)
/* Allocated less than minimum needed. Weird! */
BUG();
#endif
if (err) {
/*
* If there isn't enough space to do the wanted
* allocation, but there is enough space to do a
* minimal allocation, then try that, unless the wanted
* allocation was already the minimal allocation.
*/
if (err == -ENOSPC && nr > min_nr &&
nr_lcn2 >= min_nr) {
nr = min_nr;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
"Retrying mft data "
"allocation, nr = min_nr = %i"
".\n", nr);
goto retry_mft_data_allocation;
}
goto undo_mftbmp_alloc_err_ret;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated %i "
"clusters starting at LCN %i.\n", nr_lcn2,
lcn2);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Allocated "
"runlist:\n");
dump_runlist(rl2, r2len);
/* Append rl2 to the mft data attribute's run list. */
err = splice_runlists(&data->d.r.runlist, (int*)&data->d.r.len,
rl2, r2len);
if (err) {
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): "
"splice_runlists failed with error "
"code %i.\n", -err);
goto undo_partial_data_alloc_err_ret;
}
/* Reflect the allocated clusters in the mft allocated data. */
data->allocated += nr_lcn2 << vol->cluster_size_bits;
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After extending mft "
"data allocation, data->allocated = 0x%Lx, "
"data->size = 0x%Lx, data->initialized = "
"0x%Lx.\n", data->allocated, data->size,
data->initialized);
}
/* Prepare a formatted (empty) mft record. */
memset(buf, 0, mft_rec_size);
ntfs_fill_mft_header(buf, mft_rec_size, 0, 0, 0);
err = ntfs_insert_fixups(buf, mft_rec_size);
if (err)
goto undo_data_alloc_err_ret;
/*
* Extend mft data initialized size to reach the allocated mft record
* and write the formatted mft record buffer to each mft record being
* initialized. Note, that ntfs_readwrite_attr extends both
* data->initialized and data->size, so no need for us to touch them.
*/
old_data_initialized = data->initialized;
old_data_size = data->size;
while (ll > data->initialized) {
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Initializing mft "
"record 0x%Lx.\n",
data->initialized >> vol->mft_record_size_bits);
io.param = buf;
io.size = mft_rec_size;
io.do_read = 0;
err = ntfs_readwrite_attr(vol->mft_ino, data,
data->initialized, &io);
if (err || io.size != mft_rec_size) {
if (!err)
err = -EIO;
goto undo_data_init_err_ret;
}
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Wrote %i bytes to "
"mft data.\n", io.size);
}
/* Update the VFS inode size as well. */
VFS_I(vol->mft_ino)->i_size = data->size;
#ifdef DEBUG
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After mft record "
"initialization: data->allocated = 0x%Lx, data->size "
"= 0x%Lx, data->initialized = 0x%Lx.\n",
data->allocated, data->size, data->initialized);
/* Sanity checks. */
if (data->size > data->allocated || data->size < data->initialized ||
data->initialized > data->allocated)
BUG();
#endif
done_ret:
/* Return the number of the allocated mft record. */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At done_ret. *result = bit = "
"0x%lx.\n", bit);
*result = bit;
vol->mft_data_pos = bit + 1;
err_ret:
unlock_kernel();
free_page((unsigned long)buf);
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Syncing inode $MFT.\n");
if (ntfs_update_inode(vol->mft_ino))
ntfs_error(__FUNCTION__ "(): Failed to sync inode $MFT. "
"Continuing anyway.\n");
if (!err) {
ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): Done. Allocated mft "
"record number *result = 0x%lx.\n", *result);
return 0;
}
if (err != -ENOSPC)
ntfs_error(__FUNCTION__ "(): Failed to allocate an mft "
"record. Returning error code %i.\n", -err);
else
ntfs_debug(DEBUG_FILE3, __FUNCTION__ "(): Failed to allocate "
"an mft record due to lack of free space.\n");
return err;
undo_data_init_err_ret:
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At "
"undo_data_init_err_ret.\n");
data->initialized = old_data_initialized;
data->size = old_data_size;
undo_data_alloc_err_ret:
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At undo_data_alloc_err_ret."
"\n");
data->allocated = old_data_allocated;
undo_partial_data_alloc_err_ret:
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At "
"undo_partial_data_alloc_err_ret.\n");
/* Deallocate the clusters. */
if (ntfs_deallocate_clusters(vol, rl2, r2len))
ntfs_error(__FUNCTION__ "(): Error deallocating clusters in "
"error code path. You should run chkdsk.\n");
ntfs_vfree(rl2);
/* Revert the run list back to what it was before. */
r2len = data->d.r.len;
rl2 = data->d.r.runlist;
rl2[old_data_rlen++].len = old_data_len;
rl2[old_data_rlen].lcn = (ntfs_cluster_t)-1;
rl2[old_data_rlen].len = (ntfs_cluster_t)0;
data->d.r.len = old_data_rlen;
rl2_size = ((old_data_rlen + 1) * sizeof(ntfs_runlist) + PAGE_SIZE -
1) & PAGE_MASK;
/* Reallocate memory freeing any extra memory allocated. */
if (rl2_size < ((r2len * sizeof(ntfs_runlist) + PAGE_SIZE - 1) &
PAGE_MASK)) {
rl2 = ntfs_vmalloc(rl2_size);
if (rl2) {
ntfs_memcpy(rl2, data->d.r.runlist, rl2_size);
ntfs_vfree(data->d.r.runlist);
data->d.r.runlist = rl2;
} else
ntfs_error(__FUNCTION__ "(): Error reallocating "
"memory in error code path. This "
"should be harmless.\n");
}
undo_mftbmp_alloc_err_ret:
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At "
"undo_mftbmp_alloc_err_ret.\n");
/* Deallocate the allocated bit in the mft bitmap. */
io.param = buf;
io.size = 1;
io.do_read = 1;
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
if (!err && io.size == 1) {
*buf &= ~(1 << (bit & 7));
io.param = buf;
io.do_read = 0;
err = ntfs_readwrite_attr(vol->mft_ino, bmp, bit >> 3, &io);
}
if (err || io.size != 1) {
if (!err)
err = -EIO;
ntfs_error(__FUNCTION__ "(): Error deallocating mft record in "
"error code path. You should run chkdsk.\n");
}
shrink_mftbmp_err_ret:
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): At shrink_mftbmp_err_ret.\n");
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): have_allocated_mftbmp = "
"%i.\n", have_allocated_mftbmp);
if (!have_allocated_mftbmp)
goto err_ret;
/* Shrink the mftbmp back to previous size. */
if (bmp->size == bmp->initialized)
bmp->size -= 8LL;
bmp->initialized -= 8LL;
have_allocated_mftbmp &= ~4;
/* If no allocation occured then we are done. */
ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): have_allocated_mftbmp = "
"%i.\n", have_allocated_mftbmp);
if (!have_allocated_mftbmp)
goto err_ret;
/* Deallocate the allocated cluster. */
bmp->allocated -= (__s64)vol->cluster_size;
if (ntfs_deallocate_cluster_run(vol, lcn, (ntfs_cluster_t)1))
ntfs_error(__FUNCTION__ "(): Error deallocating cluster in "
"error code path. You should run chkdsk.\n");
switch (have_allocated_mftbmp & 3) {
case 1:
/* Delete the last lcn from the last run of mftbmp. */
rl[rlen - 1].len--;
break;
case 2:
/* Delete the last run of mftbmp. */
bmp->d.r.len = --rlen;
/* Reallocate memory if necessary. */
if ((rlen + 1) * sizeof(ntfs_runlist) <= rl_size - PAGE_SIZE) {
ntfs_runlist *rlt;
rl_size -= PAGE_SIZE;
rlt = ntfs_vmalloc(rl_size);
if (rlt) {
ntfs_memcpy(rlt, rl, rl_size);
ntfs_vfree(rl);
bmp->d.r.runlist = rl = rlt;
} else
ntfs_error(__FUNCTION__ "(): Error "
"reallocating memory in error "
"code path. This should be "
"harmless.\n");
}
bmp->d.r.runlist[bmp->d.r.len].lcn = (ntfs_cluster_t)-1;
bmp->d.r.runlist[bmp->d.r.len].len = (ntfs_cluster_t)0;
break;
default:
BUG();
}
goto err_ret;
}
/* We need 0x48 bytes in total. */
static int add_standard_information(ntfs_inode *ino)
{
ntfs_time64_t now;
char data[0x30];
char *position = data;
ntfs_attribute *si;
now = ntfs_now();
NTFS_PUTU64(position + 0x00, now); /* File creation */
NTFS_PUTU64(position + 0x08, now); /* Last modification */
NTFS_PUTU64(position + 0x10, now); /* Last mod for MFT */
NTFS_PUTU64(position + 0x18, now); /* Last access */
NTFS_PUTU64(position + 0x20, 0); /* MSDOS file perms */
NTFS_PUTU64(position + 0x28, 0); /* unknown */
return ntfs_create_attr(ino, ino->vol->at_standard_information, 0,
data, sizeof(data), &si);
}
static int add_filename(ntfs_inode *ino, ntfs_inode *dir,
const unsigned char *filename, int length, ntfs_u32 flags)
{
unsigned char *position;
unsigned int size;
ntfs_time64_t now;
int count, error;
unsigned char* data;
ntfs_attribute *fn;
/* Work out the size. */
size = 0x42 + 2 * length;
data = ntfs_malloc(size);
if (!data)
return -ENOMEM;
/* Search for a position. */
position = data;
NTFS_PUTINUM(position, dir); /* Inode num of dir */
now = ntfs_now();
NTFS_PUTU64(position + 0x08, now); /* File creation */
NTFS_PUTU64(position + 0x10, now); /* Last modification */
NTFS_PUTU64(position + 0x18, now); /* Last mod for MFT */
NTFS_PUTU64(position + 0x20, now); /* Last access */
/* FIXME: Get the following two sizes by finding the data attribute
* in ino->attr and copying the corresponding fields from there.
* If no data present then set to zero. In current implementation
* add_data is called after add_filename so zero is correct on
* creation. Need to change when we have hard links / support different
* filename namespaces. (AIA) */
NTFS_PUTS64(position + 0x28, 0); /* Allocated size */
NTFS_PUTS64(position + 0x30, 0); /* Data size */
NTFS_PUTU32(position + 0x38, flags); /* File flags */
NTFS_PUTU32(position + 0x3c, 0); /* We don't use these
* features yet. */
NTFS_PUTU8(position + 0x40, length); /* Filename length */
NTFS_PUTU8(position + 0x41, 0); /* Only long name */
/* FIXME: This is madness. We are defining the POSIX namespace
* for the filename here which can mean that the file will be
* invisible when in Windows NT/2k! )-: (AIA) */
position += 0x42;
for (count = 0; count < length; count++) {
NTFS_PUTU16(position + 2 * count, filename[count]);
}
error = ntfs_create_attr(ino, ino->vol->at_file_name, 0, data, size,
&fn);
if (!error)
error = ntfs_dir_add(dir, ino, fn);
ntfs_free(data);
return error;
}
int add_security(ntfs_inode* ino, ntfs_inode* dir)
{
int error;
char *buf;
int size;
ntfs_attribute* attr;
ntfs_io io;
ntfs_attribute *se;
attr = ntfs_find_attr(dir, ino->vol->at_security_descriptor, 0);
if (!attr)
return -EOPNOTSUPP; /* Need security in directory. */
size = attr->size;
if (size > 512)
return -EOPNOTSUPP;
buf = ntfs_malloc(size);
if (!buf)
return -ENOMEM;
io.fn_get = ntfs_get;
io.fn_put = ntfs_put;
io.param = buf;
io.size = size;
error = ntfs_read_attr(dir, ino->vol->at_security_descriptor, 0, 0,&io);
if (!error && io.size != size)
ntfs_error("wrong size in add_security\n");
if (error) {
ntfs_free(buf);
return error;
}
/* FIXME: Consider ACL inheritance. */
error = ntfs_create_attr(ino, ino->vol->at_security_descriptor,
0, buf, size, &se);
ntfs_free(buf);
return error;
}
static int add_data(ntfs_inode* ino, unsigned char *data, int length)
{
ntfs_attribute *da;
return ntfs_create_attr(ino, ino->vol->at_data, 0, data, length, &da);
}
/*
* We _could_ use 'dir' to help optimise inode allocation.
*
* FIXME: Need to undo what we do in ntfs_alloc_mft_record if we get an error
* further on in ntfs_alloc_inode. Either fold the two functions to allow
* proper undo or just deallocate the record from the mft bitmap. (AIA)
*/
int ntfs_alloc_inode(ntfs_inode *dir, ntfs_inode *result, const char *filename,
int namelen, ntfs_u32 flags)
{
ntfs_volume *vol = dir->vol;
int err;
ntfs_u8 buffer[2];
ntfs_io io;
err = ntfs_alloc_mft_record(vol, &(result->i_number));
if (err) {
if (err == -ENOSPC)
ntfs_error(__FUNCTION__ "(): No free inodes.\n");
return err;
}
/* Get the sequence number. */
io.fn_put = ntfs_put;
io.fn_get = ntfs_get;
io.param = buffer;
io.size = 2;
err = ntfs_read_attr(vol->mft_ino, vol->at_data, 0,
((__s64)result->i_number << vol->mft_record_size_bits)
+ 0x10, &io);
// FIXME: We are leaving the MFT in inconsistent state! (AIA)
if (err)
return err;
/* Increment the sequence number skipping zero. */
result->sequence_number = (NTFS_GETU16(buffer) + 1) & 0xffff;
if (!result->sequence_number)
result->sequence_number++;
result->vol = vol;
result->attr_count = 0;
result->attrs = 0;
result->record_count = 1;
result->records = ntfs_calloc(8 * sizeof(int));
if (!result->records)
goto mem_err_out;
result->records[0] = result->i_number;
result->attr = ntfs_calloc(vol->mft_record_size);
if (!result->attr) {
ntfs_free(result->records);
result->records = NULL;
goto mem_err_out;
}
ntfs_fill_mft_header(result->attr, vol->mft_record_size,
result->sequence_number, 1, 1);
err = add_standard_information(result);
if (!err)
err = add_filename(result, dir, filename, namelen, flags);
if (!err)
err = add_security(result, dir);
// FIXME: We are leaving the MFT in inconsistent state on error! (AIA)
return err;
mem_err_out:
// FIXME: We are leaving the MFT in inconsistent state! (AIA)
result->record_count = 0;
result->attr = NULL;
return -ENOMEM;
}
int ntfs_alloc_file(ntfs_inode *dir, ntfs_inode *result, char *filename,
int namelen)
{
int err;
err = ntfs_alloc_inode(dir, result, filename, namelen, 0);
if (!err)
err = add_data(result, 0, 0);
return err;
}
|