[PATCH 53/76] fs/ntfs: Use inode_sb() helper instead of inode->i_sb

From: Mark Fasheh
Date: Tue May 08 2018 - 14:25:00 EST

Signed-off-by: Mark Fasheh <mfasheh@xxxxxxx>
---
fs/ntfs/aops.c | 16 ++--
fs/ntfs/bitmap.c | 11 ++-
fs/ntfs/dir.c | 10 ++-
fs/ntfs/file.c | 30 ++++---
fs/ntfs/inode.c | 231 +++++++++++++++++++++++++++++++++---------------------
fs/ntfs/inode.h | 2 +-
fs/ntfs/logfile.c | 46 ++++++-----
fs/ntfs/namei.c | 7 +-
8 files changed, 214 insertions(+), 139 deletions(-)

diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index 3a2e509c77c5..f8817dfdc2b8 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -1400,14 +1400,16 @@ static int ntfs_writepage(struct page *page, struct writeback_control *wbc)
// TODO: Implement and replace this with
// return ntfs_write_compressed_block(page);
unlock_page(page);
- ntfs_error(vi->i_sb, "Writing to compressed files is "
+ ntfs_error(inode_sb(vi),
+ "Writing to compressed files is "
"not supported yet. Sorry.");
return -EOPNOTSUPP;
}
// TODO: Implement and remove this check.
if (NInoNonResident(ni) && NInoSparse(ni)) {
unlock_page(page);
- ntfs_error(vi->i_sb, "Writing to sparse files is not "
+ ntfs_error(inode_sb(vi),
+ "Writing to sparse files is not "
"supported yet. Sorry.");
return -EOPNOTSUPP;
}
@@ -1437,7 +1439,7 @@ static int ntfs_writepage(struct page *page, struct writeback_control *wbc)
BUG_ON(page_has_buffers(page));
BUG_ON(!PageUptodate(page));
if (unlikely(page->index > 0)) {
- ntfs_error(vi->i_sb, "BUG()! page->index (0x%lx) > 0. "
+ ntfs_error(inode_sb(vi), "BUG()! page->index (0x%lx) > 0. "
"Aborting write.", page->index);
BUG_ON(PageWriteback(page));
set_page_writeback(page);
@@ -1514,7 +1516,8 @@ static int ntfs_writepage(struct page *page, struct writeback_control *wbc)
return 0;
err_out:
if (err == -ENOMEM) {
- ntfs_warning(vi->i_sb, "Error allocating memory. Redirtying "
+ ntfs_warning(inode_sb(vi),
+ "Error allocating memory. Redirtying "
"page so we try again later.");
/*
* Put the page back on mapping->dirty_pages, but leave its
@@ -1523,7 +1526,8 @@ static int ntfs_writepage(struct page *page, struct writeback_control *wbc)
redirty_page_for_writepage(wbc, page);
err = 0;
} else {
- ntfs_error(vi->i_sb, "Resident attribute write failed with "
+ ntfs_error(inode_sb(vi),
+ "Resident attribute write failed with "
"error %i.", err);
SetPageError(page);
NVolSetErrors(ni->vol);
@@ -1735,7 +1739,7 @@ void mark_ntfs_record_dirty(struct page *page, const unsigned int ofs) {

BUG_ON(!PageUptodate(page));
end = ofs + ni->itype.index.block_size;
- bh_size = VFS_I(ni)->i_sb->s_blocksize;
+ bh_size = inode_sb(VFS_I(ni))->s_blocksize;
spin_lock(&mapping->private_lock);
if (unlikely(!page_has_buffers(page))) {
spin_unlock(&mapping->private_lock);
diff --git a/fs/ntfs/bitmap.c b/fs/ntfs/bitmap.c
index ec130c588d2b..7584c413bdb5 100644
--- a/fs/ntfs/bitmap.c
+++ b/fs/ntfs/bitmap.c
@@ -75,7 +75,8 @@ int __ntfs_bitmap_set_bits_in_run(struct inode *vi, const s64 start_bit,
page = ntfs_map_page(mapping, index);
if (IS_ERR(page)) {
if (!is_rollback)
- ntfs_error(vi->i_sb, "Failed to map first page (error "
+ ntfs_error(inode_sb(vi),
+ "Failed to map first page (error "
"%li), aborting.", PTR_ERR(page));
return PTR_ERR(page);
}
@@ -177,15 +178,17 @@ int __ntfs_bitmap_set_bits_in_run(struct inode *vi, const s64 start_bit,
pos = 0;
if (!pos) {
/* Rollback was successful. */
- ntfs_error(vi->i_sb, "Failed to map subsequent page (error "
+ ntfs_error(inode_sb(vi),
+ "Failed to map subsequent page (error "
"%li), aborting.", PTR_ERR(page));
} else {
/* Rollback failed. */
- ntfs_error(vi->i_sb, "Failed to map subsequent page (error "
+ ntfs_error(inode_sb(vi),
+ "Failed to map subsequent page (error "
"%li) and rollback failed (error %i). "
"Aborting and leaving inconsistent metadata. "
"Unmount and run chkdsk.", PTR_ERR(page), pos);
- NVolSetErrors(NTFS_SB(vi->i_sb));
+ NVolSetErrors(NTFS_SB(inode_sb(vi)));
}
return PTR_ERR(page);
}
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 1a24be9e8405..27505db99278 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1101,7 +1101,7 @@ static int ntfs_readdir(struct file *file, struct dir_context *actor)
s64 ia_pos, ia_start, prev_ia_pos, bmp_pos;
loff_t i_size;
struct inode *bmp_vi, *vdir = file_inode(file);
- struct super_block *sb = vdir->i_sb;
+ struct super_block *sb = inode_sb(vdir);
ntfs_inode *ndir = NTFS_I(vdir);
ntfs_volume *vol = NTFS_SB(sb);
MFT_RECORD *m;
@@ -1517,20 +1517,22 @@ static int ntfs_dir_fsync(struct file *filp, loff_t start, loff_t end,
na.type = AT_BITMAP;
na.name = I30;
na.name_len = 4;
- bmp_vi = ilookup5(vi->i_sb, vi->i_ino, (test_t)ntfs_test_inode, &na);
+ bmp_vi = ilookup5(inode_sb(vi), vi->i_ino, (test_t)ntfs_test_inode,
+ &na);
if (bmp_vi) {
write_inode_now(bmp_vi, !datasync);
iput(bmp_vi);
}
ret = __ntfs_write_inode(vi, 1);
write_inode_now(vi, !datasync);
- err = sync_blockdev(vi->i_sb->s_bdev);
+ err = sync_blockdev(inode_sb(vi)->s_bdev);
if (unlikely(err && !ret))
ret = err;
if (likely(!ret))
ntfs_debug("Done.");
else
- ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx. Error "
+ ntfs_warning(inode_sb(vi),
+ "Failed to f%ssync inode 0x%lx. Error "
"%u.", datasync ? "data" : "", vi->i_ino, -ret);
inode_unlock(vi);
return ret;
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 331910fa8442..8955ab0c2869 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -374,7 +374,7 @@ static ssize_t ntfs_prepare_file_for_write(struct kiocb *iocb,
* compression kick in. This is in contrast to encrypted files
* (see above).
*/
- ntfs_error(vi->i_sb, "Writing to compressed files is not "
+ ntfs_error(inode_sb(vi), "Writing to compressed files is not "
"implemented yet. Sorry.");
err = -EOPNOTSUPP;
goto out;
@@ -439,7 +439,8 @@ static ssize_t ntfs_prepare_file_for_write(struct kiocb *iocb,
iov_iter_truncate(from, ll - pos);
} else {
if (err != -ENOSPC)
- ntfs_error(vi->i_sb, "Cannot perform "
+ ntfs_error(inode_sb(vi),
+ "Cannot perform "
"write to inode "
"0x%lx, attribute "
"type 0x%x, because "
@@ -479,7 +480,8 @@ static ssize_t ntfs_prepare_file_for_write(struct kiocb *iocb,
inode_dio_wait(vi);
err = ntfs_attr_extend_initialized(ni, pos);
if (unlikely(err < 0))
- ntfs_error(vi->i_sb, "Cannot perform write to inode "
+ ntfs_error(inode_sb(vi),
+ "Cannot perform write to inode "
"0x%lx, attribute type 0x%x, because "
"extending the initialized size "
"failed (error %d).", vi->i_ino,
@@ -1412,7 +1414,7 @@ static inline int ntfs_commit_pages_after_non_resident_write(

vi = pages[0]->mapping->host;
ni = NTFS_I(vi);
- blocksize = vi->i_sb->s_blocksize;
+ blocksize = inode_sb(vi)->s_blocksize;
end = pos + bytes;
u = 0;
do {
@@ -1507,7 +1509,8 @@ static inline int ntfs_commit_pages_after_non_resident_write(
ntfs_attr_put_search_ctx(ctx);
if (m)
unmap_mft_record(base_ni);
- ntfs_error(vi->i_sb, "Failed to update initialized_size/i_size (error "
+ ntfs_error(inode_sb(vi),
+ "Failed to update initialized_size/i_size (error "
"code %i).", err);
if (err != -ENOMEM)
NVolSetErrors(ni->vol);
@@ -1664,10 +1667,12 @@ static int ntfs_commit_pages_after_write(struct page **pages,
return 0;
err_out:
if (err == -ENOMEM) {
- ntfs_warning(vi->i_sb, "Error allocating memory required to "
+ ntfs_warning(inode_sb(vi),
+ "Error allocating memory required to "
"commit the write.");
if (PageUptodate(page)) {
- ntfs_warning(vi->i_sb, "Page is uptodate, setting "
+ ntfs_warning(inode_sb(vi),
+ "Page is uptodate, setting "
"dirty so the write will be retried "
"later on by the VM.");
/*
@@ -1677,10 +1682,12 @@ static int ntfs_commit_pages_after_write(struct page **pages,
__set_page_dirty_nobuffers(page);
err = 0;
} else
- ntfs_error(vi->i_sb, "Page is not uptodate. Written "
+ ntfs_error(inode_sb(vi),
+ "Page is not uptodate. Written "
"data has been lost.");
} else {
- ntfs_error(vi->i_sb, "Resident attribute commit write failed "
+ ntfs_error(inode_sb(vi),
+ "Resident attribute commit write failed "
"with error %i.", err);
NVolSetErrors(ni->vol);
}
@@ -2003,13 +2010,14 @@ static int ntfs_file_fsync(struct file *filp, loff_t start, loff_t end,
* fs/buffer.c) for dirty blocks then we could optimize the below to be
* sync_mapping_buffers(vi->i_mapping).
*/
- err = sync_blockdev(vi->i_sb->s_bdev);
+ err = sync_blockdev(inode_sb(vi)->s_bdev);
if (unlikely(err && !ret))
ret = err;
if (likely(!ret))
ntfs_debug("Done.");
else
- ntfs_warning(vi->i_sb, "Failed to f%ssync inode 0x%lx. Error "
+ ntfs_warning(inode_sb(vi),
+ "Failed to f%ssync inode 0x%lx. Error "
"%u.", datasync ? "data" : "", vi->i_ino, -ret);
inode_unlock(vi);
return ret;
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 1c1ee489284b..cde6853c99ac 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -239,8 +239,9 @@ struct inode *ntfs_attr_iget(struct inode *base_vi, ATTR_TYPE type,
na.name = name;
na.name_len = name_len;

- vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode,
- (set_t)ntfs_init_locked_inode, &na);
+ vi = iget5_locked(inode_sb(base_vi), na.mft_no,
+ (test_t)ntfs_test_inode,
+ (set_t)ntfs_init_locked_inode, &na);
if (unlikely(!vi))
return ERR_PTR(-ENOMEM);

@@ -294,8 +295,9 @@ struct inode *ntfs_index_iget(struct inode *base_vi, ntfschar *name,
na.name = name;
na.name_len = name_len;

- vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode,
- (set_t)ntfs_init_locked_inode, &na);
+ vi = iget5_locked(inode_sb(base_vi), na.mft_no,
+ (test_t)ntfs_test_inode,
+ (set_t)ntfs_init_locked_inode, &na);
if (unlikely(!vi))
return ERR_PTR(-ENOMEM);

@@ -548,7 +550,7 @@ static int ntfs_is_extended_system_file(ntfs_attr_search_ctx *ctx)
*/
static int ntfs_read_locked_inode(struct inode *vi)
{
- ntfs_volume *vol = NTFS_SB(vi->i_sb);
+ ntfs_volume *vol = NTFS_SB(inode_sb(vi));
ntfs_inode *ni;
struct inode *bvi;
MFT_RECORD *m;
@@ -584,11 +586,11 @@ static int ntfs_read_locked_inode(struct inode *vi)
}

if (!(m->flags & MFT_RECORD_IN_USE)) {
- ntfs_error(vi->i_sb, "Inode is not in use!");
+ ntfs_error(inode_sb(vi), "Inode is not in use!");
goto unm_err_out;
}
if (m->base_mft_record) {
- ntfs_error(vi->i_sb, "Inode is an extent inode!");
+ ntfs_error(inode_sb(vi), "Inode is an extent inode!");
goto unm_err_out;
}

@@ -647,7 +649,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
* recover mount option is set) by creating a new
* attribute.
*/
- ntfs_error(vi->i_sb, "$STANDARD_INFORMATION attribute "
+ ntfs_error(inode_sb(vi),
+ "$STANDARD_INFORMATION attribute "
"is missing.");
}
goto unm_err_out;
@@ -685,7 +688,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
err = ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0, 0, 0, NULL, 0, ctx);
if (err) {
if (unlikely(err != -ENOENT)) {
- ntfs_error(vi->i_sb, "Failed to lookup attribute list "
+ ntfs_error(inode_sb(vi),
+ "Failed to lookup attribute list "
"attribute.");
goto unm_err_out;
}
@@ -696,19 +700,21 @@ static int ntfs_read_locked_inode(struct inode *vi)
NInoSetAttrList(ni);
a = ctx->attr;
if (a->flags & ATTR_COMPRESSION_MASK) {
- ntfs_error(vi->i_sb, "Attribute list attribute is "
+ ntfs_error(inode_sb(vi),
+ "Attribute list attribute is "
"compressed.");
goto unm_err_out;
}
if (a->flags & ATTR_IS_ENCRYPTED ||
a->flags & ATTR_IS_SPARSE) {
if (a->non_resident) {
- ntfs_error(vi->i_sb, "Non-resident attribute "
+ ntfs_error(inode_sb(vi),
+ "Non-resident attribute "
"list attribute is encrypted/"
"sparse.");
goto unm_err_out;
}
- ntfs_warning(vi->i_sb, "Resident attribute list "
+ ntfs_warning(inode_sb(vi), "Resident attribute list "
"attribute in inode 0x%lx is marked "
"encrypted/sparse which is not true. "
"However, Windows allows this and "
@@ -721,7 +727,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
ni->attr_list_size = (u32)ntfs_attr_size(a);
ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
if (!ni->attr_list) {
- ntfs_error(vi->i_sb, "Not enough memory to allocate "
+ ntfs_error(inode_sb(vi),
+ "Not enough memory to allocate "
"buffer for attribute list.");
err = -ENOMEM;
goto unm_err_out;
@@ -729,7 +736,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
if (a->non_resident) {
NInoSetAttrListNonResident(ni);
if (a->data.non_resident.lowest_vcn) {
- ntfs_error(vi->i_sb, "Attribute list has non "
+ ntfs_error(inode_sb(vi),
+ "Attribute list has non "
"zero lowest_vcn.");
goto unm_err_out;
}
@@ -742,7 +750,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
if (IS_ERR(ni->attr_list_rl.rl)) {
err = PTR_ERR(ni->attr_list_rl.rl);
ni->attr_list_rl.rl = NULL;
- ntfs_error(vi->i_sb, "Mapping pairs "
+ ntfs_error(inode_sb(vi), "Mapping pairs "
"decompression failed.");
goto unm_err_out;
}
@@ -751,7 +759,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
ni->attr_list, ni->attr_list_size,
sle64_to_cpu(a->data.non_resident.
initialized_size)))) {
- ntfs_error(vi->i_sb, "Failed to load "
+ ntfs_error(inode_sb(vi), "Failed to load "
"attribute list attribute.");
goto unm_err_out;
}
@@ -760,7 +768,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
+ le32_to_cpu(
a->data.resident.value_length) >
(u8*)ctx->mrec + vol->mft_record_size) {
- ntfs_error(vi->i_sb, "Corrupt attribute list "
+ ntfs_error(inode_sb(vi),
+ "Corrupt attribute list "
"in inode.");
goto unm_err_out;
}
@@ -791,7 +800,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
// FIXME: File is corrupt! Hot-fix with empty
// index root attribute if recovery option is
// set.
- ntfs_error(vi->i_sb, "$INDEX_ROOT attribute "
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ROOT attribute "
"is missing.");
}
goto unm_err_out;
@@ -820,7 +830,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
NInoSetCompressed(ni);
if (a->flags & ATTR_IS_ENCRYPTED) {
if (a->flags & ATTR_COMPRESSION_MASK) {
- ntfs_error(vi->i_sb, "Found encrypted and "
+ ntfs_error(inode_sb(vi),
+ "Found encrypted and "
"compressed attribute.");
goto unm_err_out;
}
@@ -832,23 +843,25 @@ static int ntfs_read_locked_inode(struct inode *vi)
le16_to_cpu(a->data.resident.value_offset));
ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length);
if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) {
- ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is "
+ ntfs_error(inode_sb(vi), "$INDEX_ROOT attribute is "
"corrupt.");
goto unm_err_out;
}
index_end = (u8*)&ir->index +
le32_to_cpu(ir->index.index_length);
if (index_end > ir_end) {
- ntfs_error(vi->i_sb, "Directory index is corrupt.");
+ ntfs_error(inode_sb(vi),
+ "Directory index is corrupt.");
goto unm_err_out;
}
if (ir->type != AT_FILE_NAME) {
- ntfs_error(vi->i_sb, "Indexed attribute is not "
+ ntfs_error(inode_sb(vi), "Indexed attribute is not "
"$FILE_NAME.");
goto unm_err_out;
}
if (ir->collation_rule != COLLATION_FILE_NAME) {
- ntfs_error(vi->i_sb, "Index collation rule is not "
+ ntfs_error(inode_sb(vi),
+ "Index collation rule is not "
"COLLATION_FILE_NAME.");
goto unm_err_out;
}
@@ -856,13 +869,14 @@ static int ntfs_read_locked_inode(struct inode *vi)
ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);
if (ni->itype.index.block_size &
(ni->itype.index.block_size - 1)) {
- ntfs_error(vi->i_sb, "Index block size (%u) is not a "
+ ntfs_error(inode_sb(vi),
+ "Index block size (%u) is not a "
"power of two.",
ni->itype.index.block_size);
goto unm_err_out;
}
if (ni->itype.index.block_size > PAGE_SIZE) {
- ntfs_error(vi->i_sb, "Index block size (%u) > "
+ ntfs_error(inode_sb(vi), "Index block size (%u) > "
"PAGE_SIZE (%ld) is not "
"supported. Sorry.",
ni->itype.index.block_size,
@@ -871,7 +885,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
goto unm_err_out;
}
if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {
- ntfs_error(vi->i_sb, "Index block size (%u) < "
+ ntfs_error(inode_sb(vi), "Index block size (%u) < "
"NTFS_BLOCK_SIZE (%i) is not "
"supported. Sorry.",
ni->itype.index.block_size,
@@ -914,18 +928,19 @@ static int ntfs_read_locked_inode(struct inode *vi)
CASE_SENSITIVE, 0, NULL, 0, ctx);
if (unlikely(err)) {
if (err == -ENOENT)
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION "
+ ntfs_error(inode_sb(vi), "$INDEX_ALLOCATION "
"attribute is not present but "
"$INDEX_ROOT indicated it is.");
else
- ntfs_error(vi->i_sb, "Failed to lookup "
+ ntfs_error(inode_sb(vi), "Failed to lookup "
"$INDEX_ALLOCATION "
"attribute.");
goto unm_err_out;
}
a = ctx->attr;
if (!a->non_resident) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ALLOCATION attribute "
"is resident.");
goto unm_err_out;
}
@@ -942,22 +957,25 @@ static int ntfs_read_locked_inode(struct inode *vi)
goto unm_err_out;
}
if (a->flags & ATTR_IS_ENCRYPTED) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ALLOCATION attribute "
"is encrypted.");
goto unm_err_out;
}
if (a->flags & ATTR_IS_SPARSE) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ALLOCATION attribute "
"is sparse.");
goto unm_err_out;
}
if (a->flags & ATTR_COMPRESSION_MASK) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ALLOCATION attribute "
"is compressed.");
goto unm_err_out;
}
if (a->data.non_resident.lowest_vcn) {
- ntfs_error(vi->i_sb, "First extent of "
+ ntfs_error(inode_sb(vi), "First extent of "
"$INDEX_ALLOCATION attribute has non "
"zero lowest_vcn.");
goto unm_err_out;
@@ -978,14 +996,16 @@ static int ntfs_read_locked_inode(struct inode *vi)
/* Get the index bitmap attribute inode. */
bvi = ntfs_attr_iget(vi, AT_BITMAP, I30, 4);
if (IS_ERR(bvi)) {
- ntfs_error(vi->i_sb, "Failed to get bitmap attribute.");
+ ntfs_error(inode_sb(vi),
+ "Failed to get bitmap attribute.");
err = PTR_ERR(bvi);
goto unm_err_out;
}
bni = NTFS_I(bvi);
if (NInoCompressed(bni) || NInoEncrypted(bni) ||
NInoSparse(bni)) {
- ntfs_error(vi->i_sb, "$BITMAP attribute is compressed "
+ ntfs_error(inode_sb(vi),
+ "$BITMAP attribute is compressed "
"and/or encrypted and/or sparse.");
goto iput_unm_err_out;
}
@@ -993,7 +1013,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
bvi_size = i_size_read(bvi);
if ((bvi_size << 3) < (vi->i_size >>
ni->itype.index.block_size_bits)) {
- ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) "
+ ntfs_error(inode_sb(vi),
+ "Index bitmap too small (0x%llx) "
"for index allocation (0x%llx).",
bvi_size << 3, vi->i_size);
goto iput_unm_err_out;
@@ -1020,7 +1041,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
vi->i_size = ni->initialized_size =
ni->allocated_size = 0;
if (err != -ENOENT) {
- ntfs_error(vi->i_sb, "Failed to lookup $DATA "
+ ntfs_error(inode_sb(vi),
+ "Failed to lookup $DATA "
"attribute.");
goto unm_err_out;
}
@@ -1043,7 +1065,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
goto no_data_attr_special_case;
// FIXME: File is corrupt! Hot-fix with empty data
// attribute if recovery option is set.
- ntfs_error(vi->i_sb, "$DATA attribute is missing.");
+ ntfs_error(inode_sb(vi),
+ "$DATA attribute is missing.");
goto unm_err_out;
}
a = ctx->attr;
@@ -1052,7 +1075,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
if (a->flags & ATTR_COMPRESSION_MASK) {
NInoSetCompressed(ni);
if (vol->cluster_size > 4096) {
- ntfs_error(vi->i_sb, "Found "
+ ntfs_error(inode_sb(vi), "Found "
"compressed data but "
"compression is "
"disabled due to "
@@ -1063,7 +1086,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
}
if ((a->flags & ATTR_COMPRESSION_MASK)
!= ATTR_IS_COMPRESSED) {
- ntfs_error(vi->i_sb, "Found unknown "
+ ntfs_error(inode_sb(vi),
+ "Found unknown "
"compression method "
"or corrupt file.");
goto unm_err_out;
@@ -1074,7 +1098,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
}
if (a->flags & ATTR_IS_ENCRYPTED) {
if (NInoCompressed(ni)) {
- ntfs_error(vi->i_sb, "Found encrypted and "
+ ntfs_error(inode_sb(vi),
+ "Found encrypted and "
"compressed data.");
goto unm_err_out;
}
@@ -1085,7 +1110,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
if (NInoCompressed(ni) || NInoSparse(ni)) {
if (NInoCompressed(ni) && a->data.non_resident.
compression_unit != 4) {
- ntfs_error(vi->i_sb, "Found "
+ ntfs_error(inode_sb(vi), "Found "
"non-standard "
"compression unit (%u "
"instead of 4). "
@@ -1120,7 +1145,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
compressed_size);
}
if (a->data.non_resident.lowest_vcn) {
- ntfs_error(vi->i_sb, "First extent of $DATA "
+ ntfs_error(inode_sb(vi),
+ "First extent of $DATA "
"attribute has non zero "
"lowest_vcn.");
goto unm_err_out;
@@ -1138,7 +1164,8 @@ static int ntfs_read_locked_inode(struct inode *vi)
le16_to_cpu(
a->data.resident.value_offset);
if (vi->i_size > ni->allocated_size) {
- ntfs_error(vi->i_sb, "Resident data attribute "
+ ntfs_error(inode_sb(vi),
+ "Resident data attribute "
"is corrupt (size exceeds "
"allocation).");
goto unm_err_out;
@@ -1218,7 +1245,7 @@ static int ntfs_read_locked_inode(struct inode *vi)
*/
static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
{
- ntfs_volume *vol = NTFS_SB(vi->i_sb);
+ ntfs_volume *vol = NTFS_SB(inode_sb(vi));
ntfs_inode *ni, *base_ni;
MFT_RECORD *m;
ATTR_RECORD *a;
@@ -1265,7 +1292,7 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
NInoSetCompressed(ni);
if ((ni->type != AT_DATA) || (ni->type == AT_DATA &&
ni->name_len)) {
- ntfs_error(vi->i_sb, "Found compressed "
+ ntfs_error(inode_sb(vi), "Found compressed "
"non-data or named data "
"attribute. Please report "
"you saw this message to "
@@ -1274,7 +1301,7 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
goto unm_err_out;
}
if (vol->cluster_size > 4096) {
- ntfs_error(vi->i_sb, "Found compressed "
+ ntfs_error(inode_sb(vi), "Found compressed "
"attribute but compression is "
"disabled due to cluster size "
"(%i) > 4kiB.",
@@ -1283,7 +1310,7 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
}
if ((a->flags & ATTR_COMPRESSION_MASK) !=
ATTR_IS_COMPRESSED) {
- ntfs_error(vi->i_sb, "Found unknown "
+ ntfs_error(inode_sb(vi), "Found unknown "
"compression method.");
goto unm_err_out;
}
@@ -1293,7 +1320,8 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
* to compress all files.
*/
if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) {
- ntfs_error(vi->i_sb, "Found mst protected attribute "
+ ntfs_error(inode_sb(vi),
+ "Found mst protected attribute "
"but the attribute is %s. Please "
"report you saw this message to "
"linux-ntfs-dev@xxxxxxxxxxxxxxxxxxxxx",
@@ -1306,7 +1334,8 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
}
if (a->flags & ATTR_IS_ENCRYPTED) {
if (NInoCompressed(ni)) {
- ntfs_error(vi->i_sb, "Found encrypted and compressed "
+ ntfs_error(inode_sb(vi),
+ "Found encrypted and compressed "
"data.");
goto unm_err_out;
}
@@ -1315,7 +1344,8 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
* encrypt all files.
*/
if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) {
- ntfs_error(vi->i_sb, "Found mst protected attribute "
+ ntfs_error(inode_sb(vi),
+ "Found mst protected attribute "
"but the attribute is encrypted. "
"Please report you saw this message "
"to linux-ntfs-dev@xxxxxxxxxxxxxxxxxx"
@@ -1323,7 +1353,7 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
goto unm_err_out;
}
if (ni->type != AT_DATA) {
- ntfs_error(vi->i_sb, "Found encrypted non-data "
+ ntfs_error(inode_sb(vi), "Found encrypted non-data "
"attribute.");
goto unm_err_out;
}
@@ -1338,7 +1368,8 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
goto unm_err_out;
}
if (NInoMstProtected(ni)) {
- ntfs_error(vi->i_sb, "Found mst protected attribute "
+ ntfs_error(inode_sb(vi),
+ "Found mst protected attribute "
"but the attribute is resident. "
"Please report you saw this message to "
"linux-ntfs-dev@xxxxxxxxxxxxxxxxxxxxx");
@@ -1349,7 +1380,8 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
ni->allocated_size = le32_to_cpu(a->length) -
le16_to_cpu(a->data.resident.value_offset);
if (vi->i_size > ni->allocated_size) {
- ntfs_error(vi->i_sb, "Resident attribute is corrupt "
+ ntfs_error(inode_sb(vi),
+ "Resident attribute is corrupt "
"(size exceeds allocation).");
goto unm_err_out;
}
@@ -1369,7 +1401,7 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
if (NInoCompressed(ni) || NInoSparse(ni)) {
if (NInoCompressed(ni) && a->data.non_resident.
compression_unit != 4) {
- ntfs_error(vi->i_sb, "Found non-standard "
+ ntfs_error(inode_sb(vi), "Found non-standard "
"compression unit (%u instead "
"of 4). Cannot handle this.",
a->data.non_resident.
@@ -1397,7 +1429,8 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
a->data.non_resident.compressed_size);
}
if (a->data.non_resident.lowest_vcn) {
- ntfs_error(vi->i_sb, "First extent of attribute has "
+ ntfs_error(inode_sb(vi),
+ "First extent of attribute has "
"non-zero lowest_vcn.");
goto unm_err_out;
}
@@ -1484,7 +1517,7 @@ static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi)
static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
{
loff_t bvi_size;
- ntfs_volume *vol = NTFS_SB(vi->i_sb);
+ ntfs_volume *vol = NTFS_SB(inode_sb(vi));
ntfs_inode *ni, *base_ni, *bni;
struct inode *bvi;
MFT_RECORD *m;
@@ -1524,7 +1557,7 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
CASE_SENSITIVE, 0, NULL, 0, ctx);
if (unlikely(err)) {
if (err == -ENOENT)
- ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is "
+ ntfs_error(inode_sb(vi), "$INDEX_ROOT attribute is "
"missing.");
goto unm_err_out;
}
@@ -1547,23 +1580,25 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
*/
if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED |
ATTR_IS_SPARSE)) {
- ntfs_error(vi->i_sb, "Found compressed/encrypted/sparse index "
+ ntfs_error(inode_sb(vi),
+ "Found compressed/encrypted/sparse index "
"root attribute.");
goto unm_err_out;
}
ir = (INDEX_ROOT*)((u8*)a + le16_to_cpu(a->data.resident.value_offset));
ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length);
if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) {
- ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is corrupt.");
+ ntfs_error(inode_sb(vi), "$INDEX_ROOT attribute is corrupt.");
goto unm_err_out;
}
index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length);
if (index_end > ir_end) {
- ntfs_error(vi->i_sb, "Index is corrupt.");
+ ntfs_error(inode_sb(vi), "Index is corrupt.");
goto unm_err_out;
}
if (ir->type) {
- ntfs_error(vi->i_sb, "Index type is not 0 (type is 0x%x).",
+ ntfs_error(inode_sb(vi),
+ "Index type is not 0 (type is 0x%x).",
le32_to_cpu(ir->type));
goto unm_err_out;
}
@@ -1572,19 +1607,21 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
le32_to_cpu(ir->collation_rule));
ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);
if (!is_power_of_2(ni->itype.index.block_size)) {
- ntfs_error(vi->i_sb, "Index block size (%u) is not a power of "
+ ntfs_error(inode_sb(vi),
+ "Index block size (%u) is not a power of "
"two.", ni->itype.index.block_size);
goto unm_err_out;
}
if (ni->itype.index.block_size > PAGE_SIZE) {
- ntfs_error(vi->i_sb, "Index block size (%u) > PAGE_SIZE "
+ ntfs_error(inode_sb(vi), "Index block size (%u) > PAGE_SIZE "
"(%ld) is not supported. Sorry.",
ni->itype.index.block_size, PAGE_SIZE);
err = -EOPNOTSUPP;
goto unm_err_out;
}
if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {
- ntfs_error(vi->i_sb, "Index block size (%u) < NTFS_BLOCK_SIZE "
+ ntfs_error(inode_sb(vi),
+ "Index block size (%u) < NTFS_BLOCK_SIZE "
"(%i) is not supported. Sorry.",
ni->itype.index.block_size, NTFS_BLOCK_SIZE);
err = -EOPNOTSUPP;
@@ -1617,17 +1654,18 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
CASE_SENSITIVE, 0, NULL, 0, ctx);
if (unlikely(err)) {
if (err == -ENOENT)
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ALLOCATION attribute is "
"not present but $INDEX_ROOT "
"indicated it is.");
else
- ntfs_error(vi->i_sb, "Failed to lookup "
+ ntfs_error(inode_sb(vi), "Failed to lookup "
"$INDEX_ALLOCATION attribute.");
goto unm_err_out;
}
a = ctx->attr;
if (!a->non_resident) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
+ ntfs_error(inode_sb(vi), "$INDEX_ALLOCATION attribute is "
"resident.");
goto unm_err_out;
}
@@ -1642,21 +1680,22 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
goto unm_err_out;
}
if (a->flags & ATTR_IS_ENCRYPTED) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
+ ntfs_error(inode_sb(vi), "$INDEX_ALLOCATION attribute is "
"encrypted.");
goto unm_err_out;
}
if (a->flags & ATTR_IS_SPARSE) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is sparse.");
+ ntfs_error(inode_sb(vi),
+ "$INDEX_ALLOCATION attribute is sparse.");
goto unm_err_out;
}
if (a->flags & ATTR_COMPRESSION_MASK) {
- ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is "
+ ntfs_error(inode_sb(vi), "$INDEX_ALLOCATION attribute is "
"compressed.");
goto unm_err_out;
}
if (a->data.non_resident.lowest_vcn) {
- ntfs_error(vi->i_sb, "First extent of $INDEX_ALLOCATION "
+ ntfs_error(inode_sb(vi), "First extent of $INDEX_ALLOCATION "
"attribute has non zero lowest_vcn.");
goto unm_err_out;
}
@@ -1675,21 +1714,23 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
/* Get the index bitmap attribute inode. */
bvi = ntfs_attr_iget(base_vi, AT_BITMAP, ni->name, ni->name_len);
if (IS_ERR(bvi)) {
- ntfs_error(vi->i_sb, "Failed to get bitmap attribute.");
+ ntfs_error(inode_sb(vi), "Failed to get bitmap attribute.");
err = PTR_ERR(bvi);
goto unm_err_out;
}
bni = NTFS_I(bvi);
if (NInoCompressed(bni) || NInoEncrypted(bni) ||
NInoSparse(bni)) {
- ntfs_error(vi->i_sb, "$BITMAP attribute is compressed and/or "
+ ntfs_error(inode_sb(vi),
+ "$BITMAP attribute is compressed and/or "
"encrypted and/or sparse.");
goto iput_unm_err_out;
}
/* Consistency check bitmap size vs. index allocation size. */
bvi_size = i_size_read(bvi);
if ((bvi_size << 3) < (vi->i_size >> ni->itype.index.block_size_bits)) {
- ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) for "
+ ntfs_error(inode_sb(vi),
+ "Index bitmap too small (0x%llx) for "
"index allocation (0x%llx).", bvi_size << 3,
vi->i_size);
goto iput_unm_err_out;
@@ -1719,7 +1760,8 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
if (m)
unmap_mft_record(base_ni);
err_out:
- ntfs_error(vi->i_sb, "Failed with error code %i while reading index "
+ ntfs_error(inode_sb(vi),
+ "Failed with error code %i while reading index "
"inode (mft_no 0x%lx, name_len %i.", err, vi->i_ino,
ni->name_len);
make_bad_inode(vi);
@@ -1767,7 +1809,7 @@ int ntfs_read_inode_mount(struct inode *vi)
{
VCN next_vcn, last_vcn, highest_vcn;
s64 block;
- struct super_block *sb = vi->i_sb;
+ struct super_block *sb = inode_sb(vi);
ntfs_volume *vol = NTFS_SB(sb);
struct buffer_head *bh;
ntfs_inode *ni;
@@ -2261,7 +2303,8 @@ void ntfs_evict_big_inode(struct inode *vi)
ntfs_commit_inode(vi);

if (!was_bad && (is_bad_inode(vi) || NInoDirty(ni))) {
- ntfs_error(vi->i_sb, "Failed to commit dirty inode "
+ ntfs_error(inode_sb(vi),
+ "Failed to commit dirty inode "
"0x%lx. Losing data!", vi->i_ino);
// FIXME: Do something!!!
}
@@ -2383,7 +2426,8 @@ int ntfs_truncate(struct inode *vi)
m = map_mft_record(base_ni);
if (IS_ERR(m)) {
err = PTR_ERR(m);
- ntfs_error(vi->i_sb, "Failed to map mft record for inode 0x%lx "
+ ntfs_error(inode_sb(vi),
+ "Failed to map mft record for inode 0x%lx "
"(error code %d).%s", vi->i_ino, err, te);
ctx = NULL;
m = NULL;
@@ -2391,7 +2435,8 @@ int ntfs_truncate(struct inode *vi)
}
ctx = ntfs_attr_get_search_ctx(base_ni, m);
if (unlikely(!ctx)) {
- ntfs_error(vi->i_sb, "Failed to allocate a search context for "
+ ntfs_error(inode_sb(vi),
+ "Failed to allocate a search context for "
"inode 0x%lx (not enough memory).%s",
vi->i_ino, te);
err = -ENOMEM;
@@ -2401,12 +2446,14 @@ int ntfs_truncate(struct inode *vi)
CASE_SENSITIVE, 0, NULL, 0, ctx);
if (unlikely(err)) {
if (err == -ENOENT) {
- ntfs_error(vi->i_sb, "Open attribute is missing from "
+ ntfs_error(inode_sb(vi),
+ "Open attribute is missing from "
"mft record. Inode 0x%lx is corrupt. "
"Run chkdsk.%s", vi->i_ino, te);
err = -EIO;
} else
- ntfs_error(vi->i_sb, "Failed to lookup attribute in "
+ ntfs_error(inode_sb(vi),
+ "Failed to lookup attribute in "
"inode 0x%lx (error code %d).%s",
vi->i_ino, err, te);
goto old_bad_out;
@@ -2480,7 +2527,7 @@ int ntfs_truncate(struct inode *vi)
}
}
if (NInoCompressed(ni) || NInoEncrypted(ni)) {
- ntfs_warning(vi->i_sb, "Changes in inode size are not "
+ ntfs_warning(inode_sb(vi), "Changes in inode size are not "
"supported yet for %s files, ignoring.",
NInoCompressed(ni) ? "compressed" :
"encrypted");
@@ -2889,7 +2936,8 @@ int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
goto out;
/* We do not support NTFS ACLs yet. */
if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE)) {
- ntfs_warning(vi->i_sb, "Changes in user/group/mode are not "
+ ntfs_warning(inode_sb(vi),
+ "Changes in user/group/mode are not "
"supported yet, ignoring.");
err = -EOPNOTSUPP;
goto out;
@@ -2902,7 +2950,8 @@ int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
* compressed or encrypted files yet.
*/
if (NInoCompressed(ni) || NInoEncrypted(ni)) {
- ntfs_warning(vi->i_sb, "Changes in inode size "
+ ntfs_warning(inode_sb(vi),
+ "Changes in inode size "
"are not supported yet for "
"%s files, ignoring.",
NInoCompressed(ni) ?
@@ -2924,13 +2973,13 @@ int ntfs_setattr(struct dentry *dentry, struct iattr *attr)
}
if (ia_valid & ATTR_ATIME)
vi->i_atime = timespec_trunc(attr->ia_atime,
- vi->i_sb->s_time_gran);
+ inode_sb(vi)->s_time_gran);
if (ia_valid & ATTR_MTIME)
vi->i_mtime = timespec_trunc(attr->ia_mtime,
- vi->i_sb->s_time_gran);
+ inode_sb(vi)->s_time_gran);
if (ia_valid & ATTR_CTIME)
vi->i_ctime = timespec_trunc(attr->ia_ctime,
- vi->i_sb->s_time_gran);
+ inode_sb(vi)->s_time_gran);
mark_inode_dirty(vi);
out:
return err;
@@ -3088,12 +3137,14 @@ int __ntfs_write_inode(struct inode *vi, int sync)
unmap_mft_record(ni);
err_out:
if (err == -ENOMEM) {
- ntfs_warning(vi->i_sb, "Not enough memory to write inode. "
+ ntfs_warning(inode_sb(vi),
+ "Not enough memory to write inode. "
"Marking the inode dirty again, so the VFS "
"retries later.");
mark_inode_dirty(vi);
} else {
- ntfs_error(vi->i_sb, "Failed (error %i): Run chkdsk.", -err);
+ ntfs_error(inode_sb(vi), "Failed (error %i): Run chkdsk.",
+ -err);
NVolSetErrors(ni->vol);
}
return err;
diff --git a/fs/ntfs/inode.h b/fs/ntfs/inode.h
index b3c3469de6cb..d22743c94763 100644
--- a/fs/ntfs/inode.h
+++ b/fs/ntfs/inode.h
@@ -288,7 +288,7 @@ static inline void ntfs_init_big_inode(struct inode *vi)
ntfs_inode *ni = NTFS_I(vi);

ntfs_debug("Entering.");
- __ntfs_init_inode(vi->i_sb, ni);
+ __ntfs_init_inode(inode_sb(vi), ni);
ni->mft_no = vi->i_ino;
}

diff --git a/fs/ntfs/logfile.c b/fs/ntfs/logfile.c
index 353379ff6057..2cc0cac18ac5 100644
--- a/fs/ntfs/logfile.c
+++ b/fs/ntfs/logfile.c
@@ -68,7 +68,8 @@ static bool ntfs_check_restart_page_header(struct inode *vi,
logfile_system_page_size &
(logfile_system_page_size - 1) ||
!is_power_of_2(logfile_log_page_size)) {
- ntfs_error(vi->i_sb, "$LogFile uses unsupported page size.");
+ ntfs_error(inode_sb(vi),
+ "$LogFile uses unsupported page size.");
return false;
}
/*
@@ -76,14 +77,14 @@ static bool ntfs_check_restart_page_header(struct inode *vi,
* size (2nd restart page).
*/
if (pos && pos != logfile_system_page_size) {
- ntfs_error(vi->i_sb, "Found restart area in incorrect "
+ ntfs_error(inode_sb(vi), "Found restart area in incorrect "
"position in $LogFile.");
return false;
}
/* We only know how to handle version 1.1. */
if (sle16_to_cpu(rp->major_ver) != 1 ||
sle16_to_cpu(rp->minor_ver) != 1) {
- ntfs_error(vi->i_sb, "$LogFile version %i.%i is not "
+ ntfs_error(inode_sb(vi), "$LogFile version %i.%i is not "
"supported. (This driver supports version "
"1.1 only.)", (int)sle16_to_cpu(rp->major_ver),
(int)sle16_to_cpu(rp->minor_ver));
@@ -100,7 +101,7 @@ static bool ntfs_check_restart_page_header(struct inode *vi,
/* Verify the size of the update sequence array. */
usa_count = 1 + (logfile_system_page_size >> NTFS_BLOCK_SIZE_BITS);
if (usa_count != le16_to_cpu(rp->usa_count)) {
- ntfs_error(vi->i_sb, "$LogFile restart page specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart page specifies "
"inconsistent update sequence array count.");
return false;
}
@@ -109,7 +110,7 @@ static bool ntfs_check_restart_page_header(struct inode *vi,
usa_end = usa_ofs + usa_count * sizeof(u16);
if (usa_ofs < sizeof(RESTART_PAGE_HEADER) ||
usa_end > NTFS_BLOCK_SIZE - sizeof(u16)) {
- ntfs_error(vi->i_sb, "$LogFile restart page specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart page specifies "
"inconsistent update sequence array offset.");
return false;
}
@@ -124,7 +125,7 @@ static bool ntfs_check_restart_page_header(struct inode *vi,
if (ra_ofs & 7 || (have_usa ? ra_ofs < usa_end :
ra_ofs < sizeof(RESTART_PAGE_HEADER)) ||
ra_ofs > logfile_system_page_size) {
- ntfs_error(vi->i_sb, "$LogFile restart page specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart page specifies "
"inconsistent restart area offset.");
return false;
}
@@ -133,7 +134,8 @@ static bool ntfs_check_restart_page_header(struct inode *vi,
* set.
*/
if (!ntfs_is_chkd_record(rp->magic) && sle64_to_cpu(rp->chkdsk_lsn)) {
- ntfs_error(vi->i_sb, "$LogFile restart page is not modified "
+ ntfs_error(inode_sb(vi),
+ "$LogFile restart page is not modified "
"by chkdsk but a chkdsk LSN is specified.");
return false;
}
@@ -172,7 +174,7 @@ static bool ntfs_check_restart_area(struct inode *vi, RESTART_PAGE_HEADER *rp)
*/
if (ra_ofs + offsetof(RESTART_AREA, file_size) >
NTFS_BLOCK_SIZE - sizeof(u16)) {
- ntfs_error(vi->i_sb, "$LogFile restart area specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart area specifies "
"inconsistent file offset.");
return false;
}
@@ -186,7 +188,7 @@ static bool ntfs_check_restart_area(struct inode *vi, RESTART_PAGE_HEADER *rp)
ca_ofs = le16_to_cpu(ra->client_array_offset);
if (((ca_ofs + 7) & ~7) != ca_ofs ||
ra_ofs + ca_ofs > NTFS_BLOCK_SIZE - sizeof(u16)) {
- ntfs_error(vi->i_sb, "$LogFile restart area specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart area specifies "
"inconsistent client array offset.");
return false;
}
@@ -201,7 +203,8 @@ static bool ntfs_check_restart_area(struct inode *vi, RESTART_PAGE_HEADER *rp)
ra_ofs + le16_to_cpu(ra->restart_area_length) >
le32_to_cpu(rp->system_page_size) ||
ra_len > le16_to_cpu(ra->restart_area_length)) {
- ntfs_error(vi->i_sb, "$LogFile restart area is out of bounds "
+ ntfs_error(inode_sb(vi),
+ "$LogFile restart area is out of bounds "
"of the system page size specified by the "
"restart page header and/or the specified "
"restart area length is inconsistent.");
@@ -218,7 +221,7 @@ static bool ntfs_check_restart_area(struct inode *vi, RESTART_PAGE_HEADER *rp)
(ra->client_in_use_list != LOGFILE_NO_CLIENT &&
le16_to_cpu(ra->client_in_use_list) >=
le16_to_cpu(ra->log_clients))) {
- ntfs_error(vi->i_sb, "$LogFile restart area specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart area specifies "
"overflowing client free and/or in use lists.");
return false;
}
@@ -233,21 +236,21 @@ static bool ntfs_check_restart_area(struct inode *vi, RESTART_PAGE_HEADER *rp)
fs_bits++;
}
if (le32_to_cpu(ra->seq_number_bits) != 67 - fs_bits) {
- ntfs_error(vi->i_sb, "$LogFile restart area specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart area specifies "
"inconsistent sequence number bits.");
return false;
}
/* The log record header length must be a multiple of 8. */
if (((le16_to_cpu(ra->log_record_header_length) + 7) & ~7) !=
le16_to_cpu(ra->log_record_header_length)) {
- ntfs_error(vi->i_sb, "$LogFile restart area specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart area specifies "
"inconsistent log record header length.");
return false;
}
/* Dito for the log page data offset. */
if (((le16_to_cpu(ra->log_page_data_offset) + 7) & ~7) !=
le16_to_cpu(ra->log_page_data_offset)) {
- ntfs_error(vi->i_sb, "$LogFile restart area specifies "
+ ntfs_error(inode_sb(vi), "$LogFile restart area specifies "
"inconsistent log page data offset.");
return false;
}
@@ -316,7 +319,7 @@ static bool ntfs_check_log_client_array(struct inode *vi,
ntfs_debug("Done.");
return true;
err_out:
- ntfs_error(vi->i_sb, "$LogFile log client array is corrupt.");
+ ntfs_error(inode_sb(vi), "$LogFile log client array is corrupt.");
return false;
}

@@ -373,7 +376,8 @@ static int ntfs_check_and_load_restart_page(struct inode *vi,
*/
trp = ntfs_malloc_nofs(le32_to_cpu(rp->system_page_size));
if (!trp) {
- ntfs_error(vi->i_sb, "Failed to allocate memory for $LogFile "
+ ntfs_error(inode_sb(vi),
+ "Failed to allocate memory for $LogFile "
"restart page buffer.");
return -ENOMEM;
}
@@ -400,7 +404,8 @@ static int ntfs_check_and_load_restart_page(struct inode *vi,
do {
page = ntfs_map_page(vi->i_mapping, idx);
if (IS_ERR(page)) {
- ntfs_error(vi->i_sb, "Error mapping $LogFile "
+ ntfs_error(inode_sb(vi),
+ "Error mapping $LogFile "
"page (index %lu).", idx);
err = PTR_ERR(page);
if (err != -EIO && err != -ENOMEM)
@@ -430,7 +435,8 @@ static int ntfs_check_and_load_restart_page(struct inode *vi,
if (le16_to_cpu(rp->restart_area_offset) +
le16_to_cpu(ra->restart_area_length) >
NTFS_BLOCK_SIZE - sizeof(u16)) {
- ntfs_error(vi->i_sb, "Multi sector transfer error "
+ ntfs_error(inode_sb(vi),
+ "Multi sector transfer error "
"detected in $LogFile restart page.");
err = -EINVAL;
goto err_out;
@@ -486,7 +492,7 @@ bool ntfs_check_logfile(struct inode *log_vi, RESTART_PAGE_HEADER **rp)
{
s64 size, pos;
LSN rstr1_lsn, rstr2_lsn;
- ntfs_volume *vol = NTFS_SB(log_vi->i_sb);
+ ntfs_volume *vol = NTFS_SB(inode_sb(log_vi));
struct address_space *mapping = log_vi->i_mapping;
struct page *page = NULL;
u8 *kaddr = NULL;
@@ -679,7 +685,7 @@ bool ntfs_check_logfile(struct inode *log_vi, RESTART_PAGE_HEADER **rp)
*/
bool ntfs_is_logfile_clean(struct inode *log_vi, const RESTART_PAGE_HEADER *rp)
{
- ntfs_volume *vol = NTFS_SB(log_vi->i_sb);
+ ntfs_volume *vol = NTFS_SB(inode_sb(log_vi));
RESTART_AREA *ra;

ntfs_debug("Entering.");
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index 4690cd75d8d7..b55c2fb0ed56 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -103,7 +103,7 @@
static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent,
unsigned int flags)
{
- ntfs_volume *vol = NTFS_SB(dir_ino->i_sb);
+ ntfs_volume *vol = NTFS_SB(inode_sb(dir_ino));
struct inode *dent_inode;
ntfschar *uname;
ntfs_name *name = NULL;
@@ -326,7 +326,8 @@ static struct dentry *ntfs_get_parent(struct dentry *child_dent)
ntfs_attr_put_search_ctx(ctx);
unmap_mft_record(ni);
if (err == -ENOENT)
- ntfs_error(vi->i_sb, "Inode 0x%lx does not have a "
+ ntfs_error(inode_sb(vi),
+ "Inode 0x%lx does not have a "
"file name attribute. Run chkdsk.",
vi->i_ino);
return ERR_PTR(err);
@@ -345,7 +346,7 @@ static struct dentry *ntfs_get_parent(struct dentry *child_dent)
ntfs_attr_put_search_ctx(ctx);
unmap_mft_record(ni);

- return d_obtain_alias(ntfs_iget(vi->i_sb, parent_ino));
+ return d_obtain_alias(ntfs_iget(inode_sb(vi), parent_ino));
}

static struct inode *ntfs_nfs_get_inode(struct super_block *sb,
--
2.15.1