diff --git a/lustre/ChangeLog b/lustre/ChangeLog
index 184aa6c44e1657fd9729c606ca106a7c51210b3f..4c093e54a003ba3413abd39226121fecb2a652c4 100644
--- a/lustre/ChangeLog
+++ b/lustre/ChangeLog
@@ -32,6 +32,11 @@ Description: Remove client patches from SLES 10 kernel.
Details : This causes SLES 10 clients to behave as patchless clients
even on a Lustre-patched (server) kernel.
+Severity : minor
+Bugzilla : 2369
+Description: use i_size_read and i_size_write in 2.6 port
+Details : replace inode->i_size access with i_size_read/write()
+
--------------------------------------------------------------------------------
2007-09-27 Cluster File Systems, Inc. <info@clusterfs.com>
diff --git a/lustre/include/linux/lustre_lib.h b/lustre/include/linux/lustre_lib.h
index e5be7d653ccb1ad007f7caf27d9272aa850193b7..a2fd8baf3d931eaf61c38a82d76c0bb078caf65b 100644
--- a/lustre/include/linux/lustre_lib.h
+++ b/lustre/include/linux/lustre_lib.h
@@ -79,7 +79,7 @@ static inline sigset_t l_w_e_set_sigs(int sigs)
/* initialize ost_lvb according to inode */
static inline void inode_init_lvb(struct inode *inode, struct ost_lvb *lvb)
{
- lvb->lvb_size = inode->i_size;
+ lvb->lvb_size = i_size_read(inode);
lvb->lvb_blocks = inode->i_blocks;
lvb->lvb_mtime = LTIME_S(inode->i_mtime);
lvb->lvb_atime = LTIME_S(inode->i_atime);
diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c
index 8b9ebb56afafbaede9ac961103f405bf8dad437f..8b17f466a436081d51af8fd816a9327cb42a980e 100644
--- a/lustre/llite/dir.c
+++ b/lustre/llite/dir.c
@@ -105,7 +105,7 @@ static int ll_dir_readpage(struct file *file, struct page *page)
/* swabbed by mdc_readpage() */
LASSERT_REPSWABBED(request, REPLY_REC_OFF);
- inode->i_size = body->size;
+ i_size_write(inode, body->size);
SetPageUptodate(page);
}
ptlrpc_req_finished(request);
@@ -174,15 +174,15 @@ static void ll_dir_check_page(struct inode *dir, struct page *page)
struct ll_dir_entry *ent;
err = 0;
- if ((dir->i_size >> CFS_PAGE_SHIFT) == (__u64)page->index) {
+ if ((i_size_read(dir) >> CFS_PAGE_SHIFT) == (__u64)page->index) {
/*
* Last page.
*/
- limit = dir->i_size & ~CFS_PAGE_MASK;
+ limit = i_size_read(dir) & ~CFS_PAGE_MASK;
if (limit & (size - 1)) {
CERROR("%s: dir %lu/%u size %llu doesn't match %u\n",
ll_i2mdcexp(dir)->exp_obd->obd_name, dir->i_ino,
- dir->i_generation, dir->i_size, size);
+ dir->i_generation, i_size_read(dir), size);
err++;
} else {
/*
@@ -372,13 +372,14 @@ int ll_readdir(struct file *filp, void *dirent, filldir_t filldir)
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) pos %llu/%llu\n",
- inode->i_ino, inode->i_generation, inode, pos, inode->i_size);
+ inode->i_ino, inode->i_generation, inode,
+ pos, i_size_read(inode));
/*
* Checking ->i_size without the lock. Should be harmless, as server
* re-checks.
*/
- if (pos > inode->i_size - ll_dir_rec_len(1))
+ if (pos > i_size_read(inode) - ll_dir_rec_len(1))
RETURN(0);
for (done = 0; idx < npages; idx++, offset = 0) {
@@ -394,7 +395,7 @@ int ll_readdir(struct file *filp, void *dirent, filldir_t filldir)
CDEBUG(D_EXT2,"read %lu of dir %lu/%u page %lu/%lu "
"size %llu\n",
CFS_PAGE_SIZE, inode->i_ino, inode->i_generation,
- idx, npages, inode->i_size);
+ idx, npages, i_size_read(inode));
page = ll_get_dir_page(inode, idx);
/* size might have been updated by mdc_readpage */
diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index b50cfbadcc1877a0688b97c802d72e05757e02b4..a79b7d7a8a2040f8e549e4c5439a9ade32a254c8 100644
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -652,7 +652,7 @@ void ll_pgcache_remove_extent(struct inode *inode, struct lov_stripe_md *lsm,
memcpy(&tmpex, &lock->l_policy_data, sizeof(tmpex));
CDEBUG(D_INODE|D_PAGE, "inode %lu(%p) ["LPU64"->"LPU64"] size: %llu\n",
inode->i_ino, inode, tmpex.l_extent.start, tmpex.l_extent.end,
- inode->i_size);
+ i_size_read(inode));
/* our locks are page granular thanks to osc_enqueue, we invalidate the
* whole page. */
@@ -676,7 +676,7 @@ void ll_pgcache_remove_extent(struct inode *inode, struct lov_stripe_md *lsm,
if (end < tmpex.l_extent.end >> CFS_PAGE_SHIFT)
end = ~0;
- i = inode->i_size ? (inode->i_size - 1) >> CFS_PAGE_SHIFT : 0;
+ i = i_size_read(inode) ? (i_size_read(inode) - 1) >> CFS_PAGE_SHIFT : 0;
if (i < end)
end = i;
@@ -934,7 +934,7 @@ static int ll_glimpse_callback(struct ldlm_lock *lock, void *reqp)
LDLM_DEBUG(lock, "i_size: %llu -> stripe number %u -> kms "LPU64
" atime "LPU64", mtime "LPU64", ctime "LPU64,
- inode->i_size, stripe, lvb->lvb_size, lvb->lvb_mtime,
+ i_size_read(inode), stripe, lvb->lvb_size, lvb->lvb_mtime,
lvb->lvb_atime, lvb->lvb_ctime);
iput:
iput(inode);
@@ -1044,7 +1044,7 @@ int ll_glimpse_size(struct inode *inode, int ast_flags)
ll_inode_size_lock(inode, 1);
inode_init_lvb(inode, &lvb);
rc = obd_merge_lvb(sbi->ll_osc_exp, lli->lli_smd, &lvb, 0);
- inode->i_size = lvb.lvb_size;
+ i_size_write(inode, lvb.lvb_size);
inode->i_blocks = lvb.lvb_blocks;
LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
LTIME_S(inode->i_atime) = lvb.lvb_atime;
@@ -1052,7 +1052,7 @@ int ll_glimpse_size(struct inode *inode, int ast_flags)
ll_inode_size_unlock(inode, 1);
CDEBUG(D_DLMTRACE, "glimpse: size: %llu, blocks: %llu\n",
- inode->i_size, (long long)inode->i_blocks);
+ i_size_read(inode), (long long)inode->i_blocks);
RETURN(rc);
}
@@ -1117,9 +1117,9 @@ int ll_extent_lock(struct ll_file_data *fd, struct inode *inode,
* cancel the result of the truncate. Getting the
* ll_inode_size_lock() after the enqueue maintains the DLM
* -> ll_inode_size_lock() acquiring order. */
- inode->i_size = lvb.lvb_size;
+ i_size_write(inode, lvb.lvb_size);
CDEBUG(D_INODE, "inode=%lu, updating i_size %llu\n",
- inode->i_ino, inode->i_size);
+ inode->i_ino, i_size_read(inode));
}
if (rc == 0) {
@@ -1272,11 +1272,11 @@ static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
* unguarded */
/* Read beyond end of file */
- if (*ppos >= inode->i_size)
+ if (*ppos >= i_size_read(inode))
RETURN(0);
- if (count > inode->i_size - *ppos)
- count = inode->i_size - *ppos;
+ if (count > i_size_read(inode) - *ppos)
+ count = i_size_read(inode) - *ppos;
/* Make sure to correctly adjust the file pos pointer for
* EFAULT case */
notzeroed = clear_user(buf, count);
@@ -1348,14 +1348,14 @@ repeat:
* the kms size is _correct_, it is only the _minimum_ size.
* If someone does a stat they will get the correct size which
* will always be >= the kms value here. b=11081 */
- if (inode->i_size < kms)
- inode->i_size = kms;
+ if (i_size_read(inode) < kms)
+ i_size_write(inode, kms);
ll_inode_size_unlock(inode, 1);
}
chunk = end - *ppos + 1;
CDEBUG(D_INODE,"Read ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n",
- inode->i_ino, chunk, *ppos, inode->i_size);
+ inode->i_ino, chunk, *ppos, i_size_read(inode));
/* turn off the kernel's read-ahead */
if (tree_locked) {
@@ -1467,7 +1467,7 @@ repeat:
* The i_size value gets updated in ll_extent_lock() as a consequence
* of the [0,EOF] extent lock we requested above. */
if (file->f_flags & O_APPEND) {
- *ppos = inode->i_size;
+ *ppos = i_size_read(inode);
end = *ppos + count - 1;
}
@@ -1587,12 +1587,12 @@ static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count,
goto out;
} else {
/* region is within kms and, hence, within real file size (A) */
- inode->i_size = kms;
+ i_size_write(inode, kms);
ll_inode_size_unlock(inode, 1);
}
CDEBUG(D_INFO, "Send ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n",
- inode->i_ino, count, *ppos, inode->i_size);
+ inode->i_ino, count, *ppos, i_size_read(inode));
bead.lrr_start = *ppos >> CFS_PAGE_SHIFT;
bead.lrr_count = (count + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
@@ -1956,8 +1956,8 @@ static int join_sanity_check(struct inode *head, struct inode *tail)
CERROR("file %lu can not be joined to itself \n", head->i_ino);
RETURN(-EINVAL);
}
- if (head->i_size % JOIN_FILE_ALIGN) {
- CERROR("hsize %llu must be times of 64K\n", head->i_size);
+ if (i_size_read(head) % JOIN_FILE_ALIGN) {
+ CERROR("hsize %llu must be times of 64K\n", i_size_read(head));
RETURN(-EINVAL);
}
RETURN(0);
@@ -1966,7 +1966,6 @@ static int join_sanity_check(struct inode *head, struct inode *tail)
static int join_file(struct inode *head_inode, struct file *head_filp,
struct file *tail_filp)
{
- struct inode *tail_inode, *tail_parent;
struct dentry *tail_dentry = tail_filp->f_dentry;
struct lookup_intent oit = {.it_op = IT_OPEN,
.it_flags = head_filp->f_flags|O_JOIN_FILE};
@@ -1976,21 +1975,22 @@ static int join_file(struct inode *head_inode, struct file *head_filp,
struct lustre_handle lockh;
struct mdc_op_data *op_data;
int rc;
+ loff_t data;
ENTRY;
tail_dentry = tail_filp->f_dentry;
- tail_inode = tail_dentry->d_inode;
- tail_parent = tail_dentry->d_parent->d_inode;
OBD_ALLOC_PTR(op_data);
if (op_data == NULL) {
RETURN(-ENOMEM);
}
- ll_prepare_mdc_op_data(op_data, head_inode, tail_parent,
+ data = i_size_read(head_inode);
+ ll_prepare_mdc_op_data(op_data, head_inode,
+ tail_dentry->d_parent->d_inode,
tail_dentry->d_name.name,
- tail_dentry->d_name.len, 0, &head_inode->i_size);
- rc = mdc_enqueue(ll_i2mdcexp(head_inode), &einfo, &oit,
+ tail_dentry->d_name.len, 0, &data);
+ rc = mdc_enqueue(ll_i2mdcexp(head_inode), &einfo, &oit,
op_data, &lockh, NULL, 0, 0);
if (rc < 0)
@@ -2249,13 +2249,13 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
struct lov_stripe_md *lsm = lli->lli_smd;
loff_t retval;
ENTRY;
- retval = offset + ((origin == 2) ? inode->i_size :
+ retval = offset + ((origin == 2) ? i_size_read(inode) :
(origin == 1) ? file->f_pos : 0);
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%Lu=%#Lx(%s)\n",
inode->i_ino, inode->i_generation, inode, retval, retval,
origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
-
+
if (origin == 2) { /* SEEK_END */
int nonblock = 0, rc;
@@ -2269,7 +2269,7 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
}
ll_inode_size_lock(inode, 0);
- offset += inode->i_size;
+ offset += i_size_read(inode);
ll_inode_size_unlock(inode, 0);
} else if (origin == 1) { /* SEEK_CUR */
offset += file->f_pos;
@@ -2621,7 +2621,7 @@ int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
#endif
ll_inode_size_lock(inode, 0);
- stat->size = inode->i_size;
+ stat->size = i_size_read(inode);
stat->blocks = inode->i_blocks;
ll_inode_size_unlock(inode, 0);
diff --git a/lustre/llite/llite_close.c b/lustre/llite/llite_close.c
index aa392f3368d2b6f2512d669cc75c9358af7a711b..10a98fab8c00c2de71da4f8445390e350fcb76d0 100644
--- a/lustre/llite/llite_close.c
+++ b/lustre/llite/llite_close.c
@@ -151,7 +151,7 @@ static void ll_close_done_writing(struct inode *inode)
obdo_refresh_inode(inode, &obdo, valid);
CDEBUG(D_INODE, "objid "LPX64" size %Lu, blocks %lu, blksize %lu\n",
- lli->lli_smd->lsm_object_id, inode->i_size, inode->i_blocks,
+ lli->lli_smd->lsm_object_id, i_size_read(inode), inode->i_blocks,
1<<inode->i_blkbits);
set_bit(LLI_F_HAVE_OST_SIZE_LOCK, &lli->lli_flags);
@@ -162,7 +162,7 @@ static void ll_close_done_writing(struct inode *inode)
rpc:
obdo.o_id = inode->i_ino;
- obdo.o_size = inode->i_size;
+ obdo.o_size = i_size_read(inode);
obdo.o_blocks = inode->i_blocks;
obdo.o_valid = OBD_MD_FLID | OBD_MD_FLSIZE | OBD_MD_FLBLOCKS;
diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index 8c8afb56d4479c3124ea335a605681fb6f01f223..3a2be46d71bf663b9d01653ced60f3cdf2eb0507 100644
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -1696,7 +1696,7 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md)
inode->i_rdev = old_decode_dev(body->rdev);
#endif
if (body->valid & OBD_MD_FLSIZE)
- inode->i_size = body->size;
+ i_size_write(inode, body->size);
if (body->valid & OBD_MD_FLBLOCKS)
inode->i_blocks = body->blocks;
diff --git a/lustre/llite/llite_mmap.c b/lustre/llite/llite_mmap.c
index 4b83cb653c6d133734e16e9391183577fcb845e1..cbea96185688f81b6d2fd5f1f3176c02aa35776f 100644
--- a/lustre/llite/llite_mmap.c
+++ b/lustre/llite/llite_mmap.c
@@ -420,10 +420,10 @@ struct page *ll_nopage(struct vm_area_struct *vma, unsigned long address,
* the kms size is _correct_, it is only the _minimum_ size.
* If someone does a stat they will get the correct size which
* will always be >= the kms value here. b=11081 */
- if (inode->i_size < kms) {
- inode->i_size = kms;
+ if (i_size_read(inode) < kms) {
+ i_size_write(inode, kms);
CDEBUG(D_INODE, "ino=%lu, updating i_size %llu\n",
- inode->i_ino, inode->i_size);
+ inode->i_ino, i_size_read(inode));
}
lov_stripe_unlock(lsm);
}
@@ -435,8 +435,8 @@ struct page *ll_nopage(struct vm_area_struct *vma, unsigned long address,
lov_stripe_lock(lsm);
if (mode == LCK_PW)
obd_adjust_kms(ll_i2obdexp(inode), lsm,
- min_t(loff_t, policy.l_extent.end,inode->i_size),
- 0);
+ min_t(loff_t, policy.l_extent.end,
+ i_size_read(inode)), 0);
lov_stripe_unlock(lsm);
/* disable VM_SEQ_READ and use VM_RAND_READ to make sure that
diff --git a/lustre/llite/rw.c b/lustre/llite/rw.c
index 601a10215615496d98759ca63e9f79e33ab7ad27..8abfbee277c8e9d9da02b07b48870f3882d2df2d 100644
--- a/lustre/llite/rw.c
+++ b/lustre/llite/rw.c
@@ -71,8 +71,8 @@ static int ll_brw(int cmd, struct inode *inode, struct obdo *oa,
pg.pg = page;
pg.off = ((obd_off)page->index) << CFS_PAGE_SHIFT;
- if ((cmd & OBD_BRW_WRITE) && (pg.off + CFS_PAGE_SIZE > inode->i_size))
- pg.count = inode->i_size % CFS_PAGE_SIZE;
+ if ((cmd & OBD_BRW_WRITE) && (pg.off+CFS_PAGE_SIZE>i_size_read(inode)))
+ pg.count = i_size_read(inode) % CFS_PAGE_SIZE;
else
pg.count = CFS_PAGE_SIZE;
@@ -81,9 +81,9 @@ static int ll_brw(int cmd, struct inode *inode, struct obdo *oa,
inode->i_ino, pg.off, pg.off);
if (pg.count == 0) {
CERROR("ZERO COUNT: ino %lu: size %p:%Lu(%p:%Lu) idx %lu off "
- LPU64"\n",
- inode->i_ino, inode, inode->i_size, page->mapping->host,
- page->mapping->host->i_size, page->index, pg.off);
+ LPU64"\n", inode->i_ino, inode, i_size_read(inode),
+ page->mapping->host, i_size_read(page->mapping->host),
+ page->index, pg.off);
}
pg.flag = flags;
@@ -148,7 +148,7 @@ void ll_truncate(struct inode *inode)
loff_t new_size;
ENTRY;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) to %Lu=%#Lx\n",inode->i_ino,
- inode->i_generation, inode, inode->i_size, inode->i_size);
+ inode->i_generation, inode, i_size_read(inode), i_size_read(inode));
ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_TRUNC, 1);
if (lli->lli_size_sem_owner != current) {
@@ -174,23 +174,24 @@ void ll_truncate(struct inode *inode)
inode_init_lvb(inode, &lvb);
rc = obd_merge_lvb(ll_i2obdexp(inode), lli->lli_smd, &lvb, 0);
inode->i_blocks = lvb.lvb_blocks;
- if (lvb.lvb_size == inode->i_size && rc == 0) {
+ if (lvb.lvb_size == i_size_read(inode) && rc == 0) {
CDEBUG(D_VFSTRACE, "skipping punch for obj "LPX64", %Lu=%#Lx\n",
- lli->lli_smd->lsm_object_id,inode->i_size,inode->i_size);
+ lli->lli_smd->lsm_object_id, i_size_read(inode),
+ i_size_read(inode));
lov_stripe_unlock(lli->lli_smd);
GOTO(out_unlock, 0);
}
- obd_adjust_kms(ll_i2obdexp(inode), lli->lli_smd, inode->i_size, 1);
+ obd_adjust_kms(ll_i2obdexp(inode), lli->lli_smd, i_size_read(inode), 1);
lov_stripe_unlock(lli->lli_smd);
}
if (unlikely((ll_i2sbi(inode)->ll_flags & LL_SBI_CHECKSUM) &&
- (inode->i_size & ~CFS_PAGE_MASK))) {
+ (i_size_read(inode) & ~CFS_PAGE_MASK))) {
/* If the truncate leaves behind a partial page, update its
* checksum. */
struct page *page = find_get_page(inode->i_mapping,
- inode->i_size >> CFS_PAGE_SHIFT);
+ i_size_read(inode) >> CFS_PAGE_SHIFT);
if (page != NULL) {
struct ll_async_page *llap = llap_cast_private(page);
if (llap != NULL) {
@@ -202,7 +203,7 @@ void ll_truncate(struct inode *inode)
}
}
- new_size = inode->i_size;
+ new_size = i_size_read(inode);
ll_inode_size_unlock(inode, 0);
if (!srvlock)
ll_file_punch(inode, new_size, 0);
@@ -669,7 +670,7 @@ static int queue_or_sync_write(struct obd_export *exp, struct inode *inode,
struct ll_async_page *llap,
unsigned to, obd_flag async_flags)
{
- unsigned long size_index = inode->i_size >> CFS_PAGE_SHIFT;
+ unsigned long size_index = i_size_read(inode) >> CFS_PAGE_SHIFT;
struct obd_io_group *oig;
struct ll_sb_info *sbi = ll_i2sbi(inode);
int rc, noquot = llap->llap_ignore_quota ? OBD_BRW_NOQUOTA : 0;
@@ -699,7 +700,7 @@ static int queue_or_sync_write(struct obd_export *exp, struct inode *inode,
size_index, to);
to = CFS_PAGE_SIZE;
} else if (to != CFS_PAGE_SIZE && llap->llap_page->index == size_index) {
- int size_to = inode->i_size & ~CFS_PAGE_MASK;
+ int size_to = i_size_read(inode) & ~CFS_PAGE_MASK;
LL_CDEBUG_PAGE(D_PAGE, llap->llap_page,
"sync write at EOF: size_index %lu, to %d/%d\n",
size_index, to, size_to);
@@ -810,10 +811,10 @@ out:
lov_stripe_lock(lsm);
obd_adjust_kms(exp, lsm, size, 0);
lov_stripe_unlock(lsm);
- if (size > inode->i_size)
- inode->i_size = size;
+ if (size > i_size_read(inode))
+ i_size_write(inode, size);
SetPageUptodate(page);
- } else if (size > inode->i_size) {
+ } else if (size > i_size_read(inode)) {
/* this page beyond the pales of i_size, so it can't be
* truncated in ll_p_r_e during lock revoking. we must
* teardown our book-keeping here. */
@@ -1310,7 +1311,8 @@ static void ras_update(struct ll_sb_info *sbi, struct inode *inode,
if (ras->ras_requests == 2 && !ras->ras_request_index) {
__u64 kms_pages;
- kms_pages = (inode->i_size + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
+ kms_pages = (i_size_read(inode) + CFS_PAGE_SIZE - 1) >>
+ CFS_PAGE_SHIFT;
CDEBUG(D_READA, "kmsp "LPU64" mwp %lu mp %lu\n", kms_pages,
ra->ra_max_read_ahead_whole_pages, ra->ra_max_pages);
@@ -1692,7 +1694,7 @@ ssize_t ll_file_lockless_io(struct file *file, char *buf, size_t count,
loff_t isize;
ll_inode_size_lock(inode, 0);
- isize = inode->i_size;
+ isize = i_size_read(inode);
ll_inode_size_unlock(inode, 0);
if (*ppos >= isize)
GOTO(out, rc = 0);
diff --git a/lustre/llite/symlink.c b/lustre/llite/symlink.c
index d277b3db685679810194fb418433f020e3f80251..625e84fbf541ee79b0748e9b7d055b484d21b834 100644
--- a/lustre/llite/symlink.c
+++ b/lustre/llite/symlink.c
@@ -36,7 +36,7 @@ static int ll_readlink_internal(struct inode *inode,
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ll_fid fid;
struct mds_body *body;
- int rc, symlen = inode->i_size + 1;
+ int rc, symlen = i_size_read(inode) + 1;
ENTRY;
*request = NULL;
diff --git a/lustre/lvfs/fsfilt_ext3.c b/lustre/lvfs/fsfilt_ext3.c
index 5197bbf9e154f22879a749d572bec63584eabf09..8c9aa8acbd17f055641287a2342ea3b84db81452 100644
--- a/lustre/lvfs/fsfilt_ext3.c
+++ b/lustre/lvfs/fsfilt_ext3.c
@@ -530,7 +530,8 @@ static int fsfilt_ext3_setattr(struct dentry *dentry, void *handle,
if (iattr->ia_valid & ATTR_SIZE && !do_trunc) {
/* ATTR_SIZE would invoke truncate: clear it */
iattr->ia_valid &= ~ATTR_SIZE;
- EXT3_I(inode)->i_disksize = inode->i_size = iattr->ia_size;
+ EXT3_I(inode)->i_disksize = iattr->ia_size;
+ i_size_write(inode, iattr->ia_size);
if (iattr->ia_valid & ATTR_UID)
inode->i_uid = iattr->ia_uid;
@@ -699,7 +700,7 @@ static ssize_t fsfilt_ext3_readpage(struct file *file, char *buf, size_t count,
struct buffer_head *bh;
bh = NULL;
- if (*off < inode->i_size) {
+ if (*off < i_size_read(inode)) {
int err = 0;
bh = ext3_bread(NULL, inode, *off >> blkbits,
@@ -1251,12 +1252,12 @@ static int fsfilt_ext3_read_record(struct file * file, void *buf,
/* prevent reading after eof */
lock_kernel();
- if (inode->i_size < *offs + size) {
- size = inode->i_size - *offs;
+ if (i_size_read(inode) < *offs + size) {
+ size = i_size_read(inode) - *offs;
unlock_kernel();
if (size < 0) {
CERROR("size %llu is too short for read %u@%llu\n",
- inode->i_size, size, *offs);
+ i_size_read(inode), size, *offs);
return -EIO;
} else if (size == 0) {
return 0;
@@ -1293,8 +1294,8 @@ static int fsfilt_ext3_write_record(struct file *file, void *buf, int bufsize,
struct buffer_head *bh = NULL;
unsigned long block;
struct inode *inode = file->f_dentry->d_inode;
- loff_t old_size = inode->i_size, offset = *offs;
- loff_t new_size = inode->i_size;
+ loff_t old_size = i_size_read(inode), offset = *offs;
+ loff_t new_size = i_size_read(inode);
handle_t *handle;
int err = 0, block_count = 0, blocksize, size, boffs;
@@ -1354,13 +1355,13 @@ out:
brelse(bh);
/* correct in-core and on-disk sizes */
- if (new_size > inode->i_size) {
+ if (new_size > i_size_read(inode)) {
lock_kernel();
- if (new_size > inode->i_size)
- inode->i_size = new_size;
- if (inode->i_size > EXT3_I(inode)->i_disksize)
- EXT3_I(inode)->i_disksize = inode->i_size;
- if (inode->i_size > old_size)
+ if (new_size > i_size_read(inode))
+ i_size_write(inode, new_size);
+ if (i_size_read(inode) > EXT3_I(inode)->i_disksize)
+ EXT3_I(inode)->i_disksize = i_size_read(inode);
+ if (i_size_read(inode) > old_size)
mark_inode_dirty(inode);
unlock_kernel();
}
diff --git a/lustre/lvfs/fsfilt_reiserfs.c b/lustre/lvfs/fsfilt_reiserfs.c
index d575bfefca8d2936e6ccab39de1d4b7bf48453d1..00a0433ff3ccaa1acea4a0c937432e98b6b58f28 100644
--- a/lustre/lvfs/fsfilt_reiserfs.c
+++ b/lustre/lvfs/fsfilt_reiserfs.c
@@ -95,7 +95,7 @@ static int fsfilt_reiserfs_setattr(struct dentry *dentry, void *handle,
if (iattr->ia_valid & ATTR_SIZE && !do_trunc) {
/* ATTR_SIZE would invoke truncate: clear it */
iattr->ia_valid &= ~ATTR_SIZE;
- inode->i_size = iattr->ia_size;
+ i_size_write(inode, iattr->ia_size);
/* make sure _something_ gets set - so new inode
* goes to disk (probably won't work over XFS
@@ -136,7 +136,7 @@ static int fsfilt_reiserfs_get_md(struct inode *inode, void *lmm, int lmm_size,
const char *name)
{
if (lmm == NULL)
- return inode->i_size;
+ return i_size_read(inode);
CERROR("not implemented yet\n");
return -ENOSYS;
diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c
index 35eac951c9ba96cf86e80327c3174223cd6c7b4b..8309aa6f7255420148019bf93c1f1bcc79cf4b9f 100644
--- a/lustre/mds/handler.c
+++ b/lustre/mds/handler.c
@@ -108,7 +108,7 @@ static int mds_sendpage(struct ptlrpc_request *req, struct file *file,
tmpsize = tmpcount > CFS_PAGE_SIZE ? CFS_PAGE_SIZE : tmpcount;
CDEBUG(D_EXT2, "reading %u@%llu from dir %lu (size %llu)\n",
tmpsize, offset, file->f_dentry->d_inode->i_ino,
- file->f_dentry->d_inode->i_size);
+ i_size_read(file->f_dentry->d_inode));
rc = fsfilt_readpage(req->rq_export->exp_obd, file,
kmap(pages[i]), tmpsize, &offset);
@@ -817,13 +817,14 @@ static int mds_getattr_pack_msg(struct ptlrpc_request *req, struct inode *inode,
}
bufcount++;
} else if (S_ISLNK(inode->i_mode) && (body->valid & OBD_MD_LINKNAME)) {
- if (inode->i_size + 1 != body->eadatasize)
+ if (i_size_read(inode) + 1 != body->eadatasize)
CERROR("symlink size: %Lu, reply space: %d\n",
- inode->i_size + 1, body->eadatasize);
- size[bufcount] = min_t(int, inode->i_size+1, body->eadatasize);
+ i_size_read(inode) + 1, body->eadatasize);
+ size[bufcount] = min_t(int, i_size_read(inode) + 1,
+ body->eadatasize);
bufcount++;
CDEBUG(D_INODE, "symlink size: %Lu, reply space: %d\n",
- inode->i_size + 1, body->eadatasize);
+ i_size_read(inode) + 1, body->eadatasize);
}
#ifdef CONFIG_FS_POSIX_ACL
@@ -1246,7 +1247,7 @@ static int mds_readpage(struct ptlrpc_request *req, int offset)
repbody = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
sizeof(*repbody));
- repbody->size = file->f_dentry->d_inode->i_size;
+ repbody->size = i_size_read(file->f_dentry->d_inode);
repbody->valid = OBD_MD_FLSIZE;
/* to make this asynchronous make sure that the handling function
diff --git a/lustre/mds/mds_fs.c b/lustre/mds/mds_fs.c
index 2c34203fa755590c955c7b201f79766c739e8f6a..cacbff274e274637f6a4e61daab61ceba788a551 100644
--- a/lustre/mds/mds_fs.c
+++ b/lustre/mds/mds_fs.c
@@ -256,7 +256,7 @@ static int mds_init_server_data(struct obd_device *obd, struct file *file)
struct lr_server_data *lsd;
struct mds_client_data *mcd = NULL;
loff_t off = 0;
- unsigned long last_rcvd_size = file->f_dentry->d_inode->i_size;
+ unsigned long last_rcvd_size = i_size_read(file->f_dentry->d_inode);
__u64 mount_count;
int cl_idx, rc = 0;
ENTRY;
diff --git a/lustre/mds/mds_lib.c b/lustre/mds/mds_lib.c
index 7769cdddd4fd27fba92d3f1ad98e90538e5d2ed9..b6a3cf62ea8fec41b690cb4c0e0887f917b7d2cb 100644
--- a/lustre/mds/mds_lib.c
+++ b/lustre/mds/mds_lib.c
@@ -78,7 +78,7 @@ void mds_pack_inode2body(struct mds_body *b, struct inode *inode)
b->mtime = LTIME_S(inode->i_mtime);
b->ctime = LTIME_S(inode->i_ctime);
b->mode = inode->i_mode;
- b->size = inode->i_size;
+ b->size = i_size_read(inode);
b->blocks = inode->i_blocks;
b->uid = inode->i_uid;
b->gid = inode->i_gid;
diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c
index f2e00e5ba5174d7e3330f9f2e34b61e0fcfde15d..8c277e9840942610c140fc7ea5a13c85600f7c01 100644
--- a/lustre/mds/mds_lov.c
+++ b/lustre/mds/mds_lov.c
@@ -71,7 +71,7 @@ static int mds_lov_read_objids(struct obd_device *obd)
/* Read everything in the file, even if our current lov desc
has fewer targets. Old targets not in the lov descriptor
during mds setup may still have valid objids. */
- size = mds->mds_lov_objid_filp->f_dentry->d_inode->i_size;
+ size = i_size_read(mds->mds_lov_objid_filp->f_dentry->d_inode);
if (size == 0)
RETURN(0);
diff --git a/lustre/mds/mds_open.c b/lustre/mds/mds_open.c
index 12e0ea451b465f1f9becf202f628ac9b7fcd9e2a..a71b66301e6286ba1f7f20024deb087c6c72f4c7 100644
--- a/lustre/mds/mds_open.c
+++ b/lustre/mds/mds_open.c
@@ -432,10 +432,10 @@ static int mds_create_objects(struct ptlrpc_request *req, int offset,
}
oinfo.oi_md->lsm_object_id = oinfo.oi_oa->o_id;
}
- if (inode->i_size) {
- oinfo.oi_oa->o_size = inode->i_size;
- obdo_from_inode(oinfo.oi_oa, inode, OBD_MD_FLTYPE |
- OBD_MD_FLATIME | OBD_MD_FLMTIME |
+ if (i_size_read(inode)) {
+ oinfo.oi_oa->o_size = i_size_read(inode);
+ obdo_from_inode(oinfo.oi_oa, inode, OBD_MD_FLTYPE |
+ OBD_MD_FLATIME | OBD_MD_FLMTIME |
OBD_MD_FLCTIME | OBD_MD_FLSIZE);
/* pack lustre id to OST */
diff --git a/lustre/obdclass/linux/linux-obdo.c b/lustre/obdclass/linux/linux-obdo.c
index d7f37dc740ceca21820efa8a3e2018e4a0a63805..a5bf3b990feb679d32f3b4b546cf83fb996454b4 100644
--- a/lustre/obdclass/linux/linux-obdo.c
+++ b/lustre/obdclass/linux/linux-obdo.c
@@ -151,7 +151,7 @@ void obdo_from_inode(struct obdo *dst, struct inode *src, obd_flag valid)
newvalid |= OBD_MD_FLCTIME;
}
if (valid & OBD_MD_FLSIZE) {
- dst->o_size = src->i_size;
+ dst->o_size = i_size_read(src);
newvalid |= OBD_MD_FLSIZE;
}
if (valid & OBD_MD_FLBLOCKS) { /* allocation of space (x512 bytes) */
@@ -207,7 +207,7 @@ void obdo_refresh_inode(struct inode *dst, struct obdo *src, obd_flag valid)
if (valid & OBD_MD_FLATIME && src->o_atime > LTIME_S(dst->i_atime))
LTIME_S(dst->i_atime) = src->o_atime;
-
+
/* mtime is always updated with ctime, but can be set in past.
As write and utime(2) may happen within 1 second, and utime's
mtime has a priority over write's one, leave mtime from mds
@@ -217,8 +217,8 @@ void obdo_refresh_inode(struct inode *dst, struct obdo *src, obd_flag valid)
if (valid & OBD_MD_FLMTIME)
LTIME_S(dst->i_mtime) = src->o_mtime;
}
- if (valid & OBD_MD_FLSIZE)
- dst->i_size = src->o_size;
+ if (valid & OBD_MD_FLSIZE)
+ i_size_write(dst, src->o_size);
/* optimum IO size */
if (valid & OBD_MD_FLBLKSZ && src->o_blksize > (1<<dst->i_blkbits)) {
dst->i_blkbits = ffs(src->o_blksize)-1;
@@ -257,7 +257,7 @@ void obdo_to_inode(struct inode *dst, struct obdo *src, obd_flag valid)
if (valid & OBD_MD_FLCTIME && src->o_ctime > LTIME_S(dst->i_ctime))
LTIME_S(dst->i_ctime) = src->o_ctime;
if (valid & OBD_MD_FLSIZE)
- dst->i_size = src->o_size;
+ i_size_write(dst, src->o_size);
if (valid & OBD_MD_FLBLOCKS) { /* allocation of space */
dst->i_blocks = src->o_blocks;
if (dst->i_blocks < src->o_blocks) /* overflow */
diff --git a/lustre/obdclass/llog_cat.c b/lustre/obdclass/llog_cat.c
index e4c9ba2bfdc7f88c2e2bda2865b2ee1e39d13f1a..6cb3175295f6e9df1853939f6856db882282e1fe 100644
--- a/lustre/obdclass/llog_cat.c
+++ b/lustre/obdclass/llog_cat.c
@@ -506,7 +506,7 @@ int llog_cat_init(struct llog_handle *cathandle, struct obd_uuid *tgtuuid)
down(&cathandle->lgh_lock);
llh = cathandle->lgh_hdr;
- if (cathandle->lgh_file->f_dentry->d_inode->i_size == 0) {
+ if (i_size_read(cathandle->lgh_file->f_dentry->d_inode) == 0) {
llog_write_rec(cathandle, &llh->llh_hdr, NULL, 0, NULL, 0);
write_hdr:
diff --git a/lustre/obdclass/llog_lvfs.c b/lustre/obdclass/llog_lvfs.c
index 2303a4ba82b72deee70cd9745716add861be9ee5..6204fac22891643afb817a9342d21695cb948cc7 100644
--- a/lustre/obdclass/llog_lvfs.c
+++ b/lustre/obdclass/llog_lvfs.c
@@ -160,7 +160,7 @@ static int llog_lvfs_read_header(struct llog_handle *handle)
obd = handle->lgh_ctxt->loc_exp->exp_obd;
- if (handle->lgh_file->f_dentry->d_inode->i_size == 0) {
+ if (i_size_read(handle->lgh_file->f_dentry->d_inode) == 0) {
CDEBUG(D_RPCTRACE, "not reading header from 0-byte log\n");
RETURN(LLOG_EEMPTY);
}
@@ -195,7 +195,7 @@ static int llog_lvfs_read_header(struct llog_handle *handle)
}
handle->lgh_last_idx = handle->lgh_hdr->llh_tail.lrt_index;
- handle->lgh_file->f_pos = handle->lgh_file->f_dentry->d_inode->i_size;
+ handle->lgh_file->f_pos = i_size_read(handle->lgh_file->f_dentry->d_inode);
RETURN(rc);
}
@@ -237,11 +237,11 @@ static int llog_lvfs_write_rec(struct llog_handle *loghandle,
loff_t saved_offset;
/* no header: only allowed to insert record 1 */
- if (idx != 1 && !file->f_dentry->d_inode->i_size) {
+ if (idx != 1 && !i_size_read(file->f_dentry->d_inode)) {
CERROR("idx != -1 in empty log\n");
LBUG();
}
-
+
if (idx && llh->llh_size && llh->llh_size != rec->lrh_len)
RETURN(-EINVAL);
@@ -398,7 +398,7 @@ static int llog_lvfs_next_block(struct llog_handle *loghandle, int *cur_idx,
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off "LPU64")\n",
next_idx, *cur_idx, *cur_offset);
- while (*cur_offset < loghandle->lgh_file->f_dentry->d_inode->i_size) {
+ while (*cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {
struct llog_rec_hdr *rec;
struct llog_rec_tail *tail;
loff_t ppos;
@@ -484,7 +484,7 @@ static int llog_lvfs_prev_block(struct llog_handle *loghandle,
cur_offset = LLOG_CHUNK_SIZE;
llog_skip_over(&cur_offset, 0, prev_idx);
- while (cur_offset < loghandle->lgh_file->f_dentry->d_inode->i_size) {
+ while (cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {
struct llog_rec_hdr *rec;
struct llog_rec_tail *tail;
loff_t ppos;
@@ -775,8 +775,8 @@ int llog_get_cat_list(struct obd_device *obd, struct obd_device *disk_obd,
GOTO(out, rc = -ENOENT);
}
- CDEBUG(D_CONFIG, "cat list: disk size=%d, read=%d\n",
- (int)file->f_dentry->d_inode->i_size, size);
+ CDEBUG(D_CONFIG, "cat list: disk size=%d, read=%d\n",
+ (int)i_size_read(file->f_dentry->d_inode), size);
rc = fsfilt_read_record(disk_obd, file, idarray, size, &off);
if (rc) {
diff --git a/lustre/obdclass/obd_mount.c b/lustre/obdclass/obd_mount.c
index b0bc3faeb677955190434d8e3df173b9fb5ac4c8..a726c1e5c0525f1864d75fd9f3b6ce5586e62157 100644
--- a/lustre/obdclass/obd_mount.c
+++ b/lustre/obdclass/obd_mount.c
@@ -247,7 +247,7 @@ static int ldd_parse(struct lvfs_run_ctxt *mount_ctxt,
GOTO(out, rc);
}
- len = file->f_dentry->d_inode->i_size;
+ len = i_size_read(file->f_dentry->d_inode);
CDEBUG(D_MOUNT, "Have %s, size %lu\n", MOUNT_DATA_FILE, len);
if (len != sizeof(*ldd)) {
CERROR("disk data size does not match: see %lu expect "LPSZ"\n",
diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c
index ee2c4d0b5123baed887d7d9c35dbb14c5a7d9111..1cceb303c3fad51647124614b13ab3c87815ee0e 100644
--- a/lustre/obdfilter/filter.c
+++ b/lustre/obdfilter/filter.c
@@ -621,7 +621,7 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp)
struct lr_server_data *fsd;
struct filter_client_data *fcd = NULL;
struct inode *inode = filp->f_dentry->d_inode;
- unsigned long last_rcvd_size = inode->i_size;
+ unsigned long last_rcvd_size = i_size_read(inode);
__u64 mount_count;
int cl_idx;
loff_t off = 0;
@@ -934,7 +934,7 @@ static int filter_prep_groups(struct obd_device *obd)
}
filter->fo_last_objid_files[i] = filp;
- if (filp->f_dentry->d_inode->i_size == 0) {
+ if (i_size_read(filp->f_dentry->d_inode) == 0) {
filter->fo_last_objids[i] = FILTER_INIT_OBJID;
rc = filter_update_last_objid(obd, i, 1);
if (rc)
diff --git a/lustre/obdfilter/filter_io.c b/lustre/obdfilter/filter_io.c
index c0f865177e76db9ce9629d9dd4f4141af2c07423..6b1e4a0a9b3988a07b1eaea7f74d5f91e6ecbe6b 100644
--- a/lustre/obdfilter/filter_io.c
+++ b/lustre/obdfilter/filter_io.c
@@ -320,15 +320,15 @@ static int filter_preprw_read(int cmd, struct obd_export *exp, struct obdo *oa,
*/
LASSERT(lnb->page != NULL);
- if (inode->i_size <= rnb->offset)
+ if (i_size_read(inode) <= rnb->offset)
/* If there's no more data, abort early. lnb->rc == 0,
* so it's easy to detect later. */
break;
else
filter_alloc_dio_page(obd, inode, lnb);
- if (inode->i_size < lnb->offset + lnb->len - 1)
- lnb->rc = inode->i_size - lnb->offset;
+ if (i_size_read(inode) < lnb->offset + lnb->len - 1)
+ lnb->rc = i_size_read(inode) - lnb->offset;
else
lnb->rc = lnb->len;
@@ -631,13 +631,13 @@ static int filter_preprw_write(int cmd, struct obd_export *exp, struct obdo *oa,
if (lnb->len != CFS_PAGE_SIZE) {
__s64 maxidx;
- maxidx = ((dentry->d_inode->i_size + CFS_PAGE_SIZE - 1) >>
- CFS_PAGE_SHIFT) - 1;
+ maxidx = ((i_size_read(dentry->d_inode) +
+ CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT) - 1;
if (maxidx >= lnb->page->index) {
LL_CDEBUG_PAGE(D_PAGE, lnb->page, "write %u @ "
LPU64" flg %x before EOF %llu\n",
lnb->len, lnb->offset,lnb->flags,
- dentry->d_inode->i_size);
+ i_size_read(dentry->d_inode));
filter_iobuf_add_page(exp->exp_obd, iobuf,
dentry->d_inode,
lnb->page);
@@ -713,7 +713,7 @@ void filter_release_read_page(struct filter_obd *filter, struct inode *inode,
int drop = 0;
if (inode != NULL &&
- (inode->i_size > filter->fo_readcache_max_filesize))
+ (i_size_read(inode) > filter->fo_readcache_max_filesize))
drop = 1;
/* drop from cache like truncate_list_pages() */
diff --git a/lustre/obdfilter/filter_io_24.c b/lustre/obdfilter/filter_io_24.c
index fe5e6c6658a5855b50dd080d1fb1cbad3b9869d0..a2042f898e4489148b0eaacd6a295079a4f8471d 100644
--- a/lustre/obdfilter/filter_io_24.c
+++ b/lustre/obdfilter/filter_io_24.c
@@ -170,7 +170,7 @@ int filter_clear_truncated_page(struct inode *inode)
int rc;
/* Truncate on page boundary, so nothing to flush? */
- if (!(inode->i_size & ~CFS_PAGE_MASK))
+ if (!(i_size_read(inode) & ~CFS_PAGE_MASK))
return 0;
rc = filter_sync_inode_data(inode);
@@ -180,7 +180,7 @@ int filter_clear_truncated_page(struct inode *inode)
/* be careful to call this after fsync_inode_data_buffers has waited
* for IO to complete before we evict it from the cache */
page = find_lock_page(inode->i_mapping,
- inode->i_size >> CFS_PAGE_SHIFT);
+ i_size_read(inode) >> CFS_PAGE_SHIFT);
if (page) {
if (page->mapping != NULL)
ll_truncate_complete_page(page);
@@ -244,7 +244,7 @@ int filter_direct_io(int rw, struct dentry *dchild, struct filter_iobuf *buf,
KIOBUF_GET_BLOCKS(iobuf), blocks_per_page,
1);
- if (attr->ia_size > inode->i_size)
+ if (attr->ia_size > i_size_read(inode))
attr->ia_valid |= ATTR_SIZE;
rc = fsfilt_setattr(obd, dchild,
oti->oti_handle, attr, 0);
diff --git a/lustre/obdfilter/filter_io_26.c b/lustre/obdfilter/filter_io_26.c
index 20550d5ca918d80e769ca684f0df147186523d8f..2af91fe3763f89e83a310a15d3de3d89eef5f2cb 100644
--- a/lustre/obdfilter/filter_io_26.c
+++ b/lustre/obdfilter/filter_io_26.c
@@ -489,7 +489,7 @@ int filter_clear_truncated_page(struct inode *inode)
int rc;
/* Truncate on page boundary, so nothing to flush? */
- if (!(inode->i_size & ~CFS_PAGE_MASK))
+ if (!(i_size_read(inode) & ~CFS_PAGE_MASK))
return 0;
rc = filter_sync_inode_data(inode, 1);
@@ -499,7 +499,7 @@ int filter_clear_truncated_page(struct inode *inode)
/* be careful to call this after fsync_inode_data_buffers has waited
* for IO to complete before we evict it from the cache */
page = find_lock_page(inode->i_mapping,
- inode->i_size >> CFS_PAGE_SHIFT);
+ i_size_read(inode) >> CFS_PAGE_SHIFT);
if (page) {
if (page->mapping != NULL) {
wait_on_page_writeback(page);
@@ -552,7 +552,7 @@ int filter_direct_io(int rw, struct dentry *dchild, struct filter_iobuf *iobuf,
filter_tally(exp, iobuf->dr_pages,
iobuf->dr_npages, iobuf->dr_blocks,
blocks_per_page, 1);
- if (attr->ia_size > inode->i_size)
+ if (attr->ia_size > i_size_read(inode))
attr->ia_valid |= ATTR_SIZE;
rc = fsfilt_setattr(obd, dchild,
oti->oti_handle, attr, 0);
diff --git a/lustre/obdfilter/filter_lvb.c b/lustre/obdfilter/filter_lvb.c
index 115a0124487e5dc798a5afd693b979e5caae0ab4..cb0eb9ce0da71c3749fcbf31b8d4cb534b8a2219 100644
--- a/lustre/obdfilter/filter_lvb.c
+++ b/lustre/obdfilter/filter_lvb.c
@@ -178,11 +178,11 @@ static int filter_lvbo_update(struct ldlm_resource *res, struct lustre_msg *m,
if (dentry->d_inode == NULL)
GOTO(out_dentry, rc = -ENOENT);
- if (dentry->d_inode->i_size > lvb->lvb_size || !increase_only) {
+ if (i_size_read(dentry->d_inode) > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb size from disk: "
LPU64" -> %llu\n", res->lr_name.name[0],
- lvb->lvb_size, dentry->d_inode->i_size);
- lvb->lvb_size = dentry->d_inode->i_size;
+ lvb->lvb_size, i_size_read(dentry->d_inode));
+ lvb->lvb_size = i_size_read(dentry->d_inode);
}
if (LTIME_S(dentry->d_inode->i_mtime) >lvb->lvb_mtime|| !increase_only){
diff --git a/lustre/ptlrpc/llog_server.c b/lustre/ptlrpc/llog_server.c
index 3de3553266f8b9fc12db397a11dc6e2c34b4bf86..dff4397534b5c576be4c4f93ac3377964944f61d 100644
--- a/lustre/ptlrpc/llog_server.c
+++ b/lustre/ptlrpc/llog_server.c
@@ -479,7 +479,7 @@ static int llog_catinfo_config(struct obd_device *obd, char *buf, int buf_len,
l = snprintf(out, remains, "[Log Name]: %s\nLog Size: %llu\n"
"Last Index: %d\nUncanceled Records: %d\n\n",
name[i],
- handle->lgh_file->f_dentry->d_inode->i_size,
+ i_size_read(handle->lgh_file->f_dentry->d_inode),
handle->lgh_last_idx, uncanceled);
out += l;
remains -= l;
@@ -544,7 +544,7 @@ static int llog_catinfo_cb(struct llog_handle *cat,
"\tLog Size: %llu\n\tLast Index: %d\n"
"\tUncanceled Records: %d\n",
logid->lgl_oid, logid->lgl_ogr, logid->lgl_ogen,
- handle->lgh_file->f_dentry->d_inode->i_size,
+ i_size_read(handle->lgh_file->f_dentry->d_inode),
handle->lgh_last_idx, count);
out += l;
remains -= l;
diff --git a/lustre/quota/quotacheck_test.c b/lustre/quota/quotacheck_test.c
index c5ec4aa1c3a9ca4ef915ac7a1945df89bd7ca696..6c4acf32921b26c63f8c8559b45080492f7c435b 100644
--- a/lustre/quota/quotacheck_test.c
+++ b/lustre/quota/quotacheck_test.c
@@ -86,7 +86,7 @@ static void print_inode(struct inode *inode)
size = inode_get_bytes(inode);
CERROR("%lu: uid: %u, size: %llu, blocks: %llu, real size: %llu\n",
- inode->i_ino, inode->i_uid, inode->i_size,
+ inode->i_ino, inode->i_uid, i_size_read(inode),
(long long)inode->i_blocks, size);
}