mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-11-19 17:59:16 +01:00
64f8406b07
*updated libntfs (write fix) *updated libfat *lots of changes in the startup code, removed almost everything. This might cause problems for some drives at loading the gamelist and needs to be adjusted later but better this time. more cleanup is needed in main.cpp and will come. *using libogc sd/usb for config loading and reload to cIOS afterwards *added missing boothomebrew stuff pune forgot NOTE: From now on we will be doing a lot of revs which we won't be compiling and releasing. This revs are officially not available for public so don't making issues regarding those revs. Those will be closed right away. We need first to cleanup a lot of crap and update loader to new standards before releasing stuff again.
2064 lines
48 KiB
C
2064 lines
48 KiB
C
/**
|
|
* index.c - NTFS index handling. Originated from the Linux-NTFS project.
|
|
*
|
|
* Copyright (c) 2004-2005 Anton Altaparmakov
|
|
* Copyright (c) 2004-2005 Richard Russon
|
|
* Copyright (c) 2005-2006 Yura Pakhuchiy
|
|
* Copyright (c) 2005-2008 Szabolcs Szakacsits
|
|
* Copyright (c) 2007 Jean-Pierre Andre
|
|
*
|
|
* This program/include file is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as published
|
|
* by the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program/include file is distributed in the hope that it will be
|
|
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program (in the main directory of the NTFS-3G
|
|
* distribution in the file COPYING); if not, write to the Free Software
|
|
* Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
#ifdef HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
#include "attrib.h"
|
|
#include "debug.h"
|
|
#include "index.h"
|
|
#include "collate.h"
|
|
#include "mst.h"
|
|
#include "dir.h"
|
|
#include "logging.h"
|
|
#include "bitmap.h"
|
|
#include "reparse.h"
|
|
#include "misc.h"
|
|
|
|
/**
|
|
* ntfs_index_entry_mark_dirty - mark an index entry dirty
|
|
* @ictx: ntfs index context describing the index entry
|
|
*
|
|
* Mark the index entry described by the index entry context @ictx dirty.
|
|
*
|
|
* If the index entry is in the index root attribute, simply mark the inode
|
|
* containing the index root attribute dirty. This ensures the mftrecord, and
|
|
* hence the index root attribute, will be written out to disk later.
|
|
*
|
|
* If the index entry is in an index block belonging to the index allocation
|
|
* attribute, set ib_dirty to TRUE, thus index block will be updated during
|
|
* ntfs_index_ctx_put.
|
|
*/
|
|
void ntfs_index_entry_mark_dirty(ntfs_index_context *ictx)
|
|
{
|
|
if (ictx->is_in_root)
|
|
ntfs_inode_mark_dirty(ictx->actx->ntfs_ino);
|
|
else
|
|
ictx->ib_dirty = TRUE;
|
|
}
|
|
|
|
static s64 ntfs_ib_vcn_to_pos(ntfs_index_context *icx, VCN vcn)
|
|
{
|
|
return vcn << icx->vcn_size_bits;
|
|
}
|
|
|
|
static VCN ntfs_ib_pos_to_vcn(ntfs_index_context *icx, s64 pos)
|
|
{
|
|
return pos >> icx->vcn_size_bits;
|
|
}
|
|
|
|
static int ntfs_ib_write(ntfs_index_context *icx, INDEX_BLOCK *ib)
|
|
{
|
|
s64 ret, vcn = sle64_to_cpu(ib->index_block_vcn);
|
|
|
|
ntfs_log_trace("vcn: %lld\n", (long long)vcn);
|
|
|
|
ret = ntfs_attr_mst_pwrite(icx->ia_na, ntfs_ib_vcn_to_pos(icx, vcn),
|
|
1, icx->block_size, ib);
|
|
if (ret != 1) {
|
|
ntfs_log_perror("Failed to write index block %lld, inode %llu",
|
|
(long long)vcn, (unsigned long long)icx->ni->mft_no);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static int ntfs_icx_ib_write(ntfs_index_context *icx)
|
|
{
|
|
if (ntfs_ib_write(icx, icx->ib))
|
|
return STATUS_ERROR;
|
|
|
|
icx->ib_dirty = FALSE;
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_ctx_get - allocate and initialize a new index context
|
|
* @ni: ntfs inode with which to initialize the context
|
|
* @name: name of the which context describes
|
|
* @name_len: length of the index name
|
|
*
|
|
* Allocate a new index context, initialize it with @ni and return it.
|
|
* Return NULL if allocation failed.
|
|
*/
|
|
ntfs_index_context *ntfs_index_ctx_get(ntfs_inode *ni,
|
|
ntfschar *name, u32 name_len)
|
|
{
|
|
ntfs_index_context *icx;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!ni) {
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
if (ni->nr_extents == -1)
|
|
ni = ni->base_ni;
|
|
icx = ntfs_calloc(sizeof(ntfs_index_context));
|
|
if (icx)
|
|
*icx = (ntfs_index_context) {
|
|
.ni = ni,
|
|
.name = name,
|
|
.name_len = name_len,
|
|
};
|
|
return icx;
|
|
}
|
|
|
|
static void ntfs_index_ctx_free(ntfs_index_context *icx)
|
|
{
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!icx->entry)
|
|
return;
|
|
|
|
if (icx->actx)
|
|
ntfs_attr_put_search_ctx(icx->actx);
|
|
|
|
if (!icx->is_in_root) {
|
|
if (icx->ib_dirty) {
|
|
/* FIXME: Error handling!!! */
|
|
ntfs_ib_write(icx, icx->ib);
|
|
}
|
|
free(icx->ib);
|
|
}
|
|
|
|
ntfs_attr_close(icx->ia_na);
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_ctx_put - release an index context
|
|
* @icx: index context to free
|
|
*
|
|
* Release the index context @icx, releasing all associated resources.
|
|
*/
|
|
void ntfs_index_ctx_put(ntfs_index_context *icx)
|
|
{
|
|
ntfs_index_ctx_free(icx);
|
|
free(icx);
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_ctx_reinit - reinitialize an index context
|
|
* @icx: index context to reinitialize
|
|
*
|
|
* Reinitialize the index context @icx so it can be used for ntfs_index_lookup.
|
|
*/
|
|
void ntfs_index_ctx_reinit(ntfs_index_context *icx)
|
|
{
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ntfs_index_ctx_free(icx);
|
|
|
|
*icx = (ntfs_index_context) {
|
|
.ni = icx->ni,
|
|
.name = icx->name,
|
|
.name_len = icx->name_len,
|
|
};
|
|
}
|
|
|
|
static VCN *ntfs_ie_get_vcn_addr(INDEX_ENTRY *ie)
|
|
{
|
|
return (VCN *)((u8 *)ie + le16_to_cpu(ie->length) - sizeof(VCN));
|
|
}
|
|
|
|
/**
|
|
* Get the subnode vcn to which the index entry refers.
|
|
*/
|
|
VCN ntfs_ie_get_vcn(INDEX_ENTRY *ie)
|
|
{
|
|
return sle64_to_cpup(ntfs_ie_get_vcn_addr(ie));
|
|
}
|
|
|
|
static INDEX_ENTRY *ntfs_ie_get_first(INDEX_HEADER *ih)
|
|
{
|
|
return (INDEX_ENTRY *)((u8 *)ih + le32_to_cpu(ih->entries_offset));
|
|
}
|
|
|
|
static INDEX_ENTRY *ntfs_ie_get_next(INDEX_ENTRY *ie)
|
|
{
|
|
return (INDEX_ENTRY *)((char *)ie + le16_to_cpu(ie->length));
|
|
}
|
|
|
|
static u8 *ntfs_ie_get_end(INDEX_HEADER *ih)
|
|
{
|
|
/* FIXME: check if it isn't overflowing the index block size */
|
|
return (u8 *)ih + le32_to_cpu(ih->index_length);
|
|
}
|
|
|
|
static int ntfs_ie_end(INDEX_ENTRY *ie)
|
|
{
|
|
return ie->ie_flags & INDEX_ENTRY_END || !ie->length;
|
|
}
|
|
|
|
/**
|
|
* Find the last entry in the index block
|
|
*/
|
|
static INDEX_ENTRY *ntfs_ie_get_last(INDEX_ENTRY *ie, char *ies_end)
|
|
{
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
while ((char *)ie < ies_end && !ntfs_ie_end(ie))
|
|
ie = ntfs_ie_get_next(ie);
|
|
|
|
return ie;
|
|
}
|
|
|
|
static INDEX_ENTRY *ntfs_ie_get_by_pos(INDEX_HEADER *ih, int pos)
|
|
{
|
|
INDEX_ENTRY *ie;
|
|
|
|
ntfs_log_trace("pos: %d\n", pos);
|
|
|
|
ie = ntfs_ie_get_first(ih);
|
|
|
|
while (pos-- > 0)
|
|
ie = ntfs_ie_get_next(ie);
|
|
|
|
return ie;
|
|
}
|
|
|
|
static INDEX_ENTRY *ntfs_ie_prev(INDEX_HEADER *ih, INDEX_ENTRY *ie)
|
|
{
|
|
INDEX_ENTRY *ie_prev = NULL;
|
|
INDEX_ENTRY *tmp;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
tmp = ntfs_ie_get_first(ih);
|
|
|
|
while (tmp != ie) {
|
|
ie_prev = tmp;
|
|
tmp = ntfs_ie_get_next(tmp);
|
|
}
|
|
|
|
return ie_prev;
|
|
}
|
|
|
|
char *ntfs_ie_filename_get(INDEX_ENTRY *ie)
|
|
{
|
|
FILE_NAME_ATTR *fn;
|
|
|
|
fn = (FILE_NAME_ATTR *)&ie->key;
|
|
return ntfs_attr_name_get(fn->file_name, fn->file_name_length);
|
|
}
|
|
|
|
void ntfs_ie_filename_dump(INDEX_ENTRY *ie)
|
|
{
|
|
char *s;
|
|
|
|
s = ntfs_ie_filename_get(ie);
|
|
ntfs_log_debug("'%s' ", s);
|
|
ntfs_attr_name_free(&s);
|
|
}
|
|
|
|
void ntfs_ih_filename_dump(INDEX_HEADER *ih)
|
|
{
|
|
INDEX_ENTRY *ie;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ie = ntfs_ie_get_first(ih);
|
|
while (!ntfs_ie_end(ie)) {
|
|
ntfs_ie_filename_dump(ie);
|
|
ie = ntfs_ie_get_next(ie);
|
|
}
|
|
}
|
|
|
|
static int ntfs_ih_numof_entries(INDEX_HEADER *ih)
|
|
{
|
|
int n;
|
|
INDEX_ENTRY *ie;
|
|
u8 *end;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
end = ntfs_ie_get_end(ih);
|
|
ie = ntfs_ie_get_first(ih);
|
|
for (n = 0; !ntfs_ie_end(ie) && (u8 *)ie < end; n++)
|
|
ie = ntfs_ie_get_next(ie);
|
|
return n;
|
|
}
|
|
|
|
static int ntfs_ih_one_entry(INDEX_HEADER *ih)
|
|
{
|
|
return (ntfs_ih_numof_entries(ih) == 1);
|
|
}
|
|
|
|
static int ntfs_ih_zero_entry(INDEX_HEADER *ih)
|
|
{
|
|
return (ntfs_ih_numof_entries(ih) == 0);
|
|
}
|
|
|
|
static void ntfs_ie_delete(INDEX_HEADER *ih, INDEX_ENTRY *ie)
|
|
{
|
|
u32 new_size;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
new_size = le32_to_cpu(ih->index_length) - le16_to_cpu(ie->length);
|
|
ih->index_length = cpu_to_le32(new_size);
|
|
memmove(ie, (u8 *)ie + le16_to_cpu(ie->length),
|
|
new_size - ((u8 *)ie - (u8 *)ih));
|
|
}
|
|
|
|
static void ntfs_ie_set_vcn(INDEX_ENTRY *ie, VCN vcn)
|
|
{
|
|
*ntfs_ie_get_vcn_addr(ie) = cpu_to_le64(vcn);
|
|
}
|
|
|
|
/**
|
|
* Insert @ie index entry at @pos entry. Used @ih values should be ok already.
|
|
*/
|
|
static void ntfs_ie_insert(INDEX_HEADER *ih, INDEX_ENTRY *ie, INDEX_ENTRY *pos)
|
|
{
|
|
int ie_size = le16_to_cpu(ie->length);
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ih->index_length = cpu_to_le32(le32_to_cpu(ih->index_length) + ie_size);
|
|
memmove((u8 *)pos + ie_size, pos,
|
|
le32_to_cpu(ih->index_length) - ((u8 *)pos - (u8 *)ih) - ie_size);
|
|
memcpy(pos, ie, ie_size);
|
|
}
|
|
|
|
static INDEX_ENTRY *ntfs_ie_dup(INDEX_ENTRY *ie)
|
|
{
|
|
INDEX_ENTRY *dup;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
dup = ntfs_malloc(le16_to_cpu(ie->length));
|
|
if (dup)
|
|
memcpy(dup, ie, le16_to_cpu(ie->length));
|
|
|
|
return dup;
|
|
}
|
|
|
|
static INDEX_ENTRY *ntfs_ie_dup_novcn(INDEX_ENTRY *ie)
|
|
{
|
|
INDEX_ENTRY *dup;
|
|
int size = le16_to_cpu(ie->length);
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (ie->ie_flags & INDEX_ENTRY_NODE)
|
|
size -= sizeof(VCN);
|
|
|
|
dup = ntfs_malloc(size);
|
|
if (dup) {
|
|
memcpy(dup, ie, size);
|
|
dup->ie_flags &= ~INDEX_ENTRY_NODE;
|
|
dup->length = cpu_to_le16(size);
|
|
}
|
|
return dup;
|
|
}
|
|
|
|
static int ntfs_ia_check(ntfs_index_context *icx, INDEX_BLOCK *ib, VCN vcn)
|
|
{
|
|
u32 ib_size = (unsigned)le32_to_cpu(ib->index.allocated_size) + 0x18;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!ntfs_is_indx_record(ib->magic)) {
|
|
|
|
ntfs_log_error("Corrupt index block signature: vcn %lld inode "
|
|
"%llu\n", (long long)vcn,
|
|
(unsigned long long)icx->ni->mft_no);
|
|
return -1;
|
|
}
|
|
|
|
if (sle64_to_cpu(ib->index_block_vcn) != vcn) {
|
|
|
|
ntfs_log_error("Corrupt index block: VCN (%lld) is different "
|
|
"from expected VCN (%lld) in inode %llu\n",
|
|
(long long)sle64_to_cpu(ib->index_block_vcn),
|
|
(long long)vcn,
|
|
(unsigned long long)icx->ni->mft_no);
|
|
return -1;
|
|
}
|
|
|
|
if (ib_size != icx->block_size) {
|
|
|
|
ntfs_log_error("Corrupt index block : VCN (%lld) of inode %llu "
|
|
"has a size (%u) differing from the index "
|
|
"specified size (%u)\n", (long long)vcn,
|
|
(unsigned long long)icx->ni->mft_no, ib_size,
|
|
icx->block_size);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static INDEX_ROOT *ntfs_ir_lookup(ntfs_inode *ni, ntfschar *name,
|
|
u32 name_len, ntfs_attr_search_ctx **ctx)
|
|
{
|
|
ATTR_RECORD *a;
|
|
INDEX_ROOT *ir = NULL;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
*ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
|
if (!*ctx)
|
|
return NULL;
|
|
|
|
if (ntfs_attr_lookup(AT_INDEX_ROOT, name, name_len, CASE_SENSITIVE,
|
|
0, NULL, 0, *ctx)) {
|
|
ntfs_log_perror("Failed to lookup $INDEX_ROOT");
|
|
goto err_out;
|
|
}
|
|
|
|
a = (*ctx)->attr;
|
|
if (a->non_resident) {
|
|
errno = EINVAL;
|
|
ntfs_log_perror("Non-resident $INDEX_ROOT detected");
|
|
goto err_out;
|
|
}
|
|
|
|
ir = (INDEX_ROOT *)((char *)a + le16_to_cpu(a->value_offset));
|
|
err_out:
|
|
if (!ir) {
|
|
ntfs_attr_put_search_ctx(*ctx);
|
|
*ctx = NULL;
|
|
}
|
|
return ir;
|
|
}
|
|
|
|
static INDEX_ROOT *ntfs_ir_lookup2(ntfs_inode *ni, ntfschar *name, u32 len)
|
|
{
|
|
ntfs_attr_search_ctx *ctx;
|
|
INDEX_ROOT *ir;
|
|
|
|
ir = ntfs_ir_lookup(ni, name, len, &ctx);
|
|
if (ir)
|
|
ntfs_attr_put_search_ctx(ctx);
|
|
return ir;
|
|
}
|
|
|
|
/**
|
|
* Find a key in the index block.
|
|
*
|
|
* Return values:
|
|
* STATUS_OK with errno set to ESUCCESS if we know for sure that the
|
|
* entry exists and @ie_out points to this entry.
|
|
* STATUS_NOT_FOUND with errno set to ENOENT if we know for sure the
|
|
* entry doesn't exist and @ie_out is the insertion point.
|
|
* STATUS_KEEP_SEARCHING if we can't answer the above question and
|
|
* @vcn will contain the node index block.
|
|
* STATUS_ERROR with errno set if on unexpected error during lookup.
|
|
*/
|
|
static int ntfs_ie_lookup(const void *key, const int key_len,
|
|
ntfs_index_context *icx, INDEX_HEADER *ih,
|
|
VCN *vcn, INDEX_ENTRY **ie_out)
|
|
{
|
|
INDEX_ENTRY *ie;
|
|
u8 *index_end;
|
|
int rc, item = 0;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
index_end = ntfs_ie_get_end(ih);
|
|
|
|
/*
|
|
* Loop until we exceed valid memory (corruption case) or until we
|
|
* reach the last entry.
|
|
*/
|
|
for (ie = ntfs_ie_get_first(ih); ; ie = ntfs_ie_get_next(ie)) {
|
|
/* Bounds checks. */
|
|
if ((u8 *)ie + sizeof(INDEX_ENTRY_HEADER) > index_end ||
|
|
(u8 *)ie + le16_to_cpu(ie->length) > index_end) {
|
|
errno = ERANGE;
|
|
ntfs_log_error("Index entry out of bounds in inode "
|
|
"%llu.\n",
|
|
(unsigned long long)icx->ni->mft_no);
|
|
return STATUS_ERROR;
|
|
}
|
|
/*
|
|
* The last entry cannot contain a key. It can however contain
|
|
* a pointer to a child node in the B+tree so we just break out.
|
|
*/
|
|
if (ntfs_ie_end(ie))
|
|
break;
|
|
/*
|
|
* Not a perfect match, need to do full blown collation so we
|
|
* know which way in the B+tree we have to go.
|
|
*/
|
|
if (!icx->collate) {
|
|
ntfs_log_error("Collation function not defined\n");
|
|
errno = EOPNOTSUPP;
|
|
return STATUS_ERROR;
|
|
}
|
|
rc = icx->collate(icx->ni->vol, key, key_len,
|
|
&ie->key, le16_to_cpu(ie->key_length));
|
|
if (rc == NTFS_COLLATION_ERROR) {
|
|
ntfs_log_error("Collation error. Perhaps a filename "
|
|
"contains invalid characters?\n");
|
|
errno = ERANGE;
|
|
return STATUS_ERROR;
|
|
}
|
|
/*
|
|
* If @key collates before the key of the current entry, there
|
|
* is definitely no such key in this index but we might need to
|
|
* descend into the B+tree so we just break out of the loop.
|
|
*/
|
|
if (rc == -1)
|
|
break;
|
|
|
|
if (!rc) {
|
|
*ie_out = ie;
|
|
errno = 0;
|
|
icx->parent_pos[icx->pindex] = item;
|
|
return STATUS_OK;
|
|
}
|
|
|
|
item++;
|
|
}
|
|
/*
|
|
* We have finished with this index block without success. Check for the
|
|
* presence of a child node and if not present return with errno ENOENT,
|
|
* otherwise we will keep searching in another index block.
|
|
*/
|
|
if (!(ie->ie_flags & INDEX_ENTRY_NODE)) {
|
|
ntfs_log_debug("Index entry wasn't found.\n");
|
|
*ie_out = ie;
|
|
errno = ENOENT;
|
|
return STATUS_NOT_FOUND;
|
|
}
|
|
|
|
/* Get the starting vcn of the index_block holding the child node. */
|
|
*vcn = ntfs_ie_get_vcn(ie);
|
|
if (*vcn < 0) {
|
|
errno = EINVAL;
|
|
ntfs_log_perror("Negative vcn in inode %llu",
|
|
(unsigned long long)icx->ni->mft_no);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
ntfs_log_trace("Parent entry number %d\n", item);
|
|
icx->parent_pos[icx->pindex] = item;
|
|
|
|
return STATUS_KEEP_SEARCHING;
|
|
}
|
|
|
|
static ntfs_attr *ntfs_ia_open(ntfs_index_context *icx, ntfs_inode *ni)
|
|
{
|
|
ntfs_attr *na;
|
|
|
|
na = ntfs_attr_open(ni, AT_INDEX_ALLOCATION, icx->name, icx->name_len);
|
|
if (!na) {
|
|
ntfs_log_perror("Failed to open index allocation of inode "
|
|
"%llu", (unsigned long long)ni->mft_no);
|
|
return NULL;
|
|
}
|
|
|
|
return na;
|
|
}
|
|
|
|
static int ntfs_ib_read(ntfs_index_context *icx, VCN vcn, INDEX_BLOCK *dst)
|
|
{
|
|
s64 pos, ret;
|
|
|
|
ntfs_log_trace("vcn: %lld\n", (long long)vcn);
|
|
|
|
pos = ntfs_ib_vcn_to_pos(icx, vcn);
|
|
|
|
ret = ntfs_attr_mst_pread(icx->ia_na, pos, 1, icx->block_size, (u8 *)dst);
|
|
if (ret != 1) {
|
|
if (ret == -1)
|
|
ntfs_log_perror("Failed to read index block");
|
|
else
|
|
ntfs_log_error("Failed to read full index block at "
|
|
"%lld\n", (long long)pos);
|
|
return -1;
|
|
}
|
|
|
|
if (ntfs_ia_check(icx, dst, vcn))
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ntfs_icx_parent_inc(ntfs_index_context *icx)
|
|
{
|
|
icx->pindex++;
|
|
if (icx->pindex >= MAX_PARENT_VCN) {
|
|
errno = EOPNOTSUPP;
|
|
ntfs_log_perror("Index is over %d level deep", MAX_PARENT_VCN);
|
|
return STATUS_ERROR;
|
|
}
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static int ntfs_icx_parent_dec(ntfs_index_context *icx)
|
|
{
|
|
icx->pindex--;
|
|
if (icx->pindex < 0) {
|
|
errno = EINVAL;
|
|
ntfs_log_perror("Corrupt index pointer (%d)", icx->pindex);
|
|
return STATUS_ERROR;
|
|
}
|
|
return STATUS_OK;
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_lookup - find a key in an index and return its index entry
|
|
* @key: [IN] key for which to search in the index
|
|
* @key_len: [IN] length of @key in bytes
|
|
* @icx: [IN/OUT] context describing the index and the returned entry
|
|
*
|
|
* Before calling ntfs_index_lookup(), @icx must have been obtained from a
|
|
* call to ntfs_index_ctx_get().
|
|
*
|
|
* Look for the @key in the index specified by the index lookup context @icx.
|
|
* ntfs_index_lookup() walks the contents of the index looking for the @key.
|
|
*
|
|
* If the @key is found in the index, 0 is returned and @icx is setup to
|
|
* describe the index entry containing the matching @key. @icx->entry is the
|
|
* index entry and @icx->data and @icx->data_len are the index entry data and
|
|
* its length in bytes, respectively.
|
|
*
|
|
* If the @key is not found in the index, -1 is returned, errno = ENOENT and
|
|
* @icx is setup to describe the index entry whose key collates immediately
|
|
* after the search @key, i.e. this is the position in the index at which
|
|
* an index entry with a key of @key would need to be inserted.
|
|
*
|
|
* If an error occurs return -1, set errno to error code and @icx is left
|
|
* untouched.
|
|
*
|
|
* When finished with the entry and its data, call ntfs_index_ctx_put() to free
|
|
* the context and other associated resources.
|
|
*
|
|
* If the index entry was modified, call ntfs_index_entry_mark_dirty() before
|
|
* the call to ntfs_index_ctx_put() to ensure that the changes are written
|
|
* to disk.
|
|
*/
|
|
int ntfs_index_lookup(const void *key, const int key_len, ntfs_index_context *icx)
|
|
{
|
|
VCN old_vcn, vcn;
|
|
ntfs_inode *ni = icx->ni;
|
|
INDEX_ROOT *ir;
|
|
INDEX_ENTRY *ie;
|
|
INDEX_BLOCK *ib = NULL;
|
|
int ret, err = 0;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!key || key_len <= 0) {
|
|
errno = EINVAL;
|
|
ntfs_log_perror("key: %p key_len: %d", key, key_len);
|
|
return -1;
|
|
}
|
|
|
|
ir = ntfs_ir_lookup(ni, icx->name, icx->name_len, &icx->actx);
|
|
if (!ir) {
|
|
if (errno == ENOENT)
|
|
errno = EIO;
|
|
return -1;
|
|
}
|
|
|
|
icx->block_size = le32_to_cpu(ir->index_block_size);
|
|
if (icx->block_size < NTFS_BLOCK_SIZE) {
|
|
errno = EINVAL;
|
|
ntfs_log_perror("Index block size (%d) is smaller than the "
|
|
"sector size (%d)", icx->block_size, NTFS_BLOCK_SIZE);
|
|
goto err_out;
|
|
}
|
|
|
|
if (ni->vol->cluster_size <= icx->block_size)
|
|
icx->vcn_size_bits = ni->vol->cluster_size_bits;
|
|
else
|
|
icx->vcn_size_bits = ni->vol->sector_size_bits;
|
|
/* get the appropriate collation function */
|
|
icx->collate = ntfs_get_collate_function(ir->collation_rule);
|
|
if (!icx->collate) {
|
|
err = errno = EOPNOTSUPP;
|
|
ntfs_log_perror("Unknown collation rule 0x%x",
|
|
(unsigned)le32_to_cpu(ir->collation_rule));
|
|
goto err_out;
|
|
}
|
|
|
|
old_vcn = VCN_INDEX_ROOT_PARENT;
|
|
/*
|
|
* FIXME: check for both ir and ib that the first index entry is
|
|
* within the index block.
|
|
*/
|
|
ret = ntfs_ie_lookup(key, key_len, icx, &ir->index, &vcn, &ie);
|
|
if (ret == STATUS_ERROR) {
|
|
err = errno;
|
|
goto err_out;
|
|
}
|
|
|
|
icx->ir = ir;
|
|
|
|
if (ret != STATUS_KEEP_SEARCHING) {
|
|
/* STATUS_OK or STATUS_NOT_FOUND */
|
|
err = errno;
|
|
icx->is_in_root = TRUE;
|
|
icx->parent_vcn[icx->pindex] = old_vcn;
|
|
goto done;
|
|
}
|
|
|
|
/* Child node present, descend into it. */
|
|
|
|
icx->ia_na = ntfs_ia_open(icx, ni);
|
|
if (!icx->ia_na)
|
|
goto err_out;
|
|
|
|
ib = ntfs_malloc(icx->block_size);
|
|
if (!ib) {
|
|
err = errno;
|
|
goto err_out;
|
|
}
|
|
|
|
descend_into_child_node:
|
|
|
|
icx->parent_vcn[icx->pindex] = old_vcn;
|
|
if (ntfs_icx_parent_inc(icx)) {
|
|
err = errno;
|
|
goto err_out;
|
|
}
|
|
old_vcn = vcn;
|
|
|
|
ntfs_log_debug("Descend into node with VCN %lld\n", (long long)vcn);
|
|
|
|
if (ntfs_ib_read(icx, vcn, ib))
|
|
goto err_out;
|
|
|
|
ret = ntfs_ie_lookup(key, key_len, icx, &ib->index, &vcn, &ie);
|
|
if (ret != STATUS_KEEP_SEARCHING) {
|
|
err = errno;
|
|
if (ret == STATUS_ERROR)
|
|
goto err_out;
|
|
|
|
/* STATUS_OK or STATUS_NOT_FOUND */
|
|
icx->is_in_root = FALSE;
|
|
icx->ib = ib;
|
|
icx->parent_vcn[icx->pindex] = vcn;
|
|
goto done;
|
|
}
|
|
|
|
if ((ib->index.ih_flags & NODE_MASK) == LEAF_NODE) {
|
|
ntfs_log_error("Index entry with child node found in a leaf "
|
|
"node in inode 0x%llx.\n",
|
|
(unsigned long long)ni->mft_no);
|
|
goto err_out;
|
|
}
|
|
|
|
goto descend_into_child_node;
|
|
err_out:
|
|
free(ib);
|
|
if (!err)
|
|
err = EIO;
|
|
errno = err;
|
|
return -1;
|
|
done:
|
|
icx->entry = ie;
|
|
icx->data = (u8 *)ie + offsetof(INDEX_ENTRY, key);
|
|
icx->data_len = le16_to_cpu(ie->key_length);
|
|
ntfs_log_trace("Done.\n");
|
|
if (err) {
|
|
errno = err;
|
|
return -1;
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
static INDEX_BLOCK *ntfs_ib_alloc(VCN ib_vcn, u32 ib_size,
|
|
INDEX_HEADER_FLAGS node_type)
|
|
{
|
|
INDEX_BLOCK *ib;
|
|
int ih_size = sizeof(INDEX_HEADER);
|
|
|
|
ntfs_log_trace("ib_vcn: %lld ib_size: %u\n", (long long)ib_vcn, ib_size);
|
|
|
|
ib = ntfs_calloc(ib_size);
|
|
if (!ib)
|
|
return NULL;
|
|
|
|
ib->magic = magic_INDX;
|
|
ib->usa_ofs = cpu_to_le16(sizeof(INDEX_BLOCK));
|
|
ib->usa_count = cpu_to_le16(ib_size / NTFS_BLOCK_SIZE + 1);
|
|
/* Set USN to 1 */
|
|
*(u16 *)((char *)ib + le16_to_cpu(ib->usa_ofs)) = cpu_to_le16(1);
|
|
ib->lsn = cpu_to_le64(0);
|
|
|
|
ib->index_block_vcn = cpu_to_sle64(ib_vcn);
|
|
|
|
ib->index.entries_offset = cpu_to_le32((ih_size +
|
|
le16_to_cpu(ib->usa_count) * 2 + 7) & ~7);
|
|
ib->index.index_length = 0;
|
|
ib->index.allocated_size = cpu_to_le32(ib_size -
|
|
(sizeof(INDEX_BLOCK) - ih_size));
|
|
ib->index.ih_flags = node_type;
|
|
|
|
return ib;
|
|
}
|
|
|
|
/**
|
|
* Find the median by going through all the entries
|
|
*/
|
|
static INDEX_ENTRY *ntfs_ie_get_median(INDEX_HEADER *ih)
|
|
{
|
|
INDEX_ENTRY *ie, *ie_start;
|
|
u8 *ie_end;
|
|
int i = 0, median;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ie = ie_start = ntfs_ie_get_first(ih);
|
|
ie_end = (u8 *)ntfs_ie_get_end(ih);
|
|
|
|
while ((u8 *)ie < ie_end && !ntfs_ie_end(ie)) {
|
|
ie = ntfs_ie_get_next(ie);
|
|
i++;
|
|
}
|
|
/*
|
|
* NOTE: this could be also the entry at the half of the index block.
|
|
*/
|
|
median = i / 2 - 1;
|
|
|
|
ntfs_log_trace("Entries: %d median: %d\n", i, median);
|
|
|
|
for (i = 0, ie = ie_start; i <= median; i++)
|
|
ie = ntfs_ie_get_next(ie);
|
|
|
|
return ie;
|
|
}
|
|
|
|
static s64 ntfs_ibm_vcn_to_pos(ntfs_index_context *icx, VCN vcn)
|
|
{
|
|
return ntfs_ib_vcn_to_pos(icx, vcn) / icx->block_size;
|
|
}
|
|
|
|
static s64 ntfs_ibm_pos_to_vcn(ntfs_index_context *icx, s64 pos)
|
|
{
|
|
return ntfs_ib_pos_to_vcn(icx, pos * icx->block_size);
|
|
}
|
|
|
|
static int ntfs_ibm_add(ntfs_index_context *icx)
|
|
{
|
|
u8 bmp[8];
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (ntfs_attr_exist(icx->ni, AT_BITMAP, icx->name, icx->name_len))
|
|
return STATUS_OK;
|
|
/*
|
|
* AT_BITMAP must be at least 8 bytes.
|
|
*/
|
|
memset(bmp, 0, sizeof(bmp));
|
|
if (ntfs_attr_add(icx->ni, AT_BITMAP, icx->name, icx->name_len,
|
|
bmp, sizeof(bmp))) {
|
|
ntfs_log_perror("Failed to add AT_BITMAP");
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static int ntfs_ibm_modify(ntfs_index_context *icx, VCN vcn, int set)
|
|
{
|
|
u8 byte;
|
|
s64 pos = ntfs_ibm_vcn_to_pos(icx, vcn);
|
|
u32 bpos = pos / 8;
|
|
u32 bit = 1 << (pos % 8);
|
|
ntfs_attr *na;
|
|
int ret = STATUS_ERROR;
|
|
|
|
ntfs_log_trace("%s vcn: %lld\n", set ? "set" : "clear", (long long)vcn);
|
|
|
|
na = ntfs_attr_open(icx->ni, AT_BITMAP, icx->name, icx->name_len);
|
|
if (!na) {
|
|
ntfs_log_perror("Failed to open $BITMAP attribute");
|
|
return -1;
|
|
}
|
|
|
|
if (set) {
|
|
if (na->data_size < bpos + 1) {
|
|
if (ntfs_attr_truncate(na, (na->data_size + 8) & ~7)) {
|
|
ntfs_log_perror("Failed to truncate AT_BITMAP");
|
|
goto err_na;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ntfs_attr_pread(na, bpos, 1, &byte) != 1) {
|
|
ntfs_log_perror("Failed to read $BITMAP");
|
|
goto err_na;
|
|
}
|
|
|
|
if (set)
|
|
byte |= bit;
|
|
else
|
|
byte &= ~bit;
|
|
|
|
if (ntfs_attr_pwrite(na, bpos, 1, &byte) != 1) {
|
|
ntfs_log_perror("Failed to write $Bitmap");
|
|
goto err_na;
|
|
}
|
|
|
|
ret = STATUS_OK;
|
|
err_na:
|
|
ntfs_attr_close(na);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int ntfs_ibm_set(ntfs_index_context *icx, VCN vcn)
|
|
{
|
|
return ntfs_ibm_modify(icx, vcn, 1);
|
|
}
|
|
|
|
static int ntfs_ibm_clear(ntfs_index_context *icx, VCN vcn)
|
|
{
|
|
return ntfs_ibm_modify(icx, vcn, 0);
|
|
}
|
|
|
|
static VCN ntfs_ibm_get_free(ntfs_index_context *icx)
|
|
{
|
|
u8 *bm;
|
|
int bit;
|
|
s64 vcn, byte, size;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
bm = ntfs_attr_readall(icx->ni, AT_BITMAP, icx->name, icx->name_len,
|
|
&size);
|
|
if (!bm)
|
|
return (VCN)-1;
|
|
|
|
for (byte = 0; byte < size; byte++) {
|
|
|
|
if (bm[byte] == 255)
|
|
continue;
|
|
|
|
for (bit = 0; bit < 8; bit++) {
|
|
if (!(bm[byte] & (1 << bit))) {
|
|
vcn = ntfs_ibm_pos_to_vcn(icx, byte * 8 + bit);
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
|
|
vcn = ntfs_ibm_pos_to_vcn(icx, size * 8);
|
|
out:
|
|
ntfs_log_trace("allocated vcn: %lld\n", (long long)vcn);
|
|
|
|
if (ntfs_ibm_set(icx, vcn))
|
|
vcn = (VCN)-1;
|
|
|
|
free(bm);
|
|
return vcn;
|
|
}
|
|
|
|
static INDEX_BLOCK *ntfs_ir_to_ib(INDEX_ROOT *ir, VCN ib_vcn)
|
|
{
|
|
INDEX_BLOCK *ib;
|
|
INDEX_ENTRY *ie_last;
|
|
char *ies_start, *ies_end;
|
|
int i;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ib = ntfs_ib_alloc(ib_vcn, le32_to_cpu(ir->index_block_size), LEAF_NODE);
|
|
if (!ib)
|
|
return NULL;
|
|
|
|
ies_start = (char *)ntfs_ie_get_first(&ir->index);
|
|
ies_end = (char *)ntfs_ie_get_end(&ir->index);
|
|
ie_last = ntfs_ie_get_last((INDEX_ENTRY *)ies_start, ies_end);
|
|
/*
|
|
* Copy all entries, including the termination entry
|
|
* as well, which can never have any data.
|
|
*/
|
|
i = (char *)ie_last - ies_start + le16_to_cpu(ie_last->length);
|
|
memcpy(ntfs_ie_get_first(&ib->index), ies_start, i);
|
|
|
|
ib->index.ih_flags = ir->index.ih_flags;
|
|
ib->index.index_length = cpu_to_le32(i +
|
|
le32_to_cpu(ib->index.entries_offset));
|
|
return ib;
|
|
}
|
|
|
|
static void ntfs_ir_nill(INDEX_ROOT *ir)
|
|
{
|
|
INDEX_ENTRY *ie_last;
|
|
char *ies_start, *ies_end;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
/*
|
|
* TODO: This function could be much simpler.
|
|
*/
|
|
ies_start = (char *)ntfs_ie_get_first(&ir->index);
|
|
ies_end = (char *)ntfs_ie_get_end(&ir->index);
|
|
ie_last = ntfs_ie_get_last((INDEX_ENTRY *)ies_start, ies_end);
|
|
/*
|
|
* Move the index root termination entry forward
|
|
*/
|
|
if ((char *)ie_last > ies_start) {
|
|
memmove(ies_start, (char *)ie_last, le16_to_cpu(ie_last->length));
|
|
ie_last = (INDEX_ENTRY *)ies_start;
|
|
}
|
|
}
|
|
|
|
static int ntfs_ib_copy_tail(ntfs_index_context *icx, INDEX_BLOCK *src,
|
|
INDEX_ENTRY *median, VCN new_vcn)
|
|
{
|
|
u8 *ies_end;
|
|
INDEX_ENTRY *ie_head; /* first entry after the median */
|
|
int tail_size, ret;
|
|
INDEX_BLOCK *dst;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
dst = ntfs_ib_alloc(new_vcn, icx->block_size,
|
|
src->index.ih_flags & NODE_MASK);
|
|
if (!dst)
|
|
return STATUS_ERROR;
|
|
|
|
ie_head = ntfs_ie_get_next(median);
|
|
|
|
ies_end = (u8 *)ntfs_ie_get_end(&src->index);
|
|
tail_size = ies_end - (u8 *)ie_head;
|
|
memcpy(ntfs_ie_get_first(&dst->index), ie_head, tail_size);
|
|
|
|
dst->index.index_length = cpu_to_le32(tail_size +
|
|
le32_to_cpu(dst->index.entries_offset));
|
|
ret = ntfs_ib_write(icx, dst);
|
|
|
|
free(dst);
|
|
return ret;
|
|
}
|
|
|
|
static int ntfs_ib_cut_tail(ntfs_index_context *icx, INDEX_BLOCK *ib,
|
|
INDEX_ENTRY *ie)
|
|
{
|
|
char *ies_start, *ies_end;
|
|
INDEX_ENTRY *ie_last;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ies_start = (char *)ntfs_ie_get_first(&ib->index);
|
|
ies_end = (char *)ntfs_ie_get_end(&ib->index);
|
|
|
|
ie_last = ntfs_ie_get_last((INDEX_ENTRY *)ies_start, ies_end);
|
|
if (ie_last->ie_flags & INDEX_ENTRY_NODE)
|
|
ntfs_ie_set_vcn(ie_last, ntfs_ie_get_vcn(ie));
|
|
|
|
memcpy(ie, ie_last, le16_to_cpu(ie_last->length));
|
|
|
|
ib->index.index_length = cpu_to_le32(((char *)ie - ies_start) +
|
|
le16_to_cpu(ie->length) + le32_to_cpu(ib->index.entries_offset));
|
|
|
|
if (ntfs_ib_write(icx, ib))
|
|
return STATUS_ERROR;
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static int ntfs_ia_add(ntfs_index_context *icx)
|
|
{
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (ntfs_ibm_add(icx))
|
|
return -1;
|
|
|
|
if (!ntfs_attr_exist(icx->ni, AT_INDEX_ALLOCATION, icx->name, icx->name_len)) {
|
|
|
|
if (ntfs_attr_add(icx->ni, AT_INDEX_ALLOCATION, icx->name,
|
|
icx->name_len, NULL, 0)) {
|
|
ntfs_log_perror("Failed to add AT_INDEX_ALLOCATION");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
icx->ia_na = ntfs_ia_open(icx, icx->ni);
|
|
if (!icx->ia_na)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ntfs_ir_reparent(ntfs_index_context *icx)
|
|
{
|
|
ntfs_attr_search_ctx *ctx = NULL;
|
|
INDEX_ROOT *ir;
|
|
INDEX_ENTRY *ie;
|
|
INDEX_BLOCK *ib = NULL;
|
|
VCN new_ib_vcn;
|
|
int ret = STATUS_ERROR;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ir = ntfs_ir_lookup2(icx->ni, icx->name, icx->name_len);
|
|
if (!ir)
|
|
goto out;
|
|
|
|
if ((ir->index.ih_flags & NODE_MASK) == SMALL_INDEX)
|
|
if (ntfs_ia_add(icx))
|
|
goto out;
|
|
|
|
new_ib_vcn = ntfs_ibm_get_free(icx);
|
|
if (new_ib_vcn == -1)
|
|
goto out;
|
|
|
|
ir = ntfs_ir_lookup2(icx->ni, icx->name, icx->name_len);
|
|
if (!ir)
|
|
goto clear_bmp;
|
|
|
|
ib = ntfs_ir_to_ib(ir, new_ib_vcn);
|
|
if (ib == NULL) {
|
|
ntfs_log_perror("Failed to move index root to index block");
|
|
goto clear_bmp;
|
|
}
|
|
|
|
if (ntfs_ib_write(icx, ib))
|
|
goto clear_bmp;
|
|
|
|
ir = ntfs_ir_lookup(icx->ni, icx->name, icx->name_len, &ctx);
|
|
if (!ir)
|
|
goto clear_bmp;
|
|
|
|
ntfs_ir_nill(ir);
|
|
|
|
ie = ntfs_ie_get_first(&ir->index);
|
|
ie->ie_flags |= INDEX_ENTRY_NODE;
|
|
ie->length = cpu_to_le16(sizeof(INDEX_ENTRY_HEADER) + sizeof(VCN));
|
|
|
|
ir->index.ih_flags = LARGE_INDEX;
|
|
ir->index.index_length = cpu_to_le32(le32_to_cpu(ir->index.entries_offset)
|
|
+ le16_to_cpu(ie->length));
|
|
ir->index.allocated_size = ir->index.index_length;
|
|
|
|
if (ntfs_resident_attr_value_resize(ctx->mrec, ctx->attr,
|
|
sizeof(INDEX_ROOT) - sizeof(INDEX_HEADER) +
|
|
le32_to_cpu(ir->index.allocated_size)))
|
|
/* FIXME: revert index root */
|
|
goto clear_bmp;
|
|
/*
|
|
* FIXME: do it earlier if we have enough space in IR (should always),
|
|
* so in error case we wouldn't lose the IB.
|
|
*/
|
|
ntfs_ie_set_vcn(ie, new_ib_vcn);
|
|
|
|
ret = STATUS_OK;
|
|
err_out:
|
|
free(ib);
|
|
ntfs_attr_put_search_ctx(ctx);
|
|
out:
|
|
return ret;
|
|
clear_bmp:
|
|
ntfs_ibm_clear(icx, new_ib_vcn);
|
|
goto err_out;
|
|
}
|
|
|
|
/**
|
|
* ntfs_ir_truncate - Truncate index root attribute
|
|
*
|
|
* Returns STATUS_OK, STATUS_RESIDENT_ATTRIBUTE_FILLED_MFT or STATUS_ERROR.
|
|
*/
|
|
static int ntfs_ir_truncate(ntfs_index_context *icx, int data_size)
|
|
{
|
|
ntfs_attr *na;
|
|
int ret;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
na = ntfs_attr_open(icx->ni, AT_INDEX_ROOT, icx->name, icx->name_len);
|
|
if (!na) {
|
|
ntfs_log_perror("Failed to open INDEX_ROOT");
|
|
return STATUS_ERROR;
|
|
}
|
|
/*
|
|
* INDEX_ROOT must be resident and its entries can be moved to
|
|
* INDEX_BLOCK, so ENOSPC isn't a real error.
|
|
*/
|
|
ret = ntfs_attr_truncate(na, data_size + offsetof(INDEX_ROOT, index));
|
|
if (ret == STATUS_OK) {
|
|
|
|
icx->ir = ntfs_ir_lookup2(icx->ni, icx->name, icx->name_len);
|
|
if (!icx->ir)
|
|
return STATUS_ERROR;
|
|
|
|
icx->ir->index.allocated_size = cpu_to_le32(data_size);
|
|
|
|
} else if (ret == STATUS_ERROR)
|
|
ntfs_log_perror("Failed to truncate INDEX_ROOT");
|
|
|
|
ntfs_attr_close(na);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ntfs_ir_make_space - Make more space for the index root attribute
|
|
*
|
|
* On success return STATUS_OK or STATUS_KEEP_SEARCHING.
|
|
* On error return STATUS_ERROR.
|
|
*/
|
|
static int ntfs_ir_make_space(ntfs_index_context *icx, int data_size)
|
|
{
|
|
int ret;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ret = ntfs_ir_truncate(icx, data_size);
|
|
if (ret == STATUS_RESIDENT_ATTRIBUTE_FILLED_MFT) {
|
|
|
|
ret = ntfs_ir_reparent(icx);
|
|
if (ret == STATUS_OK)
|
|
ret = STATUS_KEEP_SEARCHING;
|
|
else
|
|
ntfs_log_perror("Failed to nodify INDEX_ROOT");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* NOTE: 'ie' must be a copy of a real index entry.
|
|
*/
|
|
static int ntfs_ie_add_vcn(INDEX_ENTRY **ie)
|
|
{
|
|
INDEX_ENTRY *p, *old = *ie;
|
|
|
|
old->length = cpu_to_le16(le16_to_cpu(old->length) + sizeof(VCN));
|
|
p = realloc(old, le16_to_cpu(old->length));
|
|
if (!p)
|
|
return STATUS_ERROR;
|
|
|
|
p->ie_flags |= INDEX_ENTRY_NODE;
|
|
*ie = p;
|
|
|
|
return STATUS_OK;
|
|
}
|
|
|
|
static int ntfs_ih_insert(INDEX_HEADER *ih, INDEX_ENTRY *orig_ie, VCN new_vcn,
|
|
int pos)
|
|
{
|
|
INDEX_ENTRY *ie_node, *ie;
|
|
int ret = STATUS_ERROR;
|
|
VCN old_vcn;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ie = ntfs_ie_dup(orig_ie);
|
|
if (!ie)
|
|
return STATUS_ERROR;
|
|
|
|
if (!(ie->ie_flags & INDEX_ENTRY_NODE))
|
|
if (ntfs_ie_add_vcn(&ie))
|
|
goto out;
|
|
|
|
ie_node = ntfs_ie_get_by_pos(ih, pos);
|
|
old_vcn = ntfs_ie_get_vcn(ie_node);
|
|
ntfs_ie_set_vcn(ie_node, new_vcn);
|
|
|
|
ntfs_ie_insert(ih, ie, ie_node);
|
|
ntfs_ie_set_vcn(ie_node, old_vcn);
|
|
ret = STATUS_OK;
|
|
out:
|
|
free(ie);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static VCN ntfs_icx_parent_vcn(ntfs_index_context *icx)
|
|
{
|
|
return icx->parent_vcn[icx->pindex];
|
|
}
|
|
|
|
static VCN ntfs_icx_parent_pos(ntfs_index_context *icx)
|
|
{
|
|
return icx->parent_pos[icx->pindex];
|
|
}
|
|
|
|
|
|
static int ntfs_ir_insert_median(ntfs_index_context *icx, INDEX_ENTRY *median,
|
|
VCN new_vcn)
|
|
{
|
|
u32 new_size;
|
|
int ret;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
icx->ir = ntfs_ir_lookup2(icx->ni, icx->name, icx->name_len);
|
|
if (!icx->ir)
|
|
return STATUS_ERROR;
|
|
|
|
new_size = le32_to_cpu(icx->ir->index.index_length) +
|
|
le16_to_cpu(median->length);
|
|
if (!(median->ie_flags & INDEX_ENTRY_NODE))
|
|
new_size += sizeof(VCN);
|
|
|
|
ret = ntfs_ir_make_space(icx, new_size);
|
|
if (ret != STATUS_OK)
|
|
return ret;
|
|
|
|
icx->ir = ntfs_ir_lookup2(icx->ni, icx->name, icx->name_len);
|
|
if (!icx->ir)
|
|
return STATUS_ERROR;
|
|
|
|
return ntfs_ih_insert(&icx->ir->index, median, new_vcn,
|
|
ntfs_icx_parent_pos(icx));
|
|
}
|
|
|
|
static int ntfs_ib_split(ntfs_index_context *icx, INDEX_BLOCK *ib);
|
|
|
|
/**
|
|
* On success return STATUS_OK or STATUS_KEEP_SEARCHING.
|
|
* On error return STATUS_ERROR.
|
|
*/
|
|
static int ntfs_ib_insert(ntfs_index_context *icx, INDEX_ENTRY *ie, VCN new_vcn)
|
|
{
|
|
INDEX_BLOCK *ib;
|
|
u32 idx_size, allocated_size;
|
|
int err = STATUS_ERROR;
|
|
VCN old_vcn;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ib = ntfs_malloc(icx->block_size);
|
|
if (!ib)
|
|
return -1;
|
|
|
|
old_vcn = ntfs_icx_parent_vcn(icx);
|
|
|
|
if (ntfs_ib_read(icx, old_vcn, ib))
|
|
goto err_out;
|
|
|
|
idx_size = le32_to_cpu(ib->index.index_length);
|
|
allocated_size = le32_to_cpu(ib->index.allocated_size);
|
|
/* FIXME: sizeof(VCN) should be included only if ie has no VCN */
|
|
if (idx_size + le16_to_cpu(ie->length) + sizeof(VCN) > allocated_size) {
|
|
err = ntfs_ib_split(icx, ib);
|
|
if (err == STATUS_OK)
|
|
err = STATUS_KEEP_SEARCHING;
|
|
goto err_out;
|
|
}
|
|
|
|
if (ntfs_ih_insert(&ib->index, ie, new_vcn, ntfs_icx_parent_pos(icx)))
|
|
goto err_out;
|
|
|
|
if (ntfs_ib_write(icx, ib))
|
|
goto err_out;
|
|
|
|
err = STATUS_OK;
|
|
err_out:
|
|
free(ib);
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* ntfs_ib_split - Split an index block
|
|
*
|
|
* On success return STATUS_OK or STATUS_KEEP_SEARCHING.
|
|
* On error return is STATUS_ERROR.
|
|
*/
|
|
static int ntfs_ib_split(ntfs_index_context *icx, INDEX_BLOCK *ib)
|
|
{
|
|
INDEX_ENTRY *median;
|
|
VCN new_vcn;
|
|
int ret;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (ntfs_icx_parent_dec(icx))
|
|
return STATUS_ERROR;
|
|
|
|
median = ntfs_ie_get_median(&ib->index);
|
|
new_vcn = ntfs_ibm_get_free(icx);
|
|
if (new_vcn == -1)
|
|
return STATUS_ERROR;
|
|
|
|
if (ntfs_ib_copy_tail(icx, ib, median, new_vcn)) {
|
|
ntfs_ibm_clear(icx, new_vcn);
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
if (ntfs_icx_parent_vcn(icx) == VCN_INDEX_ROOT_PARENT)
|
|
ret = ntfs_ir_insert_median(icx, median, new_vcn);
|
|
else
|
|
ret = ntfs_ib_insert(icx, median, new_vcn);
|
|
|
|
if (ret != STATUS_OK) {
|
|
ntfs_ibm_clear(icx, new_vcn);
|
|
return ret;
|
|
}
|
|
|
|
ret = ntfs_ib_cut_tail(icx, ib, median);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* JPA static */
|
|
int ntfs_ie_add(ntfs_index_context *icx, INDEX_ENTRY *ie)
|
|
{
|
|
INDEX_HEADER *ih;
|
|
int allocated_size, new_size;
|
|
int ret = STATUS_ERROR;
|
|
|
|
#ifdef DEBUG
|
|
/* removed by JPA to make function usable for security indexes
|
|
char *fn;
|
|
fn = ntfs_ie_filename_get(ie);
|
|
ntfs_log_trace("file: '%s'\n", fn);
|
|
ntfs_attr_name_free(&fn);
|
|
*/
|
|
#endif
|
|
|
|
while (1) {
|
|
|
|
if (!ntfs_index_lookup(&ie->key, le16_to_cpu(ie->key_length), icx)) {
|
|
errno = EEXIST;
|
|
ntfs_log_perror("Index already have such entry");
|
|
goto err_out;
|
|
}
|
|
if (errno != ENOENT) {
|
|
ntfs_log_perror("Failed to find place for new entry");
|
|
goto err_out;
|
|
}
|
|
|
|
if (icx->is_in_root)
|
|
ih = &icx->ir->index;
|
|
else
|
|
ih = &icx->ib->index;
|
|
|
|
allocated_size = le32_to_cpu(ih->allocated_size);
|
|
new_size = le32_to_cpu(ih->index_length) + le16_to_cpu(ie->length);
|
|
|
|
if (new_size <= allocated_size)
|
|
break;
|
|
|
|
ntfs_log_trace("index block sizes: allocated: %d needed: %d\n",
|
|
allocated_size, new_size);
|
|
|
|
if (icx->is_in_root) {
|
|
if (ntfs_ir_make_space(icx, new_size) == STATUS_ERROR)
|
|
goto err_out;
|
|
} else {
|
|
if (ntfs_ib_split(icx, icx->ib) == STATUS_ERROR)
|
|
goto err_out;
|
|
}
|
|
|
|
ntfs_inode_mark_dirty(icx->actx->ntfs_ino);
|
|
ntfs_index_ctx_reinit(icx);
|
|
}
|
|
|
|
ntfs_ie_insert(ih, ie, icx->entry);
|
|
ntfs_index_entry_mark_dirty(icx);
|
|
|
|
ret = STATUS_OK;
|
|
err_out:
|
|
ntfs_log_trace("%s\n", ret ? "Failed" : "Done");
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_add_filename - add filename to directory index
|
|
* @ni: ntfs inode describing directory to which index add filename
|
|
* @fn: FILE_NAME attribute to add
|
|
* @mref: reference of the inode which @fn describes
|
|
*
|
|
* Return 0 on success or -1 on error with errno set to the error code.
|
|
*/
|
|
int ntfs_index_add_filename(ntfs_inode *ni, FILE_NAME_ATTR *fn, MFT_REF mref)
|
|
{
|
|
INDEX_ENTRY *ie;
|
|
ntfs_index_context *icx;
|
|
int fn_size, ie_size, err, ret = -1;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!ni || !fn) {
|
|
ntfs_log_error("Invalid arguments.\n");
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
fn_size = (fn->file_name_length * sizeof(ntfschar)) +
|
|
sizeof(FILE_NAME_ATTR);
|
|
ie_size = (sizeof(INDEX_ENTRY_HEADER) + fn_size + 7) & ~7;
|
|
|
|
ie = ntfs_calloc(ie_size);
|
|
if (!ie)
|
|
return -1;
|
|
|
|
ie->indexed_file = cpu_to_le64(mref);
|
|
ie->length = cpu_to_le16(ie_size);
|
|
ie->key_length = cpu_to_le16(fn_size);
|
|
memcpy(&ie->key, fn, fn_size);
|
|
|
|
icx = ntfs_index_ctx_get(ni, NTFS_INDEX_I30, 4);
|
|
if (!icx)
|
|
goto out;
|
|
|
|
ret = ntfs_ie_add(icx, ie);
|
|
err = errno;
|
|
ntfs_index_ctx_put(icx);
|
|
errno = err;
|
|
out:
|
|
free(ie);
|
|
return ret;
|
|
}
|
|
|
|
static int ntfs_ih_takeout(ntfs_index_context *icx, INDEX_HEADER *ih,
|
|
INDEX_ENTRY *ie, INDEX_BLOCK *ib)
|
|
{
|
|
INDEX_ENTRY *ie_roam;
|
|
int ret = STATUS_ERROR;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ie_roam = ntfs_ie_dup_novcn(ie);
|
|
if (!ie_roam)
|
|
return STATUS_ERROR;
|
|
|
|
ntfs_ie_delete(ih, ie);
|
|
|
|
if (ntfs_icx_parent_vcn(icx) == VCN_INDEX_ROOT_PARENT)
|
|
ntfs_inode_mark_dirty(icx->actx->ntfs_ino);
|
|
else
|
|
if (ntfs_ib_write(icx, ib))
|
|
goto out;
|
|
|
|
ntfs_index_ctx_reinit(icx);
|
|
|
|
ret = ntfs_ie_add(icx, ie_roam);
|
|
out:
|
|
free(ie_roam);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Used if an empty index block to be deleted has END entry as the parent
|
|
* in the INDEX_ROOT which is the only one there.
|
|
*/
|
|
static void ntfs_ir_leafify(ntfs_index_context *icx, INDEX_HEADER *ih)
|
|
{
|
|
INDEX_ENTRY *ie;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ie = ntfs_ie_get_first(ih);
|
|
ie->ie_flags &= ~INDEX_ENTRY_NODE;
|
|
ie->length = cpu_to_le16(le16_to_cpu(ie->length) - sizeof(VCN));
|
|
|
|
ih->index_length = cpu_to_le32(le32_to_cpu(ih->index_length) - sizeof(VCN));
|
|
ih->ih_flags &= ~LARGE_INDEX;
|
|
|
|
/* Not fatal error */
|
|
ntfs_ir_truncate(icx, le32_to_cpu(ih->index_length));
|
|
}
|
|
|
|
/**
|
|
* Used if an empty index block to be deleted has END entry as the parent
|
|
* in the INDEX_ROOT which is not the only one there.
|
|
*/
|
|
static int ntfs_ih_reparent_end(ntfs_index_context *icx, INDEX_HEADER *ih,
|
|
INDEX_BLOCK *ib)
|
|
{
|
|
INDEX_ENTRY *ie, *ie_prev;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
ie = ntfs_ie_get_by_pos(ih, ntfs_icx_parent_pos(icx));
|
|
ie_prev = ntfs_ie_prev(ih, ie);
|
|
|
|
ntfs_ie_set_vcn(ie, ntfs_ie_get_vcn(ie_prev));
|
|
|
|
return ntfs_ih_takeout(icx, ih, ie_prev, ib);
|
|
}
|
|
|
|
static int ntfs_index_rm_leaf(ntfs_index_context *icx)
|
|
{
|
|
INDEX_BLOCK *ib = NULL;
|
|
INDEX_HEADER *parent_ih;
|
|
INDEX_ENTRY *ie;
|
|
int ret = STATUS_ERROR;
|
|
|
|
ntfs_log_trace("pindex: %d\n", icx->pindex);
|
|
|
|
if (ntfs_icx_parent_dec(icx))
|
|
return STATUS_ERROR;
|
|
|
|
if (ntfs_ibm_clear(icx, icx->parent_vcn[icx->pindex + 1]))
|
|
return STATUS_ERROR;
|
|
|
|
if (ntfs_icx_parent_vcn(icx) == VCN_INDEX_ROOT_PARENT)
|
|
parent_ih = &icx->ir->index;
|
|
else {
|
|
ib = ntfs_malloc(icx->block_size);
|
|
if (!ib)
|
|
return STATUS_ERROR;
|
|
|
|
if (ntfs_ib_read(icx, ntfs_icx_parent_vcn(icx), ib))
|
|
goto out;
|
|
|
|
parent_ih = &ib->index;
|
|
}
|
|
|
|
ie = ntfs_ie_get_by_pos(parent_ih, ntfs_icx_parent_pos(icx));
|
|
if (!ntfs_ie_end(ie)) {
|
|
ret = ntfs_ih_takeout(icx, parent_ih, ie, ib);
|
|
goto out;
|
|
}
|
|
|
|
if (ntfs_ih_zero_entry(parent_ih)) {
|
|
|
|
if (ntfs_icx_parent_vcn(icx) == VCN_INDEX_ROOT_PARENT) {
|
|
ntfs_ir_leafify(icx, parent_ih);
|
|
goto ok;
|
|
}
|
|
|
|
ret = ntfs_index_rm_leaf(icx);
|
|
goto out;
|
|
}
|
|
|
|
if (ntfs_ih_reparent_end(icx, parent_ih, ib))
|
|
goto out;
|
|
ok:
|
|
ret = STATUS_OK;
|
|
out:
|
|
free(ib);
|
|
return ret;
|
|
}
|
|
|
|
static int ntfs_index_rm_node(ntfs_index_context *icx)
|
|
{
|
|
int entry_pos, pindex;
|
|
VCN vcn;
|
|
INDEX_BLOCK *ib = NULL;
|
|
INDEX_ENTRY *ie_succ, *ie, *entry = icx->entry;
|
|
INDEX_HEADER *ih;
|
|
u32 new_size;
|
|
int delta, ret = STATUS_ERROR;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!icx->ia_na) {
|
|
icx->ia_na = ntfs_ia_open(icx, icx->ni);
|
|
if (!icx->ia_na)
|
|
return STATUS_ERROR;
|
|
}
|
|
|
|
ib = ntfs_malloc(icx->block_size);
|
|
if (!ib)
|
|
return STATUS_ERROR;
|
|
|
|
ie_succ = ntfs_ie_get_next(icx->entry);
|
|
entry_pos = icx->parent_pos[icx->pindex]++;
|
|
pindex = icx->pindex;
|
|
descend:
|
|
vcn = ntfs_ie_get_vcn(ie_succ);
|
|
if (ntfs_ib_read(icx, vcn, ib))
|
|
goto out;
|
|
|
|
ie_succ = ntfs_ie_get_first(&ib->index);
|
|
|
|
if (ntfs_icx_parent_inc(icx))
|
|
goto out;
|
|
|
|
icx->parent_vcn[icx->pindex] = vcn;
|
|
icx->parent_pos[icx->pindex] = 0;
|
|
|
|
if ((ib->index.ih_flags & NODE_MASK) == INDEX_NODE)
|
|
goto descend;
|
|
|
|
if (ntfs_ih_zero_entry(&ib->index)) {
|
|
errno = EIO;
|
|
ntfs_log_perror("Empty index block");
|
|
goto out;
|
|
}
|
|
|
|
ie = ntfs_ie_dup(ie_succ);
|
|
if (!ie)
|
|
goto out;
|
|
|
|
if (ntfs_ie_add_vcn(&ie))
|
|
goto out2;
|
|
|
|
ntfs_ie_set_vcn(ie, ntfs_ie_get_vcn(icx->entry));
|
|
|
|
if (icx->is_in_root)
|
|
ih = &icx->ir->index;
|
|
else
|
|
ih = &icx->ib->index;
|
|
|
|
delta = le16_to_cpu(ie->length) - le16_to_cpu(icx->entry->length);
|
|
new_size = le32_to_cpu(ih->index_length) + delta;
|
|
if (delta > 0) {
|
|
if (icx->is_in_root) {
|
|
ret = ntfs_ir_make_space(icx, new_size);
|
|
if (ret != STATUS_OK)
|
|
goto out2;
|
|
|
|
ih = &icx->ir->index;
|
|
entry = ntfs_ie_get_by_pos(ih, entry_pos);
|
|
|
|
} else if (new_size > le32_to_cpu(ih->allocated_size)) {
|
|
icx->pindex = pindex;
|
|
ret = ntfs_ib_split(icx, icx->ib);
|
|
if (ret == STATUS_OK)
|
|
ret = STATUS_KEEP_SEARCHING;
|
|
goto out2;
|
|
}
|
|
}
|
|
|
|
ntfs_ie_delete(ih, entry);
|
|
ntfs_ie_insert(ih, ie, entry);
|
|
|
|
if (icx->is_in_root) {
|
|
if (ntfs_ir_truncate(icx, new_size))
|
|
goto out2;
|
|
} else
|
|
if (ntfs_icx_ib_write(icx))
|
|
goto out2;
|
|
|
|
ntfs_ie_delete(&ib->index, ie_succ);
|
|
|
|
if (ntfs_ih_zero_entry(&ib->index)) {
|
|
if (ntfs_index_rm_leaf(icx))
|
|
goto out2;
|
|
} else
|
|
if (ntfs_ib_write(icx, ib))
|
|
goto out2;
|
|
|
|
ret = STATUS_OK;
|
|
out2:
|
|
free(ie);
|
|
out:
|
|
free(ib);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_rm - remove entry from the index
|
|
* @icx: index context describing entry to delete
|
|
*
|
|
* Delete entry described by @icx from the index. Index context is always
|
|
* reinitialized after use of this function, so it can be used for index
|
|
* lookup once again.
|
|
*
|
|
* Return 0 on success or -1 on error with errno set to the error code.
|
|
*/
|
|
/*static JPA*/
|
|
int ntfs_index_rm(ntfs_index_context *icx)
|
|
{
|
|
INDEX_HEADER *ih;
|
|
int err, ret = STATUS_OK;
|
|
|
|
ntfs_log_trace("Entering\n");
|
|
|
|
if (!icx || (!icx->ib && !icx->ir) || ntfs_ie_end(icx->entry)) {
|
|
ntfs_log_error("Invalid arguments.\n");
|
|
errno = EINVAL;
|
|
goto err_out;
|
|
}
|
|
if (icx->is_in_root)
|
|
ih = &icx->ir->index;
|
|
else
|
|
ih = &icx->ib->index;
|
|
|
|
if (icx->entry->ie_flags & INDEX_ENTRY_NODE) {
|
|
|
|
ret = ntfs_index_rm_node(icx);
|
|
|
|
} else if (icx->is_in_root || !ntfs_ih_one_entry(ih)) {
|
|
|
|
ntfs_ie_delete(ih, icx->entry);
|
|
|
|
if (icx->is_in_root) {
|
|
err = ntfs_ir_truncate(icx, le32_to_cpu(ih->index_length));
|
|
if (err != STATUS_OK)
|
|
goto err_out;
|
|
} else
|
|
if (ntfs_icx_ib_write(icx))
|
|
goto err_out;
|
|
} else {
|
|
if (ntfs_index_rm_leaf(icx))
|
|
goto err_out;
|
|
}
|
|
out:
|
|
return ret;
|
|
err_out:
|
|
ret = STATUS_ERROR;
|
|
goto out;
|
|
}
|
|
|
|
int ntfs_index_remove(ntfs_inode *dir_ni, ntfs_inode *ni,
|
|
const void *key, const int keylen)
|
|
{
|
|
int ret = STATUS_ERROR;
|
|
ntfs_index_context *icx;
|
|
|
|
icx = ntfs_index_ctx_get(dir_ni, NTFS_INDEX_I30, 4);
|
|
if (!icx)
|
|
return -1;
|
|
|
|
while (1) {
|
|
|
|
if (ntfs_index_lookup(key, keylen, icx))
|
|
goto err_out;
|
|
|
|
if ((((FILE_NAME_ATTR *)icx->data)->file_attributes &
|
|
FILE_ATTR_REPARSE_POINT)
|
|
&& !ntfs_possible_symlink(ni)) {
|
|
errno = EOPNOTSUPP;
|
|
goto err_out;
|
|
}
|
|
|
|
ret = ntfs_index_rm(icx);
|
|
if (ret == STATUS_ERROR)
|
|
goto err_out;
|
|
else if (ret == STATUS_OK)
|
|
break;
|
|
|
|
ntfs_inode_mark_dirty(icx->actx->ntfs_ino);
|
|
ntfs_index_ctx_reinit(icx);
|
|
}
|
|
|
|
ntfs_inode_mark_dirty(icx->actx->ntfs_ino);
|
|
out:
|
|
ntfs_index_ctx_put(icx);
|
|
return ret;
|
|
err_out:
|
|
ret = STATUS_ERROR;
|
|
ntfs_log_perror("Delete failed");
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* ntfs_index_root_get - read the index root of an attribute
|
|
* @ni: open ntfs inode in which the ntfs attribute resides
|
|
* @attr: attribute for which we want its index root
|
|
*
|
|
* This function will read the related index root an ntfs attribute.
|
|
*
|
|
* On success a buffer is allocated with the content of the index root
|
|
* and which needs to be freed when it's not needed anymore.
|
|
*
|
|
* On error NULL is returned with errno set to the error code.
|
|
*/
|
|
INDEX_ROOT *ntfs_index_root_get(ntfs_inode *ni, ATTR_RECORD *attr)
|
|
{
|
|
ntfs_attr_search_ctx *ctx;
|
|
ntfschar *name;
|
|
INDEX_ROOT *root = NULL;
|
|
|
|
name = (ntfschar *)((u8 *)attr + le16_to_cpu(attr->name_offset));
|
|
|
|
if (!ntfs_ir_lookup(ni, name, attr->name_length, &ctx))
|
|
return NULL;
|
|
|
|
root = ntfs_malloc(sizeof(INDEX_ROOT));
|
|
if (!root)
|
|
goto out;
|
|
|
|
*root = *((INDEX_ROOT *)((u8 *)ctx->attr +
|
|
le16_to_cpu(ctx->attr->value_offset)));
|
|
out:
|
|
ntfs_attr_put_search_ctx(ctx);
|
|
return root;
|
|
}
|
|
|
|
|
|
/*
|
|
* Walk down the index tree (leaf bound)
|
|
* until there are no subnode in the first index entry
|
|
* returns the entry at the bottom left in subnode
|
|
*/
|
|
|
|
static INDEX_ENTRY *ntfs_index_walk_down(INDEX_ENTRY *ie,
|
|
ntfs_index_context *ictx)
|
|
{
|
|
INDEX_ENTRY *entry;
|
|
s64 vcn;
|
|
|
|
entry = ie;
|
|
do {
|
|
vcn = ntfs_ie_get_vcn(entry);
|
|
if (ictx->is_in_root) {
|
|
|
|
/* down from level zero */
|
|
|
|
ictx->ir = (INDEX_ROOT*)NULL;
|
|
ictx->ib = (INDEX_BLOCK*)ntfs_malloc(ictx->block_size);
|
|
ictx->pindex = 1;
|
|
ictx->is_in_root = FALSE;
|
|
} else {
|
|
|
|
/* down from non-zero level */
|
|
|
|
ictx->pindex++;
|
|
}
|
|
ictx->parent_pos[ictx->pindex] = 0;
|
|
ictx->parent_vcn[ictx->pindex] = vcn;
|
|
if (!ntfs_ib_read(ictx,vcn,ictx->ib)) {
|
|
ictx->entry = ntfs_ie_get_first(&ictx->ib->index);
|
|
entry = ictx->entry;
|
|
} else
|
|
entry = (INDEX_ENTRY*)NULL;
|
|
} while (entry && (entry->ie_flags & INDEX_ENTRY_NODE));
|
|
return (entry);
|
|
}
|
|
|
|
/*
|
|
* Walk up the index tree (root bound)
|
|
* until there is a valid data entry in parent
|
|
* returns the parent entry or NULL if no more parent
|
|
*/
|
|
|
|
static INDEX_ENTRY *ntfs_index_walk_up(INDEX_ENTRY *ie,
|
|
ntfs_index_context *ictx)
|
|
{
|
|
INDEX_ENTRY *entry;
|
|
s64 vcn;
|
|
|
|
entry = ie;
|
|
if (ictx->pindex > 0) {
|
|
do {
|
|
ictx->pindex--;
|
|
if (!ictx->pindex) {
|
|
|
|
/* we have reached the root */
|
|
|
|
free(ictx->ib);
|
|
ictx->ib = (INDEX_BLOCK*)NULL;
|
|
ictx->is_in_root = TRUE;
|
|
/* a new search context is to be allocated */
|
|
if (ictx->actx)
|
|
free(ictx->actx);
|
|
ictx->ir = ntfs_ir_lookup(ictx->ni,
|
|
ictx->name, ictx->name_len,
|
|
&ictx->actx);
|
|
if (ictx->ir)
|
|
entry = ntfs_ie_get_by_pos(
|
|
&ictx->ir->index,
|
|
ictx->parent_pos[ictx->pindex]);
|
|
else
|
|
entry = (INDEX_ENTRY*)NULL;
|
|
} else {
|
|
/* up into non-root node */
|
|
vcn = ictx->parent_vcn[ictx->pindex];
|
|
if (!ntfs_ib_read(ictx,vcn,ictx->ib)) {
|
|
entry = ntfs_ie_get_by_pos(
|
|
&ictx->ib->index,
|
|
ictx->parent_pos[ictx->pindex]);
|
|
} else
|
|
entry = (INDEX_ENTRY*)NULL;
|
|
}
|
|
ictx->entry = entry;
|
|
} while (entry && (ictx->pindex > 0)
|
|
&& (entry->ie_flags & INDEX_ENTRY_END));
|
|
} else
|
|
entry = (INDEX_ENTRY*)NULL;
|
|
return (entry);
|
|
}
|
|
|
|
/*
|
|
* Get next entry in an index according to collating sequence.
|
|
* Must be initialized through a ntfs_index_lookup()
|
|
*
|
|
* Returns next entry or NULL if none
|
|
*
|
|
* Sample layout :
|
|
*
|
|
* +---+---+---+---+---+---+---+---+ n ptrs to subnodes
|
|
* | | | 10| 25| 33| | | | n-1 keys in between
|
|
* +---+---+---+---+---+---+---+---+ no key in last entry
|
|
* | A | A
|
|
* | | | +-------------------------------+
|
|
* +--------------------------+ | +-----+ |
|
|
* | +--+ | |
|
|
* V | V |
|
|
* +---+---+---+---+---+---+---+---+ | +---+---+---+---+---+---+---+---+
|
|
* | 11| 12| 13| 14| 15| 16| 17| | | | 26| 27| 28| 29| 30| 31| 32| |
|
|
* +---+---+---+---+---+---+---+---+ | +---+---+---+---+---+---+---+---+
|
|
* | |
|
|
* +-----------------------+ |
|
|
* | |
|
|
* +---+---+---+---+---+---+---+---+
|
|
* | 18| 19| 20| 21| 22| 23| 24| |
|
|
* +---+---+---+---+---+---+---+---+
|
|
*/
|
|
|
|
INDEX_ENTRY *ntfs_index_next(INDEX_ENTRY *ie, ntfs_index_context *ictx)
|
|
{
|
|
INDEX_ENTRY *next;
|
|
int flags;
|
|
|
|
/*
|
|
* lookup() may have returned an invalid node
|
|
* when searching for a partial key
|
|
* if this happens, walk up
|
|
*/
|
|
|
|
if (ie->ie_flags & INDEX_ENTRY_END)
|
|
next = ntfs_index_walk_up(ie, ictx);
|
|
else {
|
|
/*
|
|
* get next entry in same node
|
|
* there is always one after any entry with data
|
|
*/
|
|
|
|
next = (INDEX_ENTRY*)((char*)ie + le16_to_cpu(ie->length));
|
|
++ictx->parent_pos[ictx->pindex];
|
|
flags = next->ie_flags;
|
|
|
|
/* walk down if it has a subnode */
|
|
|
|
if (flags & INDEX_ENTRY_NODE) {
|
|
next = ntfs_index_walk_down(next,ictx);
|
|
} else {
|
|
|
|
/* walk up it has no subnode, nor data */
|
|
|
|
if (flags & INDEX_ENTRY_END) {
|
|
next = ntfs_index_walk_up(next, ictx);
|
|
}
|
|
}
|
|
}
|
|
/* return NULL if stuck at end of a block */
|
|
|
|
if (next && (next->ie_flags & INDEX_ENTRY_END))
|
|
next = (INDEX_ENTRY*)NULL;
|
|
return (next);
|
|
}
|
|
|
|
|