void
_kgnilnd_debug_conn(kgn_conn_t *conn, struct libcfs_debug_msg_data *msgdata,
const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
libcfs_debug_vmsg2(msgdata, fmt, args,
" conn@0x%p->%s:%s cq %u, to %ds, "
" RX %d @ %lu/%lus; TX %d @ %lus/%lus; "
" NOOP %lus/%lu/%lus; sched %lus/%lus/%lus ago \n",
conn, conn->gnc_peer ? libcfs_nid2str(conn->gnc_peer->gnp_nid) :
"<?>", kgnilnd_conn_state2str(conn),
conn->gnc_cqid, conn->gnc_timeout,
conn->gnc_rx_seq,
cfs_duration_sec(jiffies - conn->gnc_last_rx),
cfs_duration_sec(jiffies - conn->gnc_last_rx_cq),
conn->gnc_tx_seq,
cfs_duration_sec(jiffies - conn->gnc_last_tx),
cfs_duration_sec(jiffies - conn->gnc_last_tx_cq),
cfs_duration_sec(jiffies - conn->gnc_last_noop_want),
cfs_duration_sec(jiffies - conn->gnc_last_noop_sent),
cfs_duration_sec(jiffies - conn->gnc_last_noop_cq),
cfs_duration_sec(jiffies - conn->gnc_last_sched_ask),
cfs_duration_sec(jiffies - conn->gnc_last_sched_do),
cfs_duration_sec(jiffies - conn->gnc_device->gnd_sched_alive));
va_end(args);
}
static int proc_console_min_delay_cs(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp,
loff_t *ppos)
{
int rc, min_delay_cs;
struct ctl_table dummy = *table;
long d;
dummy.data = &min_delay_cs;
dummy.proc_handler = &proc_dointvec;
if (!write) { /* read */
min_delay_cs = cfs_duration_sec(libcfs_console_min_delay * 100);
rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
return rc;
}
/* write */
min_delay_cs = 0;
rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
if (rc < 0)
return rc;
if (min_delay_cs <= 0)
return -EINVAL;
d = cfs_time_seconds(min_delay_cs) / 100;
if (d == 0 || d > libcfs_console_max_delay)
return -EINVAL;
libcfs_console_min_delay = d;
return rc;
}
int LL_PROC_PROTO(proc_console_min_delay_cs)
{
int rc, min_delay_cs;
cfs_sysctl_table_t dummy = *table;
cfs_duration_t d;
dummy.data = &min_delay_cs;
dummy.proc_handler = &proc_dointvec;
if (!write) { /* read */
min_delay_cs = cfs_duration_sec(libcfs_console_min_delay * 100);
rc = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
return rc;
}
/* write */
min_delay_cs = 0;
rc = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
if (rc < 0)
return rc;
if (min_delay_cs <= 0)
return -EINVAL;
d = cfs_time_seconds(min_delay_cs) / 100;
if (d == 0 || d > libcfs_console_max_delay)
return -EINVAL;
libcfs_console_min_delay = d;
return rc;
}
void
_kgnilnd_debug_tx(kgn_tx_t *tx, struct libcfs_debug_msg_data *msgdata,
const char *fmt, ...)
{
kgn_tx_ev_id_t *id = &tx->tx_id;
char *nid = "<?>";
va_list args;
if (tx->tx_conn && tx->tx_conn->gnc_peer) {
nid = libcfs_nid2str(tx->tx_conn->gnc_peer->gnp_nid);
}
va_start(args, fmt);
libcfs_debug_vmsg2(msgdata, fmt, args,
" tx@0x%p->%s id "LPX64
"/%u/%d:%d msg %x/%s/%d x%d q %s@%lds->0x%p f %x re %d\n",
tx, nid, id->txe_cookie, id->txe_smsg_id, id->txe_cqid,
id->txe_idx, tx->tx_msg.gnm_type,
kgnilnd_msgtype2str(tx->tx_msg.gnm_type), tx->tx_buftype,
tx->tx_msg.gnm_seq,
kgnilnd_tx_state2str(tx->tx_list_state),
cfs_duration_sec((long)jiffies - tx->tx_qtime), tx->tx_list_p,
tx->tx_state, tx->tx_retrans);
va_end(args);
}
static int lfsck_namespace_checkpoint(const struct lu_env *env,
struct lfsck_component *com, bool init)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_namespace *ns = com->lc_file_ram;
int rc;
if (com->lc_new_checked == 0 && !init)
return 0;
down_write(&com->lc_sem);
if (init) {
ns->ln_pos_latest_start = lfsck->li_pos_current;
} else {
ns->ln_pos_last_checkpoint = lfsck->li_pos_current;
ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
HALF_SEC - lfsck->li_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
ns->ln_items_checked += com->lc_new_checked;
com->lc_new_checked = 0;
}
rc = lfsck_namespace_store(env, com, false);
up_write(&com->lc_sem);
return rc;
}
static int lfsck_namespace_post(const struct lu_env *env,
struct lfsck_component *com,
int result, bool init)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_namespace *ns = com->lc_file_ram;
int rc;
down_write(&com->lc_sem);
spin_lock(&lfsck->li_lock);
if (!init)
ns->ln_pos_last_checkpoint = lfsck->li_pos_current;
if (result > 0) {
ns->ln_status = LS_SCANNING_PHASE2;
ns->ln_flags |= LF_SCANNED_ONCE;
ns->ln_flags &= ~LF_UPGRADE;
cfs_list_del_init(&com->lc_link);
cfs_list_del_init(&com->lc_link_dir);
cfs_list_add_tail(&com->lc_link, &lfsck->li_list_double_scan);
} else if (result == 0) {
ns->ln_status = lfsck->li_status;
if (ns->ln_status == 0)
ns->ln_status = LS_STOPPED;
if (ns->ln_status != LS_PAUSED) {
cfs_list_del_init(&com->lc_link);
cfs_list_del_init(&com->lc_link_dir);
cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
}
} else {
ns->ln_status = LS_FAILED;
cfs_list_del_init(&com->lc_link);
cfs_list_del_init(&com->lc_link_dir);
cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
}
spin_unlock(&lfsck->li_lock);
if (!init) {
ns->ln_run_time_phase1 += cfs_duration_sec(cfs_time_current() +
HALF_SEC - lfsck->li_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
ns->ln_items_checked += com->lc_new_checked;
com->lc_new_checked = 0;
}
rc = lfsck_namespace_store(env, com, false);
up_write(&com->lc_sem);
return rc;
}
int
libcfs_sock_write (cfs_socket_t *sock, void *buffer, int nob, int timeout)
{
int rc;
struct pollfd pfd;
cfs_time_t start_time = cfs_time_current();
pfd.fd = sock->s_fd;
pfd.events = POLLOUT;
pfd.revents = 0;
/* poll(2) measures timeout in msec */
timeout *= 1000;
while (nob != 0 && timeout > 0) {
cfs_time_t current_time;
rc = poll(&pfd, 1, timeout);
if (rc < 0)
return -errno;
if (rc == 0)
return -ETIMEDOUT;
if ((pfd.revents & POLLOUT) == 0)
return -EIO;
rc = write(sock->s_fd, buffer, nob);
if (rc < 0)
return -errno;
if (rc == 0)
return -EIO;
buffer = ((char *)buffer) + rc;
nob -= rc;
current_time = cfs_time_current();
timeout -= 1000 *
cfs_duration_sec(cfs_time_sub(current_time,
start_time));
start_time = current_time;
}
if (nob == 0)
return 0;
else
return -ETIMEDOUT;
}
static void lcw_dump_stack(struct lc_watchdog *lcw)
{
cfs_time_t current_time;
cfs_duration_t delta_time;
struct timeval timediff;
current_time = cfs_time_current();
delta_time = cfs_time_sub(current_time, lcw->lcw_last_touched);
cfs_duration_usec(delta_time, &timediff);
/*
* Check to see if we should throttle the watchdog timer to avoid
* too many dumps going to the console thus triggering an NMI.
*/
delta_time = cfs_duration_sec(cfs_time_sub(current_time,
lcw_last_watchdog_time));
if (delta_time < libcfs_watchdog_ratelimit &&
lcw_recent_watchdog_count > 3) {
LCONSOLE_WARN("Service thread pid %u was inactive for "
"%lu.%.02lus. Watchdog stack traces are limited "
"to 3 per %d seconds, skipping this one.\n",
(int)lcw->lcw_pid,
timediff.tv_sec,
timediff.tv_usec / 10000,
libcfs_watchdog_ratelimit);
} else {
if (delta_time < libcfs_watchdog_ratelimit) {
lcw_recent_watchdog_count++;
} else {
memcpy(&lcw_last_watchdog_time, ¤t_time,
sizeof(current_time));
lcw_recent_watchdog_count = 0;
}
LCONSOLE_WARN("Service thread pid %u was inactive for "
"%lu.%.02lus. The thread might be hung, or it "
"might only be slow and will resume later. "
"Dumping the stack trace for debugging purposes:"
"\n",
(int)lcw->lcw_pid,
timediff.tv_sec,
timediff.tv_usec / 10000);
lcw_dump(lcw);
}
}
ssize_t
libcfs_sock_read(struct lnet_xport *lx, void *buffer, size_t nob,
int timeout)
{
ssize_t rc;
struct pollfd pfd;
cfs_time_t start_time = cfs_time_current();
pfd.fd = lx->lx_fd;
pfd.events = POLLIN;
pfd.revents = 0;
/* poll(2) measures timeout in msec */
timeout *= 1000;
while (nob != 0 && timeout > 0) {
rc = poll(&pfd, 1, timeout);
if (rc < 0)
return -errno;
if (rc == 0)
return -ETIMEDOUT;
if ((pfd.revents & POLLIN) == 0)
return -EIO;
rc = read(lx->lx_fd, buffer, nob);
if (rc < 0)
return -errno;
if (rc == 0)
return -EIO;
buffer = ((char *)buffer) + rc;
nob -= rc;
timeout -= cfs_duration_sec(cfs_time_sub(cfs_time_current(),
start_time));
}
if (nob == 0)
return 0;
else
return -ETIMEDOUT;
}
ssize_t
libcfs_ssl_sock_read(struct lnet_xport *lx, void *buf, size_t n,
int timeout)
{
cfs_time_t start_time = cfs_time_current();
struct pollfd pfd;
ssize_t rc;
pfd.fd = lx->lx_fd;
pfd.events = POLLIN;
pfd.revents = 0;
/* poll(2) measures timeout in msec */
timeout *= 1000;
while (n != 0 && timeout > 0) {
rc = poll(&pfd, 1, timeout);
if (rc < 0)
return (-errno);
if (rc == 0)
return (-ETIMEDOUT);
if ((pfd.revents & POLLIN) == 0)
return (-EIO);
rc = SSL_read(lx->lx_ssl, buf, n);
if (rc < 0)
return (-errno);
if (rc == 0)
return (-EIO);
buf = (char *)buf + rc;
n -= rc;
timeout -= cfs_duration_sec(cfs_time_sub(
cfs_time_current(), start_time));
}
if (n == 0)
return (0);
return (-ETIMEDOUT);
}
inline cfs_time_t round_timeout(cfs_time_t timeout)
{
return cfs_time_seconds((int)cfs_duration_sec(cfs_time_sub(timeout, 0)) + 1);
}
static int param_get_delay(char *buffer, const struct kernel_param *kp)
{
unsigned int d = *(unsigned int *)kp->arg;
return sprintf(buffer, "%u", (unsigned int)cfs_duration_sec(d * 100));
}
static int lfsck_namespace_double_scan_main(void *args)
{
struct lfsck_thread_args *lta = args;
const struct lu_env *env = <a->lta_env;
struct lfsck_component *com = lta->lta_com;
struct lfsck_instance *lfsck = com->lc_lfsck;
struct ptlrpc_thread *thread = &lfsck->li_thread;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct lfsck_namespace *ns = com->lc_file_ram;
struct dt_object *obj = com->lc_obj;
const struct dt_it_ops *iops = &obj->do_index_ops->dio_it;
struct dt_object *target;
struct dt_it *di;
struct dt_key *key;
struct lu_fid fid;
int rc;
__u8 flags = 0;
ENTRY;
com->lc_new_checked = 0;
com->lc_new_scanned = 0;
com->lc_time_last_checkpoint = cfs_time_current();
com->lc_time_next_checkpoint = com->lc_time_last_checkpoint +
cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
di = iops->init(env, obj, 0, BYPASS_CAPA);
if (IS_ERR(di))
GOTO(out, rc = PTR_ERR(di));
fid_cpu_to_be(&fid, &ns->ln_fid_latest_scanned_phase2);
rc = iops->get(env, di, (const struct dt_key *)&fid);
if (rc < 0)
GOTO(fini, rc);
/* Skip the start one, which either has been processed or non-exist. */
rc = iops->next(env, di);
if (rc != 0)
GOTO(put, rc);
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NO_DOUBLESCAN))
GOTO(put, rc = 0);
do {
if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DELAY3) &&
cfs_fail_val > 0) {
struct l_wait_info lwi;
lwi = LWI_TIMEOUT(cfs_time_seconds(cfs_fail_val),
NULL, NULL);
l_wait_event(thread->t_ctl_waitq,
!thread_is_running(thread),
&lwi);
}
key = iops->key(env, di);
fid_be_to_cpu(&fid, (const struct lu_fid *)key);
target = lfsck_object_find(env, lfsck, &fid);
down_write(&com->lc_sem);
if (target == NULL) {
rc = 0;
goto checkpoint;
} else if (IS_ERR(target)) {
rc = PTR_ERR(target);
goto checkpoint;
}
/* XXX: Currently, skip remote object, the consistency for
* remote object will be processed in LFSCK phase III. */
if (dt_object_exists(target) && !dt_object_remote(target)) {
rc = iops->rec(env, di, (struct dt_rec *)&flags, 0);
if (rc == 0)
rc = lfsck_namespace_double_scan_one(env, com,
target, flags);
}
lfsck_object_put(env, target);
checkpoint:
com->lc_new_checked++;
com->lc_new_scanned++;
ns->ln_fid_latest_scanned_phase2 = fid;
if (rc > 0)
ns->ln_objs_repaired_phase2++;
else if (rc < 0)
ns->ln_objs_failed_phase2++;
up_write(&com->lc_sem);
if ((rc == 0) || ((rc > 0) && !(bk->lb_param & LPF_DRYRUN))) {
lfsck_namespace_delete(env, com, &fid);
} else if (rc < 0) {
flags |= LLF_REPAIR_FAILED;
lfsck_namespace_update(env, com, &fid, flags, true);
}
if (rc < 0 && bk->lb_param & LPF_FAILOUT)
GOTO(put, rc);
if (unlikely(cfs_time_beforeq(com->lc_time_next_checkpoint,
cfs_time_current())) &&
com->lc_new_checked != 0) {
down_write(&com->lc_sem);
ns->ln_run_time_phase2 +=
cfs_duration_sec(cfs_time_current() +
HALF_SEC - com->lc_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
ns->ln_objs_checked_phase2 += com->lc_new_checked;
com->lc_new_checked = 0;
rc = lfsck_namespace_store(env, com, false);
up_write(&com->lc_sem);
if (rc != 0)
GOTO(put, rc);
com->lc_time_last_checkpoint = cfs_time_current();
com->lc_time_next_checkpoint =
com->lc_time_last_checkpoint +
cfs_time_seconds(LFSCK_CHECKPOINT_INTERVAL);
}
lfsck_control_speed_by_self(com);
if (unlikely(!thread_is_running(thread)))
GOTO(put, rc = 0);
rc = iops->next(env, di);
} while (rc == 0);
GOTO(put, rc);
put:
iops->put(env, di);
fini:
iops->fini(env, di);
out:
down_write(&com->lc_sem);
ns->ln_run_time_phase2 += cfs_duration_sec(cfs_time_current() +
HALF_SEC - lfsck->li_time_last_checkpoint);
ns->ln_time_last_checkpoint = cfs_time_current_sec();
ns->ln_objs_checked_phase2 += com->lc_new_checked;
com->lc_new_checked = 0;
if (rc > 0) {
com->lc_journal = 0;
ns->ln_status = LS_COMPLETED;
if (!(bk->lb_param & LPF_DRYRUN))
ns->ln_flags &= ~(LF_SCANNED_ONCE | LF_INCONSISTENT);
ns->ln_time_last_complete = ns->ln_time_last_checkpoint;
ns->ln_success_count++;
} else if (rc == 0) {
ns->ln_status = lfsck->li_status;
if (ns->ln_status == 0)
ns->ln_status = LS_STOPPED;
} else {
ns->ln_status = LS_FAILED;
}
if (ns->ln_status != LS_PAUSED) {
spin_lock(&lfsck->li_lock);
cfs_list_del_init(&com->lc_link);
cfs_list_add_tail(&com->lc_link, &lfsck->li_list_idle);
spin_unlock(&lfsck->li_lock);
}
rc = lfsck_namespace_store(env, com, false);
up_write(&com->lc_sem);
if (atomic_dec_and_test(&lfsck->li_double_scan_count))
wake_up_all(&thread->t_ctl_waitq);
lfsck_thread_args_fini(lta);
return rc;
}
static int
lfsck_namespace_dump(const struct lu_env *env, struct lfsck_component *com,
char *buf, int len)
{
struct lfsck_instance *lfsck = com->lc_lfsck;
struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
struct lfsck_namespace *ns = com->lc_file_ram;
int save = len;
int ret = -ENOSPC;
int rc;
down_read(&com->lc_sem);
rc = snprintf(buf, len,
"name: lfsck_namespace\n"
"magic: %#x\n"
"version: %d\n"
"status: %s\n",
ns->ln_magic,
bk->lb_version,
lfsck_status2names(ns->ln_status));
if (rc <= 0)
goto out;
buf += rc;
len -= rc;
rc = lfsck_bits_dump(&buf, &len, ns->ln_flags, lfsck_flags_names,
"flags");
if (rc < 0)
goto out;
rc = lfsck_bits_dump(&buf, &len, bk->lb_param, lfsck_param_names,
"param");
if (rc < 0)
goto out;
rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_complete,
"time_since_last_completed");
if (rc < 0)
goto out;
rc = lfsck_time_dump(&buf, &len, ns->ln_time_latest_start,
"time_since_latest_start");
if (rc < 0)
goto out;
rc = lfsck_time_dump(&buf, &len, ns->ln_time_last_checkpoint,
"time_since_last_checkpoint");
if (rc < 0)
goto out;
rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_latest_start,
"latest_start_position");
if (rc < 0)
goto out;
rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_last_checkpoint,
"last_checkpoint_position");
if (rc < 0)
goto out;
rc = lfsck_pos_dump(&buf, &len, &ns->ln_pos_first_inconsistent,
"first_failure_position");
if (rc < 0)
goto out;
if (ns->ln_status == LS_SCANNING_PHASE1) {
struct lfsck_position pos;
const struct dt_it_ops *iops;
cfs_duration_t duration = cfs_time_current() -
lfsck->li_time_last_checkpoint;
__u64 checked = ns->ln_items_checked + com->lc_new_checked;
__u64 speed = checked;
__u64 new_checked = com->lc_new_checked * HZ;
__u32 rtime = ns->ln_run_time_phase1 +
cfs_duration_sec(duration + HALF_SEC);
if (duration != 0)
do_div(new_checked, duration);
if (rtime != 0)
do_div(speed, rtime);
rc = snprintf(buf, len,
"checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"updated_phase1: "LPU64"\n"
"updated_phase2: "LPU64"\n"
"failed_phase1: "LPU64"\n"
"failed_phase2: "LPU64"\n"
"dirs: "LPU64"\n"
"M-linked: "LPU64"\n"
"nlinks_repaired: "LPU64"\n"
"lost_found: "LPU64"\n"
"success_count: %u\n"
"run_time_phase1: %u seconds\n"
"run_time_phase2: %u seconds\n"
"average_speed_phase1: "LPU64" items/sec\n"
"average_speed_phase2: N/A\n"
"real-time_speed_phase1: "LPU64" items/sec\n"
"real-time_speed_phase2: N/A\n",
checked,
ns->ln_objs_checked_phase2,
ns->ln_items_repaired,
ns->ln_objs_repaired_phase2,
ns->ln_items_failed,
ns->ln_objs_failed_phase2,
ns->ln_dirs_checked,
ns->ln_mlinked_checked,
ns->ln_objs_nlink_repaired,
ns->ln_objs_lost_found,
ns->ln_success_count,
rtime,
ns->ln_run_time_phase2,
speed,
new_checked);
if (rc <= 0)
goto out;
buf += rc;
len -= rc;
LASSERT(lfsck->li_di_oit != NULL);
iops = &lfsck->li_obj_oit->do_index_ops->dio_it;
/* The low layer otable-based iteration position may NOT
* exactly match the namespace-based directory traversal
* cookie. Generally, it is not a serious issue. But the
* caller should NOT make assumption on that. */
pos.lp_oit_cookie = iops->store(env, lfsck->li_di_oit);
if (!lfsck->li_current_oit_processed)
pos.lp_oit_cookie--;
spin_lock(&lfsck->li_lock);
if (lfsck->li_di_dir != NULL) {
pos.lp_dir_cookie = lfsck->li_cookie_dir;
if (pos.lp_dir_cookie >= MDS_DIR_END_OFF) {
fid_zero(&pos.lp_dir_parent);
pos.lp_dir_cookie = 0;
} else {
pos.lp_dir_parent =
*lfsck_dto2fid(lfsck->li_obj_dir);
}
} else {
fid_zero(&pos.lp_dir_parent);
pos.lp_dir_cookie = 0;
}
spin_unlock(&lfsck->li_lock);
rc = lfsck_pos_dump(&buf, &len, &pos, "current_position");
if (rc <= 0)
goto out;
} else if (ns->ln_status == LS_SCANNING_PHASE2) {
cfs_duration_t duration = cfs_time_current() -
lfsck->li_time_last_checkpoint;
__u64 checked = ns->ln_objs_checked_phase2 +
com->lc_new_checked;
__u64 speed1 = ns->ln_items_checked;
__u64 speed2 = checked;
__u64 new_checked = com->lc_new_checked * HZ;
__u32 rtime = ns->ln_run_time_phase2 +
cfs_duration_sec(duration + HALF_SEC);
if (duration != 0)
do_div(new_checked, duration);
if (ns->ln_run_time_phase1 != 0)
do_div(speed1, ns->ln_run_time_phase1);
if (rtime != 0)
do_div(speed2, rtime);
rc = snprintf(buf, len,
"checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"updated_phase1: "LPU64"\n"
"updated_phase2: "LPU64"\n"
"failed_phase1: "LPU64"\n"
"failed_phase2: "LPU64"\n"
"dirs: "LPU64"\n"
"M-linked: "LPU64"\n"
"nlinks_repaired: "LPU64"\n"
"lost_found: "LPU64"\n"
"success_count: %u\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"
"real-time_speed_phase1: N/A\n"
"real-time_speed_phase2: "LPU64" objs/sec\n"
"current_position: "DFID"\n",
ns->ln_items_checked,
checked,
ns->ln_items_repaired,
ns->ln_objs_repaired_phase2,
ns->ln_items_failed,
ns->ln_objs_failed_phase2,
ns->ln_dirs_checked,
ns->ln_mlinked_checked,
ns->ln_objs_nlink_repaired,
ns->ln_objs_lost_found,
ns->ln_success_count,
ns->ln_run_time_phase1,
rtime,
speed1,
speed2,
new_checked,
PFID(&ns->ln_fid_latest_scanned_phase2));
if (rc <= 0)
goto out;
buf += rc;
len -= rc;
} else {
__u64 speed1 = ns->ln_items_checked;
__u64 speed2 = ns->ln_objs_checked_phase2;
if (ns->ln_run_time_phase1 != 0)
do_div(speed1, ns->ln_run_time_phase1);
if (ns->ln_run_time_phase2 != 0)
do_div(speed2, ns->ln_run_time_phase2);
rc = snprintf(buf, len,
"checked_phase1: "LPU64"\n"
"checked_phase2: "LPU64"\n"
"updated_phase1: "LPU64"\n"
"updated_phase2: "LPU64"\n"
"failed_phase1: "LPU64"\n"
"failed_phase2: "LPU64"\n"
"dirs: "LPU64"\n"
"M-linked: "LPU64"\n"
"nlinks_repaired: "LPU64"\n"
"lost_found: "LPU64"\n"
"success_count: %u\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"
"real-time_speed_phase1: N/A\n"
"real-time_speed_phase2: N/A\n"
"current_position: N/A\n",
ns->ln_items_checked,
ns->ln_objs_checked_phase2,
ns->ln_items_repaired,
ns->ln_objs_repaired_phase2,
ns->ln_items_failed,
ns->ln_objs_failed_phase2,
ns->ln_dirs_checked,
ns->ln_mlinked_checked,
ns->ln_objs_nlink_repaired,
ns->ln_objs_lost_found,
ns->ln_success_count,
ns->ln_run_time_phase1,
ns->ln_run_time_phase2,
speed1,
speed2);
if (rc <= 0)
goto out;
buf += rc;
len -= rc;
}
ret = save - len;
out:
up_read(&com->lc_sem);
return ret;
}
