Whamcloud - gitweb
LU-6447 mdt: mdt_identity_upcall to not block with rwlock held
[fs/lustre-release.git] / lustre / mdt / mdt_lproc.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  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2014, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/mdt/mdt_lproc.c
37  *
38  * Author: Lai Siyao <lsy@clusterfs.com>
39  * Author: Fan Yong <fanyong@clusterfs.com>
40  */
41
42 #define DEBUG_SUBSYSTEM S_MDS
43
44 #include <linux/version.h>
45 #include <asm/statfs.h>
46
47 #include <linux/module.h>
48 #include <lnet/nidstr.h>
49 /* LUSTRE_VERSION_CODE */
50 #include <lustre_ver.h>
51 /*
52  * struct OBD_{ALLOC,FREE}*()
53  * MDT_FAIL_CHECK
54  */
55 #include <obd_support.h>
56 /* struct obd_export */
57 #include <lustre_export.h>
58 /* struct obd_device */
59 #include <obd.h>
60 #include <obd_class.h>
61 #include <lustre_mds.h>
62 #include <lprocfs_status.h>
63 #include "mdt_internal.h"
64
65 /**
66  * The rename stats output would be YAML formats, like
67  * rename_stats:
68  * - snapshot_time: 1234567890.123456
69  * - same_dir:
70  *     4kB: { samples: 1230, pct: 33, cum_pct: 45 }
71  *     8kB: { samples: 1242, pct: 33, cum_pct: 78 }
72  *     16kB: { samples: 132, pct: 3, cum_pct: 81 }
73  * - crossdir_src:
74  *     4kB: { samples: 123, pct: 33, cum_pct: 45 }
75  *     8kB: { samples: 124, pct: 33, cum_pct: 78 }
76  *     16kB: { samples: 12, pct: 3, cum_pct: 81 }
77  * - crossdir_tgt:
78  *     4kB: { samples: 123, pct: 33, cum_pct: 45 }
79  *     8kB: { samples: 124, pct: 33, cum_pct: 78 }
80  *     16kB: { samples: 12, pct: 3, cum_pct: 81 }
81  **/
82
83 #define pct(a, b) (b ? a * 100 / b : 0)
84
85 static void display_rename_stats(struct seq_file *seq, char *name,
86                                  struct obd_histogram *hist)
87 {
88         unsigned long tot, t, cum = 0;
89         int i;
90
91         tot = lprocfs_oh_sum(hist);
92         if (tot > 0)
93                 seq_printf(seq, "- %-15s\n", name);
94         /* dir size start from 4K, start i from 10(2^10) here */
95         for (i = 0; i < OBD_HIST_MAX; i++) {
96                 t = hist->oh_buckets[i];
97                 cum += t;
98                 if (cum == 0)
99                         continue;
100
101                 if (i < 10)
102                         seq_printf(seq, "%6s%d%s", " ", 1<< i, "bytes:");
103                 else if (i < 20)
104                         seq_printf(seq, "%6s%d%s", " ", 1<<(i-10), "KB:");
105                 else
106                         seq_printf(seq, "%6s%d%s", " ", 1<<(i-20), "MB:");
107
108                 seq_printf(seq, " { sample: %3lu, pct: %3lu, cum_pct: %3lu }\n",
109                            t, pct(t, tot), pct(cum, tot));
110
111                 if (cum == tot)
112                         break;
113         }
114 }
115
116 static void rename_stats_show(struct seq_file *seq,
117                               struct rename_stats *rename_stats)
118 {
119         struct timeval now;
120
121         /* this sampling races with updates */
122         do_gettimeofday(&now);
123         seq_printf(seq, "rename_stats:\n");
124         seq_printf(seq, "- %-15s %lu.%lu\n", "snapshot_time:",
125                    now.tv_sec, now.tv_usec);
126
127         display_rename_stats(seq, "same_dir",
128                              &rename_stats->hist[RENAME_SAMEDIR_SIZE]);
129         display_rename_stats(seq, "crossdir_src",
130                              &rename_stats->hist[RENAME_CROSSDIR_SRC_SIZE]);
131         display_rename_stats(seq, "crossdir_tgt",
132                              &rename_stats->hist[RENAME_CROSSDIR_TGT_SIZE]);
133 }
134
135 #undef pct
136
137 static int mdt_rename_stats_seq_show(struct seq_file *seq, void *v)
138 {
139         struct mdt_device *mdt = seq->private;
140
141         rename_stats_show(seq, &mdt->mdt_rename_stats);
142
143         return 0;
144 }
145
146 static ssize_t
147 mdt_rename_stats_seq_write(struct file *file, const char __user *buf,
148                            size_t len, loff_t *off)
149 {
150         struct seq_file *seq = file->private_data;
151         struct mdt_device *mdt = seq->private;
152         int i;
153
154         for (i = 0; i < RENAME_LAST; i++)
155                 lprocfs_oh_clear(&mdt->mdt_rename_stats.hist[i]);
156
157         return len;
158 }
159 LPROC_SEQ_FOPS(mdt_rename_stats);
160
161 static int lproc_mdt_attach_rename_seqstat(struct mdt_device *mdt)
162 {
163         int i;
164
165         for (i = 0; i < RENAME_LAST; i++)
166                 spin_lock_init(&mdt->mdt_rename_stats.hist[i].oh_lock);
167
168         return lprocfs_obd_seq_create(mdt2obd_dev(mdt), "rename_stats", 0644,
169                                       &mdt_rename_stats_fops, mdt);
170 }
171
172 void mdt_rename_counter_tally(struct mdt_thread_info *info,
173                               struct mdt_device *mdt,
174                               struct ptlrpc_request *req,
175                               struct mdt_object *src,
176                               struct mdt_object *tgt)
177 {
178         struct md_attr *ma = &info->mti_attr;
179         struct rename_stats *rstats = &mdt->mdt_rename_stats;
180         int rc;
181
182         ma->ma_need = MA_INODE;
183         ma->ma_valid = 0;
184         rc = mo_attr_get(info->mti_env, mdt_object_child(src), ma);
185         if (rc) {
186                 CERROR("%s: "DFID" attr_get, rc = %d\n",
187                        mdt_obd_name(mdt), PFID(mdt_object_fid(src)), rc);
188                 return;
189         }
190
191         if (src == tgt) {
192                 mdt_counter_incr(req, LPROC_MDT_SAMEDIR_RENAME);
193                 lprocfs_oh_tally_log2(&rstats->hist[RENAME_SAMEDIR_SIZE],
194                                       (unsigned int)ma->ma_attr.la_size);
195                 return;
196         }
197
198         mdt_counter_incr(req, LPROC_MDT_CROSSDIR_RENAME);
199         lprocfs_oh_tally_log2(&rstats->hist[RENAME_CROSSDIR_SRC_SIZE],
200                               (unsigned int)ma->ma_attr.la_size);
201
202         ma->ma_need = MA_INODE;
203         ma->ma_valid = 0;
204         rc = mo_attr_get(info->mti_env, mdt_object_child(tgt), ma);
205         if (rc) {
206                 CERROR("%s: "DFID" attr_get, rc = %d\n",
207                        mdt_obd_name(mdt), PFID(mdt_object_fid(tgt)), rc);
208                 return;
209         }
210
211         lprocfs_oh_tally_log2(&rstats->hist[RENAME_CROSSDIR_TGT_SIZE],
212                               (unsigned int)ma->ma_attr.la_size);
213 }
214
215 static int mdt_identity_expire_seq_show(struct seq_file *m, void *data)
216 {
217         struct obd_device *obd = m->private;
218         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
219
220         seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
221         return 0;
222 }
223
224 static ssize_t
225 mdt_identity_expire_seq_write(struct file *file, const char __user *buffer,
226                               size_t count, loff_t *off)
227 {
228         struct seq_file   *m = file->private_data;
229         struct obd_device *obd = m->private;
230         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
231         int rc;
232         __s64 val;
233
234         rc = lprocfs_str_to_s64(buffer, count, &val);
235         if (rc)
236                 return rc;
237         if (val < 0 || val > INT_MAX)
238                 return -ERANGE;
239
240         mdt->mdt_identity_cache->uc_entry_expire = val;
241
242         return count;
243 }
244 LPROC_SEQ_FOPS(mdt_identity_expire);
245
246 static int mdt_identity_acquire_expire_seq_show(struct seq_file *m, void *data)
247 {
248         struct obd_device *obd = m->private;
249         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
250
251         seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
252         return 0;
253 }
254
255 static ssize_t
256 mdt_identity_acquire_expire_seq_write(struct file *file,
257                                       const char __user *buffer,
258                                       size_t count, loff_t *off)
259 {
260         struct seq_file   *m = file->private_data;
261         struct obd_device *obd = m->private;
262         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
263         int rc;
264         __s64 val;
265
266         rc = lprocfs_str_to_s64(buffer, count, &val);
267         if (rc)
268                 return rc;
269         if (val < 0 || val > INT_MAX)
270                 return -ERANGE;
271
272         mdt->mdt_identity_cache->uc_acquire_expire = val;
273
274         return count;
275 }
276 LPROC_SEQ_FOPS(mdt_identity_acquire_expire);
277
278 static int mdt_identity_upcall_seq_show(struct seq_file *m, void *data)
279 {
280         struct obd_device *obd = m->private;
281         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
282         struct upcall_cache *hash = mdt->mdt_identity_cache;
283
284         down_read(&hash->uc_upcall_rwsem);
285         seq_printf(m, "%s\n", hash->uc_upcall);
286         up_read(&hash->uc_upcall_rwsem);
287         return 0;
288 }
289
290 static ssize_t
291 mdt_identity_upcall_seq_write(struct file *file, const char __user *buffer,
292                               size_t count, loff_t *off)
293 {
294         struct seq_file         *m = file->private_data;
295         struct obd_device       *obd = m->private;
296         struct mdt_device       *mdt = mdt_dev(obd->obd_lu_dev);
297         struct upcall_cache     *hash = mdt->mdt_identity_cache;
298         int                      rc;
299         char                    *kernbuf;
300
301         if (count >= UC_CACHE_UPCALL_MAXPATH) {
302                 CERROR("%s: identity upcall too long\n", mdt_obd_name(mdt));
303                 return -EINVAL;
304         }
305         OBD_ALLOC(kernbuf, count + 1);
306         if (kernbuf == NULL)
307                 GOTO(failed, rc = -ENOMEM);
308         if (copy_from_user(kernbuf, buffer, count))
309                 GOTO(failed, rc = -EFAULT);
310
311         /* Remove any extraneous bits from the upcall (e.g. linefeeds) */
312         down_write(&hash->uc_upcall_rwsem);
313         sscanf(kernbuf, "%s", hash->uc_upcall);
314         up_write(&hash->uc_upcall_rwsem);
315
316         if (strcmp(hash->uc_name, mdt_obd_name(mdt)) != 0)
317                 CWARN("%s: write to upcall name %s\n",
318                       mdt_obd_name(mdt), hash->uc_upcall);
319
320         if (strcmp(hash->uc_upcall, "NONE") == 0 && mdt->mdt_opts.mo_acl)
321                 CWARN("%s: disable \"identity_upcall\" with ACL enabled maybe "
322                       "cause unexpected \"EACCESS\"\n", mdt_obd_name(mdt));
323
324         CDEBUG(D_CONFIG, "%s: identity upcall set to %s\n", mdt_obd_name(mdt),
325                hash->uc_upcall);
326         OBD_FREE(kernbuf, count + 1);
327         RETURN(count);
328
329  failed:
330         if (kernbuf)
331                 OBD_FREE(kernbuf, count + 1);
332         RETURN(rc);
333 }
334 LPROC_SEQ_FOPS(mdt_identity_upcall);
335
336 static ssize_t
337 lprocfs_identity_flush_seq_write(struct file *file, const char __user *buffer,
338                                  size_t count, void *data)
339 {
340         struct seq_file   *m = file->private_data;
341         struct obd_device *obd = m->private;
342         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
343         int rc;
344         __s64 uid;
345
346         rc = lprocfs_str_to_s64(buffer, count, &uid);
347         if (rc)
348                 return rc;
349         if (uid < INT_MIN || uid > INT_MAX)
350                 return -ERANGE;
351
352         mdt_flush_identity(mdt->mdt_identity_cache, uid);
353         return count;
354 }
355 LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_flush);
356
357 static ssize_t
358 lprocfs_identity_info_seq_write(struct file *file, const char __user *buffer,
359                                 size_t count, void *data)
360 {
361         struct seq_file   *m = file->private_data;
362         struct obd_device *obd = m->private;
363         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
364         struct identity_downcall_data *param;
365         int size = sizeof(*param), rc, checked = 0;
366
367 again:
368         if (count < size) {
369                 CERROR("%s: invalid data count = %lu, size = %d\n",
370                        mdt_obd_name(mdt), (unsigned long) count, size);
371                 return -EINVAL;
372         }
373
374         OBD_ALLOC(param, size);
375         if (param == NULL)
376                 return -ENOMEM;
377
378         if (copy_from_user(param, buffer, size)) {
379                 CERROR("%s: bad identity data\n", mdt_obd_name(mdt));
380                 GOTO(out, rc = -EFAULT);
381         }
382
383         if (checked == 0) {
384                 checked = 1;
385                 if (param->idd_magic != IDENTITY_DOWNCALL_MAGIC) {
386                         CERROR("%s: MDS identity downcall bad params\n",
387                                mdt_obd_name(mdt));
388                         GOTO(out, rc = -EINVAL);
389                 }
390
391                 if (param->idd_nperms > N_PERMS_MAX) {
392                         CERROR("%s: perm count %d more than maximum %d\n",
393                                mdt_obd_name(mdt), param->idd_nperms,
394                                N_PERMS_MAX);
395                         GOTO(out, rc = -EINVAL);
396                 }
397
398                 if (param->idd_ngroups > NGROUPS_MAX) {
399                         CERROR("%s: group count %d more than maximum %d\n",
400                                mdt_obd_name(mdt), param->idd_ngroups,
401                                NGROUPS_MAX);
402                         GOTO(out, rc = -EINVAL);
403                 }
404
405                 if (param->idd_ngroups) {
406                         rc = param->idd_ngroups; /* save idd_ngroups */
407                         OBD_FREE(param, size);
408                         size = offsetof(struct identity_downcall_data,
409                                         idd_groups[rc]);
410                         goto again;
411                 }
412         }
413
414         rc = upcall_cache_downcall(mdt->mdt_identity_cache, param->idd_err,
415                                    param->idd_uid, param);
416
417 out:
418         if (param != NULL)
419                 OBD_FREE(param, size);
420
421         return rc ? rc : count;
422 }
423 LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_info);
424
425 static int mdt_site_stats_seq_show(struct seq_file *m, void *data)
426 {
427         struct obd_device *obd = m->private;
428         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
429
430         return lu_site_stats_seq_print(mdt_lu_site(mdt), m);
431 }
432 LPROC_SEQ_FOPS_RO(mdt_site_stats);
433
434 #define BUFLEN (UUID_MAX + 4)
435
436 static ssize_t
437 lprocfs_mds_evict_client_seq_write(struct file *file, const char __user *buf,
438                                    size_t count, loff_t *off)
439 {
440         struct seq_file   *m = file->private_data;
441         struct obd_device *obd = m->private;
442         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
443         char *kbuf;
444         char *tmpbuf;
445         int rc = 0;
446
447         OBD_ALLOC(kbuf, BUFLEN);
448         if (kbuf == NULL)
449                 return -ENOMEM;
450
451         /*
452          * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1
453          * bytes into kbuf, to ensure that the string is NUL-terminated.
454          * UUID_MAX should include a trailing NUL already.
455          */
456         if (copy_from_user(kbuf, buf, min_t(unsigned long, BUFLEN - 1, count)))
457                 GOTO(out, rc = -EFAULT);
458         tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count));
459
460         if (strncmp(tmpbuf, "nid:", 4) != 0) {
461                 count = lprocfs_evict_client_seq_write(file, buf, count, off);
462                 goto out;
463         }
464
465         if (mdt->mdt_opts.mo_evict_tgt_nids) {
466                 rc = obd_set_info_async(NULL, mdt->mdt_child_exp,
467                                         sizeof(KEY_EVICT_BY_NID),
468                                         KEY_EVICT_BY_NID,
469                                         strlen(tmpbuf + 4) + 1,
470                                         tmpbuf + 4, NULL);
471                 if (rc)
472                         CERROR("Failed to evict nid %s from OSTs: rc %d\n",
473                                tmpbuf + 4, rc);
474         }
475
476         /* See the comments in function lprocfs_wr_evict_client()
477          * in ptlrpc/lproc_ptlrpc.c for details. - jay */
478         class_incref(obd, __func__, current);
479         obd_export_evict_by_nid(obd, tmpbuf + 4);
480         class_decref(obd, __func__, current);
481
482
483 out:
484         OBD_FREE(kbuf, BUFLEN);
485         return rc < 0 ? rc : count;
486 }
487
488 #undef BUFLEN
489
490 static int mdt_evict_tgt_nids_seq_show(struct seq_file *m, void *data)
491 {
492         struct obd_device *obd = m->private;
493         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
494
495         seq_printf(m, "%u\n", mdt->mdt_opts.mo_evict_tgt_nids);
496         return 0;
497 }
498
499 static ssize_t
500 mdt_evict_tgt_nids_seq_write(struct file *file, const char __user *buffer,
501                                size_t count, loff_t *off)
502 {
503         struct seq_file   *m = file->private_data;
504         struct obd_device *obd = m->private;
505         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
506         __s64 val;
507         int rc;
508
509         rc = lprocfs_str_to_s64(buffer, count, &val);
510         if (rc)
511                 return rc;
512         mdt->mdt_opts.mo_evict_tgt_nids = !!val;
513         return count;
514 }
515 LPROC_SEQ_FOPS(mdt_evict_tgt_nids);
516
517 static int mdt_cos_seq_show(struct seq_file *m, void *data)
518 {
519         struct obd_device *obd = m->private;
520         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
521
522         seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
523         return 0;
524 }
525
526 static ssize_t
527 mdt_cos_seq_write(struct file *file, const char __user *buffer,
528                   size_t count, loff_t *off)
529 {
530         struct seq_file   *m = file->private_data;
531         struct obd_device *obd = m->private;
532         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
533         int rc;
534         __s64 val;
535
536         rc = lprocfs_str_to_s64(buffer, count, &val);
537         if (rc)
538                 return rc;
539         if (val < INT_MIN || val > INT_MAX)
540                 return -ERANGE;
541
542         mdt_enable_cos(mdt, val);
543         return count;
544 }
545 LPROC_SEQ_FOPS(mdt_cos);
546
547 static int mdt_root_squash_seq_show(struct seq_file *m, void *data)
548 {
549         struct obd_device *obd = m->private;
550         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
551         struct root_squash_info *squash = &mdt->mdt_squash;
552
553         seq_printf(m, "%u:%u\n", squash->rsi_uid,
554                    squash->rsi_gid);
555         return 0;
556 }
557
558 static ssize_t
559 mdt_root_squash_seq_write(struct file *file, const char __user *buffer,
560                           size_t count, loff_t *off)
561 {
562         struct seq_file   *m = file->private_data;
563         struct obd_device *obd = m->private;
564         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
565         struct root_squash_info *squash = &mdt->mdt_squash;
566
567         return lprocfs_wr_root_squash(buffer, count, squash,
568                                       mdt_obd_name(mdt));
569 }
570 LPROC_SEQ_FOPS(mdt_root_squash);
571
572 static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data)
573 {
574         struct obd_device *obd = m->private;
575         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
576         struct root_squash_info *squash = &mdt->mdt_squash;
577         int len = 0;
578
579         down_read(&squash->rsi_sem);
580         if (!list_empty(&squash->rsi_nosquash_nids)) {
581                 len = cfs_print_nidlist(m->buf + m->count, m->size - m->count,
582                                         &squash->rsi_nosquash_nids);
583                 m->count += len;
584                 seq_putc(m, '\n');
585         } else
586                 seq_puts(m, "NONE\n");
587         up_read(&squash->rsi_sem);
588
589         return 0;
590 }
591
592 static ssize_t
593 mdt_nosquash_nids_seq_write(struct file *file, const char __user *buffer,
594                             size_t count, loff_t *off)
595 {
596         struct seq_file   *m = file->private_data;
597         struct obd_device *obd = m->private;
598         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
599         struct root_squash_info *squash = &mdt->mdt_squash;
600
601         return lprocfs_wr_nosquash_nids(buffer, count, squash,
602                                         mdt_obd_name(mdt));
603 }
604 LPROC_SEQ_FOPS(mdt_nosquash_nids);
605
606 static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data)
607 {
608         struct obd_device *obd = m->private;
609         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
610
611         seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
612         return 0;
613 }
614
615 static ssize_t
616 mdt_enable_remote_dir_seq_write(struct file *file, const char __user *buffer,
617                                 size_t count, loff_t *off)
618 {
619         struct seq_file   *m = file->private_data;
620         struct obd_device *obd = m->private;
621         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
622         __s64 val;
623         int rc;
624
625         rc = lprocfs_str_to_s64(buffer, count, &val);
626         if (rc)
627                 return rc;
628
629         if (val > 1 || val < 0)
630                 return -ERANGE;
631
632         mdt->mdt_enable_remote_dir = val;
633         return count;
634 }
635 LPROC_SEQ_FOPS(mdt_enable_remote_dir);
636
637 static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data)
638 {
639         struct obd_device *obd = m->private;
640         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
641
642         seq_printf(m, "%d\n",
643                   (int)mdt->mdt_enable_remote_dir_gid);
644         return 0;
645 }
646
647 static ssize_t
648 mdt_enable_remote_dir_gid_seq_write(struct file *file,
649                                     const char __user *buffer,
650                                     size_t count, loff_t *off)
651 {
652         struct seq_file   *m = file->private_data;
653         struct obd_device *obd = m->private;
654         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
655         __s64 val;
656         int rc;
657
658         rc = lprocfs_str_to_s64(buffer, count, &val);
659         if (rc)
660                 return rc;
661
662         mdt->mdt_enable_remote_dir_gid = val;
663         return count;
664 }
665 LPROC_SEQ_FOPS(mdt_enable_remote_dir_gid);
666
667 /**
668  * Show MDT policy for handling dirty metadata under a lock being cancelled.
669  *
670  * \param[in] m         seq_file handle
671  * \param[in] data      unused for single entry
672  *
673  * \retval              0 on success
674  * \retval              negative value on error
675  */
676 static int mdt_slc_seq_show(struct seq_file *m, void *data)
677 {
678         struct obd_device *obd = m->private;
679         struct lu_target *tgt = obd->u.obt.obt_lut;
680         char *slc_states[] = {"never", "blocking", "always" };
681
682         seq_printf(m, "%s\n", slc_states[tgt->lut_sync_lock_cancel]);
683         return 0;
684 }
685 LPROC_SEQ_FOPS_RO(mdt_slc);
686
687 /**
688  * Show MDT async commit count.
689  *
690  * \param[in] m         seq_file handle
691  * \param[in] data      unused for single entry
692  *
693  * \retval              0 on success
694  * \retval              negative value on error
695  */
696 static int mdt_async_commit_count_seq_show(struct seq_file *m, void *data)
697 {
698         struct obd_device *obd = m->private;
699         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
700
701         seq_printf(m, "%d\n", atomic_read(&mdt->mdt_async_commit_count));
702         return 0;
703 }
704
705 static ssize_t
706 mdt_async_commit_count_seq_write(struct file *file, const char __user *buffer,
707                                  size_t count, loff_t *off)
708 {
709         struct seq_file *m = file->private_data;
710         struct obd_device *obd = m->private;
711         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
712         __s64 val;
713         int rc;
714
715         rc = lprocfs_str_to_s64(buffer, count, &val);
716         if (rc)
717                 return rc;
718
719         if (val < INT_MIN || val > INT_MAX)
720                 return -ERANGE;
721
722         atomic_set(&mdt->mdt_async_commit_count, val);
723
724         return count;
725 }
726 LPROC_SEQ_FOPS(mdt_async_commit_count);
727
728 /**
729  * Show MDT sync count.
730  *
731  * \param[in] m         seq_file handle
732  * \param[in] data      unused for single entry
733  *
734  * \retval              0 on success
735  * \retval              negative value on error
736  */
737 static int mdt_sync_count_seq_show(struct seq_file *m, void *data)
738 {
739         struct obd_device *obd = m->private;
740         struct lu_target *tgt = obd->u.obt.obt_lut;
741
742         seq_printf(m, "%d\n", atomic_read(&tgt->lut_sync_count));
743         return 0;
744 }
745
746 static ssize_t
747 mdt_sync_count_seq_write(struct file *file, const char __user *buffer,
748                          size_t count, loff_t *off)
749 {
750         struct seq_file *m = file->private_data;
751         struct obd_device *obd = m->private;
752         struct lu_target *tgt = obd->u.obt.obt_lut;
753         __s64 val;
754         int rc;
755
756         rc = lprocfs_str_to_s64(buffer, count, &val);
757         if (rc)
758                 return rc;
759
760         if (val < INT_MIN || val > INT_MAX)
761                 return -ERANGE;
762
763         atomic_set(&tgt->lut_sync_count, val);
764
765         return count;
766 }
767 LPROC_SEQ_FOPS(mdt_sync_count);
768
769
770 LPROC_SEQ_FOPS_RO_TYPE(mdt, uuid);
771 LPROC_SEQ_FOPS_RO_TYPE(mdt, recovery_status);
772 LPROC_SEQ_FOPS_RO_TYPE(mdt, num_exports);
773 LPROC_SEQ_FOPS_RO_TYPE(mdt, target_instance);
774 LPROC_SEQ_FOPS_RO_TYPE(mdt, hash);
775 LPROC_SEQ_FOPS_WO_TYPE(mdt, mds_evict_client);
776 LPROC_SEQ_FOPS_RW_TYPE(mdt, job_interval);
777 LPROC_SEQ_FOPS_RW_TYPE(mdt, ir_factor);
778 LPROC_SEQ_FOPS_RW_TYPE(mdt, nid_stats_clear);
779 LPROC_SEQ_FOPS(mdt_hsm_cdt_control);
780
781 LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_hard);
782 LPROC_SEQ_FOPS_RW_TYPE(mdt, recovery_time_soft);
783
784 static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
785         { .name =       "uuid",
786           .fops =       &mdt_uuid_fops                          },
787         { .name =       "recovery_status",
788           .fops =       &mdt_recovery_status_fops               },
789         { .name =       "num_exports",
790           .fops =       &mdt_num_exports_fops                   },
791         { .name =       "identity_expire",
792           .fops =       &mdt_identity_expire_fops               },
793         { .name =       "identity_acquire_expire",
794           .fops =       &mdt_identity_acquire_expire_fops       },
795         { .name =       "identity_upcall",
796           .fops =       &mdt_identity_upcall_fops               },
797         { .name =       "identity_flush",
798           .fops =       &mdt_identity_flush_fops                },
799         { .name =       "identity_info",
800           .fops =       &mdt_identity_info_fops                 },
801         { .name =       "site_stats",
802           .fops =       &mdt_site_stats_fops                    },
803         { .name =       "evict_client",
804           .fops =       &mdt_mds_evict_client_fops              },
805         { .name =       "evict_tgt_nids",
806           .fops =       &mdt_evict_tgt_nids_fops                },
807         { .name =       "hash_stats",
808           .fops =       &mdt_hash_fops                          },
809         { .name =       "commit_on_sharing",
810           .fops =       &mdt_cos_fops                           },
811         { .name =       "root_squash",
812           .fops =       &mdt_root_squash_fops                   },
813         { .name =       "nosquash_nids",
814           .fops =       &mdt_nosquash_nids_fops                 },
815         { .name =       "instance",
816           .fops =       &mdt_target_instance_fops               },
817         { .name =       "ir_factor",
818           .fops =       &mdt_ir_factor_fops                     },
819         { .name =       "job_cleanup_interval",
820           .fops =       &mdt_job_interval_fops                  },
821         { .name =       "enable_remote_dir",
822           .fops =       &mdt_enable_remote_dir_fops             },
823         { .name =       "enable_remote_dir_gid",
824           .fops =       &mdt_enable_remote_dir_gid_fops         },
825         { .name =       "hsm_control",
826           .fops =       &mdt_hsm_cdt_control_fops               },
827         { .name =       "recovery_time_hard",
828           .fops =       &mdt_recovery_time_hard_fops    },
829         { .name =       "recovery_time_soft",
830           .fops =       &mdt_recovery_time_soft_fops    },
831         { .name =       "sync_lock_cancel",
832           .fops =       &mdt_slc_fops                           },
833         { .name =       "async_commit_count",
834           .fops =       &mdt_async_commit_count_fops            },
835         { .name =       "sync_count",
836           .fops =       &mdt_sync_count_fops                    },
837         { NULL }
838 };
839
840 static int
841 lprocfs_mdt_print_open_files(struct cfs_hash *hs, struct cfs_hash_bd *bd,
842                              struct hlist_node *hnode, void *v)
843 {
844         struct obd_export       *exp = cfs_hash_object(hs, hnode);
845         struct seq_file         *seq = v;
846
847         if (exp->exp_lock_hash != NULL) {
848                 struct mdt_export_data  *med = &exp->exp_mdt_data;
849                 struct mdt_file_data    *mfd;
850
851                 spin_lock(&med->med_open_lock);
852                 list_for_each_entry(mfd, &med->med_open_head, mfd_list) {
853                         seq_printf(seq, DFID"\n",
854                                    PFID(mdt_object_fid(mfd->mfd_object)));
855                 }
856                 spin_unlock(&med->med_open_lock);
857         }
858
859         return 0;
860 }
861
862 static int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
863 {
864         struct nid_stat *stats = seq->private;
865         struct obd_device *obd = stats->nid_obd;
866
867         cfs_hash_for_each_key(obd->obd_nid_hash, &stats->nid,
868                               lprocfs_mdt_print_open_files, seq);
869
870         return 0;
871 }
872
873 int lprocfs_mdt_open_files_seq_open(struct inode *inode, struct file *file)
874 {
875         struct seq_file         *seq;
876         int                     rc;
877
878         rc = single_open(file, &lprocfs_mdt_open_files_seq_show, NULL);
879         if (rc != 0)
880                 return rc;
881
882         seq = file->private_data;
883         seq->private = PDE_DATA(inode);
884
885         return 0;
886 }
887
888 void mdt_counter_incr(struct ptlrpc_request *req, int opcode)
889 {
890         struct obd_export *exp = req->rq_export;
891
892         if (exp->exp_obd && exp->exp_obd->obd_md_stats)
893                 lprocfs_counter_incr(exp->exp_obd->obd_md_stats, opcode);
894         if (exp->exp_nid_stats && exp->exp_nid_stats->nid_stats != NULL)
895                 lprocfs_counter_incr(exp->exp_nid_stats->nid_stats, opcode);
896         if (exp->exp_obd && exp->exp_obd->u.obt.obt_jobstats.ojs_hash &&
897             (exp_connect_flags(exp) & OBD_CONNECT_JOBSTATS))
898                 lprocfs_job_stats_log(exp->exp_obd,
899                                       lustre_msg_get_jobid(req->rq_reqmsg),
900                                       opcode, 1);
901 }
902
903 void mdt_stats_counter_init(struct lprocfs_stats *stats)
904 {
905         lprocfs_counter_init(stats, LPROC_MDT_OPEN, 0, "open", "reqs");
906         lprocfs_counter_init(stats, LPROC_MDT_CLOSE, 0, "close", "reqs");
907         lprocfs_counter_init(stats, LPROC_MDT_MKNOD, 0, "mknod", "reqs");
908         lprocfs_counter_init(stats, LPROC_MDT_LINK, 0, "link", "reqs");
909         lprocfs_counter_init(stats, LPROC_MDT_UNLINK, 0, "unlink", "reqs");
910         lprocfs_counter_init(stats, LPROC_MDT_MKDIR, 0, "mkdir", "reqs");
911         lprocfs_counter_init(stats, LPROC_MDT_RMDIR, 0, "rmdir", "reqs");
912         lprocfs_counter_init(stats, LPROC_MDT_RENAME, 0, "rename", "reqs");
913         lprocfs_counter_init(stats, LPROC_MDT_GETATTR, 0, "getattr", "reqs");
914         lprocfs_counter_init(stats, LPROC_MDT_SETATTR, 0, "setattr", "reqs");
915         lprocfs_counter_init(stats, LPROC_MDT_GETXATTR, 0, "getxattr", "reqs");
916         lprocfs_counter_init(stats, LPROC_MDT_SETXATTR, 0, "setxattr", "reqs");
917         lprocfs_counter_init(stats, LPROC_MDT_STATFS, 0, "statfs", "reqs");
918         lprocfs_counter_init(stats, LPROC_MDT_SYNC, 0, "sync", "reqs");
919         lprocfs_counter_init(stats, LPROC_MDT_SAMEDIR_RENAME, 0,
920                              "samedir_rename", "reqs");
921         lprocfs_counter_init(stats, LPROC_MDT_CROSSDIR_RENAME, 0,
922                              "crossdir_rename", "reqs");
923 }
924
925 int mdt_procfs_init(struct mdt_device *mdt, const char *name)
926 {
927         struct obd_device               *obd = mdt2obd_dev(mdt);
928         int                              rc;
929         ENTRY;
930
931         LASSERT(name != NULL);
932
933         obd->obd_vars = lprocfs_mdt_obd_vars;
934         rc = lprocfs_obd_setup(obd);
935         if (rc) {
936                 CERROR("%s: cannot create proc entries: rc = %d\n",
937                        mdt_obd_name(mdt), rc);
938                 return rc;
939         }
940
941         rc = hsm_cdt_procfs_init(mdt);
942         if (rc) {
943                 CERROR("%s: cannot create hsm proc entries: rc = %d\n",
944                        mdt_obd_name(mdt), rc);
945                 return rc;
946         }
947
948         obd->obd_proc_exports_entry = proc_mkdir("exports",
949                                                  obd->obd_proc_entry);
950         if (obd->obd_proc_exports_entry)
951                 lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
952                                    obd, &mdt_nid_stats_clear_fops);
953         rc = lprocfs_alloc_md_stats(obd, LPROC_MDT_LAST);
954         if (rc)
955                 return rc;
956         mdt_stats_counter_init(obd->obd_md_stats);
957
958         rc = lprocfs_job_stats_init(obd, LPROC_MDT_LAST,
959                                     mdt_stats_counter_init);
960
961         rc = lproc_mdt_attach_rename_seqstat(mdt);
962         if (rc)
963                 CERROR("%s: MDT can not create rename stats rc = %d\n",
964                        mdt_obd_name(mdt), rc);
965
966         RETURN(rc);
967 }
968
969 void mdt_procfs_fini(struct mdt_device *mdt)
970 {
971         struct obd_device *obd = mdt2obd_dev(mdt);
972
973         if (obd->obd_proc_exports_entry != NULL) {
974                 lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
975                 obd->obd_proc_exports_entry = NULL;
976         }
977
978         lprocfs_free_per_client_stats(obd);
979         hsm_cdt_procfs_fini(mdt);
980         lprocfs_obd_cleanup(obd);
981         lprocfs_free_md_stats(obd);
982         lprocfs_free_obd_stats(obd);
983         lprocfs_job_stats_fini(obd);
984 }