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 MGS/MDS server side code.
Change-Id: I963ab240abbc650289040ee14f267f344c9f4124
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: http://review.whamcloud.com/22371
Reviewed-by: Frank Zago <fzago@cray.com>
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
28 files changed:
*tgt = range.lsr_index;
*type = range.lsr_flags;
*tgt = range.lsr_index;
*type = range.lsr_flags;
- CDEBUG(D_INFO, "%s: got tgt %x for sequence: "LPX64"\n",
+ CDEBUG(D_INFO, "%s: got tgt %x for sequence: %#llx\n",
lod2obd(lod)->obd_name, *tgt, fid_seq(fid));
RETURN(0);
lod2obd(lod)->obd_name, *tgt, fid_seq(fid));
RETURN(0);
*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);
}
if (ost->ltd_qos.ltq_usable)
*total_wt += ost->ltd_qos.ltq_weight;
if (ost->ltd_qos.ltq_usable)
*total_wt += ost->ltd_qos.ltq_weight;
- QOS_DEBUG("recalc tgt %d usable=%d avail="LPU64
- " ostppo="LPU64" ostp="LPU64" ossppo="LPU64
- " ossp="LPU64" wt="LPU64"\n",
+ QOS_DEBUG("recalc tgt %d usable=%d avail=%llu"
+ " ostppo=%llu ostp=%llu ossppo=%llu"
+ " ossp=%llu wt=%llu\n",
i, ost->ltd_qos.ltq_usable, TGT_BAVAIL(i) >> 10,
ost->ltd_qos.ltq_penalty_per_obj >> 10,
ost->ltd_qos.ltq_penalty >> 10,
i, ost->ltd_qos.ltq_usable, TGT_BAVAIL(i) >> 10,
ost->ltd_qos.ltq_penalty_per_obj >> 10,
ost->ltd_qos.ltq_penalty >> 10,
continue;
cur_weight += ost->ltd_qos.ltq_weight;
continue;
cur_weight += ost->ltd_qos.ltq_weight;
- QOS_DEBUG("stripe_cnt=%d nfound=%d cur_weight="LPU64
- " rand="LPU64" total_weight="LPU64"\n",
+ QOS_DEBUG("stripe_cnt=%d nfound=%d cur_weight=%llu"
+ " rand=%llu total_weight=%llu\n",
stripe_cnt, nfound, cur_weight, rand,
total_weight);
stripe_cnt, nfound, cur_weight, rand,
total_weight);
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- seq_printf(m, LPU64"\n",
+ seq_printf(m, "%llu\n",
lod->lod_desc.ld_default_stripe_size);
return 0;
}
lod->lod_desc.ld_default_stripe_size);
return 0;
}
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
LASSERT(dev != NULL);
lod = lu2lod_dev(dev->obd_lu_dev);
- seq_printf(m, LPU64"\n",
+ seq_printf(m, "%llu\n",
lod->lod_desc.ld_default_stripe_offset);
return 0;
}
lod->lod_desc.ld_default_stripe_offset);
return 0;
}
LASSERT(rec->cr_hdr.lrh_type == CHANGELOG_REC);
CDEBUG(D_INFO,
LASSERT(rec->cr_hdr.lrh_type == CHANGELOG_REC);
CDEBUG(D_INFO,
- "seeing record at index %d/%d/"LPU64" t=%x %.*s in log"
+ "seeing record at index %d/%d/%llu t=%x %.*s in log"
DOSTID"\n", hdr->lrh_index, rec->cr_hdr.lrh_index,
rec->cr.cr_index, rec->cr.cr_type, rec->cr.cr_namelen,
changelog_rec_name(&rec->cr), POSTID(&llh->lgh_id.lgl_oi));
DOSTID"\n", hdr->lrh_index, rec->cr_hdr.lrh_index,
rec->cr.cr_index, rec->cr.cr_type, rec->cr.cr_namelen,
changelog_rec_name(&rec->cr), POSTID(&llh->lgh_id.lgl_oi));
LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
LASSERT(rec->cur_hdr.lrh_type == CHANGELOG_USER_REC);
LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
LASSERT(rec->cur_hdr.lrh_type == CHANGELOG_USER_REC);
- CDEBUG(D_INFO, "seeing user at index %d/%d id=%d endrec="LPU64
+ CDEBUG(D_INFO, "seeing user at index %d/%d id=%d endrec=%llu"
" in log "DOSTID"\n", hdr->lrh_index, rec->cur_hdr.lrh_index,
rec->cur_id, rec->cur_endrec, POSTID(&llh->lgh_id.lgl_oi));
" in log "DOSTID"\n", hdr->lrh_index, rec->cur_hdr.lrh_index,
rec->cur_id, rec->cur_endrec, POSTID(&llh->lgh_id.lgl_oi));
- CDEBUG(D_IOCTL, "changelog starting index="LPU64"\n",
+ CDEBUG(D_IOCTL, "changelog starting index=%llu\n",
mdd->mdd_cl.mc_index);
/* setup user changelog */
mdd->mdd_cl.mc_index);
/* setup user changelog */
if (!fid_is_norm(f) && !fid_is_igif(f) && !fid_is_root(f) &&
!fid_seq_is_dot(f->f_seq)) {
CWARN("%s: Trying to lookup invalid FID "DFID" in %s/%s, "
if (!fid_is_norm(f) && !fid_is_igif(f) && !fid_is_root(f) &&
!fid_seq_is_dot(f->f_seq)) {
CWARN("%s: Trying to lookup invalid FID "DFID" in %s/%s, "
- "sequence should be >= "LPX64" or within ["LPX64","
- ""LPX64"].\n", mdd2obd_dev(mdd)->obd_name, PFID(f),
+ "sequence should be >= %#llx or within [%#llx,"
+ "%#llx].\n", mdd2obd_dev(mdd)->obd_name, PFID(f),
dot_lustre_name, mdd_obf_dir_name, (__u64)FID_SEQ_NORMAL,
(__u64)FID_SEQ_IGIF, (__u64)FID_SEQ_IGIF_MAX);
GOTO(out, rc = -EINVAL);
dot_lustre_name, mdd_obf_dir_name, (__u64)FID_SEQ_NORMAL,
(__u64)FID_SEQ_IGIF, (__u64)FID_SEQ_IGIF_MAX);
GOTO(out, rc = -EINVAL);
}
/* Update the endrec */
}
/* Update the endrec */
- CDEBUG(D_IOCTL, "Rewriting changelog user %d endrec to "LPU64"\n",
+ CDEBUG(D_IOCTL, "Rewriting changelog user %d endrec to %llu\n",
mcud->mcud_id, rec->cur_endrec);
rc = llog_write(env, llh, hdr, hdr->lrh_index);
mcud->mcud_id, rec->cur_endrec);
rc = llog_write(env, llh, hdr, hdr->lrh_index);
mdd_changelog_user_purge_cb, (void *)&data,
0, 0);
if ((rc >= 0) && (data.mcud_minrec > 0)) {
mdd_changelog_user_purge_cb, (void *)&data,
0, 0);
if ((rc >= 0) && (data.mcud_minrec > 0)) {
- CDEBUG(D_IOCTL, "Purging changelog entries up to "LPD64
+ CDEBUG(D_IOCTL, "Purging changelog entries up to %lld"
", referenced by "CHANGELOG_USER_PREFIX"%d\n",
data.mcud_minrec, data.mcud_minid);
rc = mdd_changelog_llog_cancel(env, mdd, data.mcud_minrec);
", referenced by "CHANGELOG_USER_PREFIX"%d\n",
data.mcud_minrec, data.mcud_minid);
rc = mdd_changelog_llog_cancel(env, mdd, data.mcud_minrec);
if (!data.mcud_found) {
CWARN("No entry for user %d. Last changelog reference is "
if (!data.mcud_found) {
CWARN("No entry for user %d. Last changelog reference is "
- LPD64" by changelog user %d\n", data.mcud_id,
+ "%lld by changelog user %d\n", data.mcud_id,
data.mcud_minrec, data.mcud_minid);
rc = -ENOENT;
}
data.mcud_minrec, data.mcud_minid);
rc = -ENOENT;
}
* XXX: Setting the lov ea is not locked but setting the attr is locked?
* Should this be fixed?
*/
* XXX: Setting the lov ea is not locked but setting the attr is locked?
* Should this be fixed?
*/
- CDEBUG(D_OTHER, "ea %p/%u, cr_flags "LPO64", no_create %u\n",
+ CDEBUG(D_OTHER, "ea %p/%u, cr_flags %#llo, no_create %u\n",
spec->u.sp_ea.eadata, spec->u.sp_ea.eadatalen,
spec->sp_cr_flags, spec->no_create);
spec->u.sp_ea.eadata, spec->u.sp_ea.eadatalen,
spec->sp_cr_flags, spec->no_create);
rec = (struct llog_changelog_user_rec *)hdr;
rec = (struct llog_changelog_user_rec *)hdr;
- seq_printf(m, CHANGELOG_USER_PREFIX"%-3d "LPU64"\n",
+ seq_printf(m, CHANGELOG_USER_PREFIX"%-3d %llu\n",
rec->cur_id, rec->cur_endrec);
return 0;
}
rec->cur_id, rec->cur_endrec);
return 0;
}
cur = mdd->mdd_cl.mc_index;
spin_unlock(&mdd->mdd_cl.mc_lock);
cur = mdd->mdd_cl.mc_index;
spin_unlock(&mdd->mdd_cl.mc_lock);
- seq_printf(m, "current index: "LPU64"\n", cur);
+ seq_printf(m, "current index: %llu\n", cur);
seq_printf(m, "%-5s %s\n", "ID", "index");
llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb,
seq_printf(m, "%-5s %s\n", "ID", "index");
llog_cat_process(&env, ctxt->loc_handle, lprocfs_changelog_users_cb,
rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
&tmp);
rc = mdd_changelog_size_ctxt(&env, mdd, LLOG_CHANGELOG_USER_ORIG_CTXT,
&tmp);
- seq_printf(m, LPU64"\n", tmp);
+ seq_printf(m, "%llu\n", tmp);
lu_env_fini(&env);
return rc;
}
lu_env_fini(&env);
return rc;
}
static int mdd_object_print(const struct lu_env *env, void *cookie,
lu_printer_t p, const struct lu_object *o)
{
static int mdd_object_print(const struct lu_env *env, void *cookie,
lu_printer_t p, const struct lu_object *o)
{
- struct mdd_object *mdd = lu2mdd_obj((struct lu_object *)o);
- return (*p)(env, cookie, LUSTRE_MDD_NAME"-object@%p(open_count=%d, "
- "valid=%x, cltime="LPU64", flags=%lx)",
+ struct mdd_object *mdd = lu2mdd_obj((struct lu_object *)o);
+
+ return (*p)(env, cookie,
+ LUSTRE_MDD_NAME"-object@%p(open_count=%d, valid=%x, cltime=%llu, flags=%lx)",
mdd, mdd->mod_count, mdd->mod_valid,
mdd->mod_cltime, mdd->mod_flags);
}
mdd, mdd->mod_count, mdd->mod_valid,
mdd->mod_cltime, mdd->mod_flags);
}
/* no need to setattr anymore */
if (la_copy->la_valid == 0) {
CDEBUG(D_INODE, "%s: no valid attribute on "DFID", previous"
/* no need to setattr anymore */
if (la_copy->la_valid == 0) {
CDEBUG(D_INODE, "%s: no valid attribute on "DFID", previous"
- "valid is "LPX64"\n", mdd2obd_dev(mdd)->obd_name,
+ "valid is %#llx\n", mdd2obd_dev(mdd)->obd_name,
PFID(mdo2fid(mdd_obj)), la->la_valid);
RETURN(0);
PFID(mdo2fid(mdd_obj)), la->la_valid);
RETURN(0);
handle->th_sync = 1;
if (la->la_valid & (LA_MTIME | LA_CTIME))
handle->th_sync = 1;
if (la->la_valid & (LA_MTIME | LA_CTIME))
- CDEBUG(D_INODE, "setting mtime "LPU64", ctime "LPU64"\n",
+ CDEBUG(D_INODE, "setting mtime %llu, ctime %llu\n",
la->la_mtime, la->la_ctime);
mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
la->la_mtime, la->la_ctime);
mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
struct hsm_action_item *hai;
char buf[12];
struct hsm_action_item *hai;
char buf[12];
- CDEBUG(level, "%s: HAL header: version %X count %d compound "LPX64
- " archive_id %d flags "LPX64"\n",
+ CDEBUG(level, "%s: HAL header: version %X count %d compound %#llx"
+ " archive_id %d flags %#llx\n",
prefix, hal->hal_version, hal->hal_count,
hal->hal_compound_id, hal->hal_archive_id, hal->hal_flags);
prefix, hal->hal_version, hal->hal_count,
hal->hal_compound_id, hal->hal_archive_id, hal->hal_flags);
for (i = 0; i < hal->hal_count; i++) {
sz = hai->hai_len - sizeof(*hai);
CDEBUG(level, "%s %d: fid="DFID" dfid="DFID
for (i = 0; i < hal->hal_count; i++) {
sz = hai->hai_len - sizeof(*hai);
CDEBUG(level, "%s %d: fid="DFID" dfid="DFID
- " compound/cookie="LPX64"/"LPX64
- " action=%s extent="LPX64"-"LPX64" gid="LPX64
+ " compound/cookie=%#llx/%#llx"
+ " action=%s extent=%#llx-%#llx gid=%#llx"
" datalen=%d data=[%s]\n",
prefix, i,
PFID(&hai->hai_fid), PFID(&hai->hai_dfid),
" datalen=%d data=[%s]\n",
prefix, i,
PFID(&hai->hai_fid), PFID(&hai->hai_dfid),
cfs_size_round(MTI_NAME_MAXLEN+1) +
2 * cfs_size_round(larr->arr_hai.hai_len);
OBD_ALLOC(hal, request->hal_sz);
cfs_size_round(MTI_NAME_MAXLEN+1) +
2 * cfs_size_round(larr->arr_hai.hai_len);
OBD_ALLOC(hal, request->hal_sz);
- if (!hal) {
- CERROR("%s: Cannot allocate memory (%d o)"
- "for compound "LPX64"\n",
- mdt_obd_name(mdt),
- request->hal_sz,
- larr->arr_compound_id);
hal->hal_version = HAL_VERSION;
strlcpy(hal->hal_fsname, hsd->fs_name,
MTI_NAME_MAXLEN + 1);
hal->hal_version = HAL_VERSION;
strlcpy(hal->hal_fsname, hsd->fs_name,
MTI_NAME_MAXLEN + 1);
sz = 2 * request->hal_sz;
OBD_ALLOC(hal_buffer, sz);
sz = 2 * request->hal_sz;
OBD_ALLOC(hal_buffer, sz);
- if (!hal_buffer) {
- CERROR("%s: Cannot allocate memory "
- "(%d o) for compound "LPX64"\n",
- mdt_obd_name(mdt), sz,
- larr->arr_compound_id);
memcpy(hal_buffer, request->hal,
request->hal_used_sz);
OBD_FREE(request->hal,
memcpy(hal_buffer, request->hal,
request->hal_used_sz);
OBD_FREE(request->hal,
rc = mdt_hsm_update_request_state(hsd->mti, &pgs, 0);
if (rc)
CERROR("%s: cannot cleanup timed out request: "
rc = mdt_hsm_update_request_state(hsd->mti, &pgs, 0);
if (rc)
CERROR("%s: cannot cleanup timed out request: "
- DFID" for cookie "LPX64" action=%s\n",
+ DFID" for cookie %#llx action=%s\n",
mdt_obd_name(mdt),
PFID(&pgs.hpk_fid), pgs.hpk_cookie,
hsm_copytool_action2name(
mdt_obd_name(mdt),
PFID(&pgs.hpk_fid), pgs.hpk_cookie,
hsm_copytool_action2name(
*/
sz = hal->hal_count * sizeof(__u64);
OBD_ALLOC(cookies, sz);
*/
sz = hal->hal_count * sizeof(__u64);
OBD_ALLOC(cookies, sz);
- if (cookies == NULL) {
- CERROR("%s: Cannot allocate memory (%d o) "
- "for cookies vector "LPX64"\n",
- mdt_obd_name(mdt), sz,
- hal->hal_compound_id);
hai = hai_first(hal);
for (j = 0; j < hal->hal_count; j++) {
cookies[j] = hai->hai_cookie;
hai = hai_first(hal);
for (j = 0; j < hal->hal_count; j++) {
cookies[j] = hai->hai_cookie;
if (rc) {
CERROR("%s: mdt_agent_record_update() failed, "
"rc=%d, cannot update status to %s "
if (rc) {
CERROR("%s: mdt_agent_record_update() failed, "
"rc=%d, cannot update status to %s "
- "for cookie "LPX64"\n",
mdt_obd_name(mdt), rc,
agent_req_status2name(ARS_CANCELED),
hai->hai_cookie);
mdt_obd_name(mdt), rc,
agent_req_status2name(ARS_CANCELED),
hai->hai_cookie);
}
if (pgs->hpk_errval > CLF_HSM_MAXERROR) {
}
if (pgs->hpk_errval > CLF_HSM_MAXERROR) {
- CERROR("%s: Request "LPX64" on "DFID
+ CERROR("%s: Request %#llx on "DFID
" failed, error code %d too large\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
" failed, error code %d too large\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
break;
case HSMA_CANCEL:
hsm_set_cl_event(&cl_flags, HE_CANCEL);
break;
case HSMA_CANCEL:
hsm_set_cl_event(&cl_flags, HE_CANCEL);
- CERROR("%s: Failed request "LPX64" on "DFID
+ CERROR("%s: Failed request %#llx on "DFID
" cannot be a CANCEL\n",
mdt_obd_name(mdt),
pgs->hpk_cookie,
PFID(&pgs->hpk_fid));
break;
default:
" cannot be a CANCEL\n",
mdt_obd_name(mdt),
pgs->hpk_cookie,
PFID(&pgs->hpk_fid));
break;
default:
- CERROR("%s: Failed request "LPX64" on "DFID
+ CERROR("%s: Failed request %#llx on "DFID
" %d is an unknown action\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
" %d is an unknown action\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
break;
case HSMA_CANCEL:
hsm_set_cl_event(&cl_flags, HE_CANCEL);
break;
case HSMA_CANCEL:
hsm_set_cl_event(&cl_flags, HE_CANCEL);
- CERROR("%s: Successful request "LPX64
- " on "DFID
- " cannot be a CANCEL\n",
+ CERROR("%s: Successful request %#llx on "DFID" cannot be a CANCEL\n",
mdt_obd_name(mdt),
pgs->hpk_cookie,
PFID(&pgs->hpk_fid));
break;
default:
mdt_obd_name(mdt),
pgs->hpk_cookie,
PFID(&pgs->hpk_fid));
break;
default:
- CERROR("%s: Successful request "LPX64
- " on "DFID
- " %d is an unknown action\n",
+ CERROR("%s: Successful request %#llx on "DFID" %d is an unknown action\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
car->car_hai->hai_action);
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
car->car_hai->hai_action);
/* first do sanity checks */
car = mdt_cdt_update_request(cdt, pgs);
if (IS_ERR(car)) {
/* first do sanity checks */
car = mdt_cdt_update_request(cdt, pgs);
if (IS_ERR(car)) {
- CERROR("%s: Cannot find running request for cookie "LPX64
+ CERROR("%s: Cannot find running request for cookie %#llx"
" on fid="DFID"\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid));
" on fid="DFID"\n",
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid));
- CDEBUG(D_HSM, "Progress received for fid="DFID" cookie="LPX64
+ CDEBUG(D_HSM, "Progress received for fid="DFID" cookie=%#llx"
" action=%s flags=%d err=%d fid="DFID" dfid="DFID"\n",
PFID(&pgs->hpk_fid), pgs->hpk_cookie,
hsm_copytool_action2name(car->car_hai->hai_action),
" action=%s flags=%d err=%d fid="DFID" dfid="DFID"\n",
PFID(&pgs->hpk_fid), pgs->hpk_cookie,
hsm_copytool_action2name(car->car_hai->hai_action),
car->car_hai->hai_action == HSMA_ARCHIVE) &&
(!lu_fid_eq(&pgs->hpk_fid, &car->car_hai->hai_dfid) &&
!lu_fid_eq(&pgs->hpk_fid, &car->car_hai->hai_fid))) {
car->car_hai->hai_action == HSMA_ARCHIVE) &&
(!lu_fid_eq(&pgs->hpk_fid, &car->car_hai->hai_dfid) &&
!lu_fid_eq(&pgs->hpk_fid, &car->car_hai->hai_fid))) {
- CERROR("%s: Progress on "DFID" for cookie "LPX64
+ CERROR("%s: Progress on "DFID" for cookie %#llx"
" does not match request FID "DFID" nor data FID "
DFID"\n",
mdt_obd_name(mdt),
" does not match request FID "DFID" nor data FID "
DFID"\n",
mdt_obd_name(mdt),
}
if (pgs->hpk_errval != 0 && !(pgs->hpk_flags & HP_FLAG_COMPLETED)) {
}
if (pgs->hpk_errval != 0 && !(pgs->hpk_flags & HP_FLAG_COMPLETED)) {
- CERROR("%s: Progress on "DFID" for cookie "LPX64" action=%s"
+ CERROR("%s: Progress on "DFID" for cookie %#llx action=%s"
" is not coherent (err=%d and not completed"
" (flags=%d))\n",
mdt_obd_name(mdt),
" is not coherent (err=%d and not completed"
" (flags=%d))\n",
mdt_obd_name(mdt),
/* remove request from memory list */
mdt_cdt_remove_request(cdt, pgs->hpk_cookie);
/* remove request from memory list */
mdt_cdt_remove_request(cdt, pgs->hpk_cookie);
- CDEBUG(D_HSM, "Updating record: fid="DFID" cookie="LPX64
+ CDEBUG(D_HSM, "Updating record: fid="DFID" cookie=%#llx"
" action=%s status=%s\n", PFID(&pgs->hpk_fid),
pgs->hpk_cookie,
hsm_copytool_action2name(car->car_hai->hai_action),
" action=%s status=%s\n", PFID(&pgs->hpk_fid),
pgs->hpk_cookie,
hsm_copytool_action2name(car->car_hai->hai_action),
if (rc1)
CERROR("%s: mdt_agent_record_update() failed,"
" rc=%d, cannot update status to %s"
if (rc1)
CERROR("%s: mdt_agent_record_update() failed,"
" rc=%d, cannot update status to %s"
- " for cookie "LPX64"\n",
mdt_obd_name(mdt), rc1,
agent_req_status2name(status),
pgs->hpk_cookie);
mdt_obd_name(mdt), rc1,
agent_req_status2name(status),
pgs->hpk_cookie);
is_compat = true;
break;
}
is_compat = true;
break;
}
- CDEBUG(D_HSM, "fid="DFID" action=%s flags="LPX64
- " extent="LPX64"-"LPX64" hsm_flags=%.8X %s\n",
+ CDEBUG(D_HSM, "fid="DFID" action=%s flags=%#llx"
+ " extent=%#llx-%#llx hsm_flags=%.8X %s\n",
PFID(&hai->hai_fid),
hsm_copytool_action2name(hai->hai_action), rq_flags,
hai->hai_extent.offset, hai->hai_extent.length,
PFID(&hai->hai_fid),
hsm_copytool_action2name(hai->hai_action), rq_flags,
hai->hai_extent.offset, hai->hai_extent.length,
- seq_printf(m, "("LPX64") ", mask);
+ seq_printf(m, "(%#llx) ", mask);
for (i = 0; i < CDT_POLICY_SHIFT_COUNT; i++) {
bit = (1ULL << i);
for (i = 0; i < CDT_POLICY_SHIFT_COUNT; i++) {
bit = (1ULL << i);
- CDEBUG(D_HSM, "%s: new policy: rm="LPX64" add="LPX64" set="LPX64"\n",
+ CDEBUG(D_HSM, "%s: new policy: rm=%#llx add=%#llx set=%#llx\n",
mdt_obd_name(mdt), remove_mask, add_mask, set_mask);
/* if no sign in all string, it is a clear and set
mdt_obd_name(mdt), remove_mask, add_mask, set_mask);
/* if no sign in all string, it is a clear and set
struct coordinator *cdt = &mdt->mdt_coordinator; \
ENTRY; \
\
struct coordinator *cdt = &mdt->mdt_coordinator; \
ENTRY; \
\
- seq_printf(m, LPU64"\n", (__u64)cdt->VAR); \
+ seq_printf(m, "%llu\n", (__u64)cdt->VAR); \
RETURN(0); \
} \
static ssize_t \
RETURN(0); \
} \
static ssize_t \
if (fid != NULL) {
b->mbo_fid1 = *fid;
b->mbo_valid |= OBD_MD_FLID;
if (fid != NULL) {
b->mbo_fid1 = *fid;
b->mbo_valid |= OBD_MD_FLID;
- CDEBUG(D_INODE, DFID": nlink=%d, mode=%o, valid="LPX64"\n",
+ CDEBUG(D_INODE, DFID": nlink=%d, mode=%o, valid=%#llx\n",
PFID(fid), b->mbo_nlink, b->mbo_mode, b->mbo_valid);
}
PFID(fid), b->mbo_nlink, b->mbo_mode, b->mbo_valid);
}
#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);
}
*/
rdpg->rp_hash = reqbody->mbo_size;
if (rdpg->rp_hash != reqbody->mbo_size) {
*/
rdpg->rp_hash = reqbody->mbo_size;
if (rdpg->rp_hash != reqbody->mbo_size) {
- CERROR("Invalid hash: "LPX64" != "LPX64"\n",
+ CERROR("Invalid hash: %#llx != %#llx\n",
rdpg->rp_hash, reqbody->mbo_size);
RETURN(-EFAULT);
}
rdpg->rp_hash, reqbody->mbo_size);
RETURN(-EFAULT);
}
/* Lock is pinned by ldlm_handle_enqueue0() as it is
* a resend case, however, it could be already destroyed
* due to client eviction or a raced cancel RPC. */
/* Lock is pinned by ldlm_handle_enqueue0() as it is
* a resend case, however, it could be already destroyed
* due to client eviction or a raced cancel RPC. */
- LDLM_DEBUG_NOLOCK("Invalid lock handle "LPX64,
+ LDLM_DEBUG_NOLOCK("Invalid lock handle %#llx",
lhc->mlh_reg_lh.cookie);
RETURN(-ESTALE);
}
lhc->mlh_reg_lh.cookie);
RETURN(-ESTALE);
}
cos = (mdt_cos_is_enabled(mdt) ||
mdt_slc_is_enabled(mdt));
cos = (mdt_cos_is_enabled(mdt) ||
mdt_slc_is_enabled(mdt));
- LASSERTF(lock != NULL, "no lock for cookie "LPX64"\n",
+ LASSERTF(lock != NULL, "no lock for cookie %#llx\n",
h->cookie);
/* there is no request if mdt_object_unlock() is called
* from mdt_export_cleanup()->mdt_add_dirty_flag() */
if (likely(req != NULL)) {
CDEBUG(D_HA, "request = %p reply state = %p"
h->cookie);
/* there is no request if mdt_object_unlock() is called
* from mdt_export_cleanup()->mdt_add_dirty_flag() */
if (likely(req != NULL)) {
CDEBUG(D_HA, "request = %p reply state = %p"
- " transno = "LPD64"\n", req,
+ " transno = %lld\n", req,
req->rq_reply_state, req->rq_transno);
if (cos) {
ldlm_lock_downgrade(lock, LCK_COS);
req->rq_reply_state, req->rq_transno);
if (cos) {
ldlm_lock_downgrade(lock, LCK_COS);
/* Lock is pinned by ldlm_handle_enqueue0() as it is
* a resend case, however, it could be already destroyed
* due to client eviction or a raced cancel RPC. */
/* Lock is pinned by ldlm_handle_enqueue0() as it is
* a resend case, however, it could be already destroyed
* due to client eviction or a raced cancel RPC. */
- LDLM_DEBUG_NOLOCK("Invalid lock handle "LPX64"\n",
+ LDLM_DEBUG_NOLOCK("Invalid lock handle %#llx\n",
lh->mlh_reg_lh.cookie);
lh->mlh_reg_lh.cookie = 0;
RETURN(-ESTALE);
}
LASSERTF(new_lock != NULL,
lh->mlh_reg_lh.cookie);
lh->mlh_reg_lh.cookie = 0;
RETURN(-ESTALE);
}
LASSERTF(new_lock != NULL,
- "lockh "LPX64" flags "LPX64" rc %d\n",
+ "lockh %#llx flags %#llx : rc = %d\n",
lh->mlh_reg_lh.cookie, flags, result);
/*
lh->mlh_reg_lh.cookie, flags, result);
/*
lh->mlh_reg_mode = new_lock->l_granted_mode;
LDLM_DEBUG(new_lock, "Restoring lock cookie");
lh->mlh_reg_mode = new_lock->l_granted_mode;
LDLM_DEBUG(new_lock, "Restoring lock cookie");
- DEBUG_REQ(D_DLMTRACE, req, "restoring lock cookie "LPX64,
+ DEBUG_REQ(D_DLMTRACE, req, "restoring lock cookie %#llx",
lh->mlh_reg_lh.cookie);
return;
}
lh->mlh_reg_lh.cookie);
return;
}
*/
lustre_msg_clear_flags(req->rq_reqmsg, MSG_RESENT);
*/
lustre_msg_clear_flags(req->rq_reqmsg, MSG_RESENT);
- DEBUG_REQ(D_DLMTRACE, req, "no existing lock with rhandle "LPX64,
+ DEBUG_REQ(D_DLMTRACE, req, "no existing lock with rhandle %#llx",
dlmreq->lock_handle[0].cookie);
}
dlmreq->lock_handle[0].cookie);
}
if (!(data->ocd_connect_flags & OBD_CONNECT_MDS_MDS) &&
!(data->ocd_connect_flags & OBD_CONNECT_IBITS)) {
CWARN("%s: client %s does not support ibits lock, either "
if (!(data->ocd_connect_flags & OBD_CONNECT_MDS_MDS) &&
!(data->ocd_connect_flags & OBD_CONNECT_IBITS)) {
CWARN("%s: client %s does not support ibits lock, either "
- "very old or an invalid client: flags "LPX64"\n",
+ "very old or an invalid client: flags %#llx\n",
mdt_obd_name(mdt), exp->exp_client_uuid.uuid,
data->ocd_connect_flags);
return -EBADE;
mdt_obd_name(mdt), exp->exp_client_uuid.uuid,
data->ocd_connect_flags);
return -EBADE;
data->ocd_brw_size = min(data->ocd_brw_size,
(__u32)MD_MAX_BRW_SIZE);
if (data->ocd_brw_size == 0) {
data->ocd_brw_size = min(data->ocd_brw_size,
(__u32)MD_MAX_BRW_SIZE);
if (data->ocd_brw_size == 0) {
- CERROR("%s: cli %s/%p ocd_connect_flags: "LPX64
+ CERROR("%s: cli %s/%p ocd_connect_flags: %#llx"
" ocd_version: %x ocd_grant: %d "
"ocd_index: %u ocd_brw_size is "
"unexpectedly zero, network data "
" ocd_version: %x ocd_grant: %d "
"ocd_index: %u ocd_brw_size is "
"unexpectedly zero, network data "
- CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n",
+ CDEBUG(D_IOCTL, "path get "DFID" from %llu #%d\n",
PFID(&fp->gf_fid), fp->gf_recno, fp->gf_linkno);
if (!fid_is_sane(&fp->gf_fid))
PFID(&fp->gf_fid), fp->gf_recno, fp->gf_linkno);
if (!fid_is_sane(&fp->gf_fid))
if (!fid_is_namespace_visible(&fp->gf_fid)) {
CWARN("%s: "DFID" is invalid, sequence should be "
if (!fid_is_namespace_visible(&fp->gf_fid)) {
CWARN("%s: "DFID" is invalid, sequence should be "
- ">= "LPX64"\n", mdt_obd_name(mdt),
+ ">= %#llx\n", mdt_obd_name(mdt),
PFID(&fp->gf_fid), (__u64)FID_SEQ_NORMAL);
RETURN(-EINVAL);
}
PFID(&fp->gf_fid), (__u64)FID_SEQ_NORMAL);
RETURN(-EINVAL);
}
rc = mdt_path(info, obj, fp, root_fid);
rc = mdt_path(info, obj, fp, root_fid);
- CDEBUG(D_INFO, "fid "DFID", path %s recno "LPX64" linkno %u\n",
+ CDEBUG(D_INFO, "fid "DFID", path %s recno %#llx linkno %u\n",
PFID(&fp->gf_fid), fp->gf_u.gf_path,
fp->gf_recno, fp->gf_linkno);
PFID(&fp->gf_fid), fp->gf_u.gf_path,
fp->gf_recno, fp->gf_linkno);
hpk->hpk_errval = lustre_errno_ntoh(hpk->hpk_errval);
hpk->hpk_errval = lustre_errno_ntoh(hpk->hpk_errval);
- CDEBUG(D_HSM, "Progress on "DFID": len="LPU64" err=%d\n",
+ CDEBUG(D_HSM, "Progress on "DFID": len=%llu : rc = %d\n",
PFID(&hpk->hpk_fid), hpk->hpk_extent.length, hpk->hpk_errval);
if (hpk->hpk_errval)
PFID(&hpk->hpk_fid), hpk->hpk_extent.length, hpk->hpk_errval);
if (hpk->hpk_errval)
- CDEBUG(D_HSM, "Copytool progress on "DFID" failed (%d); %s.\n",
+ CDEBUG(D_HSM, "Copytool progress on "DFID" failed : rc = %d; %s.\n",
PFID(&hpk->hpk_fid), hpk->hpk_errval,
hpk->hpk_flags & HP_FLAG_RETRY ? "will retry" : "fatal");
if (hpk->hpk_flags & HP_FLAG_COMPLETED)
PFID(&hpk->hpk_fid), hpk->hpk_errval,
hpk->hpk_flags & HP_FLAG_RETRY ? "will retry" : "fatal");
if (hpk->hpk_flags & HP_FLAG_COMPLETED)
- CDEBUG(D_HSM, "Finished "DFID" (%d) cancel cookie="LPX64"\n",
+ CDEBUG(D_HSM, "Finished "DFID" : rc = %d; cancel cookie=%#llx\n",
PFID(&hpk->hpk_fid), hpk->hpk_errval, hpk->hpk_cookie);
info = tsi2mdt_info(tsi);
PFID(&hpk->hpk_fid), hpk->hpk_errval, hpk->hpk_cookie);
info = tsi2mdt_info(tsi);
/* Detect out-of range masks */
if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK) {
/* Detect out-of range masks */
if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK) {
- CDEBUG(D_HSM, "Incompatible masks provided (set "LPX64
- ", clear "LPX64") vs supported set (%#x).\n",
+ CDEBUG(D_HSM, "Incompatible masks provided (set %#llx"
+ ", clear %#llx) vs supported set (%#x).\n",
hss->hss_setmask, hss->hss_clearmask, HSM_FLAGS_MASK);
GOTO(out_unlock, rc = -EINVAL);
}
hss->hss_setmask, hss->hss_clearmask, HSM_FLAGS_MASK);
GOTO(out_unlock, rc = -EINVAL);
}
* NOT defined in HSM_USER_MASK. */
if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
!md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN)) {
* NOT defined in HSM_USER_MASK. */
if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
!md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN)) {
- CDEBUG(D_HSM, "Incompatible masks provided (set "LPX64
- ", clear "LPX64") vs unprivileged set (%#x).\n",
+ CDEBUG(D_HSM, "Incompatible masks provided (set %#llx"
+ ", clear %#llx) vs unprivileged set (%#x).\n",
hss->hss_setmask, hss->hss_clearmask, HSM_USER_MASK);
GOTO(out_unlock, rc = -EPERM);
}
hss->hss_setmask, hss->hss_clearmask, HSM_USER_MASK);
GOTO(out_unlock, rc = -EPERM);
}
(flags & HS_RELEASED && !(flags & HS_ARCHIVED)) ||
(flags & HS_LOST && !(flags & HS_ARCHIVED))) {
CDEBUG(D_HSM, "Incompatible flag change on "DFID
(flags & HS_RELEASED && !(flags & HS_ARCHIVED)) ||
(flags & HS_LOST && !(flags & HS_ARCHIVED))) {
CDEBUG(D_HSM, "Incompatible flag change on "DFID
PFID(&info->mti_body->mbo_fid1), flags);
GOTO(out_unlock, rc = -EINVAL);
}
PFID(&info->mti_body->mbo_fid1), flags);
GOTO(out_unlock, rc = -EINVAL);
}
sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
CDEBUG(D_HSM, "%slrh=[type=%X len=%d idx=%d] fid="DFID
" dfid="DFID
sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
CDEBUG(D_HSM, "%slrh=[type=%X len=%d idx=%d] fid="DFID
" dfid="DFID
- " compound/cookie="LPX64"/"LPX64
- " status=%s action=%s archive#=%d flags="LPX64
- " create="LPU64" change="LPU64
- " extent="LPX64"-"LPX64" gid="LPX64" datalen=%d"
+ " compound/cookie=%#llx/%#llx"
+ " status=%s action=%s archive#=%d flags=%#llx"
+ " create=%llu change=%llu"
+ " extent=%#llx-%#llx gid=%#llx datalen=%d"
" data=[%s]\n",
prefix,
larr->arr_hdr.lrh_type,
" data=[%s]\n",
prefix,
larr->arr_hdr.lrh_type,
rc = 0;
for (i = 0 ; i < ducb->cookies_count ; i++) {
rc = 0;
for (i = 0 ; i < ducb->cookies_count ; i++) {
- CDEBUG(D_HSM, "%s: search "LPX64", found "LPX64"\n",
+ CDEBUG(D_HSM, "%s: search %#llx, found %#llx\n",
mdt_obd_name(ducb->mdt), ducb->cookies[i],
larr->arr_hai.hai_cookie);
if (larr->arr_hai.hai_cookie == ducb->cookies[i]) {
mdt_obd_name(ducb->mdt), ducb->cookies[i],
larr->arr_hai.hai_cookie);
if (larr->arr_hai.hai_cookie == ducb->cookies[i]) {
RETURN(ERR_PTR(-ENOENT));
}
RETURN(ERR_PTR(-ENOENT));
}
- CDEBUG(D_HSM, "llog successfully initialized, start from "LPD64"\n",
+ CDEBUG(D_HSM, "llog successfully initialized, start from %lld\n",
*pos);
/* first call = rewind */
if (*pos == 0) {
*pos);
/* first call = rewind */
if (*pos == 0) {
count = s->count;
sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
seq_printf(s, "lrh=[type=%X len=%d idx=%d/%d] fid="DFID
count = s->count;
sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
seq_printf(s, "lrh=[type=%X len=%d idx=%d/%d] fid="DFID
- " dfid="DFID" compound/cookie="LPX64"/"LPX64
- " action=%s archive#=%d flags="LPX64
- " extent="LPX64"-"LPX64
- " gid="LPX64" datalen=%d status=%s data=[%s]\n",
+ " dfid="DFID" compound/cookie=%#llx/%#llx"
+ " action=%s archive#=%d flags=%#llx"
+ " extent=%#llx-%#llx"
+ " gid=%#llx datalen=%d status=%s data=[%s]\n",
hdr->lrh_type, hdr->lrh_len,
llh->lgh_hdr->llh_cat_idx, hdr->lrh_index,
PFID(&larr->arr_hai.hai_fid),
hdr->lrh_type, hdr->lrh_len,
llh->lgh_hdr->llh_cat_idx, hdr->lrh_index,
PFID(&larr->arr_hai.hai_fid),
CERROR("%s: mdt_agent_record_update() "
"failed, cannot update "
"status to %s for cookie "
CERROR("%s: mdt_agent_record_update() "
"failed, cannot update "
"status to %s for cookie "
mdt_obd_name(mdt),
agent_req_status2name(ARS_SUCCEED),
hai->hai_cookie, rc2);
mdt_obd_name(mdt),
agent_req_status2name(ARS_SUCCEED),
hai->hai_cookie, rc2);
"%s: mdt_agent_record_update() "
"failed, cannot update "
"status to %s for cookie "
"%s: mdt_agent_record_update() "
"failed, cannot update "
"status to %s for cookie "
mdt_obd_name(mdt),
agent_req_status2name(ARS_FAILED),
hai->hai_cookie, rc);
mdt_obd_name(mdt),
agent_req_status2name(ARS_FAILED),
hai->hai_cookie, rc);
CERROR("%s: mdt_agent_record_update() "
"failed, cannot update "
"status to %s for cookie "
CERROR("%s: mdt_agent_record_update() "
"failed, cannot update "
"status to %s for cookie "
mdt_obd_name(mdt),
agent_req_status2name(ARS_FAILED),
hai->hai_cookie, rc);
mdt_obd_name(mdt),
agent_req_status2name(ARS_FAILED),
hai->hai_cookie, rc);
is_needed = true;
break;
}
is_needed = true;
break;
}
- CDEBUG(D_HSM, "fid="DFID" action=%s rq_flags="LPX64
- " extent="LPX64"-"LPX64" hsm_flags=%X %s\n",
+ CDEBUG(D_HSM, "fid="DFID" action=%s rq_flags=%#llx"
+ " extent=%#llx-%#llx hsm_flags=%X %s\n",
PFID(&hai->hai_fid),
hsm_copytool_action2name(hai->hai_action), rq_flags,
hai->hai_extent.offset, hai->hai_extent.length,
PFID(&hai->hai_fid),
hsm_copytool_action2name(hai->hai_action), rq_flags,
hai->hai_extent.offset, hai->hai_extent.length,
down_read(&cdt->cdt_request_lock);
list_for_each_entry(car, &cdt->cdt_requests, car_request_list) {
CDEBUG(D_HSM, "%s fid="DFID" dfid="DFID
down_read(&cdt->cdt_request_lock);
list_for_each_entry(car, &cdt->cdt_requests, car_request_list) {
CDEBUG(D_HSM, "%s fid="DFID" dfid="DFID
- " compound/cookie="LPX64"/"LPX64
- " action=%s archive#=%d flags="LPX64
- " extent="LPX64"-"LPX64
- " gid="LPX64" refcount=%d canceled=%d\n",
+ " compound/cookie=%#llx/%#llx"
+ " action=%s archive#=%d flags=%#llx"
+ " extent=%#llx-%#llx"
+ " gid=%#llx refcount=%d canceled=%d\n",
prefix, PFID(&car->car_hai->hai_fid),
PFID(&car->car_hai->hai_dfid),
car->car_compound_id, car->car_hai->hai_cookie,
prefix, PFID(&car->car_hai->hai_fid),
PFID(&car->car_hai->hai_dfid),
car->car_compound_id, car->car_hai->hai_cookie,
mdt_cdt_get_work_done(car, &data_moved);
seq_printf(s, "fid="DFID" dfid="DFID
mdt_cdt_get_work_done(car, &data_moved);
seq_printf(s, "fid="DFID" dfid="DFID
- " compound/cookie="LPX64"/"LPX64
- " action=%s archive#=%d flags="LPX64
- " extent="LPX64"-"LPX64" gid="LPX64
- " data=[%s] canceled=%d uuid=%s done="LPU64"\n",
+ " compound/cookie=%#llx/%#llx"
+ " action=%s archive#=%d flags=%#llx"
+ " extent=%#llx-%#llx gid=%#llx"
+ " data=[%s] canceled=%d uuid=%s done=%llu\n",
PFID(&car->car_hai->hai_fid),
PFID(&car->car_hai->hai_dfid),
car->car_compound_id, car->car_hai->hai_cookie,
PFID(&car->car_hai->hai_fid),
PFID(&car->car_hai->hai_dfid),
car->car_compound_id, car->car_hai->hai_cookie,
GOTO(out, rc = -EREMCHG);
}
GOTO(out, rc = -EREMCHG);
}
- argv[0] = cache->uc_upcall;
- snprintf(keystr, sizeof(keystr), LPU64, entry->ue_key);
+ argv[0] = cache->uc_upcall;
+ snprintf(keystr, sizeof(keystr), "%llu", entry->ue_key);
do_gettimeofday(&start);
rc = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
do_gettimeofday(&start);
rc = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
MDS_ATTR_FORCE | MDS_ATTR_KILL_SUID | MDS_ATTR_KILL_SGID |
MDS_ATTR_FROM_OPEN | MDS_OPEN_OWNEROVERRIDE);
if (in != 0)
MDS_ATTR_FORCE | MDS_ATTR_KILL_SUID | MDS_ATTR_KILL_SGID |
MDS_ATTR_FROM_OPEN | MDS_OPEN_OWNEROVERRIDE);
if (in != 0)
- CERROR("Unknown attr bits: "LPX64"\n", in);
+ CERROR("Unknown attr bits: %#llx\n", in);
if (info->mti_transno != 0) {
struct obd_export *exp = req->rq_export;
if (info->mti_transno != 0) {
struct obd_export *exp = req->rq_export;
- CERROR("%s: replay trans "LPU64" NID %s: rc = %d\n",
+ CERROR("%s: replay trans %llu NID %s: rc = %d\n",
mdt_obd_name(mdt), info->mti_transno,
libcfs_nid2str(exp->exp_connection->c_peer.nid),
rc);
mdt_obd_name(mdt), info->mti_transno,
libcfs_nid2str(exp->exp_connection->c_peer.nid),
rc);
}
spin_unlock(&mdt->mdt_lut.lut_translock);
}
spin_unlock(&mdt->mdt_lut.lut_translock);
- CDEBUG(D_INODE, "transno = "LPU64", last_committed = "LPU64"\n",
+ CDEBUG(D_INODE, "transno = %llu, last_committed = %llu\n",
info->mti_transno,
req->rq_export->exp_obd->obd_last_committed);
info->mti_transno,
req->rq_export->exp_obd->obd_last_committed);
* otherwise the following resend(after replay) can not
* be checked correctly by xid */
mutex_unlock(&ted->ted_lcd_lock);
* otherwise the following resend(after replay) can not
* be checked correctly by xid */
mutex_unlock(&ted->ted_lcd_lock);
- CDEBUG(D_HA, "%s: transno = "LPU64" < last_transno = "LPU64"\n",
+ CDEBUG(D_HA, "%s: transno = %llu < last_transno = %llu\n",
mdt_obd_name(mdt), info->mti_transno,
lcd->lcd_last_transno);
RETURN_EXIT;
mdt_obd_name(mdt), info->mti_transno,
lcd->lcd_last_transno);
RETURN_EXIT;
- CDEBUG(D_HA, DFID " Change mfd mode "LPO64" -> "LPO64".\n",
+ CDEBUG(D_HA, DFID " Change mfd mode %#llo -> %#llo.\n",
PFID(mdt_object_fid(mfd->mfd_object)), mfd->mfd_mode, mode);
mfd->mfd_mode = mode;
PFID(mdt_object_fid(mfd->mfd_object)), mfd->mfd_mode, mode);
mfd->mfd_mode = mode;
mdt_set_disposition(info, rep, DISP_OPEN_STRIPE);
}
mdt_set_disposition(info, rep, DISP_OPEN_STRIPE);
}
- CDEBUG(D_INODE, "after open, ma_valid bit = "LPX64" lmm_size = %d\n",
- ma->ma_valid, ma->ma_lmm_size);
+ CDEBUG(D_INODE, "after open, ma_valid bit = %#llx lmm_size = %d\n",
+ ma->ma_valid, ma->ma_lmm_size);
if (ma->ma_valid & MA_LOV) {
LASSERT(ma->ma_lmm_size != 0);
if (ma->ma_valid & MA_LOV) {
LASSERT(ma->ma_lmm_size != 0);
old_mfd = mdt_handle2mfd(med, info->mti_rr.rr_handle, true);
if (old_mfd != NULL) {
CDEBUG(D_HA, "delete orphan mfd = %p, fid = "DFID", "
old_mfd = mdt_handle2mfd(med, info->mti_rr.rr_handle, true);
if (old_mfd != NULL) {
CDEBUG(D_HA, "delete orphan mfd = %p, fid = "DFID", "
- "cookie = "LPX64"\n", mfd,
+ "cookie = %#llx\n", mfd,
PFID(mdt_object_fid(mfd->mfd_object)),
info->mti_rr.rr_handle->cookie);
class_handle_unhash(&old_mfd->mfd_handle);
PFID(mdt_object_fid(mfd->mfd_object)),
info->mti_rr.rr_handle->cookie);
class_handle_unhash(&old_mfd->mfd_handle);
} else {
spin_unlock(&med->med_open_lock);
CDEBUG(D_HA, "orphan mfd not found, fid = "DFID", "
} else {
spin_unlock(&med->med_open_lock);
CDEBUG(D_HA, "orphan mfd not found, fid = "DFID", "
PFID(mdt_object_fid(mfd->mfd_object)),
info->mti_rr.rr_handle->cookie);
}
PFID(mdt_object_fid(mfd->mfd_object)),
info->mti_rr.rr_handle->cookie);
}
- CDEBUG(D_HA, "Store old cookie "LPX64" in new mfd\n",
+ CDEBUG(D_HA, "Store old cookie %#llx in new mfd\n",
info->mti_rr.rr_handle->cookie);
mfd->mfd_old_handle.cookie = info->mti_rr.rr_handle->cookie;
info->mti_rr.rr_handle->cookie);
mfd->mfd_old_handle.cookie = info->mti_rr.rr_handle->cookie;
opdata = mdt_req_from_lrd(req, info->mti_reply_data);
mdt_set_disposition(info, ldlm_rep, opdata);
opdata = mdt_req_from_lrd(req, info->mti_reply_data);
mdt_set_disposition(info, ldlm_rep, opdata);
- CDEBUG(D_INODE, "This is reconstruct open: disp="LPX64", result=%d\n",
+ CDEBUG(D_INODE, "This is reconstruct open: disp=%#llx, result=%d\n",
ldlm_rep->lock_policy_res1, req->rq_status);
if (mdt_get_disposition(ldlm_rep, DISP_OPEN_CREATE) &&
ldlm_rep->lock_policy_res1, req->rq_status);
if (mdt_get_disposition(ldlm_rep, DISP_OPEN_CREATE) &&
/* Lease must be with open lock */
if (!(open_flags & MDS_OPEN_LOCK)) {
/* Lease must be with open lock */
if (!(open_flags & MDS_OPEN_LOCK)) {
- CERROR("Request lease for file:"DFID ", but open lock "
- "is missed, open_flags = "LPO64".\n",
- PFID(mdt_object_fid(obj)), open_flags);
+ CERROR("%s: Request lease for file:"DFID ", but open lock "
+ "is missed, open_flags = %#llo : rc = %d\n",
+ mdt_obd_name(info->mti_mdt),
+ PFID(mdt_object_fid(obj)), open_flags, -EPROTO);
GOTO(out, rc = -EPROTO);
}
GOTO(out, rc = -EPROTO);
}
rc = mdt_object_lock(info, obj, lhc, *ibits);
}
rc = mdt_object_lock(info, obj, lhc, *ibits);
}
- CDEBUG(D_INODE, "Requested bits lock:"DFID ", ibits = "LPX64
- ", open_flags = "LPO64", try_layout = %d, rc = %d\n",
- PFID(mdt_object_fid(obj)), *ibits, open_flags, try_layout, rc);
+ CDEBUG(D_INODE, "%s: Requested bits lock:"DFID ", ibits = %#llx"
+ ", open_flags = %#llo, try_layout = %d : rc = %d\n",
+ mdt_obd_name(info->mti_mdt), PFID(mdt_object_fid(obj)),
+ *ibits, open_flags, try_layout, rc);
/* will change layout, revoke layout locks by enqueuing EX lock. */
if (rc == 0 && create_layout) {
struct mdt_lock_handle *ll = &info->mti_lh[MDT_LH_LAYOUT];
CDEBUG(D_INODE, "Will create layout, get EX layout lock:"DFID
/* will change layout, revoke layout locks by enqueuing EX lock. */
if (rc == 0 && create_layout) {
struct mdt_lock_handle *ll = &info->mti_lh[MDT_LH_LAYOUT];
CDEBUG(D_INODE, "Will create layout, get EX layout lock:"DFID
- ", open_flags = "LPO64"\n",
+ ", open_flags = %#llo\n",
PFID(mdt_object_fid(obj)), open_flags);
/* We cannot enqueue another lock for the same resource we
PFID(mdt_object_fid(obj)), open_flags);
/* We cannot enqueue another lock for the same resource we
GOTO(out, result = -EROFS);
CDEBUG(D_INODE, "I am going to open "DFID"/("DNAME"->"DFID") "
GOTO(out, result = -EROFS);
CDEBUG(D_INODE, "I am going to open "DFID"/("DNAME"->"DFID") "
- "cr_flag="LPO64" mode=0%06o msg_flag=0x%x\n",
+ "cr_flag=%#llo mode=0%06o msg_flag=0x%x\n",
PFID(rr->rr_fid1), PNAME(&rr->rr_name),
PFID(rr->rr_fid2), create_flags,
ma->ma_attr.la_mode, msg_flags);
PFID(rr->rr_fid1), PNAME(&rr->rr_name),
PFID(rr->rr_fid2), create_flags,
ma->ma_attr.la_mode, msg_flags);
/* Compare on-disk and packed data_version */
if (data->cd_data_version != ma->ma_hsm.mh_arch_ver) {
/* Compare on-disk and packed data_version */
if (data->cd_data_version != ma->ma_hsm.mh_arch_ver) {
- CDEBUG(D_HSM, DFID" data_version mismatches: packed="LPU64
- " and on-disk="LPU64"\n", PFID(mdt_object_fid(o)),
+ CDEBUG(D_HSM, DFID" data_version mismatches: packed=%llu"
+ " and on-disk=%llu\n", PFID(mdt_object_fid(o)),
data->cd_data_version, ma->ma_hsm.mh_arch_ver);
GOTO(out_unlock, rc = -EPERM);
}
data->cd_data_version, ma->ma_hsm.mh_arch_ver);
GOTO(out_unlock, rc = -EPERM);
}
if (mdt_mfd_closed(mfd)) {
spin_unlock(&med->med_open_lock);
CDEBUG(D_INODE, "no handle for file close: fid = "DFID
if (mdt_mfd_closed(mfd)) {
spin_unlock(&med->med_open_lock);
CDEBUG(D_INODE, "no handle for file close: fid = "DFID
- ": cookie = "LPX64"\n", PFID(info->mti_rr.rr_fid1),
+ ": cookie = %#llx\n", PFID(info->mti_rr.rr_fid1),
info->mti_close_handle.cookie);
/** not serious error since bug 3633 */
rc = -ESTALE;
info->mti_close_handle.cookie);
/** not serious error since bug 3633 */
rc = -ESTALE;
oldrep = list_entry(tmp, struct ptlrpc_reply_state,
rs_exp_list);
oldrep = list_entry(tmp, struct ptlrpc_reply_state,
rs_exp_list);
- if (oldrep->rs_xid != req->rq_xid)
- continue;
+ if (oldrep->rs_xid != req->rq_xid)
+ continue;
- if (oldrep->rs_opc != lustre_msg_get_opc(req->rq_reqmsg))
- CERROR ("Resent req xid "LPU64" has mismatched opc: "
- "new %d old %d\n", req->rq_xid,
- lustre_msg_get_opc(req->rq_reqmsg),
- oldrep->rs_opc);
+ if (oldrep->rs_opc != lustre_msg_get_opc(req->rq_reqmsg))
+ CERROR("%s: Resent req xid %llu has mismatched opc: "
+ "new %d old %d\n", exp->exp_obd->obd_name,
+ req->rq_xid, lustre_msg_get_opc(req->rq_reqmsg),
+ oldrep->rs_opc);
svcpt = oldrep->rs_svcpt;
spin_lock(&svcpt->scp_rep_lock);
list_del_init(&oldrep->rs_exp_list);
svcpt = oldrep->rs_svcpt;
spin_lock(&svcpt->scp_rep_lock);
list_del_init(&oldrep->rs_exp_list);
- CDEBUG(D_HA, "Stealing %d locks from rs %p x"LPD64".t"LPD64
+ CDEBUG(D_HA, "Stealing %d locks from rs %p x%lld.t%lld"
" o%d NID %s\n",
oldrep->rs_nlocks, oldrep,
oldrep->rs_xid, oldrep->rs_transno, oldrep->rs_opc,
" o%d NID %s\n",
oldrep->rs_nlocks, oldrep,
oldrep->rs_xid, oldrep->rs_transno, oldrep->rs_opc,
LASSERT(trd != NULL);
lrd = &trd->trd_reply;
LASSERT(trd != NULL);
lrd = &trd->trd_reply;
- DEBUG_REQ(D_HA, req, "restoring transno "LPD64"/status %d",
+ DEBUG_REQ(D_HA, req, "restoring transno %lld/status %d",
lrd->lrd_transno, lrd->lrd_result);
req->rq_transno = lrd->lrd_transno;
lrd->lrd_transno, lrd->lrd_result);
req->rq_transno = lrd->lrd_transno;
lustre_msg_set_transno(req->rq_repmsg, req->rq_transno);
lustre_msg_set_status(req->rq_repmsg, req->rq_status);
lustre_msg_set_transno(req->rq_repmsg, req->rq_transno);
lustre_msg_set_status(req->rq_repmsg, req->rq_status);
- DEBUG_REQ(D_RPCTRACE, req, "restoring transno "LPD64"/status %d",
+ DEBUG_REQ(D_RPCTRACE, req, "restoring transno %lld/status %d",
req->rq_transno, req->rq_status);
mdt_steal_ack_locks(req);
req->rq_transno, req->rq_status);
mdt_steal_ack_locks(req);
static void mdt_obj_version_get(struct mdt_thread_info *info,
struct mdt_object *o, __u64 *version)
{
static void mdt_obj_version_get(struct mdt_thread_info *info,
struct mdt_object *o, __u64 *version)
{
if (mdt_object_exists(o) && !mdt_object_remote(o) &&
!fid_is_obf(mdt_object_fid(o)))
if (mdt_object_exists(o) && !mdt_object_remote(o) &&
!fid_is_obf(mdt_object_fid(o)))
- *version = dt_version_get(info->mti_env, mdt_obj2dt(o));
- else
- *version = ENOENT_VERSION;
- CDEBUG(D_INODE, "FID "DFID" version is "LPX64"\n",
- PFID(mdt_object_fid(o)), *version);
+ *version = dt_version_get(info->mti_env, mdt_obj2dt(o));
+ else
+ *version = ENOENT_VERSION;
+ CDEBUG(D_INODE, "FID "DFID" version is %#llx\n",
+ PFID(mdt_object_fid(o)), *version);
spin_unlock(&req->rq_export->exp_lock);
RETURN(-EOVERFLOW);
} else if (pre_ver[idx] != version) {
spin_unlock(&req->rq_export->exp_lock);
RETURN(-EOVERFLOW);
} else if (pre_ver[idx] != version) {
- CDEBUG(D_INODE, "Version mismatch "LPX64" != "LPX64"\n",
+ CDEBUG(D_INODE, "Version mismatch %#llx != %#llx\n",
pre_ver[idx], version);
spin_lock(&req->rq_export->exp_lock);
req->rq_export->exp_vbr_failed = 1;
pre_ver[idx], version);
spin_lock(&req->rq_export->exp_lock);
req->rq_export->exp_vbr_failed = 1;
req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
} else {
req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size);
req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size);
} else {
- CDEBUG(D_INFO, "Valid bits: "LPX64"\n",
+ CDEBUG(D_INFO, "Valid bits: %#llx\n",
info->mti_body->mbo_valid);
info->mti_body->mbo_valid);
if (size == -ENODATA) {
size = 0;
if (size == -ENODATA) {
size = 0;
/* This isn't strictly an error, but all current clients
* should set OBD_MD_FLCTIME when setting attributes. */
CWARN("%s: client miss to set OBD_MD_FLCTIME when "
/* This isn't strictly an error, but all current clients
* should set OBD_MD_FLCTIME when setting attributes. */
CWARN("%s: client miss to set OBD_MD_FLCTIME when "
- "setxattr %s: [object "DFID"] [valid "LPU64"]\n",
+ "setxattr %s: [object "DFID"] [valid %llu]\n",
mdt_obd_name(info->mti_mdt), xattr_name,
PFID(rr->rr_fid1), valid);
attr->la_ctime = cfs_time_current_sec();
mdt_obd_name(info->mti_mdt), xattr_name,
PFID(rr->rr_fid1), valid);
attr->la_ctime = cfs_time_current_sec();
ma->ma_attr_flags |= MDS_PERM_BYPASS;
mo_attr_set(env, child, ma);
}
ma->ma_attr_flags |= MDS_PERM_BYPASS;
mo_attr_set(env, child, ma);
}
- } else {
- CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid);
- rc = -EINVAL;
- }
- if (rc == 0)
+ } else {
+ CDEBUG(D_INFO, "valid bits: %#llx\n", valid);
+ rc = -EINVAL;
+ }
+ if (rc == 0)
mdt_counter_incr(req, LPROC_MDT_SETXATTR);
EXIT;
mdt_counter_incr(req, LPROC_MDT_SETXATTR);
EXIT;
NULL, fsdb, 0, LVB_T_NONE, NULL,
&lockh);
if (rc != ELDLM_OK) {
NULL, fsdb, 0, LVB_T_NONE, NULL,
&lockh);
if (rc != ELDLM_OK) {
- CERROR("can't take cfg lock for "LPX64"/"LPX64"(%d)\n",
+ CERROR("%s: can't take cfg lock for %#llx/%#llx : rc = %d\n",
+ mgs->mgs_obd->obd_name,
le64_to_cpu(res_id.name[0]),
le64_to_cpu(res_id.name[1]), rc);
le64_to_cpu(res_id.name[0]),
le64_to_cpu(res_id.name[1]), rc);
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 %lld: ignoring repeat request\n",
val);
LPROCFS_CLIMP_EXIT(dev);
val);
LPROCFS_CLIMP_EXIT(dev);
if (osp == NULL || osp->opd_pre == NULL)
return 0;
if (osp == NULL || osp->opd_pre == NULL)
return 0;
- seq_printf(m, LPX64"\n", fid_seq(&osp->opd_pre_used_fid));
+ seq_printf(m, "%#llx\n", fid_seq(&osp->opd_pre_used_fid));
return 0;
}
LPROC_SEQ_FOPS_RO(osp_prealloc_next_seq);
return 0;
}
LPROC_SEQ_FOPS_RO(osp_prealloc_next_seq);
if (osp == NULL || osp->opd_pre == NULL)
return 0;
if (osp == NULL || osp->opd_pre == NULL)
return 0;
- seq_printf(m, LPX64"\n",
+ seq_printf(m, "%#llx\n",
fid_seq(&osp->opd_pre_last_created_fid));
return 0;
}
fid_seq(&osp->opd_pre_last_created_fid));
return 0;
}
if (osp == NULL || osp->opd_pre == NULL)
return 0;
if (osp == NULL || osp->opd_pre == NULL)
return 0;
- seq_printf(m, LPU64"\n", osp->opd_pre_reserved);
+ seq_printf(m, "%llu\n", osp->opd_pre_reserved);
return 0;
}
LPROC_SEQ_FOPS_RO(osp_prealloc_reserved);
return 0;
}
LPROC_SEQ_FOPS_RO(osp_prealloc_reserved);
LASSERT(sfs->os_fprecreated <= OST_MAX_PRECREATE * 2);
LASSERT(sfs->os_fprecreated <= OST_MAX_PRECREATE * 2);
- CDEBUG(D_OTHER, "%s: "LPU64" blocks, "LPU64" free, "LPU64" avail, "
- LPU64" files, "LPU64" free files\n", d->opd_obd->obd_name,
+ CDEBUG(D_OTHER, "%s: %llu blocks, %llu free, %llu avail, "
+ "%llu files, %llu free files\n", d->opd_obd->obd_name,
sfs->os_blocks, sfs->os_bfree, sfs->os_bavail,
sfs->os_files, sfs->os_ffree);
RETURN(0);
sfs->os_blocks, sfs->os_bfree, sfs->os_bavail,
sfs->os_files, sfs->os_ffree);
RETURN(0);
if (rc != 0)
GOTO(out, rc);
if (rc != 0)
GOTO(out, rc);
- CDEBUG(D_CACHE, "%s: id: used %lu, processed "LPU64"\n",
+ CDEBUG(D_CACHE, "%s: id: used %lu, processed %llu\n",
d->opd_obd->obd_name, id, d->opd_syn_last_processed_id);
/* wait till all-in-line are processed */
d->opd_obd->obd_name, id, d->opd_syn_last_processed_id);
/* wait till all-in-line are processed */
update = thandle_to_osp_update_request(th);
LASSERT(update != NULL);
update = thandle_to_osp_update_request(th);
LASSERT(update != NULL);
- CDEBUG(D_INFO, "write "DFID" offset = "LPU64" length = %zu\n",
+ CDEBUG(D_INFO, "write "DFID" offset = %llu length = %zu\n",
PFID(lu_object_fid(&dt->do_lu)), *pos, buf->lb_len);
rc = osp_update_rpc_pack(env, write, update, OUT_WRITE,
PFID(lu_object_fid(&dt->do_lu)), *pos, buf->lb_len);
rc = osp_update_rpc_pack(env, write, update, OUT_WRITE,
- LCONSOLE_INFO("%s: update sequence from "LPX64" to "LPX64"\n",
+ LCONSOLE_INFO("%s: update sequence from %#llx to %#llx\n",
osp->opd_obd->obd_name, fid_seq(last_fid),
fid_seq(fid));
/* Update last_xxx to the new seq */
osp->opd_obd->obd_name, fid_seq(last_fid),
fid_seq(fid));
/* Update last_xxx to the new seq */
if ((msfs->os_ffree < 32) || (msfs->os_bavail < used)) {
d->opd_pre_status = -ENOSPC;
if (old != -ENOSPC)
if ((msfs->os_ffree < 32) || (msfs->os_bavail < used)) {
d->opd_pre_status = -ENOSPC;
if (old != -ENOSPC)
- CDEBUG(D_INFO, "%s: status: "LPU64" blocks, "
- LPU64" free, "LPU64" used, "LPU64" "
+ CDEBUG(D_INFO, "%s: status: %llu blocks, "
+ "%llu free, %llu used, %llu "
"avail -> %d: rc = %d\n",
d->opd_obd->obd_name, msfs->os_blocks,
msfs->os_bfree, used, msfs->os_bavail,
"avail -> %d: rc = %d\n",
d->opd_obd->obd_name, msfs->os_blocks,
msfs->os_bfree, used, msfs->os_bavail,
d->opd_pre_create_count = OST_MIN_PRECREATE;
spin_unlock(&d->opd_pre_lock);
wake_up(&d->opd_pre_waitq);
d->opd_pre_create_count = OST_MIN_PRECREATE;
spin_unlock(&d->opd_pre_lock);
wake_up(&d->opd_pre_waitq);
- CDEBUG(D_INFO, "%s: no space: "LPU64" blocks, "LPU64
- " free, "LPU64" used, "LPU64" avail -> %d: "
+ CDEBUG(D_INFO, "%s: no space: %llu blocks, %llu"
+ " free, %llu used, %llu avail -> %d: "
"rc = %d\n", d->opd_obd->obd_name,
msfs->os_blocks, msfs->os_bfree, used,
msfs->os_bavail, d->opd_pre_status, rc);
"rc = %d\n", d->opd_obd->obd_name,
msfs->os_blocks, msfs->os_bfree, used,
msfs->os_bavail, d->opd_pre_status, rc);
if (unlikely(osp_precreate_end_seq(&env, d) &&
osp_create_end_seq(&env, d))) {
if (unlikely(osp_precreate_end_seq(&env, d) &&
osp_create_end_seq(&env, d))) {
- LCONSOLE_INFO("%s:"LPX64" is used up."
+ LCONSOLE_INFO("%s:%#llx is used up."
" Update to new seq\n",
d->opd_obd->obd_name,
fid_seq(&d->opd_pre_last_created_fid));
" Update to new seq\n",
d->opd_obd->obd_name,
fid_seq(&d->opd_pre_last_created_fid));
struct osp_device *d = data;
CDEBUG(D_HA, "%s: slow creates, last="DFID", next="DFID", "
struct osp_device *d = data;
CDEBUG(D_HA, "%s: slow creates, last="DFID", next="DFID", "
- "reserved="LPU64", syn_changes=%u, "
+ "reserved=%llu, syn_changes=%u, "
"syn_rpc_in_progress=%d, status=%d\n",
d->opd_obd->obd_name, PFID(&d->opd_pre_last_created_fid),
PFID(&d->opd_pre_used_fid), d->opd_pre_reserved,
"syn_rpc_in_progress=%d, status=%d\n",
d->opd_obd->obd_name, PFID(&d->opd_pre_last_created_fid),
PFID(&d->opd_pre_used_fid), d->opd_pre_reserved,
struct osp_device *d = req->rq_cb_data;
struct osp_job_req_args *jra;
struct osp_device *d = req->rq_cb_data;
struct osp_job_req_args *jra;
- CDEBUG(D_HA, "commit req %p, transno "LPU64"\n", req, req->rq_transno);
+ CDEBUG(D_HA, "commit req %p, transno %llu\n", req, req->rq_transno);
if (unlikely(req->rq_transno == 0))
return;
if (unlikely(req->rq_transno == 0))
return;
*/
LASSERTF(req->rq_transno == 0 ||
req->rq_import_generation < imp->imp_generation,
*/
LASSERTF(req->rq_transno == 0 ||
req->rq_import_generation < imp->imp_generation,
- "transno "LPU64", rc %d, gen: req %d, imp %d\n",
+ "transno %llu, rc %d, gen: req %d, imp %d\n",
req->rq_transno, rc, req->rq_import_generation,
imp->imp_generation);
if (req->rq_transno == 0) {
req->rq_transno, rc, req->rq_import_generation,
imp->imp_generation);
if (req->rq_transno == 0) {
/* lsr_valid can only be 0 or have OBD_MD_{FLUID,FLGID} set,
* so no bits other than these should be set. */
if ((rec->lsr_valid & ~(OBD_MD_FLUID | OBD_MD_FLGID)) != 0) {
/* lsr_valid can only be 0 or have OBD_MD_{FLUID,FLGID} set,
* so no bits other than these should be set. */
if ((rec->lsr_valid & ~(OBD_MD_FLUID | OBD_MD_FLGID)) != 0) {
- CERROR("%s: invalid setattr record, lsr_valid:"LPU64"\n",
+ CERROR("%s: invalid setattr record, lsr_valid:%llu\n",
d->opd_obd->obd_name, rec->lsr_valid);
/* return 1 on invalid record */
RETURN(1);
d->opd_obd->obd_name, rec->lsr_valid);
/* return 1 on invalid record */
RETURN(1);
CERROR("%s: can't cancel record: %d\n",
obd->obd_name, rc);
} else {
CERROR("%s: can't cancel record: %d\n",
obd->obd_name, rc);
} else {
- DEBUG_REQ(D_OTHER, req, "imp_committed = "LPU64,
+ DEBUG_REQ(D_OTHER, req, "imp_committed = %llu",
imp->imp_peer_committed_transno);
}
ptlrpc_req_finished(req);
imp->imp_peer_committed_transno);
}
ptlrpc_req_finished(req);
spin_lock(&tr->otr_lock);
if (likely(txn->oti_current_id > tr->otr_committed_id)) {
spin_lock(&tr->otr_lock);
if (likely(txn->oti_current_id > tr->otr_committed_id)) {
- CDEBUG(D_OTHER, "committed: "LPU64" -> "LPU64"\n",
+ CDEBUG(D_OTHER, "committed: %llu -> %llu\n",
tr->otr_committed_id, txn->oti_current_id);
tr->otr_committed_id = txn->oti_current_id;
tr->otr_committed_id, txn->oti_current_id);
tr->otr_committed_id = txn->oti_current_id;
if (unlikely(tr->otr_next_id <= d->opd_syn_last_used_id)) {
spin_unlock(&tr->otr_lock);
if (unlikely(tr->otr_next_id <= d->opd_syn_last_used_id)) {
spin_unlock(&tr->otr_lock);
- CERROR("%s: next "LPU64", last synced "LPU64"\n",
+ CERROR("%s: next %llu, last synced %llu\n",
d->opd_obd->obd_name, tr->otr_next_id,
d->opd_syn_last_used_id);
LBUG();
d->opd_obd->obd_name, tr->otr_next_id,
d->opd_syn_last_used_id);
LBUG();
if (list_empty(&d->opd_syn_ontrack))
list_add(&d->opd_syn_ontrack, &tr->otr_wakeup_list);
spin_unlock(&tr->otr_lock);
if (list_empty(&d->opd_syn_ontrack))
list_add(&d->opd_syn_ontrack, &tr->otr_wakeup_list);
spin_unlock(&tr->otr_lock);
- CDEBUG(D_OTHER, "new id "LPU64"\n", id);
+ CDEBUG(D_OTHER, "new id %llu\n", id);
update = object_update_request_get(ourq, i, &size);
LASSERT(update != NULL);
CDEBUG(mask, "i = %u fid = "DFID" op = %s "
update = object_update_request_get(ourq, i, &size);
LASSERT(update != NULL);
CDEBUG(mask, "i = %u fid = "DFID" op = %s "
- "params = %d batchid = "LPU64" size = %zu repsize %u\n",
+ "params = %d batchid = %llu size = %zu repsize %u\n",
i, PFID(&update->ou_fid),
update_op_str(update->ou_type),
update->ou_params_count,
i, PFID(&update->ou_fid),
update_op_str(update->ou_type),
update->ou_params_count,
last_committed_transno =
req->rq_import->imp_peer_committed_transno;
last_committed_transno =
req->rq_import->imp_peer_committed_transno;
- CDEBUG(D_HA, "trans no "LPU64" committed transno "LPU64"\n",
+ CDEBUG(D_HA, "trans no %llu committed transno %llu\n",
req->rq_transno, last_committed_transno);
/* If the transaction is not really committed, mark result = 1 */
req->rq_transno, last_committed_transno);
/* If the transaction is not really committed, mark result = 1 */
spin_unlock(&ou->ou_lock);
LASSERT(oth->ot_super.th_wait_submit == 1);
spin_unlock(&ou->ou_lock);
LASSERT(oth->ot_super.th_wait_submit == 1);
- CDEBUG(D_INFO, "%s: version "LPU64" oth:version %p:"LPU64"\n",
+ CDEBUG(D_INFO, "%s: version %llu oth:version %p:%llu\n",
osp->opd_obd->obd_name, ou->ou_version, oth,
oth->ot_our->our_version);
osp->opd_obd->obd_name, ou->ou_version, oth,
oth->ot_our->our_version);
spin_lock(&ou->ou_lock);
list_for_each_entry_safe(our, tmp, &ou->ou_list, our_list) {
LASSERT(our->our_th != NULL);
spin_lock(&ou->ou_lock);
list_for_each_entry_safe(our, tmp, &ou->ou_list, our_list) {
LASSERT(our->our_th != NULL);
- CDEBUG(D_HA, "ou %p version "LPU64" rpc_version "LPU64"\n",
+ CDEBUG(D_HA, "ou %p version %llu rpc_version %llu\n",
ou, our->our_version, ou->ou_rpc_version);
spin_lock(&our->our_list_lock);
/* Find next osp_update_request in the list */
ou, our->our_version, ou->ou_rpc_version);
spin_lock(&our->our_list_lock);
/* Find next osp_update_request in the list */
- CDEBUG(D_HA, "%s: add oth %p with version "LPU64"\n",
+ CDEBUG(D_HA, "%s: add oth %p with version %llu\n",
osp->opd_obd->obd_name, oth, our->our_version);
LASSERT(our->our_req_ready == 0);
osp->opd_obd->obd_name, oth, our->our_version);
LASSERT(our->our_req_ready == 0);