usbloadergx/source/libntfs/inode.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 */