X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flprocfs_status.c;h=8c2e1b11c0fe7f450fff89abebdfdd9315a795c8;hb=9d4b898b1c1c7c318fda5f0c345ed726c774c06a;hp=fcfb991924f62d18798e6fb15c810c83a6eb8043;hpb=7a7e17d4db28fac1ca4bc333d60cbeb8dbc530d6;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c index fcfb991..8c2e1b1 100644 --- a/lustre/obdclass/lprocfs_status.c +++ b/lustre/obdclass/lprocfs_status.c @@ -35,6 +35,7 @@ # include # endif # include +# include #else /* __KERNEL__ */ # include #endif @@ -44,7 +45,6 @@ #include #if defined(LPROCFS) && defined(__KERNEL__) - struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, const char *name) { @@ -64,7 +64,6 @@ struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, } /* lprocfs API calls */ - int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list, void *data) { @@ -363,30 +362,29 @@ int lprocfs_rd_numrefs(char *page, char **start, off_t off, int count, return snprintf(page, count, "%d\n", class->typ_refcnt); } -int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list) +int lprocfs_obd_attach(struct obd_device *dev, struct lprocfs_vars *list) { int rc = 0; - LASSERT(obd != NULL); - LASSERT(obd->obd_type != NULL); - LASSERT(obd->obd_type->typ_procroot != NULL); - - obd->obd_proc_entry = lprocfs_register(obd->obd_name, - obd->obd_type->typ_procroot, - list, obd); - if (IS_ERR(obd->obd_proc_entry)) { - rc = PTR_ERR(obd->obd_proc_entry); - CERROR("error %d setting up lprocfs for %s\n",rc,obd->obd_name); - obd->obd_proc_entry = NULL; + LASSERT(dev != NULL); + LASSERT(dev->obd_type != NULL); + LASSERT(dev->obd_type->typ_procroot != NULL); + + dev->obd_proc_entry = lprocfs_register(dev->obd_name, + dev->obd_type->typ_procroot, + list, dev); + if (IS_ERR(dev->obd_proc_entry)) { + rc = PTR_ERR(dev->obd_proc_entry); + dev->obd_proc_entry = NULL; } return rc; } -int lprocfs_obd_cleanup(struct obd_device *obd) +int lprocfs_obd_detach(struct obd_device *dev) { - if (obd && obd->obd_proc_entry) { - lprocfs_remove(obd->obd_proc_entry); - obd->obd_proc_entry = NULL; + if (dev && dev->obd_proc_entry) { + lprocfs_remove(dev->obd_proc_entry); + dev->obd_proc_entry = NULL; } return 0; } @@ -542,11 +540,11 @@ static int lprocfs_stats_seq_open(struct inode *inode, struct file *file) } struct file_operations lprocfs_stats_seq_fops = { - owner: THIS_MODULE, - open: lprocfs_stats_seq_open, - read: seq_read, - llseek: seq_lseek, - release: seq_release, + .owner = THIS_MODULE, + .open = lprocfs_stats_seq_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release, }; int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, @@ -598,7 +596,7 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) LASSERT(obd->obd_proc_entry != NULL); LASSERT(obd->obd_cntr_base == 0); - num_stats = 1 + OBD_COUNTER_OFFSET(notify) + + num_stats = 1 + OBD_COUNTER_OFFSET(init_ea_size) + num_private_stats; stats = lprocfs_alloc_stats(num_stats); if (stats == NULL) @@ -612,12 +610,17 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) LPROCFS_OBD_OP_INIT(num_private_stats, stats, setup); LPROCFS_OBD_OP_INIT(num_private_stats, stats, precleanup); LPROCFS_OBD_OP_INIT(num_private_stats, stats, cleanup); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, process_config); LPROCFS_OBD_OP_INIT(num_private_stats, stats, postrecov); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, add_conn); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, del_conn); LPROCFS_OBD_OP_INIT(num_private_stats, stats, connect); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, connect_post); LPROCFS_OBD_OP_INIT(num_private_stats, stats, disconnect); LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs); LPROCFS_OBD_OP_INIT(num_private_stats, stats, packmd); LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpackmd); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, revalidate_md); LPROCFS_OBD_OP_INIT(num_private_stats, stats, preallocate); LPROCFS_OBD_OP_INIT(num_private_stats, stats, create); LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy); @@ -639,6 +642,8 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) LPROCFS_OBD_OP_INIT(num_private_stats, stats, iterate); LPROCFS_OBD_OP_INIT(num_private_stats, stats, preprw); LPROCFS_OBD_OP_INIT(num_private_stats, stats, commitrw); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, do_cow); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, write_extents); LPROCFS_OBD_OP_INIT(num_private_stats, stats, enqueue); LPROCFS_OBD_OP_INIT(num_private_stats, stats, match); LPROCFS_OBD_OP_INIT(num_private_stats, stats, change_cbdata); @@ -649,16 +654,18 @@ int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats) LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy_export); LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_init); LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_finish); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, llog_connect); LPROCFS_OBD_OP_INIT(num_private_stats, stats, pin); LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpin); LPROCFS_OBD_OP_INIT(num_private_stats, stats, import_event); LPROCFS_OBD_OP_INIT(num_private_stats, stats, notify); - + LPROCFS_OBD_OP_INIT(num_private_stats, stats, getready); + LPROCFS_OBD_OP_INIT(num_private_stats, stats, init_ea_size); + for (i = num_private_stats; i < num_stats; i++) { - /* If this LBUGs, it is likely that an obd - * operation was added to struct obd_ops in - * , and that the corresponding line item - * LPROCFS_OBD_OP_INIT(.., .., opname) + /* if this LBUGs, it is likely that an obd operation was added + * to struct obd_ops in , and that the + * corresponding line item LPROCFS_OBD_OP_INIT(.., .., opname) * is missing from the list above. */ if (stats->ls_percpu[0]->lp_cntr[i].lc_name == NULL) { CERROR("Missing obd_stat initializer obd_op " @@ -787,14 +794,127 @@ void lprocfs_oh_clear(struct obd_histogram *oh) } EXPORT_SYMBOL(lprocfs_oh_clear); +/* XXX copied from ldlm/ldlm_lockd.c, copied from ptlrpc/service.c */ +static long timeval_sub(struct timeval *large, struct timeval *small) +{ + return ((large->tv_sec - small->tv_sec) * 1000000) + + (large->tv_usec - small->tv_usec); +} +void lprocfs_stime_record(struct obd_service_time *stime, struct timeval *large, + struct timeval *small) +{ + long diff = timeval_sub(large, small); + + if (diff < 0) + return; + + stime->st_num++; + stime->st_total_us += diff; +} +EXPORT_SYMBOL(lprocfs_stime_record); + +unsigned long lprocfs_stime_avg_ms(struct obd_service_time *stime) +{ + struct obd_service_time copy; + + memcpy(©, stime, sizeof(copy)); + if (copy.st_num > 0) { + do_div(copy.st_total_us, copy.st_num * 1000); + return (unsigned long)copy.st_total_us; + } + return 0; +} +EXPORT_SYMBOL(lprocfs_stime_avg_ms); + +unsigned long lprocfs_stime_avg_us(struct obd_service_time *stime) +{ + struct obd_service_time copy; + __u32 remainder; + + memcpy(©, stime, sizeof(copy)); + if (copy.st_num > 0) { + do_div(copy.st_total_us, copy.st_num); + remainder = do_div(copy.st_total_us, 1000); + return (unsigned long)remainder; + } + return 0; +} +EXPORT_SYMBOL(lprocfs_stime_avg_us); + +int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct obd_device *obd = data; + int len = 0, n, + connected = obd->obd_connected_clients, + max_recoverable = obd->obd_max_recoverable_clients, + recoverable = obd->obd_recoverable_clients, + completed = max_recoverable - recoverable, + queue_len = obd->obd_requests_queued_for_recovery, + replayed = obd->obd_replayed_requests; + __u64 next_transno = obd->obd_next_recovery_transno; + + LASSERT(obd != NULL); + *eof = 1; + + n = snprintf(page, count, "status: "); + page += n; len += n; count -= n; + if (obd->obd_max_recoverable_clients == 0) { + n = snprintf(page, count, "INACTIVE\n"); + return len + n; + } + + /* sampled unlocked, but really... */ + if (obd->obd_recovering == 0) { + n = snprintf(page, count, "COMPLETE\n"); + page += n; len += n; count -= n; + + n = snprintf(page, count, "recovery_start: %lu\n", + obd->obd_recovery_start); + page += n; len += n; count -= n; + n = snprintf(page, count, "recovery_end: %lu\n", + obd->obd_recovery_end); + page += n; len += n; count -= n; + n = snprintf(page, count, "recovered_clients: %d\n", + completed); + page += n; len += n; count -= n; + n = snprintf(page, count, "unrecovered_clients: %d\n", + obd->obd_recoverable_clients); + page += n; len += n; count -= n; + n = snprintf(page, count, "last_transno: "LPD64"\n", + next_transno - 1); + page += n; len += n; count -= n; + n = snprintf(page, count, "replayed_requests: %d\n", replayed); + return len + n; + } + + n = snprintf(page, count, "RECOVERING\n"); + page += n; len += n; count -= n; + n = snprintf(page, count, "recovery_start: %lu\n", + obd->obd_recovery_start); + page += n; len += n; count -= n; + n = snprintf(page, count, "connected_clients: %d/%d\n", + connected, max_recoverable); + page += n; len += n; count -= n; + n = snprintf(page, count, "completed_clients: %d/%d\n", + completed, max_recoverable); + page += n; len += n; count -= n; + n = snprintf(page, count, "replayed_requests: %d/??\n", replayed); + page += n; len += n; count -= n; + n = snprintf(page, count, "queued_requests: %d\n", queue_len); + page += n; len += n; count -= n; + n = snprintf(page, count, "next_transno: "LPD64"\n", next_transno); + return len + n; +} +EXPORT_SYMBOL(lprocfs_obd_rd_recovery_status); #endif /* LPROCFS*/ EXPORT_SYMBOL(lprocfs_register); EXPORT_SYMBOL(lprocfs_srch); EXPORT_SYMBOL(lprocfs_remove); EXPORT_SYMBOL(lprocfs_add_vars); -EXPORT_SYMBOL(lprocfs_obd_setup); -EXPORT_SYMBOL(lprocfs_obd_cleanup); +EXPORT_SYMBOL(lprocfs_obd_attach); +EXPORT_SYMBOL(lprocfs_obd_detach); EXPORT_SYMBOL(lprocfs_alloc_stats); EXPORT_SYMBOL(lprocfs_free_stats); EXPORT_SYMBOL(lprocfs_register_stats);