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) 2004, 2010, Oracle and/or its affiliates. All rights reserved. | |
24 | * Use is subject to license terms. | |
25 | * | |
26 | * Copyright (c) 2012, 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 | ||
33 | #define DEBUG_SUBSYSTEM S_CLASS | |
34 | ||
d7e09d03 | 35 | #include <linux/seq_file.h> |
588a12d7 | 36 | #include <linux/statfs.h> |
a8c495ac GKH |
37 | #include "../include/lprocfs_status.h" |
38 | #include "../include/obd_class.h" | |
80e17738 | 39 | #include "lmv_internal.h" |
d7e09d03 | 40 | |
b5fa70d7 OD |
41 | static ssize_t numobd_show(struct kobject *kobj, struct attribute *attr, |
42 | char *buf) | |
d7e09d03 | 43 | { |
b5fa70d7 OD |
44 | struct obd_device *dev = container_of(kobj, struct obd_device, |
45 | obd_kobj); | |
46 | struct lmv_desc *desc; | |
d7e09d03 | 47 | |
d7e09d03 | 48 | desc = &dev->u.lmv.desc; |
b5fa70d7 | 49 | return sprintf(buf, "%u\n", desc->ld_tgt_count); |
d7e09d03 | 50 | } |
b5fa70d7 | 51 | LUSTRE_RO_ATTR(numobd); |
d7e09d03 PT |
52 | |
53 | static const char *placement_name[] = { | |
54 | [PLACEMENT_CHAR_POLICY] = "CHAR", | |
55 | [PLACEMENT_NID_POLICY] = "NID", | |
56 | [PLACEMENT_INVAL_POLICY] = "INVAL" | |
57 | }; | |
58 | ||
fe672997 | 59 | static enum placement_policy placement_name2policy(char *name, int len) |
d7e09d03 PT |
60 | { |
61 | int i; | |
62 | ||
63 | for (i = 0; i < PLACEMENT_MAX_POLICY; i++) { | |
64 | if (!strncmp(placement_name[i], name, len)) | |
65 | return i; | |
66 | } | |
67 | return PLACEMENT_INVAL_POLICY; | |
68 | } | |
69 | ||
fe672997 | 70 | static const char *placement_policy2name(enum placement_policy placement) |
d7e09d03 PT |
71 | { |
72 | LASSERT(placement < PLACEMENT_MAX_POLICY); | |
73 | return placement_name[placement]; | |
74 | } | |
75 | ||
b5fa70d7 OD |
76 | static ssize_t placement_show(struct kobject *kobj, struct attribute *attr, |
77 | char *buf) | |
d7e09d03 | 78 | { |
b5fa70d7 OD |
79 | struct obd_device *dev = container_of(kobj, struct obd_device, |
80 | obd_kobj); | |
81 | struct lmv_obd *lmv; | |
d7e09d03 | 82 | |
d7e09d03 | 83 | lmv = &dev->u.lmv; |
b5fa70d7 | 84 | return sprintf(buf, "%s\n", placement_policy2name(lmv->lmv_placement)); |
d7e09d03 PT |
85 | } |
86 | ||
87 | #define MAX_POLICY_STRING_SIZE 64 | |
88 | ||
b5fa70d7 OD |
89 | static ssize_t placement_store(struct kobject *kobj, struct attribute *attr, |
90 | const char *buffer, | |
91 | size_t count) | |
d7e09d03 | 92 | { |
b5fa70d7 OD |
93 | struct obd_device *dev = container_of(kobj, struct obd_device, |
94 | obd_kobj); | |
95 | char dummy[MAX_POLICY_STRING_SIZE + 1]; | |
96 | enum placement_policy policy; | |
97 | struct lmv_obd *lmv = &dev->u.lmv; | |
d7e09d03 | 98 | |
b5fa70d7 | 99 | memcpy(dummy, buffer, MAX_POLICY_STRING_SIZE); |
d7e09d03 | 100 | |
b5fa70d7 OD |
101 | if (count > MAX_POLICY_STRING_SIZE) |
102 | count = MAX_POLICY_STRING_SIZE; | |
d7e09d03 | 103 | |
b5fa70d7 OD |
104 | if (dummy[count - 1] == '\n') |
105 | count--; | |
106 | dummy[count] = '\0'; | |
d7e09d03 | 107 | |
b5fa70d7 | 108 | policy = placement_name2policy(dummy, count); |
d7e09d03 PT |
109 | if (policy != PLACEMENT_INVAL_POLICY) { |
110 | spin_lock(&lmv->lmv_lock); | |
111 | lmv->lmv_placement = policy; | |
112 | spin_unlock(&lmv->lmv_lock); | |
113 | } else { | |
d7e09d03 PT |
114 | return -EINVAL; |
115 | } | |
116 | return count; | |
117 | } | |
b5fa70d7 | 118 | LUSTRE_RW_ATTR(placement); |
d7e09d03 | 119 | |
b5fa70d7 OD |
120 | static ssize_t activeobd_show(struct kobject *kobj, struct attribute *attr, |
121 | char *buf) | |
d7e09d03 | 122 | { |
b5fa70d7 OD |
123 | struct obd_device *dev = container_of(kobj, struct obd_device, |
124 | obd_kobj); | |
125 | struct lmv_desc *desc; | |
d7e09d03 | 126 | |
d7e09d03 | 127 | desc = &dev->u.lmv.desc; |
b5fa70d7 | 128 | return sprintf(buf, "%u\n", desc->ld_active_tgt_count); |
d7e09d03 | 129 | } |
b5fa70d7 | 130 | LUSTRE_RO_ATTR(activeobd); |
d7e09d03 | 131 | |
73bb1da6 | 132 | static int lmv_desc_uuid_seq_show(struct seq_file *m, void *v) |
d7e09d03 | 133 | { |
73bb1da6 | 134 | struct obd_device *dev = (struct obd_device *)m->private; |
d7e09d03 PT |
135 | struct lmv_obd *lmv; |
136 | ||
2cbdaa45 | 137 | LASSERT(dev); |
d7e09d03 | 138 | lmv = &dev->u.lmv; |
8faeebdf JP |
139 | seq_printf(m, "%s\n", lmv->desc.ld_uuid.uuid); |
140 | return 0; | |
d7e09d03 | 141 | } |
c9f6bb96 | 142 | |
73bb1da6 | 143 | LPROC_SEQ_FOPS_RO(lmv_desc_uuid); |
d7e09d03 PT |
144 | |
145 | static void *lmv_tgt_seq_start(struct seq_file *p, loff_t *pos) | |
146 | { | |
147 | struct obd_device *dev = p->private; | |
148 | struct lmv_obd *lmv = &dev->u.lmv; | |
50ffcb7e | 149 | |
d7e09d03 PT |
150 | return (*pos >= lmv->desc.ld_tgt_count) ? NULL : lmv->tgts[*pos]; |
151 | } | |
152 | ||
153 | static void lmv_tgt_seq_stop(struct seq_file *p, void *v) | |
154 | { | |
155 | return; | |
156 | } | |
157 | ||
158 | static void *lmv_tgt_seq_next(struct seq_file *p, void *v, loff_t *pos) | |
159 | { | |
160 | struct obd_device *dev = p->private; | |
161 | struct lmv_obd *lmv = &dev->u.lmv; | |
162 | ++*pos; | |
163 | return (*pos >= lmv->desc.ld_tgt_count) ? NULL : lmv->tgts[*pos]; | |
164 | } | |
165 | ||
166 | static int lmv_tgt_seq_show(struct seq_file *p, void *v) | |
167 | { | |
168 | struct lmv_tgt_desc *tgt = v; | |
169 | ||
2cbdaa45 | 170 | if (!tgt) |
d7e09d03 | 171 | return 0; |
8faeebdf JP |
172 | seq_printf(p, "%d: %s %sACTIVE\n", |
173 | tgt->ltd_idx, tgt->ltd_uuid.uuid, | |
174 | tgt->ltd_active ? "" : "IN"); | |
175 | return 0; | |
d7e09d03 PT |
176 | } |
177 | ||
02b31079 | 178 | static const struct seq_operations lmv_tgt_sops = { |
d7e09d03 PT |
179 | .start = lmv_tgt_seq_start, |
180 | .stop = lmv_tgt_seq_stop, | |
181 | .next = lmv_tgt_seq_next, | |
182 | .show = lmv_tgt_seq_show, | |
183 | }; | |
184 | ||
185 | static int lmv_target_seq_open(struct inode *inode, struct file *file) | |
186 | { | |
d7e09d03 PT |
187 | struct seq_file *seq; |
188 | int rc; | |
189 | ||
190 | rc = seq_open(file, &lmv_tgt_sops); | |
191 | if (rc) | |
192 | return rc; | |
193 | ||
194 | seq = file->private_data; | |
61e87ab0 | 195 | seq->private = inode->i_private; |
d7e09d03 PT |
196 | |
197 | return 0; | |
198 | } | |
199 | ||
5dc8d7b4 | 200 | static struct lprocfs_vars lprocfs_lmv_obd_vars[] = { |
f5e8269b JG |
201 | { "desc_uuid", &lmv_desc_uuid_fops, NULL, 0 }, |
202 | { NULL } | |
d7e09d03 PT |
203 | }; |
204 | ||
d6e7a2fe | 205 | const struct file_operations lmv_proc_target_fops = { |
d7e09d03 PT |
206 | .owner = THIS_MODULE, |
207 | .open = lmv_target_seq_open, | |
208 | .read = seq_read, | |
209 | .llseek = seq_lseek, | |
210 | .release = seq_release, | |
211 | }; | |
212 | ||
b5fa70d7 OD |
213 | static struct attribute *lmv_attrs[] = { |
214 | &lustre_attr_activeobd.attr, | |
215 | &lustre_attr_numobd.attr, | |
216 | &lustre_attr_placement.attr, | |
217 | NULL, | |
218 | }; | |
219 | ||
220 | static struct attribute_group lmv_attr_group = { | |
221 | .attrs = lmv_attrs, | |
222 | }; | |
223 | ||
d7e09d03 PT |
224 | void lprocfs_lmv_init_vars(struct lprocfs_static_vars *lvars) |
225 | { | |
b5fa70d7 | 226 | lvars->sysfs_vars = &lmv_attr_group; |
d7e09d03 PT |
227 | lvars->obd_vars = lprocfs_lmv_obd_vars; |
228 | } |