*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/ofd/ofd_dev.c
*
}
lu_site_purge(env, top->ld_site, ~0);
- if (!cfs_hash_is_empty(top->ld_site->ls_obj_hash)) {
- LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_OTHER, NULL);
- lu_site_print(env, top->ld_site, &msgdata, lu_cdebug_printer);
- }
-
+ lu_site_print(env, top->ld_site, &top->ld_site->ls_obj_hash.nelems,
+ D_OTHER, lu_cdebug_printer);
LASSERT(m->ofd_osd_exp);
obd_disconnect(m->ofd_osd_exp);
return (*p)(env, cookie, LUSTRE_OST_NAME"-object@%p", o);
}
-static struct lu_object_operations ofd_obj_ops = {
+static const struct lu_object_operations ofd_obj_ops = {
.loo_object_init = ofd_object_init,
.loo_object_free = ofd_object_free,
.loo_object_print = ofd_object_print
/**
* lu_device_operations matrix for OFD device.
*/
-static struct lu_device_operations ofd_lu_ops = {
+static const struct lu_device_operations ofd_lu_ops = {
.ldo_object_alloc = ofd_object_alloc,
.ldo_process_config = ofd_process_config,
.ldo_recovery_complete = ofd_recovery_complete,
void *key, *val = NULL;
int keylen, vallen, rc = 0;
bool is_grant_shrink;
+ ktime_t kstart = ktime_get();
ENTRY;
if (is_grant_shrink) {
body = req_capsule_client_get(tsi->tsi_pill, &RMF_OST_BODY);
+ /*
+ * Because we already sync grant info with client when
+ * reconnect, grant info will be cleared for resent
+ * req, otherwise, outdated grant count in the rpc
+ * would de-sync grant counters
+ */
+ if (lustre_msg_get_flags(req->rq_reqmsg) &
+ (MSG_RESENT | MSG_REPLAY)) {
+ DEBUG_REQ(D_CACHE, req,
+ "clear resent/replay req grant info");
+ body->oa.o_valid &= ~OBD_MD_FLGRANT;
+ }
+
repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY);
*repbody = *body;
rc = -EOPNOTSUPP;
}
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SET_INFO,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
RETURN(rc);
}
return rc;
CDEBUG(D_OTHER, "ost lock [%llu,%llu], lh=%p\n", begin, end, &lh);
- tgt_extent_unlock(&lh, LCK_PR);
+ tgt_data_unlock(&lh, LCK_PR);
return 0;
}
void *key;
int keylen;
int replylen, rc = 0;
+ ktime_t kstart = ktime_get();
ENTRY;
if (rc)
RETURN(err_serious(rc));
+ if (OBD_FAIL_CHECK(OBD_FAIL_OST_GET_LAST_FID))
+ RETURN(-EAGAIN);
+
fid = req_capsule_client_get(tsi->tsi_pill, &RMF_FID);
if (fid == NULL)
RETURN(err_serious(-EPROTO));
oseq = ofd_seq_load(tsi->tsi_env, ofd,
ostid_seq(&fti->fti_ostid));
if (IS_ERR(oseq))
- RETURN(PTR_ERR(oseq));
+ RETURN(-EFAULT);
rc = ostid_to_fid(fid, &oseq->os_oi,
ofd->ofd_lut.lut_lsd.lsd_osd_index);
if (rc != 0)
- GOTO(out_put, rc);
+ GOTO(out_put, rc = -EFAULT);
CDEBUG(D_HA, "%s: LAST FID is "DFID"\n", ofd_name(ofd),
PFID(fid));
rc = -EOPNOTSUPP;
}
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_GET_INFO,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
RETURN(rc);
}
struct ofd_object *fo;
__u64 flags = 0;
enum ldlm_mode lock_mode = LCK_PR;
+ ktime_t kstart = ktime_get();
bool srvlock;
int rc;
ENTRY;
ofd_object_put(tsi->tsi_env, fo);
out:
if (srvlock)
- tgt_extent_unlock(&lh, lock_mode);
+ tgt_data_unlock(&lh, lock_mode);
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_GETATTR,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
repbody->oa.o_valid |= OBD_MD_FLFLAGS;
repbody->oa.o_flags = OBD_FL_FLUSH;
struct ost_body *repbody;
struct ldlm_resource *res;
struct ofd_object *fo;
+ ktime_t kstart = ktime_get();
int rc = 0;
ENTRY;
OFD_VALID_FLAGS | LA_UID | LA_GID | LA_PROJID);
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SETATTR,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
EXIT;
out_put:
ofd_object_put(tsi->tsi_env, fo);
u64 seq = ostid_seq(&oa->o_oi);
u64 oid = ostid_id(&oa->o_oi);
struct ofd_seq *oseq;
- s64 diff;
- int rc = 0;
int sync_trans = 0;
long granted = 0;
+ ktime_t kstart = ktime_get();
+ s64 diff;
+ int rc = 0;
ENTRY;
GOTO(out, rc = -EINVAL);
}
- if (diff < 0) {
+ if (diff <= -OST_MAX_PRECREATE) {
/* LU-5648 */
CERROR("%s: invalid precreate request for "
DOSTID", last_id %llu. "
ofd_name(ofd), POSTID(&oa->o_oi),
ofd_seq_last_oid(oseq));
GOTO(out, rc = -EINVAL);
+ } else if (diff < 0) {
+ LCONSOLE(D_INFO,
+ "%s: MDS LAST_ID "DFID" (%llu) is %lld behind OST LAST_ID "DFID" (%llu), trust the OST\n",
+ ofd_name(ofd), PFID(&oa->o_oi.oi_fid),
+ oid, -diff, PFID(&oseq->os_oi.oi_fid),
+ ofd_seq_last_oid(oseq));
+ /* Let MDS know that we are so far ahead. */
+ rc = ostid_set_id(&rep_oa->o_oi,
+ ofd_seq_last_oid(oseq) + 1);
}
}
}
* (possibly filling the OST), only precreate the last batch.
* LFSCK will eventually clean up any orphans. LU-14 */
if (diff > 5 * OST_MAX_PRECREATE) {
+ /* Message below is checked in conf-sanity test_122b */
+ LCONSOLE_WARN("%s: precreate FID "DOSTID" is over %lld higher than LAST_ID "DOSTID", only precreating the last %u objects. OST replaced or reformatted?\n",
+ ofd_name(ofd), POSTID(&oa->o_oi), diff,
+ POSTID(&oseq->os_oi),
+ OST_MAX_PRECREATE / 2);
diff = OST_MAX_PRECREATE / 2;
- LCONSOLE_WARN("%s: Too many FIDs to precreate "
- "OST replaced or reformatted: "
- "LFSCK will clean up",
- ofd_name(ofd));
-
- CDEBUG(D_HA, "%s: precreate FID "DOSTID" is over "
- "%u larger than the LAST_ID "DOSTID", only "
- "precreating the last %lld objects.\n",
- ofd_name(ofd), POSTID(&oa->o_oi),
- 5 * OST_MAX_PRECREATE,
- POSTID(&oseq->os_oi), diff);
ofd_seq_last_oid_set(oseq, ostid_id(&oa->o_oi) - diff);
}
}
EXIT;
ofd_counter_incr(exp, LPROC_OFD_STATS_CREATE,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
if (unlikely(!oseq->os_last_id_synced))
oseq->os_last_id_synced = 1;
out:
struct ofd_device *ofd = ofd_exp(tsi->tsi_exp);
struct ofd_thread_info *fti = tsi2ofd_info(tsi);
struct lu_fid *fid = &fti->fti_fid;
+ ktime_t kstart = ktime_get();
u64 oid;
u32 count;
int rc = 0;
}
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_DESTROY,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
GOTO(out, rc);
*/
static int ofd_statfs_hdl(struct tgt_session_info *tsi)
{
+ ktime_t kstart = ktime_get();
struct obd_statfs *osfs;
int rc;
rc = -EINPROGRESS;
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_STATFS,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
RETURN(rc);
}
struct ofd_thread_info *fti = tsi2ofd_info(tsi);
struct ofd_device *ofd = ofd_exp(tsi->tsi_exp);
struct ofd_object *fo = NULL;
+ ktime_t kstart = ktime_get();
int rc = 0;
ENTRY;
GOTO(put, rc);
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_SYNC,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
if (fo == NULL)
RETURN(0);
struct ldlm_resource *res;
struct ofd_object *fo;
__u64 flags = 0;
+ __u64 valid;
struct lustre_handle lh = { 0, };
int rc, mode;
__u64 start, end;
bool srvlock;
+ ktime_t kstart = ktime_get();
repbody = req_capsule_server_get(tsi->tsi_pill, &RMF_OST_BODY);
if (repbody == NULL)
RETURN(err_serious(-ENOMEM));
/*
- * fallocate start and end are passed in o_size, o_blocks
- * on the wire.
+ * fallocate() start and end are passed in o_size and o_blocks
+ * on the wire. Clients 2.15.0 and newer should always set
+ * the OBD_MD_FLSIZE and OBD_MD_FLBLOCKS valid flags, but some
+ * older client versions did not. We permit older clients to
+ * not set these flags, checking their version by proxy using
+ * the lack of OBD_CONNECT_TRUNCLOCK to imply 2.14.0 and older.
+ *
+ * Return -EOPNOTSUPP to also work with older clients not
+ * supporting newer server modes.
*/
+ if ((oa->o_valid & (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) !=
+ (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 21, 53, 0)
+ && (tgt_conn_flags(tsi) & OBD_CONNECT_OLD_FALLOC)
+#endif
+ )
+ RETURN(-EOPNOTSUPP);
+
start = oa->o_size;
end = oa->o_blocks;
+ /* client should already limit len >= 0 */
+ if (start >= end)
+ RETURN(-EINVAL);
+
mode = oa->o_falloc_mode;
/*
- * Only mode == 0 (which is standard prealloc) is supported now.
- * Punch is not supported yet.
+ * mode == 0 (which is standard prealloc) and PUNCH is supported
+ * Rest of mode options are not supported yet.
*/
- if (mode & ~FALLOC_FL_KEEP_SIZE)
+ if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
RETURN(-EOPNOTSUPP);
+ /* PUNCH_HOLE mode should always be accompanied with KEEP_SIZE flag
+ * Check that and add the missing flag for such invalid call with
+ * warning.
+ */
+ if (mode & FALLOC_FL_PUNCH_HOLE && !(mode & FALLOC_FL_KEEP_SIZE)) {
+ CWARN("%s: PUNCH mode misses KEEP_SIZE flag, setting it\n",
+ tsi->tsi_tgt->lut_obd->obd_name);
+ mode |= FALLOC_FL_KEEP_SIZE;
+ }
+
repbody->oa.o_oi = oa->o_oi;
repbody->oa.o_valid = OBD_MD_FLID;
if (IS_ERR(fo))
GOTO(out, rc = PTR_ERR(fo));
- la_from_obdo(&info->fti_attr, oa,
- OBD_MD_FLMTIME | OBD_MD_FLATIME | OBD_MD_FLCTIME);
+ valid = OBD_MD_FLUID | OBD_MD_FLGID | OBD_MD_FLPROJID |
+ OBD_MD_FLATIME | OBD_MD_FLMTIME | OBD_MD_FLCTIME;
+ la_from_obdo(&info->fti_attr, oa, valid);
rc = ofd_object_fallocate(tsi->tsi_env, fo, start, end, mode,
&info->fti_attr, oa);
rc = ofd_attr_get(tsi->tsi_env, fo, &info->fti_attr);
if (rc == 0)
- obdo_from_la(&repbody->oa, &info->fti_attr,
- OFD_VALID_FLAGS);
+ obdo_from_la(&repbody->oa, &info->fti_attr, OFD_VALID_FLAGS);
else
rc = 0;
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_PREALLOC,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
EXIT;
out_put:
ofd_object_put(tsi->tsi_env, fo);
out:
if (srvlock)
- tgt_extent_unlock(&lh, LCK_PW);
+ tgt_data_unlock(&lh, LCK_PW);
if (rc == 0) {
res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid,
LDLM_EXTENT, 0);
RETURN(rc);
}
-
/**
* OFD request handler for OST_PUNCH RPC.
*
struct ofd_object *fo;
__u64 flags = 0;
struct lustre_handle lh = { 0, };
- int rc;
__u64 start, end;
bool srvlock;
+ ktime_t kstart = ktime_get();
+ int rc;
ENTRY;
OBD_FAIL_TIMEOUT(OBD_FAIL_OST_PAUSE_PUNCH, cfs_fail_val);
- /* check that we do support OBD_CONNECT_TRUNCLOCK. */
- BUILD_BUG_ON(!(OST_CONNECT_SUPPORTED & OBD_CONNECT_TRUNCLOCK));
-
if ((oa->o_valid & (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS)) !=
(OBD_MD_FLSIZE | OBD_MD_FLBLOCKS))
RETURN(err_serious(-EPROTO));
GOTO(out_put, rc);
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_PUNCH,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
EXIT;
out_put:
ofd_object_put(tsi->tsi_env, fo);
out:
if (srvlock)
- tgt_extent_unlock(&lh, LCK_PW);
+ tgt_data_unlock(&lh, LCK_PW);
if (rc == 0) {
/* we do not call this before to avoid lu_object_find() in
* ->lvbo_update() holding another reference on the object.
req->rq_status = ofd_ladvise_prefetch(env, fo,
tbc->local,
start, end, dbt);
- tgt_extent_unlock(&lockh, LCK_PR);
+ tgt_data_unlock(&lockh, LCK_PR);
break;
case LU_LADVISE_DONTNEED:
rc = dt_ladvise(env, dob, ladvise->lla_start,
{
struct obd_quotactl *oqctl, *repoqc;
struct lu_nodemap *nodemap;
+ ktime_t kstart = ktime_get();
int id;
int rc;
id = nodemap_map_id(nodemap, NODEMAP_GID,
NODEMAP_CLIENT_TO_FS,
repoqc->qc_id);
+ else if (oqctl->qc_type == PRJQUOTA)
+ id = nodemap_map_id(nodemap, NODEMAP_PROJID,
+ NODEMAP_CLIENT_TO_FS,
+ repoqc->qc_id);
nodemap_putref(nodemap);
rc = lquotactl_slv(tsi->tsi_env, tsi->tsi_tgt->lut_bottom, repoqc);
ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_QUOTACTL,
- tsi->tsi_jobid, 1);
+ tsi->tsi_jobid, ktime_us_delta(ktime_get(), kstart));
if (repoqc->qc_id != id)
swap(repoqc->qc_id, id);
TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SYNC, ofd_sync_hdl),
TGT_OST_HDL(HAS_REPLY, OST_QUOTACTL, ofd_quotactl),
TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_LADVISE, ofd_ladvise_hdl),
-TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_FALLOCATE, ofd_fallocate_hdl)
+TGT_OST_HDL(HAS_BODY | HAS_REPLY | IS_MUTABLE, OST_FALLOCATE, ofd_fallocate_hdl),
+TGT_OST_HDL(HAS_BODY | HAS_REPLY, OST_SEEK, tgt_lseek),
};
static struct tgt_opc_slice ofd_common_slice[] = {
spin_lock_init(&m->ofd_flags_lock);
m->ofd_raid_degraded = 0;
- m->ofd_checksum_t10pi_enforce = 0;
m->ofd_sync_journal = 0;
ofd_slc_set(m);
m->ofd_soft_sync_limit = OFD_SOFT_SYNC_LIMIT_DEFAULT;
m->ofd_seq_count = 0;
- init_waitqueue_head(&m->ofd_inconsistency_thread.t_ctl_waitq);
INIT_LIST_HEAD(&m->ofd_inconsistency_list);
spin_lock_init(&m->ofd_inconsistency_lock);
LDLM_NAMESPACE_SERVER,
LDLM_NAMESPACE_GREEDY,
LDLM_NS_TYPE_OST);
- if (m->ofd_namespace == NULL)
- GOTO(err_fini_stack, rc = -ENOMEM);
+ if (IS_ERR(m->ofd_namespace)) {
+ rc = PTR_ERR(m->ofd_namespace);
+ CERROR("%s: unable to create server namespace: rc = %d\n",
+ obd->obd_name, rc);
+ m->ofd_namespace = NULL;
+ GOTO(err_fini_stack, rc);
+ }
/* set obd_namespace for compatibility with old code */
obd->obd_namespace = m->ofd_namespace;
ldlm_register_intent(m->ofd_namespace, ofd_intent_policy);
tgd->tgd_reserved_pcnt = 0;
m->ofd_brw_size = m->ofd_lut.lut_dt_conf.ddp_brw_size;
- m->ofd_cksum_types_supported =
- obd_cksum_types_supported_server(obd->obd_name);
m->ofd_precreate_batch = OFD_PRECREATE_BATCH_DEFAULT;
if (tgd->tgd_osfs.os_bsize * tgd->tgd_osfs.os_blocks <
OFD_PRECREATE_SMALL_FS)
/* type constructor/destructor: ofd_type_init(), ofd_type_fini() */
LU_TYPE_INIT_FINI(ofd, &ofd_thread_key);
-static struct lu_device_type_operations ofd_device_type_ops = {
+static const struct lu_device_type_operations ofd_device_type_ops = {
.ldto_init = ofd_type_init,
.ldto_fini = ofd_type_fini,
if (rc)
goto out_caches;
- rc = class_register_type(&ofd_obd_ops, NULL, true, NULL,
+ rc = class_register_type(&ofd_obd_ops, NULL, true,
LUSTRE_OST_NAME, &ofd_device_type);
if (rc)
goto out_ofd_access_log;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff