#include <lustre_quota.h>
#include <lustre_nodemap.h>
#include <lustre_log.h>
+#include <linux/falloc.h>
#include "ofd_internal.h"
}
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);
GOTO(out_server, rc = -ENOMEM);
snprintf(name, len, "%s-super", obd_name);
- rc = seq_client_init(ss->ss_client_seq, NULL, LUSTRE_SEQ_DATA,
- name, NULL);
- if (rc) {
- CERROR("%s: seq client init error: rc = %d\n", obd_name, rc);
- GOTO(out_client, rc);
- }
+ seq_client_init(ss->ss_client_seq, NULL, LUSTRE_SEQ_DATA,
+ name, NULL);
rc = seq_server_set_cli(env, ss->ss_server_seq, ss->ss_client_seq);
if (rc) {
-out_client:
seq_client_fini(ss->ss_client_seq);
OBD_FREE_PTR(ss->ss_client_seq);
ss->ss_client_seq = NULL;
void *key, *val = NULL;
int keylen, vallen, rc = 0;
bool is_grant_shrink;
+ ktime_t kstart = ktime_get();
ENTRY;
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);
}
void *key;
int keylen;
int replylen, rc = 0;
+ ktime_t kstart = ktime_get();
ENTRY;
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;
tgt_extent_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;
}
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);
}
/**
+ * OFD request handler for OST_FALLOCATE RPC.
+ *
+ * This is part of request processing. Validate request fields,
+ * preallocate the given OFD object and pack reply.
+ *
+ * \param[in] tsi target session environment for this request
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
+ */
+static int ofd_fallocate_hdl(struct tgt_session_info *tsi)
+{
+ struct obdo *oa = &tsi->tsi_ost_body->oa;
+ struct ost_body *repbody;
+ struct ofd_thread_info *info = tsi2ofd_info(tsi);
+ struct ldlm_namespace *ns = tsi->tsi_tgt->lut_obd->obd_namespace;
+ struct ldlm_resource *res;
+ struct ofd_object *fo;
+ __u64 flags = 0;
+ 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.
+ */
+ start = oa->o_size;
+ end = oa->o_blocks;
+ mode = oa->o_falloc_mode;
+ /*
+ * Only mode == 0 (which is standard prealloc) is supported now.
+ * Punch is not supported yet.
+ */
+ if (mode & ~FALLOC_FL_KEEP_SIZE)
+ RETURN(-EOPNOTSUPP);
+
+ repbody->oa.o_oi = oa->o_oi;
+ repbody->oa.o_valid = OBD_MD_FLID;
+
+ srvlock = oa->o_valid & OBD_MD_FLFLAGS &&
+ oa->o_flags & OBD_FL_SRVLOCK;
+
+ if (srvlock) {
+ rc = tgt_extent_lock(tsi->tsi_env, ns, &tsi->tsi_resid,
+ start, end, &lh, LCK_PW, &flags);
+ if (rc != 0)
+ RETURN(rc);
+ }
+
+ fo = ofd_object_find_exists(tsi->tsi_env, ofd_exp(tsi->tsi_exp),
+ &tsi->tsi_fid);
+ 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);
+
+ rc = ofd_object_fallocate(tsi->tsi_env, fo, start, end, mode,
+ &info->fti_attr, oa);
+ if (rc)
+ GOTO(out_put, rc);
+
+ 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);
+ else
+ rc = 0;
+
+ ofd_counter_incr(tsi->tsi_exp, LPROC_OFD_STATS_PREALLOC,
+ 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);
+ if (rc == 0) {
+ res = ldlm_resource_get(ns, NULL, &tsi->tsi_resid,
+ LDLM_EXTENT, 0);
+ if (!IS_ERR(res)) {
+ struct ost_lvb *res_lvb;
+
+ ldlm_res_lvbo_update(res, NULL, 0);
+ res_lvb = res->lr_lvb_data;
+ /* Blocks */
+ repbody->oa.o_valid |= OBD_MD_FLBLOCKS;
+ repbody->oa.o_blocks = res_lvb->lvb_blocks;
+ /* Size */
+ repbody->oa.o_valid |= OBD_MD_FLSIZE;
+ repbody->oa.o_size = res_lvb->lvb_size;
+
+ ldlm_resource_putref(res);
+ }
+ }
+
+ RETURN(rc);
+}
+
+
+/**
* OFD request handler for OST_PUNCH RPC.
*
* This is part of request processing. Validate request fields,
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;
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);
{
struct obd_quotactl *oqctl, *repoqc;
struct lu_nodemap *nodemap;
+ ktime_t kstart = ktime_get();
int id;
int rc;
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);
}
/**
- * Calculate the amount of time for lock prolongation.
- *
- * This is helper for ofd_prolong_extent_locks() function to get
- * the timeout extra time.
- *
- * \param[in] req current request
- *
- * \retval amount of time to extend the timeout with
- */
-static inline time64_t prolong_timeout(struct ptlrpc_request *req)
-{
- struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
- time64_t req_timeout;
-
- if (AT_OFF)
- return obd_timeout / 2;
-
- req_timeout = req->rq_deadline - req->rq_arrival_time.tv_sec;
- return max_t(time64_t, at_est2timeout(at_get(&svcpt->scp_at_estimate)),
- req_timeout);
-}
-
-/**
* Prolong lock timeout for the given extent.
*
* This function finds all locks related with incoming request and
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)
};
static struct tgt_opc_slice ofd_common_slice[] = {
INIT_LIST_HEAD(&m->ofd_inconsistency_list);
spin_lock_init(&m->ofd_inconsistency_lock);
+ m->ofd_access_log_mask = -1; /* Log all accesses if enabled. */
+
spin_lock_init(&m->ofd_batch_lock);
init_rwsem(&m->ofd_lastid_rwsem);
if (tgd->tgd_osfs.os_bsize * tgd->tgd_osfs.os_blocks <
OFD_PRECREATE_SMALL_FS)
m->ofd_precreate_batch = OFD_PRECREATE_BATCH_SMALL;
+ m->ofd_atime_diff = OFD_DEF_ATIME_DIFF;
rc = ofd_fs_setup(env, m, obd);
if (rc)
d->ld_obd->obd_namespace = m->ofd_namespace = NULL;
}
+ ofd_access_log_delete(m->ofd_access_log);
+ m->ofd_access_log = NULL;
+
ofd_stack_fini(env, m, &m->ofd_dt_dev.dd_lu_dev);
LASSERT(atomic_read(&d->ld_ref) == 0);
*/
static int __init ofd_init(void)
{
- int rc;
+ int rc;
rc = lu_kmem_init(ofd_caches);
if (rc)
return rc;
+
+ rc = ofd_access_log_module_init();
+ if (rc)
+ goto out_caches;
+
rc = class_register_type(&ofd_obd_ops, NULL, true, NULL,
LUSTRE_OST_NAME, &ofd_device_type);
+ if (rc)
+ goto out_ofd_access_log;
+
+ return 0;
+
+out_ofd_access_log:
+ ofd_access_log_module_exit();
+out_caches:
+ lu_kmem_fini(ofd_caches);
+
return rc;
}
*/
static void __exit ofd_exit(void)
{
- lu_kmem_fini(ofd_caches);
class_unregister_type(LUSTRE_OST_NAME);
+ ofd_access_log_module_exit();
+ lu_kmem_fini(ofd_caches);
}
MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");