/**
* __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;
}
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);
}
void ntfsCloseEntry (ntfs_vd *vd, ntfs_inode *ni)
{
// Sanity check
if (!vd) {
errno = ENODEV;
return;
}
// Lock
ntfsLock(vd);
// Sync the entry (if it is dirty)
if (NInoDirty(ni))
ntfsSync(vd, ni);
// Close the entry
ntfs_inode_close(ni);
// Unlock
ntfsUnlock(vd);
return;
}
/**
* 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_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_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);
/* 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;
}
/**
* ntfs_mft_writepage - check if a metadata page contains dirty mft records
* @page: metadata page possibly containing dirty mft records
* @wbc: writeback control structure
*
* This is called from the VM when it wants to have a dirty $MFT/$DATA metadata
* page cache page cleaned. The VM has already locked the page and marked it
* clean. Instead of writing the page as a conventional ->writepage function
* would do, we check if the page still contains any dirty mft records (it must
* have done at some point in the past since the page was marked dirty) and if
* none are found, i.e. all mft records are clean, we unlock the page and
* return. The VM is then free to do with the page as it pleases. If on the
* other hand we do find any dirty mft records in the page, we redirty the page
* before unlocking it and returning so the VM knows that the page is still
* busy and cannot be thrown out.
*
* Note, we do not actually write any dirty mft records here because they are
* dirty inodes and hence will be written by the VFS inode dirty code paths.
* There is no need to write them from the VM page dirty code paths, too and in
* fact once we implement journalling it would be a complete nightmare having
* two code paths leading to mft record writeout.
*/
static int ntfs_mft_writepage(struct page *page, struct writeback_control *wbc)
{
struct inode *mft_vi = page->mapping->host;
struct super_block *sb = mft_vi->i_sb;
ntfs_volume *vol = NTFS_SB(sb);
u8 *maddr;
MFT_RECORD *m;
ntfs_inode **extent_nis;
unsigned long mft_no;
int nr, i, j;
BOOL is_dirty = FALSE;
BUG_ON(!PageLocked(page));
BUG_ON(PageWriteback(page));
BUG_ON(mft_vi != vol->mft_ino);
/* The first mft record number in the page. */
mft_no = page->index << (PAGE_CACHE_SHIFT - vol->mft_record_size_bits);
/* Number of mft records in the page. */
nr = PAGE_CACHE_SIZE >> vol->mft_record_size_bits;
BUG_ON(!nr);
ntfs_debug("Entering for %i inodes starting at 0x%lx.", nr, mft_no);
/* Iterate over the mft records in the page looking for a dirty one. */
maddr = (u8*)kmap(page);
for (i = 0; i < nr; ++i, ++mft_no, maddr += vol->mft_record_size) {
struct inode *vi;
ntfs_inode *ni, *eni;
ntfs_attr na;
na.mft_no = mft_no;
na.name = NULL;
na.name_len = 0;
na.type = AT_UNUSED;
/*
* Check if the inode corresponding to this mft record is in
* the VFS inode cache and obtain a reference to it if it is.
*/
ntfs_debug("Looking for inode 0x%lx in icache.", mft_no);
/*
* For inode 0, i.e. $MFT itself, we cannot use ilookup5() from
* here or we deadlock because the inode is already locked by
* the kernel (fs/fs-writeback.c::__sync_single_inode()) and
* ilookup5() waits until the inode is unlocked before
* returning it and it never gets unlocked because
* ntfs_mft_writepage() never returns. )-: Fortunately, we
* have inode 0 pinned in icache for the duration of the mount
* so we can access it directly.
*/
if (!mft_no) {
/* Balance the below iput(). */
vi = igrab(mft_vi);
BUG_ON(vi != mft_vi);
} else
vi = ilookup5(sb, mft_no, (test_t)ntfs_test_inode, &na);
if (vi) {
ntfs_debug("Inode 0x%lx is in icache.", mft_no);
/* The inode is in icache. Check if it is dirty. */
ni = NTFS_I(vi);
if (!NInoDirty(ni)) {
/* The inode is not dirty, skip this record. */
ntfs_debug("Inode 0x%lx is not dirty, "
"continuing search.", mft_no);
iput(vi);
continue;
}
ntfs_debug("Inode 0x%lx is dirty, aborting search.",
mft_no);
/* The inode is dirty, no need to search further. */
iput(vi);
is_dirty = TRUE;
break;
}
ntfs_debug("Inode 0x%lx is not in icache.", mft_no);
/* The inode is not in icache. */
/* Skip the record if it is not a mft record (type "FILE"). */
if (!ntfs_is_mft_recordp(maddr)) {
ntfs_debug("Mft record 0x%lx is not a FILE record, "
"continuing search.", mft_no);
continue;
}
m = (MFT_RECORD*)maddr;
/*
* Skip the mft record if it is not in use. FIXME: What about
* deleted/deallocated (extent) inodes? (AIA)
*/
if (!(m->flags & MFT_RECORD_IN_USE)) {
ntfs_debug("Mft record 0x%lx is not in use, "
"continuing search.", mft_no);
continue;
}
/* Skip the mft record if it is a base inode. */
if (!m->base_mft_record) {
ntfs_debug("Mft record 0x%lx is a base record, "
"continuing search.", mft_no);
continue;
}
/*
* This is an extent mft record. Check if the inode
* corresponding to its base mft record is in icache.
*/
na.mft_no = MREF_LE(m->base_mft_record);
ntfs_debug("Mft record 0x%lx is an extent record. Looking "
"for base inode 0x%lx in icache.", mft_no,
na.mft_no);
vi = ilookup5(sb, na.mft_no, (test_t)ntfs_test_inode,
&na);
if (!vi) {
/*
* The base inode is not in icache. Skip this extent
* mft record.
*/
ntfs_debug("Base inode 0x%lx is not in icache, "
"continuing search.", na.mft_no);
continue;
}
ntfs_debug("Base inode 0x%lx is in icache.", na.mft_no);
/*
* The base inode is in icache. Check if it has the extent
* inode corresponding to this extent mft record attached.
*/
ni = NTFS_I(vi);
down(&ni->extent_lock);
if (ni->nr_extents <= 0) {
/*
* The base inode has no attached extent inodes. Skip
* this extent mft record.
*/
up(&ni->extent_lock);
iput(vi);
continue;
}
/* Iterate over the attached extent inodes. */
extent_nis = ni->ext.extent_ntfs_inos;
for (eni = NULL, j = 0; j < ni->nr_extents; ++j) {
if (mft_no == extent_nis[j]->mft_no) {
/*
* Found the extent inode corresponding to this
* extent mft record.
*/
eni = extent_nis[j];
break;
}
}
/*
* If the extent inode was not attached to the base inode, skip
* this extent mft record.
*/
if (!eni) {
up(&ni->extent_lock);
iput(vi);
continue;
}
/*
* Found the extent inode corrsponding to this extent mft
* record. If it is dirty, no need to search further.
*/
if (NInoDirty(eni)) {
up(&ni->extent_lock);
iput(vi);
is_dirty = TRUE;
break;
}
/* The extent inode is not dirty, so do the next record. */
up(&ni->extent_lock);
iput(vi);
}
kunmap(page);
/* If a dirty mft record was found, redirty the page. */
if (is_dirty) {
ntfs_debug("Inode 0x%lx is dirty. Redirtying the page "
"starting at inode 0x%lx.", mft_no,
page->index << (PAGE_CACHE_SHIFT -
vol->mft_record_size_bits));
redirty_page_for_writepage(wbc, page);
unlock_page(page);
} else {
/*
* Keep the VM happy. This must be done otherwise the
* radix-tree tag PAGECACHE_TAG_DIRTY remains set even though
* the page is clean.
*/
BUG_ON(PageWriteback(page));
set_page_writeback(page);
unlock_page(page);
end_page_writeback(page);
}
ntfs_debug("Done.");
return 0;
}