/**
* Implementation of ldlm_valblock_ops::lvbo_update for OFD.
*
* When a client generates a glimpse enqueue, it wants to get the current
* file size and updated attributes for a stat() type operation, but these
* attributes may be writeback cached on another client. The client with
* the DLM extent lock at the highest offset is asked for its current
* attributes via a glimpse callback on its extent lock, on the assumption
* that it has the highest file size and the newest timestamps. The timestamps
* are guaranteed to be correct if there is only a single writer on the file,
* but may be slightly inaccurate if there are multiple concurrent writers on
* the same object. In order to avoid race conditions between the glimpse AST
* and the client cancelling the lock, ofd_lvbo_update() also updates
* the attributes from the local object. If the last client hasn't done any
* writes yet, or has already written its data and cancelled its lock before
* it processed the glimpse, then the local inode will have more uptodate
* information.
*
* This is called in two ways:
* \a req != NULL : called by the DLM itself after a glimpse callback
* \a req == NULL : called by the OFD after a disk write
*
* \param[in] res LDLM resource
* \param[in] req PTLRPC request
* \param[in] increase_only don't allow LVB values to decrease
*
* \retval 0 on successful setup
* \retval negative value on error
*/
static int ofd_lvbo_update(struct ldlm_resource *res,
struct ptlrpc_request *req, int increase_only)
{
struct ofd_device *ofd;
struct ofd_object *fo;
struct ofd_thread_info *info;
struct ost_lvb *lvb;
struct lu_env env;
int rc = 0;
ENTRY;
LASSERT(res != NULL);
ofd = ldlm_res_to_ns(res)->ns_lvbp;
LASSERT(ofd != NULL);
rc = lu_env_init(&env, LCT_DT_THREAD);
if (rc)
RETURN(rc);
info = ofd_info_init(&env, NULL);
fid_extract_from_res_name(&info->fti_fid, &res->lr_name);
lvb = res->lr_lvb_data;
if (lvb == NULL) {
CERROR("%s: no LVB data for "DFID"\n",
ofd_name(ofd), PFID(&info->fti_fid));
GOTO(out_env, rc = 0);
}
/* Update the LVB from the network message */
if (req != NULL) {
struct ost_lvb *rpc_lvb;
bool lvb_type;
if (req->rq_import != NULL)
lvb_type = imp_connect_lvb_type(req->rq_import);
else
lvb_type = exp_connect_lvb_type(req->rq_export);
if (!lvb_type) {
struct ost_lvb_v1 *lvb_v1;
lvb_v1 = req_capsule_server_swab_get(&req->rq_pill,
&RMF_DLM_LVB, lustre_swab_ost_lvb_v1);
if (lvb_v1 == NULL)
goto disk_update;
rpc_lvb = &info->fti_lvb;
memcpy(rpc_lvb, lvb_v1, sizeof *lvb_v1);
rpc_lvb->lvb_mtime_ns = 0;
rpc_lvb->lvb_atime_ns = 0;
rpc_lvb->lvb_ctime_ns = 0;
} else {
rpc_lvb = req_capsule_server_swab_get(&req->rq_pill,
&RMF_DLM_LVB,
lustre_swab_ost_lvb);
if (rpc_lvb == NULL)
goto disk_update;
}
lock_res(res);
if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_size, rpc_lvb->lvb_size);
lvb->lvb_size = rpc_lvb->lvb_size;
}
if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_mtime, rpc_lvb->lvb_mtime);
lvb->lvb_mtime = rpc_lvb->lvb_mtime;
}
if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_atime, rpc_lvb->lvb_atime);
lvb->lvb_atime = rpc_lvb->lvb_atime;
}
if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_ctime, rpc_lvb->lvb_ctime);
lvb->lvb_ctime = rpc_lvb->lvb_ctime;
}
if (rpc_lvb->lvb_blocks > lvb->lvb_blocks || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_blocks, rpc_lvb->lvb_blocks);
lvb->lvb_blocks = rpc_lvb->lvb_blocks;
}
unlock_res(res);
}
disk_update:
/* Update the LVB from the disk inode */
ost_fid_from_resid(&info->fti_fid, &res->lr_name,
ofd->ofd_lut.lut_lsd.lsd_osd_index);
fo = ofd_object_find(&env, ofd, &info->fti_fid);
if (IS_ERR(fo))
GOTO(out_env, rc = PTR_ERR(fo));
rc = ofd_attr_get(&env, fo, &info->fti_attr);
if (rc)
GOTO(out_obj, rc);
lock_res(res);
if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size from disk: "
LPU64" -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_size, info->fti_attr.la_size);
lvb->lvb_size = info->fti_attr.la_size;
}
if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime from disk: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_mtime, info->fti_attr.la_mtime);
lvb->lvb_mtime = info->fti_attr.la_mtime;
}
if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime from disk: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_atime, info->fti_attr.la_atime);
lvb->lvb_atime = info->fti_attr.la_atime;
}
if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime from disk: "
LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
lvb->lvb_ctime, info->fti_attr.la_ctime);
lvb->lvb_ctime = info->fti_attr.la_ctime;
}
if (info->fti_attr.la_blocks > lvb->lvb_blocks || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks from disk: "
LPU64" -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
(unsigned long long)info->fti_attr.la_blocks);
lvb->lvb_blocks = info->fti_attr.la_blocks;
}
unlock_res(res);
out_obj:
ofd_object_put(&env, fo);
out_env:
lu_env_fini(&env);
return rc;
}
int lustre_check_remote_perm(struct inode *inode, int mask)
{
struct ll_inode_info *lli = ll_i2info(inode);
struct ll_sb_info *sbi = ll_i2sbi(inode);
struct ptlrpc_request *req = NULL;
struct mdt_remote_perm *perm;
struct obd_capa *oc;
unsigned long save;
int i = 0, rc;
do {
save = lli->lli_rmtperm_time;
rc = do_check_remote_perm(lli, mask);
if (!rc || (rc != -ENOENT && i))
break;
might_sleep();
mutex_lock(&lli->lli_rmtperm_mutex);
/* check again */
if (save != lli->lli_rmtperm_time) {
rc = do_check_remote_perm(lli, mask);
if (!rc || (rc != -ENOENT && i)) {
mutex_unlock(&lli->lli_rmtperm_mutex);
break;
}
}
if (i++ > 5) {
CERROR("check remote perm falls in dead loop!\n");
LBUG();
}
oc = ll_mdscapa_get(inode);
rc = md_get_remote_perm(sbi->ll_md_exp, ll_inode2fid(inode), oc,
ll_i2suppgid(inode), &req);
capa_put(oc);
if (rc) {
mutex_unlock(&lli->lli_rmtperm_mutex);
break;
}
perm = req_capsule_server_swab_get(&req->rq_pill, &RMF_ACL,
lustre_swab_mdt_remote_perm);
if (unlikely(perm == NULL)) {
mutex_unlock(&lli->lli_rmtperm_mutex);
rc = -EPROTO;
break;
}
rc = ll_update_remote_perm(inode, perm);
mutex_unlock(&lli->lli_rmtperm_mutex);
if (rc == -ENOMEM)
break;
ptlrpc_req_finished(req);
req = NULL;
} while (1);
ptlrpc_req_finished(req);
return rc;
}