diff --git a/lustre/ChangeLog b/lustre/ChangeLog
index af55abfa3d6debd77d775d91fe9d74ff678eab9b..e1d41546a3e4bd15d757fe9986a69c192449edf5 100644
--- a/lustre/ChangeLog
+++ b/lustre/ChangeLog
@@ -244,6 +244,11 @@ Details : "lfs find -obd UUID" will return all directory names instead
of just file names. It is incorrect because the directories
do not reside on the OSTs.
+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-08-10 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 87be84859b5624aaf4bf23329c59cbce13140b43..bb6cdf452e2daed2b2f9e899487a1fdc698c1ab7 100644
--- a/lustre/llite/dir.c
+++ b/lustre/llite/dir.c
@@ -171,7 +171,7 @@ static int ll_dir_readpage(struct file *file, struct page *page)
LASSERT_REPSWABBED(request, REPLY_REC_OFF);
if (body->valid & OBD_MD_FLSIZE)
- inode->i_size = body->size;
+ i_size_write(inode, body->size);
SetPageUptodate(page);
}
ptlrpc_req_finished(request);
@@ -187,7 +187,7 @@ struct address_space_operations ll_dir_aops = {
static inline unsigned long dir_pages(struct inode *inode)
{
- return (inode->i_size + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
+ return (i_size_read(inode) + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
}
static inline unsigned ll_chunk_size(struct inode *inode)
@@ -416,7 +416,7 @@ int ll_readdir(struct file *filp, void *cookie, filldir_t filldir)
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) pos %lu/%llu\n",
inode->i_ino, inode->i_generation, inode,
- (unsigned long)pos, inode->i_size);
+ (unsigned long)pos, i_size_read(inode));
if (pos == DIR_END_OFF)
/*
@@ -440,7 +440,7 @@ int ll_readdir(struct file *filp, void *cookie, filldir_t filldir)
* If page is empty (end of directoryis reached),
* use this value.
*/
- __u32 hash = DIR_END_OFF;
+ __u32 hash = DIR_END_OFF;
__u32 next;
dp = page_address(page);
diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index 7c4e5a37c3679312051edf6a7635e54318b0029b..82a6108292ba7c1bc48baf2460e065a632427c26 100644
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -56,7 +56,7 @@ void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
op_data->op_attr.ia_atime = inode->i_atime;
op_data->op_attr.ia_mtime = inode->i_mtime;
op_data->op_attr.ia_ctime = inode->i_ctime;
- op_data->op_attr.ia_size = inode->i_size;
+ op_data->op_attr.ia_size = i_size_read(inode);
op_data->op_attr_blocks = inode->i_blocks;
((struct ll_iattr *)&op_data->op_attr)->ia_attr_flags = inode->i_flags;
op_data->op_ioepoch = ll_i2info(inode)->lli_ioepoch;
@@ -673,8 +673,8 @@ int ll_inode_getattr(struct inode *inode, struct obdo *obdo)
obdo_refresh_inode(inode, oinfo.oi_oa, oinfo.oi_oa->o_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,
- inode->i_blksize);
+ lli->lli_smd->lsm_object_id, i_size_read(inode),
+ inode->i_blocks, inode->i_blksize);
RETURN(0);
}
@@ -752,7 +752,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. */
@@ -777,7 +777,8 @@ 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 ? (__u64)(inode->i_size - 1) >> CFS_PAGE_SHIFT : 0;
+ i = i_size_read(inode) ? (__u64)(i_size_read(inode) - 1) >>
+ CFS_PAGE_SHIFT : 0;
if (i < end)
end = i;
@@ -1037,7 +1038,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);
@@ -1062,7 +1063,7 @@ static void ll_merge_lvb(struct inode *inode)
ll_inode_size_lock(inode, 1);
inode_init_lvb(inode, &lvb);
obd_merge_lvb(sbi->ll_dt_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;
@@ -1193,7 +1194,7 @@ int ll_glimpse_size(struct inode *inode, int ast_flags)
ll_merge_lvb(inode);
CDEBUG(D_DLMTRACE, "glimpse: size: %llu, blocks: %lu\n",
- inode->i_size, inode->i_blocks);
+ i_size_read(inode), inode->i_blocks);
RETURN(rc);
}
@@ -1258,9 +1259,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;
- CDEBUG(D_INODE, "inode=%lu, updating i_size %llu\n",
- inode->i_ino, inode->i_size);
+ i_size_write(inode, lvb.lvb_size);
+ CDEBUG(D_INODE, "inode=%lu, updating i_size %llu\n",
+ inode->i_ino, i_size_read(inode));
}
if (rc == 0) {
@@ -1328,11 +1329,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);
@@ -1411,14 +1412,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 (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
@@ -1534,7 +1535,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;
}
@@ -1648,12 +1649,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;
@@ -2015,8 +2016,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);
@@ -2025,23 +2026,23 @@ 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};
struct lustre_handle lockh;
struct md_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;
- op_data = ll_prep_md_op_data(NULL, head_inode, tail_parent,
+ data = i_size_read(head_inode);
+ op_data = ll_prep_md_op_data(NULL, head_inode,
+ tail_dentry->d_parent->d_inode,
tail_dentry->d_name.name,
tail_dentry->d_name.len, 0,
- LUSTRE_OPC_ANY, &head_inode->i_size);
+ LUSTRE_OPC_ANY, &data);
if (IS_ERR(op_data))
RETURN(PTR_ERR(op_data));
@@ -2311,13 +2312,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;
@@ -2331,7 +2332,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;
@@ -2705,7 +2706,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 ffddd6eb4a6219c5fbdef1476a1b56cfaa478304..326adf44dc53e249038b1ff4ad86f951c54bb6fa 100644
--- a/lustre/llite/llite_close.c
+++ b/lustre/llite/llite_close.c
@@ -33,7 +33,7 @@
void llap_write_pending(struct inode *inode, struct ll_async_page *llap)
{
struct ll_inode_info *lli = ll_i2info(inode);
-
+
ENTRY;
spin_lock(&lli->lli_lock);
lli->lli_flags |= LLIF_SOM_DIRTY;
@@ -199,7 +199,7 @@ int ll_sizeonmds_update(struct inode *inode, struct lustre_handle *fh,
CWARN("ino %lu/%u(flags %lu) som valid it just after "
"recovery\n", inode->i_ino, inode->i_generation,
lli->lli_flags);
-
+
OBDO_ALLOC(oa);
OBD_ALLOC_PTR(op_data);
if (!oa || !op_data) {
@@ -214,13 +214,13 @@ int ll_sizeonmds_update(struct inode *inode, struct lustre_handle *fh,
GOTO(out, rc);
}
CDEBUG(D_INODE, "Size-on-MDS update on "DFID"\n", PFID(&lli->lli_fid));
-
+
md_from_obdo(op_data, oa, oa->o_valid);
memcpy(&op_data->op_handle, fh, sizeof(*fh));
-
+
op_data->op_ioepoch = ioepoch;
op_data->op_flags |= MF_SOM_CHANGE;
-
+
rc = ll_md_setattr(inode, op_data);
EXIT;
out:
diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index 6d4095b7ee6e2625943399c306061288f7214f4e..241bcd4a25a97f311c6be74cd1718f15549d57e8 100644
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -1174,7 +1174,7 @@ int ll_md_setattr(struct inode *inode, struct md_op_data *op_data)
/* Extract epoch data if obtained. */
memcpy(&op_data->op_handle, &md.body->handle, sizeof(op_data->op_handle));
op_data->op_ioepoch = md.body->ioepoch;
-
+
ll_update_inode(inode, &md);
ptlrpc_req_finished(request);
@@ -1296,7 +1296,7 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
RETURN(-ENOMEM);
memcpy(&op_data->op_attr, attr, sizeof(*attr));
-
+
/* Open epoch for truncate. */
if (ia_valid & ATTR_SIZE)
op_data->op_flags = MF_EPOCH_OPEN;
@@ -1304,7 +1304,7 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
rc = ll_md_setattr(inode, op_data);
if (rc)
GOTO(out, rc);
-
+
if (op_data->op_ioepoch)
CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID" for "
"truncate\n", op_data->op_ioepoch, PFID(&lli->lli_fid));
@@ -1668,11 +1668,11 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md)
"do not trust the size got from MDS\n",
inode->i_ino, lli->lli_flags);
else {
- inode->i_size = body->size;
+ i_size_write(inode, body->size);
lli->lli_flags |= LLIF_MDS_SIZE_LOCK;
}
} else {
- inode->i_size = body->size;
+ i_size_write(inode, body->size);
}
if (body->valid & OBD_MD_FLBLOCKS)
diff --git a/lustre/llite/llite_mmap.c b/lustre/llite/llite_mmap.c
index a00e6af10ab45f2f13f3968a298857cd03f1cbe1..e45f84db4e0061efdc2c32cbb092643430697a8d 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_i2dtexp(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 005590b4bd52859d982e3734fae1f09a40d9e7f9..25c4179bbd2e25aee36af8d96ceebfe515957bf5 100644
--- a/lustre/llite/rw.c
+++ b/lustre/llite/rw.c
@@ -73,8 +73,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;
@@ -83,9 +83,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;
@@ -125,7 +125,8 @@ void ll_truncate(struct inode *inode)
int rc;
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) {
@@ -146,22 +147,24 @@ void ll_truncate(struct inode *inode)
lov_stripe_lock(lli->lli_smd);
inode_init_lvb(inode, &lvb);
obd_merge_lvb(ll_i2dtexp(inode), lli->lli_smd, &lvb, 0);
- if (lvb.lvb_size == inode->i_size) {
+ if (lvb.lvb_size == i_size_read(inode)) {
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_i2dtexp(inode), lli->lli_smd, inode->i_size, 1);
+ obd_adjust_kms(ll_i2dtexp(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) {
@@ -174,10 +177,10 @@ void ll_truncate(struct inode *inode)
}
CDEBUG(D_INFO, "calling punch for "LPX64" (new size %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));
oinfo.oi_md = lli->lli_smd;
- oinfo.oi_policy.l_extent.start = inode->i_size;
+ oinfo.oi_policy.l_extent.start = i_size_read(inode);
oinfo.oi_policy.l_extent.end = OBD_OBJECT_EOF;
oinfo.oi_oa = &oa;
oa.o_id = lli->lli_smd->lsm_object_id;
@@ -673,7 +676,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;
@@ -704,7 +707,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);
@@ -836,10 +839,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. */
@@ -1341,7 +1344,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);
diff --git a/lustre/llite/symlink.c b/lustre/llite/symlink.c
index 3edbb1f35507ec0360552ed65e5380694d25cffb..232ff19ee92d91cfd225ba86ddcf51b08f18f678 100644
--- a/lustre/llite/symlink.c
+++ b/lustre/llite/symlink.c
@@ -34,7 +34,7 @@ static int ll_readlink_internal(struct inode *inode,
{
struct ll_inode_info *lli = ll_i2info(inode);
struct ll_sb_info *sbi = ll_i2sbi(inode);
- int rc, symlen = inode->i_size + 1;
+ int rc, symlen = i_size_read(inode) + 1;
struct mdt_body *body;
struct obd_capa *oc;
ENTRY;
diff --git a/lustre/lvfs/fsfilt_ext3.c b/lustre/lvfs/fsfilt_ext3.c
index 73222567e3d20bd0d6d41c3827d0a6bba10e4cb7..6164a09a8d7d33d443647828e0922d9ad766aa8f 100644
--- a/lustre/lvfs/fsfilt_ext3.c
+++ b/lustre/lvfs/fsfilt_ext3.c
@@ -508,7 +508,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;
@@ -645,7 +646,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,
@@ -1137,12 +1138,12 @@ int fsfilt_ext3_read(struct inode *inode, void *buf, int size, loff_t *offs)
/* 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;
@@ -1188,8 +1189,8 @@ int fsfilt_ext3_write_handle(struct inode *inode, void *buf, int bufsize,
loff_t *offs, handle_t *handle)
{
struct buffer_head *bh = NULL;
- 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);
unsigned long block;
int err = 0, blocksize = 1 << inode->i_blkbits, size, boffs;
@@ -1230,13 +1231,13 @@ int fsfilt_ext3_write_handle(struct inode *inode, void *buf, int bufsize,
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 684afe98fe0c06f1ce2b4084299b5c75c4212b53..f03f8537f6b146927c497dc39980c70a0d4867e4 100644
--- a/lustre/lvfs/fsfilt_reiserfs.c
+++ b/lustre/lvfs/fsfilt_reiserfs.c
@@ -96,7 +96,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
@@ -137,7 +137,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 cb20435c99ad35f711fc1929aabfa0a8529d6692..c1eccb326312d1ddce55cc4a5e444d18a3e6f489 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);
@@ -797,13 +797,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
@@ -1225,7 +1226,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 c62dd112cac1972b711e4a751644dd8373b5a4aa..6d94db70105bd4bb715ecbd1b49ac20ba28d8867 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 678ce53b0a5c98471b47d0a3b61c5f68296bc366..ff2346cde92afc72418b25c6157cdcd05432e24d 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 0206299ed65549907d5be6d7777bb0883e59258c..0ef7084dcf6bf2d2bce152c9b6fd3a74728fdeb0 100644
--- a/lustre/mds/mds_lov.c
+++ b/lustre/mds/mds_lov.c
@@ -72,7 +72,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 e526ee9b4904791a168888706f5d958e54bcdff0..73da5aa8081b8c853db8cddc44ea94da201f0894 100644
--- a/lustre/mds/mds_open.c
+++ b/lustre/mds/mds_open.c
@@ -433,8 +433,8 @@ static int mds_create_objects(struct ptlrpc_request *req, int offset,
oinfo.oi_md->lsm_object_id = oinfo.oi_oa->o_id;
oinfo.oi_md->lsm_object_gr = oinfo.oi_oa->o_gr;
}
- if (inode->i_size) {
- oinfo.oi_oa->o_size = inode->i_size;
+ 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);
diff --git a/lustre/obdclass/linux/linux-obdo.c b/lustre/obdclass/linux/linux-obdo.c
index d6bc3c31db3111dc6b3d83c968ed128bbef41110..b66062d63ec8dc659a6231089beb2455e5816246 100644
--- a/lustre/obdclass/linux/linux-obdo.c
+++ b/lustre/obdclass/linux/linux-obdo.c
@@ -68,7 +68,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) */
@@ -169,7 +169,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
@@ -179,8 +179,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;
@@ -219,7 +219,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 a757e68c3c724479fd62eb6e775028d2992f5d1f..5bd8d128a2ec9addb2c641c9fcc7ac2be2b64520 100644
--- a/lustre/obdclass/llog_cat.c
+++ b/lustre/obdclass/llog_cat.c
@@ -507,7 +507,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 6e0309bd4abab9ef92793b85676c2724982776d5..6c46344f82e82a99d2db13c60c4d2af082c99fd5 100644
--- a/lustre/obdclass/llog_lvfs.c
+++ b/lustre/obdclass/llog_lvfs.c
@@ -161,7 +161,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_HA, "not reading header from 0-byte log\n");
RETURN(LLOG_EEMPTY);
}
@@ -196,7 +196,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);
}
@@ -238,7 +238,7 @@ 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();
}
@@ -399,7 +399,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;
@@ -485,7 +485,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;
@@ -776,8 +776,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 cfd04edcdb0b5dd88633cd1986d290413cdcc443..29d50224505701843071a4a6f958a90abe4c433e 100644
--- a/lustre/obdclass/obd_mount.c
+++ b/lustre/obdclass/obd_mount.c
@@ -272,7 +272,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 81530b225b18658780cfabf0b9cdab9735b77be9..b53ea58a70853ed53680dd37fd1482fc1fc6214c 100644
--- a/lustre/obdfilter/filter.c
+++ b/lustre/obdfilter/filter.c
@@ -623,7 +623,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;
@@ -1040,7 +1040,7 @@ static int filter_read_group_internal(struct obd_device *obd, int group,
filter_update_last_group(obd, group);
- if (filp->f_dentry->d_inode->i_size == 0) {
+ if (i_size_read(filp->f_dentry->d_inode) == 0) {
filter->fo_last_objids[group] = FILTER_INIT_OBJID;
rc = filter_update_last_objid(obd, group, 1);
RETURN(rc);
diff --git a/lustre/obdfilter/filter_io.c b/lustre/obdfilter/filter_io.c
index 04845a70244d2e84a9e457f37dea6862fb2793c6..81e1acefa96912587c77c99ba83a1a9f38ed83cf 100644
--- a/lustre/obdfilter/filter_io.c
+++ b/lustre/obdfilter/filter_io.c
@@ -339,15 +339,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;
@@ -633,13 +633,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_26.c b/lustre/obdfilter/filter_io_26.c
index cc3bb41b7784c116e9254b074a18e51d2245edb0..03b456c28819d42945e89934622e33814df55247 100644
--- a/lustre/obdfilter/filter_io_26.c
+++ b/lustre/obdfilter/filter_io_26.c
@@ -468,7 +468,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);
@@ -478,7 +478,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);
@@ -530,7 +530,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 86d01922c19bd96f1f1b944ff33f19e3e409c84a..43c69b1eec3f150bcf75188511a0aeaa72ebb21e 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/osd/osd_handler.c b/lustre/osd/osd_handler.c
index 7033717e525f5ccad727b97661f2561eb02e3ecd..37efb19836cfc67d90ab82ae1c3d3c1b73e9f14d 100644
--- a/lustre/osd/osd_handler.c
+++ b/lustre/osd/osd_handler.c
@@ -1063,8 +1063,10 @@ static void osd_inode_setattr(const struct lu_env *env,
inode->i_ctime = *osd_inode_time(env, inode, attr->la_ctime);
if (bits & LA_MTIME)
inode->i_mtime = *osd_inode_time(env, inode, attr->la_mtime);
- if (bits & LA_SIZE)
- LDISKFS_I(inode)->i_disksize = inode->i_size = attr->la_size;
+ if (bits & LA_SIZE) {
+ LDISKFS_I(inode)->i_disksize = attr->la_size;
+ i_size_write(inode, attr->la_size);
+ }
if (bits & LA_BLOCKS)
inode->i_blocks = attr->la_blocks;
if (bits & LA_MODE)
@@ -2487,7 +2489,7 @@ static void osd_inode_getattr(const struct lu_env *env,
attr->la_mtime = LTIME_S(inode->i_mtime);
attr->la_ctime = LTIME_S(inode->i_ctime);
attr->la_mode = inode->i_mode;
- attr->la_size = inode->i_size;
+ attr->la_size = i_size_read(inode);
attr->la_blocks = inode->i_blocks;
attr->la_uid = inode->i_uid;
attr->la_gid = inode->i_gid;
diff --git a/lustre/ptlrpc/llog_server.c b/lustre/ptlrpc/llog_server.c
index a45208b39183a703bb53053209814a097e0fbf69..b06c2f6d6002871c43cc6be2661f287baf0f43ad 100644
--- a/lustre/ptlrpc/llog_server.c
+++ b/lustre/ptlrpc/llog_server.c
@@ -480,7 +480,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;
@@ -541,7 +541,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 c2c204017e15a4aae4ecac570d3ceb0954eccb06..e42a1675bf7f4ec5440f4862f68dfd5aa0027983 100644
--- a/lustre/quota/quotacheck_test.c
+++ b/lustre/quota/quotacheck_test.c
@@ -86,7 +86,8 @@ static void print_inode(struct inode *inode)
size = inode_get_bytes(inode);
CERROR("%lu: uid: %u, size: %llu, blocks: %lu, real size: %llu\n",
- inode->i_ino, inode->i_uid, inode->i_size, inode->i_blocks, size);
+ inode->i_ino, inode->i_uid, i_size_read(inode),
+ inode->i_blocks, size);
}
/* Test quotaon */