Whamcloud - gitweb
688082e09bd4ca7cccb5a20f9af3bd8d14a55d84
[fs/lustre-release.git] / lustre / fid / lproc_fid.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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2015, 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/fid/lproc_fid.c
33  *
34  * Lustre Sequence Manager
35  *
36  * Author: Yury Umanets <umka@clusterfs.com>
37  */
38
39 #define DEBUG_SUBSYSTEM S_FID
40
41 #include <libcfs/libcfs.h>
42 #include <linux/module.h>
43 #include <obd.h>
44 #include <obd_class.h>
45 #include <obd_support.h>
46 #include <lustre_fid.h>
47 #include <lprocfs_status.h>
48 #include "fid_internal.h"
49
50 /* Format: [0x64BIT_INT - 0x64BIT_INT] + 32 bytes just in case */
51 #define MAX_FID_RANGE_STRLEN (32 + 2 * 2 * sizeof(__u64))
52 /**
53  * Reduce the SEQ range allocated to a node to a strict subset of the range
54  * currently-allocated SEQ range.  If the specified range is "clear", then
55  * drop all allocated sequences and request a new one from the master.
56  *
57  * Note: this function should only be used for testing, it is not necessarily
58  * safe for production use.
59  */
60 static int
61 ldebugfs_fid_write_common(const char __user *buffer, size_t count,
62                           struct lu_seq_range *range)
63 {
64         char kernbuf[MAX_FID_RANGE_STRLEN];
65         struct lu_seq_range tmp = {
66                 .lsr_start = 0,
67         };
68         int rc;
69
70         ENTRY;
71         LASSERT(range);
72
73         if (count >= sizeof(kernbuf))
74                 RETURN(-EINVAL);
75
76         if (copy_from_user(kernbuf, buffer, count))
77                 RETURN(-EFAULT);
78
79         kernbuf[count] = 0;
80
81         if (count == 5 && strcmp(kernbuf, "clear") == 0) {
82                 memset(range, 0, sizeof(*range));
83                 RETURN(count);
84         }
85
86         /* of the form "[0x0000000240000400 - 0x000000028000400]" */
87         rc = sscanf(kernbuf, "[%llx - %llx]\n",
88                     (unsigned long long *)&tmp.lsr_start,
89                     (unsigned long long *)&tmp.lsr_end);
90         if (rc != 2)
91                 RETURN(-EINVAL);
92         if (!lu_seq_range_is_sane(&tmp) || lu_seq_range_is_zero(&tmp) ||
93             tmp.lsr_start < range->lsr_start || tmp.lsr_end > range->lsr_end)
94                 RETURN(-EINVAL);
95         *range = tmp;
96         RETURN(0);
97 }
98
99 #ifdef HAVE_SERVER_SUPPORT
100 /*
101  * Server side debugfs stuff.
102  */
103 static ssize_t
104 ldebugfs_server_fid_space_seq_write(struct file *file,
105                                     const char __user *buffer,
106                                     size_t count, loff_t *off)
107 {
108         struct seq_file *m = file->private_data;
109         struct lu_server_seq *seq = m->private;
110         int rc;
111
112         ENTRY;
113
114         mutex_lock(&seq->lss_mutex);
115         rc = ldebugfs_fid_write_common(buffer, count, &seq->lss_space);
116         if (rc == 0) {
117                 CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",
118                        seq->lss_name, PRANGE(&seq->lss_space));
119         }
120         mutex_unlock(&seq->lss_mutex);
121
122         RETURN(count);
123 }
124
125 static int
126 ldebugfs_server_fid_space_seq_show(struct seq_file *m, void *unused)
127 {
128         struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
129         ENTRY;
130
131         mutex_lock(&seq->lss_mutex);
132         seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lss_space));
133         mutex_unlock(&seq->lss_mutex);
134
135         RETURN(0);
136 }
137
138 static int
139 ldebugfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
140 {
141         struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
142         struct client_obd *cli;
143         ENTRY;
144
145         if (seq->lss_cli) {
146                 if (seq->lss_cli->lcs_exp != NULL) {
147                         cli = &seq->lss_cli->lcs_exp->exp_obd->u.cli;
148                         seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
149                 } else {
150                         seq_printf(m, "%s\n", seq->lss_cli->lcs_srv->lss_name);
151                 }
152         } else {
153                 seq_puts(m, "<none>\n");
154         }
155
156         RETURN(0);
157 }
158
159 static ssize_t ldebugfs_server_fid_width_seq_write(struct file *file,
160                                                    const char __user *buffer,
161                                                    size_t count, loff_t *off)
162 {
163         struct seq_file *m = file->private_data;
164         struct lu_server_seq *seq = m->private;
165         int rc;
166
167         ENTRY;
168         mutex_lock(&seq->lss_mutex);
169
170         rc = kstrtoull_from_user(buffer, count, 0, &seq->lss_width);
171         if (rc) {
172                 CERROR("%s: invalid FID sequence width: rc = %d\n",
173                        seq->lss_name, rc);
174                 GOTO(out_unlock, count = rc);
175         }
176
177         CDEBUG(D_INFO, "%s: Width: %llu\n",
178                seq->lss_name, seq->lss_width);
179 out_unlock:
180         mutex_unlock(&seq->lss_mutex);
181
182         RETURN(count);
183 }
184
185 static int
186 ldebugfs_server_fid_width_seq_show(struct seq_file *m, void *unused)
187 {
188         struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
189
190         ENTRY;
191         mutex_lock(&seq->lss_mutex);
192         seq_printf(m, "%llu\n", seq->lss_width);
193         mutex_unlock(&seq->lss_mutex);
194
195         RETURN(0);
196 }
197
198 LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_space);
199 LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_width);
200 LDEBUGFS_SEQ_FOPS_RO(ldebugfs_server_fid_server);
201
202 struct lprocfs_vars seq_server_debugfs_list[] = {
203         { .name =       "space",
204           .fops =       &ldebugfs_server_fid_space_fops },
205         { .name =       "width",
206           .fops =       &ldebugfs_server_fid_width_fops },
207         { .name =       "server",
208           .fops =       &ldebugfs_server_fid_server_fops},
209         { NULL }
210 };
211
212 struct fld_seq_param {
213         struct lu_env           fsp_env;
214         struct dt_it            *fsp_it;
215         struct lu_server_fld    *fsp_fld;
216         struct lu_server_seq    *fsp_seq;
217         unsigned int            fsp_stop:1;
218 };
219
220 /*
221  * XXX: below is a copy of the functions in lustre/fld/lproc_fld.c.
222  * we want to avoid this duplication either by exporting the
223  * functions or merging fid and fld into a single module.
224  */
225 static void *fldb_seq_start(struct seq_file *p, loff_t *pos)
226 {
227         struct fld_seq_param    *param = p->private;
228         struct lu_server_fld    *fld;
229         struct dt_object        *obj;
230         const struct dt_it_ops  *iops;
231         struct dt_key           *key;
232         int                     rc;
233
234         if (param == NULL || param->fsp_stop)
235                 return NULL;
236
237         fld = param->fsp_fld;
238         obj = fld->lsf_obj;
239         LASSERT(obj != NULL);
240         iops = &obj->do_index_ops->dio_it;
241
242         rc = iops->load(&param->fsp_env, param->fsp_it, *pos);
243         if (rc <= 0)
244                 return NULL;
245
246         key = iops->key(&param->fsp_env, param->fsp_it);
247         if (IS_ERR(key))
248                 return NULL;
249
250         *pos = be64_to_cpu(*(__u64 *)key);
251
252         return param;
253 }
254
255 static void fldb_seq_stop(struct seq_file *p, void *v)
256 {
257         struct fld_seq_param    *param = p->private;
258         const struct dt_it_ops  *iops;
259         struct lu_server_fld    *fld;
260         struct dt_object        *obj;
261
262         if (param == NULL)
263                 return;
264
265         fld = param->fsp_fld;
266         obj = fld->lsf_obj;
267         LASSERT(obj != NULL);
268         iops = &obj->do_index_ops->dio_it;
269
270         iops->put(&param->fsp_env, param->fsp_it);
271 }
272
273 static void *fldb_seq_next(struct seq_file *p, void *v, loff_t *pos)
274 {
275         struct fld_seq_param    *param = p->private;
276         struct lu_server_fld    *fld;
277         struct dt_object        *obj;
278         const struct dt_it_ops  *iops;
279         int                     rc;
280
281         if (param == NULL || param->fsp_stop)
282                 return NULL;
283
284         fld = param->fsp_fld;
285         obj = fld->lsf_obj;
286         LASSERT(obj != NULL);
287         iops = &obj->do_index_ops->dio_it;
288
289         rc = iops->next(&param->fsp_env, param->fsp_it);
290         if (rc > 0) {
291                 param->fsp_stop = 1;
292                 return NULL;
293         }
294
295         *pos = be64_to_cpu(*(__u64 *)iops->key(&param->fsp_env, param->fsp_it));
296         return param;
297 }
298
299 static int fldb_seq_show(struct seq_file *p, void *v)
300 {
301         struct fld_seq_param    *param = p->private;
302         struct lu_server_fld    *fld;
303         struct dt_object        *obj;
304         const struct dt_it_ops  *iops;
305         struct lu_seq_range      fld_rec;
306         int                     rc;
307
308         if (param == NULL || param->fsp_stop)
309                 return 0;
310
311         fld = param->fsp_fld;
312         obj = fld->lsf_obj;
313         LASSERT(obj != NULL);
314         iops = &obj->do_index_ops->dio_it;
315
316         rc = iops->rec(&param->fsp_env, param->fsp_it,
317                        (struct dt_rec *)&fld_rec, 0);
318         if (rc != 0) {
319                 CERROR("%s: read record error: rc = %d\n",
320                        fld->lsf_name, rc);
321         } else if (fld_rec.lsr_start != 0) {
322                 range_be_to_cpu(&fld_rec, &fld_rec);
323                 seq_printf(p, DRANGE"\n", PRANGE(&fld_rec));
324         }
325
326         return rc;
327 }
328
329 struct seq_operations fldb_sops = {
330         .start = fldb_seq_start,
331         .stop = fldb_seq_stop,
332         .next = fldb_seq_next,
333         .show = fldb_seq_show,
334 };
335
336 static int fldb_seq_open(struct inode *inode, struct file *file)
337 {
338         struct seq_file         *seq;
339         struct lu_server_seq *ss = inode->i_private;
340         struct lu_server_fld    *fld;
341         struct dt_object        *obj;
342         const struct dt_it_ops  *iops;
343         struct fld_seq_param    *param = NULL;
344         int                     env_init = 0;
345         int                     rc;
346
347         fld = ss->lss_site->ss_server_fld;
348         LASSERT(fld != NULL);
349
350         rc = seq_open(file, &fldb_sops);
351         if (rc)
352                 return rc;
353
354         obj = fld->lsf_obj;
355         if (obj == NULL) {
356                 seq = file->private_data;
357                 seq->private = NULL;
358                 return 0;
359         }
360
361         OBD_ALLOC_PTR(param);
362         if (param == NULL)
363                 GOTO(out, rc = -ENOMEM);
364
365         rc = lu_env_init(&param->fsp_env, LCT_MD_THREAD);
366         if (rc != 0)
367                 GOTO(out, rc);
368
369         env_init = 1;
370         iops = &obj->do_index_ops->dio_it;
371         param->fsp_it = iops->init(&param->fsp_env, obj, 0);
372         if (IS_ERR(param->fsp_it))
373                 GOTO(out, rc = PTR_ERR(param->fsp_it));
374
375         param->fsp_fld = fld;
376         param->fsp_seq = ss;
377         param->fsp_stop = 0;
378
379         seq = file->private_data;
380         seq->private = param;
381 out:
382         if (rc != 0) {
383                 if (env_init == 1)
384                         lu_env_fini(&param->fsp_env);
385                 if (param != NULL)
386                         OBD_FREE_PTR(param);
387         }
388         return rc;
389 }
390
391 static int fldb_seq_release(struct inode *inode, struct file *file)
392 {
393         struct seq_file         *seq = file->private_data;
394         struct fld_seq_param    *param;
395         struct lu_server_fld    *fld;
396         struct dt_object        *obj;
397         const struct dt_it_ops  *iops;
398
399         param = seq->private;
400         if (param == NULL) {
401                 seq_release(inode, file);
402                 return 0;
403         }
404
405         fld = param->fsp_fld;
406         obj = fld->lsf_obj;
407         LASSERT(obj != NULL);
408         iops = &obj->do_index_ops->dio_it;
409
410         LASSERT(iops != NULL);
411         LASSERT(param->fsp_it != NULL);
412         iops->fini(&param->fsp_env, param->fsp_it);
413         lu_env_fini(&param->fsp_env);
414         OBD_FREE_PTR(param);
415         seq_release(inode, file);
416
417         return 0;
418 }
419
420 static ssize_t fldb_seq_write(struct file *file, const char __user *buf,
421                               size_t len, loff_t *off)
422 {
423         struct seq_file         *seq = file->private_data;
424         struct fld_seq_param    *param;
425         struct lu_seq_range      range;
426         int                      rc = 0;
427         char                     _buffer[MAX_FID_RANGE_STRLEN];
428         char                    *buffer = _buffer;
429         ENTRY;
430
431         param = seq->private;
432         if (param == NULL)
433                 RETURN(-EINVAL);
434
435         if (len >= sizeof(_buffer))
436                 RETURN(-EINVAL);
437
438         if (copy_from_user(buffer, buf, len))
439                 GOTO(out, rc = -EFAULT);
440         buffer[len] = 0;
441
442         /*
443          * format - [0x0000000200000007-0x0000000200000008):0:mdt
444          */
445         if (*buffer != '[')
446                 GOTO(out, rc = -EINVAL);
447         buffer++;
448
449         range.lsr_start = simple_strtoull(buffer, &buffer, 0);
450         if (*buffer != '-')
451                 GOTO(out, rc = -EINVAL);
452         buffer++;
453
454         range.lsr_end = simple_strtoull(buffer, &buffer, 0);
455         if (*buffer != ')')
456                 GOTO(out, rc = -EINVAL);
457         buffer++;
458         if (*buffer != ':')
459                 GOTO(out, rc = -EINVAL);
460         buffer++;
461
462         range.lsr_index = simple_strtoul(buffer, &buffer, 0);
463         if (*buffer != ':')
464                 GOTO(out, rc = -EINVAL);
465         buffer++;
466
467         if (strncmp(buffer, "mdt", 3) == 0)
468                 range.lsr_flags = LU_SEQ_RANGE_MDT;
469         else if (strncmp(buffer, "ost", 3) == 0)
470                 range.lsr_flags = LU_SEQ_RANGE_OST;
471         else
472                 GOTO(out, rc = -EINVAL);
473
474         rc = seq_server_alloc_spec(param->fsp_seq->lss_site->ss_control_seq,
475                                    &range, &param->fsp_env);
476
477 out:
478         RETURN(rc < 0 ? rc : len);
479 }
480
481 const struct file_operations seq_fld_debugfs_seq_fops = {
482         .owner   = THIS_MODULE,
483         .open    = fldb_seq_open,
484         .read    = seq_read,
485         .write   = fldb_seq_write,
486         .release = fldb_seq_release,
487 };
488
489 #endif /* HAVE_SERVER_SUPPORT */
490
491 /* Client side debugfs stuff */
492 static ssize_t
493 ldebugfs_client_fid_space_seq_write(struct file *file,
494                                     const char __user *buffer,
495                                     size_t count, loff_t *off)
496 {
497         struct seq_file *m = file->private_data;
498         struct lu_client_seq *seq = m->private;
499         int rc;
500
501         ENTRY;
502
503         mutex_lock(&seq->lcs_mutex);
504         rc = ldebugfs_fid_write_common(buffer, count, &seq->lcs_space);
505         if (rc == 0) {
506                 CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",
507                        seq->lcs_name, PRANGE(&seq->lcs_space));
508         }
509
510         mutex_unlock(&seq->lcs_mutex);
511
512         RETURN(count);
513 }
514
515 static int ldebugfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
516 {
517         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
518
519         ENTRY;
520         mutex_lock(&seq->lcs_mutex);
521         seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lcs_space));
522         mutex_unlock(&seq->lcs_mutex);
523
524         RETURN(0);
525 }
526
527 static ssize_t ldebugfs_client_fid_width_seq_write(struct file *file,
528                                                    const char __user *buffer,
529                                                    size_t count, loff_t *off)
530 {
531         struct seq_file *m = file->private_data;
532         struct lu_client_seq *seq = m->private;
533         u64 val;
534         u64 max;
535         int rc;
536
537         ENTRY;
538         rc = kstrtoull_from_user(buffer, count, 0, &val);
539         if (rc)
540                 return rc;
541
542         mutex_lock(&seq->lcs_mutex);
543         if (seq->lcs_type == LUSTRE_SEQ_DATA)
544                 max = LUSTRE_DATA_SEQ_MAX_WIDTH;
545         else
546                 max = LUSTRE_METADATA_SEQ_MAX_WIDTH;
547
548         if (val <= max) {
549                 seq->lcs_width = val;
550
551                 CDEBUG(D_INFO, "%s: Sequence size: %llu\n", seq->lcs_name,
552                        seq->lcs_width);
553         } else {
554                 count = -ERANGE;
555         }
556
557         mutex_unlock(&seq->lcs_mutex);
558         RETURN(count);
559 }
560
561 static int
562 ldebugfs_client_fid_width_seq_show(struct seq_file *m, void *unused)
563 {
564         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
565
566         ENTRY;
567         mutex_lock(&seq->lcs_mutex);
568         seq_printf(m, "%llu\n", seq->lcs_width);
569         mutex_unlock(&seq->lcs_mutex);
570
571         RETURN(0);
572 }
573
574 static int
575 ldebugfs_client_fid_fid_seq_show(struct seq_file *m, void *unused)
576 {
577         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
578
579         ENTRY;
580         mutex_lock(&seq->lcs_mutex);
581         seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
582         mutex_unlock(&seq->lcs_mutex);
583
584         RETURN(0);
585 }
586
587 static int
588 ldebugfs_client_fid_server_seq_show(struct seq_file *m, void *unused)
589 {
590         struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
591         struct client_obd *cli;
592         ENTRY;
593
594         if (seq->lcs_exp) {
595                 cli = &seq->lcs_exp->exp_obd->u.cli;
596                 seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
597 #ifdef HAVE_SERVER_SUPPORT
598         } else {
599                 seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
600 #endif /* HAVE_SERVER_SUPPORT */
601         }
602
603         RETURN(0);
604 }
605
606 LDEBUGFS_SEQ_FOPS(ldebugfs_client_fid_space);
607 LDEBUGFS_SEQ_FOPS(ldebugfs_client_fid_width);
608 LDEBUGFS_SEQ_FOPS_RO(ldebugfs_client_fid_server);
609 LDEBUGFS_SEQ_FOPS_RO(ldebugfs_client_fid_fid);
610
611 struct lprocfs_vars seq_client_debugfs_list[] = {
612         { .name =       "space",
613           .fops =       &ldebugfs_client_fid_space_fops },
614         { .name =       "width",
615           .fops =       &ldebugfs_client_fid_width_fops },
616         { .name =       "server",
617           .fops =       &ldebugfs_client_fid_server_fops},
618         { .name =       "fid",
619           .fops =       &ldebugfs_client_fid_fid_fops   },
620         { NULL }
621 };