*seqnr = seq->lcs_space.lsr_start;
seq->lcs_space.lsr_start += 1;
- CDEBUG(D_INFO, "%s: Allocated sequence ["LPX64"]\n", seq->lcs_name,
+ CDEBUG(D_INFO, "%s: Allocated sequence [%#llx]\n", seq->lcs_name,
*seqnr);
RETURN(rc);
mutex_lock(&seq->lcs_mutex);
if (seqnr != 0) {
- CDEBUG(D_INFO, "%s: New sequence [0x%16.16"LPF64"x]\n",
+ CDEBUG(D_INFO, "%s: New sequence [0x%16.16llx]\n",
seq->lcs_name, seqnr);
seq->lcs_fid.f_seq = seqnr;
LASSERT(seq != NULL);
mutex_lock(&seq->lss_mutex);
- seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n", PRANGE(&seq->lss_space));
+ seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lss_space));
mutex_unlock(&seq->lss_mutex);
RETURN(0);
seq->lss_width = val;
- CDEBUG(D_INFO, "%s: Width: "LPU64"\n",
+ CDEBUG(D_INFO, "%s: Width: %llu\n",
seq->lss_name, seq->lss_width);
out_unlock:
mutex_unlock(&seq->lss_mutex);
LASSERT(seq != NULL);
mutex_lock(&seq->lss_mutex);
- seq_printf(m, LPU64"\n", seq->lss_width);
+ seq_printf(m, "%llu\n", seq->lss_width);
mutex_unlock(&seq->lss_mutex);
RETURN(0);
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
- seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n",
+ seq_printf(m, "[%#llx - %#llx]:%x:%s\n",
PRANGE(&seq->lcs_space));
mutex_unlock(&seq->lcs_mutex);
if (val <= max && val > 0) {
seq->lcs_width = val;
- CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
+ CDEBUG(D_INFO, "%s: Sequence size: %llu\n",
seq->lcs_name, seq->lcs_width);
} else {
GOTO(out_unlock, count = -ERANGE);
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
- seq_printf(m, LPU64"\n", seq->lcs_width);
+ seq_printf(m, "%llu\n", seq->lcs_width);
mutex_unlock(&seq->lcs_mutex);
RETURN(0);
}
CDEBUG(D_INFO, "FLD cache statistics (%s):\n", cache->fci_name);
- CDEBUG(D_INFO, " Total reqs: "LPU64"\n", cache->fci_stat.fst_count);
- CDEBUG(D_INFO, " Cache reqs: "LPU64"\n", cache->fci_stat.fst_cache);
- CDEBUG(D_INFO, " Cache hits: "LPU64"%%\n", pct);
+ CDEBUG(D_INFO, " Total reqs: %llu\n", cache->fci_stat.fst_count);
+ CDEBUG(D_INFO, " Cache reqs: %llu\n", cache->fci_stat.fst_cache);
+ CDEBUG(D_INFO, " Cache hits: %llu%%\n", pct);
OBD_FREE_PTR(cache);
if (index == 0 && rc == LDD_F_SV_TYPE_MDT) {
/* On server side, all entries should be in cache.
* If we can not find it in cache, just return error */
- CERROR("%s: Cannot find sequence "LPX64": rc = %d\n",
+ CERROR("%s: Cannot find sequence %#llx: rc = %d\n",
fld->lsf_name, seq, -ENOENT);
RETURN(-ENOENT);
} else {
if (fld->lsf_control_exp == NULL) {
- CERROR("%s: lookup "LPX64", but not connects to MDT0"
+ CERROR("%s: lookup %#llx, but not connects to MDT0"
"yet: rc = %d.\n", fld->lsf_name, seq, -EIO);
RETURN(-EIO);
}
rc = -ENOENT;
}
- CDEBUG(D_INFO, "%s: lookup seq = "LPX64" range : "DRANGE" rc = %d\n",
+ CDEBUG(D_INFO, "%s: lookup seq = %#llx range : "DRANGE" rc = %d\n",
fld->lsf_name, seq, PRANGE(range), rc);
RETURN(rc);
goto again;
}
- CERROR("%s: Can't find target by hash %d (seq "LPX64"). "
+ CERROR("%s: Can't find target by hash %d (seq %#llx). "
"Targets (%d):\n", fld->lcf_name, hash, seq,
fld->lcf_count);
(char *)target->ft_exp->exp_obd->obd_uuid.uuid :
"<null>";
- CERROR(" exp: 0x%p (%s), srv: 0x%p (%s), idx: "LPU64"\n",
+ CERROR(" exp: 0x%p (%s), srv: 0x%p (%s), idx: %llu\n",
target->ft_exp, exp_name, target->ft_srv,
srv_name, target->ft_idx);
}
spin_unlock(&fld->lcf_lock);
if (target != NULL) {
- CDEBUG(D_INFO, "%s: Found target (idx "LPU64
- ") by seq "LPX64"\n", fld->lcf_name,
+ CDEBUG(D_INFO, "%s: Found target (idx %llu"
+ ") by seq %#llx\n", fld->lcf_name,
target->ft_idx, seq);
}
LASSERT(name != NULL);
LASSERT(tar->ft_srv != NULL || tar->ft_exp != NULL);
- CDEBUG(D_INFO, "%s: Adding target %s (idx "LPU64")\n", fld->lcf_name,
+ CDEBUG(D_INFO, "%s: Adding target %s (idx %llu)\n", fld->lcf_name,
name, tar->ft_idx);
OBD_ALLOC_PTR(target);
if (tmp->ft_idx == tar->ft_idx) {
spin_unlock(&fld->lcf_lock);
OBD_FREE_PTR(target);
- CERROR("Target %s exists in FLD and known as %s:#"LPU64"\n",
+ CERROR("Target %s exists in FLD and known as %s:#%llu\n",
name, fld_target_name(tmp), tmp->ft_idx);
RETURN(-EEXIST);
}
LASSERT(target != NULL);
origin = target;
again:
- CDEBUG(D_INFO, "%s: Lookup fld entry (seq: "LPX64") on "
- "target %s (idx "LPU64")\n", fld->lcf_name, seq,
+ CDEBUG(D_INFO, "%s: Lookup fld entry (seq: %#llx) on "
+ "target %s (idx %llu)\n", fld->lcf_name, seq,
fld_target_name(target), target->ft_idx);
res.lsr_start = seq;
fid->f_seq = fid_idif_seq(0, ost_idx);
} else {
LASSERTF(fid_seq_is_norm(seq) || fid_seq_is_echo(seq) ||
- fid_seq_is_idif(seq), LPX64"\n", seq);
+ fid_seq_is_idif(seq), "%#llx\n", seq);
fid->f_seq = seq;
}
fid->f_oid = 0;
OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, statfs);
- CDEBUG(D_SUPER, "%s: osfs %p age "LPU64", max_age "LPU64"\n",
+ CDEBUG(D_SUPER, "%s: osfs %p age %llu, max_age %llu\n",
obd->obd_name, &obd->obd_osfs, obd->obd_osfs_age, max_age);
if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
rc = OBP(obd, statfs_async)(exp, oinfo, max_age, rqset);
} else {
- CDEBUG(D_SUPER,"%s: use %p cache blocks "LPU64"/"LPU64
- " objects "LPU64"/"LPU64"\n",
+ CDEBUG(D_SUPER, "%s: use %p cache blocks %llu/%llu objects %llu/%llu\n",
obd->obd_name, &obd->obd_osfs,
obd->obd_osfs.os_bavail, obd->obd_osfs.os_blocks,
obd->obd_osfs.os_ffree, obd->obd_osfs.os_files);
OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, statfs);
- CDEBUG(D_SUPER, "osfs "LPU64", max_age "LPU64"\n",
+ CDEBUG(D_SUPER, "osfs %llu, max_age %llu\n",
obd->obd_osfs_age, max_age);
if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
rc = OBP(obd, statfs)(env, exp, osfs, max_age, flags);
spin_unlock(&obd->obd_osfs_lock);
}
} else {
- CDEBUG(D_SUPER, "%s: use %p cache blocks "LPU64"/"LPU64
- " objects "LPU64"/"LPU64"\n",
+ CDEBUG(D_SUPER, "%s: use %p cache blocks %llu/%llu"
+ " objects %llu/%llu\n",
obd->obd_name, &obd->obd_osfs,
obd->obd_osfs.os_bavail, obd->obd_osfs.os_blocks,
obd->obd_osfs.os_ffree, obd->obd_osfs.os_files);
if (unlikely((ptr) == NULL)) { \
CERROR("vmalloc of '" #ptr "' (%d bytes) failed\n", \
(int)(size)); \
- CERROR(LPU64" total bytes allocated by Lustre, %d by LNET\n", \
+ CERROR("%llu total bytes allocated by Lustre, %d by LNET\n", \
obd_memory_sum(), atomic_read(&libcfs_kmemory)); \
} else { \
OBD_ALLOC_POST(ptr, size, "vmalloced"); \
new_ex->start = ((new_ex->start - 1) | mask) + 1;
new_ex->end = ((new_ex->end + 1) & ~mask) - 1;
LASSERTF(new_ex->start <= req_start,
- "mask "LPX64" grant start "LPU64" req start "LPU64"\n",
+ "mask %#llx grant start %llu req start %llu\n",
mask, new_ex->start, req_start);
LASSERTF(new_ex->end >= req_end,
- "mask "LPX64" grant end "LPU64" req end "LPU64"\n",
+ "mask %#llx grant end %llu req end %llu\n",
mask, new_ex->end, req_end);
}
res = ldlm_resource_get(arg->lpa_export->exp_obd->obd_namespace, NULL,
&arg->lpa_resid, LDLM_EXTENT, 0);
if (IS_ERR(res)) {
- CDEBUG(D_DLMTRACE, "Failed to get resource for resid "LPU64"/"
- LPU64"\n", arg->lpa_resid.name[0],
- arg->lpa_resid.name[1]);
+ CDEBUG(D_DLMTRACE, "Failed to get resource for resid %llu/%llu\n",
+ arg->lpa_resid.name[0], arg->lpa_resid.name[1]);
RETURN_EXIT;
}
if (lck->l_policy_data.l_extent.end + 1 > kms)
kms = lck->l_policy_data.l_extent.end + 1;
}
- LASSERTF(kms <= old_kms, "kms "LPU64" old_kms "LPU64"\n", kms, old_kms);
+ LASSERTF(kms <= old_kms, "kms %llu old_kms %llu\n", kms, old_kms);
RETURN(kms);
}
{
ENTRY;
- LDLM_DEBUG(lock, "ldlm_flock_destroy(mode: %d, flags: "LPX64")",
+ LDLM_DEBUG(lock, "ldlm_flock_destroy(mode: %d, flags: %#llx)",
mode, flags);
/* Safe to not lock here, since it should be empty anyway */
const struct ldlm_callback_suite null_cbs = { NULL };
ENTRY;
- CDEBUG(D_DLMTRACE, "flags "LPX64" owner "LPU64" pid %u mode %u start "
- LPU64" end "LPU64"\n", *flags,
+ CDEBUG(D_DLMTRACE, "flags %#llx owner %llu pid %u mode %u start "
+ "%llu end %llu\n", *flags,
new->l_policy_data.l_flock.owner,
new->l_policy_data.l_flock.pid, mode,
req->l_policy_data.l_flock.start,
unlock_res_and_lock(lock);
OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CP_CB_WAIT3, 4);
}
- CDEBUG(D_DLMTRACE, "flags: "LPX64" data: %p getlk: %p\n",
+ CDEBUG(D_DLMTRACE, "flags: %#llx data: %p getlk: %p\n",
flags, data, getlk);
LASSERT(flags != LDLM_FL_WAIT_NOREPROC);
if (data) {
LASSERTF((ocd->ocd_connect_flags & data->ocd_connect_flags) ==
- ocd->ocd_connect_flags, "old "LPX64", new "LPX64"\n",
+ ocd->ocd_connect_flags, "old %#llx, new %#llx\n",
data->ocd_connect_flags, ocd->ocd_connect_flags);
data->ocd_connect_flags = ocd->ocd_connect_flags;
/* clear the flag as it was not set and is not known
ENTRY;
if (!obd) {
- CERROR("invalid export for disconnect: exp %p cookie "LPX64"\n",
+ CERROR("invalid export for disconnect: exp %p cookie %#llx\n",
exp, exp ? exp->exp_handle.h_cookie : -1);
RETURN(-EINVAL);
}
if (!exp->exp_connection || !lustre_handle_is_used(hdl)) {
conn->cookie = exp->exp_handle.h_cookie;
CDEBUG(D_HA, "connect export for UUID '%s' at %p,"
- " cookie "LPX64"\n", cluuid->uuid, exp, conn->cookie);
+ " cookie %#llx\n", cluuid->uuid, exp, conn->cookie);
RETURN(0);
}
/* Might be a re-connect after a partition. */
if (memcmp(&conn->cookie, &hdl->cookie, sizeof conn->cookie)) {
LCONSOLE_WARN("%s: already connected client %s (at %s) "
- "with handle "LPX64". Rejecting client "
+ "with handle %#llx. Rejecting client "
"with the same UUID trying to reconnect "
- "with handle "LPX64"\n", target->obd_name,
+ "with handle %#llx\n", target->obd_name,
obd_uuid2str(&exp->exp_client_uuid),
obd_export_nid2str(exp),
hdl->cookie, conn->cookie);
GOTO(out, rc);
}
- CDEBUG(D_HA, "%s: connection from %s@%s %st"LPU64" exp %p cur %ld last %ld\n",
+ CDEBUG(D_HA, "%s: connection from %s@%s %st%llu exp %p cur %ld last %ld\n",
target->obd_name, cluuid.uuid, libcfs_nid2str(req->rq_peer.nid),
target->obd_recovering ? "recovering/" : "", data->ocd_transno,
export, (long)cfs_time_current_sec(),
next_transno = obd->obd_next_recovery_transno;
CDEBUG(D_HA, "max: %d, connected: %d, completed: %d, queue_len: %d, "
- "req_transno: "LPU64", next_transno: "LPU64"\n",
+ "req_transno: %llu, next_transno: %llu\n",
obd->obd_max_recoverable_clients, connected, completed,
queue_len, req_transno, next_transno);
wake_up = 1;
} else if (tdtd != NULL && req != NULL &&
is_req_replayed_by_update(req)) {
- LASSERTF(req_transno < next_transno, "req_transno "LPU64
- "next_transno"LPU64"\n", req_transno, next_transno);
- CDEBUG(D_HA, "waking for duplicate req ("LPU64")\n",
+ LASSERTF(req_transno < next_transno, "req_transno %llu"
+ "next_transno%llu\n", req_transno, next_transno);
+ CDEBUG(D_HA, "waking for duplicate req (%llu)\n",
req_transno);
wake_up = 1;
} else if (req_transno == next_transno ||
(update_transno != 0 && update_transno <= next_transno)) {
- CDEBUG(D_HA, "waking for next ("LPD64")\n", next_transno);
+ CDEBUG(D_HA, "waking for next (%lld)\n", next_transno);
wake_up = 1;
} else if (queue_len > 0 &&
queue_len == atomic_read(&obd->obd_req_replay_clients)) {
/** handle gaps occured due to lost reply or VBR */
LASSERTF(req_transno >= next_transno,
- "req_transno: "LPU64", next_transno: "LPU64"\n",
+ "req_transno: %llu, next_transno: %llu\n",
req_transno, next_transno);
CDEBUG(D_HA,
"%s: waking for gap in transno, VBR is %s (skip: "
- LPD64", ql: %d, comp: %d, conn: %d, next: "LPD64
- ", next_update "LPD64" last_committed: "LPD64")\n",
+ "%lld, ql: %d, comp: %d, conn: %d, next: %lld"
+ ", next_update %lld last_committed: %lld)\n",
obd->obd_name, obd->obd_version_recov ? "ON" : "OFF",
next_transno, queue_len, completed, connected,
req_transno, update_transno, obd->obd_last_committed);
wake_up = 1;
} else if (OBD_FAIL_CHECK(OBD_FAIL_MDS_RECOVERY_ACCEPTS_GAPS)) {
CDEBUG(D_HA, "accepting transno gaps is explicitly allowed"
- " by fail_lock, waking up ("LPD64")\n", next_transno);
+ " by fail_lock, waking up (%lld)\n", next_transno);
obd->obd_next_recovery_transno = req_transno;
wake_up = 1;
}
* clients */
abort_req_replay_queue(obd);
abort_lock_replay_queue(obd);
- CDEBUG(D_HA, "%s: there are still update replay ("LPX64
+ CDEBUG(D_HA, "%s: there are still update replay (%#llx"
")in the queue.\n", obd->obd_name,
next_update_transno);
} else {
struct obd_device *obd,
struct ptlrpc_request *req)
{
- DEBUG_REQ(D_HA, req, "remove t"LPD64" from %s because of duplicate"
+ DEBUG_REQ(D_HA, req, "remove t%lld from %s because of duplicate"
" update records are found.\n",
lustre_msg_get_transno(req->rq_reqmsg),
libcfs_nid2str(req->rq_peer.nid));
__u64 transno;
ENTRY;
- CDEBUG(D_HA, "Waiting for transno "LPD64"\n",
+ CDEBUG(D_HA, "Waiting for transno %lld\n",
obd->obd_next_recovery_transno);
/* Replay all of request and update by transno */
}
LASSERT(trd->trd_processing_task == current_pid());
- DEBUG_REQ(D_HA, req, "processing t"LPD64" from %s",
+ DEBUG_REQ(D_HA, req, "processing t%lld from %s",
lustre_msg_get_transno(req->rq_reqmsg),
libcfs_nid2str(req->rq_peer.nid));
extend_recovery_timer(obd, obd_timeout, true);
if (rc == 0 && dtrq->dtrq_xid != 0) {
- CDEBUG(D_HA, "Move x"LPU64" t"LPU64
+ CDEBUG(D_HA, "Move x%llu t%llu"
" to finish list\n", dtrq->dtrq_xid,
dtrq->dtrq_master_transno);
/* next stage: replay requests or update */
delta = jiffies;
- CDEBUG(D_INFO, "1: request replay stage - %d clients from t"LPU64"\n",
+ CDEBUG(D_INFO, "1: request replay stage - %d clients from t%llu\n",
atomic_read(&obd->obd_req_replay_clients),
obd->obd_next_recovery_transno);
replay_request_or_update(env, lut, trd, thread);
}
CDEBUG(D_HA, "RECOVERY: service %s, %d recoverable clients, "
- "last_transno "LPU64"\n", obd->obd_name,
+ "last_transno %llu\n", obd->obd_name,
obd->obd_max_recoverable_clients, obd->obd_last_committed);
LASSERT(obd->obd_stopping == 0);
obd->obd_next_recovery_transno = obd->obd_last_committed + 1;
* Also, a resent, replayed request that has already been
* handled will pass through here and be processed immediately.
*/
- CDEBUG(D_HA, "Next recovery transno: "LPU64
- ", current: "LPU64", replaying\n",
+ CDEBUG(D_HA, "Next recovery transno: %llu"
+ ", current: %llu, replaying\n",
obd->obd_next_recovery_transno, transno);
/* If the request has been replayed by update replay, then sends this
"%d)", exp->exp_obd->obd_no_transno,
req->rq_repmsg == NULL);
- CDEBUG(D_INFO, "last_committed "LPU64", transno "LPU64", xid "LPU64"\n",
+ CDEBUG(D_INFO, "last_committed %llu, transno %llu, xid %llu\n",
exp->exp_last_committed, req->rq_transno, req->rq_xid);
}
rs->rs_opc = lustre_msg_get_opc(req->rq_reqmsg);
spin_lock(&exp->exp_uncommitted_replies_lock);
- CDEBUG(D_NET, "rs transno = "LPU64", last committed = "LPU64"\n",
+ CDEBUG(D_NET, "rs transno = %llu, last committed = %llu\n",
rs->rs_transno, exp->exp_last_committed);
if (rs->rs_transno > exp->exp_last_committed) {
/* not committed already */
struct ldlm_lock *lock;
lock = ldlm_handle2lock(lockh);
- LASSERTF(lock != NULL, "Non-existing lock: "LPX64"\n", lockh->cookie);
+ LASSERTF(lock != NULL, "Non-existing lock: %#llx\n", lockh->cookie);
ldlm_lock_addref_internal(lock, mode);
LDLM_LOCK_PUT(lock);
}
void ldlm_lock_decref(const struct lustre_handle *lockh, enum ldlm_mode mode)
{
struct ldlm_lock *lock = __ldlm_handle2lock(lockh, 0);
- LASSERTF(lock != NULL, "Non-existing lock: "LPX64"\n", lockh->cookie);
+ LASSERTF(lock != NULL, "Non-existing lock: %#llx\n", lockh->cookie);
ldlm_lock_decref_internal(lock, mode);
LDLM_LOCK_PUT(lock);
}
}
out2:
if (rc) {
- LDLM_DEBUG(lock, "matched ("LPU64" "LPU64")",
+ LDLM_DEBUG(lock, "matched (%llu %llu)",
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
res_id->name[2] : policy->l_extent.start,
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
} else if (!(flags & LDLM_FL_TEST_LOCK)) {/*less verbose for test-only*/
LDLM_DEBUG_NOLOCK("not matched ns %p type %u mode %u res "
- LPU64"/"LPU64" ("LPU64" "LPU64")", ns,
+ "%llu/%llu (%llu %llu)", ns,
type, mode, res_id->name[0], res_id->name[1],
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
res_id->name[2] :policy->l_extent.start,
if (resource == NULL) {
libcfs_debug_vmsg2(msgdata, fmt, args,
- " ns: \?\? lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
- "res: \?\? rrc=\?\? type: \?\?\? flags: "LPX64" nid: %s "
- "remote: "LPX64" expref: %d pid: %u timeout: %lu "
+ " ns: \?\? lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s "
+ "res: \?\? rrc=\?\? type: \?\?\? flags: %#llx nid: %s "
+ "remote: %#llx expref: %d pid: %u timeout: %lu "
"lvb_type: %d\n",
lock,
lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
switch (resource->lr_type) {
case LDLM_EXTENT:
libcfs_debug_vmsg2(msgdata, fmt, args,
- " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
- "res: "DLDLMRES" rrc: %d type: %s ["LPU64"->"LPU64"] "
- "(req "LPU64"->"LPU64") flags: "LPX64" nid: %s remote: "
- LPX64" expref: %d pid: %u timeout: %lu lvb_type: %d\n",
+ " ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s "
+ "res: "DLDLMRES" rrc: %d type: %s [%llu->%llu] "
+ "(req %llu->%llu) flags: %#llx nid: %s remote: "
+ "%#llx expref: %d pid: %u timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock), lock,
lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
case LDLM_FLOCK:
libcfs_debug_vmsg2(msgdata, fmt, args,
- " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
+ " ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s "
"res: "DLDLMRES" rrc: %d type: %s pid: %d "
- "["LPU64"->"LPU64"] flags: "LPX64" nid: %s "
- "remote: "LPX64" expref: %d pid: %u timeout: %lu\n",
+ "[%llu->%llu] flags: %#llx nid: %s "
+ "remote: %#llx expref: %d pid: %u timeout: %lu\n",
ldlm_lock_to_ns_name(lock), lock,
lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
lock->l_readers, lock->l_writers,
case LDLM_IBITS:
libcfs_debug_vmsg2(msgdata, fmt, args,
- " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
- "res: "DLDLMRES" bits "LPX64" rrc: %d type: %s "
- "flags: "LPX64" nid: %s remote: "LPX64" expref: %d "
+ " ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s "
+ "res: "DLDLMRES" bits %#llx rrc: %d type: %s "
+ "flags: %#llx nid: %s remote: %#llx expref: %d "
"pid: %u timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock),
lock, lock->l_handle.h_cookie,
default:
libcfs_debug_vmsg2(msgdata, fmt, args,
- " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
- "res: "DLDLMRES" rrc: %d type: %s flags: "LPX64" "
- "nid: %s remote: "LPX64" expref: %d pid: %u "
+ " ns: %s lock: %p/%#llx lrc: %d/%d,%d mode: %s/%s "
+ "res: "DLDLMRES" rrc: %d type: %s flags: %#llx "
+ "nid: %s remote: %#llx expref: %d pid: %u "
"timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock),
lock, lock->l_handle.h_cookie,
if (!req->rq_replied || (rc && rc != -EINVAL)) {
if (lock->l_export && lock->l_export->exp_libclient) {
LDLM_DEBUG(lock,
- "%s AST (req@%p x"LPU64") to liblustre client (nid %s) timeout, just cancelling lock",
+ "%s AST (req@%p x%llu) to liblustre client (nid %s) timeout, just cancelling lock",
ast_type, req, req->rq_xid,
libcfs_nid2str(peer.nid));
ldlm_lock_cancel(lock);
rc = -ERESTART;
} else if (ldlm_is_cancel(lock)) {
LDLM_DEBUG(lock,
- "%s AST (req@%p x"LPU64") timeout from nid %s, but cancel was received (AST reply lost?)",
+ "%s AST (req@%p x%llu) timeout from nid %s, but cancel was received (AST reply lost?)",
ast_type, req, req->rq_xid,
libcfs_nid2str(peer.nid));
ldlm_lock_cancel(lock);
rc = -ERESTART;
} else {
LDLM_ERROR(lock,
- "client (nid %s) %s %s AST (req@%p x"LPU64" status %d rc %d), evict it",
+ "client (nid %s) %s %s AST (req@%p x%llu status %d rc %d), evict it",
libcfs_nid2str(peer.nid),
req->rq_replied ? "returned error from" :
"failed to reply to",
struct ldlm_resource *res = lock->l_resource;
LDLM_DEBUG(lock,
- "client (nid %s) returned %d from %s AST (req@%p x"LPU64") - normal race",
+ "client (nid %s) returned %d from %s AST (req@%p x%llu) - normal race",
libcfs_nid2str(peer.nid),
req->rq_repmsg ?
lustre_msg_get_status(req->rq_repmsg) : -1,
lock = cfs_hash_lookup(req->rq_export->exp_lock_hash,
(void *)&dlm_req->lock_handle[0]);
if (lock != NULL) {
- DEBUG_REQ(D_DLMTRACE, req, "found existing lock cookie "
- LPX64, lock->l_handle.h_cookie);
+ DEBUG_REQ(D_DLMTRACE, req, "found existing lock cookie %#llx",
+ lock->l_handle.h_cookie);
flags |= LDLM_FL_RESENT;
GOTO(existing_lock, rc = 0);
}
if (unlikely(!ldlm_is_cancel_on_block(lock) ||
!(dlm_rep->lock_flags & LDLM_FL_CANCEL_ON_BLOCK))){
CERROR("Granting sync lock to libclient. "
- "req fl %d, rep fl %d, lock fl "LPX64"\n",
+ "req fl %d, rep fl %d, lock fl %#llx\n",
dlm_req->lock_flags, dlm_rep->lock_flags,
lock->l_flags);
LDLM_ERROR(lock, "sync lock");
it = req_capsule_client_get(&req->rq_pill,
&RMF_LDLM_INTENT);
if (it != NULL) {
- CERROR("This is intent %s ("LPU64")\n",
+ CERROR("This is intent %s (%llu)\n",
ldlm_it2str(it->opc), it->opc);
}
}
lock = ldlm_handle2lock(&dlm_req->lock_handle[i]);
if (!lock) {
LDLM_DEBUG_NOLOCK("server-side cancel handler stale "
- "lock (cookie "LPU64")",
+ "lock (cookie %llu)",
dlm_req->lock_handle[i].cookie);
continue;
}
const struct lustre_handle *handle)
{
DEBUG_REQ((req->rq_no_reply || rc) ? D_WARNING : D_DLMTRACE, req,
- "%s: [nid %s] [rc %d] [lock "LPX64"]",
+ "%s: [nid %s] [rc %d] [lock %#llx]",
msg, libcfs_id2str(req->rq_peer), rc,
handle ? handle->cookie : 0);
if (req->rq_no_reply)
lock = ldlm_handle2lock_long(&dlm_req->lock_handle[0], 0);
if (!lock) {
- CDEBUG(D_DLMTRACE, "callback on lock "LPX64" - lock "
+ CDEBUG(D_DLMTRACE, "callback on lock %#llx - lock "
"disappeared\n", dlm_req->lock_handle[0].cookie);
rc = ldlm_callback_reply(req, -EINVAL);
ldlm_callback_errmsg(req, "Operate with invalid parameter", rc,
* should send cancel after dropping the cache. */
if ((ldlm_is_canceling(lock) && ldlm_is_bl_done(lock)) ||
ldlm_is_failed(lock)) {
- LDLM_DEBUG(lock, "callback on lock "
- LPX64" - lock disappeared",
+ LDLM_DEBUG(lock, "callback on lock %llx - lock disappeared",
dlm_req->lock_handle[0].cookie);
unlock_res_and_lock(lock);
LDLM_LOCK_RELEASE(lock);
struct ldlm_request *dlm_req;
CERROR("%s from %s arrived at %lu with bad export cookie "
- LPU64"\n",
+ "%llu\n",
ll_opcode2str(lustre_msg_get_opc(req->rq_reqmsg)),
libcfs_nid2str(req->rq_peer.nid),
req->rq_arrival_time.tv_sec,
if (lustre_handle_equal(&dlm_req->lock_handle[i],
&lockh)) {
DEBUG_REQ(D_RPCTRACE, req,
- "Prio raised by lock "LPX64".", lockh.cookie);
+ "Prio raised by lock %#llx.", lockh.cookie);
rc = 1;
break;
spin_unlock(&pl->pl_lock);
seq_printf(m, "LDLM pool state (%s):\n"
- " SLV: "LPU64"\n"
- " CLV: "LPU64"\n"
+ " SLV: %llu\n"
+ " CLV: %llu\n"
" LVF: %d\n",
pl->pl_name, slv, clv, lvf);
LDLM_FL_INHERIT_MASK);
unlock_res_and_lock(lock);
- CDEBUG(D_INFO, "local: %p, remote cookie: "LPX64", flags: "LPX64"\n",
+ CDEBUG(D_INFO, "local: %p, remote cookie: %#llx, flags: %#llx\n",
lock, reply->lock_handle.cookie, *flags);
/* If enqueue returned a blocked lock but the completion handler has
lock->l_req_extent = policy->l_extent;
}
- LDLM_DEBUG(lock, "client-side enqueue START, flags "LPX64,
+ LDLM_DEBUG(lock, "client-side enqueue START, flags %#llx",
*flags);
}
if (lustre_msg_get_slv(req->rq_repmsg) == 0 ||
lustre_msg_get_limit(req->rq_repmsg) == 0) {
DEBUG_REQ(D_HA, req, "Zero SLV or Limit found "
- "(SLV: "LPU64", Limit: %u)",
+ "(SLV: %llu, Limit: %u)",
lustre_msg_get_slv(req->rq_repmsg),
lustre_msg_get_limit(req->rq_repmsg));
RETURN(0);
res = ldlm_resource_get(ns, NULL, res_id, 0, 0);
if (IS_ERR(res)) {
/* This is not a problem. */
- CDEBUG(D_INFO, "No resource "LPU64"\n", res_id->name[0]);
+ CDEBUG(D_INFO, "No resource %llu\n", res_id->name[0]);
RETURN(0);
}
lock = ldlm_handle2lock(&aa->lock_handle);
if (!lock) {
- CERROR("received replay ack for unknown local cookie "LPX64
- " remote cookie "LPX64 " from server %s id %s\n",
+ CERROR("received replay ack for unknown local cookie %#llx"
+ " remote cookie %#llx from server %s id %s\n",
aa->lock_handle.cookie, reply->lock_handle.cookie,
req->rq_export->exp_client_uuid.uuid,
libcfs_id2str(req->rq_peer));
static int seq_watermark_show(struct seq_file *m, void *data)
{
- seq_printf(m, LPU64"\n", *(__u64 *)m->private);
+ seq_printf(m, "%llu\n", *(__u64 *)m->private);
return 0;
}
static int seq_granted_show(struct seq_file *m, void *data)
{
- seq_printf(m, LPU64"\n", percpu_counter_sum_positive(
+ seq_printf(m, "%llu\n", percpu_counter_sum_positive(
(struct percpu_counter *)m->private));
return 0;
}
handle.cookie = it->it_lock_handle;
- CDEBUG(D_DLMTRACE, "releasing lock with cookie "LPX64
- " from it %p\n", handle.cookie, it);
+ CDEBUG(D_DLMTRACE, "releasing lock with cookie %#llx from it %p\n",
+ handle.cookie, it);
ldlm_lock_decref(&handle, it->it_lock_mode);
/* bug 494: intent_release may be called multiple times, from
handle.cookie = it->it_remote_lock_handle;
CDEBUG(D_DLMTRACE, "releasing remote lock with cookie"
- LPX64" from it %p\n", handle.cookie, it);
+ "%#llx from it %p\n", handle.cookie, it);
ldlm_lock_decref(&handle,
it->it_remote_lock_mode);
it->it_remote_lock_mode = 0;
if (rc != 0) {
CDEBUG(D_HSM, "Could not read file data version of "
DFID" (rc = %d). Archive request ("
- LPX64") could not be done.\n",
+ "%#llx) could not be done.\n",
PFID(©->hc_hai.hai_fid), rc,
copy->hc_hai.hai_cookie);
hpk.hpk_flags |= HP_FLAG_RETRY;
(copy->hc_data_version != data_version)) {
CDEBUG(D_HSM, "File data version mismatched. "
"File content was changed during archiving. "
- DFID", start:"LPX64" current:"LPX64"\n",
+ DFID", start:%#llx current:%#llx\n",
PFID(©->hc_hai.hai_fid),
copy->hc_data_version, data_version);
/* File was changed, send error to cdt. Do not ask for
if (it.it_lock_mode == 0 ||
it.it_lock_bits != MDS_INODELOCK_OPEN) {
/* open lock must return for lease */
- CERROR(DFID "lease granted but no open lock, %d/"LPU64".\n",
+ CERROR(DFID "lease granted but no open lock, %d/%llu.\n",
PFID(ll_inode2fid(inode)), it.it_lock_mode,
it.it_lock_bits);
GOTO(out_close, rc = -EPROTO);
if (mtime < attr->cat_mtime)
mtime = attr->cat_mtime;
- CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
+ CDEBUG(D_VFSTRACE, DFID" updating i_size %llu\n",
PFID(&lli->lli_fid), attr->cat_size);
i_size_write(inode, attr->cat_size);
ENTRY;
- CDEBUG(D_VFSTRACE, "file: %s, type: %d ppos: "LPU64", count: %zu\n",
+ CDEBUG(D_VFSTRACE, "file: %s, type: %d ppos: %llu, count: %zu\n",
file_dentry(file)->d_name.name, iot, *ppos, count);
restart:
if (IS_ERR(op_data))
RETURN(PTR_ERR(op_data));
- CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags="LPX64", mode=%u, "
- "start="LPU64", end="LPU64"\n", PFID(ll_inode2fid(inode)),
+ CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags=%#llx, mode=%u, "
+ "start=%llu, end=%llu\n", PFID(ll_inode2fid(inode)),
flock.l_flock.pid, flags, einfo.ei_mode,
flock.l_flock.start, flock.l_flock.end);
cli = &watched->u.cli;
lco = owner;
flags = cli->cl_import->imp_connect_data.ocd_connect_flags;
- CDEBUG(D_SUPER, "Changing connect_flags: "LPX64" -> "LPX64"\n",
+ CDEBUG(D_SUPER, "Changing connect_flags: %#llx -> %#llx\n",
lco->lco_flags, flags);
mutex_lock(&lco->lco_lock);
lco->lco_flags &= flags;
if (it->it_remote_lock_mode) {
handle.cookie = it->it_remote_lock_handle;
CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID
- "(%p) for remote lock "LPX64"\n",
+ "(%p) for remote lock %#llx\n",
PFID(ll_inode2fid(inode)), inode,
handle.cookie);
md_set_lock_data(exp, &handle, inode, NULL);
handle.cookie = it->it_lock_handle;
CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID"(%p)"
- " for lock "LPX64"\n",
+ " for lock %#llx\n",
PFID(ll_inode2fid(inode)), inode, handle.cookie);
md_set_lock_data(exp, &handle, inode, &it->it_lock_bits);
if (sbi->ll_flags & LL_SBI_ALWAYS_PING)
data->ocd_connect_flags &= ~OBD_CONNECT_PINGLESS;
- CDEBUG(D_RPCTRACE, "ocd_connect_flags: "LPX64" ocd_version: %d "
+ CDEBUG(D_RPCTRACE, "ocd_connect_flags: %#llx ocd_version: %d "
"ocd_grant: %d\n", data->ocd_connect_flags,
data->ocd_version, data->ocd_grant);
* OST maximum object size and number of stripes. This
* needs another check in addition to the VFS check above. */
if (attr->ia_size > ll_file_maxbytes(inode)) {
- CDEBUG(D_INODE,"file "DFID" too large %llu > "LPU64"\n",
+ CDEBUG(D_INODE,"file "DFID" too large %llu > %llu\n",
PFID(&lli->lli_fid), attr->ia_size,
ll_file_maxbytes(inode));
RETURN(-EFBIG);
osfs->os_type = sb->s_magic;
- CDEBUG(D_SUPER, "MDC blocks "LPU64"/"LPU64" objects "LPU64"/"LPU64"\n",
+ CDEBUG(D_SUPER, "MDC blocks %llu/%llu objects %llu/%llu\n",
osfs->os_bavail, osfs->os_blocks, osfs->os_ffree,osfs->os_files);
if (sbi->ll_flags & LL_SBI_LAZYSTATFS)
RETURN(rc);
}
- CDEBUG(D_SUPER, "OSC blocks "LPU64"/"LPU64" objects "LPU64"/"LPU64"\n",
+ CDEBUG(D_SUPER, "OSC blocks %llu/%llu objects %llu/%llu\n",
obd_osfs.os_bavail, obd_osfs.os_blocks, obd_osfs.os_ffree,
obd_osfs.os_files);
__u64 fsid = huge_encode_dev(sb->s_dev);
int rc;
- CDEBUG(D_VFSTRACE, "VFS Op: at "LPU64" jiffies\n", get_jiffies_64());
+ CDEBUG(D_VFSTRACE, "VFS Op: at %llu jiffies\n", get_jiffies_64());
ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_STAFS, 1);
/* Some amount of caching on the client is allowed */
if (body->mbo_valid & OBD_MD_FLMTIME) {
if (body->mbo_mtime > LTIME_S(inode->i_mtime)) {
CDEBUG(D_INODE, "setting ino %lu mtime from %lu "
- "to "LPU64"\n", inode->i_ino,
+ "to %llu\n", inode->i_ino,
LTIME_S(inode->i_mtime), body->mbo_mtime);
LTIME_S(inode->i_mtime) = body->mbo_mtime;
}
obd = class_exp2obd(sbi->ll_md_exp);
if (obd == NULL) {
- CERROR("Invalid MDC connection handle "LPX64"\n",
+ CERROR("Invalid MDC connection handle %#llx\n",
sbi->ll_md_exp->exp_handle.h_cookie);
EXIT;
return;
obd = class_exp2obd(sbi->ll_dt_exp);
if (obd == NULL) {
- CERROR("Invalid LOV connection handle "LPX64"\n",
+ CERROR("Invalid LOV connection handle %#llx\n",
sbi->ll_dt_exp->exp_handle.h_cookie);
EXIT;
return;
int rc = -ENOENT;
ENTRY;
- LASSERTF(last > first, "last "LPU64" first "LPU64"\n", last, first);
+ LASSERTF(last > first, "last %llu first %llu\n", last, first);
if (mapping_mapped(mapping)) {
rc = 0;
unmap_mapping_range(mapping, first + PAGE_CACHE_SIZE - 1,
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
- seq_printf(m, LPU64"\n", osfs.os_files);
+ seq_printf(m, "%llu\n", osfs.os_files);
return rc;
}
LPROC_SEQ_FOPS_RO(ll_filestotal);
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
- seq_printf(m, LPU64"\n", osfs.os_ffree);
+ seq_printf(m, "%llu\n", osfs.os_ffree);
return rc;
}
LPROC_SEQ_FOPS_RO(ll_filesfree);
if (val >= 0 && val <= LL_SA_RPC_MAX)
sbi->ll_sa_max = val;
else
- CERROR("Bad statahead_max value "LPD64". Valid values are in "
+ CERROR("Bad statahead_max value %lld. Valid values are in "
"the range [0, %d]\n", val, LL_SA_RPC_MAX);
return count;
lli->lli_fid = body->mbo_fid1;
if (unlikely(!(body->mbo_valid & OBD_MD_FLTYPE))) {
CERROR("Can not initialize inode "DFID" without object type: "
- "valid = "LPX64"\n",
+ "valid = %#llx\n",
PFID(&lli->lli_fid), body->mbo_valid);
return -EINVAL;
}
LASSERT(body);
if (body->mbo_valid & OBD_MD_FLMTIME &&
body->mbo_mtime > LTIME_S(inode->i_mtime)) {
- CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to "LPU64
+ CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to %llu"
"\n", PFID(ll_inode2fid(inode)),
LTIME_S(inode->i_mtime), body->mbo_mtime);
LTIME_S(inode->i_mtime) = body->mbo_mtime;
#include <libcfs/libcfs.h>
#include <interval_tree.h>
-#define RL_FMT "["LPU64", "LPU64"]"
+#define RL_FMT "[%llu, %llu]"
#define RL_PARA(range) \
(range)->rl_node.in_extent.start, \
(range)->rl_node.in_extent.end
if (end_left > st_pgs)
end_left = st_pgs;
- CDEBUG(D_READA, "start "LPU64", end "LPU64" start_left %lu end_left %lu \n",
+ CDEBUG(D_READA, "start %llu, end %llu start_left %lu end_left %lu\n",
start, end, start_left, end_left);
if (start == end)
kms_pages = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
PAGE_CACHE_SHIFT;
- CDEBUG(D_READA, "kmsp "LPU64" mwp %lu mp %lu\n", kms_pages,
+ CDEBUG(D_READA, "kmsp %llu mwp %lu mp %lu\n", kms_pages,
ra->ra_max_read_ahead_whole_pages, ra->ra_max_pages_per_file);
if (kms_pages &&
if (unlikely(entry == NULL))
RETURN(ERR_PTR(-ENOMEM));
- CDEBUG(D_READA, "alloc sa entry %.*s(%p) index "LPU64"\n",
+ CDEBUG(D_READA, "alloc sa entry %.*s(%p) index %llu\n",
len, name, entry, index);
entry->se_index = index;
/* free sa_entry, which should have been unhashed and not in any list */
static void sa_free(struct ll_statahead_info *sai, struct sa_entry *entry)
{
- CDEBUG(D_READA, "free sa entry %.*s(%p) index "LPU64"\n",
+ CDEBUG(D_READA, "free sa entry %.*s(%p) index %llu\n",
entry->se_qstr.len, entry->se_qstr.name, entry,
entry->se_index);
}
CDEBUG(D_READA, "Handling (init) async glimpse: inode = "
- DFID", idx = "LPU64"\n", PFID(&lli->lli_fid), index);
+ DFID", idx = %llu\n", PFID(&lli->lli_fid), index);
cl_agl(inode);
lli->lli_agl_index = 0;
up_write(&lli->lli_glimpse_sem);
CDEBUG(D_READA, "Handled (init) async glimpse: inode= "
- DFID", idx = "LPU64", rc = %d\n",
+ DFID", idx = %llu, rc = %d\n",
PFID(&lli->lli_fid), index, rc);
iput(inode);
sai->sai_in_readpage = 0;
if (IS_ERR(page)) {
rc = PTR_ERR(page);
- CDEBUG(D_READA, "error reading dir "DFID" at "LPU64
- "/"LPU64" opendir_pid = %u: rc = %d\n",
+ CDEBUG(D_READA, "error reading dir "DFID" at %llu"
+ "/%llu opendir_pid = %u: rc = %d\n",
PFID(ll_inode2fid(dir)), pos, sai->sai_index,
lli->lli_opendir_pid, rc);
break;
rc = -EFAULT;
atomic_inc(&sbi->ll_sa_wrong);
CDEBUG(D_READA, "Statahead for dir "DFID" hit "
- "ratio too low: hit/miss "LPU64"/"LPU64
- ", sent/replied "LPU64"/"LPU64", stopping "
+ "ratio too low: hit/miss %llu/%llu"
+ ", sent/replied %llu/%llu, stopping "
"statahead thread: pid %d\n",
PFID(&lli->lli_fid), sai->sai_hit,
sai->sai_miss, sai->sai_sent,
struct ll_inode_info *lli = ll_i2info(dir);
rc = PTR_ERR(page);
- CERROR("%s: reading dir "DFID" at "LPU64
+ CERROR("%s: reading dir "DFID" at %llu"
"opendir_pid = %u : rc = %d\n",
ll_get_fsname(dir->i_sb, NULL, 0),
PFID(ll_inode2fid(dir)), pos,
if (i_size_read(inode) < kms) {
i_size_write(inode, kms);
CDEBUG(D_VFSTRACE,
- DFID" updating i_size "LPU64"\n",
+ DFID" updating i_size %llu\n",
PFID(lu_object_fid(&obj->co_lu)),
(__u64)i_size_read(inode));
}
* addition to the VFS checks earlier. */
if (pos + cnt > ll_file_maxbytes(inode)) {
CDEBUG(D_INODE,
- "%s: file "DFID" offset %llu > maxbytes "LPU64"\n",
+ "%s: file "DFID" offset %llu > maxbytes %llu\n",
ll_get_fsname(inode->i_sb, NULL, 0),
PFID(ll_inode2fid(inode)), pos + cnt,
ll_file_maxbytes(inode));
rc = fld_client_lookup(&lmv->lmv_fld, fid_seq(fid), mds,
LU_SEQ_RANGE_MDT, NULL);
if (rc) {
- CERROR("Error while looking for mds number. Seq "LPX64
+ CERROR("Error while looking for mds number. Seq %#llx"
", err = %d\n", fid_seq(fid), rc);
RETURN(rc);
}
if (tgt == NULL || tgt->ltd_exp == NULL)
continue;
- CDEBUG(D_INFO, "Target idx %d is %s conn "LPX64"\n", i,
+ CDEBUG(D_INFO, "Target idx %d is %s conn %#llx\n", i,
tgt->ltd_uuid.uuid, tgt->ltd_exp->exp_handle.h_cookie);
if (obd_uuid_equals(uuid, &tgt->ltd_uuid))
*ptr = '/';
}
- CDEBUG(D_INFO, "%s: get path %s "DFID" rec: "LPU64" ln: %u\n",
+ CDEBUG(D_INFO, "%s: get path %s "DFID" rec: %llu ln: %u\n",
tgt->ltd_exp->exp_obd->obd_name,
gf->gf_u.gf_path, PFID(&gf->gf_fid), gf->gf_recno,
gf->gf_linkno);
obd = class_exp2obd(exp);
if (obd == NULL) {
- CDEBUG(D_IOCTL, "Invalid client cookie "LPX64"\n",
+ CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
obd = class_exp2obd(exp);
if (obd == NULL) {
- CDEBUG(D_IOCTL, "Invalid client cookie "LPX64"\n",
+ CDEBUG(D_IOCTL, "Invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
void dump_lsm(unsigned int level, const struct lov_stripe_md *lsm)
{
- CDEBUG(level, "lsm %p, objid "DOSTID", maxbytes "LPX64", magic 0x%08X,"
+ CDEBUG(level, "lsm %p, objid "DOSTID", maxbytes %#llx, magic 0x%08X,"
" stripe_size %u, stripe_count %u, refc: %d,"
" layout_gen %u, pool ["LOV_POOLNAMEF"]\n", lsm,
POSTID(&lsm->lsm_oi), lsm->lsm_maxbytes, lsm->lsm_magic,
if (rc != 0)
break;
- CDEBUG(D_VFSTRACE, "shrink: %d ["LPU64", "LPU64")\n",
+ CDEBUG(D_VFSTRACE, "shrink: %d [%llu, %llu)\n",
stripe, start, end);
list_add_tail(&sub->sub_linkage, &lio->lis_active);
next) - io->u.ci_rw.crw_pos;
lio->lis_pos = io->u.ci_rw.crw_pos;
lio->lis_endpos = io->u.ci_rw.crw_pos + io->u.ci_rw.crw_count;
- CDEBUG(D_VFSTRACE, "stripe: "LPU64" chunk: ["LPU64", "LPU64") "
- LPU64"\n", (__u64)start, lio->lis_pos, lio->lis_endpos,
+ CDEBUG(D_VFSTRACE, "stripe: %llu chunk: [%llu, %llu) "
+ "%llu\n", (__u64)start, lio->lis_pos, lio->lis_endpos,
(__u64)lio->lis_io_endpos);
}
/*
assert_spin_locked(&lsm->lsm_lock);
LASSERT(lsm->lsm_lock_owner == current_pid());
- CDEBUG(D_INODE, "MDT ID "DOSTID" initial value: s="LPU64" m="LPU64
- " a="LPU64" c="LPU64" b="LPU64"\n", POSTID(&lsm->lsm_oi),
+ CDEBUG(D_INODE, "MDT ID "DOSTID" initial value: s=%llu m=%llu"
+ " a=%llu c=%llu b=%llu\n", POSTID(&lsm->lsm_oi),
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime, lvb->lvb_ctime,
lvb->lvb_blocks);
for (i = 0; i < lsm->lsm_stripe_count; i++) {
if (loi->loi_lvb.lvb_ctime > current_ctime)
current_ctime = loi->loi_lvb.lvb_ctime;
- CDEBUG(D_INODE, "MDT ID "DOSTID" on OST[%u]: s="LPU64" m="LPU64
- " a="LPU64" c="LPU64" b="LPU64"\n", POSTID(&lsm->lsm_oi),
+ CDEBUG(D_INODE, "MDT ID "DOSTID" on OST[%u]: s=%llu m=%llu"
+ " a=%llu c=%llu b=%llu\n", POSTID(&lsm->lsm_oi),
loi->loi_ost_idx, loi->loi_lvb.lvb_size,
loi->loi_lvb.lvb_mtime, loi->loi_lvb.lvb_atime,
loi->loi_lvb.lvb_ctime, loi->loi_lvb.lvb_blocks);
if (!tgt->ltd_exp)
continue;
- CDEBUG(D_INFO, "lov idx %d is %s conn "LPX64"\n",
+ CDEBUG(D_INFO, "lov idx %d is %s conn %#llx\n",
index, obd_uuid2str(&tgt->ltd_uuid),
tgt->ltd_exp->exp_handle.h_cookie);
if (obd_uuid_equals(uuid, &tgt->ltd_uuid))
*val = LOV_DESC_STRIPE_SIZE_DEFAULT;
} else if (*val & (LOV_MIN_STRIPE_SIZE - 1)) {
*val &= ~(LOV_MIN_STRIPE_SIZE - 1);
- LCONSOLE_WARN("Changing default stripe size to "LPU64" (a "
+ LCONSOLE_WARN("Changing default stripe size to %llu (a "
"multiple of %u)\n",
*val, LOV_MIN_STRIPE_SIZE);
}
start_side = lov_stripe_offset(lsm, start, stripeno, obd_start);
end_side = lov_stripe_offset(lsm, end, stripeno, obd_end);
- CDEBUG(D_INODE, "["LPD64"->"LPD64"] -> [(%d) "LPD64"->"LPD64" (%d)]\n",
+ CDEBUG(D_INODE, "[%lld->%lld] -> [(%d) %lld->%lld (%d)]\n",
start, end, start_side, *obd_start, *obd_end, end_side);
/* this stripe doesn't intersect the file extent when neither
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
- seq_printf(m, LPU64"\n", desc->ld_default_stripe_size);
+ seq_printf(m, "%llu\n", desc->ld_default_stripe_size);
return 0;
}
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
- seq_printf(m, LPU64"\n", desc->ld_default_stripe_offset);
+ seq_printf(m, "%llu\n", desc->ld_default_stripe_offset);
return 0;
}
if (dev->u.cli.cl_import->imp_deactive == val)
rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
else
- CDEBUG(D_CONFIG, "activate "LPD64": ignoring repeat request\n",
+ CDEBUG(D_CONFIG, "activate %llu: ignoring repeat request\n",
val);
return count;
LASSERT(it);
CDEBUG(D_DLMTRACE, "(name: %.*s,"DFID") in obj "DFID
- ", intent: %s flags %#"LPF64"o\n", (int)op_data->op_namelen,
+ ", intent: %s flags %#llo\n", (int)op_data->op_namelen,
op_data->op_name, PFID(&op_data->op_fid2),
PFID(&op_data->op_fid1), ldlm_it2str(it->it_op),
it->it_flags);
__u64 flags = LDLM_FL_HAS_INTENT;
ENTRY;
- CDEBUG(D_DLMTRACE, "name: %.*s in inode "DFID", intent: %s flags %#"
- LPF64"o\n",
+ CDEBUG(D_DLMTRACE, "name: %.*s in inode "DFID", intent: %s flags %#llo\n",
(int)op_data->op_namelen, op_data->op_name,
PFID(&op_data->op_fid1), ldlm_it2str(it->it_op), it->it_flags);
GOTO(out, rc = -EPROTO);
*rootfid = body->mbo_fid1;
- CDEBUG(D_NET, "root fid="DFID", last_committed="LPU64"\n",
+ CDEBUG(D_NET, "root fid="DFID", last_committed=%llu\n",
PFID(rootfid), lustre_msg_get_last_committed(req->rq_repmsg));
EXIT;
out:
LASSERT(och->och_magic == OBD_CLIENT_HANDLE_MAGIC);
file_fh = &och->och_fh;
- CDEBUG(D_HA, "updating handle from "LPX64" to "LPX64"\n",
+ CDEBUG(D_HA, "updating handle from %#llx to %#llx\n",
file_fh->cookie, body->mbo_handle.cookie);
old = *file_fh;
*file_fh = body->mbo_handle;
if (unlikely(*start == 1 && *hash == 0))
*hash = *start;
else
- LASSERTF(*start <= *hash, "start = "LPX64
- ",end = "LPX64",hash = "LPX64"\n",
+ LASSERTF(*start <= *hash, "start = %#llx"
+ ",end = %#llx,hash = %#llx\n",
*start, *end, *hash);
- CDEBUG(D_VFSTRACE, "offset %lx ["LPX64" "LPX64"],"
- " hash "LPX64"\n", offset, *start, *end, *hash);
+ CDEBUG(D_VFSTRACE, "offset %lx [%#llx %#llx],"
+ " hash %#llx\n", offset, *start, *end, *hash);
if (*hash > *end) {
kunmap(page);
mdc_release_page(page, 0);
page = mdc_page_locate(mapping, &rp_param.rp_off, &start, &end,
rp_param.rp_hash64);
if (IS_ERR(page)) {
- CERROR("%s: dir page locate: "DFID" at "LPU64": rc %ld\n",
+ CERROR("%s: dir page locate: "DFID" at %llu: rc %ld\n",
exp->exp_obd->obd_name, PFID(&op_data->op_fid1),
rp_param.rp_off, PTR_ERR(page));
GOTO(out_unlock, rc = PTR_ERR(page));
rp_param.rp_hash64),
mdc_read_page_remote, &rp_param);
if (IS_ERR(page)) {
- CDEBUG(D_INFO, "%s: read cache page: "DFID" at "LPU64": %ld\n",
+ CDEBUG(D_INFO, "%s: read cache page: "DFID" at %llu: %ld\n",
exp->exp_obd->obd_name, PFID(&op_data->op_fid1),
rp_param.rp_off, PTR_ERR(page));
GOTO(out_unlock, rc = PTR_ERR(page));
wait_on_page_locked(page);
(void)kmap(page);
if (!PageUptodate(page)) {
- CERROR("%s: page not updated: "DFID" at "LPU64": rc %d\n",
+ CERROR("%s: page not updated: "DFID" at %llu: rc %d\n",
exp->exp_obd->obd_name, PFID(&op_data->op_fid1),
rp_param.rp_off, -5);
goto fail;
if (!PageChecked(page))
SetPageChecked(page);
if (PageError(page)) {
- CERROR("%s: page error: "DFID" at "LPU64": rc %d\n",
+ CERROR("%s: page error: "DFID" at %llu: rc %d\n",
exp->exp_obd->obd_name, PFID(&op_data->op_fid1),
rp_param.rp_off, -5);
goto fail;
LASSERT(start == rp_param.rp_off);
CWARN("Page-wide hash collision: %#lx\n", (unsigned long)end);
#if BITS_PER_LONG == 32
- CWARN("Real page-wide hash collision at ["LPU64" "LPU64"] with "
- "hash "LPU64"\n", le64_to_cpu(dp->ldp_hash_start),
+ CWARN("Real page-wide hash collision at [%llu %llu] with "
+ "hash %llu\n", le64_to_cpu(dp->ldp_hash_start),
le64_to_cpu(dp->ldp_hash_end), hash_offset);
#endif
memcpy(key + cfs_size_round(sizeof(KEY_FID2PATH)), gf, sizeof(*gf));
memcpy(key + cfs_size_round(sizeof(KEY_FID2PATH)) + sizeof(*gf),
gf->gf_u.gf_root_fid, sizeof(struct lu_fid));
- CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n",
+ CDEBUG(D_IOCTL, "path get "DFID" from %llu #%d\n",
PFID(&gf->gf_fid), gf->gf_recno, gf->gf_linkno);
if (!fid_is_sane(&gf->gf_fid))
if (vallen > sizeof(*gf) + gf->gf_pathlen)
GOTO(out, rc = -EOVERFLOW);
- CDEBUG(D_IOCTL, "path got "DFID" from "LPU64" #%d: %s\n",
+ CDEBUG(D_IOCTL, "path got "DFID" from %llu #%d: %s\n",
PFID(&gf->gf_fid), gf->gf_recno, gf->gf_linkno,
gf->gf_pathlen < 512 ? gf->gf_u.gf_path :
/* only log the last 512 characters of the path */
if (rec->cr.cr_index < cs->cs_startrec) {
/* Skip entries earlier than what we are interested in */
- CDEBUG(D_HSM, "rec="LPU64" start="LPU64"\n",
+ CDEBUG(D_HSM, "rec=%llu start=%llu\n",
rec->cr.cr_index, cs->cs_startrec);
RETURN(0);
}
- CDEBUG(D_HSM, LPU64" %02d%-5s "LPU64" 0x%x t="DFID" p="DFID" %.*s\n",
+ CDEBUG(D_HSM, "%llu %02d%-5s %llu 0x%x t="DFID" p="DFID" %.*s\n",
rec->cr.cr_index, rec->cr.cr_type,
changelog_type2str(rec->cr.cr_type), rec->cr.cr_time,
rec->cr.cr_flags & CLF_FLAGMASK,
enum llog_flag flags = LLOG_F_IS_CAT;
int rc;
- CDEBUG(D_HSM, "changelog to fp=%p start "LPU64"\n",
+ CDEBUG(D_HSM, "changelog to fp=%p start %llu\n",
cs->cs_fp, cs->cs_startrec);
OBD_ALLOC(cs->cs_buf, KUC_CHANGELOG_MSG_MAXSIZE);
LBUG();
}
res_id->name[1] = cpu_to_le64(resname);
- CDEBUG(D_MGC, "log %s to resid "LPX64"/"LPX64" (%.8s)\n", name,
+ CDEBUG(D_MGC, "log %s to resid %#llx/%#llx (%.8s)\n", name,
res_id->name[0], res_id->name[1], (char *)&res_id->name[0]);
return 0;
}
int rc;
ENTRY;
- CDEBUG(D_MGC, "Enqueue for %s (res "LPX64")\n", cld->cld_logname,
+ CDEBUG(D_MGC, "Enqueue for %s (res %#llx)\n", cld->cld_logname,
cld->cld_resid.name[0]);
/* We need a callback for every lockholder, so don't try to
break;
}
- CDEBUG(D_INFO, "ir apply logs "LPD64"/"LPD64" for %s -> %s\n",
+ CDEBUG(D_INFO, "ir apply logs %lld/%lld for %s -> %s\n",
prev_version, max_version, obdname, params);
rc = class_process_config(lcfg);
cfg->cfg_last_idx = res->mcr_offset;
eof = res->mcr_offset == res->mcr_size;
- CDEBUG(D_INFO, "Latest version "LPD64", more %d.\n",
+ CDEBUG(D_INFO, "Latest version %lld, more %d.\n",
res->mcr_offset, eof == false);
}
ENTRY;
LU_OBJECT_HEADER(D_VFSTRACE, env, &io->ci_obj->co_lu,
- "io range: %u ["LPU64", "LPU64") %u %u\n",
+ "io range: %u [%llu, %llu) %u %u\n",
iot, (__u64)pos, (__u64)pos + count,
io->u.ci_rw.crw_nonblock, io->u.ci_wr.wr_append);
io->u.ci_rw.crw_pos = pos;
}
}
LU_OBJECT_HEADER(D_DLMTRACE, env, lu_object_top(top),
- "size: "LPU64" mtime: "LPU64" atime: "LPU64" "
- "ctime: "LPU64" blocks: "LPU64"\n",
+ "size: %llu mtime: %llu atime: %llu "
+ "ctime: %llu blocks: %llu\n",
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime,
lvb->lvb_ctime, lvb->lvb_blocks);
RETURN(result);
char buf[64];
int len, ret = 0;
- CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", LPU64, LPD64, LPX64);
-
- CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF);
+ CDEBUG(D_INFO, "OBD_OBJECT_EOF = %#llx\n", (__u64)OBD_OBJECT_EOF);
u64val = OBD_OBJECT_EOF;
- CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
+ CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
if (u64val != OBD_OBJECT_EOF) {
- CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
u64val, (int)sizeof(u64val));
ret = -EINVAL;
}
- len = snprintf(buf, sizeof(buf), LPX64, u64val);
+ len = snprintf(buf, sizeof(buf), "%#llx", u64val);
if (len != 18) {
- CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
+ CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
ret = -EINVAL;
}
div64val = OBD_OBJECT_EOF;
- CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
+ CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = %#llx\n", u64val);
if (u64val != OBD_OBJECT_EOF) {
- CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
u64val, (int)sizeof(u64val));
ret = -EOVERFLOW;
}
if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
- CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
u64val, (int)sizeof(u64val));
return -EOVERFLOW;
}
if (do_div(div64val, 256) != (u64val & 255)) {
- CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255);
+ CERROR("do_div(%#llx,256) != %llu\n", u64val, u64val & 255);
return -EOVERFLOW;
}
if (u64val >> 8 != div64val) {
- CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n",
+ CERROR("do_div(%#llx,256) %llu != %llu\n",
u64val, div64val, u64val >> 8);
return -EOVERFLOW;
}
- len = snprintf(buf, sizeof(buf), LPX64, u64val);
+ len = snprintf(buf, sizeof(buf), "%#llx", u64val);
if (len != 18) {
- CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
+ CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
ret = -EINVAL;
}
- len = snprintf(buf, sizeof(buf), LPU64, u64val);
+ len = snprintf(buf, sizeof(buf), "%llu", u64val);
if (len != 20) {
- CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
+ CWARN("u64 wrong length! strlen(%s)=%d != 20\n", buf, len);
ret = -EINVAL;
}
- len = snprintf(buf, sizeof(buf), LPD64, u64val);
+ len = snprintf(buf, sizeof(buf), "%lld", u64val);
if (len != 2) {
- CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len);
+ CWARN("s64 wrong length! strlen(%s)=%d != 2\n", buf, len);
ret = -EINVAL;
}
if ((u64val & ~PAGE_CACHE_MASK) >= PAGE_CACHE_SIZE) {
- CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val,
+ CWARN("mask failed: u64val %llu >= %llu\n", u64val,
(__u64)PAGE_CACHE_SIZE);
ret = -EINVAL;
}
lprocfs_free_stats(&obd_memory);
CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
- "obd_memory max: "LPU64", leaked: "LPU64"\n",
+ "obd_memory max: %llu, leaked: %llu\n",
memory_max, memory_leaked);
EXIT;
void dump_lniobuf(struct niobuf_local *nb)
{
CDEBUG(D_RPCTRACE,
- "niobuf_local: file_offset="LPD64", len=%d, page=%p, rc=%d\n",
+ "niobuf_local: file_offset=%lld, len=%d, page=%p, rc=%d\n",
nb->lnb_file_offset, nb->lnb_len, nb->lnb_page, nb->lnb_rc);
CDEBUG(D_RPCTRACE, "nb->page: index = %ld\n",
nb->lnb_page ? page_index(nb->lnb_page) : -1);
ne_off = le64_to_cpu (off);
id = le64_to_cpu (id);
if (memcmp(addr, (char *)&ne_off, LPDS)) {
- CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" off: "LPX64" != "
- LPX64"\n", who, id, off, *(__u64 *)addr, ne_off);
+ CDEBUG(D_ERROR, "%s: id %#llx offset %llu off: %#llx != "
+ "%#llx\n", who, id, off, *(__u64 *)addr, ne_off);
err = -EINVAL;
}
if (memcmp(addr + LPDS, (char *)&id, LPDS)) {
- CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" id: "LPX64" != "LPX64"\n",
+ CDEBUG(D_ERROR, "%s: id %#llx offset %llu id: %#llx != %#llx\n",
who, id, off, *(__u64 *)(addr + LPDS), id);
err = -EINVAL;
}
addr += end - LPDS - LPDS;
if (memcmp(addr, (char *)&ne_off, LPDS)) {
- CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" end off: "LPX64" != "
- LPX64"\n", who, id, off, *(__u64 *)addr, ne_off);
+ CDEBUG(D_ERROR, "%s: id %#llx offset %llu end off: %#llx != "
+ "%#llx\n", who, id, off, *(__u64 *)addr, ne_off);
err = -EINVAL;
}
if (memcmp(addr + LPDS, (char *)&id, LPDS)) {
- CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" end id: "LPX64" != "
- LPX64"\n", who, id, off, *(__u64 *)(addr + LPDS), id);
+ CDEBUG(D_ERROR, "%s: id %#llx offset %llu end id: %#llx != "
+ "%#llx\n", who, id, off, *(__u64 *)(addr + LPDS), id);
err = -EINVAL;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
int rc = dt_statfs(NULL, dt, &osfs);
if (rc == 0)
- seq_printf(m, LPU64"\n", osfs.os_files);
+ seq_printf(m, "%llu\n", osfs.os_files);
return rc;
}
EXPORT_SYMBOL(lprocfs_dt_filestotal_seq_show);
int rc = dt_statfs(NULL, dt, &osfs);
if (rc == 0)
- seq_printf(m, LPU64"\n", osfs.os_ffree);
+ seq_printf(m, "%llu\n", osfs.os_ffree);
return rc;
}
EXPORT_SYMBOL(lprocfs_dt_filesfree_seq_show);
RETURN(NULL);
}
- CDEBUG(D_INFO, "looking for export cookie "LPX64"\n", conn->cookie);
+ CDEBUG(D_INFO, "looking for export cookie %#llx\n", conn->cookie);
export = class_handle2object(conn->cookie, NULL);
RETURN(export);
}
conn->cookie = export->exp_handle.h_cookie;
class_export_put(export);
- CDEBUG(D_IOCTL, "connect: client %s, cookie "LPX64"\n",
+ CDEBUG(D_IOCTL, "connect: client %s, cookie %#llx\n",
cluuid->uuid, conn->cookie);
RETURN(0);
}
GOTO(no_disconn, already_disconnected);
}
- CDEBUG(D_IOCTL, "disconnect: cookie "LPX64"\n",
+ CDEBUG(D_IOCTL, "disconnect: cookie %#llx\n",
export->exp_handle.h_cookie);
if (!hlist_unhashed(&export->exp_nid_hash))
}
spin_unlock(&exp->exp_lock);
- CDEBUG(D_HA, "%s: %s %p %s %s %d (%d %d %d) %d %d %d %d: %p %s "LPU64"\n",
+ CDEBUG(D_HA, "%s: %s %p %s %s %d (%d %d %d) %d %d %d %d: %p %s %llu\n",
exp->exp_obd->obd_name, status, exp, exp->exp_client_uuid.uuid,
obd_export_nid2str(exp), atomic_read(&exp->exp_refcount),
atomic_read(&exp->exp_rpc_count),
if (write)
return -EINVAL;
- len = snprintf(buf, sizeof(buf), LPU64"\n", obd_memory_sum());
+ len = snprintf(buf, sizeof(buf), "%llu\n", obd_memory_sum());
if (len > *lenp)
len = *lenp;
buf[len] = '\0';
if (write)
return -EINVAL;
- len = snprintf(buf, sizeof(buf), LPU64"\n", obd_memory_max());
+ len = snprintf(buf, sizeof(buf), "%llu\n", obd_memory_max());
if (len > *lenp)
len = *lenp;
buf[len] = '\0';
/* Don't allow them to let dirty pages exceed 90% of system
* memory and set a hard minimum of 4MB. */
if (val > ((totalram_pages / 10) * 9)) {
- CERROR("Refusing to set max dirty pages to "LPD64", "
+ CERROR("Refusing to set max dirty pages to %lld, "
"which is more than 90%% of available RAM; "
"setting to %lu\n", val,
((totalram_pages / 10) * 9));
size = llog_size(env, llh);
*cum_size += size;
- CDEBUG(D_INFO, "Add llog entry "DOSTID" size "LPU64"\n",
+ CDEBUG(D_INFO, "Add llog entry "DOSTID" size %llu\n",
POSTID(&llh->lgh_id.lgl_oi), size);
llog_handle_put(llh);
if (dt_object_remote(o))
loghandle->lgh_write_offset = lgi->lgi_off;
- CDEBUG(D_HA, "added record "DFID": idx: %u, %u off"LPU64"\n",
+ CDEBUG(D_HA, "added record "DFID": idx: %u, %u off%llu\n",
PFID(lu_object_fid(&o->do_lu)), index, rec->lrh_len,
lgi->lgi_off);
if (reccookie != NULL) {
GOTO(out, rc);
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off"
- LPU64"), size %llu\n", next_idx, *cur_idx,
+ "%llu), size %llu\n", next_idx, *cur_idx,
*cur_offset, lgi->lgi_attr.la_size);
while (*cur_offset < lgi->lgi_attr.la_size) {
goto retry;
CERROR("%s: can't read llog block from log "DFID
- " offset "LPU64": rc = %d\n",
+ " offset %llu: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), *cur_offset,
rc);
goto retry;
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
- "offset "LPU64"\n",
+ "offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
if (last_rec->lrh_index != tail->lrt_index) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
- "offset "LPU64" last_rec idx %u tail idx %u\n",
+ "offset %llu last_rec idx %u tail idx %u\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset,
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
- "offset "LPU64" bytes %d\n",
+ "offset %llu bytes %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset, rc);
rc = dt_read(env, o, &lgi->lgi_buf, &cur_offset);
if (rc < 0) {
CERROR("%s: can't read llog block from log "DFID
- " offset "LPU64": rc = %d\n",
+ " offset %llu: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), cur_offset, rc);
GOTO(out, rc);
if (rc < sizeof(*tail)) {
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
- "offset "LPU64"\n",
+ "offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
- "offset "LPU64"\n",
+ "offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
CDEBUG(D_OTHER, "\tlgd_index: %#x\n", d->lgd_index);
CDEBUG(D_OTHER, "\tlgd_saved_index: %#x\n", d->lgd_saved_index);
CDEBUG(D_OTHER, "\tlgd_len: %#x\n", d->lgd_len);
- CDEBUG(D_OTHER, "\tlgd_cur_offset: "LPX64"\n", d->lgd_cur_offset);
+ CDEBUG(D_OTHER, "\tlgd_cur_offset: %#llx\n", d->lgd_cur_offset);
}
void lustre_swab_lu_fid(struct lu_fid *fid)
CDEBUG(D_OTHER, "\tllh_hdr.lrh_index: %#x\n", h->llh_hdr.lrh_index);
CDEBUG(D_OTHER, "\tllh_hdr.lrh_len: %#x\n", h->llh_hdr.lrh_len);
CDEBUG(D_OTHER, "\tllh_hdr.lrh_type: %#x\n", h->llh_hdr.lrh_type);
- CDEBUG(D_OTHER, "\tllh_timestamp: "LPX64"\n", h->llh_timestamp);
+ CDEBUG(D_OTHER, "\tllh_timestamp: %#llx\n", h->llh_timestamp);
CDEBUG(D_OTHER, "\tllh_count: %#x\n", h->llh_count);
CDEBUG(D_OTHER, "\tllh_bitmap_offset: %#x\n", h->llh_bitmap_offset);
CDEBUG(D_OTHER, "\tllh_flags: %#x\n", h->llh_flags);
LASSERT(lgh->lgh_hdr->llh_size > 0);
if (lgh->lgh_cur_offset != lgh->lgh_hdr->llh_hdr.lrh_len +
(cur_idx - 1) * lgh->lgh_hdr->llh_size)
- CERROR("Wrong record offset in cur_off: "LPU64", should be %u\n",
+ CERROR("Wrong record offset in cur_off: %llu, should be %u\n",
lgh->lgh_cur_offset,
lgh->lgh_hdr->llh_hdr.lrh_len +
(cur_idx - 1) * lgh->lgh_hdr->llh_size);
test_3_rec_off = lgh->lgh_cur_offset;
test_3_paddings++;
} else {
- CERROR("Wrong record offset in cur_off: "LPU64
+ CERROR("Wrong record offset in cur_off: %llu"
", should be %lld (rec len %u)\n",
lgh->lgh_cur_offset,
(long long)test_3_rec_off,
if (rc)
RETURN(rc);
- CDEBUG(D_OTHER, "original size "LPU64"\n", la.la_size);
+ CDEBUG(D_OTHER, "original size %llu\n", la.la_size);
rc = sizeof(struct llog_log_hdr) + sizeof(struct llog_mini_rec);
if (la.la_size < rc) {
- CERROR("too small llog: "LPU64"\n", la.la_size);
+ CERROR("too small llog: %llu\n", la.la_size);
RETURN(0);
}
if (la.la_size != cat_max_size) {
CERROR("10e: catalog size has changed after it has wrap around,"
- " current size = "LPU64", expected size = "LPU64"\n",
+ " current size = %llu, expected size = %llu\n",
la.la_size, cat_max_size);
GOTO(out, rc = -EINVAL);
}
if (la.la_size != cat_max_size) {
CERROR("10f: catalog size has changed after it has wrap around,"
- " current size = "LPU64", expected size = "LPU64"\n",
+ " current size = %llu, expected size = %llu\n",
la.la_size, cat_max_size);
GOTO(out, rc = -EINVAL);
}
return PTR_ERR(root);
/* find old last_id file */
- snprintf(dti->dti_buf, sizeof(dti->dti_buf), "seq-"LPX64"-lastid",
+ snprintf(dti->dti_buf, sizeof(dti->dti_buf), "seq-%#llx-lastid",
lastid_seq);
rc = dt_lookup_dir(env, root, dti->dti_buf, &dti->dti_fid);
lu_object_put_nocache(env, &root->do_lu);
} else if (rc < 0) {
return rc;
} else {
- CDEBUG(D_INFO, "Found old lastid file for sequence "LPX64"\n",
+ CDEBUG(D_INFO, "Found old lastid file for sequence %#llx\n",
lastid_seq);
o = ls_locate(env, ls, &dti->dti_fid, NULL);
if (IS_ERR(o))
rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
dt_read_unlock(env, o);
if (rc == 0 && le32_to_cpu(losd.lso_magic) != LOS_MAGIC) {
- CERROR("%s: wrong content of seq-"LPX64"-lastid file, magic %x\n",
+ CERROR("%s: wrong content of seq-%#llx-lastid file, magic %x\n",
o->do_lu.lo_dev->ld_obd->obd_name, lastid_seq,
le32_to_cpu(losd.lso_magic));
rc = -EINVAL;
} else if (rc < 0) {
- CERROR("%s: failed to read seq-"LPX64"-lastid: rc = %d\n",
+ CERROR("%s: failed to read seq-%#llx-lastid: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name, lastid_seq, rc);
}
lu_object_put_nocache(env, &o->do_lu);
rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
dt_read_unlock(env, o);
if (rc == 0 && le64_to_cpu(lastid) > OBIF_MAX_OID) {
- CERROR("%s: bad oid "LPU64" is read from LAST_ID\n",
+ CERROR("%s: bad oid %llu is read from LAST_ID\n",
o->do_lu.lo_dev->ld_obd->obd_name,
le64_to_cpu(lastid));
rc = -EINVAL;
cntr_header = &s->ls_cnt_header[i];
lprocfs_stats_collect(s, i, &ret);
- seq_printf(p, " %s:%.*s { samples: %11"LPF64"u",
+ seq_printf(p, " %s:%.*s { samples: %11llu",
cntr_header->lc_name,
width(cntr_header->lc_name, 15), spaces,
ret.lc_count);
seq_printf(p, ", unit: %5s", cntr_header->lc_units);
if (cntr_header->lc_config & LPROCFS_CNTR_AVGMINMAX) {
- seq_printf(p, ", min:%8"LPF64"u, max:%8"LPF64"u,"
- " sum:%16"LPF64"u",
+ seq_printf(p, ", min:%8llu, max:%8llu,"
+ " sum:%16llu",
ret.lc_count ? ret.lc_min : 0,
ret.lc_count ? ret.lc_max : 0,
ret.lc_count ? ret.lc_sum : 0);
}
if (cntr_header->lc_config & LPROCFS_CNTR_STDDEV) {
- seq_printf(p, ", sumsq: %18"LPF64"u",
+ seq_printf(p, ", sumsq: %18llu",
ret.lc_count ? ret.lc_sumsquare : 0);
}
int lprocfs_u64_seq_show(struct seq_file *m, void *data)
{
LASSERT(data != NULL);
- seq_printf(m, LPU64"\n", *(__u64 *)data);
+ seq_printf(m, "%llu\n", *(__u64 *)data);
return 0;
}
EXPORT_SYMBOL(lprocfs_u64_seq_show);
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
}
return rc;
}
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
- seq_printf(m, LPU64"\n", osfs.os_files);
+ seq_printf(m, "%llu\n", osfs.os_files);
return rc;
}
EXPORT_SYMBOL(lprocfs_filestotal_seq_show);
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
- seq_printf(m, LPU64"\n", osfs.os_ffree);
+ seq_printf(m, "%llu\n", osfs.os_ffree);
return rc;
}
EXPORT_SYMBOL(lprocfs_filesfree_seq_show);
}
if (flags & ~(mask - 1)) {
- seq_printf(m, "%sunknown_"LPX64,
+ seq_printf(m, "%sunknown_%#llx",
first ? "" : sep, flags & ~(mask - 1));
first = false;
}
}
if (flags2 & ~(mask - 1)) {
- seq_printf(m, "%sunknown2_"LPX64,
+ seq_printf(m, "%sunknown2_%#llx",
first ? "" : sep, flags2 & ~(mask - 1));
first = false;
}
if (flags & ~(mask - 1))
ret += snprintf(page + ret, count - ret,
- "%sunknown_"LPX64,
+ "%sunknown_%#llx",
ret ? sep : "", flags & ~(mask - 1));
if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0)
if (flags2 & ~(mask - 1))
ret += snprintf(page + ret, count - ret,
- "%sunknown2_"LPX64,
+ "%sunknown2_%#llx",
ret ? sep : "", flags2 & ~(mask - 1));
return ret;
flags = ocd->ocd_connect_flags;
seq_printf(m, " connect_data:\n"
- " flags: "LPX64"\n"
+ " flags: %#llx\n"
" instance: %u\n",
ocd->ocd_connect_flags,
ocd->ocd_instance);
if (flags & OBD_CONNECT_BRW_SIZE)
seq_printf(m, " max_brw_size: %d\n", ocd->ocd_brw_size);
if (flags & OBD_CONNECT_IBITS)
- seq_printf(m, " ibits_known: "LPX64"\n",
+ seq_printf(m, " ibits_known: %#llx\n",
ocd->ocd_ibits_known);
if (flags & OBD_CONNECT_GRANT_PARAM)
seq_printf(m, " grant_block_size: %d\n"
ocd->ocd_grant_max_blks << ocd->ocd_grant_blkbits,
ocd->ocd_grant_tax_kb << 10);
if (flags & OBD_CONNECT_TRANSNO)
- seq_printf(m, " first_transno: "LPX64"\n",
+ seq_printf(m, " first_transno: %#llx\n",
ocd->ocd_transno);
if (flags & OBD_CONNECT_CKSUM)
seq_printf(m, " cksum_types: %#x\n",
if (flags & OBD_CONNECT_MAX_EASIZE)
seq_printf(m, " max_easize: %d\n", ocd->ocd_max_easize);
if (flags & OBD_CONNECT_MAXBYTES)
- seq_printf(m, " max_object_bytes: "LPU64"\n",
+ seq_printf(m, " max_object_bytes: %llu\n",
ocd->ocd_maxbytes);
if (flags & OBD_CONNECT_MULTIMODRPCS)
seq_printf(m, " max_mod_rpcs: %hu\n",
" inflight: %u\n"
" unregistering: %u\n"
" timeouts: %u\n"
- " avg_waittime: "LPU64" %s\n",
+ " avg_waittime: %llu %s\n",
atomic_read(&imp->imp_inflight),
atomic_read(&imp->imp_unregistering),
atomic_read(&imp->imp_timeouts),
at_get(&imp->imp_at.iat_net_latency));
seq_printf(m, " transactions:\n"
- " last_replay: "LPU64"\n"
- " peer_committed: "LPU64"\n"
- " last_checked: "LPU64"\n",
+ " last_replay: %llu\n"
+ " peer_committed: %llu\n"
+ " last_checked: %llu\n",
imp->imp_last_replay_transno,
imp->imp_peer_committed_transno,
imp->imp_last_transno_checked);
do_div(sum, ret.lc_count);
ret.lc_sum = sum;
seq_printf(m, " %s_data_averages:\n"
- " bytes_per_rpc: "LPU64"\n",
+ " bytes_per_rpc: %llu\n",
rw ? "write" : "read",
ret.lc_sum);
}
__u64 sum = ret.lc_sum;
do_div(sum, ret.lc_count);
ret.lc_sum = sum;
- seq_printf(m, " %s_per_rpc: "LPU64"\n",
+ seq_printf(m, " %s_per_rpc: %llu\n",
header->lc_units, ret.lc_sum);
j = (int)ret.lc_sum;
if (j > 0)
LPROCFS_CLIMP_CHECK(obd);
flags = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags;
flags2 = obd->u.cli.cl_import->imp_connect_data.ocd_connect_flags2;
- seq_printf(m, "flags="LPX64"\n", flags);
- seq_printf(m, "flags2="LPX64"\n", flags2);
+ seq_printf(m, "flags=%#llx\n", flags);
+ seq_printf(m, "flags2=%#llx\n", flags2);
obd_connect_seq_flags2str(m, flags, flags2, "\n");
seq_printf(m, "\n");
LPROCFS_CLIMP_EXIT(obd);
if (ctr.lc_count == 0)
return 0;
- seq_printf(p, "%-25s "LPD64" samples [%s]", hdr->lc_name,
+ seq_printf(p, "%-25s %lld samples [%s]", hdr->lc_name,
ctr.lc_count, hdr->lc_units);
if ((hdr->lc_config & LPROCFS_CNTR_AVGMINMAX) && ctr.lc_count > 0) {
- seq_printf(p, " "LPD64" "LPD64" "LPD64,
+ seq_printf(p, " %lld %lld %lld",
ctr.lc_min, ctr.lc_max, ctr.lc_sum);
if (hdr->lc_config & LPROCFS_CNTR_STDDEV)
- seq_printf(p, " "LPD64, ctr.lc_sumsquare);
+ seq_printf(p, " %llu", ctr.lc_sumsquare);
}
seq_putc(p, '\n');
return 0;
obd->obd_max_recoverable_clients);
seq_printf(m, "replayed_requests: %d\n",
obd->obd_replayed_requests);
- seq_printf(m, "last_transno: "LPD64"\n",
+ seq_printf(m, "last_transno: %lld\n",
obd->obd_next_recovery_transno - 1);
seq_printf(m, "VBR: %s\n", obd->obd_version_recov ?
"ENABLED" : "DISABLED");
seq_printf(m, "replayed_requests: %d\n", obd->obd_replayed_requests);
seq_printf(m, "queued_requests: %d\n",
obd->obd_requests_queued_for_recovery);
- seq_printf(m, "next_transno: "LPD64"\n",
+ seq_printf(m, "next_transno: %lld\n",
obd->obd_next_recovery_transno);
out:
return 0;
h->h_in = 1;
spin_unlock(&bucket->lock);
- CDEBUG(D_INFO, "added object %p with handle "LPX64" to hash\n",
+ CDEBUG(D_INFO, "added object %p with handle %#llx to hash\n",
h, h->h_cookie);
EXIT;
}
static void class_handle_unhash_nolock(struct portals_handle *h)
{
if (list_empty(&h->h_link)) {
- CERROR("removing an already-removed handle ("LPX64")\n",
+ CERROR("removing an already-removed handle (%#llx)\n",
h->h_cookie);
return;
}
- CDEBUG(D_INFO, "removing object %p with handle "LPX64" from hash\n",
+ CDEBUG(D_INFO, "removing object %p with handle %#llx from hash\n",
h, h->h_cookie);
spin_lock(&h->h_lock);
spin_lock(&handle_hash[i].lock);
list_for_each_entry_rcu(h, &(handle_hash[i].head), h_link) {
- CERROR("force clean handle "LPX64" addr %p ops %p\n",
+ CERROR("force clean handle %#llx addr %p ops %p\n",
h->h_cookie, h, h->h_ops);
class_handle_unhash_nolock(h);
GOTO(out, err);
}
case LCFG_ADD_UUID: {
- CDEBUG(D_IOCTL, "adding mapping from uuid %s to nid "LPX64
+ CDEBUG(D_IOCTL, "adding mapping from uuid %s to nid %#llx"
" (%s)\n", lustre_cfg_string(lcfg, 1),
lcfg->lcfg_nid, libcfs_nid2str(lcfg->lcfg_nid));
char nidstr[LNET_NIDSTR_SIZE];
libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
- ptr += snprintf(ptr, end - ptr, ", nid: %s("LPX64")",
+ ptr += snprintf(ptr, end - ptr, ", nid: %s(%#llx)",
nidstr, lcfg->lcfg_nid);
}
char nidstr[LNET_NIDSTR_SIZE];
libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
- ptr += snprintf(ptr, end-ptr, "nid=%s("LPX64")\n ",
+ ptr += snprintf(ptr, end-ptr, "nid=%s(%#llx)\n ",
nidstr, lcfg->lcfg_nid);
}
u64 newvalid = 0;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE, "valid "LPX64", new time %lu/%lu\n",
+ CDEBUG(D_INODE, "valid %#llx, new time %lu/%lu\n",
valid, LTIME_S(src->i_mtime),
LTIME_S(src->i_ctime));
void obdo_cpy_md(struct obdo *dst, const struct obdo *src, u64 valid)
{
- CDEBUG(D_INODE, "src obdo "DOSTID" valid "LPX64", dst obdo "DOSTID"\n",
+ CDEBUG(D_INODE, "src obdo "DOSTID" valid %#llx, dst obdo "DOSTID"\n",
POSTID(&src->o_oi), src->o_valid, POSTID(&dst->o_oi));
if (valid & OBD_MD_FLATIME)
dst->o_atime = src->o_atime;
cache->uc_ops->free_entry(cache, entry);
list_del(&entry->ue_hash);
- CDEBUG(D_OTHER, "destroy cache entry %p for key "LPU64"\n",
+ CDEBUG(D_OTHER, "destroy cache entry %p for key %llu\n",
entry, entry->ue_key);
LIBCFS_FREE(entry, sizeof(*entry));
}
if (UC_CACHE_IS_ACQUIRING(entry)) {
/* we're interrupted or upcall failed in the middle */
rc = left > 0 ? -EINTR : -ETIMEDOUT;
- CERROR("acquire for key "LPU64": error %d\n",
+ CERROR("acquire for key %llu: error %d\n",
entry->ue_key, rc);
put_entry(cache, entry);
GOTO(out, entry = ERR_PTR(rc));
}
if (!found) {
- CDEBUG(D_OTHER, "%s: upcall for key "LPU64" not expected\n",
+ CDEBUG(D_OTHER, "%s: upcall for key %llu not expected\n",
cache->uc_name, key);
/* haven't found, it's possible */
spin_unlock(&cache->uc_lock);
}
if (err) {
- CDEBUG(D_OTHER, "%s: upcall for key "LPU64" returned %d\n",
+ CDEBUG(D_OTHER, "%s: upcall for key %llu returned %d\n",
cache->uc_name, entry->ue_key, err);
GOTO(out, rc = -EINVAL);
}
if (!UC_CACHE_IS_ACQUIRING(entry)) {
- CDEBUG(D_RPCTRACE, "%s: found uptodate entry %p (key "LPU64")"
+ CDEBUG(D_RPCTRACE, "%s: found uptodate entry %p (key %llu)"
"\n", cache->uc_name, entry, entry->ue_key);
GOTO(out, rc = 0);
}
if (UC_CACHE_IS_INVALID(entry) || UC_CACHE_IS_EXPIRED(entry)) {
- CERROR("%s: found a stale entry %p (key "LPU64") in ioctl\n",
+ CERROR("%s: found a stale entry %p (key %llu) in ioctl\n",
cache->uc_name, entry, entry->ue_key);
GOTO(out, rc = -EINVAL);
}
entry->ue_expire = cfs_time_shift(cache->uc_entry_expire);
UC_CACHE_SET_VALID(entry);
- CDEBUG(D_OTHER, "%s: created upcall cache entry %p for key "LPU64"\n",
+ CDEBUG(D_OTHER, "%s: created upcall cache entry %p for key %llu\n",
cache->uc_name, entry, entry->ue_key);
out:
if (rc) {
}
if (found) {
- CWARN("%s: flush entry %p: key "LPU64", ref %d, fl %x, "
+ CWARN("%s: flush entry %p: key %llu, ref %d, fl %x, "
"cur %lu, ex %ld/%ld\n",
cache->uc_name, entry, entry->ue_key,
atomic_read(&entry->ue_refcount), entry->ue_flags,
struct obd_device *obd = class_exp2obd(exp);
if (!obd) {
- CERROR("invalid client cookie "LPX64"\n",
+ CERROR("invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
return -EINVAL;
}
}
if (!(oa->o_valid & OBD_MD_FLTYPE)) {
- CERROR("invalid o_valid "LPX64"\n", oa->o_valid);
+ CERROR("invalid o_valid %#llx\n", oa->o_valid);
return -EINVAL;
}
ENTRY;
if (!obd) {
- CERROR("invalid client cookie "LPX64"\n",
+ CERROR("invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
if (!(oa->o_valid & OBD_MD_FLID)) {
- CERROR("obdo missing FLID valid flag: "LPX64"\n", oa->o_valid);
+ CERROR("obdo missing FLID valid flag: %#llx\n", oa->o_valid);
RETURN(-EINVAL);
}
ENTRY;
if (!obd) {
- CERROR("invalid client cookie "LPX64"\n",
+ CERROR("invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
if (!(oa->o_valid & OBD_MD_FLID)) {
- CERROR("obdo missing FLID valid flag: "LPX64"\n", oa->o_valid);
+ CERROR("obdo missing FLID valid flag: %#llx\n", oa->o_valid);
RETURN(-EINVAL);
}
ENTRY;
if (!obd) {
- CERROR("invalid client cookie "LPX64"\n",
+ CERROR("invalid client cookie %#llx\n",
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
if (!(oa->o_valid & OBD_MD_FLID)) {
- CERROR("obdo missing FLID valid flag: "LPX64"\n", oa->o_valid);
+ CERROR("obdo missing FLID valid flag: %#llx\n", oa->o_valid);
RETURN(-EINVAL);
}
}
}
- CDEBUG(D_PAGE, "$$$$ get page %p @ "LPU64" for %d\n",
+ CDEBUG(D_PAGE, "$$$$ get page %p @ %llu for %d\n",
res->lnb_page, res->lnb_file_offset, res->lnb_len);
if (cmd & OBD_BRW_READ)
void *addr;
if (page == NULL) {
- CERROR("null page objid "LPU64":%p, buf %d/%d\n",
+ CERROR("null page objid %llu:%p, buf %d/%d\n",
ostid_id(&obj->ioo_oid), page, i,
obj->ioo_bufcnt);
return -EFAULT;
addr = kmap(page);
- CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@"LPU64"\n",
+ CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@%llu\n",
res->lnb_page, addr, res->lnb_file_offset);
if (verify) {
#include <lustre_net.h>
#ifdef HAVE_SERVER_SUPPORT
# include <md_object.h>
+
+#define ETI_NAME_LEN 20
+
#endif /* HAVE_SERVER_SUPPORT */
#include "echo_internal.h"
/* per-thread values, can be re-used */
void *eti_big_lmm; /* may be vmalloc'd */
int eti_big_lmmsize;
- char eti_name[20];
+ char eti_name[ETI_NAME_LEN];
struct lu_buf eti_buf;
char eti_xattr_buf[LUSTRE_POSIX_ACL_MAX_SIZE];
#endif
spin_lock(&ec->ec_lock);
list_for_each(el, &ec->ec_locks) {
ecl = list_entry(el, struct echo_lock, el_chain);
- CDEBUG(D_INFO, "ecl: %p, cookie: "LPX64"\n", ecl, ecl->el_cookie);
+ CDEBUG(D_INFO, "ecl: %p, cookie: %#llx\n", ecl, ecl->el_cookie);
found = (ecl->el_cookie == cookie);
if (found) {
if (atomic_dec_and_test(&ecl->el_refcount))
static inline void echo_md_build_name(struct lu_name *lname, char *name,
__u64 id)
{
- sprintf(name, LPU64, id);
+ snprintf(name, ETI_NAME_LEN, "%llu", id);
lname->ln_name = name;
lname->ln_namelen = strlen(name);
}
#endif
out:
ma->ma_need = need;
- CDEBUG(D_INODE, "after getattr rc = %d, ma_valid = "LPX64" ma_lmm=%p\n",
+ CDEBUG(D_INODE, "after getattr rc = %d, ma_valid = %#llx ma_lmm=%p\n",
rc, ma->ma_valid, ma->ma_lmm);
RETURN(rc);
}
addr + delta, OBD_ECHO_BLOCK_SIZE,
stripe_off, stripe_id);
if (rc2 != 0) {
- CERROR ("Error in echo object "LPX64"\n", id);
+ CERROR("Error in echo object %#llx\n", id);
rc = rc2;
}
}
seq_printf(m, "used_mb: %ld\n"
"busy_cnt: %ld\n"
- "reclaim: "LPU64"\n",
+ "reclaim: %llu\n",
(atomic_long_read(&cli->cl_lru_in_list) +
atomic_long_read(&cli->cl_lru_busy)) >> shift,
atomic_long_read(&cli->cl_lru_busy),
seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n",
now.tv_sec, now.tv_usec);
- seq_printf(seq, "lockless_write_bytes\t\t"LPU64"\n",
+ seq_printf(seq, "lockless_write_bytes\t\t%llu\n",
stats->os_lockless_writes);
- seq_printf(seq, "lockless_read_bytes\t\t"LPU64"\n",
+ seq_printf(seq, "lockless_read_bytes\t\t%llu\n",
stats->os_lockless_reads);
- seq_printf(seq, "lockless_truncate\t\t"LPU64"\n",
+ seq_printf(seq, "lockless_truncate\t\t%llu\n",
stats->os_lockless_truncates);
return 0;
}
INIT_LIST_HEAD(&oap->oap_rpc_item);
spin_lock_init(&oap->oap_lock);
- CDEBUG(D_INFO, "oap %p page %p obj off "LPU64"\n",
+ CDEBUG(D_INFO, "oap %p page %p obj off %llu\n",
oap, page, oap->oap_obj_off);
RETURN(0);
}
break;
}
- OSC_EXTENT_DUMP(D_CACHE, ext, "try to trunc:"LPU64".\n", size);
+ OSC_EXTENT_DUMP(D_CACHE, ext, "try to trunc:%llu.\n", size);
osc_extent_get(ext);
if (ext->oe_state == OES_ACTIVE) {
LASSERT(*extp == NULL);
*extp = osc_extent_get(ext);
OSC_EXTENT_DUMP(D_CACHE, ext,
- "trunc at "LPU64"\n", size);
+ "trunc at %llu\n", size);
}
osc_extent_put(env, ext);
}
*
* here
*/
- CDEBUG(D_INODE, "stripe KMS %sincreasing "LPU64"->"LPU64" "LPU64"\n",
+ CDEBUG(D_INODE, "stripe KMS %sincreasing %llu->%llu %llu\n",
kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms,
loi->loi_lvb.lvb_size);
oap = &ops->ops_oap;
if (oap->oap_cmd & OBD_BRW_WRITE &&
!list_empty(&oap->oap_pending_item))
- CL_PAGE_DEBUG(D_ERROR, env, page, "exists " LPU64 "/%s.\n",
+ CL_PAGE_DEBUG(D_ERROR, env, page, "exists %llu/%s.\n",
start, current->comm);
if (PageLocked(page->cp_vmpage))
if (size > dlmlock->l_policy_data.l_extent.end)
size = dlmlock->l_policy_data.l_extent.end + 1;
if (size >= oinfo->loi_kms) {
- LDLM_DEBUG(dlmlock, "lock acquired, setting rss="LPU64
- ", kms="LPU64, lvb->lvb_size, size);
+ LDLM_DEBUG(dlmlock, "lock acquired, setting rss=%llu"
+ ", kms=%llu", lvb->lvb_size, size);
valid |= CAT_KMS;
attr->cat_kms = size;
} else {
LDLM_DEBUG(dlmlock, "lock acquired, setting rss="
- LPU64"; leaving kms="LPU64", end="LPU64,
+ "%llu; leaving kms=%llu, end=%llu",
lvb->lvb_size, oinfo->loi_kms,
dlmlock->l_policy_data.l_extent.end);
}
{
struct osc_lock *lock = cl2osc_lock(slice);
- (*p)(env, cookie, "%p "LPX64" "LPX64" %d %p ",
+ (*p)(env, cookie, "%p %#llx %#llx %d %p ",
lock->ols_dlmlock, lock->ols_flags, lock->ols_handle.cookie,
lock->ols_state, lock->ols_owner);
osc_lvb_print(env, cookie, p, &lock->ols_lvb);
if (io->ci_type == CIT_WRITE || cl_io_is_mkwrite(io))
osc_lock_set_writer(env, io, obj, oscl);
- LDLM_DEBUG_NOLOCK("lock %p, osc lock %p, flags "LPX64,
+ LDLM_DEBUG_NOLOCK("lock %p, osc lock %p, flags %#llx",
lock, oscl, oscl->ols_flags);
return 0;
int osc_lvb_print(const struct lu_env *env, void *cookie,
lu_printer_t p, const struct ost_lvb *lvb)
{
- return (*p)(env, cookie, "size: "LPU64" mtime: "LPU64" atime: "LPU64" "
- "ctime: "LPU64" blocks: "LPU64,
+ return (*p)(env, cookie, "size: %llu mtime: %llu atime: %llu "
+ "ctime: %llu blocks: %llu",
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime,
lvb->lvb_ctime, lvb->lvb_blocks);
}
struct osc_async_rc *ar = &oinfo->loi_ar;
(*p)(env, cookie, "id: "DOSTID" "
- "idx: %d gen: %d kms_valid: %u kms "LPU64" "
- "rc: %d force_sync: %d min_xid: "LPU64" ",
+ "idx: %d gen: %d kms_valid: %u kms %llu "
+ "rc: %d force_sync: %d min_xid: %llu ",
POSTID(&oinfo->loi_oi), oinfo->loi_ost_idx,
oinfo->loi_ost_gen, oinfo->loi_kms_valid, oinfo->loi_kms,
ar->ar_rc, ar->ar_force_sync, ar->ar_min_xid);
if (valid & CAT_BLOCKS)
lvb->lvb_blocks = attr->cat_blocks;
if (valid & CAT_KMS) {
- CDEBUG(D_CACHE, "set kms from "LPU64"to "LPU64"\n",
+ CDEBUG(D_CACHE, "set kms from %lluto %llu\n",
oinfo->loi_kms, (__u64)attr->cat_kms);
loi_kms_set(oinfo, attr->cat_kms);
}
return (*printer)(env, cookie, LUSTRE_OSC_NAME"-page@%p %lu: "
"1< %#x %d %u %s %s > "
- "2< "LPD64" %u %u %#x %#x | %p %p %p > "
+ "2< %lld %u %u %#x %#x | %p %p %p > "
"3< %d %lu %d > "
"4< %d %d %d %lu %s | %s %s %s %s > "
"5< %s %s %s %s | %d %s | %d %s %s>\n",
oa->o_blksize = cli_brw_size(exp->exp_obd);
oa->o_valid |= OBD_MD_FLBLKSZ;
- CDEBUG(D_HA, "transno: "LPD64"\n",
+ CDEBUG(D_HA, "transno: %lld\n",
lustre_msg_get_transno(req->rq_repmsg));
out_req:
ptlrpc_req_finished(req);
oa->o_dropped = cli->cl_lost_grant;
cli->cl_lost_grant = 0;
spin_unlock(&cli->cl_loi_list_lock);
- CDEBUG(D_CACHE,"dirty: "LPU64" undirty: %u dropped %u grant: "LPU64"\n",
+ CDEBUG(D_CACHE, "dirty: %llu undirty: %u dropped %u grant: %llu\n",
oa->o_dirty, oa->o_undirty, oa->o_dropped, oa->o_grant);
}
static void osc_update_grant(struct client_obd *cli, struct ost_body *body)
{
if (body->oa.o_valid & OBD_MD_FLGRANT) {
- CDEBUG(D_CACHE, "got "LPU64" extra grant\n", body->oa.o_grant);
+ CDEBUG(D_CACHE, "got %llu extra grant\n", body->oa.o_grant);
__osc_update_grant(cli, body->oa.o_grant);
}
}
ergo(i > 0 && i < page_count - 1,
poff == 0 && pg->count == PAGE_CACHE_SIZE) &&
ergo(i == page_count - 1, poff == 0)),
- "i: %d/%d pg: %p off: "LPU64", count: %u\n",
+ "i: %d/%d pg: %p off: %llu, count: %u\n",
i, page_count, pg, pg->off, pg->count);
LASSERTF(i == 0 || pg->off > pg_prev->off,
- "i %d p_c %u pg %p [pri %lu ind %lu] off "LPU64
- " prev_pg %p [pri %lu ind %lu] off "LPU64"\n",
+ "i %d p_c %u pg %p [pri %lu ind %lu] off %llu"
+ " prev_pg %p [pri %lu ind %lu] off %llu\n",
i, page_count,
pg->pg, page_private(pg->pg), pg->pg->index, pg->off,
pg_prev->pg, page_private(pg_prev->pg),
"likely false positive due to mmap IO (bug 11742)";
LCONSOLE_ERROR_MSG(0x132, "BAD WRITE CHECKSUM: %s: from %s inode "DFID
- " object "DOSTID" extent ["LPU64"-"LPU64"]\n",
+ " object "DOSTID" extent [%llu-%llu]\n",
msg, libcfs_nid2str(peer->nid),
oa->o_valid & OBD_MD_FLFID ? oa->o_parent_seq : (__u64)0,
oa->o_valid & OBD_MD_FLFID ? oa->o_parent_oid : 0,
unsigned int qid[LL_MAXQUOTAS] =
{body->oa.o_uid, body->oa.o_gid};
- CDEBUG(D_QUOTA, "setdq for [%u %u] with valid "LPX64", flags %x\n",
+ CDEBUG(D_QUOTA, "setdq for [%u %u] with valid %#llx, flags %x\n",
body->oa.o_uid, body->oa.o_gid, body->oa.o_valid,
body->oa.o_flags);
osc_quota_setdq(cli, qid, body->oa.o_valid, body->oa.o_flags);
if (server_cksum != client_cksum) {
LCONSOLE_ERROR_MSG(0x133, "%s: BAD READ CHECKSUM: from "
"%s%s%s inode "DFID" object "DOSTID
- " extent ["LPU64"-"LPU64"]\n",
+ " extent [%llu-%llu]\n",
req->rq_import->imp_obd->obd_name,
libcfs_nid2str(peer->nid),
via, router,
rc = osc_brw_redo_request(req, aa, rc);
} else {
CERROR("%s: too many resent retries for object: "
- ""LPU64":"LPU64", rc = %d.\n",
+ "%llu:%llu, rc = %d.\n",
req->rq_import->imp_obd->obd_name,
POSTID(&aa->aa_oa->o_oi), rc);
}
* be valid. */
lock = ldlm_handle2lock(lockh);
LASSERTF(lock != NULL,
- "lockh "LPX64", req %p, aa %p - client evicted?\n",
+ "lockh %#llx, req %p, aa %p - client evicted?\n",
lockh->cookie, req, aa);
/* Take an additional reference so that a blocking AST that
cli->cl_lost_grant = 0;
spin_unlock(&cli->cl_loi_list_lock);
- CDEBUG(D_RPCTRACE, "ocd_connect_flags: "LPX64" ocd_version: %d"
+ CDEBUG(D_RPCTRACE, "ocd_connect_flags: %#llx ocd_version: %d"
" ocd_grant: %d, lost: %ld.\n", data->ocd_connect_flags,
data->ocd_version, data->ocd_grant, lost_grant);
}
LASSERT(versions);
lustre_msg_set_versions(reqmsg, versions);
- CDEBUG(D_INFO, "Client save versions ["LPX64"/"LPX64"]\n",
+ CDEBUG(D_INFO, "Client save versions [%#llx/%#llx]\n",
versions[0], versions[1]);
EXIT;
req = list_entry(imp->imp_unreplied_list.next, struct ptlrpc_request,
rq_unreplied_list);
- LASSERTF(req->rq_xid >= 1, "XID:"LPU64"\n", req->rq_xid);
+ LASSERTF(req->rq_xid >= 1, "XID:%llu\n", req->rq_xid);
if (imp->imp_known_replied_xid < req->rq_xid - 1)
imp->imp_known_replied_xid = req->rq_xid - 1;
}
CDEBUG(D_RPCTRACE, "Sending RPC pname:cluuid:pid:xid:nid:opc"
- " %s:%s:%d:"LPU64":%s:%d\n", current_comm(),
+ " %s:%s:%d:%llu:%s:%d\n", current_comm(),
imp->imp_obd->obd_uuid.uuid,
lustre_msg_get_status(req->rq_reqmsg), req->rq_xid,
libcfs_nid2str(imp->imp_connection->c_peer.nid),
CDEBUG(req->rq_reqmsg != NULL ? D_RPCTRACE : 0,
"Completed RPC pname:cluuid:pid:xid:nid:"
- "opc %s:%s:%d:"LPU64":%s:%d\n",
+ "opc %s:%s:%d:%llu:%s:%d\n",
current_comm(), imp->imp_obd->obd_uuid.uuid,
lustre_msg_get_status(req->rq_reqmsg), req->rq_xid,
libcfs_nid2str(imp->imp_connection->c_peer.nid),
if (imp->imp_peer_committed_transno == imp->imp_last_transno_checked &&
imp->imp_generation == imp->imp_last_generation_checked) {
- CDEBUG(D_INFO, "%s: skip recheck: last_committed "LPU64"\n",
+ CDEBUG(D_INFO, "%s: skip recheck: last_committed %llu\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno);
RETURN_EXIT;
}
- CDEBUG(D_RPCTRACE, "%s: committing for last_committed "LPU64" gen %d\n",
+ CDEBUG(D_RPCTRACE, "%s: committing for last_committed %llu gen %d\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno,
imp->imp_generation);
continue;
}
- DEBUG_REQ(D_INFO, req, "commit (last_committed "LPU64")",
+ DEBUG_REQ(D_INFO, req, "commit (last_committed %llu)",
imp->imp_peer_committed_transno);
free_req:
ptlrpc_free_request(req);
LASSERTF(lustre_msg_get_transno(req->rq_reqmsg) ==
lustre_msg_get_transno(req->rq_repmsg) ||
lustre_msg_get_transno(req->rq_repmsg) == 0,
- LPX64"/"LPX64"\n",
+ "%#llx/%#llx\n",
lustre_msg_get_transno(req->rq_reqmsg),
lustre_msg_get_transno(req->rq_repmsg));
}
/* transaction number shouldn't be bigger than the latest replayed */
if (req->rq_transno > lustre_msg_get_transno(req->rq_reqmsg)) {
DEBUG_REQ(D_ERROR, req,
- "Reported transno "LPU64" is bigger than the "
- "replayed one: "LPU64, req->rq_transno,
+ "Reported transno %llu is bigger than the "
+ "replayed one: %llu", req->rq_transno,
lustre_msg_get_transno(req->rq_reqmsg));
GOTO(out, rc = -EINVAL);
}
req->rq_mbits = req->rq_xid;
spin_unlock(&req->rq_import->imp_lock);
}
- CDEBUG(D_HA, "resend bulk old x"LPU64" new x"LPU64"\n",
+ CDEBUG(D_HA, "resend bulk old x%llu new x%llu\n",
old_mbits, req->rq_mbits);
}
req->rq_rqbd = rqbd;
req->rq_phase = RQ_PHASE_NEW;
if (ev->type == LNET_EVENT_PUT)
- CDEBUG(D_INFO, "incoming req@%p x"LPU64" msgsize %u\n",
+ CDEBUG(D_INFO, "incoming req@%p x%llu msgsize %u\n",
req, req->rq_xid, ev->mlength);
CDEBUG(D_RPCTRACE, "peer: %s\n", libcfs_id2str(req->rq_peer));
might_sleep();
- CWARN("%s ctx %p idx "LPX64" (%u->%s)\n",
+ CWARN("%s ctx %p idx %#llx (%u->%s)\n",
sec_is_reverse(ctx->cc_sec) ?
"server finishing reverse" : "client finishing forward",
ctx, gss_handle_to_u64(&gctx->gc_handle),
if (coinfo == NULL)
goto out;
- snprintf(coinfo, coinfo_size, "%d:%s:%u:%u:%s:%c:%d:"LPX64":%s:"LPX64,
+ snprintf(coinfo, coinfo_size, "%d:%s:%u:%u:%s:%c:%d:%#llx:%s:%#llx",
sec->ps_id, sec2gsec(sec)->gs_mech->gm_name,
vcred->vc_uid, vcred->vc_gid,
sec_part_flags, svc_flag, import_to_gss_svc(imp),
seq_printf(seq, "%p: uid %u, ref %d, expire %lu(%+ld), fl %s, "
"seq %d, win %u, key %08x(ref %d), "
- "hdl "LPX64":"LPX64", mech: %s\n",
+ "hdl %#llx:%#llx, mech: %s\n",
ctx, ctx->cc_vcred.vc_uid,
atomic_read(&ctx->cc_refcount),
ctx->cc_expire,
gumd = &gmsg->gum_data;
LASSERT(atomic_read(&gmsg->gum_refcount) > 0);
- CERROR("failed msg %p (seq %u, uid %u, svc %u, nid "LPX64", obd %.*s): "
+ CERROR("failed msg %p (seq %u, uid %u, svc %u, nid %#llx, obd %.*s): "
"errno %d\n", msg, gumd->gum_seq, gumd->gum_uid, gumd->gum_svc,
gumd->gum_nid, (int) sizeof(gumd->gum_obd),
gumd->gum_obd, msg->errno);
LASSERT(list_empty(&gmsg->gum_base.list));
CERROR("failing remaining msg %p:seq %u, uid %u, svc %u, "
- "nid "LPX64", obd %.*s\n", gmsg,
+ "nid %#llx, obd %.*s\n", gmsg,
gumd->gum_seq, gumd->gum_uid, gumd->gum_svc,
gumd->gum_nid, (int) sizeof(gumd->gum_obd),
gumd->gum_obd);
rscp->target = imp->imp_obd;
rawobj_dup(&gctx->gc_svc_handle, &rscp->handle);
- CWARN("create reverse svc ctx %p to %s: idx "LPX64"\n",
+ CWARN("create reverse svc ctx %p to %s: idx %#llx\n",
&rscp->ctx, obd2cli_tgt(imp->imp_obd), gsec->gs_rvs_hdl);
rc = 0;
out:
rsc_free(&rsci);
if (rc)
- CERROR("create reverse svc ctx: idx "LPX64", rc %d\n",
+ CERROR("create reverse svc ctx: idx %#llx, rc %d\n",
gsec->gs_rvs_hdl, rc);
RETURN(rc);
}
if (rc != SECSVC_OK)
set_bit(CACHE_NEGATIVE, &rsci->h.flags);
else
- CDEBUG(D_SEC, "create rsc with idx "LPX64"\n",
+ CDEBUG(D_SEC, "create rsc with idx %#llx\n",
gss_handle_to_u64(&rsci->handle));
COMPAT_RSC_PUT(&rsci->h, &rsc_cache);
rsc = gss_svc_searchbyctx(&gw->gw_handle);
if (!rsc) {
- CWARN("Invalid gss ctx idx "LPX64" from %s\n",
+ CWARN("Invalid gss ctx idx %#llx from %s\n",
gss_handle_to_u64(&gw->gw_handle),
libcfs_nid2str(req->rq_peer.nid));
return NULL;
set_bit(PTLRPC_CTX_UPTODATE_BIT, &ctx->cc_flags);
if (sec_is_reverse(ctx->cc_sec)) {
- CWARN("server installed reverse ctx %p idx "LPX64", "
+ CWARN("server installed reverse ctx %p idx %#llx, "
"expiry %lu(%+lds)\n", ctx,
gss_handle_to_u64(&gctx->gc_handle),
ctx->cc_expire,
cfs_time_sub(ctx->cc_expire, cfs_time_current_sec()));
} else {
- CWARN("client refreshed ctx %p idx "LPX64" (%u->%s), "
+ CWARN("client refreshed ctx %p idx %#llx (%u->%s), "
"expiry %lu(%+lds)\n", ctx,
gss_handle_to_u64(&gctx->gc_handle),
ctx->cc_vcred.vc_uid, sec2target_str(ctx->cc_sec),
errhdr = (struct gss_err_header *) ghdr;
- CWARN("req x"LPU64"/t"LPU64", ctx %p idx "LPX64"(%u->%s): "
+ CWARN("req x%llu/t%llu, ctx %p idx %#llx(%u->%s): "
"%sserver respond (%08x/%08x)\n",
req->rq_xid, req->rq_transno, ctx,
gss_handle_to_u64(&ctx2gctx(ctx)->gc_handle),
if (rc == 0)
RETURN(SECSVC_OK);
- CERROR("svc %u failed: major 0x%08x: req xid "LPU64" ctx %p idx "
- LPX64"(%u->%s)\n", gw->gw_svc, major, req->rq_xid,
+ CERROR("svc %u failed: major 0x%08x: req xid %llu ctx %p idx "
+ "%#llx(%u->%s)\n", gw->gw_svc, major, req->rq_xid,
grctx->src_ctx, gss_handle_to_u64(&gw->gw_handle),
grctx->src_ctx->gsc_uid, libcfs_nid2str(req->rq_peer.nid));
error:
if (gss_svc_verify_request(req, grctx, gw, &major))
RETURN(SECSVC_DROP);
- CWARN("destroy svc ctx %p idx "LPX64" (%u->%s)\n",
+ CWARN("destroy svc ctx %p idx %#llx (%u->%s)\n",
grctx->src_ctx, gss_handle_to_u64(&gw->gw_handle),
grctx->src_ctx->gsc_uid, libcfs_nid2str(req->rq_peer.nid));
}
list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
- CDEBUG(D_HA, "%s: connect to NID %s last attempt "LPU64"\n",
+ CDEBUG(D_HA, "%s: connect to NID %s last attempt %llu\n",
imp->imp_obd->obd_name,
libcfs_nid2str(conn->oic_conn->c_peer.nid),
conn->oic_last_attempt);
!(ocd->ocd_connect_flags & OBD_CONNECT_IBITS)) {
LCONSOLE_WARN("%s: MDS %s does not support ibits "
"lock, either very old or invalid: "
- "requested "LPX64", replied "LPX64"\n",
+ "requested %#llx, replied %#llx\n",
imp->imp_obd->obd_name,
imp->imp_connection->c_remote_uuid.uuid,
imp->imp_connect_flags_orig,
* disable lru_resize, etc. */
if (old_connect_flags != exp_connect_flags(exp) || init_connect) {
CDEBUG(D_HA, "%s: Resetting ns_connect_flags to server "
- "flags: "LPX64"\n", imp->imp_obd->obd_name,
+ "flags: %#llx\n", imp->imp_obd->obd_name,
ocd->ocd_connect_flags);
imp->imp_obd->obd_namespace->ns_connect_flags =
ocd->ocd_connect_flags;
if ((ocd->ocd_connect_flags & imp->imp_connect_flags_orig) !=
ocd->ocd_connect_flags) {
CERROR("%s: Server didn't grant requested subset of flags: "
- "asked="LPX64" granted="LPX64"\n",
+ "asked=%#llx granted=%#llx\n",
imp->imp_obd->obd_name, imp->imp_connect_flags_orig,
ocd->ocd_connect_flags);
GOTO(out, rc = -EPROTO);
if ((ocd->ocd_connect_flags2 & imp->imp_connect_flags2_orig) !=
ocd->ocd_connect_flags2) {
CERROR("%s: Server didn't grant requested subset of flags2: "
- "asked="LPX64" granted="LPX64"\n",
+ "asked=%#llx granted=%#llx\n",
imp->imp_obd->obd_name, imp->imp_connect_flags2_orig,
ocd->ocd_connect_flags2);
GOTO(out, rc = -EPROTO);
if (!memcmp(&old_hdl, lustre_msg_get_handle(request->rq_repmsg),
sizeof (old_hdl))) {
LCONSOLE_WARN("Reconnect to %s (at @%s) failed due "
- "bad handle "LPX64"\n",
+ "bad handle %#llx\n",
obd2cli_tgt(imp->imp_obd),
imp->imp_connection->c_remote_uuid.uuid,
imp->imp_dlm_handle.cookie);
* with server again */
if ((MSG_CONNECT_RECOVERING & msg_flags)) {
CDEBUG(level,"%s@%s changed server handle from "
- LPX64" to "LPX64
+ "%#llx to %#llx"
" but is still in recovery\n",
obd2cli_tgt(imp->imp_obd),
imp->imp_connection->c_remote_uuid.uuid,
} else {
LCONSOLE_WARN("Evicted from %s (at %s) "
"after server handle changed from "
- LPX64" to "LPX64"\n",
+ "%#llx to %#llx\n",
obd2cli_tgt(imp->imp_obd),
imp->imp_connection-> \
c_remote_uuid.uuid,
if (lustre_msg_get_last_committed(request->rq_repmsg) > 0 &&
lustre_msg_get_last_committed(request->rq_repmsg) <
aa->pcaa_peer_committed) {
- CERROR("%s went back in time (transno "LPD64
- " was previously committed, server now claims "LPD64
+ CERROR("%s went back in time (transno %lld"
+ " was previously committed, server now claims %lld"
")! See https://bugzilla.lustre.org/show_bug.cgi?"
"id=9646\n",
obd2cli_tgt(imp->imp_obd), aa->pcaa_peer_committed,
* be near the head), we shouldn't have to do long
* re-scans */
LASSERTF(srhi->srhi_seq == srhi->srhi_req->rq_history_seq,
- "%s:%d: seek seq "LPU64", request seq "LPU64"\n",
+ "%s:%d: seek seq %llu, request seq %llu\n",
svcpt->scp_service->srv_name, svcpt->scp_cpt,
srhi->srhi_seq, srhi->srhi_req->rq_history_seq);
LASSERTF(!list_empty(&svcpt->scp_hist_reqs),
- "%s:%d: seek offset "LPU64", request seq "LPU64", "
- "last culled "LPU64"\n",
+ "%s:%d: seek offset %llu, request seq %llu, "
+ "last culled %llu\n",
svcpt->scp_service->srv_name, svcpt->scp_cpt,
seq, srhi->srhi_seq, svcpt->scp_hist_seq_culled);
e = &srhi->srhi_req->rq_history_list;
* must be just as careful as the service's request
* parser. Currently I only print stuff here I know is OK
* to look at coz it was set up in request_in_callback()!!! */
- seq_printf(s, LPD64":%s:%s:x"LPU64":%d:%s:"
+ seq_printf(s, "%lld:%s:%s:x%llu:%d:%s:"
"%ld.%06ld:%ld.%06lds(%+ld.0s) ",
req->rq_history_seq, nidstr,
libcfs_id2str(req->rq_peer), req->rq_xid,
RETURN (-ENOMEM);
}
- CDEBUG(D_NET, "Sending %d bytes to portal %d, xid "LPD64", offset %u\n",
+ CDEBUG(D_NET, "Sending %d bytes to portal %d, xid %lld, offset %u\n",
len, portal, xid, offset);
rc = LNetPut (conn->c_self, *mdh, ack,
/* We're going to get an UNLINK event when I unlink below,
* which will complete just like any other failed send, so
* I fall through and return success here! */
- CERROR("LNetPut(%s, %d, "LPD64") failed: %d\n",
+ CERROR("LNetPut(%s, %d, %lld) failed: %d\n",
libcfs_id2str(conn->c_peer), portal, xid, rc);
rc2 = LNetMDUnlink(*mdh);
LASSERTF(rc2 == 0, "rc2 = %d\n", rc2);
posted_md++;
if (rc != 0) {
- CERROR("%s: failed bulk transfer with %s:%u x"LPU64": "
+ CERROR("%s: failed bulk transfer with %s:%u x%llu: "
"rc = %d\n", exp->exp_obd->obd_name,
libcfs_id2str(conn->c_peer), desc->bd_portal,
mbits, rc);
}
CDEBUG(D_NET, "Transferring %u pages %u bytes via portal %d "
- "id %s mbits "LPX64"-"LPX64"\n", desc->bd_iov_count,
+ "id %s mbits %#llx-%#llx\n", desc->bd_iov_count,
desc->bd_nob, desc->bd_portal, libcfs_id2str(conn->c_peer),
mbits - posted_md, mbits - 1);
mbits = req->rq_mbits - total_md + 1;
LASSERTF(mbits == (req->rq_mbits & PTLRPC_BULK_OPS_MASK),
- "first mbits = x"LPU64", last mbits = x"LPU64"\n",
+ "first mbits = x%llu, last mbits = x%llu\n",
mbits, req->rq_mbits);
LASSERTF(!(desc->bd_registered &&
req->rq_send_state != LUSTRE_IMP_REPLAY) ||
mbits != desc->bd_last_mbits,
- "registered: %d rq_mbits: "LPU64" bd_last_mbits: "LPU64"\n",
+ "registered: %d rq_mbits: %llu bd_last_mbits: %llu\n",
desc->bd_registered, mbits, desc->bd_last_mbits);
desc->bd_registered = 1;
rc = LNetMEAttach(desc->bd_portal, peer, mbits, 0,
LNET_UNLINK, LNET_INS_AFTER, &me_h);
if (rc != 0) {
- CERROR("%s: LNetMEAttach failed x"LPU64"/%d: rc = %d\n",
+ CERROR("%s: LNetMEAttach failed x%llu/%d: rc = %d\n",
desc->bd_import->imp_obd->obd_name, mbits,
posted_md, rc);
break;
rc = LNetMDAttach(me_h, md, LNET_UNLINK,
&desc->bd_mds[posted_md]);
if (rc != 0) {
- CERROR("%s: LNetMDAttach failed x"LPU64"/%d: rc = %d\n",
+ CERROR("%s: LNetMDAttach failed x%llu/%d: rc = %d\n",
desc->bd_import->imp_obd->obd_name, mbits,
posted_md, rc);
rc2 = LNetMEUnlink(me_h);
spin_unlock(&desc->bd_lock);
CDEBUG(D_NET, "Setup %u bulk %s buffers: %u pages %u bytes, "
- "mbits x"LPX64"-"LPX64", portal %u\n", desc->bd_md_count,
+ "mbits x%#llx-%#llx, portal %u\n", desc->bd_md_count,
ptlrpc_is_bulk_op_get(desc->bd_type) ? "get-source" : "put-sink",
desc->bd_iov_count, desc->bd_nob,
desc->bd_last_mbits, req->rq_mbits, desc->bd_portal);
if (list_empty(&request->rq_unreplied_list) ||
request->rq_xid <= imp->imp_known_replied_xid) {
- DEBUG_REQ(D_ERROR, request, "xid: "LPU64", replied: "LPU64", "
+ DEBUG_REQ(D_ERROR, request, "xid: %llu, replied: %llu, "
"list_empty:%d\n", request->rq_xid,
imp->imp_known_replied_xid,
list_empty(&request->rq_unreplied_list));
GOTO(cleanup_me, rc = -ENOMEM);
}
- CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid "LPU64
+ CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid %llu"
", portal %u\n",
request->rq_repbuf_len, request->rq_xid,
request->rq_reply_portal);
CDEBUG(D_RPCTRACE,
"NRS: starting to handle %s request from %s, with round "
- LPU64"\n", NRS_POL_NAME_CRRN,
+ "%llu\n", NRS_POL_NAME_CRRN,
libcfs_id2str(req->rq_peer), nrq->nr_u.crr.cr_round);
/** Peek at the next request to be served */
rq_nrq);
CDEBUG(D_RPCTRACE,
- "NRS: finished handling %s request from %s, with round "LPU64
+ "NRS: finished handling %s request from %s, with round %llu"
"\n", NRS_POL_NAME_CRRN,
libcfs_id2str(req->rq_peer), nrq->nr_u.crr.cr_round);
}
list_del_init(&nrq->nr_u.fifo.fr_list);
- CDEBUG(D_RPCTRACE, "NRS start %s request from %s, seq: "LPU64
+ CDEBUG(D_RPCTRACE, "NRS start %s request from %s, seq: %llu"
"\n", policy->pol_desc->pd_name,
libcfs_id2str(req->rq_peer), nrq->nr_u.fifo.fr_sequence);
}
struct ptlrpc_request *req = container_of(nrq, struct ptlrpc_request,
rq_nrq);
- CDEBUG(D_RPCTRACE, "NRS stop %s request from %s, seq: "LPU64"\n",
+ CDEBUG(D_RPCTRACE, "NRS stop %s request from %s, seq: %llu\n",
policy->pol_desc->pd_name, libcfs_id2str(req->rq_peer),
nrq->nr_u.fifo.fr_sequence);
}
CDEBUG(D_RPCTRACE,
"NRS: starting to handle %s request for object "
"with FID "DFID", from OST with index %u, with "
- "round "LPU64"\n", NRS_POL_NAME_ORR,
+ "round %llu\n", NRS_POL_NAME_ORR,
PFID(&orro->oo_key.ok_fid),
nrq->nr_u.orr.or_key.ok_idx,
nrq->nr_u.orr.or_round);
else
CDEBUG(D_RPCTRACE,
"NRS: starting to handle %s request from OST "
- "with index %u, with round "LPU64"\n",
+ "with index %u, with round %llu\n",
NRS_POL_NAME_TRR, nrq->nr_u.orr.or_key.ok_idx,
nrq->nr_u.orr.or_round);
NRS_POL_NAME_MAX) == 0)
CDEBUG(D_RPCTRACE,
"NRS: finished handling %s request for object with FID "
- DFID", from OST with index %u, with round "LPU64"\n",
+ DFID", from OST with index %u, with round %llu\n",
NRS_POL_NAME_ORR, PFID(&nrq->nr_u.orr.or_key.ok_fid),
nrq->nr_u.orr.or_key.ok_idx, nrq->nr_u.orr.or_round);
else
CDEBUG(D_RPCTRACE,
"NRS: finished handling %s request from OST with index %u,"
- " with round "LPU64"\n",
+ " with round %llu\n",
NRS_POL_NAME_TRR, nrq->nr_u.orr.or_key.ok_idx,
nrq->nr_u.orr.or_round);
}
}
CDEBUG(D_RPCTRACE,
"NRS start %s request from %s, "
- "seq: "LPU64"\n",
+ "seq: %llu\n",
policy->pol_desc->pd_name,
libcfs_id2str(req->rq_peer),
nrq->nr_u.tbf.tr_sequence);
assert_spin_locked(&policy->pol_nrs->nrs_svcpt->scp_req_lock);
- CDEBUG(D_RPCTRACE, "NRS stop %s request from %s, seq: "LPU64"\n",
+ CDEBUG(D_RPCTRACE, "NRS stop %s request from %s, seq: %llu\n",
policy->pol_desc->pd_name, libcfs_id2str(req->rq_peer),
nrq->nr_u.tbf.tr_sequence);
}
CDEBUG(lvl, "%s lov_user_md %p:\n", msg, lum);
CDEBUG(lvl, "\tlmm_magic: %#x\n", lum->lmm_magic);
CDEBUG(lvl, "\tlmm_pattern: %#x\n", lum->lmm_pattern);
- CDEBUG(lvl, "\tlmm_object_id: "LPU64"\n", lmm_oi_id(&lum->lmm_oi));
- CDEBUG(lvl, "\tlmm_object_gr: "LPU64"\n", lmm_oi_seq(&lum->lmm_oi));
+ CDEBUG(lvl, "\tlmm_object_id: %llu\n", lmm_oi_id(&lum->lmm_oi));
+ CDEBUG(lvl, "\tlmm_object_gr: %llu\n", lmm_oi_seq(&lum->lmm_oi));
CDEBUG(lvl, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size);
CDEBUG(lvl, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count);
CDEBUG(lvl, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n",
void dump_rniobuf(struct niobuf_remote *nb)
{
- CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
+ CDEBUG(D_RPCTRACE, "niobuf_remote: offset=%llu, len=%d, flags=%x\n",
nb->rnb_offset, nb->rnb_len, nb->rnb_flags);
}
{
u64 valid = oa->o_valid;
- CDEBUG(D_RPCTRACE, "obdo: o_valid = "LPX64"\n", valid);
+ CDEBUG(D_RPCTRACE, "obdo: o_valid = %#llx\n", valid);
if (valid & OBD_MD_FLID)
CDEBUG(D_RPCTRACE, "obdo: id = "DOSTID"\n", POSTID(&oa->o_oi));
if (valid & OBD_MD_FLFID)
- CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = "LPX64"\n",
+ CDEBUG(D_RPCTRACE, "obdo: o_parent_seq = %#llx\n",
oa->o_parent_seq);
if (valid & OBD_MD_FLSIZE)
- CDEBUG(D_RPCTRACE, "obdo: o_size = "LPD64"\n", oa->o_size);
+ CDEBUG(D_RPCTRACE, "obdo: o_size = %lld\n", oa->o_size);
if (valid & OBD_MD_FLMTIME)
- CDEBUG(D_RPCTRACE, "obdo: o_mtime = "LPD64"\n", oa->o_mtime);
+ CDEBUG(D_RPCTRACE, "obdo: o_mtime = %lld\n", oa->o_mtime);
if (valid & OBD_MD_FLATIME)
- CDEBUG(D_RPCTRACE, "obdo: o_atime = "LPD64"\n", oa->o_atime);
+ CDEBUG(D_RPCTRACE, "obdo: o_atime = %lld\n", oa->o_atime);
if (valid & OBD_MD_FLCTIME)
- CDEBUG(D_RPCTRACE, "obdo: o_ctime = "LPD64"\n", oa->o_ctime);
+ CDEBUG(D_RPCTRACE, "obdo: o_ctime = %lld\n", oa->o_ctime);
if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
- CDEBUG(D_RPCTRACE, "obdo: o_blocks = "LPD64"\n", oa->o_blocks);
+ CDEBUG(D_RPCTRACE, "obdo: o_blocks = %lld\n", oa->o_blocks);
if (valid & OBD_MD_FLGRANT)
- CDEBUG(D_RPCTRACE, "obdo: o_grant = "LPD64"\n", oa->o_grant);
+ CDEBUG(D_RPCTRACE, "obdo: o_grant = %lld\n", oa->o_grant);
if (valid & OBD_MD_FLBLKSZ)
CDEBUG(D_RPCTRACE, "obdo: o_blksize = %d\n", oa->o_blksize);
if (valid & (OBD_MD_FLTYPE | OBD_MD_FLMODE))
CDEBUG(D_RPCTRACE, "obdo: o_parent_oid = %x\n",
oa->o_parent_oid);
if (valid & OBD_MD_FLEPOCH)
- CDEBUG(D_RPCTRACE, "obdo: o_ioepoch = "LPD64"\n",
+ CDEBUG(D_RPCTRACE, "obdo: o_ioepoch = %lld\n",
oa->o_ioepoch);
if (valid & OBD_MD_FLFID) {
CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n",
oa->o_parent_ver);
}
if (valid & OBD_MD_FLHANDLE)
- CDEBUG(D_RPCTRACE, "obdo: o_handle = "LPD64"\n",
+ CDEBUG(D_RPCTRACE, "obdo: o_handle = %lld\n",
oa->o_handle.cookie);
}
va_start(args, fmt);
libcfs_debug_vmsg2(msgdata, fmt, args,
- " req@%p x"LPU64"/t"LPD64"("LPD64") o%d->%s@%s:%d/%d"
+ " req@%p x%llu/t%lld(%lld) o%d->%s@%s:%d/%d"
" lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d "
"fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n",
req, req->rq_xid, req->rq_transno,
last_transno = imp->imp_last_replay_transno;
spin_unlock(&imp->imp_lock);
- CDEBUG(D_HA, "import %p from %s committed "LPU64" last "LPU64"\n",
+ CDEBUG(D_HA, "import %p from %s committed %llu last %llu\n",
imp, obd2cli_tgt(imp->imp_obd),
imp->imp_peer_committed_transno, last_transno);
rc = ptlrpc_replay_req(req);
if (rc) {
CERROR("recovery replay error %d for req "
- LPU64"\n", rc, req->rq_xid);
+ "%llu\n", rc, req->rq_xid);
RETURN(rc);
}
*inflight = 1;
case 0:
break;
default:
- CERROR("failed unpack reply: x"LPU64"\n", req->rq_xid);
+ CERROR("failed unpack reply: x%llu\n", req->rq_xid);
RETURN(-EPROTO);
}
case 0:
break;
default:
- CERROR("error unpacking request from %s x"LPU64"\n",
+ CERROR("error unpacking request from %s x%llu\n",
libcfs_id2str(req->rq_peer), req->rq_xid);
RETURN(SECSVC_DROP);
}
} else if (lustre_msg_get_transno(req->rq_reqmsg) != 0 &&
!obd->obd_recovering) {
DEBUG_REQ(D_ERROR, req, "Invalid req with transno "
- LPU64" without recovery",
+ "%llu without recovery",
lustre_msg_get_transno(req->rq_reqmsg));
class_fail_export(req->rq_export);
rc = -ENODEV;
rc = ptlrpc_unpack_req_msg(req, req->rq_reqlen);
if (rc != 0) {
CERROR("error unpacking request: ptl %d from %s "
- "x"LPU64"\n", svc->srv_req_portal,
+ "x%llu\n", svc->srv_req_portal,
libcfs_id2str(req->rq_peer), req->rq_xid);
goto err_req;
}
rc = lustre_unpack_req_ptlrpc_body(req, MSG_PTLRPC_BODY_OFF);
if (rc) {
CERROR ("error unpacking ptlrpc body: ptl %d from %s x"
- LPU64"\n", svc->srv_req_portal,
+ "%llu\n", svc->srv_req_portal,
libcfs_id2str(req->rq_peer), req->rq_xid);
goto err_req;
}
if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_REQ_OPC) &&
lustre_msg_get_opc(req->rq_reqmsg) == cfs_fail_val) {
- CERROR("drop incoming rpc opc %u, x"LPU64"\n",
+ CERROR("drop incoming rpc opc %u, x%llu\n",
cfs_fail_val, req->rq_xid);
goto err_req;
}
break;
}
- CDEBUG(D_RPCTRACE, "got req x"LPU64"\n", req->rq_xid);
+ CDEBUG(D_RPCTRACE, "got req x%llu\n", req->rq_xid);
req->rq_export = class_conn2export(
lustre_msg_get_handle(req->rq_reqmsg));
}
CDEBUG(D_RPCTRACE, "Handling RPC pname:cluuid+ref:pid:xid:nid:opc "
- "%s:%s+%d:%d:x"LPU64":%s:%d\n", current_comm(),
+ "%s:%s+%d:%d:x%llu:%s:%d\n", current_comm(),
(request->rq_export ?
(char *)request->rq_export->exp_client_uuid.uuid : "0"),
(request->rq_export ?
if (lustre_msg_get_opc(request->rq_reqmsg) != OBD_PING)
CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_PAUSE_REQ, cfs_fail_val);
- CDEBUG(D_NET, "got req "LPU64"\n", request->rq_xid);
+ CDEBUG(D_NET, "got req %llu\n", request->rq_xid);
/* re-assign request and sesson thread to the current one */
request->rq_svc_thread = thread;
do_gettimeofday(&work_end);
timediff = cfs_timeval_sub(&work_end, &work_start, NULL);
CDEBUG(D_RPCTRACE, "Handled RPC pname:cluuid+ref:pid:xid:nid:opc "
- "%s:%s+%d:%d:x"LPU64":%s:%d Request procesed in "
- "%ldus (%ldus total) trans "LPU64" rc %d/%d\n",
+ "%s:%s+%d:%d:x%llu:%s:%d Request procesed in "
+ "%ldus (%ldus total) trans %llu rc %d/%d\n",
current_comm(),
(request->rq_export ?
(char *)request->rq_export->exp_client_uuid.uuid : "0"),
if (nlocks == 0 && !been_handled) {
/* If we see this, we should already have seen the warning
* in mds_steal_ack_locks() */
- CDEBUG(D_HA, "All locks stolen from rs %p x"LPD64".t"LPD64
+ CDEBUG(D_HA, "All locks stolen from rs %p x%lld.t%lld"
" o%d NID %s\n",
rs,
rs->rs_xid, rs->rs_transno, rs->rs_opc,