Commit | Line | Data |
---|---|---|
d7e09d03 PT |
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 | |
6a5b99a4 | 18 | * http://www.gnu.org/licenses/gpl-2.0.html |
d7e09d03 | 19 | * |
d7e09d03 PT |
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 | * | |
1dc563a6 | 26 | * Copyright (c) 2012, 2015 Intel Corporation. |
d7e09d03 PT |
27 | */ |
28 | /* | |
29 | * This file is part of Lustre, http://www.lustre.org/ | |
30 | * Lustre is a trademark of Sun Microsystems, Inc. | |
31 | */ | |
32 | #define DEBUG_SUBSYSTEM S_CLASS | |
33 | ||
e8fd99fd | 34 | #include <linux/statfs.h> |
0cf0f7a7 GKH |
35 | #include "../include/lprocfs_status.h" |
36 | #include "../include/obd_class.h" | |
d7e09d03 PT |
37 | #include <linux/seq_file.h> |
38 | #include "lov_internal.h" | |
39 | ||
73bb1da6 | 40 | static int lov_stripesize_seq_show(struct seq_file *m, void *v) |
d7e09d03 | 41 | { |
73bb1da6 | 42 | struct obd_device *dev = (struct obd_device *)m->private; |
d7e09d03 PT |
43 | struct lov_desc *desc; |
44 | ||
00697c43 | 45 | LASSERT(dev); |
d7e09d03 | 46 | desc = &dev->u.lov.desc; |
8faeebdf JP |
47 | seq_printf(m, "%llu\n", desc->ld_default_stripe_size); |
48 | return 0; | |
d7e09d03 PT |
49 | } |
50 | ||
e84962e3 | 51 | static ssize_t lov_stripesize_seq_write(struct file *file, |
f1564f16 OD |
52 | const char __user *buffer, |
53 | size_t count, loff_t *off) | |
d7e09d03 | 54 | { |
73bb1da6 | 55 | struct obd_device *dev = ((struct seq_file *)file->private_data)->private; |
d7e09d03 PT |
56 | struct lov_desc *desc; |
57 | __u64 val; | |
58 | int rc; | |
59 | ||
00697c43 | 60 | LASSERT(dev); |
d7e09d03 PT |
61 | desc = &dev->u.lov.desc; |
62 | rc = lprocfs_write_u64_helper(buffer, count, &val); | |
63 | if (rc) | |
64 | return rc; | |
65 | ||
66 | lov_fix_desc_stripe_size(&val); | |
67 | desc->ld_default_stripe_size = val; | |
68 | return count; | |
69 | } | |
c9f6bb96 | 70 | |
73bb1da6 | 71 | LPROC_SEQ_FOPS(lov_stripesize); |
d7e09d03 | 72 | |
73bb1da6 | 73 | static int lov_stripeoffset_seq_show(struct seq_file *m, void *v) |
d7e09d03 | 74 | { |
73bb1da6 | 75 | struct obd_device *dev = (struct obd_device *)m->private; |
d7e09d03 PT |
76 | struct lov_desc *desc; |
77 | ||
00697c43 | 78 | LASSERT(dev); |
d7e09d03 | 79 | desc = &dev->u.lov.desc; |
8faeebdf JP |
80 | seq_printf(m, "%llu\n", desc->ld_default_stripe_offset); |
81 | return 0; | |
d7e09d03 PT |
82 | } |
83 | ||
e84962e3 | 84 | static ssize_t lov_stripeoffset_seq_write(struct file *file, |
f1564f16 OD |
85 | const char __user *buffer, |
86 | size_t count, loff_t *off) | |
d7e09d03 | 87 | { |
73bb1da6 | 88 | struct obd_device *dev = ((struct seq_file *)file->private_data)->private; |
d7e09d03 PT |
89 | struct lov_desc *desc; |
90 | __u64 val; | |
91 | int rc; | |
92 | ||
00697c43 | 93 | LASSERT(dev); |
d7e09d03 PT |
94 | desc = &dev->u.lov.desc; |
95 | rc = lprocfs_write_u64_helper(buffer, count, &val); | |
96 | if (rc) | |
97 | return rc; | |
98 | ||
99 | desc->ld_default_stripe_offset = val; | |
100 | return count; | |
101 | } | |
c9f6bb96 | 102 | |
73bb1da6 | 103 | LPROC_SEQ_FOPS(lov_stripeoffset); |
d7e09d03 | 104 | |
73bb1da6 | 105 | static int lov_stripetype_seq_show(struct seq_file *m, void *v) |
d7e09d03 | 106 | { |
73bb1da6 | 107 | struct obd_device *dev = (struct obd_device *)m->private; |
d7e09d03 PT |
108 | struct lov_desc *desc; |
109 | ||
00697c43 | 110 | LASSERT(dev); |
d7e09d03 | 111 | desc = &dev->u.lov.desc; |
8faeebdf JP |
112 | seq_printf(m, "%u\n", desc->ld_pattern); |
113 | return 0; | |
d7e09d03 PT |
114 | } |
115 | ||
e84962e3 | 116 | static ssize_t lov_stripetype_seq_write(struct file *file, |
f1564f16 OD |
117 | const char __user *buffer, |
118 | size_t count, loff_t *off) | |
d7e09d03 | 119 | { |
73bb1da6 | 120 | struct obd_device *dev = ((struct seq_file *)file->private_data)->private; |
d7e09d03 PT |
121 | struct lov_desc *desc; |
122 | int val, rc; | |
123 | ||
00697c43 | 124 | LASSERT(dev); |
d7e09d03 PT |
125 | desc = &dev->u.lov.desc; |
126 | rc = lprocfs_write_helper(buffer, count, &val); | |
127 | if (rc) | |
128 | return rc; | |
129 | ||
130 | lov_fix_desc_pattern(&val); | |
131 | desc->ld_pattern = val; | |
132 | return count; | |
133 | } | |
c9f6bb96 | 134 | |
73bb1da6 | 135 | LPROC_SEQ_FOPS(lov_stripetype); |
d7e09d03 | 136 | |
73bb1da6 | 137 | static int lov_stripecount_seq_show(struct seq_file *m, void *v) |
d7e09d03 | 138 | { |
73bb1da6 | 139 | struct obd_device *dev = (struct obd_device *)m->private; |
d7e09d03 PT |
140 | struct lov_desc *desc; |
141 | ||
00697c43 | 142 | LASSERT(dev); |
d7e09d03 | 143 | desc = &dev->u.lov.desc; |
8faeebdf JP |
144 | seq_printf(m, "%d\n", (__s16)(desc->ld_default_stripe_count + 1) - 1); |
145 | return 0; | |
d7e09d03 PT |
146 | } |
147 | ||
e84962e3 | 148 | static ssize_t lov_stripecount_seq_write(struct file *file, |
f1564f16 OD |
149 | const char __user *buffer, |
150 | size_t count, loff_t *off) | |
d7e09d03 | 151 | { |
73bb1da6 | 152 | struct obd_device *dev = ((struct seq_file *)file->private_data)->private; |
d7e09d03 PT |
153 | struct lov_desc *desc; |
154 | int val, rc; | |
155 | ||
00697c43 | 156 | LASSERT(dev); |
d7e09d03 PT |
157 | desc = &dev->u.lov.desc; |
158 | rc = lprocfs_write_helper(buffer, count, &val); | |
159 | if (rc) | |
160 | return rc; | |
161 | ||
162 | lov_fix_desc_stripe_count(&val); | |
163 | desc->ld_default_stripe_count = val; | |
164 | return count; | |
165 | } | |
c9f6bb96 | 166 | |
73bb1da6 | 167 | LPROC_SEQ_FOPS(lov_stripecount); |
d7e09d03 | 168 | |
cb1debff OD |
169 | static ssize_t numobd_show(struct kobject *kobj, struct attribute *attr, |
170 | char *buf) | |
d7e09d03 | 171 | { |
cb1debff OD |
172 | struct obd_device *dev = container_of(kobj, struct obd_device, |
173 | obd_kobj); | |
d7e09d03 PT |
174 | struct lov_desc *desc; |
175 | ||
d7e09d03 | 176 | desc = &dev->u.lov.desc; |
cb1debff | 177 | return sprintf(buf, "%u\n", desc->ld_tgt_count); |
d7e09d03 | 178 | } |
cb1debff | 179 | LUSTRE_RO_ATTR(numobd); |
d7e09d03 | 180 | |
cb1debff OD |
181 | static ssize_t activeobd_show(struct kobject *kobj, struct attribute *attr, |
182 | char *buf) | |
d7e09d03 | 183 | { |
cb1debff OD |
184 | struct obd_device *dev = container_of(kobj, struct obd_device, |
185 | obd_kobj); | |
d7e09d03 PT |
186 | struct lov_desc *desc; |
187 | ||
d7e09d03 | 188 | desc = &dev->u.lov.desc; |
cb1debff | 189 | return sprintf(buf, "%u\n", desc->ld_active_tgt_count); |
d7e09d03 | 190 | } |
cb1debff | 191 | LUSTRE_RO_ATTR(activeobd); |
d7e09d03 | 192 | |
73bb1da6 | 193 | static int lov_desc_uuid_seq_show(struct seq_file *m, void *v) |
d7e09d03 | 194 | { |
73bb1da6 | 195 | struct obd_device *dev = (struct obd_device *)m->private; |
d7e09d03 PT |
196 | struct lov_obd *lov; |
197 | ||
00697c43 | 198 | LASSERT(dev); |
d7e09d03 | 199 | lov = &dev->u.lov; |
8faeebdf JP |
200 | seq_printf(m, "%s\n", lov->desc.ld_uuid.uuid); |
201 | return 0; | |
d7e09d03 | 202 | } |
c9f6bb96 | 203 | |
73bb1da6 | 204 | LPROC_SEQ_FOPS_RO(lov_desc_uuid); |
d7e09d03 PT |
205 | |
206 | static void *lov_tgt_seq_start(struct seq_file *p, loff_t *pos) | |
207 | { | |
208 | struct obd_device *dev = p->private; | |
209 | struct lov_obd *lov = &dev->u.lov; | |
210 | ||
211 | while (*pos < lov->desc.ld_tgt_count) { | |
212 | if (lov->lov_tgts[*pos]) | |
213 | return lov->lov_tgts[*pos]; | |
214 | ++*pos; | |
215 | } | |
216 | return NULL; | |
217 | } | |
218 | ||
219 | static void lov_tgt_seq_stop(struct seq_file *p, void *v) | |
220 | { | |
221 | } | |
222 | ||
223 | static void *lov_tgt_seq_next(struct seq_file *p, void *v, loff_t *pos) | |
224 | { | |
225 | struct obd_device *dev = p->private; | |
226 | struct lov_obd *lov = &dev->u.lov; | |
227 | ||
228 | while (++*pos < lov->desc.ld_tgt_count) { | |
229 | if (lov->lov_tgts[*pos]) | |
230 | return lov->lov_tgts[*pos]; | |
231 | } | |
232 | return NULL; | |
233 | } | |
234 | ||
235 | static int lov_tgt_seq_show(struct seq_file *p, void *v) | |
236 | { | |
237 | struct lov_tgt_desc *tgt = v; | |
8faeebdf JP |
238 | |
239 | seq_printf(p, "%d: %s %sACTIVE\n", | |
240 | tgt->ltd_index, obd_uuid2str(&tgt->ltd_uuid), | |
241 | tgt->ltd_active ? "" : "IN"); | |
242 | return 0; | |
d7e09d03 PT |
243 | } |
244 | ||
12e397cd | 245 | static const struct seq_operations lov_tgt_sops = { |
d7e09d03 PT |
246 | .start = lov_tgt_seq_start, |
247 | .stop = lov_tgt_seq_stop, | |
248 | .next = lov_tgt_seq_next, | |
249 | .show = lov_tgt_seq_show, | |
250 | }; | |
251 | ||
252 | static int lov_target_seq_open(struct inode *inode, struct file *file) | |
253 | { | |
d7e09d03 PT |
254 | struct seq_file *seq; |
255 | int rc; | |
256 | ||
d7e09d03 | 257 | rc = seq_open(file, &lov_tgt_sops); |
73bb1da6 | 258 | if (rc) |
d7e09d03 | 259 | return rc; |
d7e09d03 PT |
260 | |
261 | seq = file->private_data; | |
61e87ab0 | 262 | seq->private = inode->i_private; |
d7e09d03 PT |
263 | return 0; |
264 | } | |
265 | ||
12e397cd | 266 | static struct lprocfs_vars lprocfs_lov_obd_vars[] = { |
33700ac7 DG |
267 | { "stripesize", &lov_stripesize_fops, NULL }, |
268 | { "stripeoffset", &lov_stripeoffset_fops, NULL }, | |
269 | { "stripecount", &lov_stripecount_fops, NULL }, | |
270 | { "stripetype", &lov_stripetype_fops, NULL }, | |
33700ac7 | 271 | /*{ "filegroups", lprocfs_rd_filegroups, NULL, 0 },*/ |
33700ac7 DG |
272 | { "desc_uuid", &lov_desc_uuid_fops, NULL, 0 }, |
273 | { NULL } | |
d7e09d03 PT |
274 | }; |
275 | ||
cb1debff OD |
276 | static struct attribute *lov_attrs[] = { |
277 | &lustre_attr_activeobd.attr, | |
278 | &lustre_attr_numobd.attr, | |
279 | NULL, | |
280 | }; | |
281 | ||
282 | static struct attribute_group lov_attr_group = { | |
283 | .attrs = lov_attrs, | |
284 | }; | |
285 | ||
d7e09d03 PT |
286 | void lprocfs_lov_init_vars(struct lprocfs_static_vars *lvars) |
287 | { | |
cb1debff OD |
288 | lvars->sysfs_vars = &lov_attr_group; |
289 | lvars->obd_vars = lprocfs_lov_obd_vars; | |
d7e09d03 PT |
290 | } |
291 | ||
2c185ffa | 292 | const struct file_operations lov_proc_target_fops = { |
d7e09d03 PT |
293 | .owner = THIS_MODULE, |
294 | .open = lov_target_seq_open, | |
295 | .read = seq_read, | |
296 | .llseek = seq_lseek, | |
297 | .release = lprocfs_seq_release, | |
298 | }; |