Whamcloud - gitweb
Revert "LU-5275 lprocfs: remove last of non seq data structs and functions."
[fs/lustre-release.git] / lustre / obdclass / lprocfs_status_server.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2013, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lustre/obdclass/lprocfs_status_server.c
33  */
34
35 #define DEBUG_SUBSYSTEM S_CLASS
36
37
38 #include <obd_class.h>
39 #include <lprocfs_status.h>
40 #include <lustre/lustre_idl.h>
41 #include <lustre_nodemap.h>
42
43 #if defined(LPROCFS)
44
45 int lprocfs_evict_client_open(struct inode *inode, struct file *f)
46 {
47         struct obd_device *obd = PDE_DATA(f->f_dentry->d_inode);
48
49         atomic_inc(&obd->obd_evict_inprogress);
50         return 0;
51 }
52
53 int lprocfs_evict_client_release(struct inode *inode, struct file *f)
54 {
55         struct obd_device *obd = PDE_DATA(f->f_dentry->d_inode);
56
57         atomic_dec(&obd->obd_evict_inprogress);
58         wake_up(&obd->obd_evict_inprogress_waitq);
59
60         return 0;
61 }
62
63 #define BUFLEN (UUID_MAX + 5)
64
65 ssize_t
66 lprocfs_evict_client_seq_write(struct file *file, const char *buffer,
67                                size_t count, loff_t *off)
68 {
69         struct seq_file *m = file->private_data;
70         struct obd_device *obd = m->private;
71         char *tmpbuf, *kbuf;
72
73         OBD_ALLOC(kbuf, BUFLEN);
74         if (kbuf == NULL)
75                 return -ENOMEM;
76
77         /*
78          * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1
79          * bytes into kbuf, to ensure that the string is NUL-terminated.
80          * UUID_MAX should include a trailing NUL already.
81          */
82         if (copy_from_user(kbuf, buffer,
83                            min_t(unsigned long, BUFLEN - 1, count))) {
84                 count = -EFAULT;
85                 goto out;
86         }
87         tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count));
88         class_incref(obd, __func__, current);
89
90         if (strncmp(tmpbuf, "nid:", 4) == 0)
91                 obd_export_evict_by_nid(obd, tmpbuf + 4);
92         else if (strncmp(tmpbuf, "uuid:", 5) == 0)
93                 obd_export_evict_by_uuid(obd, tmpbuf + 5);
94         else
95                 obd_export_evict_by_uuid(obd, tmpbuf);
96
97         class_decref(obd, __func__, current);
98
99 out:
100         OBD_FREE(kbuf, BUFLEN);
101         return count;
102 }
103 EXPORT_SYMBOL(lprocfs_evict_client_seq_write);
104
105 #undef BUFLEN
106
107 int lprocfs_num_exports_seq_show(struct seq_file *m, void *data)
108 {
109         struct obd_device *obd = data;
110
111         LASSERT(obd != NULL);
112         return seq_printf(m, "%u\n", obd->obd_num_exports);
113 }
114 EXPORT_SYMBOL(lprocfs_num_exports_seq_show);
115
116 static void lprocfs_free_client_stats(struct nid_stat *client_stat)
117 {
118         CDEBUG(D_CONFIG, "stat %p - data %p/%p\n", client_stat,
119                client_stat->nid_proc, client_stat->nid_stats);
120
121         LASSERTF(atomic_read(&client_stat->nid_exp_ref_count) == 0,
122                  "nid %s:count %d\n", libcfs_nid2str(client_stat->nid),
123                  atomic_read(&client_stat->nid_exp_ref_count));
124
125         if (client_stat->nid_proc)
126                 lprocfs_remove(&client_stat->nid_proc);
127
128         if (client_stat->nid_stats)
129                 lprocfs_free_stats(&client_stat->nid_stats);
130
131         if (client_stat->nid_ldlm_stats)
132                 lprocfs_free_stats(&client_stat->nid_ldlm_stats);
133
134         OBD_FREE_PTR(client_stat);
135         return;
136 }
137
138 void lprocfs_free_per_client_stats(struct obd_device *obd)
139 {
140         cfs_hash_t *hash = obd->obd_nid_stats_hash;
141         struct nid_stat *stat;
142         ENTRY;
143
144         /* we need extra list - because hash_exit called to early */
145         /* not need locking because all clients is died */
146         while (!list_empty(&obd->obd_nid_stats)) {
147                 stat = list_entry(obd->obd_nid_stats.next,
148                                   struct nid_stat, nid_list);
149                 list_del_init(&stat->nid_list);
150                 cfs_hash_del(hash, &stat->nid, &stat->nid_hash);
151                 lprocfs_free_client_stats(stat);
152         }
153         EXIT;
154 }
155 EXPORT_SYMBOL(lprocfs_free_per_client_stats);
156
157 int lprocfs_exp_nid_seq_show(struct seq_file *m, void *data)
158 {
159         struct obd_export *exp = m->private;
160         LASSERT(exp != NULL);
161         return seq_printf(m, "%s\n", obd_export_nid2str(exp));
162 }
163
164 int lprocfs_exp_print_uuid_seq(cfs_hash_t *hs, cfs_hash_bd_t *bd,
165                                 struct hlist_node *hnode, void *cb_data)
166
167 {
168         struct obd_export *exp = cfs_hash_object(hs, hnode);
169         struct seq_file *m = cb_data;
170
171         if (exp->exp_nid_stats)
172                 seq_printf(m, "%s\n", obd_uuid2str(&exp->exp_client_uuid));
173         return 0;
174 }
175
176 int lprocfs_exp_nodemap_seq_show(struct seq_file *m, void *data)
177 {
178         struct obd_export       *exp = m->private;
179         if (exp->exp_target_data.ted_nodemap)
180                 return seq_printf(m, "%s\n",
181                                   exp->exp_target_data.ted_nodemap->nm_name);
182         return seq_printf(m, "null\n");
183 }
184 LPROC_SEQ_FOPS_RO(lprocfs_exp_nodemap);
185
186 int lprocfs_exp_uuid_seq_show(struct seq_file *m, void *data)
187 {
188         struct nid_stat *stats = m->private;
189         struct obd_device *obd = stats->nid_obd;
190
191         cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
192                                 lprocfs_exp_print_uuid_seq, m);
193         return 0;
194 }
195 LPROC_SEQ_FOPS_RO(lprocfs_exp_uuid);
196
197 int lprocfs_exp_print_hash_seq(cfs_hash_t *hs, cfs_hash_bd_t *bd,
198                                 struct hlist_node *hnode, void *cb_data)
199
200 {
201         struct seq_file *m = cb_data;
202         struct obd_export *exp = cfs_hash_object(hs, hnode);
203
204         if (exp->exp_lock_hash != NULL) {
205                 cfs_hash_debug_header(m);
206                 cfs_hash_debug_str(hs, m);
207         }
208         return 0;
209 }
210
211 int lprocfs_exp_hash_seq_show(struct seq_file *m, void *data)
212 {
213         struct nid_stat *stats = m->private;
214         struct obd_device *obd = stats->nid_obd;
215
216         cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
217                                 lprocfs_exp_print_hash_seq, m);
218         return 0;
219 }
220 LPROC_SEQ_FOPS_RO(lprocfs_exp_hash);
221
222 int lprocfs_nid_stats_clear_seq_show(struct seq_file *m, void *data)
223 {
224         return seq_printf(m, "%s\n", "Write into this file to clear all nid "
225                           "stats and stale nid entries");
226 }
227 EXPORT_SYMBOL(lprocfs_nid_stats_clear_seq_show);
228
229 static int lprocfs_nid_stats_clear_write_cb(void *obj, void *data)
230 {
231         struct nid_stat *stat = obj;
232         ENTRY;
233
234         CDEBUG(D_INFO, "refcnt %d\n", atomic_read(&stat->nid_exp_ref_count));
235         if (atomic_read(&stat->nid_exp_ref_count) == 1) {
236                 /* object has only hash references. */
237                 spin_lock(&stat->nid_obd->obd_nid_lock);
238                 list_move(&stat->nid_list, data);
239                 spin_unlock(&stat->nid_obd->obd_nid_lock);
240                 RETURN(1);
241         }
242         /* we has reference to object - only clear data*/
243         if (stat->nid_stats)
244                 lprocfs_clear_stats(stat->nid_stats);
245
246         RETURN(0);
247 }
248
249 ssize_t
250 lprocfs_nid_stats_clear_seq_write(struct file *file, const char *buffer,
251                                         size_t count, loff_t *off)
252 {
253         struct seq_file *m = file->private_data;
254         struct obd_device *obd = m->private;
255         struct nid_stat *client_stat;
256         struct list_head free_list;
257
258         INIT_LIST_HEAD(&free_list);
259         cfs_hash_cond_del(obd->obd_nid_stats_hash,
260                           lprocfs_nid_stats_clear_write_cb, &free_list);
261
262         while (!list_empty(&free_list)) {
263                 client_stat = list_entry(free_list.next, struct nid_stat,
264                                          nid_list);
265                 list_del_init(&client_stat->nid_list);
266                 lprocfs_free_client_stats(client_stat);
267         }
268         return count;
269 }
270 EXPORT_SYMBOL(lprocfs_nid_stats_clear_seq_write);
271
272 int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *nid, int *newnid)
273 {
274         struct nid_stat *new_stat, *old_stat;
275         struct obd_device *obd = NULL;
276         struct proc_dir_entry *entry;
277         char *buffer = NULL;
278         int rc = 0;
279         ENTRY;
280
281         *newnid = 0;
282
283         if (!exp || !exp->exp_obd || !exp->exp_obd->obd_proc_exports_entry ||
284             !exp->exp_obd->obd_nid_stats_hash)
285                 RETURN(-EINVAL);
286
287         /* not test against zero because eric say:
288          * You may only test nid against another nid, or LNET_NID_ANY.
289          * Anything else is nonsense.*/
290         if (!nid || *nid == LNET_NID_ANY)
291                 RETURN(0);
292
293         spin_lock(&exp->exp_lock);
294         if (exp->exp_nid_stats != NULL) {
295                 spin_unlock(&exp->exp_lock);
296                 RETURN(-EALREADY);
297         }
298         spin_unlock(&exp->exp_lock);
299
300         obd = exp->exp_obd;
301
302         CDEBUG(D_CONFIG, "using hash %p\n", obd->obd_nid_stats_hash);
303
304         OBD_ALLOC_PTR(new_stat);
305         if (new_stat == NULL)
306                 RETURN(-ENOMEM);
307
308         new_stat->nid           = *nid;
309         new_stat->nid_obd       = exp->exp_obd;
310         /* we need set default refcount to 1 to balance obd_disconnect */
311         atomic_set(&new_stat->nid_exp_ref_count, 1);
312
313         old_stat = cfs_hash_findadd_unique(obd->obd_nid_stats_hash,
314                                            nid, &new_stat->nid_hash);
315         CDEBUG(D_INFO, "Found stats %p for nid %s - ref %d\n",
316                old_stat, libcfs_nid2str(*nid),
317                atomic_read(&new_stat->nid_exp_ref_count));
318
319         /* Return -EALREADY here so that we know that the /proc
320          * entry already has been created */
321         if (old_stat != new_stat) {
322                 spin_lock(&exp->exp_lock);
323                 if (exp->exp_nid_stats) {
324                         LASSERT(exp->exp_nid_stats == old_stat);
325                         nidstat_putref(exp->exp_nid_stats);
326                 }
327                 exp->exp_nid_stats = old_stat;
328                 spin_unlock(&exp->exp_lock);
329                 GOTO(destroy_new, rc = -EALREADY);
330         }
331         /* not found - create */
332         OBD_ALLOC(buffer, LNET_NIDSTR_SIZE);
333         if (buffer == NULL)
334                 GOTO(destroy_new, rc = -ENOMEM);
335
336         memcpy(buffer, libcfs_nid2str(*nid), LNET_NIDSTR_SIZE);
337 #ifndef HAVE_ONLY_PROCFS_SEQ
338         new_stat->nid_proc = lprocfs_register(buffer,
339                                               obd->obd_proc_exports_entry,
340                                               NULL, NULL);
341 #else
342         new_stat->nid_proc = lprocfs_seq_register(buffer,
343                                                   obd->obd_proc_exports_entry,
344                                                   NULL, NULL);
345 #endif
346         OBD_FREE(buffer, LNET_NIDSTR_SIZE);
347
348         if (IS_ERR(new_stat->nid_proc)) {
349                 rc = PTR_ERR(new_stat->nid_proc);
350                 new_stat->nid_proc = NULL;
351                 CERROR("%s: cannot create proc entry for export %s: rc = %d\n",
352                        obd->obd_name, libcfs_nid2str(*nid), rc);
353                 GOTO(destroy_new_ns, rc);
354         }
355
356         entry = lprocfs_add_simple(new_stat->nid_proc, "nodemap",
357                                    exp, &lprocfs_exp_nodemap_fops);
358         if (IS_ERR(entry)) {
359                 rc = PTR_ERR(entry);
360                 CWARN("Error adding the nodemap file: rc = %d\n", rc);
361                 GOTO(destroy_new_ns, rc);
362         }
363
364         entry = lprocfs_add_simple(new_stat->nid_proc, "uuid", new_stat,
365                                    &lprocfs_exp_uuid_fops);
366         if (IS_ERR(entry)) {
367                 rc = PTR_ERR(entry);
368                 CWARN("Error adding the NID stats file: rc = %d\n", rc);
369                 GOTO(destroy_new_ns, rc);
370         }
371
372         entry = lprocfs_add_simple(new_stat->nid_proc, "hash", new_stat,
373                                    &lprocfs_exp_hash_fops);
374         if (IS_ERR(entry)) {
375                 rc = PTR_ERR(entry);
376                 CWARN("Error adding the hash file: rc = %d\n", rc);
377                 GOTO(destroy_new_ns, rc);
378         }
379
380         spin_lock(&exp->exp_lock);
381         exp->exp_nid_stats = new_stat;
382         spin_unlock(&exp->exp_lock);
383         *newnid = 1;
384         /* protect competitive add to list, not need locking on destroy */
385         spin_lock(&obd->obd_nid_lock);
386         list_add(&new_stat->nid_list, &obd->obd_nid_stats);
387         spin_unlock(&obd->obd_nid_lock);
388
389         RETURN(rc);
390
391 destroy_new_ns:
392         if (new_stat->nid_proc != NULL)
393                 lprocfs_remove(&new_stat->nid_proc);
394         cfs_hash_del(obd->obd_nid_stats_hash, nid, &new_stat->nid_hash);
395
396 destroy_new:
397         nidstat_putref(new_stat);
398         OBD_FREE_PTR(new_stat);
399         RETURN(rc);
400 }
401 EXPORT_SYMBOL(lprocfs_exp_setup);
402
403 int lprocfs_exp_cleanup(struct obd_export *exp)
404 {
405         struct nid_stat *stat = exp->exp_nid_stats;
406
407         if (!stat || !exp->exp_obd)
408                 RETURN(0);
409
410         nidstat_putref(exp->exp_nid_stats);
411         exp->exp_nid_stats = NULL;
412
413         return 0;
414 }
415 EXPORT_SYMBOL(lprocfs_exp_cleanup);
416
417 #define LPROCFS_OBD_OP_INIT(base, stats, op)                    \
418 do {                                                            \
419         unsigned int coffset = base + OBD_COUNTER_OFFSET(op);   \
420         LASSERT(coffset < stats->ls_num);                       \
421         lprocfs_counter_init(stats, coffset, 0, #op, "reqs");   \
422 } while (0)
423
424 void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats)
425 {
426         LPROCFS_OBD_OP_INIT(num_private_stats, stats, iocontrol);
427         LPROCFS_OBD_OP_INIT(num_private_stats, stats, get_info);
428         LPROCFS_OBD_OP_INIT(num_private_stats, stats, set_info_async);
429         LPROCFS_OBD_OP_INIT(num_private_stats, stats, setup);
430         LPROCFS_OBD_OP_INIT(num_private_stats, stats, precleanup);
431         LPROCFS_OBD_OP_INIT(num_private_stats, stats, cleanup);
432         LPROCFS_OBD_OP_INIT(num_private_stats, stats, process_config);
433         LPROCFS_OBD_OP_INIT(num_private_stats, stats, postrecov);
434         LPROCFS_OBD_OP_INIT(num_private_stats, stats, add_conn);
435         LPROCFS_OBD_OP_INIT(num_private_stats, stats, del_conn);
436         LPROCFS_OBD_OP_INIT(num_private_stats, stats, connect);
437         LPROCFS_OBD_OP_INIT(num_private_stats, stats, reconnect);
438         LPROCFS_OBD_OP_INIT(num_private_stats, stats, disconnect);
439         LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_init);
440         LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_fini);
441         LPROCFS_OBD_OP_INIT(num_private_stats, stats, fid_alloc);
442         LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs);
443         LPROCFS_OBD_OP_INIT(num_private_stats, stats, statfs_async);
444         LPROCFS_OBD_OP_INIT(num_private_stats, stats, packmd);
445         LPROCFS_OBD_OP_INIT(num_private_stats, stats, unpackmd);
446         LPROCFS_OBD_OP_INIT(num_private_stats, stats, create);
447         LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy);
448         LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr);
449         LPROCFS_OBD_OP_INIT(num_private_stats, stats, setattr_async);
450         LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr);
451         LPROCFS_OBD_OP_INIT(num_private_stats, stats, getattr_async);
452         LPROCFS_OBD_OP_INIT(num_private_stats, stats, preprw);
453         LPROCFS_OBD_OP_INIT(num_private_stats, stats, commitrw);
454         LPROCFS_OBD_OP_INIT(num_private_stats, stats, change_cbdata);
455         LPROCFS_OBD_OP_INIT(num_private_stats, stats, find_cbdata);
456         LPROCFS_OBD_OP_INIT(num_private_stats, stats, init_export);
457         LPROCFS_OBD_OP_INIT(num_private_stats, stats, destroy_export);
458         LPROCFS_OBD_OP_INIT(num_private_stats, stats, import_event);
459         LPROCFS_OBD_OP_INIT(num_private_stats, stats, notify);
460         LPROCFS_OBD_OP_INIT(num_private_stats, stats, health_check);
461         LPROCFS_OBD_OP_INIT(num_private_stats, stats, get_uuid);
462         LPROCFS_OBD_OP_INIT(num_private_stats, stats, quotacheck);
463         LPROCFS_OBD_OP_INIT(num_private_stats, stats, quotactl);
464         LPROCFS_OBD_OP_INIT(num_private_stats, stats, ping);
465         LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_new);
466         LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_rem);
467         LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_add);
468         LPROCFS_OBD_OP_INIT(num_private_stats, stats, pool_del);
469         LPROCFS_OBD_OP_INIT(num_private_stats, stats, getref);
470         LPROCFS_OBD_OP_INIT(num_private_stats, stats, putref);
471
472         CLASSERT(NUM_OBD_STATS == OBD_COUNTER_OFFSET(putref) + 1);
473 }
474 EXPORT_SYMBOL(lprocfs_init_ops_stats);
475
476 int lprocfs_alloc_obd_stats(struct obd_device *obd, unsigned num_private_stats)
477 {
478         struct lprocfs_stats *stats;
479         unsigned int num_stats;
480         int rc, i;
481
482         LASSERT(obd->obd_stats == NULL);
483         LASSERT(obd->obd_proc_entry != NULL);
484         LASSERT(obd->obd_cntr_base == 0);
485
486         num_stats = NUM_OBD_STATS + num_private_stats;
487         stats = lprocfs_alloc_stats(num_stats, 0);
488         if (stats == NULL)
489                 return -ENOMEM;
490
491         lprocfs_init_ops_stats(num_private_stats, stats);
492
493         for (i = num_private_stats; i < num_stats; i++) {
494                 /* If this LBUGs, it is likely that an obd
495                  * operation was added to struct obd_ops in
496                  * <obd.h>, and that the corresponding line item
497                  * LPROCFS_OBD_OP_INIT(.., .., opname)
498                  * is missing from the list above. */
499                 LASSERTF(stats->ls_cnt_header[i].lc_name != NULL,
500                          "Missing obd_stat initializer obd_op "
501                          "operation at offset %d.\n", i - num_private_stats);
502         }
503         rc = lprocfs_register_stats(obd->obd_proc_entry, "stats", stats);
504         if (rc < 0) {
505                 lprocfs_free_stats(&stats);
506         } else {
507                 obd->obd_stats  = stats;
508                 obd->obd_cntr_base = num_private_stats;
509         }
510         return rc;
511 }
512 EXPORT_SYMBOL(lprocfs_alloc_obd_stats);
513
514 void lprocfs_free_obd_stats(struct obd_device *obd)
515 {
516         if (obd->obd_stats)
517                 lprocfs_free_stats(&obd->obd_stats);
518 }
519 EXPORT_SYMBOL(lprocfs_free_obd_stats);
520
521 int lprocfs_hash_seq_show(struct seq_file *m, void *data)
522 {
523         struct obd_device *obd = m->private;
524         int c = 0;
525
526         if (obd == NULL)
527                 return 0;
528
529         c += cfs_hash_debug_header(m);
530         c += cfs_hash_debug_str(obd->obd_uuid_hash, m);
531         c += cfs_hash_debug_str(obd->obd_nid_hash, m);
532         c += cfs_hash_debug_str(obd->obd_nid_stats_hash, m);
533         return c;
534 }
535 EXPORT_SYMBOL(lprocfs_hash_seq_show);
536
537 int lprocfs_recovery_status_seq_show(struct seq_file *m, void *data)
538 {
539         struct obd_device *obd = m->private;
540
541         LASSERT(obd != NULL);
542
543         seq_printf(m, "status: ");
544         if (obd->obd_max_recoverable_clients == 0) {
545                 seq_printf(m, "INACTIVE\n");
546                 goto out;
547         }
548
549         /* sampled unlocked, but really... */
550         if (obd->obd_recovering == 0) {
551                 seq_printf(m, "COMPLETE\n");
552                 seq_printf(m, "recovery_start: %lu\n", obd->obd_recovery_start);
553                 seq_printf(m, "recovery_duration: %lu\n",
554                            obd->obd_recovery_end - obd->obd_recovery_start);
555                 /* Number of clients that have completed recovery */
556                 seq_printf(m, "completed_clients: %d/%d\n",
557                            obd->obd_max_recoverable_clients -
558                            obd->obd_stale_clients,
559                            obd->obd_max_recoverable_clients);
560                 seq_printf(m, "replayed_requests: %d\n",
561                            obd->obd_replayed_requests);
562                 seq_printf(m, "last_transno: "LPD64"\n",
563                            obd->obd_next_recovery_transno - 1);
564                 seq_printf(m, "VBR: %s\n", obd->obd_version_recov ?
565                            "ENABLED" : "DISABLED");
566                 seq_printf(m, "IR: %s\n", obd->obd_no_ir ?
567                            "DISABLED" : "ENABLED");
568                 goto out;
569         }
570
571         seq_printf(m, "RECOVERING\n");
572         seq_printf(m, "recovery_start: %lu\n", obd->obd_recovery_start);
573         seq_printf(m, "time_remaining: %lu\n",
574                    cfs_time_current_sec() >=
575                    obd->obd_recovery_start +
576                    obd->obd_recovery_timeout ? 0 :
577                    obd->obd_recovery_start +
578                    obd->obd_recovery_timeout -
579                    cfs_time_current_sec());
580         seq_printf(m, "connected_clients: %d/%d\n",
581                    atomic_read(&obd->obd_connected_clients),
582                    obd->obd_max_recoverable_clients);
583         /* Number of clients that have completed recovery */
584         seq_printf(m, "req_replay_clients: %d\n",
585                    atomic_read(&obd->obd_req_replay_clients));
586         seq_printf(m, "lock_repay_clients: %d\n",
587                    atomic_read(&obd->obd_lock_replay_clients));
588         seq_printf(m, "completed_clients: %d\n",
589                    atomic_read(&obd->obd_connected_clients) -
590                    atomic_read(&obd->obd_lock_replay_clients));
591         seq_printf(m, "evicted_clients: %d\n", obd->obd_stale_clients);
592         seq_printf(m, "replayed_requests: %d\n", obd->obd_replayed_requests);
593         seq_printf(m, "queued_requests: %d\n",
594                    obd->obd_requests_queued_for_recovery);
595         seq_printf(m, "next_transno: "LPD64"\n",
596                    obd->obd_next_recovery_transno);
597 out:
598         return 0;
599 }
600 EXPORT_SYMBOL(lprocfs_recovery_status_seq_show);
601
602 int lprocfs_ir_factor_seq_show(struct seq_file *m, void *data)
603 {
604         struct obd_device *obd = m->private;
605
606         LASSERT(obd != NULL);
607         return seq_printf(m, "%d\n", obd->obd_recovery_ir_factor);
608 }
609 EXPORT_SYMBOL(lprocfs_ir_factor_seq_show);
610
611 ssize_t
612 lprocfs_ir_factor_seq_write(struct file *file, const char *buffer,
613                             size_t count, loff_t *off)
614 {
615         struct seq_file *m = file->private_data;
616         struct obd_device *obd = m->private;
617         int val, rc;
618
619         LASSERT(obd != NULL);
620         rc = lprocfs_write_helper(buffer, count, &val);
621         if (rc)
622                 return rc;
623
624         if (val < OBD_IR_FACTOR_MIN || val > OBD_IR_FACTOR_MAX)
625                 return -EINVAL;
626
627         obd->obd_recovery_ir_factor = val;
628         return count;
629 }
630 EXPORT_SYMBOL(lprocfs_ir_factor_seq_write);
631
632 int lprocfs_recovery_time_soft_seq_show(struct seq_file *m, void *data)
633 {
634         struct obd_device *obd = m->private;
635
636         LASSERT(obd != NULL);
637         return seq_printf(m, "%d\n", obd->obd_recovery_timeout);
638 }
639 EXPORT_SYMBOL(lprocfs_recovery_time_soft_seq_show);
640
641 ssize_t
642 lprocfs_recovery_time_soft_seq_write(struct file *file, const char *buffer,
643                                         size_t count, loff_t *off)
644 {
645         struct seq_file *m = file->private_data;
646         struct obd_device *obd = m->private;
647         int val, rc;
648
649         LASSERT(obd != NULL);
650         rc = lprocfs_write_helper(buffer, count, &val);
651         if (rc)
652                 return rc;
653
654         obd->obd_recovery_timeout = val;
655         return count;
656 }
657 EXPORT_SYMBOL(lprocfs_recovery_time_soft_seq_write);
658
659 int lprocfs_recovery_time_hard_seq_show(struct seq_file *m, void *data)
660 {
661         struct obd_device *obd = m->private;
662
663         LASSERT(obd != NULL);
664         return seq_printf(m, "%u\n", obd->obd_recovery_time_hard);
665 }
666 EXPORT_SYMBOL(lprocfs_recovery_time_hard_seq_show);
667
668 ssize_t
669 lprocfs_recovery_time_hard_seq_write(struct file *file, const char *buffer,
670                                      size_t count, loff_t *off)
671 {
672         struct seq_file *m = file->private_data;
673         struct obd_device *obd = m->private;
674         int val, rc;
675
676         LASSERT(obd != NULL);
677         rc = lprocfs_write_helper(buffer, count, &val);
678         if (rc)
679                 return rc;
680
681         obd->obd_recovery_time_hard = val;
682         return count;
683 }
684 EXPORT_SYMBOL(lprocfs_recovery_time_hard_seq_write);
685
686 int lprocfs_target_instance_seq_show(struct seq_file *m, void *data)
687 {
688         struct obd_device *obd = m->private;
689         struct obd_device_target *target = &obd->u.obt;
690
691         LASSERT(obd != NULL);
692         LASSERT(target->obt_magic == OBT_MAGIC);
693         return seq_printf(m, "%u\n", obd->u.obt.obt_instance);
694 }
695 EXPORT_SYMBOL(lprocfs_target_instance_seq_show);
696
697 #endif /* LPROCFS*/