if (range_space(space) < seq->seq_super_width) {
CWARN("sequences space is going to exhaust soon. "
- "Only can allocate "LPU64" sequences\n",
- space->lr_end - space->lr_start);
+ "Can allocate only "LPU64" sequences\n",
+ range_space(space));
*range = *space;
space->lr_start = space->lr_end;
rc = 0;
if (rc == 0) {
CDEBUG(D_INFO, "%s: allocated super-sequence "
- "["LPX64"-"LPX64"]\n", seq->seq_name,
- range->lr_start, range->lr_end);
+ DRANGE"\n", seq->seq_name, PRANGE(range));
}
RETURN(rc);
if (rc == 0) {
CDEBUG(D_INFO, "%s: allocated meta-sequence "
- "["LPX64"-"LPX64"]\n", seq->seq_name,
- range->lr_start, range->lr_end);
+ DRANGE"\n", seq->seq_name, PRANGE(range));
}
RETURN(rc);
RETURN(rc);
}
-struct seq_thread_info {
- struct req_capsule sti_pill;
- int sti_rep_buf_size[2];
-};
-
static int seq_req_handle0(const struct lu_context *ctx,
struct ptlrpc_request *req,
struct seq_thread_info *info)
if (opc != NULL) {
out = req_capsule_server_get(&info->sti_pill,
&RMF_SEQ_RANGE);
- if (out == NULL) {
- CERROR("can't get range buffer\n");
+ if (out == NULL)
RETURN(-EPROTO);
- }
switch (*opc) {
case SEQ_ALLOC_META:
if (!site->ls_server_seq) {
- CERROR("sequence-server is not initialized\n");
+ CERROR("sequence-server is not "
+ "initialized\n");
RETURN(-EINVAL);
}
- rc = seq_server_alloc_meta(site->ls_server_seq, out, ctx);
+ rc = seq_server_alloc_meta(site->ls_server_seq,
+ out, ctx);
break;
case SEQ_ALLOC_SUPER:
if (!site->ls_control_seq) {
- CERROR("sequence-controller is not initialized\n");
+ CERROR("sequence-controller is not "
+ "initialized\n");
RETURN(-EINVAL);
}
- rc = seq_server_alloc_super(site->ls_control_seq, out, ctx);
+ rc = seq_server_alloc_super(site->ls_control_seq,
+ out, ctx);
break;
default:
- CERROR("wrong opc 0x%x\n", *opc);
+ CERROR("wrong opc %#x\n", *opc);
break;
}
- } else {
- CERROR("cannot unpack client request\n");
}
RETURN(rc);
static int seq_req_handle(struct ptlrpc_request *req)
{
- int fail = OBD_FAIL_SEQ_ALL_REPLY_NET;
const struct lu_context *ctx;
struct seq_thread_info *info;
int rc = 0;
req->rq_status = -ENOTCONN;
}
} else {
- CERROR("Wrong opcode: %d\n",
- req->rq_reqmsg->opc);
+ CERROR("Wrong opcode: %d\n", req->rq_reqmsg->opc);
req->rq_status = -ENOTSUPP;
rc = ptlrpc_error(req);
GOTO(out_info, rc);
}
- target_send_reply(req, rc, fail);
+ target_send_reply(req, rc, OBD_FAIL_SEQ_ALL_REPLY_NET);
EXIT;
out_info:
seq_thread_info_fini(info);
return rc;
}
+static void seq_server_proc_fini(struct lu_server_seq *seq);
+
#ifdef LPROCFS
static int seq_server_proc_init(struct lu_server_seq *seq)
{
if (IS_ERR(seq->seq_proc_dir)) {
CERROR("LProcFS failed in seq-init\n");
rc = PTR_ERR(seq->seq_proc_dir);
- GOTO(err, rc);
+ RETURN(rc);
}
seq->seq_proc_entry = lprocfs_register("services",
if (IS_ERR(seq->seq_proc_entry)) {
CERROR("LProcFS failed in seq-init\n");
rc = PTR_ERR(seq->seq_proc_entry);
- GOTO(err_type, rc);
+ GOTO(out_cleanup, rc);
}
rc = lprocfs_add_vars(seq->seq_proc_dir,
if (rc) {
CERROR("can't init sequence manager "
"proc, rc %d\n", rc);
- GOTO(err_entry, rc);
+ GOTO(out_cleanup, rc);
}
RETURN(0);
-err_entry:
- lprocfs_remove(seq->seq_proc_entry);
-err_type:
- lprocfs_remove(seq->seq_proc_dir);
-err:
- seq->seq_proc_dir = NULL;
- seq->seq_proc_entry = NULL;
+out_cleanup:
+ seq_server_proc_fini(seq);
return rc;
}
static void seq_server_proc_fini(struct lu_server_seq *seq)
{
ENTRY;
- if (seq->seq_proc_entry) {
- lprocfs_remove(seq->seq_proc_entry);
+ if (seq->seq_proc_entry != NULL) {
+ if (!IS_ERR(seq->seq_proc_entry))
+ lprocfs_remove(seq->seq_proc_entry);
seq->seq_proc_entry = NULL;
}
- if (seq->seq_proc_dir) {
- lprocfs_remove(seq->seq_proc_dir);
+ if (seq->seq_proc_dir != NULL) {
+ if (!IS_ERR(seq->seq_proc_dir))
+ lprocfs_remove(seq->seq_proc_dir);
seq->seq_proc_dir = NULL;
}
EXIT;
}
+#else
+static int seq_server_proc_init(struct lu_server_seq *seq)
+{
+ return 0;
+}
+
+static void seq_server_proc_fini(struct lu_server_seq *seq)
+{
+ return;
+}
#endif
int seq_server_init(struct lu_server_seq *seq,
struct dt_device *dev,
const char *uuid,
- lu_server_type_t type,
+ enum lu_mgr_type type,
const struct lu_context *ctx)
{
- int rc, portal = (type == LUSTRE_SEQ_SRV) ?
- SEQ_SRV_PORTAL : SEQ_CTLR_PORTAL;
+ int is_srv = type == LUSTRE_SEQ_SERVER;
+
+ int rc, portal = is_srv ?
+ SEQ_SERVER_PORTAL : SEQ_CONTROLLER_PORTAL;
struct ptlrpc_service_conf seq_conf = {
.psc_nbufs = MDS_NBUFS,
seq->seq_meta_width = LUSTRE_SEQ_META_WIDTH;
snprintf(seq->seq_name, sizeof(seq->seq_name), "%s-%s-%s",
- LUSTRE_SEQ_NAME, (type == LUSTRE_SEQ_SRV ? "srv" : "ctl"),
+ LUSTRE_SEQ_NAME, (is_srv ? "srv" : "ctl"),
uuid);
seq->seq_space = LUSTRE_SEQ_SPACE_RANGE;
/* request backing store for saved sequence info */
rc = seq_store_read(seq, ctx);
if (rc == -ENODATA) {
- if (type == LUSTRE_SEQ_SRV) {
- CDEBUG(D_INFO|D_WARNING, "%s: no data on "
- "disk found, wait for controller "
- "attach\n", seq->seq_name);
- } else {
- CDEBUG(D_INFO|D_WARNING, "%s: no data on "
- "disk found, this is first controller "
- "run\n", seq->seq_name);
- }
+ CDEBUG(D_INFO|D_WARNING, "%s: no data on "
+ "storage was found, %s\n", seq->seq_name,
+ is_srv ? "wait for controller attach" :
+ "this is first controller run");
} else if (rc) {
CERROR("can't read sequence state, rc = %d\n",
rc);
GOTO(out, rc);
}
-#ifdef LPROCFS
rc = seq_server_proc_init(seq);
if (rc)
GOTO(out, rc);
-#endif
seq->seq_service = ptlrpc_init_svc_conf(&seq_conf,
seq_req_handle,
seq_server_fini(seq, ctx);
} else {
CDEBUG(D_INFO|D_WARNING, "%s Sequence Manager\n",
- (type == LUSTRE_SEQ_SRV ? "Server" : "Controller"));
+ (is_srv ? "Server" : "Controller"));
}
return rc;
}
seq->seq_service = NULL;
}
-#ifdef LPROCFS
seq_server_proc_fini(seq);
-#endif
-
seq_store_fini(seq, ctx);
if (seq->seq_dev != NULL) {
#endif
#ifdef __KERNEL__
+struct seq_store_record {
+ struct lu_range ssr_space;
+ struct lu_range ssr_super;
+};
+
+struct seq_thread_info {
+ struct txn_param sti_txn;
+ struct req_capsule sti_pill;
+ struct seq_store_record sti_record;
+ int sti_rep_buf_size[2];
+};
+
+extern struct lu_context_key seq_thread_key;
+
int seq_store_init(struct lu_server_seq *seq,
const struct lu_context *ctx);
}
EXPORT_SYMBOL(fid_to_be);
+void range_to_le(struct lu_range *dst, const struct lu_range *src)
+{
+ /* check that all fields are converted */
+ CLASSERT(sizeof *src ==
+ sizeof src->lr_start +
+ sizeof src->lr_end);
+ dst->lr_start = le64_to_cpu(src->lr_start);
+ dst->lr_end = le64_to_cpu(src->lr_end);
+}
+EXPORT_SYMBOL(range_to_le);
+
+void range_to_be(struct lu_range *dst, const struct lu_range *src)
+{
+ /* check that all fields are converted */
+ CLASSERT(sizeof *src ==
+ sizeof src->lr_start +
+ sizeof src->lr_end);
+ dst->lr_start = be64_to_cpu(src->lr_start);
+ dst->lr_end = be64_to_cpu(src->lr_end);
+}
+EXPORT_SYMBOL(range_to_be);
+
static int seq_client_rpc(struct lu_client_seq *seq,
struct lu_range *range,
- __u32 opc)
+ __u32 opc, const char *opcname)
{
struct obd_export *exp = seq->seq_exp;
int repsize = sizeof(struct lu_range);
req->rq_replen = lustre_msg_size(1, &repsize);
req->rq_request_portal = (opc == SEQ_ALLOC_SUPER) ?
- SEQ_CTLR_PORTAL : SEQ_SRV_PORTAL;
+ SEQ_CONTROLLER_PORTAL : SEQ_SERVER_PORTAL;
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out_req, rc);
ran = req_capsule_server_get(&pill, &RMF_SEQ_RANGE);
- if (ran == NULL) {
- CERROR("invalid range is returned\n");
+ if (ran == NULL)
GOTO(out_req, rc = -EPROTO);
- }
*range = *ran;
- LASSERT(range_is_sane(range));
- LASSERT(!range_is_exhausted(range));
+ if (!range_is_sane(range)) {
+ CERROR("invalid seq range obtained from server: "
+ DRANGE"\n", PRANGE(range));
+ GOTO(out_req, rc = -EINVAL);
+ }
+
+ if (range_is_exhausted(range)) {
+ CERROR("seq range obtained from server is exhausted: "
+ DRANGE"]\n", PRANGE(range));
+ GOTO(out_req, rc = -EINVAL);
+ }
+ if (rc == 0) {
+ CDEBUG(D_INFO, "%s: allocated %s-sequence "
+ DRANGE"]\n", seq->seq_name, opcname,
+ PRANGE(range));
+ }
+
EXIT;
out_req:
req_capsule_fini(&pill);
return rc;
}
-static int __seq_client_alloc_opc(struct lu_client_seq *seq,
- int opc, const char *opcname)
-{
- int rc;
- ENTRY;
-
- rc = seq_client_rpc(seq, &seq->seq_range, opc);
- if (rc == 0) {
- CDEBUG(D_INFO, "%s: allocated %s-sequence ["
- LPX64"-"LPX64"]\n", seq->seq_name, opcname,
- seq->seq_range.lr_start, seq->seq_range.lr_end);
- }
- RETURN(rc);
-}
-
/* request sequence-controller node to allocate new super-sequence. */
static int __seq_client_alloc_super(struct lu_client_seq *seq)
{
- ENTRY;
- RETURN(__seq_client_alloc_opc(seq, SEQ_ALLOC_SUPER, "super"));
+ return seq_client_rpc(seq, &seq->seq_range,
+ SEQ_ALLOC_SUPER, "super");
}
int seq_client_alloc_super(struct lu_client_seq *seq)
/* request sequence-controller node to allocate new meta-sequence. */
static int __seq_client_alloc_meta(struct lu_client_seq *seq)
{
- ENTRY;
- RETURN(__seq_client_alloc_opc(seq, SEQ_ALLOC_META, "meta"));
+ return seq_client_rpc(seq, &seq->seq_range,
+ SEQ_ALLOC_META, "meta");
}
int seq_client_alloc_meta(struct lu_client_seq *seq)
}
}
+ LASSERT(range_space(&seq->seq_range) > 0);
*seqnr = seq->seq_range.lr_start;
seq->seq_range.lr_start++;
int seq_client_alloc_fid(struct lu_client_seq *seq, struct lu_fid *fid)
{
- seqno_t seqnr = 0;
int rc;
ENTRY;
if (!fid_is_sane(&seq->seq_fid) ||
fid_oid(&seq->seq_fid) >= seq->seq_width)
{
- /* allocate new sequence for case client hass no sequence at all
- * or sequnece is exhausted and should be switched. */
+ seqno_t seqnr;
+
+ /* allocate new sequence for case client has no sequence at all
+ * or sequence is exhausted and should be switched. */
rc = __seq_client_alloc_seq(seq, &seqnr);
if (rc) {
CERROR("can't allocate new sequence, "
seq->seq_fid.f_seq = seqnr;
seq->seq_fid.f_ver = 0;
- /* inform caller that sequnece switch is performed to allow it
+ /* inform caller that sequence switch is performed to allow it
* to setup FLD for it. */
- rc = -ERESTART;
+ rc = 1;
} else {
seq->seq_fid.f_oid++;
rc = 0;
*fid = seq->seq_fid;
LASSERT(fid_is_sane(fid));
- CDEBUG(D_INFO, "%s: allocated FID "DFID3"\n",
- seq->seq_name, PFID3(fid));
+ CDEBUG(D_INFO, "%s: allocated FID "DFID"\n",
+ seq->seq_name, PFID(fid));
EXIT;
out:
}
EXIT;
}
+#else
+static int seq_client_proc_init(struct lu_client_seq *seq)
+{
+ return 0;
+}
+
+static void seq_client_proc_fini(struct lu_client_seq *seq)
+{
+ return;
+}
#endif
int seq_client_init(struct lu_client_seq *seq,
snprintf(seq->seq_name, sizeof(seq->seq_name),
"%s-cli-%s", LUSTRE_SEQ_NAME, uuid);
-#ifdef LPROCFS
rc = seq_client_proc_init(seq);
-#endif
-
if (rc)
seq_client_fini(seq);
else
{
ENTRY;
-#ifdef LPROCFS
seq_client_proc_fini(seq);
-#endif
if (seq->seq_exp != NULL) {
class_export_put(seq->seq_exp);
#include "fid_internal.h"
#ifdef __KERNEL__
-struct seq_store_capsule {
- struct lu_range ssc_space;
- struct lu_range ssc_super;
-};
-
enum {
SEQ_TXN_STORE_CREDITS = 20
};
{
struct dt_object *dt_obj = seq->seq_obj;
struct dt_device *dt_dev = seq->seq_dev;
- struct seq_store_capsule capsule;
- loff_t pos = 0;
- struct txn_param txn;
+ struct seq_thread_info *info;
struct thandle *th;
+ loff_t pos = 0;
int rc;
ENTRY;
+ info = lu_context_key_get(ctx, &seq_thread_key);
+ LASSERT(info != NULL);
+
/* stub here, will fix it later */
- txn.tp_credits = SEQ_TXN_STORE_CREDITS;
+ info->sti_txn.tp_credits = SEQ_TXN_STORE_CREDITS;
- th = dt_dev->dd_ops->dt_trans_start(ctx, dt_dev, &txn);
+ th = dt_dev->dd_ops->dt_trans_start(ctx, dt_dev, &info->sti_txn);
if (!IS_ERR(th)) {
+ /* store ranges in le format */
+ range_to_le(&info->sti_record.ssr_space, &seq->seq_space);
+ range_to_le(&info->sti_record.ssr_super, &seq->seq_super);
+
rc = dt_obj->do_body_ops->dbo_write(ctx, dt_obj,
- (char *)&capsule,
- sizeof(capsule),
+ (char *)&info->sti_record,
+ sizeof(info->sti_record),
&pos, th);
- if (rc == sizeof(capsule)) {
+ if (rc == sizeof(info->sti_record)) {
rc = 0;
} else if (rc >= 0) {
rc = -EIO;
const struct lu_context *ctx)
{
struct dt_object *dt_obj = seq->seq_obj;
- struct seq_store_capsule capsule;
+ struct seq_thread_info *info;
loff_t pos = 0;
int rc;
ENTRY;
+ info = lu_context_key_get(ctx, &seq_thread_key);
+ LASSERT(info != NULL);
+
rc = dt_obj->do_body_ops->dbo_read(ctx, dt_obj,
- (char *)&capsule,
- sizeof(capsule), &pos);
- if (rc == sizeof(capsule)) {
- seq->seq_space = capsule.ssc_space;
- seq->seq_super = capsule.ssc_super;
+ (char *)&info->sti_record,
+ sizeof(info->sti_record), &pos);
+ if (rc == sizeof(info->sti_record)) {
+ seq->seq_space = info->sti_record.ssr_space;
+ lustre_swab_lu_range(&seq->seq_space);
+
+ seq->seq_super = info->sti_record.ssr_super;
+ lustre_swab_lu_range(&seq->seq_super);
rc = 0;
} else if (rc == 0) {
rc = -ENODATA;
} else if (rc >= 0) {
CERROR("read only %d bytes of %d\n",
- rc, sizeof(capsule));
+ rc, sizeof(info->sti_record));
rc = -EIO;
}
{
struct dt_device *dt = seq->seq_dev;
struct dt_object *dt_obj;
+ struct lu_fid fid;
int rc;
ENTRY;
LASSERT(seq->seq_service == NULL);
- dt_obj = dt_store_open(ctx, dt, "seq", &seq->seq_fid);
+ dt_obj = dt_store_open(ctx, dt, "seq", &fid);
if (!IS_ERR(dt_obj)) {
seq->seq_obj = dt_obj;
rc = 0;
#include "fid_internal.h"
#ifdef LPROCFS
-/* server side procfs stuff */
+/*
+ * Server side procfs stuff.
+ *
+ * Note: this function is only used for testing, it is no safe for production
+ * use.
+ */
static int
seq_proc_write_common(struct file *file, const char *buffer,
unsigned long count, void *data,
LASSERT(range != NULL);
- rc = sscanf(buffer, "["LPU64"-"LPU64"]\n",
+ rc = sscanf(buffer, DRANGE"\n",
&tmp.lr_start, &tmp.lr_end);
/* did not match 2 values */
if (rc != 2 || !range_is_sane(&tmp) || range_is_zero(&tmp)) {
- CERROR("can't parse input string or "
- "input is not correct\n");
+ CERROR("can't parse input string or input is not correct\n");
RETURN(-EINVAL);
}
ENTRY;
*eof = 1;
- rc = snprintf(page, count, "["LPU64"-"LPU64"]\n",
- range->lr_start, range->lr_end);
+ rc = snprintf(page, count, DRANGE"]\n",
+ PRANGE(range));
RETURN(rc);
}
rc = seq_proc_write_common(file, buffer, count,
data, &seq->seq_space);
if (rc == 0) {
- CDEBUG(D_WARNING, "SEQ-MGR(srv): sequences space has changed "
- "to ["LPU64"-"LPU64"]\n", seq->seq_space.lr_start,
- seq->seq_space.lr_end);
+ CDEBUG(D_WARNING, "SEQ-MGR(srv): sequences space has "
+ "changed to "DRANGE"\n", PRANGE(&seq->seq_space));
}
up(&seq->seq_sem);
data, &seq->seq_super);
if (rc == 0) {
- CDEBUG(D_WARNING, "SEQ-MGR(srv): super-sequence has changed to "
- "["LPU64"-"LPU64"]\n", seq->seq_super.lr_start,
- seq->seq_super.lr_end);
+ CDEBUG(D_WARNING, "SEQ-MGR(srv): super-sequence has "
+ "changed to "DRANGE"\n", PRANGE(&seq->seq_super));
}
up(&seq->seq_sem);
if (rc == 0) {
CDEBUG(D_WARNING, "SEQ-MGR(cli): range has changed to "
- "["LPU64"-"LPU64"]\n", seq->seq_range.lr_start,
- seq->seq_range.lr_end);
+ DRANGE"\n", PRANGE(&seq->seq_range));
}
up(&seq->seq_sem);
LASSERT(seq != NULL);
down(&seq->seq_sem);
- rc = snprintf(page, count, DFID3"\n",
- PFID3(&seq->seq_fid));
+ rc = snprintf(page, count, DFID"\n",
+ PFID(&seq->seq_fid));
up(&seq->seq_sem);
RETURN(rc);
}
EXPORT_SYMBOL(fid_is_local);
+static void fld_server_proc_fini(struct lu_server_fld *fld);
+
#ifdef LPROCFS
static int fld_server_proc_init(struct lu_server_fld *fld)
{
if (IS_ERR(fld->fld_proc_dir)) {
CERROR("LProcFS failed in fld-init\n");
rc = PTR_ERR(fld->fld_proc_dir);
- GOTO(err, rc);
+ RETURN(rc);
}
fld->fld_proc_entry = lprocfs_register("services",
if (IS_ERR(fld->fld_proc_entry)) {
CERROR("LProcFS failed in fld-init\n");
rc = PTR_ERR(fld->fld_proc_entry);
- GOTO(err_type, rc);
+ GOTO(out_cleanup, rc);
}
rc = lprocfs_add_vars(fld->fld_proc_dir,
fld_server_proc_list, fld);
if (rc) {
CERROR("can't init FLD proc, rc %d\n", rc);
- GOTO(err_entry, rc);
+ GOTO(out_cleanup, rc);
}
RETURN(0);
-err_entry:
- lprocfs_remove(fld->fld_proc_entry);
-err_type:
- lprocfs_remove(fld->fld_proc_dir);
-err:
- fld->fld_proc_dir = NULL;
- fld->fld_proc_entry = NULL;
+out_cleanup:
+ fld_server_proc_fini(fld);
return rc;
}
static void fld_server_proc_fini(struct lu_server_fld *fld)
{
ENTRY;
- if (fld->fld_proc_entry) {
- lprocfs_remove(fld->fld_proc_entry);
+ if (fld->fld_proc_entry != NULL) {
+ if (!IS_ERR(fld->fld_proc_entry))
+ lprocfs_remove(fld->fld_proc_entry);
fld->fld_proc_entry = NULL;
}
- if (fld->fld_proc_dir) {
- lprocfs_remove(fld->fld_proc_dir);
+ if (fld->fld_proc_dir != NULL) {
+ if (!IS_ERR(fld->fld_proc_dir))
+ lprocfs_remove(fld->fld_proc_dir);
fld->fld_proc_dir = NULL;
}
EXIT;
}
+#else
+static int fld_server_proc_init(struct lu_server_fld *fld)
+{
+ return 0;
+}
+
+static void fld_server_proc_fini(struct lu_server_fld *fld)
+{
+ return;
+}
#endif
int fld_server_init(struct lu_server_fld *fld,
if (rc)
GOTO(out, rc);
-#ifdef LPROCFS
rc = fld_server_proc_init(fld);
if (rc)
GOTO(out, rc);
-#endif
fld->fld_service =
ptlrpc_init_svc_conf(&fld_conf, fld_req_handle,
{
ENTRY;
-#ifdef LPROCFS
fld_server_proc_fini(fld);
-#endif
if (fld->fld_service != NULL) {
ptlrpc_unregister_service(fld->fld_service);
}
EXIT;
}
+#else
+static int fld_client_proc_init(struct lu_client_fld *fld)
+{
+ return 0;
+}
+
+static void fld_client_proc_fini(struct lu_client_fld *fld)
+{
+ return;
+}
#endif
static inline int hash_is_sane(int hash)
}
#endif
-#ifdef LPROCFS
rc = fld_client_proc_init(fld);
if (rc)
GOTO(out, rc);
-#endif
EXIT;
-#ifdef __KERNEL__
out:
-#endif
if (rc)
fld_client_fini(fld);
else
struct fld_target *target, *tmp;
ENTRY;
-#ifdef LPROCFS
fld_client_proc_fini(fld);
-#endif
spin_lock(&fld->fld_lock);
list_for_each_entry_safe(target, tmp,
GOTO(out_req, rc);
pmf = req_capsule_server_get(&pill, &RMF_FLD_MDFLD);
- if (pmf == NULL) {
- CERROR("Can't unpack FLD response\n");
+ if (pmf == NULL)
GOTO(out_req, rc = -EFAULT);
- }
*mf = *pmf;
EXIT;
out_req:
#define MGS_REPLY_PORTAL 27
#define OST_REQUEST_PORTAL 28
#define FLD_REQUEST_PORTAL 29
-#define SEQ_SRV_PORTAL 30
-#define SEQ_CTLR_PORTAL 31
+#define SEQ_SERVER_PORTAL 30
+#define SEQ_CONTROLLER_PORTAL 31
#define SVC_KILLED 1
#define SVC_EVENT 2
return range_space(r) == 0;
}
+#define DRANGE "["LPU64"-"LPU64"]"
+
+#define PRANGE(range) \
+ (range)->lr_start, \
+ (range)->lr_end
+
struct lu_fid {
__u64 f_seq; /* holds fid sequence. Lustre should support 2 ^ 64
* objects, thus even if one sequence has one object we
fid_seq_is_sane(fid_seq(fid)) && fid_oid(fid) != 0;
}
-#define DFID3 "[%16.16"LPF64"x/%8.8x:%8.8x]"
+#define DFID "[%16.16"LPF64"x/%8.8x:%8.8x]"
-#define PFID3(fid) \
- fid_seq(fid), \
- fid_oid(fid), \
- fid_ver(fid)
+#define PFID(fid) \
+ fid_seq((fid)), \
+ fid_oid((fid)), \
+ fid_ver((fid))
extern void lustre_swab_lu_fid(struct lu_fid *fid);
extern void lustre_swab_lu_range(struct lu_range *range);
extern const struct lu_range LUSTRE_SEQ_SPACE_RANGE;
extern const struct lu_range LUSTRE_SEQ_ZERO_RANGE;
-/* this is how may FIDs may be allocated in one sequence. */
-#define LUSTRE_SEQ_MAX_WIDTH 0x00000000000002800
+enum {
+ /* this is how may FIDs may be allocated in one sequence. */
+ LUSTRE_SEQ_MAX_WIDTH = 0x00000000000002800ULL,
-/* how many sequences may be allocate for meta-sequence (this is 10240
- * sequences). */
-#define LUSTRE_SEQ_META_WIDTH 0x00000000000002800
+ /* how many sequences may be allocate for meta-sequence (this is 10240
+ * sequences). */
+ LUSTRE_SEQ_META_WIDTH = 0x00000000000002800ULL,
-/* this is how many sequneces (10240 * 10240) may be in one super-sequence
- * allocated to MDTs. */
-#define LUSTRE_SEQ_SUPER_WIDTH (LUSTRE_SEQ_META_WIDTH * LUSTRE_SEQ_META_WIDTH)
-
-enum lu_server_type {
- LUSTRE_SEQ_SRV,
- LUSTRE_SEQ_CTLR
+ /* this is how many sequneces (10240 * 10240) may be in one
+ * super-sequence allocated to MDTs. */
+ LUSTRE_SEQ_SUPER_WIDTH = (LUSTRE_SEQ_META_WIDTH * LUSTRE_SEQ_META_WIDTH)
+};
+
+enum lu_mgr_type {
+ LUSTRE_SEQ_SERVER,
+ LUSTRE_SEQ_CONTROLLER
};
-
-typedef enum lu_server_type lu_server_type_t;
/* client sequence manager interface */
struct lu_client_seq {
/* /seq file object device */
struct dt_object *seq_obj;
- /* /seq file fid */
- struct lu_fid seq_fid;
-
/* seq related proc */
cfs_proc_dir_entry_t *seq_proc_entry;
cfs_proc_dir_entry_t *seq_proc_dir;
/* LUSTRE_SEQ_SRV or LUSTRE_SEQ_CTLR */
- lu_server_type_t seq_type;
+ enum lu_mgr_type seq_type;
/* server side seq service */
struct ptlrpc_service *seq_service;
int seq_server_init(struct lu_server_seq *seq,
struct dt_device *dev,
const char *uuid,
- lu_server_type_t type,
+ enum lu_mgr_type type,
const struct lu_context *ctx);
void seq_server_fini(struct lu_server_seq *seq,
void fid_to_le(struct lu_fid *dst, const struct lu_fid *src);
void fid_to_be(struct lu_fid *dst, const struct lu_fid *src);
+/* Range common stuff */
+void range_to_le(struct lu_range *dst, const struct lu_range *src);
+void range_to_be(struct lu_range *dst, const struct lu_range *src);
+
#endif /* __LINUX_OBD_CLASS_H */
CERROR("cannot mds_connect: rc = %d\n", err);
GOTO(out_dt_fid, err);
}
- CDEBUG(D_SUPER, "rootfid "DFID3"\n", PFID3(&rootfid));
+ CDEBUG(D_SUPER, "rootfid "DFID"\n", PFID(&rootfid));
sbi->ll_root_fid = rootfid;
/* fetch attr of root inode */
pos = hash;
} else {
rc = PTR_ERR(page);
- CERROR("error reading dir "DFID3" at %lu: rc %d\n",
- PFID3(&info->lli_fid), (unsigned long)pos, rc);
+ CERROR("error reading dir "DFID" at %lu: rc %d\n",
+ PFID(&info->lli_fid), (unsigned long)pos, rc);
}
}
RETURN(0);
fid = &ll_i2info(inode)->lli_fid;
- CDEBUG(D_INFO, "trying to match res "DFID3"\n", PFID3(fid));
+ CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
CERROR("cannot mds_connect: rc = %d\n", err);
GOTO(out_dt_fid, err);
}
- CDEBUG(D_SUPER, "rootfid "DFID3"\n", PFID3(&rootfid));
+ CDEBUG(D_SUPER, "rootfid "DFID"\n", PFID(&rootfid));
sbi->ll_root_fid = rootfid;
sb->s_op = &lustre_super_operations;
rc = md_getattr(sbi->ll_md_exp, fid, valid, eadatalen, &req);
if (rc) {
- CERROR("can't get object attrs, fid "DFID3", rc %d\n",
- PFID3(fid), rc);
+ CERROR("can't get object attrs, fid "DFID", rc %d\n",
+ PFID(fid), rc);
return ERR_PTR(rc);
}
if (is_bad_inode(inode)) {
/* we didn't find the right inode.. */
- CERROR("can't get inode by fid "DFID3"\n",
- PFID3(fid));
+ CERROR("can't get inode by fid "DFID"\n",
+ PFID(fid));
iput(inode);
return ERR_PTR(-ESTALE);
}
if (lock->l_resource->lr_name.name[0] != fid_seq(ll_inode2fid(inode)) ||
lock->l_resource->lr_name.name[1] != fid_oid(ll_inode2fid(inode)) ||
lock->l_resource->lr_name.name[2] != fid_ver(ll_inode2fid(inode))) {
- LDLM_ERROR(lock, "data mismatch with object "DFID3" (%p)",
- PFID3(ll_inode2fid(inode)), inode);
+ LDLM_ERROR(lock, "data mismatch with object "DFID" (%p)",
+ PFID(ll_inode2fid(inode)), inode);
}
if (bits & MDS_INODELOCK_UPDATE)
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)name, len);
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n",
- mds, PFID3(&rpid));
+ CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n",
+ mds, PFID(&rpid));
rpid = obj->lo_inodes[mds].li_fid;
lmv_obj_put(obj);
}
* this is "usual" situation, we should not print error here,
* only debug info.
*/
- CDEBUG(D_OTHER, "can't handle remote %s: dir "DFID3"("DFID3"):"
- "%*s: %d\n", LL_IT2STR(it), PFID3(pid), PFID3(&rpid),
+ CDEBUG(D_OTHER, "can't handle remote %s: dir "DFID"("DFID"):"
+ "%*s: %d\n", LL_IT2STR(it), PFID(pid), PFID(&rpid),
len, name, rc);
GOTO(out_free_op_data, rc);
}
if (obj) {
/* this is splitted dir and we'd want to get attrs */
- CDEBUG(D_OTHER, "attrs from slaves for "DFID3"\n",
- PFID3(cid));
+ CDEBUG(D_OTHER, "attrs from slaves for "DFID"\n",
+ PFID(cid));
rc = lmv_revalidate_slaves(exp, reqp, cid, it, 1,
cb_blocking, extra_lock_flags);
} else if (S_ISDIR(body->mode)) {
- CDEBUG(D_OTHER, "object "DFID3" has not lmv obj?\n",
- PFID3(cid));
+ CDEBUG(D_OTHER, "object "DFID" has not lmv obj?\n",
+ PFID(cid));
}
if (obj)
if (cid) {
/* caller wants to revalidate attrs of obj we have to revalidate
* slaves if requested object is splitted directory */
- CDEBUG(D_OTHER, "revalidate attrs for "DFID3"\n", PFID3(cid));
+ CDEBUG(D_OTHER, "revalidate attrs for "DFID"\n", PFID(cid));
mds = lmv_fld_lookup(obd, cid);
if (mds < 0)
GOTO(out_free_op_data, rc = mds);
#endif
op_data->fid2 = *cid;
} else {
- CDEBUG(D_OTHER, "INTENT getattr for %*s on "DFID3"\n",
- len, name, PFID3(pid));
+ CDEBUG(D_OTHER, "INTENT getattr for %*s on "DFID"\n",
+ len, name, PFID(pid));
mds = lmv_fld_lookup(obd, pid);
if (mds < 0)
GOTO(out_free_op_data, rc = mds);
mds = lmv_fld_lookup(obd, &rpid);
lmv_obj_put(obj);
- CDEBUG(D_OTHER, "forward to MDS #%u (slave "DFID3")\n",
- mds, PFID3(&rpid));
+ CDEBUG(D_OTHER, "forward to MDS #%u (slave "DFID")\n",
+ mds, PFID(&rpid));
}
}
* notify about object * removal.
*/
CDEBUG(D_OTHER,
- "revalidate slaves for "DFID3", rc %d\n",
- PFID3(cid), rc);
+ "revalidate slaves for "DFID", rc %d\n",
+ PFID(cid), rc);
LASSERT(cid != 0);
rc = lmv_revalidate_slaves(exp, reqp, cid, it, rc,
if (obj2) {
/* this is splitted dir and we'd want to get attrs */
- CDEBUG(D_OTHER, "attrs from slaves for "DFID3", rc %d\n",
- PFID3(cid), rc);
+ CDEBUG(D_OTHER, "attrs from slaves for "DFID", rc %d\n",
+ PFID(cid), rc);
rc = lmv_revalidate_slaves(exp, reqp, cid, it, 1,
cb_blocking, extra_lock_flags);
obj = lmv_obj_grab(obd, &body->fid1);
LASSERT(obj != NULL);
- CDEBUG(D_OTHER, "lookup slaves for "DFID3"\n",
- PFID3(&body->fid1));
+ CDEBUG(D_OTHER, "lookup slaves for "DFID"\n",
+ PFID(&body->fid1));
OBD_ALLOC_PTR(op_data);
if (op_data == NULL)
/* skip master obj */
continue;
- CDEBUG(D_OTHER, "lookup slave "DFID3"\n", PFID3(&fid));
+ CDEBUG(D_OTHER, "lookup slave "DFID"\n", PFID(&fid));
/* is obj valid? */
memset(&it, 0, sizeof(it));
if (mds < 0)
GOTO(out_free_op_data, rc = mds);
- CDEBUG(D_OTHER, "revalidate lookup for "DFID3" to %d MDS\n",
- PFID3(cid), mds);
+ CDEBUG(D_OTHER, "revalidate lookup for "DFID" to %d MDS\n",
+ PFID(cid), mds);
op_data->fid2 = *cid;
} else {
* very interesting. it seems object is still valid but for some
* reason llite calls lookup, not revalidate.
*/
- CDEBUG(D_OTHER, "lookup for "DFID3" and data should be uptodate\n",
- PFID3(&rpid));
+ CDEBUG(D_OTHER, "lookup for "DFID" and data should be uptodate\n",
+ PFID(&rpid));
LASSERT(*reqp == NULL);
GOTO(out_free_op_data, rc);
}
if (rc == 0 && *reqp == NULL) {
/* once again, we're asked for lookup, not revalidate */
- CDEBUG(D_OTHER, "lookup for "DFID3" and data should be uptodate\n",
- PFID3(&rpid));
+ CDEBUG(D_OTHER, "lookup for "DFID" and data should be uptodate\n",
+ PFID(&rpid));
GOTO(out_free_op_data, rc);
}
i = lmv_fld_lookup(obd, pid);
if (i < 0)
RETURN(i);
- CDEBUG(D_OTHER, "INTENT LOCK '%s' for '%*s' on "DFID3" -> %d\n",
- LL_IT2STR(it), len, name, PFID3(pid), i);
+ CDEBUG(D_OTHER, "INTENT LOCK '%s' for '%*s' on "DFID" -> %d\n",
+ LL_IT2STR(it), len, name, PFID(pid), i);
rc = lmv_check_connect(obd);
if (rc)
struct lookup_intent it;
int master = 0;
- CDEBUG(D_OTHER, "revalidate subobj "DFID3"\n",
- PFID3(&fid));
+ CDEBUG(D_OTHER, "revalidate subobj "DFID"\n",
+ PFID(&fid));
memset(op_data, 0, sizeof(*op_data));
memset(&it, 0, sizeof(it));
rc = obd_fid_alloc(lmv->tgts[mds].ltd_exp, fid, hint);
/* client switches to new sequence, setup fld */
- if (rc == -ERESTART) {
+ if (rc > 0) {
+ LASSERT(fid_is_sane(fid));
+
rc = fld_client_create(&lmv->lmv_fld,
fid_seq(fid),
mds);
LASSERT(exp && fid);
if (lmv_obj_delete(exp, fid)) {
- CDEBUG(D_OTHER, "lmv object "DFID3" is destroyed.\n",
- PFID3(fid));
+ CDEBUG(D_OTHER, "lmv object "DFID" is destroyed.\n",
+ PFID(fid));
}
RETURN(0);
}
obj = lmv_obj_grab(obd, fid);
- CDEBUG(D_OTHER, "GETATTR for "DFID3" %s\n",
- PFID3(fid), obj ? "(splitted)" : "");
+ CDEBUG(D_OTHER, "GETATTR for "DFID" %s\n",
+ PFID(fid), obj ? "(splitted)" : "");
/* if object is splitted, then we loop over all the slaves and gather
* size attribute. In ideal world we would have to gather also mds field
if (rc)
RETURN(rc);
- CDEBUG(D_OTHER, "CBDATA for "DFID3"\n", PFID3(fid));
+ CDEBUG(D_OTHER, "CBDATA for "DFID"\n", PFID(fid));
/* with CMD every object can have two locks in different namespaces:
* lookup lock in space of mds storing direntry and update/open lock in
RETURN(i);
LASSERT(i < lmv->desc.ld_tgt_count);
- CDEBUG(D_OTHER, "CLOSE "DFID3"\n", PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "CLOSE "DFID"\n", PFID(&op_data->fid1));
rc = md_close(lmv->tgts[i].ltd_exp, op_data, och, request);
RETURN(rc);
}
lmv_obj_put(obj);
}
- CDEBUG(D_OTHER, "CREATE '%*s' on "DFID3"\n", op_data->namelen,
- op_data->name, PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "CREATE '%*s' on "DFID"\n", op_data->namelen,
+ op_data->name, PFID(&op_data->fid1));
mds = lmv_fld_lookup(obd, &op_data->fid1);
if (mds < 0)
if (body == NULL)
RETURN(-ENOMEM);
- CDEBUG(D_OTHER, "created. "DFID3"\n", PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "created. "DFID"\n", PFID(&op_data->fid1));
} else if (rc == -ERESTART) {
/* directory got splitted. time to update local object and
* repeat the request with proper MDS. */
lockmode, op_data2, lockh + i, lmm, lmmsize,
cb_compl, cb_blocking, cb_data, 0);
- CDEBUG(D_OTHER, "take lock on slave "DFID3" -> %d/%d\n",
- PFID3(&mea->mea_ids[i]), rc, it->d.lustre.it_status);
+ CDEBUG(D_OTHER, "take lock on slave "DFID" -> %d/%d\n",
+ PFID(&mea->mea_ids[i]), rc, it->d.lustre.it_status);
if (rc)
GOTO(cleanup, rc);
if (it->d.lustre.it_data) {
if (!(body->valid & OBD_MD_MDS))
RETURN(0);
- CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID3" -> "DFID3"\n",
- LL_IT2STR(it), PFID3(&op_data->fid1), PFID3(&body->fid1));
+ CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID" -> "DFID"\n",
+ LL_IT2STR(it), PFID(&op_data->fid1), PFID(&body->fid1));
/* we got LOOKUP lock, but we really need attrs */
pmode = it->d.lustre.it_lock_mode;
lmv_obj_put(obj);
}
}
- CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID3"\n", LL_IT2STR(it),
- PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID"\n", LL_IT2STR(it),
+ PFID(&op_data->fid1));
mds = lmv_fld_lookup(obd, &op_data->fid1);
if (mds < 0)
lmv_obj_put(obj);
}
- CDEBUG(D_OTHER, "getattr_lock for %*s on "DFID3" -> "DFID3"\n",
- namelen, filename, PFID3(fid), PFID3(&rid));
+ CDEBUG(D_OTHER, "getattr_lock for %*s on "DFID" -> "DFID"\n",
+ namelen, filename, PFID(fid), PFID(&rid));
mds = lmv_fld_lookup(obd, &rid);
if (mds < 0)
struct ptlrpc_request *req = NULL;
rid = body->fid1;
- CDEBUG(D_OTHER, "request attrs for "DFID3"\n", PFID3(&rid));
+ CDEBUG(D_OTHER, "request attrs for "DFID"\n", PFID(&rid));
/*
* XXX check for error.
if (mds < 0)
RETURN(mds);
- CDEBUG(D_OTHER,"link "DFID3":%*s to "DFID3"\n",
- PFID3(&op_data->fid2), op_data->namelen,
- op_data->name, PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER,"link "DFID":%*s to "DFID"\n",
+ PFID(&op_data->fid2), op_data->namelen,
+ op_data->name, PFID(&op_data->fid1));
} else {
mds = lmv_fld_lookup(obd, &op_data->fid1);
if (mds < 0)
RETURN(mds);
/* request from MDS to acquire i_links for inode by fid1 */
- CDEBUG(D_OTHER, "inc i_nlinks for "DFID3"\n",
- PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "inc i_nlinks for "DFID"\n",
+ PFID(&op_data->fid1));
}
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n",
- mds, PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n",
+ mds, PFID(&op_data->fid1));
rc = md_link(lmv->tgts[mds].ltd_exp, op_data, request);
RETURN(rc);
int rc, mds, mds2;
ENTRY;
- CDEBUG(D_OTHER, "rename %*s in "DFID3" to %*s in "DFID3"\n",
- oldlen, old, PFID3(&op_data->fid1), newlen, new,
- PFID3(&op_data->fid2));
+ CDEBUG(D_OTHER, "rename %*s in "DFID" to %*s in "DFID"\n",
+ oldlen, old, PFID(&op_data->fid1), newlen, new,
+ PFID(&op_data->fid2));
rc = lmv_check_connect(obd);
if (rc)
* there.
*/
CDEBUG(D_OTHER,
- "create %*s(%d/%d) in "DFID3" pointing "
- "to "DFID3"\n", newlen, new, oldlen, newlen,
- PFID3(&op_data->fid2), PFID3(&op_data->fid1));
+ "create %*s(%d/%d) in "DFID" pointing "
+ "to "DFID"\n", newlen, new, oldlen, newlen,
+ PFID(&op_data->fid2), PFID(&op_data->fid1));
mds = lmv_fld_lookup(obd, &op_data->fid2);
if (mds < 0)
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
op_data->fid2 = obj->lo_inodes[mds].li_fid;
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
- PFID3(&op_data->fid2));
+ CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n", mds,
+ PFID(&op_data->fid2));
lmv_obj_put(obj);
}
goto request;
mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)old, oldlen);
op_data->fid1 = obj->lo_inodes[mds].li_fid;
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
- PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n", mds,
+ PFID(&op_data->fid1));
lmv_obj_put(obj);
}
(char *)new, newlen);
op_data->fid2 = obj->lo_inodes[mds].li_fid;
- CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
- PFID3(&op_data->fid2));
+ CDEBUG(D_OTHER, "forward to MDS #%u ("DFID")\n", mds,
+ PFID(&op_data->fid2));
lmv_obj_put(obj);
}
RETURN(mds2);
if (mds != mds2) {
- CDEBUG(D_OTHER,"cross-node rename "DFID3"/%*s to "DFID3"/%*s\n",
- PFID3(&op_data->fid1), oldlen, old, PFID3(&op_data->fid2),
+ CDEBUG(D_OTHER,"cross-node rename "DFID"/%*s to "DFID"/%*s\n",
+ PFID(&op_data->fid1), oldlen, old, PFID(&op_data->fid2),
newlen, new);
}
obj = lmv_obj_grab(obd, &op_data->fid1);
- CDEBUG(D_OTHER, "SETATTR for "DFID3", valid 0x%x%s\n",
- PFID3(&op_data->fid1), iattr->ia_valid, obj ? ", splitted" : "");
+ CDEBUG(D_OTHER, "SETATTR for "DFID", valid 0x%x%s\n",
+ PFID(&op_data->fid1), iattr->ia_valid, obj ? ", splitted" : "");
if (obj) {
for (i = 0; i < obj->lo_objcount; i++) {
obj = lock->l_ast_data;
if (obj) {
CDEBUG(D_OTHER, "cancel %s on "LPU64"/"LPU64
- ", master "DFID3"\n",
+ ", master "DFID"\n",
lock->l_resource->lr_name.name[3] == 1 ?
"LOOKUP" : "UPDATE",
lock->l_resource->lr_name.name[0],
lock->l_resource->lr_name.name[1],
- PFID3(&obj->lo_fid));
+ PFID(&obj->lo_fid));
lmv_obj_put(obj);
}
break;
if (i < 0)
RETURN(i);
LASSERT(i < lmv->desc.ld_tgt_count);
- CDEBUG(D_OTHER, "READPAGE at %llu from "DFID3"\n",
- offset, PFID3(&rid));
+ CDEBUG(D_OTHER, "READPAGE at %llu from "DFID"\n",
+ offset, PFID(&rid));
obj = lmv_obj_grab(obd, fid);
if (obj) {
lmv_obj_unlock(obj);
lmv_obj_put(obj);
- CDEBUG(D_OTHER, "forward to "DFID3" with offset %lu\n",
- PFID3(&rid), (unsigned long)offset);
+ CDEBUG(D_OTHER, "forward to "DFID" with offset %lu\n",
+ PFID(&rid), (unsigned long)offset);
}
i = lmv_fld_lookup(obd, &rid);
if (i < 0)
rc = md_unlink(lmv->tgts[mds].ltd_exp,
op_data2, req);
- CDEBUG(D_OTHER, "unlink slave "DFID3" -> %d\n",
- PFID3(&mea->mea_ids[i]), rc);
+ CDEBUG(D_OTHER, "unlink slave "DFID" -> %d\n",
+ PFID(&mea->mea_ids[i]), rc);
if (*req) {
ptlrpc_req_finished(*req);
op_data->fid1 = obj->lo_inodes[i].li_fid;
lmv_obj_put(obj);
}
- CDEBUG(D_OTHER, "unlink '%*s' in "DFID3" -> %u\n",
- op_data->namelen, op_data->name, PFID3(&op_data->fid1),
+ CDEBUG(D_OTHER, "unlink '%*s' in "DFID" -> %u\n",
+ op_data->namelen, op_data->name, PFID(&op_data->fid1),
i);
} else {
- CDEBUG(D_OTHER, "drop i_nlink on "DFID3"\n",
- PFID3(&op_data->fid1));
+ CDEBUG(D_OTHER, "drop i_nlink on "DFID"\n",
+ PFID(&op_data->fid1));
}
i = lmv_fld_lookup(obd, &op_data->fid1);
if (i < 0)
int i, rc = 0;
ENTRY;
- CDEBUG(D_OTHER, "lock match for "DFID3"\n", PFID3(fid));
+ CDEBUG(D_OTHER, "lock match for "DFID"\n", PFID(fid));
/* with CMD every object can have two locks in different namespaces:
* lookup lock in space of mds storing direntry and update/open lock in
/* put all ids in */
for (i = 0; i < mea->mea_count; i++) {
- CDEBUG(D_OTHER, "subobj "DFID3"\n",
- PFID3(&mea->mea_ids[i]));
+ CDEBUG(D_OTHER, "subobj "DFID"\n",
+ PFID(&mea->mea_ids[i]));
obj->lo_inodes[i].li_fid = mea->mea_ids[i];
LASSERT(fid_is_sane(&obj->lo_inodes[i].li_fid));
}
if (atomic_dec_and_test(&obj->lo_count)) {
struct lu_fid *fid = &obj->lo_fid;
- CDEBUG(D_OTHER, "last reference to "DFID3" - "
- "destroying\n", PFID3(fid));
+ CDEBUG(D_OTHER, "last reference to "DFID" - "
+ "destroying\n", PFID(fid));
__lmv_obj_del(obj);
}
}
spin_unlock(&obj_list_lock);
- CDEBUG(D_OTHER, "new obj in lmv cache: "DFID3"\n",
- PFID3(fid));
+ CDEBUG(D_OTHER, "new obj in lmv cache: "DFID"\n",
+ PFID(fid));
RETURN(new);
int mealen, rc, mds;
ENTRY;
- CDEBUG(D_OTHER, "get mea for "DFID3" and create lmv obj\n",
- PFID3(fid));
+ CDEBUG(D_OTHER, "get mea for "DFID" and create lmv obj\n",
+ PFID(fid));
md.mea = NULL;
/* got mea, now create obj for it. */
obj = __lmv_obj_create(obd, fid, mea);
if (!obj) {
- CERROR("Can't create new object "DFID3"\n",
- PFID3(fid));
+ CERROR("Can't create new object "DFID"\n",
+ PFID(fid));
GOTO(cleanup, obj = ERR_PTR(-ENOMEM));
}
obj->lo_state |= O_FREEING;
if (atomic_read(&obj->lo_count) > 1) {
- CERROR("obj "DFID3" has count > 1 (%d)\n",
- PFID3(&obj->lo_fid), atomic_read(&obj->lo_count));
+ CERROR("obj "DFID" has count > 1 (%d)\n",
+ PFID(&obj->lo_fid), atomic_read(&obj->lo_count));
}
__lmv_obj_put(obj);
}
ENTRY;
LASSERT(it);
- CDEBUG(D_DLMTRACE, "(name: %.*s,"DFID3") in obj "DFID3
+ CDEBUG(D_DLMTRACE, "(name: %.*s,"DFID") in obj "DFID
", intent: %s flags %#o\n",
- op_data->namelen, op_data->name, PFID3(&op_data->fid2),
- PFID3(&op_data->fid1), ldlm_it2str(it->it_op), it->it_flags);
+ op_data->namelen, op_data->name, PFID(&op_data->fid2),
+ PFID(&op_data->fid1), ldlm_it2str(it->it_op), it->it_flags);
if (fid_is_sane(&op_data->fid2) &&
(it->it_op & (IT_LOOKUP | IT_GETATTR))) {
memcpy(rootfid, &body->fid1, sizeof(*rootfid));
- CDEBUG(D_NET, "root fid="DFID3", last_committed="LPU64
+ CDEBUG(D_NET, "root fid="DFID", last_committed="LPU64
", last_xid="LPU64"\n",
- PFID3(rootfid), req->rq_repmsg->last_committed,
+ PFID(rootfid), req->rq_repmsg->last_committed,
req->rq_repmsg->last_xid);
}
int rc, size[] = { sizeof(*body) };
ENTRY;
- CDEBUG(D_INODE, "object: "DFID3"\n", PFID3(fid));
+ CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid));
req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_READPAGE,
1, size, NULL);
rc = obd_create(lov_exp, oa, &lsm, NULL);
if (rc) {
if (rc > 0) {
- CERROR("create errro for "DFID3": %d \n",
- PFID3(mdo2fid(child)), rc);
+ CERROR("create errro for "DFID": %d \n",
+ PFID(mdo2fid(child)), rc);
rc = -EIO;
}
GOTO(out_oa, rc);
rc = obd_setattr(lov_exp, oa, lsm, NULL);
if (rc) {
- CERROR("error setting attrs for "DFID3": rc %d\n",
- PFID3(mdo2fid(child)), rc);
+ CERROR("error setting attrs for "DFID": rc %d\n",
+ PFID(mdo2fid(child)), rc);
if (rc > 0) {
- CERROR("obd_setattr for "DFID3" rc %d\n",
- PFID3(mdo2fid(child)), rc);
+ CERROR("obd_setattr for "DFID" rc %d\n",
+ PFID(mdo2fid(child)), rc);
rc = -EIO;
}
GOTO(out_oa, rc);
if (fid) {
b->fid1 = *fid;
b->valid |= OBD_MD_FLID;
- CDEBUG(D_INODE, ""DFID3": nlink=%d, mode=%o, size="LPU64"\n",
- PFID3(fid), b->nlink, b->mode, b->size);
+ CDEBUG(D_INODE, ""DFID": nlink=%d, mode=%o, size="LPU64"\n",
+ PFID(fid), b->nlink, b->mode, b->size);
}
}
repbody->valid |= OBD_MD_FLID;
GOTO(shrink, rc = 0);
} else if (rc){
- CERROR("getattr error for "DFID3": %d\n",
- PFID3(mdt_object_fid(o)), rc);
+ CERROR("getattr error for "DFID": %d\n",
+ PFID(mdt_object_fid(o)), rc);
RETURN(rc);
}
if (mdt_body_has_lov(la, reqbody)) {
if (/*ma->ma_lmm_size && */(ma->ma_valid & MA_LOV)) {
LASSERT(ma->ma_lmm_size);
- CDEBUG(D_INODE, "packing ea for "DFID3"\n",
- PFID3(mdt_object_fid(o)));
+ CDEBUG(D_INODE, "packing ea for "DFID"\n",
+ PFID(mdt_object_fid(o)));
mdt_dump_lmm(D_INFO, ma->ma_lmm);
repbody->eadatasize = ma->ma_lmm_size;
repbody->valid |= OBD_MD_FLEASIZE;
if (name == NULL)
RETURN(-EFAULT);
- CDEBUG(D_INODE, "getattr with lock for "DFID3"/%s, ldlm_rep = %p\n",
- PFID3(mdt_object_fid(parent)), name, ldlm_rep);
+ CDEBUG(D_INODE, "getattr with lock for "DFID"/%s, ldlm_rep = %p\n",
+ PFID(mdt_object_fid(parent)), name, ldlm_rep);
intent_set_disposition(ldlm_rep, DISP_LOOKUP_EXECD);
if (strlen(name) == 0) {
/* only getattr on the child. parent is on another node. */
intent_set_disposition(ldlm_rep, DISP_LOOKUP_POS);
child = parent;
- CDEBUG(D_INODE, "partial getattr_name child_fid = "DFID3
+ CDEBUG(D_INODE, "partial getattr_name child_fid = "DFID
", ldlm_rep=%p\n",
- PFID3(mdt_object_fid(child)), ldlm_rep);
+ PFID(mdt_object_fid(child)), ldlm_rep);
mdt_lock_handle_init(lhc);
lhc->mlh_mode = LCK_CR;
LDLM_DEBUG(lock, "we will return this lock client\n");
LASSERTF(fid_res_name_eq(mdt_object_fid(child),
&lock->l_resource->lr_name),
- "Lock res_id: %lu/%lu/%lu, Fid: "DFID3".\n",
+ "Lock res_id: %lu/%lu/%lu, Fid: "DFID".\n",
(unsigned long)res_id->name[0],
(unsigned long)res_id->name[1],
(unsigned long)res_id->name[2],
- PFID3(mdt_object_fid(child)));
+ PFID(mdt_object_fid(child)));
LDLM_LOCK_PUT(lock);
}
} else
result = PTR_ERR(obj);
} else {
- CERROR("Invalid fid: "DFID3"\n", PFID3(&body->fid1));
+ CERROR("Invalid fid: "DFID"\n", PFID(&body->fid1));
result = -EINVAL;
}
} else
if (ls->ls_control_seq != NULL) {
rc = seq_server_init(ls->ls_control_seq,
m->mdt_bottom, uuid,
- LUSTRE_SEQ_CTLR,
+ LUSTRE_SEQ_CONTROLLER,
ctx);
} else
rc = -ENOMEM;
if (ls->ls_server_seq != NULL) {
rc = seq_server_init(ls->ls_server_seq,
m->mdt_bottom, uuid,
- LUSTRE_SEQ_SRV,
+ LUSTRE_SEQ_SERVER,
ctx);
} else
rc = -ENOMEM;
int rc = 0;
ENTRY;
- CDEBUG(D_INODE, "object init, fid = "DFID3"\n",
- PFID3(lu_object_fid(o)));
+ CDEBUG(D_INODE, "object init, fid = "DFID"\n",
+ PFID(lu_object_fid(o)));
under = &d->mdt_child->md_lu_dev;
below = under->ld_ops->ldo_object_alloc(ctxt, o->lo_header, under);
ENTRY;
h = o->lo_header;
- CDEBUG(D_INODE, "object free, fid = "DFID3"\n",
- PFID3(lu_object_fid(o)));
+ CDEBUG(D_INODE, "object free, fid = "DFID"\n",
+ PFID(lu_object_fid(o)));
lu_object_fini(o);
lu_object_header_fini(h);
if (S_ISREG(la->la_mode) &&
la->la_nlink == 0 && mo->mot_header.loh_ref == 1) {
- CDEBUG(D_INODE, "Last reference is released on "DFID3"\n",
- PFID3(mdt_object_fid(mo)));
+ CDEBUG(D_INODE, "Last reference is released on "DFID"\n",
+ PFID(mdt_object_fid(mo)));
CDEBUG(D_INODE, "ma_valid = "LPX64"\n", ma->ma_valid);
repbody = req_capsule_server_get(&info->mti_pill,
rc = -ETXTBSY;
} else {
if (o->mot_io_epoch != 0) {
- CDEBUG(D_INODE, "continue epoch "LPU64" for "DFID3"\n",
- o->mot_io_epoch, PFID3(mdt_object_fid(o)));
+ CDEBUG(D_INODE, "continue epoch "LPU64" for "DFID"\n",
+ o->mot_io_epoch, PFID(mdt_object_fid(o)));
} else {
if (epoch > mdt->mdt_io_epoch)
mdt->mdt_io_epoch = epoch;
else
mdt->mdt_io_epoch++;
o->mot_io_epoch = mdt->mdt_io_epoch;
- CDEBUG(D_INODE, "starting epoch "LPU64" for "DFID3"\n",
- mdt->mdt_io_epoch, PFID3(mdt_object_fid(o)));
+ CDEBUG(D_INODE, "starting epoch "LPU64" for "DFID"\n",
+ mdt->mdt_io_epoch, PFID(mdt_object_fid(o)));
}
atomic_inc(&o->mot_writecount);
}
/*TODO: remove this and add MDS_CHECK_RESENT if resent enabled*/
LASSERT(info->mti_pill.rc_fmt == &RQF_LDLM_INTENT_OPEN);
- CDEBUG(D_INODE, "I am going to create "DFID3"/("DFID3":%s) "
+ CDEBUG(D_INODE, "I am going to create "DFID"/("DFID":%s) "
"cr_flag=%x mode=%06o\n",
- PFID3(rr->rr_fid1), PFID3(rr->rr_fid2),
+ PFID(rr->rr_fid1), PFID(rr->rr_fid2),
rr->rr_name, create_flags, la->la_mode);
ldlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
mfd = mdt_handle2mfd(&(info->mti_body->handle));
if (mfd == NULL) {
spin_unlock(&med->med_open_lock);
- CDEBUG(D_INODE, "no handle for file close: fid = "DFID3
- ": cookie = "LPX64"\n", PFID3(&info->mti_body->fid1),
+ CDEBUG(D_INODE, "no handle for file close: fid = "DFID
+ ": cookie = "LPX64"\n", PFID(&info->mti_body->fid1),
info->mti_body->handle.cookie);
rc = -ESTALE;
} else {
ENTRY;
- DEBUG_REQ(D_INODE, req, "setattr "DFID3" %x", PFID3(rr->rr_fid1),
+ DEBUG_REQ(D_INODE, req, "setattr "DFID" %x", PFID(rr->rr_fid1),
(unsigned int)attr->la_valid);
/*pack the reply*/
int rc;
ENTRY;
- DEBUG_REQ(D_INODE, req, "unlink "DFID3"/%s\n", PFID3(rr->rr_fid1),
+ DEBUG_REQ(D_INODE, req, "unlink "DFID"/%s\n", PFID(rr->rr_fid1),
rr->rr_name);
/*pack the reply*/
req_capsule_set_size(&info->mti_pill, &RMF_MDT_MD, RCL_SERVER,
ENTRY;
- DEBUG_REQ(D_INODE, req, "link original "DFID3" to "DFID3" %s",
- PFID3(rr->rr_fid1), PFID3(rr->rr_fid2), rr->rr_name);
+ DEBUG_REQ(D_INODE, req, "link original "DFID" to "DFID" %s",
+ PFID(rr->rr_fid1), PFID(rr->rr_fid2), rr->rr_name);
/* MDS_CHECK_RESENT here */
ENTRY;
- DEBUG_REQ(D_INODE, req, "rename_tgt "DFID3" to "DFID3" %s",
- PFID3(rr->rr_fid2),
- PFID3(rr->rr_fid1), rr->rr_tgt);
+ DEBUG_REQ(D_INODE, req, "rename_tgt "DFID" to "DFID" %s",
+ PFID(rr->rr_fid2),
+ PFID(rr->rr_fid1), rr->rr_tgt);
/* step 1: lookup & lock the tgt dir */
lh_tgt = &info->mti_lh[MDT_LH_CHILD];
ENTRY;
- DEBUG_REQ(D_INODE, req, "rename "DFID3"/%s to "DFID3"/%s",
- PFID3(rr->rr_fid1), rr->rr_name,
- PFID3(rr->rr_fid2), rr->rr_tgt);
+ DEBUG_REQ(D_INODE, req, "rename "DFID"/%s to "DFID"/%s",
+ PFID(rr->rr_fid1), rr->rr_name,
+ PFID(rr->rr_fid2), rr->rr_tgt);
/* MDS_CHECK_RESENT here */
LASSERT(lu_object_assert_exists(info->mti_ctxt,
&info->mti_object->mot_obj.mo_lu));
- CDEBUG(D_INODE, "getxattr "DFID3"\n",
- PFID3(&info->mti_body->fid1));
+ CDEBUG(D_INODE, "getxattr "DFID"\n",
+ PFID(&info->mti_body->fid1));
if (MDT_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK))
RETURN(-ENOMEM);
int rc;
ENTRY;
- CDEBUG(D_INODE, "setxattr "DFID3"\n", PFID3(&body->fid1));
+ CDEBUG(D_INODE, "setxattr "DFID"\n", PFID(&body->fid1));
if (MDT_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
RETURN(-ENOMEM);
void *cookie, lu_printer_t printer,
const struct lu_object_header *hdr)
{
- (*printer)(ctx, cookie, "header@%p[%#lx, %d, "DFID3"%s%s]",
- hdr, hdr->loh_flags, hdr->loh_ref, PFID3(&hdr->loh_fid),
+ (*printer)(ctx, cookie, "header@%p[%#lx, %d, "DFID"%s%s]",
+ hdr, hdr->loh_flags, hdr->loh_ref, PFID(&hdr->loh_fid),
hlist_unhashed(&hdr->loh_hash) ? "" : " hash",
list_empty(&hdr->loh_lru) ? "" : " lru");
}
*/
hash = *(__u32 *)(name - sizeof(__u16) - sizeof(__u32));
*end = hash;
- CERROR("%p %p %d "DFID3": %#8.8x (%d)\"%*.*s\"\n",
- area, ent, nob, PFID3(fid), hash, len, len, len, name);
+ CERROR("%p %p %d "DFID": %#8.8x (%d)\"%*.*s\"\n",
+ area, ent, nob, PFID(fid), hash, len, len, len, name);
if (nob >= recsize) {
ent->lde_fid = *fid;
ent->lde_hash = hash;
git://git.whamcloud.com / fs / lustre-release.git / commitdiff