mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-09-09 09:03:20 +02:00
1567 lines
42 KiB
C
1567 lines
42 KiB
C
![]() |
/**
|
||
|
* inode.c - Inode handling code. Originated from the Linux-NTFS project.
|
||
|
*
|
||
|
* Copyright (c) 2002-2005 Anton Altaparmakov
|
||
|
* Copyright (c) 2002-2008 Szabolcs Szakacsits
|
||
|
* Copyright (c) 2004-2007 Yura Pakhuchiy
|
||
|
* Copyright (c) 2004-2005 Richard Russon
|
||
|
* Copyright (c) 2009-2010 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
|
||
|
#ifdef HAVE_SETXATTR
|
||
|
#include <sys/xattr.h>
|
||
|
#endif
|
||
|
|
||
|
#include "param.h"
|
||
|
#include "compat.h"
|
||
|
#include "types.h"
|
||
|
#include "volume.h"
|
||
|
#include "cache.h"
|
||
|
#include "inode.h"
|
||
|
#include "attrib.h"
|
||
|
#include "debug.h"
|
||
|
#include "mft.h"
|
||
|
#include "attrlist.h"
|
||
|
#include "runlist.h"
|
||
|
#include "lcnalloc.h"
|
||
|
#include "index.h"
|
||
|
#include "dir.h"
|
||
|
#include "ntfstime.h"
|
||
|
#include "logging.h"
|
||
|
#include "misc.h"
|
||
|
|
||
|
ntfs_inode *ntfs_inode_base(ntfs_inode *ni)
|
||
|
{
|
||
|
if (ni->nr_extents == -1)
|
||
|
return ni->base_ni;
|
||
|
return ni;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_mark_dirty - set the inode (and its base inode if it exists) dirty
|
||
|
* @ni: ntfs inode to set dirty
|
||
|
*
|
||
|
* Set the inode @ni dirty so it is written out later (at the latest at
|
||
|
* ntfs_inode_close() time). If @ni is an extent inode, set the base inode
|
||
|
* dirty, too.
|
||
|
*
|
||
|
* This function cannot fail.
|
||
|
*/
|
||
|
void ntfs_inode_mark_dirty(ntfs_inode *ni)
|
||
|
{
|
||
|
NInoSetDirty(ni);
|
||
|
if (ni->nr_extents == -1)
|
||
|
NInoSetDirty(ni->base_ni);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* __ntfs_inode_allocate - Create and initialise an NTFS inode object
|
||
|
* @vol:
|
||
|
*
|
||
|
* Description...
|
||
|
*
|
||
|
* Returns:
|
||
|
*/
|
||
|
static ntfs_inode *__ntfs_inode_allocate(ntfs_volume *vol)
|
||
|
{
|
||
|
ntfs_inode *ni;
|
||
|
|
||
|
ni = (ntfs_inode*)ntfs_calloc(sizeof(ntfs_inode));
|
||
|
if (ni)
|
||
|
ni->vol = vol;
|
||
|
return ni;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_allocate - Create an NTFS inode object
|
||
|
* @vol:
|
||
|
*
|
||
|
* Description...
|
||
|
*
|
||
|
* Returns:
|
||
|
*/
|
||
|
ntfs_inode *ntfs_inode_allocate(ntfs_volume *vol)
|
||
|
{
|
||
|
return __ntfs_inode_allocate(vol);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* __ntfs_inode_release - Destroy an NTFS inode object
|
||
|
* @ni:
|
||
|
*
|
||
|
* Description...
|
||
|
*
|
||
|
* Returns:
|
||
|
*/
|
||
|
static void __ntfs_inode_release(ntfs_inode *ni)
|
||
|
{
|
||
|
if (NInoDirty(ni))
|
||
|
ntfs_log_error("Releasing dirty inode %lld!\n",
|
||
|
(long long)ni->mft_no);
|
||
|
if (NInoAttrList(ni) && ni->attr_list)
|
||
|
free(ni->attr_list);
|
||
|
free(ni->mrec);
|
||
|
free(ni);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_open - open an inode ready for access
|
||
|
* @vol: volume to get the inode from
|
||
|
* @mref: inode number / mft record number to open
|
||
|
*
|
||
|
* Allocate an ntfs_inode structure and initialize it for the given inode
|
||
|
* specified by @mref. @mref specifies the inode number / mft record to read,
|
||
|
* including the sequence number, which can be 0 if no sequence number checking
|
||
|
* is to be performed.
|
||
|
*
|
||
|
* Then, allocate a buffer for the mft record, read the mft record from the
|
||
|
* volume @vol, and attach it to the ntfs_inode structure (->mrec). The
|
||
|
* mft record is mst deprotected and sanity checked for validity and we abort
|
||
|
* if deprotection or checks fail.
|
||
|
*
|
||
|
* Finally, search for an attribute list attribute in the mft record and if one
|
||
|
* is found, load the attribute list attribute value and attach it to the
|
||
|
* ntfs_inode structure (->attr_list). Also set the NI_AttrList bit to indicate
|
||
|
* this.
|
||
|
*
|
||
|
* Return a pointer to the ntfs_inode structure on success or NULL on error,
|
||
|
* with errno set to the error code.
|
||
|
*/
|
||
|
static ntfs_inode *ntfs_inode_real_open(ntfs_volume *vol, const MFT_REF mref)
|
||
|
{
|
||
|
s64 l;
|
||
|
ntfs_inode *ni = NULL;
|
||
|
ntfs_attr_search_ctx *ctx;
|
||
|
STANDARD_INFORMATION *std_info;
|
||
|
le32 lthle;
|
||
|
int olderrno;
|
||
|
|
||
|
ntfs_log_enter("Entering for inode %lld\n", (long long)MREF(mref));
|
||
|
if (!vol) {
|
||
|
errno = EINVAL;
|
||
|
goto out;
|
||
|
}
|
||
|
ni = __ntfs_inode_allocate(vol);
|
||
|
if (!ni)
|
||
|
goto out;
|
||
|
if (ntfs_file_record_read(vol, mref, &ni->mrec, NULL))
|
||
|
goto err_out;
|
||
|
if (!(ni->mrec->flags & MFT_RECORD_IN_USE)) {
|
||
|
errno = ENOENT;
|
||
|
goto err_out;
|
||
|
}
|
||
|
ni->mft_no = MREF(mref);
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (!ctx)
|
||
|
goto err_out;
|
||
|
/* Receive some basic information about inode. */
|
||
|
if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED,
|
||
|
0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
|
||
|
if (!ni->mrec->base_mft_record)
|
||
|
ntfs_log_perror("No STANDARD_INFORMATION in base record"
|
||
|
" %lld", (long long)MREF(mref));
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
ni->flags = std_info->file_attributes;
|
||
|
ni->creation_time = std_info->creation_time;
|
||
|
ni->last_data_change_time = std_info->last_data_change_time;
|
||
|
ni->last_mft_change_time = std_info->last_mft_change_time;
|
||
|
ni->last_access_time = std_info->last_access_time;
|
||
|
/* JPA insert v3 extensions if present */
|
||
|
/* length may be seen as 72 (v1.x) or 96 (v3.x) */
|
||
|
lthle = ctx->attr->length;
|
||
|
if (le32_to_cpu(lthle) > sizeof(STANDARD_INFORMATION)) {
|
||
|
set_nino_flag(ni, v3_Extensions);
|
||
|
ni->owner_id = std_info->owner_id;
|
||
|
ni->security_id = std_info->security_id;
|
||
|
ni->quota_charged = std_info->quota_charged;
|
||
|
ni->usn = std_info->usn;
|
||
|
} else {
|
||
|
clear_nino_flag(ni, v3_Extensions);
|
||
|
ni->owner_id = const_cpu_to_le32(0);
|
||
|
ni->security_id = const_cpu_to_le32(0);
|
||
|
}
|
||
|
/* Set attribute list information. */
|
||
|
olderrno = errno;
|
||
|
if (ntfs_attr_lookup(AT_ATTRIBUTE_LIST, AT_UNNAMED, 0,
|
||
|
CASE_SENSITIVE, 0, NULL, 0, ctx)) {
|
||
|
if (errno != ENOENT)
|
||
|
goto put_err_out;
|
||
|
/* Attribute list attribute does not present. */
|
||
|
/* restore previous errno to avoid misinterpretation */
|
||
|
errno = olderrno;
|
||
|
goto get_size;
|
||
|
}
|
||
|
NInoSetAttrList(ni);
|
||
|
l = ntfs_get_attribute_value_length(ctx->attr);
|
||
|
if (!l)
|
||
|
goto put_err_out;
|
||
|
if (l > 0x40000) {
|
||
|
errno = EIO;
|
||
|
ntfs_log_perror("Too large attrlist attribute (%lld), inode "
|
||
|
"%lld", (long long)l, (long long)MREF(mref));
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
ni->attr_list_size = l;
|
||
|
ni->attr_list = ntfs_malloc(ni->attr_list_size);
|
||
|
if (!ni->attr_list)
|
||
|
goto put_err_out;
|
||
|
l = ntfs_get_attribute_value(vol, ctx->attr, ni->attr_list);
|
||
|
if (!l)
|
||
|
goto put_err_out;
|
||
|
if (l != ni->attr_list_size) {
|
||
|
errno = EIO;
|
||
|
ntfs_log_perror("Unexpected attrlist size (%lld <> %u), inode "
|
||
|
"%lld", (long long)l, ni->attr_list_size,
|
||
|
(long long)MREF(mref));
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
get_size:
|
||
|
olderrno = errno;
|
||
|
if (ntfs_attr_lookup(AT_DATA, AT_UNNAMED, 0, 0, 0, NULL, 0, ctx)) {
|
||
|
if (errno != ENOENT)
|
||
|
goto put_err_out;
|
||
|
/* Directory or special file. */
|
||
|
/* restore previous errno to avoid misinterpretation */
|
||
|
errno = olderrno;
|
||
|
ni->data_size = ni->allocated_size = 0;
|
||
|
} else {
|
||
|
if (ctx->attr->non_resident) {
|
||
|
ni->data_size = sle64_to_cpu(ctx->attr->data_size);
|
||
|
if (ctx->attr->flags &
|
||
|
(ATTR_IS_COMPRESSED | ATTR_IS_SPARSE))
|
||
|
ni->allocated_size = sle64_to_cpu(
|
||
|
ctx->attr->compressed_size);
|
||
|
else
|
||
|
ni->allocated_size = sle64_to_cpu(
|
||
|
ctx->attr->allocated_size);
|
||
|
} else {
|
||
|
ni->data_size = le32_to_cpu(ctx->attr->value_length);
|
||
|
ni->allocated_size = (ni->data_size + 7) & ~7;
|
||
|
}
|
||
|
set_nino_flag(ni,KnownSize);
|
||
|
}
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
out:
|
||
|
ntfs_log_leave("\n");
|
||
|
return ni;
|
||
|
|
||
|
put_err_out:
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
err_out:
|
||
|
__ntfs_inode_release(ni);
|
||
|
ni = NULL;
|
||
|
goto out;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_close - close an ntfs inode and free all associated memory
|
||
|
* @ni: ntfs inode to close
|
||
|
*
|
||
|
* Make sure the ntfs inode @ni is clean.
|
||
|
*
|
||
|
* If the ntfs inode @ni is a base inode, close all associated extent inodes,
|
||
|
* then deallocate all memory attached to it, and finally free the ntfs inode
|
||
|
* structure itself.
|
||
|
*
|
||
|
* If it is an extent inode, we disconnect it from its base inode before we
|
||
|
* destroy it.
|
||
|
*
|
||
|
* It is OK to pass NULL to this function, it is just noop in this case.
|
||
|
*
|
||
|
* Return 0 on success or -1 on error with errno set to the error code. On
|
||
|
* error, @ni has not been freed. The user should attempt to handle the error
|
||
|
* and call ntfs_inode_close() again. The following error codes are defined:
|
||
|
*
|
||
|
* EBUSY @ni and/or its attribute list runlist is/are dirty and the
|
||
|
* attempt to write it/them to disk failed.
|
||
|
* EINVAL @ni is invalid (probably it is an extent inode).
|
||
|
* EIO I/O error while trying to write inode to disk.
|
||
|
*/
|
||
|
|
||
|
int ntfs_inode_real_close(ntfs_inode *ni)
|
||
|
{
|
||
|
int ret = -1;
|
||
|
|
||
|
if (!ni)
|
||
|
return 0;
|
||
|
|
||
|
ntfs_log_enter("Entering for inode %lld\n", (long long)ni->mft_no);
|
||
|
|
||
|
/* If we have dirty metadata, write it out. */
|
||
|
if (NInoDirty(ni) || NInoAttrListDirty(ni)) {
|
||
|
if (ntfs_inode_sync(ni)) {
|
||
|
if (errno != EIO)
|
||
|
errno = EBUSY;
|
||
|
goto err;
|
||
|
}
|
||
|
}
|
||
|
/* Is this a base inode with mapped extent inodes? */
|
||
|
if (ni->nr_extents > 0) {
|
||
|
while (ni->nr_extents > 0) {
|
||
|
if (ntfs_inode_real_close(ni->extent_nis[0])) {
|
||
|
if (errno != EIO)
|
||
|
errno = EBUSY;
|
||
|
goto err;
|
||
|
}
|
||
|
}
|
||
|
} else if (ni->nr_extents == -1) {
|
||
|
ntfs_inode **tmp_nis;
|
||
|
ntfs_inode *base_ni;
|
||
|
s32 i;
|
||
|
|
||
|
/*
|
||
|
* If the inode is an extent inode, disconnect it from the
|
||
|
* base inode before destroying it.
|
||
|
*/
|
||
|
base_ni = ni->base_ni;
|
||
|
for (i = 0; i < base_ni->nr_extents; ++i) {
|
||
|
tmp_nis = base_ni->extent_nis;
|
||
|
if (tmp_nis[i] != ni)
|
||
|
continue;
|
||
|
/* Found it. Disconnect. */
|
||
|
memmove(tmp_nis + i, tmp_nis + i + 1,
|
||
|
(base_ni->nr_extents - i - 1) *
|
||
|
sizeof(ntfs_inode *));
|
||
|
/* Buffer should be for multiple of four extents. */
|
||
|
if ((--base_ni->nr_extents) & 3) {
|
||
|
i = -1;
|
||
|
break;
|
||
|
}
|
||
|
/*
|
||
|
* ElectricFence is unhappy with realloc(x,0) as free(x)
|
||
|
* thus we explicitly separate these two cases.
|
||
|
*/
|
||
|
if (base_ni->nr_extents) {
|
||
|
/* Resize the memory buffer. */
|
||
|
tmp_nis = realloc(tmp_nis, base_ni->nr_extents *
|
||
|
sizeof(ntfs_inode *));
|
||
|
/* Ignore errors, they don't really matter. */
|
||
|
if (tmp_nis)
|
||
|
base_ni->extent_nis = tmp_nis;
|
||
|
} else if (tmp_nis) {
|
||
|
free(tmp_nis);
|
||
|
base_ni->extent_nis = (ntfs_inode**)NULL;
|
||
|
}
|
||
|
/* Allow for error checking. */
|
||
|
i = -1;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* We could successfully sync, so only log this error
|
||
|
* and try to sync other inode extents too.
|
||
|
*/
|
||
|
if (i != -1)
|
||
|
ntfs_log_error("Extent inode %lld was not found\n",
|
||
|
(long long)ni->mft_no);
|
||
|
}
|
||
|
|
||
|
__ntfs_inode_release(ni);
|
||
|
ret = 0;
|
||
|
err:
|
||
|
ntfs_log_leave("\n");
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
#if CACHE_NIDATA_SIZE
|
||
|
|
||
|
/*
|
||
|
* Free an inode structure when there is not more space
|
||
|
* in the cache
|
||
|
*/
|
||
|
|
||
|
void ntfs_inode_nidata_free(const struct CACHED_GENERIC *cached)
|
||
|
{
|
||
|
ntfs_inode_real_close(((const struct CACHED_NIDATA*)cached)->ni);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Compute a hash value for an inode entry
|
||
|
*/
|
||
|
|
||
|
int ntfs_inode_nidata_hash(const struct CACHED_GENERIC *item)
|
||
|
{
|
||
|
return (((const struct CACHED_NIDATA*)item)->inum
|
||
|
% (2*CACHE_NIDATA_SIZE));
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* inum comparing for entering/fetching from cache
|
||
|
*/
|
||
|
|
||
|
static int idata_cache_compare(const struct CACHED_GENERIC *cached,
|
||
|
const struct CACHED_GENERIC *wanted)
|
||
|
{
|
||
|
return (((const struct CACHED_NIDATA*)cached)->inum
|
||
|
!= ((const struct CACHED_NIDATA*)wanted)->inum);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Invalidate an inode entry when not needed anymore.
|
||
|
* The entry should have been synced, it may be reused later,
|
||
|
* if it is requested before it is dropped from cache.
|
||
|
*/
|
||
|
|
||
|
void ntfs_inode_invalidate(ntfs_volume *vol, const MFT_REF mref)
|
||
|
{
|
||
|
struct CACHED_NIDATA item;
|
||
|
int count;
|
||
|
|
||
|
item.inum = MREF(mref);
|
||
|
item.ni = (ntfs_inode*)NULL;
|
||
|
item.pathname = (const char*)NULL;
|
||
|
item.varsize = 0;
|
||
|
count = ntfs_invalidate_cache(vol->nidata_cache,
|
||
|
GENERIC(&item),idata_cache_compare,CACHE_FREE);
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
/*
|
||
|
* Open an inode
|
||
|
*
|
||
|
* When possible, an entry recorded in the cache is reused
|
||
|
*
|
||
|
* **NEVER REOPEN** an inode, this can lead to a duplicated
|
||
|
* cache entry (hard to detect), and to an obsolete one being
|
||
|
* reused. System files are however protected from being cached.
|
||
|
*/
|
||
|
|
||
|
ntfs_inode *ntfs_inode_open(ntfs_volume *vol, const MFT_REF mref)
|
||
|
{
|
||
|
ntfs_inode *ni;
|
||
|
#if CACHE_NIDATA_SIZE
|
||
|
struct CACHED_NIDATA item;
|
||
|
struct CACHED_NIDATA *cached;
|
||
|
|
||
|
/* fetch idata from cache */
|
||
|
item.inum = MREF(mref);
|
||
|
debug_double_inode(item.inum,1);
|
||
|
item.pathname = (const char*)NULL;
|
||
|
item.varsize = 0;
|
||
|
cached = (struct CACHED_NIDATA*)ntfs_fetch_cache(vol->nidata_cache,
|
||
|
GENERIC(&item),idata_cache_compare);
|
||
|
if (cached) {
|
||
|
ni = cached->ni;
|
||
|
/* do not keep open entries in cache */
|
||
|
ntfs_remove_cache(vol->nidata_cache,
|
||
|
(struct CACHED_GENERIC*)cached,0);
|
||
|
} else {
|
||
|
ni = ntfs_inode_real_open(vol, mref);
|
||
|
}
|
||
|
#else
|
||
|
ni = ntfs_inode_real_open(vol, mref);
|
||
|
#endif
|
||
|
return (ni);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Close an inode entry
|
||
|
*
|
||
|
* If cacheing is in use, the entry is synced and kept available
|
||
|
* in cache for further use.
|
||
|
*
|
||
|
* System files (inode < 16 or having the IS_4 flag) are protected
|
||
|
* against being cached.
|
||
|
*/
|
||
|
|
||
|
int ntfs_inode_close(ntfs_inode *ni)
|
||
|
{
|
||
|
int res;
|
||
|
#if CACHE_NIDATA_SIZE
|
||
|
BOOL dirty;
|
||
|
struct CACHED_NIDATA item;
|
||
|
|
||
|
if (ni) {
|
||
|
debug_double_inode(ni->mft_no,0);
|
||
|
/* do not cache system files : could lead to double entries */
|
||
|
if (ni->vol && ni->vol->nidata_cache
|
||
|
&& ((ni->mft_no == FILE_root)
|
||
|
|| ((ni->mft_no >= FILE_first_user)
|
||
|
&& !(ni->mrec->flags & MFT_RECORD_IS_4)))) {
|
||
|
/* If we have dirty metadata, write it out. */
|
||
|
dirty = NInoDirty(ni) || NInoAttrListDirty(ni);
|
||
|
if (dirty) {
|
||
|
res = ntfs_inode_sync(ni);
|
||
|
/* do a real close if sync failed */
|
||
|
if (res)
|
||
|
ntfs_inode_real_close(ni);
|
||
|
} else
|
||
|
res = 0;
|
||
|
|
||
|
if (!res) {
|
||
|
/* feed idata into cache */
|
||
|
item.inum = ni->mft_no;
|
||
|
item.ni = ni;
|
||
|
item.pathname = (const char*)NULL;
|
||
|
item.varsize = 0;
|
||
|
debug_cached_inode(ni);
|
||
|
ntfs_enter_cache(ni->vol->nidata_cache,
|
||
|
GENERIC(&item), idata_cache_compare);
|
||
|
}
|
||
|
} else {
|
||
|
/* cache not ready or system file, really close */
|
||
|
res = ntfs_inode_real_close(ni);
|
||
|
}
|
||
|
} else
|
||
|
res = 0;
|
||
|
#else
|
||
|
res = ntfs_inode_real_close(ni);
|
||
|
#endif
|
||
|
return (res);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_extent_inode_open - load an extent inode and attach it to its base
|
||
|
* @base_ni: base ntfs inode
|
||
|
* @mref: mft reference of the extent inode to load (in little endian)
|
||
|
*
|
||
|
* First check if the extent inode @mref is already attached to the base ntfs
|
||
|
* inode @base_ni, and if so, return a pointer to the attached extent inode.
|
||
|
*
|
||
|
* If the extent inode is not already attached to the base inode, allocate an
|
||
|
* ntfs_inode structure and initialize it for the given inode @mref. @mref
|
||
|
* specifies the inode number / mft record to read, including the sequence
|
||
|
* number, which can be 0 if no sequence number checking is to be performed.
|
||
|
*
|
||
|
* Then, allocate a buffer for the mft record, read the mft record from the
|
||
|
* volume @base_ni->vol, and attach it to the ntfs_inode structure (->mrec).
|
||
|
* The mft record is mst deprotected and sanity checked for validity and we
|
||
|
* abort if deprotection or checks fail.
|
||
|
*
|
||
|
* Finally attach the ntfs inode to its base inode @base_ni and return a
|
||
|
* pointer to the ntfs_inode structure on success or NULL on error, with errno
|
||
|
* set to the error code.
|
||
|
*
|
||
|
* Note, extent inodes are never closed directly. They are automatically
|
||
|
* disposed off by the closing of the base inode.
|
||
|
*/
|
||
|
ntfs_inode *ntfs_extent_inode_open(ntfs_inode *base_ni, const MFT_REF mref)
|
||
|
{
|
||
|
u64 mft_no = MREF_LE(mref);
|
||
|
ntfs_inode *ni = NULL;
|
||
|
ntfs_inode **extent_nis;
|
||
|
int i;
|
||
|
|
||
|
if (!base_ni) {
|
||
|
errno = EINVAL;
|
||
|
ntfs_log_perror("%s", __FUNCTION__);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
ntfs_log_enter("Opening extent inode %lld (base mft record %lld).\n",
|
||
|
(unsigned long long)mft_no,
|
||
|
(unsigned long long)base_ni->mft_no);
|
||
|
|
||
|
/* Is the extent inode already open and attached to the base inode? */
|
||
|
if (base_ni->nr_extents > 0) {
|
||
|
extent_nis = base_ni->extent_nis;
|
||
|
for (i = 0; i < base_ni->nr_extents; i++) {
|
||
|
u16 seq_no;
|
||
|
|
||
|
ni = extent_nis[i];
|
||
|
if (mft_no != ni->mft_no)
|
||
|
continue;
|
||
|
/* Verify the sequence number if given. */
|
||
|
seq_no = MSEQNO_LE(mref);
|
||
|
if (seq_no && seq_no != le16_to_cpu(
|
||
|
ni->mrec->sequence_number)) {
|
||
|
errno = EIO;
|
||
|
ntfs_log_perror("Found stale extent mft "
|
||
|
"reference mft=%lld",
|
||
|
(long long)ni->mft_no);
|
||
|
goto out;
|
||
|
}
|
||
|
goto out;
|
||
|
}
|
||
|
}
|
||
|
/* Wasn't there, we need to load the extent inode. */
|
||
|
ni = __ntfs_inode_allocate(base_ni->vol);
|
||
|
if (!ni)
|
||
|
goto out;
|
||
|
if (ntfs_file_record_read(base_ni->vol, le64_to_cpu(mref), &ni->mrec, NULL))
|
||
|
goto err_out;
|
||
|
ni->mft_no = mft_no;
|
||
|
ni->nr_extents = -1;
|
||
|
ni->base_ni = base_ni;
|
||
|
/* Attach extent inode to base inode, reallocating memory if needed. */
|
||
|
if (!(base_ni->nr_extents & 3)) {
|
||
|
i = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
|
||
|
|
||
|
extent_nis = ntfs_malloc(i);
|
||
|
if (!extent_nis)
|
||
|
goto err_out;
|
||
|
if (base_ni->nr_extents) {
|
||
|
memcpy(extent_nis, base_ni->extent_nis,
|
||
|
i - 4 * sizeof(ntfs_inode *));
|
||
|
free(base_ni->extent_nis);
|
||
|
}
|
||
|
base_ni->extent_nis = extent_nis;
|
||
|
}
|
||
|
base_ni->extent_nis[base_ni->nr_extents++] = ni;
|
||
|
out:
|
||
|
ntfs_log_leave("\n");
|
||
|
return ni;
|
||
|
err_out:
|
||
|
__ntfs_inode_release(ni);
|
||
|
ni = NULL;
|
||
|
goto out;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_attach_all_extents - attach all extents for target inode
|
||
|
* @ni: opened ntfs inode for which perform attach
|
||
|
*
|
||
|
* Return 0 on success and -1 on error with errno set to the error code.
|
||
|
*/
|
||
|
int ntfs_inode_attach_all_extents(ntfs_inode *ni)
|
||
|
{
|
||
|
ATTR_LIST_ENTRY *ale;
|
||
|
u64 prev_attached = 0;
|
||
|
|
||
|
if (!ni) {
|
||
|
ntfs_log_trace("Invalid arguments.\n");
|
||
|
errno = EINVAL;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
if (ni->nr_extents == -1)
|
||
|
ni = ni->base_ni;
|
||
|
|
||
|
ntfs_log_trace("Entering for inode 0x%llx.\n", (long long) ni->mft_no);
|
||
|
|
||
|
/* Inode haven't got attribute list, thus nothing to attach. */
|
||
|
if (!NInoAttrList(ni))
|
||
|
return 0;
|
||
|
|
||
|
if (!ni->attr_list) {
|
||
|
ntfs_log_trace("Corrupt in-memory struct.\n");
|
||
|
errno = EINVAL;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/* Walk through attribute list and attach all extents. */
|
||
|
errno = 0;
|
||
|
ale = (ATTR_LIST_ENTRY *)ni->attr_list;
|
||
|
while ((u8*)ale < ni->attr_list + ni->attr_list_size) {
|
||
|
if (ni->mft_no != MREF_LE(ale->mft_reference) &&
|
||
|
prev_attached != MREF_LE(ale->mft_reference)) {
|
||
|
if (!ntfs_extent_inode_open(ni, ale->mft_reference)) {
|
||
|
ntfs_log_trace("Couldn't attach extent inode.\n");
|
||
|
return -1;
|
||
|
}
|
||
|
prev_attached = MREF_LE(ale->mft_reference);
|
||
|
}
|
||
|
ale = (ATTR_LIST_ENTRY *)((u8*)ale + le16_to_cpu(ale->length));
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_sync_standard_information - update standard information attribute
|
||
|
* @ni: ntfs inode to update standard information
|
||
|
*
|
||
|
* Return 0 on success or -1 on error with errno set to the error code.
|
||
|
*/
|
||
|
static int ntfs_inode_sync_standard_information(ntfs_inode *ni)
|
||
|
{
|
||
|
ntfs_attr_search_ctx *ctx;
|
||
|
STANDARD_INFORMATION *std_info;
|
||
|
u32 lth;
|
||
|
le32 lthle;
|
||
|
|
||
|
ntfs_log_trace("Entering for inode %lld\n", (long long)ni->mft_no);
|
||
|
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (!ctx)
|
||
|
return -1;
|
||
|
if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED,
|
||
|
0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
|
||
|
ntfs_log_perror("Failed to sync standard info (inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
return -1;
|
||
|
}
|
||
|
std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
std_info->file_attributes = ni->flags;
|
||
|
if (!test_nino_flag(ni, TimesSet)) {
|
||
|
std_info->creation_time = ni->creation_time;
|
||
|
std_info->last_data_change_time = ni->last_data_change_time;
|
||
|
std_info->last_mft_change_time = ni->last_mft_change_time;
|
||
|
std_info->last_access_time = ni->last_access_time;
|
||
|
}
|
||
|
|
||
|
/* JPA update v3.x extensions, ensuring consistency */
|
||
|
|
||
|
lthle = ctx->attr->length;
|
||
|
lth = le32_to_cpu(lthle);
|
||
|
if (test_nino_flag(ni, v3_Extensions)
|
||
|
&& (lth <= sizeof(STANDARD_INFORMATION)))
|
||
|
ntfs_log_error("bad sync of standard information\n");
|
||
|
|
||
|
if (lth > sizeof(STANDARD_INFORMATION)) {
|
||
|
std_info->owner_id = ni->owner_id;
|
||
|
std_info->security_id = ni->security_id;
|
||
|
std_info->quota_charged = ni->quota_charged;
|
||
|
std_info->usn = ni->usn;
|
||
|
}
|
||
|
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_sync_file_name - update FILE_NAME attributes
|
||
|
* @ni: ntfs inode to update FILE_NAME attributes
|
||
|
*
|
||
|
* Update all FILE_NAME attributes for inode @ni in the index.
|
||
|
*
|
||
|
* Return 0 on success or -1 on error with errno set to the error code.
|
||
|
*/
|
||
|
static int ntfs_inode_sync_file_name(ntfs_inode *ni, ntfs_inode *dir_ni)
|
||
|
{
|
||
|
ntfs_attr_search_ctx *ctx = NULL;
|
||
|
ntfs_index_context *ictx;
|
||
|
ntfs_inode *index_ni;
|
||
|
FILE_NAME_ATTR *fn;
|
||
|
FILE_NAME_ATTR *fnx;
|
||
|
REPARSE_POINT *rpp;
|
||
|
le32 reparse_tag;
|
||
|
int err = 0;
|
||
|
|
||
|
ntfs_log_trace("Entering for inode %lld\n", (long long)ni->mft_no);
|
||
|
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (!ctx) {
|
||
|
err = errno;
|
||
|
goto err_out;
|
||
|
}
|
||
|
/* Collect the reparse tag, if any */
|
||
|
reparse_tag = cpu_to_le32(0);
|
||
|
if (ni->flags & FILE_ATTR_REPARSE_POINT) {
|
||
|
if (!ntfs_attr_lookup(AT_REPARSE_POINT, NULL,
|
||
|
0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
|
||
|
rpp = (REPARSE_POINT*)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
reparse_tag = rpp->reparse_tag;
|
||
|
}
|
||
|
ntfs_attr_reinit_search_ctx(ctx);
|
||
|
}
|
||
|
/* Walk through all FILE_NAME attributes and update them. */
|
||
|
while (!ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, 0, 0, NULL, 0, ctx)) {
|
||
|
fn = (FILE_NAME_ATTR *)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
if (MREF_LE(fn->parent_directory) == ni->mft_no) {
|
||
|
/*
|
||
|
* WARNING: We cheat here and obtain 2 attribute
|
||
|
* search contexts for one inode (first we obtained
|
||
|
* above, second will be obtained inside
|
||
|
* ntfs_index_lookup), it's acceptable for library,
|
||
|
* but will deadlock in the kernel.
|
||
|
*/
|
||
|
index_ni = ni;
|
||
|
} else
|
||
|
if (dir_ni)
|
||
|
index_ni = dir_ni;
|
||
|
else
|
||
|
index_ni = ntfs_inode_open(ni->vol,
|
||
|
le64_to_cpu(fn->parent_directory));
|
||
|
if (!index_ni) {
|
||
|
if (!err)
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Failed to open inode %lld with index",
|
||
|
(long long)le64_to_cpu(fn->parent_directory));
|
||
|
continue;
|
||
|
}
|
||
|
ictx = ntfs_index_ctx_get(index_ni, NTFS_INDEX_I30, 4);
|
||
|
if (!ictx) {
|
||
|
if (!err)
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Failed to get index ctx, inode %lld",
|
||
|
(long long)index_ni->mft_no);
|
||
|
if ((ni != index_ni) && !dir_ni
|
||
|
&& ntfs_inode_close(index_ni) && !err)
|
||
|
err = errno;
|
||
|
continue;
|
||
|
}
|
||
|
if (ntfs_index_lookup(fn, sizeof(FILE_NAME_ATTR), ictx)) {
|
||
|
if (!err) {
|
||
|
if (errno == ENOENT)
|
||
|
err = EIO;
|
||
|
else
|
||
|
err = errno;
|
||
|
}
|
||
|
ntfs_log_perror("Index lookup failed, inode %lld",
|
||
|
(long long)index_ni->mft_no);
|
||
|
ntfs_index_ctx_put(ictx);
|
||
|
if (ni != index_ni && ntfs_inode_close(index_ni) && !err)
|
||
|
err = errno;
|
||
|
continue;
|
||
|
}
|
||
|
/* Update flags and file size. */
|
||
|
fnx = (FILE_NAME_ATTR *)ictx->data;
|
||
|
fnx->file_attributes =
|
||
|
(fnx->file_attributes & ~FILE_ATTR_VALID_FLAGS) |
|
||
|
(ni->flags & FILE_ATTR_VALID_FLAGS);
|
||
|
if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
|
||
|
fnx->data_size = fnx->allocated_size
|
||
|
= const_cpu_to_le64(0);
|
||
|
else {
|
||
|
fnx->allocated_size = cpu_to_sle64(ni->allocated_size);
|
||
|
fnx->data_size = cpu_to_sle64(ni->data_size);
|
||
|
}
|
||
|
/* update or clear the reparse tag in the index */
|
||
|
fnx->reparse_point_tag = reparse_tag;
|
||
|
if (!test_nino_flag(ni, TimesSet)) {
|
||
|
fnx->creation_time = ni->creation_time;
|
||
|
fnx->last_data_change_time = ni->last_data_change_time;
|
||
|
fnx->last_mft_change_time = ni->last_mft_change_time;
|
||
|
fnx->last_access_time = ni->last_access_time;
|
||
|
} else {
|
||
|
fnx->creation_time = fn->creation_time;
|
||
|
fnx->last_data_change_time = fn->last_data_change_time;
|
||
|
fnx->last_mft_change_time = fn->last_mft_change_time;
|
||
|
fnx->last_access_time = fn->last_access_time;
|
||
|
}
|
||
|
ntfs_index_entry_mark_dirty(ictx);
|
||
|
ntfs_index_ctx_put(ictx);
|
||
|
if ((ni != index_ni) && !dir_ni
|
||
|
&& ntfs_inode_close(index_ni) && !err)
|
||
|
err = errno;
|
||
|
}
|
||
|
/* Check for real error occurred. */
|
||
|
if (errno != ENOENT) {
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Attribute lookup failed, inode %lld",
|
||
|
(long long)ni->mft_no);
|
||
|
goto err_out;
|
||
|
}
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
if (err) {
|
||
|
errno = err;
|
||
|
return -1;
|
||
|
}
|
||
|
return 0;
|
||
|
err_out:
|
||
|
if (ctx)
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
errno = err;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_sync - write the inode (and its dirty extents) to disk
|
||
|
* @ni: ntfs inode to write
|
||
|
*
|
||
|
* Write the inode @ni to disk as well as its dirty extent inodes if such
|
||
|
* exist and @ni is a base inode. If @ni is an extent inode, only @ni is
|
||
|
* written completely disregarding its base inode and any other extent inodes.
|
||
|
*
|
||
|
* For a base inode with dirty extent inodes if any writes fail for whatever
|
||
|
* reason, the failing inode is skipped and the sync process is continued. At
|
||
|
* the end the error condition that brought about the failure is returned. Thus
|
||
|
* the smallest amount of data loss possible occurs.
|
||
|
*
|
||
|
* Return 0 on success or -1 on error with errno set to the error code.
|
||
|
* The following error codes are defined:
|
||
|
* EINVAL - Invalid arguments were passed to the function.
|
||
|
* EBUSY - Inode and/or one of its extents is busy, try again later.
|
||
|
* EIO - I/O error while writing the inode (or one of its extents).
|
||
|
*/
|
||
|
static int ntfs_inode_sync_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
|
||
|
{
|
||
|
int ret = 0;
|
||
|
int err = 0;
|
||
|
if (!ni) {
|
||
|
errno = EINVAL;
|
||
|
ntfs_log_error("Failed to sync NULL inode\n");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
ntfs_log_enter("Entering for inode %lld\n", (long long)ni->mft_no);
|
||
|
|
||
|
/* Update STANDARD_INFORMATION. */
|
||
|
if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
|
||
|
ntfs_inode_sync_standard_information(ni)) {
|
||
|
if (!err || errno == EIO) {
|
||
|
err = errno;
|
||
|
if (err != EIO)
|
||
|
err = EBUSY;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* Update FILE_NAME's in the index. */
|
||
|
if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
|
||
|
NInoFileNameTestAndClearDirty(ni) &&
|
||
|
ntfs_inode_sync_file_name(ni, dir_ni)) {
|
||
|
if (!err || errno == EIO) {
|
||
|
err = errno;
|
||
|
if (err != EIO)
|
||
|
err = EBUSY;
|
||
|
}
|
||
|
ntfs_log_perror("Failed to sync FILE_NAME (inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
NInoFileNameSetDirty(ni);
|
||
|
}
|
||
|
|
||
|
/* Write out attribute list from cache to disk. */
|
||
|
if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
|
||
|
NInoAttrList(ni) && NInoAttrListTestAndClearDirty(ni)) {
|
||
|
ntfs_attr *na;
|
||
|
|
||
|
na = ntfs_attr_open(ni, AT_ATTRIBUTE_LIST, AT_UNNAMED, 0);
|
||
|
if (!na) {
|
||
|
if (!err || errno == EIO) {
|
||
|
err = errno;
|
||
|
if (err != EIO)
|
||
|
err = EBUSY;
|
||
|
ntfs_log_perror("Attribute list sync failed "
|
||
|
"(open, inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
}
|
||
|
NInoAttrListSetDirty(ni);
|
||
|
goto sync_inode;
|
||
|
}
|
||
|
|
||
|
if (na->data_size == ni->attr_list_size) {
|
||
|
if (ntfs_attr_pwrite(na, 0, ni->attr_list_size,
|
||
|
ni->attr_list) != ni->attr_list_size) {
|
||
|
if (!err || errno == EIO) {
|
||
|
err = errno;
|
||
|
if (err != EIO)
|
||
|
err = EBUSY;
|
||
|
ntfs_log_perror("Attribute list sync "
|
||
|
"failed (write, inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
}
|
||
|
NInoAttrListSetDirty(ni);
|
||
|
}
|
||
|
} else {
|
||
|
err = EIO;
|
||
|
ntfs_log_error("Attribute list sync failed (bad size, "
|
||
|
"inode %lld)\n", (long long)ni->mft_no);
|
||
|
NInoAttrListSetDirty(ni);
|
||
|
}
|
||
|
ntfs_attr_close(na);
|
||
|
}
|
||
|
|
||
|
sync_inode:
|
||
|
/* Write this inode out to the $MFT (and $MFTMirr if applicable). */
|
||
|
if (NInoTestAndClearDirty(ni)) {
|
||
|
if (ntfs_mft_record_write(ni->vol, ni->mft_no, ni->mrec)) {
|
||
|
if (!err || errno == EIO) {
|
||
|
err = errno;
|
||
|
if (err != EIO)
|
||
|
err = EBUSY;
|
||
|
}
|
||
|
NInoSetDirty(ni);
|
||
|
ntfs_log_perror("MFT record sync failed, inode %lld",
|
||
|
(long long)ni->mft_no);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* If this is a base inode with extents write all dirty extents, too. */
|
||
|
if (ni->nr_extents > 0) {
|
||
|
s32 i;
|
||
|
|
||
|
for (i = 0; i < ni->nr_extents; ++i) {
|
||
|
ntfs_inode *eni;
|
||
|
|
||
|
eni = ni->extent_nis[i];
|
||
|
if (!NInoTestAndClearDirty(eni))
|
||
|
continue;
|
||
|
|
||
|
if (ntfs_mft_record_write(eni->vol, eni->mft_no,
|
||
|
eni->mrec)) {
|
||
|
if (!err || errno == EIO) {
|
||
|
err = errno;
|
||
|
if (err != EIO)
|
||
|
err = EBUSY;
|
||
|
}
|
||
|
NInoSetDirty(eni);
|
||
|
ntfs_log_perror("Extent MFT record sync failed,"
|
||
|
" inode %lld/%lld",
|
||
|
(long long)ni->mft_no,
|
||
|
(long long)eni->mft_no);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (err) {
|
||
|
errno = err;
|
||
|
ret = -1;
|
||
|
}
|
||
|
|
||
|
ntfs_log_leave("\n");
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
int ntfs_inode_sync(ntfs_inode *ni)
|
||
|
{
|
||
|
return (ntfs_inode_sync_in_dir(ni, (ntfs_inode*)NULL));
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Close an inode with an open parent inode
|
||
|
*/
|
||
|
|
||
|
int ntfs_inode_close_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
|
||
|
{
|
||
|
int res;
|
||
|
|
||
|
res = ntfs_inode_sync_in_dir(ni, dir_ni);
|
||
|
if (res) {
|
||
|
if (errno != EIO)
|
||
|
errno = EBUSY;
|
||
|
} else
|
||
|
res = ntfs_inode_close(ni);
|
||
|
return (res);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_add_attrlist - add attribute list to inode and fill it
|
||
|
* @ni: opened ntfs inode to which add attribute list
|
||
|
*
|
||
|
* Return 0 on success or -1 on error with errno set to the error code.
|
||
|
* The following error codes are defined:
|
||
|
* EINVAL - Invalid arguments were passed to the function.
|
||
|
* EEXIST - Attribute list already exist.
|
||
|
* EIO - Input/Ouput error occurred.
|
||
|
* ENOMEM - Not enough memory to perform add.
|
||
|
*/
|
||
|
int ntfs_inode_add_attrlist(ntfs_inode *ni)
|
||
|
{
|
||
|
int err;
|
||
|
ntfs_attr_search_ctx *ctx;
|
||
|
u8 *al = NULL, *aln;
|
||
|
int al_len = 0;
|
||
|
ATTR_LIST_ENTRY *ale = NULL;
|
||
|
ntfs_attr *na;
|
||
|
|
||
|
if (!ni) {
|
||
|
errno = EINVAL;
|
||
|
ntfs_log_perror("%s", __FUNCTION__);
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
ntfs_log_trace("inode %llu\n", (unsigned long long) ni->mft_no);
|
||
|
|
||
|
if (NInoAttrList(ni) || ni->nr_extents) {
|
||
|
errno = EEXIST;
|
||
|
ntfs_log_perror("Inode already has attribute list");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/* Form attribute list. */
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (!ctx) {
|
||
|
err = errno;
|
||
|
goto err_out;
|
||
|
}
|
||
|
/* Walk through all attributes. */
|
||
|
while (!ntfs_attr_lookup(AT_UNUSED, NULL, 0, 0, 0, NULL, 0, ctx)) {
|
||
|
|
||
|
int ale_size;
|
||
|
|
||
|
if (ctx->attr->type == AT_ATTRIBUTE_LIST) {
|
||
|
err = EIO;
|
||
|
ntfs_log_perror("Attribute list already present");
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
|
||
|
ale_size = (sizeof(ATTR_LIST_ENTRY) + sizeof(ntfschar) *
|
||
|
ctx->attr->name_length + 7) & ~7;
|
||
|
al_len += ale_size;
|
||
|
|
||
|
aln = realloc(al, al_len);
|
||
|
if (!aln) {
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Failed to realloc %d bytes", al_len);
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
ale = (ATTR_LIST_ENTRY *)(aln + ((u8 *)ale - al));
|
||
|
al = aln;
|
||
|
|
||
|
memset(ale, 0, ale_size);
|
||
|
|
||
|
/* Add attribute to attribute list. */
|
||
|
ale->type = ctx->attr->type;
|
||
|
ale->length = cpu_to_le16((sizeof(ATTR_LIST_ENTRY) +
|
||
|
sizeof(ntfschar) * ctx->attr->name_length + 7) & ~7);
|
||
|
ale->name_length = ctx->attr->name_length;
|
||
|
ale->name_offset = (u8 *)ale->name - (u8 *)ale;
|
||
|
if (ctx->attr->non_resident)
|
||
|
ale->lowest_vcn = ctx->attr->lowest_vcn;
|
||
|
else
|
||
|
ale->lowest_vcn = 0;
|
||
|
ale->mft_reference = MK_LE_MREF(ni->mft_no,
|
||
|
le16_to_cpu(ni->mrec->sequence_number));
|
||
|
ale->instance = ctx->attr->instance;
|
||
|
memcpy(ale->name, (u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->name_offset),
|
||
|
ctx->attr->name_length * sizeof(ntfschar));
|
||
|
ale = (ATTR_LIST_ENTRY *)(al + al_len);
|
||
|
}
|
||
|
/* Check for real error occurred. */
|
||
|
if (errno != ENOENT) {
|
||
|
err = errno;
|
||
|
ntfs_log_perror("%s: Attribute lookup failed, inode %lld",
|
||
|
__FUNCTION__, (long long)ni->mft_no);
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
|
||
|
/* Set in-memory attribute list. */
|
||
|
ni->attr_list = al;
|
||
|
ni->attr_list_size = al_len;
|
||
|
NInoSetAttrList(ni);
|
||
|
NInoAttrListSetDirty(ni);
|
||
|
|
||
|
/* Free space if there is not enough it for $ATTRIBUTE_LIST. */
|
||
|
if (le32_to_cpu(ni->mrec->bytes_allocated) -
|
||
|
le32_to_cpu(ni->mrec->bytes_in_use) <
|
||
|
offsetof(ATTR_RECORD, resident_end)) {
|
||
|
if (ntfs_inode_free_space(ni,
|
||
|
offsetof(ATTR_RECORD, resident_end))) {
|
||
|
/* Failed to free space. */
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Failed to free space for attrlist");
|
||
|
goto rollback;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* Add $ATTRIBUTE_LIST to mft record. */
|
||
|
if (ntfs_resident_attr_record_add(ni,
|
||
|
AT_ATTRIBUTE_LIST, NULL, 0, NULL, 0, 0) < 0) {
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Couldn't add $ATTRIBUTE_LIST to MFT");
|
||
|
goto rollback;
|
||
|
}
|
||
|
|
||
|
/* Resize it. */
|
||
|
na = ntfs_attr_open(ni, AT_ATTRIBUTE_LIST, AT_UNNAMED, 0);
|
||
|
if (!na) {
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Failed to open just added $ATTRIBUTE_LIST");
|
||
|
goto remove_attrlist_record;
|
||
|
}
|
||
|
if (ntfs_attr_truncate(na, al_len)) {
|
||
|
err = errno;
|
||
|
ntfs_log_perror("Failed to resize just added $ATTRIBUTE_LIST");
|
||
|
ntfs_attr_close(na);
|
||
|
goto remove_attrlist_record;;
|
||
|
}
|
||
|
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
ntfs_attr_close(na);
|
||
|
return 0;
|
||
|
|
||
|
remove_attrlist_record:
|
||
|
/* Prevent ntfs_attr_recorm_rm from freeing attribute list. */
|
||
|
ni->attr_list = NULL;
|
||
|
NInoClearAttrList(ni);
|
||
|
/* Remove $ATTRIBUTE_LIST record. */
|
||
|
ntfs_attr_reinit_search_ctx(ctx);
|
||
|
if (!ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0,
|
||
|
CASE_SENSITIVE, 0, NULL, 0, ctx)) {
|
||
|
if (ntfs_attr_record_rm(ctx))
|
||
|
ntfs_log_perror("Rollback failed to remove attrlist");
|
||
|
} else
|
||
|
ntfs_log_perror("Rollback failed to find attrlist");
|
||
|
/* Setup back in-memory runlist. */
|
||
|
ni->attr_list = al;
|
||
|
ni->attr_list_size = al_len;
|
||
|
NInoSetAttrList(ni);
|
||
|
rollback:
|
||
|
/*
|
||
|
* Scan attribute list for attributes that placed not in the base MFT
|
||
|
* record and move them to it.
|
||
|
*/
|
||
|
ntfs_attr_reinit_search_ctx(ctx);
|
||
|
ale = (ATTR_LIST_ENTRY*)al;
|
||
|
while ((u8*)ale < al + al_len) {
|
||
|
if (MREF_LE(ale->mft_reference) != ni->mft_no) {
|
||
|
if (!ntfs_attr_lookup(ale->type, ale->name,
|
||
|
ale->name_length,
|
||
|
CASE_SENSITIVE,
|
||
|
sle64_to_cpu(ale->lowest_vcn),
|
||
|
NULL, 0, ctx)) {
|
||
|
if (ntfs_attr_record_move_to(ctx, ni))
|
||
|
ntfs_log_perror("Rollback failed to "
|
||
|
"move attribute");
|
||
|
} else
|
||
|
ntfs_log_perror("Rollback failed to find attr");
|
||
|
ntfs_attr_reinit_search_ctx(ctx);
|
||
|
}
|
||
|
ale = (ATTR_LIST_ENTRY*)((u8*)ale + le16_to_cpu(ale->length));
|
||
|
}
|
||
|
/* Remove in-memory attribute list. */
|
||
|
ni->attr_list = NULL;
|
||
|
ni->attr_list_size = 0;
|
||
|
NInoClearAttrList(ni);
|
||
|
NInoAttrListClearDirty(ni);
|
||
|
put_err_out:
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
err_out:
|
||
|
free(al);
|
||
|
errno = err;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_free_space - free space in the MFT record of an inode
|
||
|
* @ni: ntfs inode in which MFT record needs more free space
|
||
|
* @size: amount of space needed to free
|
||
|
*
|
||
|
* Return 0 on success or -1 on error with errno set to the error code.
|
||
|
*/
|
||
|
int ntfs_inode_free_space(ntfs_inode *ni, int size)
|
||
|
{
|
||
|
ntfs_attr_search_ctx *ctx;
|
||
|
int freed;
|
||
|
|
||
|
if (!ni || size < 0) {
|
||
|
errno = EINVAL;
|
||
|
ntfs_log_perror("%s: ni=%p size=%d", __FUNCTION__, ni, size);
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
ntfs_log_trace("Entering for inode %lld, size %d\n",
|
||
|
(unsigned long long)ni->mft_no, size);
|
||
|
|
||
|
freed = (le32_to_cpu(ni->mrec->bytes_allocated) -
|
||
|
le32_to_cpu(ni->mrec->bytes_in_use));
|
||
|
|
||
|
if (size <= freed)
|
||
|
return 0;
|
||
|
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (!ctx)
|
||
|
return -1;
|
||
|
/*
|
||
|
* $STANDARD_INFORMATION and $ATTRIBUTE_LIST must stay in the base MFT
|
||
|
* record, so position search context on the first attribute after them.
|
||
|
*/
|
||
|
if (ntfs_attr_position(AT_FILE_NAME, ctx))
|
||
|
goto put_err_out;
|
||
|
|
||
|
while (1) {
|
||
|
int record_size;
|
||
|
/*
|
||
|
* Check whether attribute is from different MFT record. If so,
|
||
|
* find next, because we don't need such.
|
||
|
*/
|
||
|
while (ctx->ntfs_ino->mft_no != ni->mft_no) {
|
||
|
retry:
|
||
|
if (ntfs_attr_position(AT_UNUSED, ctx))
|
||
|
goto put_err_out;
|
||
|
}
|
||
|
|
||
|
if (ntfs_inode_base(ctx->ntfs_ino)->mft_no == FILE_MFT &&
|
||
|
ctx->attr->type == AT_DATA)
|
||
|
goto retry;
|
||
|
|
||
|
if (ctx->attr->type == AT_INDEX_ROOT)
|
||
|
goto retry;
|
||
|
|
||
|
record_size = le32_to_cpu(ctx->attr->length);
|
||
|
|
||
|
if (ntfs_attr_record_move_away(ctx, 0)) {
|
||
|
ntfs_log_perror("Failed to move out attribute #2");
|
||
|
break;
|
||
|
}
|
||
|
freed += record_size;
|
||
|
|
||
|
/* Check whether we are done. */
|
||
|
if (size <= freed) {
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
return 0;
|
||
|
}
|
||
|
/*
|
||
|
* Reposition to first attribute after $STANDARD_INFORMATION
|
||
|
* and $ATTRIBUTE_LIST instead of simply skipping this attribute
|
||
|
* because in the case when we have got only in-memory attribute
|
||
|
* list then ntfs_attr_lookup will fail when it tries to find
|
||
|
* $ATTRIBUTE_LIST.
|
||
|
*/
|
||
|
ntfs_attr_reinit_search_ctx(ctx);
|
||
|
if (ntfs_attr_position(AT_FILE_NAME, ctx))
|
||
|
break;
|
||
|
}
|
||
|
put_err_out:
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
if (errno == ENOSPC)
|
||
|
ntfs_log_trace("No attributes left that could be moved out.\n");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_update_times - update selected time fields for ntfs inode
|
||
|
* @ni: ntfs inode for which update time fields
|
||
|
* @mask: select which time fields should be updated
|
||
|
*
|
||
|
* This function updates time fields to current time. Fields to update are
|
||
|
* selected using @mask (see enum @ntfs_time_update_flags for posssible values).
|
||
|
*/
|
||
|
void ntfs_inode_update_times(ntfs_inode *ni, ntfs_time_update_flags mask)
|
||
|
{
|
||
|
ntfs_time now;
|
||
|
|
||
|
if (!ni) {
|
||
|
ntfs_log_error("%s(): Invalid arguments.\n", __FUNCTION__);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ((ni->mft_no < FILE_first_user && ni->mft_no != FILE_root) ||
|
||
|
NVolReadOnly(ni->vol) || !mask)
|
||
|
return;
|
||
|
|
||
|
now = ntfs_current_time();
|
||
|
if (mask & NTFS_UPDATE_ATIME)
|
||
|
ni->last_access_time = now;
|
||
|
if (mask & NTFS_UPDATE_MTIME)
|
||
|
ni->last_data_change_time = now;
|
||
|
if (mask & NTFS_UPDATE_CTIME)
|
||
|
ni->last_mft_change_time = now;
|
||
|
|
||
|
NInoFileNameSetDirty(ni);
|
||
|
NInoSetDirty(ni);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* ntfs_inode_badclus_bad - check for $Badclus:$Bad data attribute
|
||
|
* @mft_no: mft record number where @attr is present
|
||
|
* @attr: attribute record used to check for the $Bad attribute
|
||
|
*
|
||
|
* Check if the mft record given by @mft_no and @attr contains the bad sector
|
||
|
* list. Please note that mft record numbers describing $Badclus extent inodes
|
||
|
* will not match the current $Badclus:$Bad check.
|
||
|
*
|
||
|
* On success return 1 if the file is $Badclus:$Bad, otherwise return 0.
|
||
|
* On error return -1 with errno set to the error code.
|
||
|
*/
|
||
|
int ntfs_inode_badclus_bad(u64 mft_no, ATTR_RECORD *attr)
|
||
|
{
|
||
|
int len, ret = 0;
|
||
|
ntfschar *ustr;
|
||
|
|
||
|
if (!attr) {
|
||
|
ntfs_log_error("Invalid argument.\n");
|
||
|
errno = EINVAL;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
if (mft_no != FILE_BadClus)
|
||
|
return 0;
|
||
|
|
||
|
if (attr->type != AT_DATA)
|
||
|
return 0;
|
||
|
|
||
|
if ((ustr = ntfs_str2ucs("$Bad", &len)) == NULL) {
|
||
|
ntfs_log_perror("Couldn't convert '$Bad' to Unicode");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
if (ustr && ntfs_names_are_equal(ustr, len,
|
||
|
(ntfschar *)((u8 *)attr + le16_to_cpu(attr->name_offset)),
|
||
|
attr->name_length, 0, NULL, 0))
|
||
|
ret = 1;
|
||
|
|
||
|
ntfs_ucsfree(ustr);
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
#ifdef HAVE_SETXATTR /* extended attributes interface required */
|
||
|
|
||
|
/*
|
||
|
* Get high precision NTFS times
|
||
|
*
|
||
|
* They are returned in following order : create, update, access, change
|
||
|
* provided they fit in requested size.
|
||
|
*
|
||
|
* Returns the modified size if successfull (or 32 if buffer size is null)
|
||
|
* -errno if failed
|
||
|
*/
|
||
|
|
||
|
int ntfs_inode_get_times(ntfs_inode *ni, char *value, size_t size)
|
||
|
{
|
||
|
ntfs_attr_search_ctx *ctx;
|
||
|
STANDARD_INFORMATION *std_info;
|
||
|
u64 *times;
|
||
|
int ret;
|
||
|
|
||
|
ret = 0;
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (ctx) {
|
||
|
if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED,
|
||
|
0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
|
||
|
ntfs_log_perror("Failed to get standard info (inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
} else {
|
||
|
std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
if (value && (size >= 8)) {
|
||
|
times = (u64*)value;
|
||
|
times[0] = le64_to_cpu(std_info->creation_time);
|
||
|
ret = 8;
|
||
|
if (size >= 16) {
|
||
|
times[1] = le64_to_cpu(std_info->last_data_change_time);
|
||
|
ret = 16;
|
||
|
}
|
||
|
if (size >= 24) {
|
||
|
times[2] = le64_to_cpu(std_info->last_access_time);
|
||
|
ret = 24;
|
||
|
}
|
||
|
if (size >= 32) {
|
||
|
times[3] = le64_to_cpu(std_info->last_mft_change_time);
|
||
|
ret = 32;
|
||
|
}
|
||
|
} else
|
||
|
if (!size)
|
||
|
ret = 32;
|
||
|
else
|
||
|
ret = -ERANGE;
|
||
|
}
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
}
|
||
|
return (ret ? ret : -errno);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Set high precision NTFS times
|
||
|
*
|
||
|
* They are expected in this order : create, update, access
|
||
|
* provided they are present in input. The change time is set to
|
||
|
* current time.
|
||
|
*
|
||
|
* The times are inserted directly in the standard_information and
|
||
|
* file names attributes to avoid manipulating low precision times
|
||
|
*
|
||
|
* Returns 0 if success
|
||
|
* -1 if there were an error (described by errno)
|
||
|
*/
|
||
|
|
||
|
int ntfs_inode_set_times(ntfs_inode *ni, const char *value, size_t size,
|
||
|
int flags)
|
||
|
{
|
||
|
ntfs_attr_search_ctx *ctx;
|
||
|
STANDARD_INFORMATION *std_info;
|
||
|
FILE_NAME_ATTR *fn;
|
||
|
const u64 *times;
|
||
|
ntfs_time now;
|
||
|
int cnt;
|
||
|
int ret;
|
||
|
|
||
|
ret = -1;
|
||
|
if ((size >= 8) && !(flags & XATTR_CREATE)) {
|
||
|
times = (const u64*)value;
|
||
|
now = ntfs_current_time();
|
||
|
/* update the standard information attribute */
|
||
|
ctx = ntfs_attr_get_search_ctx(ni, NULL);
|
||
|
if (ctx) {
|
||
|
if (ntfs_attr_lookup(AT_STANDARD_INFORMATION,
|
||
|
AT_UNNAMED, 0, CASE_SENSITIVE,
|
||
|
0, NULL, 0, ctx)) {
|
||
|
ntfs_log_perror("Failed to get standard info (inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
} else {
|
||
|
std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
/*
|
||
|
* Mark times set to avoid overwriting
|
||
|
* them when the inode is closed.
|
||
|
* The inode structure must also be updated
|
||
|
* (with loss of precision) because of cacheing.
|
||
|
* TODO : use NTFS precision in inode, and
|
||
|
* return sub-second times in getattr()
|
||
|
*/
|
||
|
set_nino_flag(ni, TimesSet);
|
||
|
std_info->creation_time = cpu_to_le64(times[0]);
|
||
|
ni->creation_time
|
||
|
= std_info->creation_time;
|
||
|
if (size >= 16) {
|
||
|
std_info->last_data_change_time = cpu_to_le64(times[1]);
|
||
|
ni->last_data_change_time
|
||
|
= std_info->last_data_change_time;
|
||
|
}
|
||
|
if (size >= 24) {
|
||
|
std_info->last_access_time = cpu_to_le64(times[2]);
|
||
|
ni->last_access_time
|
||
|
= std_info->last_access_time;
|
||
|
}
|
||
|
std_info->last_mft_change_time = now;
|
||
|
ni->last_mft_change_time = now;
|
||
|
ntfs_inode_mark_dirty(ctx->ntfs_ino);
|
||
|
NInoFileNameSetDirty(ni);
|
||
|
|
||
|
/* update the file names attributes */
|
||
|
ntfs_attr_reinit_search_ctx(ctx);
|
||
|
cnt = 0;
|
||
|
while (!ntfs_attr_lookup(AT_FILE_NAME,
|
||
|
AT_UNNAMED, 0, CASE_SENSITIVE,
|
||
|
0, NULL, 0, ctx)) {
|
||
|
fn = (FILE_NAME_ATTR*)((u8 *)ctx->attr +
|
||
|
le16_to_cpu(ctx->attr->value_offset));
|
||
|
fn->creation_time
|
||
|
= cpu_to_le64(times[0]);
|
||
|
if (size >= 16)
|
||
|
fn->last_data_change_time
|
||
|
= cpu_to_le64(times[1]);
|
||
|
if (size >= 24)
|
||
|
fn->last_access_time
|
||
|
= cpu_to_le64(times[2]);
|
||
|
fn->last_mft_change_time = now;
|
||
|
cnt++;
|
||
|
}
|
||
|
if (cnt)
|
||
|
ret = 0;
|
||
|
else {
|
||
|
ntfs_log_perror("Failed to get file names (inode %lld)",
|
||
|
(long long)ni->mft_no);
|
||
|
}
|
||
|
}
|
||
|
ntfs_attr_put_search_ctx(ctx);
|
||
|
}
|
||
|
} else
|
||
|
if (size < 8)
|
||
|
errno = ERANGE;
|
||
|
else
|
||
|
errno = EEXIST;
|
||
|
return (ret);
|
||
|
}
|
||
|
|
||
|
#endif /* HAVE_SETXATTR */
|