#include <lustre/lustre_idl.h>
#include <lustre_dlm.h>
#include <lustre_quota.h>
+#include <lustre_nodemap.h>
#include "ofd_internal.h"
strcat(flags, "A");
lustre_cfg_bufs_set_string(&bufs, 1, flags);
lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
- if (!lcfg) {
- CERROR("Cannot alloc lcfg!\n");
+ if (lcfg == NULL)
RETURN_EXIT;
- }
LASSERT(top);
top->ld_ops->ldo_process_config(env, top, lcfg);
return (*p)(env, cookie, LUSTRE_OST_NAME"-object@%p", o);
}
-struct lu_object_operations ofd_obj_ops = {
+static 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
obd->obd_uses_nid_stats = 1;
- entry = lprocfs_seq_register("exports", obd->obd_proc_entry, NULL,
- NULL);
+ entry = lprocfs_register("exports", obd->obd_proc_entry, NULL, NULL);
if (IS_ERR(entry)) {
rc = PTR_ERR(entry);
CERROR("%s: error %d setting up lprocfs for %s\n",
* \retval 0 if successful
* \retval negative value on error
*/
-int ofd_set_info_hdl(struct tgt_session_info *tsi)
+static int ofd_set_info_hdl(struct tgt_session_info *tsi)
{
struct ptlrpc_request *req = tgt_ses_req(tsi);
struct ost_body *body = NULL, *repbody;
void *key, *val = NULL;
int keylen, vallen, rc = 0;
bool is_grant_shrink;
- struct ofd_device *ofd = ofd_exp(tsi->tsi_exp);
ENTRY;
if (vallen > 0)
obd_export_evict_by_nid(tsi->tsi_exp->exp_obd, val);
rc = 0;
- } else if (KEY_IS(KEY_CAPA_KEY)) {
- rc = ofd_update_capa_key(ofd, val);
} else if (KEY_IS(KEY_SPTLRPC_CONF)) {
rc = tgt_adapt_sptlrpc_conf(tsi->tsi_tgt, 0);
} else {
* \retval 0 if successful
* \retval negative value on error
*/
-int ofd_get_info_hdl(struct tgt_session_info *tsi)
+static int ofd_get_info_hdl(struct tgt_session_info *tsi)
{
struct obd_export *exp = tsi->tsi_exp;
struct ofd_device *ofd = ofd_exp(exp);
RCL_CLIENT);
if (KEY_IS(KEY_LAST_ID)) {
- obd_id *last_id;
+ u64 *last_id;
struct ofd_seq *oseq;
req_capsule_extend(tsi->tsi_pill, &RQF_OST_GET_INFO_LAST_ID);
last_id = req_capsule_server_get(tsi->tsi_pill, &RMF_OBD_ID);
oseq = ofd_seq_load(tsi->tsi_env, ofd,
- (obd_seq)exp->exp_filter_data.fed_group);
+ (u64)exp->exp_filter_data.fed_group);
if (IS_ERR(oseq))
rc = -EFAULT;
else
struct lu_fid *fid = &info->fti_fid;
struct ost_id *oi = &oa->o_oi;
struct ofd_seq *oseq;
- obd_seq seq = ostid_seq(oi);
- obd_id end_id = ostid_id(oi);
- obd_id last;
- obd_id oid;
+ u64 seq = ostid_seq(oi);
+ u64 end_id = ostid_id(oi);
+ u64 last;
+ u64 oid;
int skip_orphan;
int rc = 0;
struct obdo *rep_oa;
struct obd_export *exp = tsi->tsi_exp;
struct ofd_device *ofd = ofd_exp(exp);
- obd_seq seq = ostid_seq(&oa->o_oi);
- obd_id oid = ostid_id(&oa->o_oi);
+ u64 seq = ostid_seq(&oa->o_oi);
+ u64 oid = ostid_id(&oa->o_oi);
struct ofd_seq *oseq;
int rc = 0, diff;
int sync_trans = 0;
CDEBUG(D_HA, "ofd_last_id() = "LPU64" -> diff = %d\n",
ofd_seq_last_oid(oseq), diff);
if (-diff > OST_MAX_PRECREATE) {
- /* FIXME: should reset precreate_next_id on MDS */
+ /* Let MDS know that we are so far ahead. */
+ ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq) + 1);
rc = 0;
} else if (diff < 0) {
rc = ofd_orphans_destroy(tsi->tsi_env, exp,
ofd_name(ofd), POSTID(&oa->o_oi));
GOTO(out, rc = -EINVAL);
}
+
+ if (diff < 0) {
+ /* LU-5648 */
+ CERROR("%s: invalid precreate request for "
+ DOSTID", last_id " LPU64 ". "
+ "Likely MDS last_id corruption\n",
+ ofd_name(ofd), POSTID(&oa->o_oi),
+ ofd_seq_last_oid(oseq));
+ GOTO(out, rc = -EINVAL);
+ }
}
}
if (diff > 0) {
cfs_time_t enough_time = cfs_time_shift(DISK_TIMEOUT);
- obd_id next_id;
+ u64 next_id;
int created = 0;
int count;
struct ofd_device *ofd = ofd_exp(tsi->tsi_exp);
struct ofd_thread_info *fti = tsi2ofd_info(tsi);
struct lu_fid *fid = &fti->fti_fid;
- obd_id oid;
- obd_count count;
+ u64 oid;
+ u32 count;
int rc = 0;
ENTRY;
static int ofd_quotactl(struct tgt_session_info *tsi)
{
struct obd_quotactl *oqctl, *repoqc;
+ struct lu_nodemap *nodemap =
+ tsi->tsi_exp->exp_target_data.ted_nodemap;
+ int id;
int rc;
ENTRY;
if (repoqc == NULL)
RETURN(err_serious(-ENOMEM));
- /* report success for quota on/off for interoperability with current MDT
- * stack */
- if (oqctl->qc_cmd == Q_QUOTAON || oqctl->qc_cmd == Q_QUOTAOFF)
- RETURN(0);
-
*repoqc = *oqctl;
+
+ id = repoqc->qc_id;
+ if (oqctl->qc_type == USRQUOTA)
+ id = nodemap_map_id(nodemap, NODEMAP_UID,
+ NODEMAP_CLIENT_TO_FS,
+ repoqc->qc_id);
+ else if (oqctl->qc_type == GRPQUOTA)
+ id = nodemap_map_id(nodemap, NODEMAP_GID,
+ NODEMAP_CLIENT_TO_FS,
+ repoqc->qc_id);
+
+ if (repoqc->qc_id != id)
+ swap(repoqc->qc_id, id);
+
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);
+ if (repoqc->qc_id != id)
+ swap(repoqc->qc_id, id);
+
RETURN(rc);
}
ofd_punch_hpreq_check(req);
}
-struct ptlrpc_hpreq_ops ofd_hpreq_rw = {
+static struct ptlrpc_hpreq_ops ofd_hpreq_rw = {
.hpreq_lock_match = ofd_rw_hpreq_lock_match,
.hpreq_check = ofd_rw_hpreq_check,
.hpreq_fini = ofd_rw_hpreq_fini
};
-struct ptlrpc_hpreq_ops ofd_hpreq_punch = {
+static struct ptlrpc_hpreq_ops ofd_hpreq_punch = {
.hpreq_lock_match = ofd_punch_hpreq_lock_match,
.hpreq_check = ofd_punch_hpreq_check,
.hpreq_fini = ofd_punch_hpreq_fini
spin_lock_init(&m->ofd_batch_lock);
init_rwsem(&m->ofd_lastid_rwsem);
- obd->u.filter.fo_fl_oss_capa = 0;
- INIT_LIST_HEAD(&obd->u.filter.fo_capa_keys);
- obd->u.filter.fo_capa_hash = init_capa_hash();
- if (obd->u.filter.fo_capa_hash == NULL)
- RETURN(-ENOMEM);
-
m->ofd_dt_dev.dd_lu_dev.ld_ops = &ofd_lu_ops;
m->ofd_dt_dev.dd_lu_dev.ld_obd = obd;
/* set this lu_device to obd, because error handling need it */
err_fini_lut:
tgt_fini(env, &m->ofd_lut);
err_free_ns:
- ldlm_namespace_free(m->ofd_namespace, 0, obd->obd_force);
+ ldlm_namespace_free(m->ofd_namespace, NULL, obd->obd_force);
obd->obd_namespace = m->ofd_namespace = NULL;
err_fini_stack:
ofd_stack_fini(env, m, &m->ofd_osd->dd_lu_dev);
lfsck_degister(env, m->ofd_osd);
ofd_fs_cleanup(env, m);
- ofd_free_capa_keys(m);
- cleanup_capa_hash(obd->u.filter.fo_capa_hash);
-
if (m->ofd_namespace != NULL) {
ldlm_namespace_free(m->ofd_namespace, NULL,
d->ld_obd->obd_force);
* \retval 0 if successful
* \retval negative value on error
*/
-int __init ofd_init(void)
+static int __init ofd_init(void)
{
int rc;
* This function is called upon OFD module unloading.
* It frees all related structures and unregisters OFD device type.
*/
-void __exit ofd_exit(void)
+static void __exit ofd_exit(void)
{
ofd_fmd_exit();
lu_kmem_fini(ofd_caches);
class_unregister_type(LUSTRE_OST_NAME);
}
-MODULE_AUTHOR("Whamcloud, Inc. <http://www.whamcloud.com/>");
+MODULE_AUTHOR("Intel Corporation. <https://www.hpdd.intel.com/>");
MODULE_DESCRIPTION("Lustre Object Filtering Device");
MODULE_LICENSE("GPL");