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; }