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>
/* 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);
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);
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)
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)
/*
* 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);
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;
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);
}
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. */
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;
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);
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;
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);
}
* 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) {
* 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);
* 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))
* 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;
}
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;
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);
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));
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;
}
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;
#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);
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;
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) {
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:
/* 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);
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;
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));
"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)
* 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);
}
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
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;
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;
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) {
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) {
}
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;
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;
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);
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. */
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);
{
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;
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;
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,
/* 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;
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;
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();
}
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
const char *name)
{
if (lmm == NULL)
- return inode->i_size;
+ return i_size_read(inode);
CERROR("not implemented yet\n");
return -ENOSYS;
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);
}
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
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
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;
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;
/* 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);
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);
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) */
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
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;
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 */
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:
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);
}
}
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);
}
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();
}
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;
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;
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) {
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",
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;
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);
*/
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;
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);
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() */
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);
/* 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);
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);
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){
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)
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;
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;
"\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;
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 */
git://git.whamcloud.com / fs / lustre-release.git / commitdiff