Originally when lustre code was built for userland we needed
a proper way to handle 32 bit and 64 bit platforms when
reporting unsigned longs. Now that this code is only built
for kernel space and the kernel has it own special string
handling functions we don't need this abstraction anymore.
Remove this abstraction from the client side code.
Change-Id: Ic0c55a413237bdf57d60031c12d5d9b62fa39cef
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: http://review.whamcloud.com/20590
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>
Reviewed-by: Bob Glossman <bob.glossman@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
88 files changed:
*seqnr = seq->lcs_space.lsr_start;
seq->lcs_space.lsr_start += 1;
*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,
mutex_lock(&seq->lcs_mutex);
if (seqnr != 0) {
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;
seq->lcs_name, seqnr);
seq->lcs_fid.f_seq = seqnr;
LASSERT(seq != NULL);
mutex_lock(&seq->lss_mutex);
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);
mutex_unlock(&seq->lss_mutex);
RETURN(0);
- 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);
seq->lss_name, seq->lss_width);
out_unlock:
mutex_unlock(&seq->lss_mutex);
LASSERT(seq != NULL);
mutex_lock(&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);
mutex_unlock(&seq->lss_mutex);
RETURN(0);
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
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);
PRANGE(&seq->lcs_space));
mutex_unlock(&seq->lcs_mutex);
if (val <= max && val > 0) {
seq->lcs_width = val;
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);
seq->lcs_name, seq->lcs_width);
} else {
GOTO(out_unlock, count = -ERANGE);
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
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);
mutex_unlock(&seq->lcs_mutex);
RETURN(0);
}
CDEBUG(D_INFO, "FLD cache statistics (%s):\n", cache->fci_name);
}
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);
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 */
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) {
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);
}
"yet: rc = %d.\n", fld->lsf_name, seq, -EIO);
RETURN(-EIO);
}
- 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);
fld->lsf_name, seq, PRANGE(range), rc);
RETURN(rc);
- 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);
"Targets (%d):\n", fld->lcf_name, hash, seq,
fld->lcf_count);
(char *)target->ft_exp->exp_obd->obd_uuid.uuid :
"<null>";
(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);
}
target->ft_exp, exp_name, target->ft_srv,
srv_name, target->ft_idx);
}
spin_unlock(&fld->lcf_lock);
if (target != NULL) {
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,
LASSERT(name != NULL);
LASSERT(tar->ft_srv != NULL || tar->ft_exp != NULL);
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);
name, tar->ft_idx);
OBD_ALLOC_PTR(target);
if (tmp->ft_idx == tar->ft_idx) {
spin_unlock(&fld->lcf_lock);
OBD_FREE_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);
}
name, fld_target_name(tmp), tmp->ft_idx);
RETURN(-EEXIST);
}
LASSERT(target != NULL);
origin = target;
again:
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;
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->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;
fid->f_seq = seq;
}
fid->f_oid = 0;
OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, statfs);
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 {
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->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);
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);
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 {
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);
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)); \
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"); \
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,
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, 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);
}
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)) {
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]);
if (lck->l_policy_data.l_extent.end + 1 > kms)
kms = lck->l_policy_data.l_extent.end + 1;
}
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);
- 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 */
mode, flags);
/* Safe to not lock here, since it should be empty anyway */
const struct ldlm_callback_suite null_cbs = { NULL };
ENTRY;
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,
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);
}
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);
flags, data, getlk);
LASSERT(flags != LDLM_FL_WAIT_NOREPROC);
if (data) {
LASSERTF((ocd->ocd_connect_flags & data->ocd_connect_flags) ==
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
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
- 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);
}
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,"
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);
/* 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) "
/* 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 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);
obd_uuid2str(&exp->exp_client_uuid),
obd_export_nid2str(exp),
hdl->cookie, conn->cookie);
- 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(),
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, "
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);
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)) {
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)) {
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,
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: "
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);
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"
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;
}
obd->obd_next_recovery_transno = req_transno;
wake_up = 1;
}
* clients */
abort_req_replay_queue(obd);
abort_lock_replay_queue(obd);
* 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 {
")in the queue.\n", obd->obd_name,
next_update_transno);
} else {
struct obd_device *obd,
struct ptlrpc_request *req)
{
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));
" update records are found.\n",
lustre_msg_get_transno(req->rq_reqmsg),
libcfs_nid2str(req->rq_peer.nid));
- 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 */
obd->obd_next_recovery_transno);
/* Replay all of request and update by transno */
}
LASSERT(trd->trd_processing_task == current_pid());
}
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));
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) {
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);
" to finish list\n", dtrq->dtrq_xid,
dtrq->dtrq_master_transno);
/* next stage: replay requests or update */
delta = jiffies;
/* 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);
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, "
}
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;
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.
*/
* 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
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);
"%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);
}
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);
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 */
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);
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);
}
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);
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);
}
ldlm_lock_decref_internal(lock, mode);
LDLM_LOCK_PUT(lock);
}
- 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) ?
(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 "
} 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,
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,
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),
"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,
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,
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,
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 "
"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,
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,
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,
"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,
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,
"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,
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,
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,
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",
libcfs_nid2str(peer.nid),
req->rq_replied ? "returned error from" :
"failed to reply to",
struct ldlm_resource *res = lock->l_resource;
LDLM_DEBUG(lock,
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,
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) {
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);
}
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. "
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");
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) {
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);
}
}
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 = ldlm_handle2lock(&dlm_req->lock_handle[i]);
if (!lock) {
LDLM_DEBUG_NOLOCK("server-side cancel handler stale "
- "lock (cookie "LPU64")",
dlm_req->lock_handle[i].cookie);
continue;
}
dlm_req->lock_handle[i].cookie);
continue;
}
const struct lustre_handle *handle)
{
DEBUG_REQ((req->rq_no_reply || rc) ? D_WARNING : D_DLMTRACE, req,
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)
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) {
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,
"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)) {
* 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);
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 "
struct ldlm_request *dlm_req;
CERROR("%s from %s arrived at %lu with bad export cookie "
ll_opcode2str(lustre_msg_get_opc(req->rq_reqmsg)),
libcfs_nid2str(req->rq_peer.nid),
req->rq_arrival_time.tv_sec,
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,
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);
spin_unlock(&pl->pl_lock);
seq_printf(m, "LDLM pool state (%s):\n"
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);
" LVF: %d\n",
pl->pl_name, slv, clv, lvf);
LDLM_FL_INHERIT_MASK);
unlock_res_and_lock(lock);
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, reply->lock_handle.cookie, *flags);
/* If enqueue returned a blocked lock but the completion handler has
lock->l_req_extent = policy->l_extent;
}
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",
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 "
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);
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. */
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]);
lock = ldlm_handle2lock(&aa->lock_handle);
if (!lock) {
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));
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)
{
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);
static int seq_granted_show(struct seq_file *m, void *data)
{
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;
}
(struct percpu_counter *)m->private));
return 0;
}
handle.cookie = it->it_lock_handle;
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
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"
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;
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 ("
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;
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. "
(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
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 */
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);
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;
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);
PFID(&lli->lli_fid), attr->cat_size);
i_size_write(inode, attr->cat_size);
- 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:
file_dentry(file)->d_name.name, iot, *ppos, count);
restart:
if (IS_ERR(op_data))
RETURN(PTR_ERR(op_data));
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);
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;
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;
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
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);
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)"
handle.cookie = it->it_lock_handle;
CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID"(%p)"
PFID(ll_inode2fid(inode)), inode, handle.cookie);
md_set_lock_data(exp, &handle, inode, &it->it_lock_bits);
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;
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);
"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)) {
* 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);
PFID(&lli->lli_fid), attr->ia_size,
ll_file_maxbytes(inode));
RETURN(-EFBIG);
osfs->os_type = sb->s_magic;
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)
osfs->os_bavail, osfs->os_blocks, osfs->os_ffree,osfs->os_files);
if (sbi->ll_flags & LL_SBI_LAZYSTATFS)
- 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);
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;
__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 */
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 "
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;
}
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) {
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;
sbi->ll_md_exp->exp_handle.h_cookie);
EXIT;
return;
obd = class_exp2obd(sbi->ll_dt_exp);
if (obd == NULL) {
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;
sbi->ll_dt_exp->exp_handle.h_cookie);
EXIT;
return;
- 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,
if (mapping_mapped(mapping)) {
rc = 0;
unmap_mapping_range(mapping, first + PAGE_CACHE_SIZE - 1,
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!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);
return rc;
}
LPROC_SEQ_FOPS_RO(ll_filestotal);
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
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);
return rc;
}
LPROC_SEQ_FOPS_RO(ll_filesfree);
if (val >= 0 && val <= LL_SA_RPC_MAX)
sbi->ll_sa_max = val;
else
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;
"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: "
lli->lli_fid = body->mbo_fid1;
if (unlikely(!(body->mbo_valid & OBD_MD_FLTYPE))) {
CERROR("Can not initialize inode "DFID" without object type: "
PFID(&lli->lli_fid), body->mbo_valid);
return -EINVAL;
}
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)) {
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;
"\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>
#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
#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;
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)
start, end, start_left, end_left);
if (start == end)
kms_pages = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
PAGE_CACHE_SHIFT;
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 &&
ra->ra_max_read_ahead_whole_pages, ra->ra_max_pages_per_file);
if (kms_pages &&
if (unlikely(entry == NULL))
RETURN(ERR_PTR(-ENOMEM));
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;
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)
{
/* 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);
entry->se_qstr.len, entry->se_qstr.name, entry,
entry->se_index);
}
CDEBUG(D_READA, "Handling (init) async glimpse: inode = "
}
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;
cl_agl(inode);
lli->lli_agl_index = 0;
up_write(&lli->lli_glimpse_sem);
CDEBUG(D_READA, "Handled (init) async glimpse: inode= "
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);
PFID(&lli->lli_fid), index, rc);
iput(inode);
sai->sai_in_readpage = 0;
if (IS_ERR(page)) {
rc = PTR_ERR(page);
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;
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 "
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,
"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);
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,
"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,
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));
}
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,
* 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));
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) {
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);
}
", err = %d\n", fid_seq(fid), rc);
RETURN(rc);
}
if (tgt == NULL || tgt->ltd_exp == NULL)
continue;
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))
tgt->ltd_uuid.uuid, tgt->ltd_exp->exp_handle.h_cookie);
if (obd_uuid_equals(uuid, &tgt->ltd_uuid))
- 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);
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) {
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);
}
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
obd = class_exp2obd(exp);
if (obd == NULL) {
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);
}
exp->exp_handle.h_cookie);
RETURN(-EINVAL);
}
void dump_lsm(unsigned int level, const struct lov_stripe_md *lsm)
{
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,
" 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,
- 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);
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;
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);
}
/*
(__u64)lio->lis_io_endpos);
}
/*
assert_spin_locked(&lsm->lsm_lock);
LASSERT(lsm->lsm_lock_owner == current_pid());
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++) {
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;
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);
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;
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))
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);
*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);
}
"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);
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
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;
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);
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
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);
if (dev->u.cli.cl_import->imp_deactive == val)
rc = ptlrpc_set_import_active(dev->u.cli.cl_import, val);
else
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",
LASSERT(it);
CDEBUG(D_DLMTRACE, "(name: %.*s,"DFID") in obj "DFID
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);
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;
__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);
(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;
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:
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;
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;
file_fh->cookie, body->mbo_handle.cookie);
old = *file_fh;
*file_fh = body->mbo_handle;
if (unlikely(*start == 1 && *hash == 0))
*hash = *start;
else
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",
- 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);
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)) {
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));
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)) {
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));
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)) {
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;
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)) {
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;
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
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
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));
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))
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);
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 */
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 */
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);
}
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,
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;
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);
cs->cs_fp, cs->cs_startrec);
OBD_ALLOC(cs->cs_buf, KUC_CHANGELOG_MSG_MAXSIZE);
LBUG();
}
res_id->name[1] = cpu_to_le64(resname);
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;
}
res_id->name[0], res_id->name[1], (char *)&res_id->name[0]);
return 0;
}
- 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
cld->cld_resid.name[0]);
/* We need a callback for every lockholder, so don't try to
- 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);
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;
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);
}
res->mcr_offset, eof == false);
}
ENTRY;
LU_OBJECT_HEADER(D_VFSTRACE, env, &io->ci_obj->co_lu,
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;
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),
}
}
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);
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime,
lvb->lvb_ctime, lvb->lvb_blocks);
RETURN(result);
char buf[64];
int len, ret = 0;
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);
- 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) {
if (u64val != OBD_OBJECT_EOF) {
- CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("__u64 %#llx(%d) != 0xffffffffffffffff\n",
u64val, (int)sizeof(u64val));
ret = -EINVAL;
}
u64val, (int)sizeof(u64val));
ret = -EINVAL;
}
- len = snprintf(buf, sizeof(buf), LPX64, u64val);
+ len = snprintf(buf, sizeof(buf), "%#llx", u64val);
- 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;
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) {
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) {
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)) {
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) {
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;
}
u64val, div64val, u64val >> 8);
return -EOVERFLOW;
}
- len = snprintf(buf, sizeof(buf), LPX64, u64val);
+ len = snprintf(buf, sizeof(buf), "%#llx", u64val);
- CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
+ CWARN("u64 hex wrong length! strlen(%s)=%d != 18\n", buf, len);
- len = snprintf(buf, sizeof(buf), LPU64, u64val);
+ len = snprintf(buf, sizeof(buf), "%llu", u64val);
- CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
+ CWARN("u64 wrong length! strlen(%s)=%d != 20\n", buf, len);
- len = snprintf(buf, sizeof(buf), LPD64, u64val);
+ len = snprintf(buf, sizeof(buf), "%lld", u64val);
- 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) {
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;
}
(__u64)PAGE_CACHE_SIZE);
ret = -EINVAL;
}
lprocfs_free_stats(&obd_memory);
CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
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;
memory_max, memory_leaked);
EXIT;
void dump_lniobuf(struct niobuf_local *nb)
{
CDEBUG(D_RPCTRACE,
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);
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)) {
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)) {
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)) {
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)) {
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);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
int rc = dt_statfs(NULL, dt, &osfs);
if (rc == 0)
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);
return rc;
}
EXPORT_SYMBOL(lprocfs_dt_filestotal_seq_show);
int rc = dt_statfs(NULL, dt, &osfs);
if (rc == 0)
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 rc;
}
EXPORT_SYMBOL(lprocfs_dt_filesfree_seq_show);
- 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);
}
export = class_handle2object(conn->cookie, NULL);
RETURN(export);
}
conn->cookie = export->exp_handle.h_cookie;
class_export_put(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);
}
cluuid->uuid, conn->cookie);
RETURN(0);
}
GOTO(no_disconn, already_disconnected);
}
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))
export->exp_handle.h_cookie);
if (!hlist_unhashed(&export->exp_nid_hash))
}
spin_unlock(&exp->exp_lock);
}
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),
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;
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 (len > *lenp)
len = *lenp;
buf[len] = '\0';
if (write)
return -EINVAL;
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';
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)) {
/* 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));
"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;
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);
POSTID(&llh->lgh_id.lgl_oi), size);
llog_handle_put(llh);
if (dt_object_remote(o))
loghandle->lgh_write_offset = lgi->lgi_off;
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) {
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"
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) {
*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
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);
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 "
goto retry;
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
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 "
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,
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 "
/* 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);
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
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);
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 "
if (rc < sizeof(*tail)) {
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
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 "
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
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_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)
}
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_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);
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)
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);
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 {
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,
", should be %lld (rec len %u)\n",
lgh->lgh_cur_offset,
(long long)test_3_rec_off,
- 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) {
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);
if (la.la_size != cat_max_size) {
CERROR("10e: catalog size has changed after it has wrap around,"
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);
}
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,"
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);
}
la.la_size, cat_max_size);
GOTO(out, rc = -EINVAL);
}
return PTR_ERR(root);
/* find old last_id file */
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);
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 {
} 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))
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) {
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) {
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);
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) {
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;
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);
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);
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, ", 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) {
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);
}
ret.lc_count ? ret.lc_sumsquare : 0);
}
int lprocfs_u64_seq_show(struct seq_file *m, void *data)
{
LASSERT(data != NULL);
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);
return 0;
}
EXPORT_SYMBOL(lprocfs_u64_seq_show);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
while (blk_size >>= 1)
result <<= 1;
while (blk_size >>= 1)
result <<= 1;
- seq_printf(m, LPU64"\n", result);
+ seq_printf(m, "%llu\n", result);
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!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);
return rc;
}
EXPORT_SYMBOL(lprocfs_filestotal_seq_show);
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
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);
return rc;
}
EXPORT_SYMBOL(lprocfs_filesfree_seq_show);
}
if (flags & ~(mask - 1)) {
}
if (flags & ~(mask - 1)) {
- seq_printf(m, "%sunknown_"LPX64,
+ seq_printf(m, "%sunknown_%#llx",
first ? "" : sep, flags & ~(mask - 1));
first = false;
}
first ? "" : sep, flags & ~(mask - 1));
first = false;
}
}
if (flags2 & ~(mask - 1)) {
}
if (flags2 & ~(mask - 1)) {
- seq_printf(m, "%sunknown2_"LPX64,
+ seq_printf(m, "%sunknown2_%#llx",
first ? "" : sep, flags2 & ~(mask - 1));
first = false;
}
first ? "" : sep, flags2 & ~(mask - 1));
first = false;
}
if (flags & ~(mask - 1))
ret += snprintf(page + ret, count - ret,
if (flags & ~(mask - 1))
ret += snprintf(page + ret, count - ret,
ret ? sep : "", flags & ~(mask - 1));
if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0)
ret ? sep : "", flags & ~(mask - 1));
if (!(flags & OBD_CONNECT_FLAGS2) || flags2 == 0)
if (flags2 & ~(mask - 1))
ret += snprintf(page + ret, count - ret,
if (flags2 & ~(mask - 1))
ret += snprintf(page + ret, count - ret,
ret ? sep : "", flags2 & ~(mask - 1));
return ret;
ret ? sep : "", flags2 & ~(mask - 1));
return ret;
flags = ocd->ocd_connect_flags;
seq_printf(m, " connect_data:\n"
flags = ocd->ocd_connect_flags;
seq_printf(m, " connect_data:\n"
" instance: %u\n",
ocd->ocd_connect_flags,
ocd->ocd_instance);
" 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)
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_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)
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",
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)
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",
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"
" 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),
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"
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);
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"
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);
}
rw ? "write" : "read",
ret.lc_sum);
}
__u64 sum = ret.lc_sum;
do_div(sum, ret.lc_count);
ret.lc_sum = 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)
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;
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);
obd_connect_seq_flags2str(m, flags, flags2, "\n");
seq_printf(m, "\n");
LPROCFS_CLIMP_EXIT(obd);
if (ctr.lc_count == 0)
return 0;
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) {
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)
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;
}
seq_putc(p, '\n');
return 0;
obd->obd_max_recoverable_clients);
seq_printf(m, "replayed_requests: %d\n",
obd->obd_replayed_requests);
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");
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, "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;
obd->obd_next_recovery_transno);
out:
return 0;
h->h_in = 1;
spin_unlock(&bucket->lock);
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",
static void class_handle_unhash_nolock(struct portals_handle *h)
{
if (list_empty(&h->h_link)) {
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",
- 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);
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) {
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);
h->h_cookie, h, h->h_ops);
class_handle_unhash_nolock(h);
GOTO(out, err);
}
case LCFG_ADD_UUID: {
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));
" (%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));
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);
}
nidstr, lcfg->lcfg_nid);
}
char nidstr[LNET_NIDSTR_SIZE];
libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
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);
}
nidstr, lcfg->lcfg_nid);
}
u64 newvalid = 0;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
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));
valid, LTIME_S(src->i_mtime),
LTIME_S(src->i_ctime));
void obdo_cpy_md(struct obdo *dst, const struct obdo *src, u64 valid)
{
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;
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);
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));
}
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;
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));
entry->ue_key, rc);
put_entry(cache, entry);
GOTO(out, entry = ERR_PTR(rc));
- 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);
cache->uc_name, key);
/* haven't found, it's possible */
spin_unlock(&cache->uc_lock);
- 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)) {
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)) {
"\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);
}
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);
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) {
cache->uc_name, entry, entry->ue_key);
out:
if (rc) {
- 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,
"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) {
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;
}
exp->exp_handle.h_cookie);
return -EINVAL;
}
}
if (!(oa->o_valid & OBD_MD_FLTYPE)) {
}
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);
- 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)) {
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);
- 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)) {
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);
- 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)) {
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);
- 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)
res->lnb_page, res->lnb_file_offset, res->lnb_len);
if (cmd & OBD_BRW_READ)
void *addr;
if (page == NULL) {
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;
ostid_id(&obj->ioo_oid), page, i,
obj->ioo_bufcnt);
return -EFAULT;
- 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) {
res->lnb_page, addr, res->lnb_file_offset);
if (verify) {
#include <lustre_net.h>
#ifdef HAVE_SERVER_SUPPORT
# include <md_object.h>
#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"
#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;
/* per-thread values, can be re-used */
void *eti_big_lmm; /* may be vmalloc'd */
int eti_big_lmmsize;
+ char eti_name[ETI_NAME_LEN];
struct lu_buf eti_buf;
char eti_xattr_buf[LUSTRE_POSIX_ACL_MAX_SIZE];
#endif
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);
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))
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)
{
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);
}
lname->ln_name = name;
lname->ln_namelen = strlen(name);
}
#endif
out:
ma->ma_need = need;
#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);
}
rc, ma->ma_valid, ma->ma_lmm);
RETURN(rc);
}
addr + delta, OBD_ECHO_BLOCK_SIZE,
stripe_off, stripe_id);
if (rc2 != 0) {
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);
seq_printf(m, "used_mb: %ld\n"
"busy_cnt: %ld\n"
seq_printf(m, "used_mb: %ld\n"
"busy_cnt: %ld\n"
(atomic_long_read(&cli->cl_lru_in_list) +
atomic_long_read(&cli->cl_lru_busy)) >> shift,
atomic_long_read(&cli->cl_lru_busy),
(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, "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);
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);
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;
}
stats->os_lockless_truncates);
return 0;
}
INIT_LIST_HEAD(&oap->oap_rpc_item);
spin_lock_init(&oap->oap_lock);
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);
}
oap, page, oap->oap_obj_off);
RETURN(0);
}
- 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) {
osc_extent_get(ext);
if (ext->oe_state == OES_ACTIVE) {
LASSERT(*extp == NULL);
*extp = osc_extent_get(ext);
OSC_EXTENT_DUMP(D_CACHE, ext,
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);
}
}
osc_extent_put(env, ext);
}
- 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);
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))
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))
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) {
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="
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);
}
lvb->lvb_size, oinfo->loi_kms,
dlmlock->l_policy_data.l_extent.end);
}
{
struct osc_lock *lock = cl2osc_lock(slice);
{
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);
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);
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;
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)
{
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);
}
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" "
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);
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) {
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);
}
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 > "
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",
"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;
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);
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);
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);
}
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) {
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);
}
}
__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)),
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, 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),
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
"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,
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};
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);
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
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,
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: "
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);
}
req->rq_import->imp_obd->obd_name,
POSTID(&aa->aa_oa->o_oi), rc);
}
* be valid. */
lock = ldlm_handle2lock(lockh);
LASSERTF(lock != NULL,
* 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
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);
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);
}
" 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);
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;
versions[0], versions[1]);
EXIT;
req = list_entry(imp->imp_unreplied_list.next, struct ptlrpc_request,
rq_unreplied_list);
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;
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"
}
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),
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:"
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),
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) {
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;
}
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);
imp->imp_obd->obd_name, imp->imp_peer_committed_transno,
imp->imp_generation);
- 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);
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,
LASSERTF(lustre_msg_get_transno(req->rq_reqmsg) ==
lustre_msg_get_transno(req->rq_repmsg) ||
lustre_msg_get_transno(req->rq_repmsg) == 0,
lustre_msg_get_transno(req->rq_reqmsg),
lustre_msg_get_transno(req->rq_repmsg));
}
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,
/* 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);
}
lustre_msg_get_transno(req->rq_reqmsg));
GOTO(out, rc = -EINVAL);
}
req->rq_mbits = req->rq_xid;
spin_unlock(&req->rq_import->imp_lock);
}
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);
}
old_mbits, req->rq_mbits);
}
req->rq_rqbd = rqbd;
req->rq_phase = RQ_PHASE_NEW;
if (ev->type == LNET_EVENT_PUT)
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));
req, req->rq_xid, ev->mlength);
CDEBUG(D_RPCTRACE, "peer: %s\n", libcfs_id2str(req->rq_peer));
- 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),
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;
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),
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), "
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,
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);
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);
"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, "
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);
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);
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:
&rscp->ctx, obd2cli_tgt(imp->imp_obd), gsec->gs_rvs_hdl);
rc = 0;
out:
- 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);
}
gsec->gs_rvs_hdl, rc);
RETURN(rc);
}
if (rc != SECSVC_OK)
set_bit(CACHE_NEGATIVE, &rsci->h.flags);
else
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);
gss_handle_to_u64(&rsci->handle));
COMPAT_RSC_PUT(&rsci->h, &rsc_cache);
rsc = gss_svc_searchbyctx(&gw->gw_handle);
if (!rsc) {
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;
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)) {
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 {
"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),
"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;
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),
"%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);
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:
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);
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));
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) {
}
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);
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: "
!(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,
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 "
* 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;
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: "
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);
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: "
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);
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 "
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",
obd2cli_tgt(imp->imp_obd),
imp->imp_connection->c_remote_uuid.uuid,
imp->imp_dlm_handle.cookie);
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 "
* with server again */
if ((MSG_CONNECT_RECOVERING & msg_flags)) {
CDEBUG(level,"%s@%s changed server handle from "
" but is still in recovery\n",
obd2cli_tgt(imp->imp_obd),
imp->imp_connection->c_remote_uuid.uuid,
" 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 "
} else {
LCONSOLE_WARN("Evicted from %s (at %s) "
"after server handle changed from "
obd2cli_tgt(imp->imp_obd),
imp->imp_connection-> \
c_remote_uuid.uuid,
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) {
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,
")! 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,
* 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),
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;
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()!!! */
* 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,
"%ld.%06ld:%ld.%06lds(%+ld.0s) ",
req->rq_history_seq, nidstr,
libcfs_id2str(req->rq_peer), req->rq_xid,
- 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,
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! */
/* 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);
libcfs_id2str(conn->c_peer), portal, xid, rc);
rc2 = LNetMDUnlink(*mdh);
LASSERTF(rc2 == 0, "rc2 = %d\n", rc2);
posted_md++;
if (rc != 0) {
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);
"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 "
}
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);
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),
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,
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;
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) {
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;
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) {
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);
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, "
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);
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) {
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));
"list_empty:%d\n", request->rq_xid,
imp->imp_known_replied_xid,
list_empty(&request->rq_unreplied_list));
GOTO(cleanup_me, rc = -ENOMEM);
}
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);
", 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 "
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 */
libcfs_id2str(req->rq_peer), nrq->nr_u.crr.cr_round);
/** Peek at the next request to be served */
rq_nrq);
CDEBUG(D_RPCTRACE,
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);
}
"\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);
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);
}
"\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);
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);
}
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 "
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 "
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_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 "
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,"
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",
NRS_POL_NAME_TRR, nrq->nr_u.orr.or_key.ok_idx,
nrq->nr_u.orr.or_round);
}
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, "
}
CDEBUG(D_RPCTRACE,
"NRS start %s request from %s, "
policy->pol_desc->pd_name,
libcfs_id2str(req->rq_peer),
nrq->nr_u.tbf.tr_sequence);
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);
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);
}
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, "%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",
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)
{
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);
}
nb->rnb_offset, nb->rnb_len, nb->rnb_flags);
}
{
u64 valid = oa->o_valid;
{
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)
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)
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)
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)
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)
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 */
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)
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))
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_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_ioepoch);
if (valid & OBD_MD_FLFID) {
CDEBUG(D_RPCTRACE, "obdo: o_stripe_idx = %u\n",
oa->o_parent_ver);
}
if (valid & OBD_MD_FLHANDLE)
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",
va_start(args, fmt);
libcfs_debug_vmsg2(msgdata, fmt, args,
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,
" 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);
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);
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 "
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;
RETURN(rc);
}
*inflight = 1;
- CERROR("failed unpack reply: x"LPU64"\n", req->rq_xid);
+ CERROR("failed unpack reply: x%llu\n", req->rq_xid);
- 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);
}
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 "
} 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;
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 "
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;
}
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"
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) {
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;
}
cfs_fail_val, req->rq_xid);
goto err_req;
}
- 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));
req->rq_export = class_conn2export(
lustre_msg_get_handle(req->rq_reqmsg));
}
CDEBUG(D_RPCTRACE, "Handling RPC pname:cluuid+ref:pid:xid:nid:opc "
}
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 ?
(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);
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;
/* 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 "
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"),
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() */
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,
" o%d NID %s\n",
rs,
rs->rs_xid, rs->rs_transno, rs->rs_opc,