if (CFS_FAIL_TIMEOUT(OBD_FAIL_LFSCK_DELAY2, cfs_fail_val) &&
unlikely(!thread_is_running(thread))) {
CDEBUG(D_LFSCK, "%s: scan dir exit for engine stop, "
- "parent "DFID", cookie "LPX64"\n",
+ "parent "DFID", cookie %#llx\n",
lfsck_lfsck2name(lfsck),
PFID(lfsck_dto2fid(dir)), lfsck->li_cookie_dir);
if (rc != 0) {
CDEBUG(D_LFSCK, "%s: scan dir failed at rec(), "
- "parent "DFID", cookie "LPX64": rc = %d\n",
+ "parent "DFID", cookie %#llx: rc = %d\n",
lfsck_lfsck2name(lfsck),
PFID(lfsck_dto2fid(dir)),
lfsck->li_cookie_dir, rc);
lfsck_control_speed(lfsck);
if (unlikely(!thread_is_running(thread))) {
CDEBUG(D_LFSCK, "%s: scan dir exit for engine stop, "
- "parent "DFID", cookie "LPX64"\n",
+ "parent "DFID", cookie %#llx\n",
lfsck_lfsck2name(lfsck),
PFID(lfsck_dto2fid(dir)),
lfsck->li_cookie_dir);
if (CFS_FAIL_TIMEOUT(OBD_FAIL_LFSCK_DELAY1, cfs_fail_val) &&
unlikely(!thread_is_running(thread))) {
CDEBUG(D_LFSCK, "%s: OIT scan exit for engine stop, "
- "cookie "LPU64"\n",
+ "cookie %llu\n",
lfsck_lfsck2name(lfsck), iops->store(env, di));
RETURN(0);
target = lfsck_object_find_bottom(env, lfsck, fid);
if (IS_ERR(target)) {
CDEBUG(D_LFSCK, "%s: OIT scan failed at find target "
- DFID", cookie "LPU64": rc = %d\n",
+ DFID", cookie %llu: rc = %d\n",
lfsck_lfsck2name(lfsck), PFID(fid),
iops->store(env, di), rc);
lfsck_fail(env, lfsck, true);
lfsck->li_current_oit_processed = 0;
else
CDEBUG(D_LFSCK, "%s oit engine fail to locate next at "
- LPU64 ": rc = %d\n", lfsck_lfsck2name(lfsck),
+ "%llu: rc = %d\n", lfsck_lfsck2name(lfsck),
iops->store(env, di), rc);
if (unlikely(!thread_is_running(thread))) {
CDEBUG(D_LFSCK, "%s: OIT scan exit for engine stop, "
- "cookie "LPU64"\n", lfsck_lfsck2name(lfsck),
+ "cookie %llu\n", lfsck_lfsck2name(lfsck),
iops->store(env, di));
RETURN(0);
}
GOTO(fini_oit, rc);
CDEBUG(D_LFSCK, "LFSCK entry: oit_flags = %#x, dir_flags = %#x, "
- "oit_cookie = "LPU64", dir_cookie = "LPX64", parent = "DFID
+ "oit_cookie = %llu, dir_cookie = %#llx, parent = "DFID
", pid = %d\n", lfsck->li_args_oit, lfsck->li_args_dir,
lfsck->li_pos_checkpoint.lp_oit_cookie,
lfsck->li_pos_checkpoint.lp_dir_cookie,
lfsck_pos_fill(env, lfsck, &lfsck->li_pos_checkpoint, false);
CDEBUG(D_LFSCK, "LFSCK exit: oit_flags = %#x, dir_flags = %#x, "
- "oit_cookie = "LPU64", dir_cookie = "LPX64", parent = "DFID
+ "oit_cookie = %llu, dir_cookie = %#llx, parent = "DFID
", pid = %d, rc = %d\n", lfsck->li_args_oit, lfsck->li_args_dir,
lfsck->li_pos_checkpoint.lp_oit_cookie,
lfsck->li_pos_checkpoint.lp_dir_cookie,
log:
CDEBUG(D_LFSCK, "%s: layout LFSCK will create LAST_ID for <seq> "
- LPX64": rc = %d\n",
+ "%#llx: rc = %d\n",
lfsck_lfsck2name(lfsck), fid_seq(lfsck_dto2fid(obj)), rc);
return rc;
lo->ll_flags |= LF_CRASHED_LASTID;
CDEBUG(D_LFSCK, "%s: layout LFSCK finds crashed "
- "LAST_ID file (1) for the sequence "LPX64
- ", old value "LPU64", known value "LPU64"\n",
+ "LAST_ID file (1) for the sequence %#llx"
+ ", old value %llu, known value %llu\n",
lfsck_lfsck2name(lfsck), lls->lls_seq,
lastid, lls->lls_lastid);
}
continue;
CDEBUG(D_LFSCK, "%s: layout LFSCK will sync the LAST_ID for "
- "<seq> "LPX64" as <oid> "LPU64"\n",
+ "<seq> %#llx as <oid> %llu\n",
lfsck_lfsck2name(lfsck), lls->lls_seq, lls->lls_lastid);
if (bk->lb_param & LPF_DRYRUN) {
if (IS_ERR(th)) {
rc1 = PTR_ERR(th);
CDEBUG(D_LFSCK, "%s: layout LFSCK failed to store "
- "the LAST_ID for <seq> "LPX64"(1): rc = %d\n",
+ "the LAST_ID for <seq> %#llx(1): rc = %d\n",
lfsck_lfsck2name(com->lc_lfsck),
lls->lls_seq, rc1);
continue;
if (rc != 0) {
rc1 = rc;
CDEBUG(D_LFSCK, "%s: layout LFSCK failed to store "
- "the LAST_ID for <seq> "LPX64"(2): rc = %d\n",
+ "the LAST_ID for <seq> %#llx(2): rc = %d\n",
lfsck_lfsck2name(com->lc_lfsck),
lls->lls_seq, rc1);
}
lo->ll_flags |= LF_CRASHED_LASTID;
CDEBUG(D_LFSCK, "%s: layout LFSCK cannot find the "
- "LAST_ID file for sequence "LPX64"\n",
+ "LAST_ID file for sequence %#llx\n",
lfsck_lfsck2name(lfsck), lls->lls_seq);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY4) &&
lo->ll_flags |= LF_CRASHED_LASTID;
CDEBUG(D_LFSCK, "%s: layout LFSCK finds invalid "
- "LAST_ID file for the sequence "LPX64
+ "LAST_ID file for the sequence %#llx"
": rc = %d\n",
lfsck_lfsck2name(lfsck), lls->lls_seq, rc);
}
lo->ll_pos_first_inconsistent = cookie;
CDEBUG(D_LFSCK, "%s: layout LFSCK hit first non-repaired "
- "inconsistency at the pos ["LPU64"]\n",
+ "inconsistency at the pos [%llu]\n",
lfsck_lfsck2name(lfsck),
lo->ll_pos_first_inconsistent);
}
up_write(&com->lc_sem);
CDEBUG(D_LFSCK, "%s: layout LFSCK master checkpoint at the pos ["
- LPU64"], status = %d: rc = %d\n", lfsck_lfsck2name(lfsck),
+ "%llu], status = %d: rc = %d\n", lfsck_lfsck2name(lfsck),
lfsck->li_pos_current.lp_oit_cookie, lo->ll_status, rc);
return rc;
up_write(&com->lc_sem);
CDEBUG(D_LFSCK, "%s: layout LFSCK slave checkpoint at the pos ["
- LPU64"], status = %d: rc = %d\n", lfsck_lfsck2name(lfsck),
+ "%llu], status = %d: rc = %d\n", lfsck_lfsck2name(lfsck),
lfsck->li_pos_current.lp_oit_cookie, lo->ll_status, rc);
return rc;
}
CDEBUG(D_LFSCK, "%s: layout LFSCK slave prep done, start pos ["
- LPU64"]\n", lfsck_lfsck2name(lfsck),
+ "%llu]\n", lfsck_lfsck2name(lfsck),
com->lc_pos_start.lp_oit_cookie);
return rc;
log:
CDEBUG(D_LFSCK, "%s: layout LFSCK master prep done, start pos ["
- LPU64"]\n", lfsck_lfsck2name(com->lc_lfsck),
+ "%llu]\n", lfsck_lfsck2name(com->lc_lfsck),
com->lc_pos_start.lp_oit_cookie);
return 0;
rc = lfsck_layout_lastid_load(env, com, lls);
if (rc != 0) {
CDEBUG(D_LFSCK, "%s: layout LFSCK failed to "
- "load LAST_ID for "LPX64": rc = %d\n",
+ "load LAST_ID for %#llx: rc = %d\n",
lfsck_lfsck2name(com->lc_lfsck), seq, rc);
lo->ll_objs_failed_phase1++;
OBD_FREE_PTR(lls);
rc = lfsck_layout_lastid_reload(env, com, lls);
if (unlikely(rc != 0)) {
CDEBUG(D_LFSCK, "%s: layout LFSCK failed to "
- "reload LAST_ID for "LPX64": rc = %d\n",
+ "reload LAST_ID for %#llx: rc = %d\n",
lfsck_lfsck2name(com->lc_lfsck),
lls->lls_seq, rc);
lo->ll_flags |= LF_CRASHED_LASTID;
CDEBUG(D_LFSCK, "%s: layout LFSCK finds crashed "
- "LAST_ID file (2) for the sequence "LPX64
- ", old value "LPU64", known value "LPU64"\n",
+ "LAST_ID file (2) for the sequence %#llx"
+ ", old value %llu, known value %llu\n",
lfsck_lfsck2name(lfsck), lls->lls_seq,
lls->lls_lastid, oid);
}
lfsck_time_dump(m, lo->ll_time_last_checkpoint, "last_checkpoint");
- seq_printf(m, "latest_start_position: "LPU64"\n"
- "last_checkpoint_position: "LPU64"\n"
- "first_failure_position: "LPU64"\n",
+ seq_printf(m, "latest_start_position: %llu\n"
+ "last_checkpoint_position: %llu\n"
+ "first_failure_position: %llu\n",
lo->ll_pos_latest_start,
lo->ll_pos_last_checkpoint,
lo->ll_pos_first_inconsistent);
seq_printf(m, "success_count: %u\n"
- "repaired_dangling: "LPU64"\n"
- "repaired_unmatched_pair: "LPU64"\n"
- "repaired_multiple_referenced: "LPU64"\n"
- "repaired_orphan: "LPU64"\n"
- "repaired_inconsistent_owner: "LPU64"\n"
- "repaired_others: "LPU64"\n"
- "skipped: "LPU64"\n"
- "failed_phase1: "LPU64"\n"
- "failed_phase2: "LPU64"\n",
+ "repaired_dangling: %llu\n"
+ "repaired_unmatched_pair: %llu\n"
+ "repaired_multiple_referenced: %llu\n"
+ "repaired_orphan: %llu\n"
+ "repaired_inconsistent_owner: %llu\n"
+ "repaired_others: %llu\n"
+ "skipped: %llu\n"
+ "failed_phase1: %llu\n"
+ "failed_phase2: %llu\n",
lo->ll_success_count,
lo->ll_objs_repaired[LLIT_DANGLING - 1],
lo->ll_objs_repaired[LLIT_UNMATCHED_PAIR - 1],
do_div(new_checked, duration);
if (rtime != 0)
do_div(speed, rtime);
- seq_printf(m, "checked_phase1: "LPU64"\n"
- "checked_phase2: "LPU64"\n"
+ seq_printf(m, "checked_phase1: %llu\n"
+ "checked_phase2: %llu\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n"
- "average_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_phase1: %llu items/sec\n"
"average_speed_phase2: N/A\n"
- "real-time_speed_phase1: "LPU64" items/sec\n"
+ "real-time_speed_phase1: %llu items/sec\n"
"real-time_speed_phase2: N/A\n",
checked,
lo->ll_objs_checked_phase2,
pos = iops->store(env, lfsck->li_di_oit);
if (!lfsck->li_current_oit_processed)
pos--;
- seq_printf(m, "current_position: "LPU64"\n", pos);
+ seq_printf(m, "current_position: %llu\n", pos);
} else if (lo->ll_status == LS_SCANNING_PHASE2) {
cfs_duration_t duration = cfs_time_current() -
do_div(speed1, lo->ll_run_time_phase1);
if (rtime != 0)
do_div(speed2, rtime);
- seq_printf(m, "checked_phase1: "LPU64"\n"
- "checked_phase2: "LPU64"\n"
+ seq_printf(m, "checked_phase1: %llu\n"
+ "checked_phase2: %llu\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n"
- "average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: "LPU64" items/sec\n"
+ "average_speed_phase1: %llu items/sec\n"
+ "average_speed_phase2: %llu items/sec\n"
"real-time_speed_phase1: N/A\n"
- "real-time_speed_phase2: "LPU64" items/sec\n"
+ "real-time_speed_phase2: %llu items/sec\n"
"current_position: "DFID"\n",
lo->ll_objs_checked_phase1,
checked,
do_div(speed1, lo->ll_run_time_phase1);
if (lo->ll_run_time_phase2 != 0)
do_div(speed2, lo->ll_run_time_phase2);
- seq_printf(m, "checked_phase1: "LPU64"\n"
- "checked_phase2: "LPU64"\n"
+ seq_printf(m, "checked_phase1: %llu\n"
+ "checked_phase2: %llu\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n"
- "average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: "LPU64" objs/sec\n"
+ "average_speed_phase1: %llu items/sec\n"
+ "average_speed_phase2: %llu objs/sec\n"
"real-time_speed_phase1: N/A\n"
"real-time_speed_phase2: N/A\n"
"current_position: N/A\n",
LASSERT(llst != NULL);
if (hash != llst->llst_hash) {
- CDEBUG(D_LFSCK, "%s: the given hash "LPU64" for orphan "
+ CDEBUG(D_LFSCK, "%s: the given hash %llu for orphan "
"iteration does not match the one when fini "
- LPU64", to be reset.\n",
+ "%llu, to be reset.\n",
lfsck_lfsck2name(it->loi_com->lc_lfsck), hash,
llst->llst_hash);
fid_zero(&llst->llst_fid);
seq_printf(m, "%s_time: N/A\n", name);
seq_printf(m, "time_since_%s: N/A\n", name);
} else {
- seq_printf(m, "%s_time: "LPU64"\n", name, time);
- seq_printf(m, "time_since_%s: "LPU64" seconds\n",
+ seq_printf(m, "%s_time: %llu\n", name, time);
+ seq_printf(m, "time_since_%s: %llu seconds\n",
name, cfs_time_current_sec() - time);
}
}
seq_printf(m, "%s: N/A, N/A, N/A\n", prefix);
return;
}
- seq_printf(m, "%s: "LPU64", N/A, N/A\n",
+ seq_printf(m, "%s: %llu, N/A, N/A\n",
prefix, pos->lp_oit_cookie);
} else {
- seq_printf(m, "%s: "LPU64", "DFID", "LPX64"\n",
+ seq_printf(m, "%s: %llu, "DFID", %#llx\n",
prefix, pos->lp_oit_cookie,
PFID(&pos->lp_dir_parent), pos->lp_dir_cookie);
}
ns->ln_pos_first_inconsistent = pos;
CDEBUG(D_LFSCK, "%s: namespace LFSCK hit first non-repaired "
- "inconsistency at the pos ["LPU64", "DFID", "LPX64"]\n",
+ "inconsistency at the pos [%llu, "DFID", %#llx]\n",
lfsck_lfsck2name(lfsck),
ns->ln_pos_first_inconsistent.lp_oit_cookie,
PFID(&ns->ln_pos_first_inconsistent.lp_dir_parent),
__u32 time_phase1,
__u32 time_phase2)
{
- seq_printf(m, "checked_phase1: "LPU64"\n"
- "checked_phase2: "LPU64"\n"
- "updated_phase1: "LPU64"\n"
- "updated_phase2: "LPU64"\n"
- "failed_phase1: "LPU64"\n"
- "failed_phase2: "LPU64"\n"
- "directories: "LPU64"\n"
- "dirent_repaired: "LPU64"\n"
- "linkea_repaired: "LPU64"\n"
- "nlinks_repaired: "LPU64"\n"
- "multiple_linked_checked: "LPU64"\n"
- "multiple_linked_repaired: "LPU64"\n"
- "unknown_inconsistency: "LPU64"\n"
- "unmatched_pairs_repaired: "LPU64"\n"
- "dangling_repaired: "LPU64"\n"
- "multiple_referenced_repaired: "LPU64"\n"
- "bad_file_type_repaired: "LPU64"\n"
- "lost_dirent_repaired: "LPU64"\n"
- "local_lost_found_scanned: "LPU64"\n"
- "local_lost_found_moved: "LPU64"\n"
- "local_lost_found_skipped: "LPU64"\n"
- "local_lost_found_failed: "LPU64"\n"
- "striped_dirs_scanned: "LPU64"\n"
- "striped_dirs_repaired: "LPU64"\n"
- "striped_dirs_failed: "LPU64"\n"
- "striped_dirs_disabled: "LPU64"\n"
- "striped_dirs_skipped: "LPU64"\n"
- "striped_shards_scanned: "LPU64"\n"
- "striped_shards_repaired: "LPU64"\n"
- "striped_shards_failed: "LPU64"\n"
- "striped_shards_skipped: "LPU64"\n"
- "name_hash_repaired: "LPU64"\n"
+ seq_printf(m, "checked_phase1: %llu\n"
+ "checked_phase2: %llu\n"
+ "updated_phase1: %llu\n"
+ "updated_phase2: %llu\n"
+ "failed_phase1: %llu\n"
+ "failed_phase2: %llu\n"
+ "directories: %llu\n"
+ "dirent_repaired: %llu\n"
+ "linkea_repaired: %llu\n"
+ "nlinks_repaired: %llu\n"
+ "multiple_linked_checked: %llu\n"
+ "multiple_linked_repaired: %llu\n"
+ "unknown_inconsistency: %llu\n"
+ "unmatched_pairs_repaired: %llu\n"
+ "dangling_repaired: %llu\n"
+ "multiple_referenced_repaired: %llu\n"
+ "bad_file_type_repaired: %llu\n"
+ "lost_dirent_repaired: %llu\n"
+ "local_lost_found_scanned: %llu\n"
+ "local_lost_found_moved: %llu\n"
+ "local_lost_found_skipped: %llu\n"
+ "local_lost_found_failed: %llu\n"
+ "striped_dirs_scanned: %llu\n"
+ "striped_dirs_repaired: %llu\n"
+ "striped_dirs_failed: %llu\n"
+ "striped_dirs_disabled: %llu\n"
+ "striped_dirs_skipped: %llu\n"
+ "striped_shards_scanned: %llu\n"
+ "striped_shards_repaired: %llu\n"
+ "striped_shards_failed: %llu\n"
+ "striped_shards_skipped: %llu\n"
+ "name_hash_repaired: %llu\n"
"success_count: %u\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n",
up_write(&com->lc_sem);
log:
- CDEBUG(D_LFSCK, "%s: namespace LFSCK checkpoint at the pos ["LPU64
- ", "DFID", "LPX64"], status = %d: rc = %d\n",
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK checkpoint at the pos [%llu"
+ ", "DFID", %#llx], status = %d: rc = %d\n",
lfsck_lfsck2name(lfsck), lfsck->li_pos_current.lp_oit_cookie,
PFID(&lfsck->li_pos_current.lp_dir_parent),
lfsck->li_pos_current.lp_dir_cookie, ns->ln_status, rc);
rc = lfsck_start_assistant(env, com, lsp);
- CDEBUG(D_LFSCK, "%s: namespace LFSCK prep done, start pos ["LPU64", "
- DFID", "LPX64"]: rc = %d\n",
+ CDEBUG(D_LFSCK, "%s: namespace LFSCK prep done, start pos [%llu, "
+ DFID", %#llx]: rc = %d\n",
lfsck_lfsck2name(lfsck), pos->lp_oit_cookie,
PFID(&pos->lp_dir_parent), pos->lp_dir_cookie, rc);
do_div(speed, rtime);
lfsck_namespace_dump_statistics(m, ns, checked, 0, rtime, 0);
- seq_printf(m, "average_speed_phase1: "LPU64" items/sec\n"
+ seq_printf(m, "average_speed_phase1: %llu items/sec\n"
"average_speed_phase2: N/A\n"
- "average_speed_total: "LPU64" items/sec\n"
- "real_time_speed_phase1: "LPU64" items/sec\n"
+ "average_speed_total: %llu items/sec\n"
+ "real_time_speed_phase1: %llu items/sec\n"
"real_time_speed_phase2: N/A\n",
speed,
speed,
lfsck_namespace_dump_statistics(m, ns, ns->ln_items_checked,
checked,
ns->ln_run_time_phase1, rtime);
- seq_printf(m, "average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: "LPU64" objs/sec\n"
- "average_speed_total: "LPU64" items/sec\n"
+ seq_printf(m, "average_speed_phase1: %llu items/sec\n"
+ "average_speed_phase2: %llu objs/sec\n"
+ "average_speed_total: %llu items/sec\n"
"real_time_speed_phase1: N/A\n"
- "real_time_speed_phase2: "LPU64" objs/sec\n"
+ "real_time_speed_phase2: %llu objs/sec\n"
"current_position: "DFID"\n",
speed1,
speed2,
ns->ln_objs_checked_phase2,
ns->ln_run_time_phase1,
ns->ln_run_time_phase2);
- seq_printf(m, "average_speed_phase1: "LPU64" items/sec\n"
- "average_speed_phase2: "LPU64" objs/sec\n"
- "average_speed_total: "LPU64" items/sec\n"
+ seq_printf(m, "average_speed_phase1: %llu items/sec\n"
+ "average_speed_phase2: %llu objs/sec\n"
+ "average_speed_total: %llu items/sec\n"
"real_time_speed_phase1: N/A\n"
"real_time_speed_phase2: N/A\n"
"current_position: N/A\n",
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- seq_printf(m, LPU64"\n", ofd->ofd_tot_dirty);
+ seq_printf(m, "%llu\n", ofd->ofd_tot_dirty);
return 0;
}
LPROC_SEQ_FOPS_RO(ofd_tot_dirty);
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- seq_printf(m, LPU64"\n", ofd->ofd_tot_granted);
+ seq_printf(m, "%llu\n", ofd->ofd_tot_granted);
return 0;
}
LPROC_SEQ_FOPS_RO(ofd_tot_granted);
LASSERT(obd != NULL);
ofd = ofd_dev(obd->obd_lu_dev);
- seq_printf(m, LPU64"\n", ofd->ofd_tot_pending);
+ seq_printf(m, "%llu\n", ofd->ofd_tot_pending);
return 0;
}
LPROC_SEQ_FOPS_RO(ofd_tot_pending);
struct obd_device *obd = m->private;
struct ofd_device *ofd = ofd_dev(obd->obd_lu_dev);
- seq_printf(m, "switch: %s\ndetected: "LPU64"\nrepaired: "LPU64"\n",
+ seq_printf(m, "switch: %s\ndetected: %llu\nrepaired: %llu\n",
ofd->ofd_lfsck_verify_pfid ? "on" : "off",
ofd->ofd_inconsistency_self_detected,
ofd->ofd_inconsistency_self_repaired);
oseq = ofd_seq_load(tsi->tsi_env, ofd, seq);
if (IS_ERR(oseq)) {
- CERROR("%s: Can't find FID Sequence "LPX64": rc = %ld\n",
+ CERROR("%s: Can't find FID Sequence %#llx: rc = %ld\n",
ofd_name(ofd), seq, PTR_ERR(oseq));
GOTO(out_sem, rc = -EINVAL);
}
(oa->o_flags & OBD_FL_RECREATE_OBJS)) {
if (!ofd_obd(ofd)->obd_recovering ||
oid > ofd_seq_last_oid(oseq)) {
- CERROR("%s: recreate objid "DOSTID" > last id "LPU64
+ CERROR("%s: recreate objid "DOSTID" > last id %llu"
"\n", ofd_name(ofd), POSTID(&oa->o_oi),
ofd_seq_last_oid(oseq));
GOTO(out_nolock, rc = -EINVAL);
oseq->os_destroys_in_progress = 1;
mutex_lock(&oseq->os_create_lock);
if (!oseq->os_destroys_in_progress) {
- CERROR("%s:["LPU64"] destroys_in_progress already"
+ CERROR("%s:[%llu] destroys_in_progress already"
" cleared\n", ofd_name(ofd), seq);
ostid_set_id(&rep_oa->o_oi, ofd_seq_last_oid(oseq));
GOTO(out, rc = 0);
}
diff = oid - ofd_seq_last_oid(oseq);
- CDEBUG(D_HA, "ofd_last_id() = "LPU64" -> diff = %d\n",
+ CDEBUG(D_HA, "ofd_last_id() = %llu -> diff = %d\n",
ofd_seq_last_oid(oseq), diff);
if (-diff > OST_MAX_PRECREATE) {
/* Let MDS know that we are so far ahead. */
if (diff < 0) {
/* LU-5648 */
CERROR("%s: invalid precreate request for "
- DOSTID", last_id " LPU64 ". "
+ DOSTID", last_id %llu. "
"Likely MDS last_id corruption\n",
ofd_name(ofd), POSTID(&oa->o_oi),
ofd_seq_last_oid(oseq));
next_id = ofd_seq_last_oid(oseq) + 1;
count = ofd_precreate_batch(ofd, diff);
- CDEBUG(D_HA, "%s: reserve %d objects in group "LPX64
- " at "LPU64"\n", ofd_name(ofd),
+ CDEBUG(D_HA, "%s: reserve %d objects in group %#llx"
+ " at %llu\n", ofd_name(ofd),
count, seq, next_id);
if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY)
RETURN(rc);
}
- CDEBUG(D_INODE, "calling punch for object "DFID", valid = "LPX64
- ", start = "LPD64", end = "LPD64"\n", PFID(&tsi->tsi_fid),
+ CDEBUG(D_INODE, "calling punch for object "DFID", valid = %#llx"
+ ", start = %lld, end = %lld\n", PFID(&tsi->tsi_fid),
oa->o_valid, start, end);
fo = ofd_object_find_exists(tsi->tsi_env, ofd_exp(tsi->tsi_exp),
data->lpa_export = tsi->tsi_exp;
data->lpa_resid = tsi->tsi_resid;
- CDEBUG(D_RPCTRACE, "Prolong locks for req %p with x"LPU64
- " ext("LPU64"->"LPU64")\n", tgt_ses_req(tsi),
+ CDEBUG(D_RPCTRACE, "Prolong locks for req %p with x%llu"
+ " ext(%llu->%llu)\n", tgt_ses_req(tsi),
tgt_ses_req(tsi)->rq_xid, data->lpa_extent.start,
data->lpa_extent.end);
pa.lpa_extent.end = rnb->rnb_offset + rnb->rnb_len - 1;
DEBUG_REQ(D_RPCTRACE, req, "%s %s: refresh rw locks: "DFID
- " ("LPU64"->"LPU64")\n", tgt_name(tsi->tsi_tgt),
+ " (%llu->%llu)\n", tgt_name(tsi->tsi_tgt),
current->comm, PFID(&tsi->tsi_fid), pa.lpa_extent.start,
pa.lpa_extent.end);
pa.lpa_extent.end = oa->o_blocks;
CDEBUG(D_DLMTRACE,
- "%s: refresh locks: "LPU64"/"LPU64" ("LPU64"->"LPU64")\n",
+ "%s: refresh locks: %llu/%llu (%llu->%llu)\n",
tgt_name(tsi->tsi_tgt), tsi->tsi_resid.name[0],
tsi->tsi_resid.name[1], pa.lpa_extent.start, pa.lpa_extent.end);
}
ofd_seq_last_oid_set(oseq, le64_to_cpu(lastid));
} else {
- CERROR("%s: corrupted size "LPU64" LAST_ID of seq "LPX64"\n",
+ CERROR("%s: corrupted size %llu LAST_ID of seq %#llx\n",
ofd_name(ofd), (__u64)info->fti_attr.la_size, seq);
GOTO(cleanup, rc = -EINVAL);
}
error = 1;
if (fed->fed_grant + fed->fed_pending > maxsize) {
CERROR("%s: cli %s/%p fed_grant(%ld) + fed_pending(%ld)"
- " > maxsize("LPU64")\n", obd->obd_name,
+ " > maxsize(%llu)\n", obd->obd_name,
exp->exp_client_uuid.uuid, exp, fed->fed_grant,
fed->fed_pending, maxsize);
spin_unlock(&obd->obd_dev_lock);
LBUG();
}
if (fed->fed_dirty > maxsize) {
- CERROR("%s: cli %s/%p fed_dirty(%ld) > maxsize("LPU64
+ CERROR("%s: cli %s/%p fed_dirty(%ld) > maxsize(%llu"
")\n", obd->obd_name, exp->exp_client_uuid.uuid,
exp, fed->fed_dirty, maxsize);
spin_unlock(&obd->obd_dev_lock);
error = 1;
if (fed->fed_grant + fed->fed_pending > maxsize) {
CERROR("%s: cli %s/%p fed_grant(%ld) + fed_pending(%ld)"
- " > maxsize("LPU64")\n", obd->obd_name,
+ " > maxsize(%llu)\n", obd->obd_name,
exp->exp_client_uuid.uuid, exp, fed->fed_grant,
fed->fed_pending, maxsize);
spin_unlock(&obd->obd_dev_lock);
LBUG();
}
if (fed->fed_dirty > maxsize) {
- CERROR("%s: cli %s/%p fed_dirty(%ld) > maxsize("LPU64
+ CERROR("%s: cli %s/%p fed_dirty(%ld) > maxsize(%llu"
")\n", obd->obd_name, exp->exp_client_uuid.uuid,
exp, fed->fed_dirty, maxsize);
spin_unlock(&obd->obd_dev_lock);
spin_unlock(&ofd->ofd_grant_lock);
if (tot_granted != fo_tot_granted)
- CERROR("%s: tot_granted "LPU64" != fo_tot_granted "LPU64"\n",
+ CERROR("%s: tot_granted %llu != fo_tot_granted %llu\n",
func, tot_granted, fo_tot_granted);
if (tot_pending != fo_tot_pending)
- CERROR("%s: tot_pending "LPU64" != fo_tot_pending "LPU64"\n",
+ CERROR("%s: tot_pending %llu != fo_tot_pending %llu\n",
func, tot_pending, fo_tot_pending);
if (tot_dirty != fo_tot_dirty)
- CERROR("%s: tot_dirty "LPU64" != fo_tot_dirty "LPU64"\n",
+ CERROR("%s: tot_dirty %llu != fo_tot_dirty %llu\n",
func, tot_dirty, fo_tot_dirty);
if (tot_pending > tot_granted)
- CERROR("%s: tot_pending "LPU64" > tot_granted "LPU64"\n",
+ CERROR("%s: tot_pending %llu > tot_granted %llu\n",
func, tot_pending, tot_granted);
if (tot_granted > maxsize)
- CERROR("%s: tot_granted "LPU64" > maxsize "LPU64"\n",
+ CERROR("%s: tot_granted %llu > maxsize %llu\n",
func, tot_granted, maxsize);
if (tot_dirty > maxsize)
- CERROR("%s: tot_dirty "LPU64" > maxsize "LPU64"\n",
+ CERROR("%s: tot_dirty %llu > maxsize %llu\n",
func, tot_dirty, maxsize);
}
return;
}
- CDEBUG(D_CACHE, "%s: cli %s/%p free: "LPU64" avail: "LPU64"\n",
+ CDEBUG(D_CACHE, "%s: cli %s/%p free: %llu avail: %llu\n",
obd->obd_name, exp->exp_client_uuid.uuid, exp,
osfs->os_bfree << ofd->ofd_blockbits,
osfs->os_bavail << ofd->ofd_blockbits);
tot_granted - ofd->ofd_tot_pending) ?
D_ERROR : D_CACHE;
- CDEBUG_LIMIT(mask, "%s: cli %s/%p left "LPU64" < tot_grant "
- LPU64" unstable "LPU64" pending "LPU64" "
- "dirty "LPU64"\n",
+ CDEBUG_LIMIT(mask, "%s: cli %s/%p left %llu < tot_grant "
+ "%llu unstable %llu pending %llu "
+ "dirty %llu\n",
obd->obd_name, exp->exp_client_uuid.uuid, exp,
left, tot_granted, unstable,
ofd->ofd_tot_pending, ofd->ofd_tot_dirty);
/* Align left on block size */
left &= ~((1ULL << ofd->ofd_blockbits) - 1);
- CDEBUG(D_CACHE, "%s: cli %s/%p avail "LPU64" left "LPU64" unstable "
- LPU64" tot_grant "LPU64" pending "LPU64"\n", obd->obd_name,
+ CDEBUG(D_CACHE, "%s: cli %s/%p avail %llu left %llu unstable "
+ "%llu tot_grant %llu pending %llu\n", obd->obd_name,
exp->exp_client_uuid.uuid, exp, avail, left, unstable,
tot_granted, ofd->ofd_tot_pending);
* out-or-order and have already consumed some grant. We want to
* leave this here in case there is a large error in accounting. */
CDEBUG(D_CACHE,
- "%s: cli %s/%p reports grant "LPU64" dropped %u, local %lu\n",
+ "%s: cli %s/%p reports grant %llu dropped %u, local %lu\n",
obd->obd_name, exp->exp_client_uuid.uuid, exp, oa->o_grant,
oa->o_dropped, fed->fed_grant);
dropped = 0;
}
if (ofd->ofd_tot_granted < dropped) {
- CERROR("%s: cli %s/%p reports %lu dropped > tot_grant "LPU64
- "\n", obd->obd_name, exp->exp_client_uuid.uuid, exp,
+ CERROR("%s: cli %s/%p reports %lu dropped > tot_grant %llu\n",
+ obd->obd_name, exp->exp_client_uuid.uuid, exp,
dropped, ofd->ofd_tot_granted);
dropped = 0;
}
fed->fed_grant -= grant_shrink;
ofd->ofd_tot_granted -= grant_shrink;
- CDEBUG(D_CACHE, "%s: cli %s/%p shrink %ld fed_grant %ld total "
- LPU64"\n", obd->obd_name, exp->exp_client_uuid.uuid,
- exp, grant_shrink, fed->fed_grant, ofd->ofd_tot_granted);
+ CDEBUG(D_CACHE, "%s: cli %s/%p shrink %ld fed_grant %ld total %llu\n",
+ obd->obd_name, exp->exp_client_uuid.uuid, exp, grant_shrink,
+ fed->fed_grant, ofd->ofd_tot_granted);
/* client has just released some grant, don't grant any space back */
oa->o_grant = 0;
RETURN(0);
if (want > 0x7fffffff) {
- CERROR("%s: client %s/%p requesting > 2GB grant "LPU64"\n",
+ CERROR("%s: client %s/%p requesting > 2GB grant %llu\n",
obd->obd_name, exp->exp_client_uuid.uuid, exp, want);
RETURN(0);
}
fed->fed_grant += grant;
if (fed->fed_grant < 0) {
- CERROR("%s: cli %s/%p grant %ld want "LPU64" current "LPU64"\n",
+ CERROR("%s: cli %s/%p grant %ld want %llu current %llu\n",
obd->obd_name, exp->exp_client_uuid.uuid, exp,
fed->fed_grant, want, curgrant);
spin_unlock(&ofd->ofd_grant_lock);
}
CDEBUG(D_CACHE,
- "%s: cli %s/%p wants: "LPU64" current grant "LPU64
- " granting: "LPU64"\n", obd->obd_name, exp->exp_client_uuid.uuid,
+ "%s: cli %s/%p wants: %llu current grant %llu"
+ " granting: %llu\n", obd->obd_name, exp->exp_client_uuid.uuid,
exp, want, curgrant, grant);
CDEBUG(D_CACHE,
- "%s: cli %s/%p tot cached:"LPU64" granted:"LPU64
+ "%s: cli %s/%p tot cached:%llu granted:%llu"
" num_exports: %d\n", obd->obd_name, exp->exp_client_uuid.uuid,
exp, ofd->ofd_tot_dirty, ofd->ofd_tot_granted,
obd->obd_num_exports);
spin_unlock(&ofd->ofd_grant_lock);
- CDEBUG(D_CACHE, "%s: cli %s/%p ocd_grant: %d want: "LPU64" left: "
- LPU64"\n", exp->exp_obd->obd_name, exp->exp_client_uuid.uuid,
+ CDEBUG(D_CACHE, "%s: cli %s/%p ocd_grant: %d want: %llu left: %llu\n",
+ exp->exp_obd->obd_name, exp->exp_client_uuid.uuid,
exp, data->ocd_grant, want, left);
EXIT;
spin_lock(&ofd->ofd_grant_lock);
LASSERTF(ofd->ofd_tot_granted >= fed->fed_grant,
- "%s: tot_granted "LPU64" cli %s/%p fed_grant %ld\n",
+ "%s: tot_granted %llu cli %s/%p fed_grant %ld\n",
obd->obd_name, ofd->ofd_tot_granted,
exp->exp_client_uuid.uuid, exp, fed->fed_grant);
ofd->ofd_tot_granted -= fed->fed_grant;
fed->fed_grant = 0;
LASSERTF(ofd->ofd_tot_pending >= fed->fed_pending,
- "%s: tot_pending "LPU64" cli %s/%p fed_pending %ld\n",
+ "%s: tot_pending %llu cli %s/%p fed_pending %ld\n",
obd->obd_name, ofd->ofd_tot_pending,
exp->exp_client_uuid.uuid, exp, fed->fed_pending);
/* ofd_tot_pending is handled in ofd_grant_commit as bulk
* commmits */
LASSERTF(ofd->ofd_tot_dirty >= fed->fed_dirty,
- "%s: tot_dirty "LPU64" cli %s/%p fed_dirty %ld\n",
+ "%s: tot_dirty %llu cli %s/%p fed_dirty %ld\n",
obd->obd_name, ofd->ofd_tot_dirty,
exp->exp_client_uuid.uuid, exp, fed->fed_dirty);
ofd->ofd_tot_dirty -= fed->fed_dirty;
if (ofd->ofd_osfs.os_bavail - (fed->fed_grant >> ofd->ofd_blockbits) <
(ofd->ofd_osfs.os_blocks >> 10)) {
spin_unlock(&ofd->ofd_grant_lock);
- CDEBUG(D_RPCTRACE, "%s: not enough space for create "LPU64"\n",
+ CDEBUG(D_RPCTRACE, "%s: not enough space for create %llu\n",
ofd_name(ofd),
ofd->ofd_osfs.os_bavail * ofd->ofd_osfs.os_blocks);
RETURN(-ENOSPC);
exp->exp_filter_data.fed_pending -= pending;
if (ofd->ofd_tot_granted < pending) {
- CERROR("%s: cli %s/%p tot_granted("LPU64") < grant_used(%lu)"
- "\n", exp->exp_obd->obd_name,
- exp->exp_client_uuid.uuid, exp, ofd->ofd_tot_granted,
- pending);
+ CERROR("%s: cli %s/%p tot_granted(%llu) < grant_used(%lu)\n",
+ exp->exp_obd->obd_name, exp->exp_client_uuid.uuid, exp,
+ ofd->ofd_tot_granted, pending);
spin_unlock(&ofd->ofd_grant_lock);
LBUG();
}
ofd->ofd_tot_granted -= pending;
if (ofd->ofd_tot_pending < pending) {
- CERROR("%s: cli %s/%p tot_pending("LPU64") < grant_used(%lu)"
- "\n", exp->exp_obd->obd_name, exp->exp_client_uuid.uuid,
- exp, ofd->ofd_tot_pending, pending);
+ CERROR("%s: cli %s/%p tot_pending(%llu) < grant_used(%lu)\n",
+ exp->exp_obd->obd_name, exp->exp_client_uuid.uuid, exp,
+ ofd->ofd_tot_pending, pending);
spin_unlock(&ofd->ofd_grant_lock);
LBUG();
}
oseq = ofd_seq_load(env, ofd, seq);
if (IS_ERR(oseq)) {
- CERROR("%s: Can't find FID Sequence "LPX64": rc = %d\n",
+ CERROR("%s: Can't find FID Sequence %#llx: rc = %d\n",
ofd_name(ofd), seq, (int)PTR_ERR(oseq));
GOTO(out, rc = -EINVAL);
}
lvb->lvb_atime = info->fti_attr.la_atime;
lvb->lvb_ctime = info->fti_attr.la_ctime;
- CDEBUG(D_DLMTRACE, "res: "DFID" initial lvb size: "LPU64", "
- "mtime: "LPX64", blocks: "LPX64"\n",
+ CDEBUG(D_DLMTRACE, "res: "DFID" initial lvb size: %llu, "
+ "mtime: %#llx, blocks: %#llx\n",
PFID(&info->fti_fid), lvb->lvb_size,
lvb->lvb_mtime, lvb->lvb_blocks);
lock_res(res);
if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_size, rpc_lvb->lvb_size);
lvb->lvb_size = rpc_lvb->lvb_size;
}
if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_mtime, rpc_lvb->lvb_mtime);
lvb->lvb_mtime = rpc_lvb->lvb_mtime;
}
if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_atime, rpc_lvb->lvb_atime);
lvb->lvb_atime = rpc_lvb->lvb_atime;
}
if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_ctime, rpc_lvb->lvb_ctime);
lvb->lvb_ctime = rpc_lvb->lvb_ctime;
}
if (rpc_lvb->lvb_blocks > lvb->lvb_blocks || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_blocks, rpc_lvb->lvb_blocks);
lvb->lvb_blocks = rpc_lvb->lvb_blocks;
}
lock_res(res);
if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size from disk: "
- LPU64" -> %llu\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_size, info->fti_attr.la_size);
lvb->lvb_size = info->fti_attr.la_size;
}
if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime from disk: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_mtime, info->fti_attr.la_mtime);
lvb->lvb_mtime = info->fti_attr.la_mtime;
}
if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime from disk: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_atime, info->fti_attr.la_atime);
lvb->lvb_atime = info->fti_attr.la_atime;
}
if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime from disk: "
- LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+ "%llu -> %llu\n", PFID(&info->fti_fid),
lvb->lvb_ctime, info->fti_attr.la_ctime);
lvb->lvb_ctime = info->fti_attr.la_ctime;
}
if (info->fti_attr.la_blocks > lvb->lvb_blocks || !increase_only) {
CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks from disk: "
- LPU64" -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
+ "%llu -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
(unsigned long long)info->fti_attr.la_blocks);
lvb->lvb_blocks = info->fti_attr.la_blocks;
}
if (!data)
RETURN(0);
- CDEBUG(D_RPCTRACE, "%s: cli %s/%p ocd_connect_flags: "LPX64
+ CDEBUG(D_RPCTRACE, "%s: cli %s/%p ocd_connect_flags: %#llx"
" ocd_version: %x ocd_grant: %d ocd_index: %u"
" ocd_group %u\n",
exp->exp_obd->obd_name, exp->exp_client_uuid.uuid, exp,
if (data->ocd_brw_size > ofd->ofd_brw_size)
data->ocd_brw_size = ofd->ofd_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 corruption?"
* might be under-reporting if clients haven't announced their
* caches with brw recently */
- CDEBUG(D_SUPER | D_CACHE, "blocks cached "LPU64" granted "LPU64
- " pending "LPU64" free "LPU64" avail "LPU64"\n",
+ CDEBUG(D_SUPER | D_CACHE, "blocks cached %llu granted %llu"
+ " pending %llu free %llu avail %llu\n",
ofd->ofd_tot_dirty, ofd->ofd_tot_granted, ofd->ofd_tot_pending,
osfs->os_bfree << ofd->ofd_blockbits,
osfs->os_bavail << ofd->ofd_blockbits);
}
ofd_grant_sanity_check(obd, __FUNCTION__);
- CDEBUG(D_CACHE, LPU64" blocks: "LPU64" free, "LPU64" avail; "
- LPU64" objects: "LPU64" free; state %x\n",
+ CDEBUG(D_CACHE, "%llu blocks: %llu free, %llu avail; "
+ "%llu objects: %llu free; state %x\n",
osfs->os_blocks, osfs->os_bfree, osfs->os_bavail,
osfs->os_files, osfs->os_ffree, osfs->os_state);
oseq = ofd_seq_load(env, ofd, seq);
if (IS_ERR(oseq)) {
- CERROR("%s: Can't find FID Sequence "LPX64": rc = %ld\n",
+ CERROR("%s: Can't find FID Sequence %#llx: rc = %ld\n",
ofd_name(ofd), seq, PTR_ERR(oseq));
GOTO(out_sem, rc = -EINVAL);
}
/* VBR: version is checked always because costs nothing */
if (info->fti_pre_version != 0 &&
info->fti_pre_version != curr_version) {
- CDEBUG(D_INODE, "Version mismatch "LPX64" != "LPX64"\n",
+ CDEBUG(D_INODE, "Version mismatch %#llx != %#llx\n",
info->fti_pre_version, curr_version);
spin_lock(&info->fti_exp->exp_lock);
info->fti_exp->exp_vbr_failed = 1;
if (unlikely(ofd_object_exists(fo))) {
/* object may exist being re-created by write replay */
- CDEBUG(D_INODE, "object "LPX64"/"LPX64" exists: "
+ CDEBUG(D_INODE, "object %#llx/%#llx exists: "
DFID"\n", ostid_seq(&oseq->os_oi), id,
PFID(lu_object_fid(&fo->ofo_obj.do_lu)));
continue;
&info->fti_buf, &info->fti_off, th);
dt_write_unlock(env, oseq->os_lastid_obj);
if (rc1 != 0)
- CERROR("%s: fail to reset the LAST_ID for seq ("LPX64
- ") from "LPU64" to "LPU64"\n", ofd_name(ofd),
+ CERROR("%s: fail to reset the LAST_ID for seq (%#llx"
+ ") from %llu to %llu\n", ofd_name(ofd),
ostid_seq(&oseq->os_oi), id + nr - 1,
ofd_seq_last_oid(oseq));
}
}
/**
- * Use LPU64 for legacy OST sequences, but use LPX64i for new
+ * Use %llu for legacy OST sequences, but use %llx for new
* sequences names, so that the O/{seq}/dN/{oid} more closely
* follows the DFID/PFID format. This makes it easier to map from
* debug messages to objects in the future, and the legacy space
{
snprintf(seq_name, name_size,
(fid_seq_is_rsvd(seq) ||
- fid_seq_is_mdt0(seq)) ? LPU64 : LPX64i,
+ fid_seq_is_mdt0(seq)) ? "%llu" : "%llx",
fid_seq_is_idif(seq) ? 0 : seq);
}
snprintf(name, name_size,
(fid_seq_is_rsvd(fid_seq(fid)) ||
fid_seq_is_mdt0(fid_seq(fid)) ||
- fid_seq_is_idif(fid_seq(fid))) ? LPU64 : LPX64i, id);
+ fid_seq_is_idif(fid_seq(fid))) ? "%llu" : "%llx", id);
}
/* external locking is required */
rc = osd_fld_lookup(env, osd, seq, range);
if (rc != 0) {
if (rc != -ENOENT)
- CERROR("%s: can't lookup FLD sequence "LPX64
- ": rc = %d\n", osd_name(osd), seq, rc);
+ CERROR("%s: can't lookup FLD sequence %#llx: rc = %d\n",
+ osd_name(osd), seq, rc);
RETURN(0);
}
{
struct inode *inode = osd_dt_obj(dt)->oo_inode;
- CDEBUG(D_INODE, "Get version "LPX64" for inode %lu\n",
+ CDEBUG(D_INODE, "Get version %#llx for inode %lu\n",
LDISKFS_I(inode)->i_fs_version, inode->i_ino);
*ver = LDISKFS_I(inode)->i_fs_version;
return 0;
{
struct inode *inode = osd_dt_obj(dt)->oo_inode;
- CDEBUG(D_INODE, "Set version "LPX64" (old "LPX64") for inode %lu\n",
+ CDEBUG(D_INODE, "Set version %#llx (old %#llx) for inode %lu\n",
*new_version, LDISKFS_I(inode)->i_fs_version, inode->i_ino);
LDISKFS_I(inode)->i_fs_version = *new_version;
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- seq_printf(m, LPU64"\n", dev->od_full_scrub_ratio);
+ seq_printf(m, "%llu\n", dev->od_full_scrub_ratio);
return 0;
}
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
- seq_printf(m, LPU64" (bad OI mappings/minute)\n",
+ seq_printf(m, "%llu (bad OI mappings/minute)\n",
dev->od_full_scrub_threshold_rate);
return 0;
}
if (unlikely(osd->od_mnt == NULL))
return -EINPROGRESS;
- seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize);
+ seq_printf(m, "%llu\n", osd->od_readcache_max_filesize);
return 0;
}
struct scrub_file *sf = &scrub->os_file;
CDEBUG(D_LFSCK, "%.16s: reset OI scrub file, old flags = "
- LPX64", add flags = "LPX64"\n",
+ "%#llx, add flags = %#llx\n",
osd_scrub2name(scrub), sf->sf_flags, flags);
memcpy(sf->sf_uuid, uuid, 16);
static void scrub_time_dump(struct seq_file *m, __u64 time, const char *prefix)
{
if (time != 0)
- seq_printf(m, "%s: "LPU64" seconds\n", prefix,
+ seq_printf(m, "%s: %llu seconds\n", prefix,
cfs_time_current_sec() - time);
else
seq_printf(m, "%s: N/A\n", prefix);
static void scrub_pos_dump(struct seq_file *m, __u64 pos, const char *prefix)
{
if (pos != 0)
- seq_printf(m, "%s: "LPU64"\n", prefix, pos);
+ seq_printf(m, "%s: %llu\n", prefix, pos);
else
seq_printf(m, "%s: N/A\n", prefix);
}
"first_failure_position");
checked = sf->sf_items_checked + scrub->os_new_checked;
- seq_printf(m, "checked: "LPU64"\n"
- "updated: "LPU64"\n"
- "failed: "LPU64"\n"
- "prior_updated: "LPU64"\n"
- "noscrub: "LPU64"\n"
- "igif: "LPU64"\n"
+ seq_printf(m, "checked: %llu\n"
+ "updated: %llu\n"
+ "failed: %llu\n"
+ "prior_updated: %llu\n"
+ "noscrub: %llu\n"
+ "igif: %llu\n"
"success_count: %u\n",
checked, sf->sf_items_updated, sf->sf_items_failed,
sf->sf_items_updated_prior, sf->sf_items_noscrub,
if (rtime != 0)
do_div(speed, rtime);
seq_printf(m, "run_time: %u seconds\n"
- "average_speed: "LPU64" objects/sec\n"
- "real-time_speed: "LPU64" objects/sec\n"
+ "average_speed: %llu objects/sec\n"
+ "real-time_speed: %llu objects/sec\n"
"current_position: %u\n"
- "lf_scanned: "LPU64"\n"
- "lf_repaired: "LPU64"\n"
- "lf_failed: "LPU64"\n",
+ "lf_scanned: %llu\n"
+ "lf_repaired: %llu\n"
+ "lf_failed: %llu\n",
rtime, speed, new_checked, scrub->os_pos_current,
scrub->os_lf_scanned, scrub->os_lf_repaired,
scrub->os_lf_failed);
if (sf->sf_run_time != 0)
do_div(speed, sf->sf_run_time);
seq_printf(m, "run_time: %u seconds\n"
- "average_speed: "LPU64" objects/sec\n"
+ "average_speed: %llu objects/sec\n"
"real-time_speed: N/A\n"
"current_position: N/A\n"
- "lf_scanned: "LPU64"\n"
- "lf_repaired: "LPU64"\n"
- "lf_failed: "LPU64"\n",
+ "lf_scanned: %llu\n"
+ "lf_repaired: %llu\n"
+ "lf_failed: %llu\n",
sf->sf_run_time, speed, scrub->os_lf_scanned,
scrub->os_lf_repaired, scrub->os_lf_failed);
}
rc = -dmu_free_long_range(osd->od_os, oid, 0, DMU_OBJECT_END);
if (rc != 0) {
- CWARN("%s: Cannot truncate "LPU64": rc = %d\n",
+ CWARN("%s: Cannot truncate %llu: rc = %d\n",
osd->od_svname, oid, rc);
return rc;
}
dmu_tx_hold_zap(tx, osd->od_unlinkedid, FALSE, NULL);
rc = -dmu_tx_assign(tx, TXG_WAIT);
if (rc != 0) {
- CWARN("%s: Cannot assign tx for "LPU64": rc = %d\n",
+ CWARN("%s: Cannot assign tx for %llu: rc = %d\n",
osd->od_svname, oid, rc);
goto failed;
}
rc = -zap_remove_int(osd->od_os, osd->od_unlinkedid, oid, tx);
if (rc != 0) {
- CWARN("%s: Cannot remove "LPU64" from unlinked set: rc = %d\n",
+ CWARN("%s: Cannot remove %llu from unlinked set: rc = %d\n",
osd->od_svname, oid, rc);
goto failed;
}
rc = -dmu_object_free(osd->od_os, oid, tx);
if (rc != 0) {
- CWARN("%s: Cannot free "LPU64": rc = %d\n",
+ CWARN("%s: Cannot free %llu: rc = %d\n",
osd->od_svname, oid, rc);
goto failed;
}
if (unlikely((lma->lma_incompat & ~LMA_INCOMPAT_SUPP) ||
CFS_FAIL_CHECK(OBD_FAIL_OSD_LMA_INCOMPAT))) {
CWARN("%s: unsupported incompat LMA feature(s) %#x for "
- "oid = "LPX64"\n", osd->od_svname,
+ "oid = %#llx\n", osd->od_svname,
lma->lma_incompat & ~LMA_INCOMPAT_SUPP, oid);
GOTO(out, rc = -EOPNOTSUPP);
} else {
rc = osd_fld_lookup(env, osd, seq, range);
if (rc != 0) {
if (rc != -ENOENT)
- CERROR("%s: Can not lookup fld for "LPX64"\n",
+ CERROR("%s: Can not lookup fld for %#llx\n",
osd_name(osd), seq);
RETURN(0);
}
* XXX: we need a binary version of zap_cursor_move_to_key()
* to implement this API */
if (*((const __u64 *)key) != 0)
- CERROR("NOT IMPLEMETED YET (move to "LPX64")\n",
+ CERROR("NOT IMPLEMETED YET (move to %#llx)\n",
*((__u64 *)key));
zap_cursor_fini(it->ozi_zc);
* copies */
space *= osd->od_os->os_copies;
space = toqb(space);
- CDEBUG(D_QUOTA, "writing %d pages, reserving "LPD64"K of quota space\n",
+ CDEBUG(D_QUOTA, "writing %d pages, reserving %lldK of quota space\n",
npages, space);
record_start_io(osd, WRITE, discont_pages);
GOTO(out, rc);
}
if (rc != 0) {
- CERROR("%s: lookup "DFID"/"LPX64" failed: rc = %d\n",
+ CERROR("%s: lookup "DFID"/%#llx failed: rc = %d\n",
osd->od_svname, PFID(lu_object_fid(l)), oid, rc);
GOTO(out, rc);
}
LASSERT(obj->oo_attr.la_size <= osd_sync_destroy_max_size);
rc = -dmu_object_free(osd->od_os, oid, oh->ot_tx);
if (rc)
- CERROR("%s: failed to free %s "LPU64": rc = %d\n",
+ CERROR("%s: failed to free %s %llu: rc = %d\n",
osd->od_svname, buf, oid, rc);
} else if (obj->oo_destroy == OSD_DESTROY_SYNC) {
rc = -dmu_object_free(osd->od_os, oid, oh->ot_tx);
if (rc)
- CERROR("%s: failed to free %s "LPU64": rc = %d\n",
+ CERROR("%s: failed to free %s %llu: rc = %d\n",
osd->od_svname, buf, oid, rc);
} else { /* asynchronous destroy */
rc = osd_object_unlinked_add(obj, oh);
rc = -zap_add_int(osd->od_os, osd->od_unlinkedid,
oid, oh->ot_tx);
if (rc)
- CERROR("%s: zap_add_int() failed %s "LPU64": rc = %d\n",
+ CERROR("%s: zap_add_int() failed %s %llu: rc = %d\n",
osd->od_svname, buf, oid, rc);
}
/* Create a new DMU object using the default dnode size. */
oid = osd_dmu_object_alloc(osd->od_os, type, 0, 0, tx);
rc = -sa_buf_hold(osd->od_os, oid, osd_obj_tag, dbp);
- LASSERTF(rc == 0, "sa_buf_hold "LPU64" failed: %d\n", oid, rc);
+ LASSERTF(rc == 0, "sa_buf_hold %llu failed: %d\n", oid, rc);
LASSERT(la->la_valid & LA_MODE);
la->la_size = 0;
oi.oi_zapid = osd->od_O_id;
sprintf(seq_name, (fid_seq_is_rsvd(seq) ||
- fid_seq_is_mdt0(seq)) ? LPU64 : LPX64i,
+ fid_seq_is_mdt0(seq)) ? "%llu" : "%llx",
fid_seq_is_idif(seq) ? 0 : seq);
rc = osd_oi_find_or_create(env, osd, oi.oi_zapid, seq_name, &odb);
LASSERT(osd_seq->os_compat_dirs[b]);
if (buf)
- snprintf(buf, bufsize, LPU64, id);
+ snprintf(buf, bufsize, "%llu", id);
return osd_seq->os_compat_dirs[b];
}
rc = -dmu_object_free(osd->od_os, obj->oo_xattr, tx);
if (rc)
- CERROR("%s: free xattr "LPU64" failed: rc = %d\n",
+ CERROR("%s: free xattr %llu failed: rc = %d\n",
osd->od_svname, obj->oo_xattr, rc);
return rc;