#include <file.h>
#endif
-#undef LIST_HEAD
-
#include "llite_lib.h"
#ifndef MAY_EXEC
if (current->fsuid == st->st_uid)
mode >>= 6;
- else if (in_group_p(st->st_gid))
+ else if (cfs_curproc_is_in_groups(st->st_gid))
mode >>= 3;
if ((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask)
int next = 0;
ENTRY;
- list_del(&sbi->ll_conn_chain);
+ cfs_list_del(&sbi->ll_conn_chain);
cl_sb_fini(sbi);
obd_disconnect(sbi->ll_dt_exp);
obd_disconnect(sbi->ll_md_exp);
}
}
- if (body->valid & OBD_MD_FLMTIME &&
- body->mtime > LTIME_S(st->st_mtime))
- LTIME_S(st->st_mtime) = body->mtime;
- if (body->valid & OBD_MD_FLATIME &&
- body->atime > LTIME_S(st->st_atime))
- LTIME_S(st->st_atime) = body->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, so take mtime from mds
- for the same ctimes. */
- if (body->valid & OBD_MD_FLCTIME &&
- body->ctime >= LTIME_S(st->st_ctime)) {
- LTIME_S(st->st_ctime) = body->ctime;
- if (body->valid & OBD_MD_FLMTIME)
+ if (body->valid & OBD_MD_FLATIME) {
+ if (body->atime > LTIME_S(st->st_atime))
+ LTIME_S(st->st_atime) = body->atime;
+ lli->lli_lvb.lvb_atime = body->atime;
+ }
+ if (body->valid & OBD_MD_FLMTIME) {
+ if (body->mtime > LTIME_S(st->st_mtime))
LTIME_S(st->st_mtime) = body->mtime;
+ lli->lli_lvb.lvb_mtime = body->mtime;
+ }
+ if (body->valid & OBD_MD_FLCTIME) {
+ if (body->ctime > LTIME_S(st->st_ctime))
+ LTIME_S(st->st_ctime) = body->ctime;
+ lli->lli_lvb.lvb_ctime = body->ctime;
}
- if (S_ISREG(st->st_mode))
+ if (S_ISREG(st->st_mode))
st->st_blksize = min(2UL * PTLRPC_MAX_BRW_SIZE, LL_MAX_BLKSIZE);
else
st->st_blksize = 4096;
dst->o_valid |= newvalid;
}
-/*
- * really does the getattr on the inode and updates its fields
+/**
+ * Performs the getattr on the inode and updates its fields.
+ * If @sync != 0, perform the getattr under the server-side lock.
*/
-int llu_inode_getattr(struct inode *inode, struct obdo *obdo)
+int llu_inode_getattr(struct inode *inode, struct obdo *obdo,
+ __u64 ioepoch, int sync)
{
struct llu_inode_info *lli = llu_i2info(inode);
struct ptlrpc_request_set *set;
oinfo.oi_oa->o_id = lsm->lsm_object_id;
oinfo.oi_oa->o_gr = lsm->lsm_object_gr;
oinfo.oi_oa->o_mode = S_IFREG;
+ oinfo.oi_oa->o_ioepoch = ioepoch;
oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
OBD_MD_FLBLKSZ | OBD_MD_FLMTIME |
- OBD_MD_FLCTIME | OBD_MD_FLGROUP;
+ OBD_MD_FLCTIME | OBD_MD_FLGROUP |
+ OBD_MD_FLATIME | OBD_MD_FLEPOCH;
+ if (sync) {
+ oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
+ oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK;
+ }
set = ptlrpc_prep_set();
if (set == NULL) {
static int llu_inode_revalidate(struct inode *inode)
{
- struct lov_stripe_md *lsm = NULL;
+ struct llu_inode_info *lli = llu_i2info(inode);
+ struct intnl_stat *st = llu_i2stat(inode);
ENTRY;
if (!inode) {
struct lustre_md md;
struct ptlrpc_request *req = NULL;
struct llu_sb_info *sbi = llu_i2sbi(inode);
+ struct md_op_data op_data = { { 0 } };
unsigned long valid = OBD_MD_FLGETATTR;
int rc, ealen = 0;
/* Why don't we update all valid MDS fields here, if we're
* doing an RPC anyways? -phil */
- if (S_ISREG(llu_i2stat(inode)->st_mode)) {
+ if (S_ISREG(st->st_mode)) {
ealen = obd_size_diskmd(sbi->ll_dt_exp, NULL);
valid |= OBD_MD_FLEASIZE;
}
- rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
- NULL, valid, ealen, &req);
+
+ llu_prep_md_op_data(&op_data, inode, NULL, NULL, 0, ealen,
+ LUSTRE_OPC_ANY);
+ op_data.op_valid = valid;
+
+ rc = md_getattr(sbi->ll_md_exp, &op_data, &req);
if (rc) {
CERROR("failure %d inode %llu\n", rc,
- (long long)llu_i2stat(inode)->st_ino);
+ (long long)st->st_ino);
RETURN(-abs(rc));
}
rc = md_get_lustre_md(sbi->ll_md_exp, req,
llu_update_inode(inode, &md);
- if (md.lsm != NULL && llu_i2info(inode)->lli_smd != md.lsm)
+ if (md.lsm != NULL && lli->lli_smd != md.lsm)
obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
ptlrpc_req_finished(req);
}
- lsm = llu_i2info(inode)->lli_smd;
- if (!lsm) /* object not yet allocated, don't validate size */
+ if (!lli->lli_smd) {
+ /* object not yet allocated, don't validate size */
+ st->st_atime = lli->lli_lvb.lvb_atime;
+ st->st_mtime = lli->lli_lvb.lvb_mtime;
+ st->st_ctime = lli->lli_lvb.lvb_ctime;
RETURN(0);
+ }
/* ll_glimpse_size will prefer locally cached writes if they extend
* the file */
st->st_ctime = attr->ia_ctime;
if (ia_valid & ATTR_MODE) {
st->st_mode = attr->ia_mode;
- if (!in_group_p(st->st_gid) && !cfs_capable(CFS_CAP_FSETID))
+ if (!cfs_curproc_is_in_groups(st->st_gid) &&
+ !cfs_capable(CFS_CAP_FSETID))
st->st_mode &= ~S_ISGID;
}
/* mark_inode_dirty(inode); */
CDEBUG(D_INODE, "Epoch "LPU64" closed on "DFID" for truncate\n",
op_data->op_ioepoch, PFID(&lli->lli_fid));
- op_data->op_flags = MF_EPOCH_CLOSE | MF_SOM_CHANGE;
+ op_data->op_flags = MF_EPOCH_CLOSE;
+ llu_done_writing_attr(inode, op_data);
+ llu_pack_inode2opdata(inode, op_data, NULL);
+
rc = md_done_writing(llu_i2sbi(inode)->ll_md_exp, op_data, mod);
if (rc == -EAGAIN) {
/* MDS has instructed us to obtain Size-on-MDS attribute
* from OSTs and send setattr to back to MDS. */
- rc = llu_sizeonmds_update(inode, &op_data->op_handle,
- op_data->op_ioepoch);
+ rc = llu_som_update(inode, op_data);
} else if (rc) {
CERROR("inode %llu mdc truncate failed: rc = %d\n",
(unsigned long long)st->st_ino, rc);
/* We mark all of the fields "set" so MDS/OST does not re-set them */
if (attr->ia_valid & ATTR_CTIME) {
- attr->ia_ctime = CURRENT_TIME;
+ attr->ia_ctime = CFS_CURRENT_TIME;
attr->ia_valid |= ATTR_CTIME_SET;
}
if (!(ia_valid & ATTR_ATIME_SET) && (attr->ia_valid & ATTR_ATIME)) {
- attr->ia_atime = CURRENT_TIME;
+ attr->ia_atime = CFS_CURRENT_TIME;
attr->ia_valid |= ATTR_ATIME_SET;
}
if (!(ia_valid & ATTR_MTIME_SET) && (attr->ia_valid & ATTR_MTIME)) {
- attr->ia_mtime = CURRENT_TIME;
+ attr->ia_mtime = CFS_CURRENT_TIME;
attr->ia_valid |= ATTR_MTIME_SET;
}
- if ((attr->ia_valid & ATTR_CTIME) && !(attr->ia_valid & ATTR_MTIME)) {
- /* To avoid stale mtime on mds, obtain it from ost and send
- to mds. */
- rc = cl_glimpse_size(inode);
- if (rc)
- RETURN(rc);
-
- attr->ia_valid |= ATTR_MTIME_SET | ATTR_MTIME;
- attr->ia_mtime = inode->i_stbuf.st_mtime;
- }
if (attr->ia_valid & (ATTR_MTIME | ATTR_CTIME))
CDEBUG(D_INODE, "setting mtime "CFS_TIME_T", ctime "CFS_TIME_T
", now = "CFS_TIME_T"\n",
LTIME_S(attr->ia_mtime), LTIME_S(attr->ia_ctime),
- LTIME_S(CURRENT_TIME));
+ LTIME_S(CFS_CURRENT_TIME));
/* NB: ATTR_SIZE will only be set after this point if the size
* resides on the MDS, ie, this file has no objects. */
memcpy(&op_data.op_attr, attr, sizeof(*attr));
/* Open epoch for truncate. */
- if ((llu_i2mdexp(inode)->exp_connect_flags & OBD_CONNECT_SOM) &&
+ if (exp_connect_som(llu_i2mdexp(inode)) &&
(ia_valid & ATTR_SIZE))
op_data.op_flags = MF_EPOCH_OPEN;
rc = llu_md_setattr(inode, &op_data, &mod);
inode_setattr(inode, attr);
}
- if (ia_valid & ATTR_SIZE) {
- rc = cl_setattr_do_truncate(inode, attr->ia_size, NULL);
- } else if (ia_valid & (ATTR_MTIME | ATTR_MTIME_SET)) {
- CDEBUG(D_INODE, "set mtime on OST inode %llu to %lu\n",
- (long long unsigned)st->st_ino, LTIME_S(attr->ia_mtime));
- rc = cl_setattr_ost(inode, NULL);
- }
+ if (ia_valid & ATTR_SIZE)
+ attr->ia_valid |= ATTR_SIZE;
+ if ((ia_valid & ATTR_SIZE) |
+ ((ia_valid | ATTR_ATIME | ATTR_ATIME_SET) &&
+ LTIME_S(attr->ia_atime) < LTIME_S(attr->ia_ctime)) ||
+ ((ia_valid | ATTR_MTIME | ATTR_MTIME_SET) &&
+ LTIME_S(attr->ia_mtime) < LTIME_S(attr->ia_ctime)))
+ /* perform truncate and setting mtime/atime to past under PW
+ * 0:EOF extent lock (new_size:EOF for truncate) */
+ rc = cl_setattr_ost(inode, attr, NULL);
EXIT;
out:
if (op_data.op_ioepoch)
}
iattr.ia_valid |= ATTR_RAW | ATTR_CTIME;
- iattr.ia_ctime = CURRENT_TIME;
+ iattr.ia_ctime = CFS_CURRENT_TIME;
rc = llu_setattr_raw(ino, &iattr);
liblustre_wait_idle();
struct llu_sb_info *sbi = llu_i2sbi(inode);
struct mdt_body *body;
struct intnl_stat *st = llu_i2stat(inode);
+ struct md_op_data op_data = {{ 0 }};
int rc, symlen = st->st_size + 1;
ENTRY;
RETURN(0);
}
- rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode), NULL,
- OBD_MD_LINKNAME, symlen, request);
+ llu_prep_md_op_data(&op_data, inode, NULL, NULL, 0, symlen,
+ LUSTRE_OPC_ANY);
+ op_data.op_valid = OBD_MD_LINKNAME;
+
+ rc = md_getattr(sbi->ll_md_exp, &op_data, request);
if (rc) {
CERROR("inode %llu: rc = %d\n", (long long)st->st_ino, rc);
RETURN(rc);
/* For now we will always get up-to-date statfs values, but in the
* future we may allow some amount of caching on the client (e.g.
* from QOS or lprocfs updates). */
- rc = llu_statfs_internal(sbi, &osfs, cfs_time_current_64() - HZ);
+ rc = llu_statfs_internal(sbi, &osfs, cfs_time_current_64() - CFS_HZ);
if (rc)
return rc;
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) ==
sizeof(lump->lmm_objects[0]));
- if (copy_from_user(&lum, lump, sizeof(lum)))
+ if (cfs_copy_from_user(&lum, lump, sizeof(lum)))
return(-EFAULT);
switch (lum.lmm_magic) {
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lump->lmm_objects[0]));
- if (copy_from_user(&lum, lump, sizeof(lum)))
+ if (cfs_copy_from_user(&lum, lump, sizeof(lum)))
RETURN(-EFAULT);
rc = llu_lov_setstripe_ea_info(ino, flags, &lum, sizeof(lum));
char *osc = NULL, *mdc = NULL;
int async = 1, err = -EINVAL;
struct obd_connect_data ocd = {0,};
+ struct md_op_data op_data = {{0}};
ENTRY;
}
CDEBUG(D_SUPER, "rootfid "DFID"\n", PFID(&sbi->ll_root_fid));
+ op_data.op_fid1 = sbi->ll_root_fid;
+ op_data.op_valid = OBD_MD_FLGETATTR | OBD_MD_FLBLOCKS;
/* fetch attr of root inode */
- err = md_getattr(sbi->ll_md_exp, &sbi->ll_root_fid, NULL,
- OBD_MD_FLGETATTR | OBD_MD_FLBLOCKS, 0, &request);
+ err = md_getattr(sbi->ll_md_exp, &op_data, &request);
if (err) {
CERROR("md_getattr failed for root: rc = %d\n", err);
GOTO(out_lock_cn_cb, err);