Commit | Line | Data |
---|---|---|
aebe17f6 VD |
1 | /* |
2 | * sysfs.c - sysfs support implementation. | |
3 | * | |
4 | * Copyright (C) 2005-2014 Nippon Telegraph and Telephone Corporation. | |
5 | * Copyright (C) 2014 HGST, Inc., a Western Digital Company. | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * Written by Vyacheslav Dubeyko <Vyacheslav.Dubeyko@hgst.com> | |
18 | */ | |
19 | ||
20 | #include <linux/kobject.h> | |
21 | ||
22 | #include "nilfs.h" | |
23 | #include "mdt.h" | |
24 | #include "sufile.h" | |
25 | #include "cpfile.h" | |
26 | #include "sysfs.h" | |
27 | ||
28 | /* /sys/fs/<nilfs>/ */ | |
29 | static struct kset *nilfs_kset; | |
30 | ||
31 | #define NILFS_SHOW_TIME(time_t_val, buf) ({ \ | |
32 | struct tm res; \ | |
33 | int count = 0; \ | |
34 | time_to_tm(time_t_val, 0, &res); \ | |
35 | res.tm_year += 1900; \ | |
36 | res.tm_mon += 1; \ | |
37 | count = scnprintf(buf, PAGE_SIZE, \ | |
38 | "%ld-%.2d-%.2d %.2d:%.2d:%.2d\n", \ | |
39 | res.tm_year, res.tm_mon, res.tm_mday, \ | |
40 | res.tm_hour, res.tm_min, res.tm_sec);\ | |
41 | count; \ | |
42 | }) | |
43 | ||
caa05d49 VD |
44 | #define NILFS_DEV_INT_GROUP_OPS(name, parent_name) \ |
45 | static ssize_t nilfs_##name##_attr_show(struct kobject *kobj, \ | |
46 | struct attribute *attr, char *buf) \ | |
47 | { \ | |
48 | struct the_nilfs *nilfs = container_of(kobj->parent, \ | |
49 | struct the_nilfs, \ | |
50 | ns_##parent_name##_kobj); \ | |
51 | struct nilfs_##name##_attr *a = container_of(attr, \ | |
52 | struct nilfs_##name##_attr, \ | |
53 | attr); \ | |
54 | return a->show ? a->show(a, nilfs, buf) : 0; \ | |
55 | } \ | |
56 | static ssize_t nilfs_##name##_attr_store(struct kobject *kobj, \ | |
57 | struct attribute *attr, \ | |
58 | const char *buf, size_t len) \ | |
59 | { \ | |
60 | struct the_nilfs *nilfs = container_of(kobj->parent, \ | |
61 | struct the_nilfs, \ | |
62 | ns_##parent_name##_kobj); \ | |
63 | struct nilfs_##name##_attr *a = container_of(attr, \ | |
64 | struct nilfs_##name##_attr, \ | |
65 | attr); \ | |
66 | return a->store ? a->store(a, nilfs, buf, len) : 0; \ | |
67 | } \ | |
68 | static const struct sysfs_ops nilfs_##name##_attr_ops = { \ | |
69 | .show = nilfs_##name##_attr_show, \ | |
70 | .store = nilfs_##name##_attr_store, \ | |
71 | }; | |
72 | ||
73 | #define NILFS_DEV_INT_GROUP_TYPE(name, parent_name) \ | |
74 | static void nilfs_##name##_attr_release(struct kobject *kobj) \ | |
75 | { \ | |
76 | struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \ | |
77 | struct the_nilfs *nilfs = container_of(kobj->parent, \ | |
78 | struct the_nilfs, \ | |
79 | ns_##parent_name##_kobj); \ | |
80 | subgroups = nilfs->ns_##parent_name##_subgroups; \ | |
81 | complete(&subgroups->sg_##name##_kobj_unregister); \ | |
82 | } \ | |
83 | static struct kobj_type nilfs_##name##_ktype = { \ | |
84 | .default_attrs = nilfs_##name##_attrs, \ | |
85 | .sysfs_ops = &nilfs_##name##_attr_ops, \ | |
86 | .release = nilfs_##name##_attr_release, \ | |
87 | }; | |
88 | ||
89 | #define NILFS_DEV_INT_GROUP_FNS(name, parent_name) \ | |
dd70edbd | 90 | static int nilfs_sysfs_create_##name##_group(struct the_nilfs *nilfs) \ |
caa05d49 VD |
91 | { \ |
92 | struct kobject *parent; \ | |
93 | struct kobject *kobj; \ | |
94 | struct completion *kobj_unregister; \ | |
95 | struct nilfs_sysfs_##parent_name##_subgroups *subgroups; \ | |
96 | int err; \ | |
97 | subgroups = nilfs->ns_##parent_name##_subgroups; \ | |
98 | kobj = &subgroups->sg_##name##_kobj; \ | |
99 | kobj_unregister = &subgroups->sg_##name##_kobj_unregister; \ | |
100 | parent = &nilfs->ns_##parent_name##_kobj; \ | |
101 | kobj->kset = nilfs_kset; \ | |
102 | init_completion(kobj_unregister); \ | |
103 | err = kobject_init_and_add(kobj, &nilfs_##name##_ktype, parent, \ | |
104 | #name); \ | |
105 | if (err) \ | |
106 | return err; \ | |
107 | return 0; \ | |
108 | } \ | |
dd70edbd | 109 | static void nilfs_sysfs_delete_##name##_group(struct the_nilfs *nilfs) \ |
caa05d49 VD |
110 | { \ |
111 | kobject_del(&nilfs->ns_##parent_name##_subgroups->sg_##name##_kobj); \ | |
112 | } | |
113 | ||
a5a7332a VD |
114 | /************************************************************************ |
115 | * NILFS snapshot attrs * | |
116 | ************************************************************************/ | |
117 | ||
118 | static ssize_t | |
119 | nilfs_snapshot_inodes_count_show(struct nilfs_snapshot_attr *attr, | |
120 | struct nilfs_root *root, char *buf) | |
121 | { | |
122 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
123 | (unsigned long long)atomic64_read(&root->inodes_count)); | |
124 | } | |
125 | ||
126 | static ssize_t | |
127 | nilfs_snapshot_blocks_count_show(struct nilfs_snapshot_attr *attr, | |
128 | struct nilfs_root *root, char *buf) | |
129 | { | |
130 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
131 | (unsigned long long)atomic64_read(&root->blocks_count)); | |
132 | } | |
133 | ||
134 | static const char snapshot_readme_str[] = | |
135 | "The group contains details about mounted snapshot.\n\n" | |
136 | "(1) inodes_count\n\tshow number of inodes for snapshot.\n\n" | |
137 | "(2) blocks_count\n\tshow number of blocks for snapshot.\n\n"; | |
138 | ||
139 | static ssize_t | |
140 | nilfs_snapshot_README_show(struct nilfs_snapshot_attr *attr, | |
141 | struct nilfs_root *root, char *buf) | |
142 | { | |
143 | return snprintf(buf, PAGE_SIZE, snapshot_readme_str); | |
144 | } | |
145 | ||
146 | NILFS_SNAPSHOT_RO_ATTR(inodes_count); | |
147 | NILFS_SNAPSHOT_RO_ATTR(blocks_count); | |
148 | NILFS_SNAPSHOT_RO_ATTR(README); | |
149 | ||
150 | static struct attribute *nilfs_snapshot_attrs[] = { | |
151 | NILFS_SNAPSHOT_ATTR_LIST(inodes_count), | |
152 | NILFS_SNAPSHOT_ATTR_LIST(blocks_count), | |
153 | NILFS_SNAPSHOT_ATTR_LIST(README), | |
154 | NULL, | |
155 | }; | |
156 | ||
157 | static ssize_t nilfs_snapshot_attr_show(struct kobject *kobj, | |
158 | struct attribute *attr, char *buf) | |
159 | { | |
160 | struct nilfs_root *root = | |
161 | container_of(kobj, struct nilfs_root, snapshot_kobj); | |
162 | struct nilfs_snapshot_attr *a = | |
163 | container_of(attr, struct nilfs_snapshot_attr, attr); | |
164 | ||
165 | return a->show ? a->show(a, root, buf) : 0; | |
166 | } | |
167 | ||
168 | static ssize_t nilfs_snapshot_attr_store(struct kobject *kobj, | |
169 | struct attribute *attr, | |
170 | const char *buf, size_t len) | |
171 | { | |
172 | struct nilfs_root *root = | |
173 | container_of(kobj, struct nilfs_root, snapshot_kobj); | |
174 | struct nilfs_snapshot_attr *a = | |
175 | container_of(attr, struct nilfs_snapshot_attr, attr); | |
176 | ||
177 | return a->store ? a->store(a, root, buf, len) : 0; | |
178 | } | |
179 | ||
180 | static void nilfs_snapshot_attr_release(struct kobject *kobj) | |
181 | { | |
182 | struct nilfs_root *root = container_of(kobj, struct nilfs_root, | |
183 | snapshot_kobj); | |
184 | complete(&root->snapshot_kobj_unregister); | |
185 | } | |
186 | ||
187 | static const struct sysfs_ops nilfs_snapshot_attr_ops = { | |
188 | .show = nilfs_snapshot_attr_show, | |
189 | .store = nilfs_snapshot_attr_store, | |
190 | }; | |
191 | ||
192 | static struct kobj_type nilfs_snapshot_ktype = { | |
193 | .default_attrs = nilfs_snapshot_attrs, | |
194 | .sysfs_ops = &nilfs_snapshot_attr_ops, | |
195 | .release = nilfs_snapshot_attr_release, | |
196 | }; | |
197 | ||
198 | int nilfs_sysfs_create_snapshot_group(struct nilfs_root *root) | |
199 | { | |
200 | struct the_nilfs *nilfs; | |
201 | struct kobject *parent; | |
202 | int err; | |
203 | ||
204 | nilfs = root->nilfs; | |
205 | parent = &nilfs->ns_dev_subgroups->sg_mounted_snapshots_kobj; | |
206 | root->snapshot_kobj.kset = nilfs_kset; | |
207 | init_completion(&root->snapshot_kobj_unregister); | |
208 | ||
209 | if (root->cno == NILFS_CPTREE_CURRENT_CNO) { | |
210 | err = kobject_init_and_add(&root->snapshot_kobj, | |
211 | &nilfs_snapshot_ktype, | |
212 | &nilfs->ns_dev_kobj, | |
213 | "current_checkpoint"); | |
214 | } else { | |
215 | err = kobject_init_and_add(&root->snapshot_kobj, | |
216 | &nilfs_snapshot_ktype, | |
217 | parent, | |
218 | "%llu", root->cno); | |
219 | } | |
220 | ||
221 | if (err) | |
222 | return err; | |
223 | ||
224 | return 0; | |
225 | } | |
226 | ||
227 | void nilfs_sysfs_delete_snapshot_group(struct nilfs_root *root) | |
228 | { | |
229 | kobject_del(&root->snapshot_kobj); | |
230 | } | |
231 | ||
a2ecb791 VD |
232 | /************************************************************************ |
233 | * NILFS mounted snapshots attrs * | |
234 | ************************************************************************/ | |
235 | ||
236 | static const char mounted_snapshots_readme_str[] = | |
237 | "The mounted_snapshots group contains group for\n" | |
238 | "every mounted snapshot.\n"; | |
239 | ||
240 | static ssize_t | |
241 | nilfs_mounted_snapshots_README_show(struct nilfs_mounted_snapshots_attr *attr, | |
242 | struct the_nilfs *nilfs, char *buf) | |
243 | { | |
244 | return snprintf(buf, PAGE_SIZE, mounted_snapshots_readme_str); | |
245 | } | |
246 | ||
247 | NILFS_MOUNTED_SNAPSHOTS_RO_ATTR(README); | |
248 | ||
249 | static struct attribute *nilfs_mounted_snapshots_attrs[] = { | |
250 | NILFS_MOUNTED_SNAPSHOTS_ATTR_LIST(README), | |
251 | NULL, | |
252 | }; | |
253 | ||
254 | NILFS_DEV_INT_GROUP_OPS(mounted_snapshots, dev); | |
255 | NILFS_DEV_INT_GROUP_TYPE(mounted_snapshots, dev); | |
256 | NILFS_DEV_INT_GROUP_FNS(mounted_snapshots, dev); | |
257 | ||
02a0ba1c VD |
258 | /************************************************************************ |
259 | * NILFS checkpoints attrs * | |
260 | ************************************************************************/ | |
261 | ||
262 | static ssize_t | |
263 | nilfs_checkpoints_checkpoints_number_show(struct nilfs_checkpoints_attr *attr, | |
264 | struct the_nilfs *nilfs, | |
265 | char *buf) | |
266 | { | |
267 | __u64 ncheckpoints; | |
268 | struct nilfs_cpstat cpstat; | |
269 | int err; | |
270 | ||
271 | down_read(&nilfs->ns_segctor_sem); | |
272 | err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat); | |
273 | up_read(&nilfs->ns_segctor_sem); | |
274 | if (err < 0) { | |
275 | printk(KERN_ERR "NILFS: unable to get checkpoint stat: err=%d\n", | |
276 | err); | |
277 | return err; | |
278 | } | |
279 | ||
280 | ncheckpoints = cpstat.cs_ncps; | |
281 | ||
282 | return snprintf(buf, PAGE_SIZE, "%llu\n", ncheckpoints); | |
283 | } | |
284 | ||
285 | static ssize_t | |
286 | nilfs_checkpoints_snapshots_number_show(struct nilfs_checkpoints_attr *attr, | |
287 | struct the_nilfs *nilfs, | |
288 | char *buf) | |
289 | { | |
290 | __u64 nsnapshots; | |
291 | struct nilfs_cpstat cpstat; | |
292 | int err; | |
293 | ||
294 | down_read(&nilfs->ns_segctor_sem); | |
295 | err = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat); | |
296 | up_read(&nilfs->ns_segctor_sem); | |
297 | if (err < 0) { | |
298 | printk(KERN_ERR "NILFS: unable to get checkpoint stat: err=%d\n", | |
299 | err); | |
300 | return err; | |
301 | } | |
302 | ||
303 | nsnapshots = cpstat.cs_nsss; | |
304 | ||
305 | return snprintf(buf, PAGE_SIZE, "%llu\n", nsnapshots); | |
306 | } | |
307 | ||
308 | static ssize_t | |
309 | nilfs_checkpoints_last_seg_checkpoint_show(struct nilfs_checkpoints_attr *attr, | |
310 | struct the_nilfs *nilfs, | |
311 | char *buf) | |
312 | { | |
313 | __u64 last_cno; | |
314 | ||
315 | spin_lock(&nilfs->ns_last_segment_lock); | |
316 | last_cno = nilfs->ns_last_cno; | |
317 | spin_unlock(&nilfs->ns_last_segment_lock); | |
318 | ||
319 | return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno); | |
320 | } | |
321 | ||
322 | static ssize_t | |
323 | nilfs_checkpoints_next_checkpoint_show(struct nilfs_checkpoints_attr *attr, | |
324 | struct the_nilfs *nilfs, | |
325 | char *buf) | |
326 | { | |
327 | __u64 cno; | |
328 | ||
329 | down_read(&nilfs->ns_sem); | |
330 | cno = nilfs->ns_cno; | |
331 | up_read(&nilfs->ns_sem); | |
332 | ||
333 | return snprintf(buf, PAGE_SIZE, "%llu\n", cno); | |
334 | } | |
335 | ||
336 | static const char checkpoints_readme_str[] = | |
337 | "The checkpoints group contains attributes that describe\n" | |
338 | "details about volume's checkpoints.\n\n" | |
339 | "(1) checkpoints_number\n\tshow number of checkpoints on volume.\n\n" | |
340 | "(2) snapshots_number\n\tshow number of snapshots on volume.\n\n" | |
341 | "(3) last_seg_checkpoint\n" | |
342 | "\tshow checkpoint number of the latest segment.\n\n" | |
343 | "(4) next_checkpoint\n\tshow next checkpoint number.\n\n"; | |
344 | ||
345 | static ssize_t | |
346 | nilfs_checkpoints_README_show(struct nilfs_checkpoints_attr *attr, | |
347 | struct the_nilfs *nilfs, char *buf) | |
348 | { | |
349 | return snprintf(buf, PAGE_SIZE, checkpoints_readme_str); | |
350 | } | |
351 | ||
352 | NILFS_CHECKPOINTS_RO_ATTR(checkpoints_number); | |
353 | NILFS_CHECKPOINTS_RO_ATTR(snapshots_number); | |
354 | NILFS_CHECKPOINTS_RO_ATTR(last_seg_checkpoint); | |
355 | NILFS_CHECKPOINTS_RO_ATTR(next_checkpoint); | |
356 | NILFS_CHECKPOINTS_RO_ATTR(README); | |
357 | ||
358 | static struct attribute *nilfs_checkpoints_attrs[] = { | |
359 | NILFS_CHECKPOINTS_ATTR_LIST(checkpoints_number), | |
360 | NILFS_CHECKPOINTS_ATTR_LIST(snapshots_number), | |
361 | NILFS_CHECKPOINTS_ATTR_LIST(last_seg_checkpoint), | |
362 | NILFS_CHECKPOINTS_ATTR_LIST(next_checkpoint), | |
363 | NILFS_CHECKPOINTS_ATTR_LIST(README), | |
364 | NULL, | |
365 | }; | |
366 | ||
367 | NILFS_DEV_INT_GROUP_OPS(checkpoints, dev); | |
368 | NILFS_DEV_INT_GROUP_TYPE(checkpoints, dev); | |
369 | NILFS_DEV_INT_GROUP_FNS(checkpoints, dev); | |
370 | ||
ef43d5cd VD |
371 | /************************************************************************ |
372 | * NILFS segments attrs * | |
373 | ************************************************************************/ | |
374 | ||
375 | static ssize_t | |
376 | nilfs_segments_segments_number_show(struct nilfs_segments_attr *attr, | |
377 | struct the_nilfs *nilfs, | |
378 | char *buf) | |
379 | { | |
380 | return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_nsegments); | |
381 | } | |
382 | ||
383 | static ssize_t | |
384 | nilfs_segments_blocks_per_segment_show(struct nilfs_segments_attr *attr, | |
385 | struct the_nilfs *nilfs, | |
386 | char *buf) | |
387 | { | |
388 | return snprintf(buf, PAGE_SIZE, "%lu\n", nilfs->ns_blocks_per_segment); | |
389 | } | |
390 | ||
391 | static ssize_t | |
392 | nilfs_segments_clean_segments_show(struct nilfs_segments_attr *attr, | |
393 | struct the_nilfs *nilfs, | |
394 | char *buf) | |
395 | { | |
396 | unsigned long ncleansegs; | |
397 | ||
398 | down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); | |
399 | ncleansegs = nilfs_sufile_get_ncleansegs(nilfs->ns_sufile); | |
400 | up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); | |
401 | ||
402 | return snprintf(buf, PAGE_SIZE, "%lu\n", ncleansegs); | |
403 | } | |
404 | ||
405 | static ssize_t | |
406 | nilfs_segments_dirty_segments_show(struct nilfs_segments_attr *attr, | |
407 | struct the_nilfs *nilfs, | |
408 | char *buf) | |
409 | { | |
410 | struct nilfs_sustat sustat; | |
411 | int err; | |
412 | ||
413 | down_read(&nilfs->ns_segctor_sem); | |
414 | err = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat); | |
415 | up_read(&nilfs->ns_segctor_sem); | |
416 | if (err < 0) { | |
417 | printk(KERN_ERR "NILFS: unable to get segment stat: err=%d\n", | |
418 | err); | |
419 | return err; | |
420 | } | |
421 | ||
422 | return snprintf(buf, PAGE_SIZE, "%llu\n", sustat.ss_ndirtysegs); | |
423 | } | |
424 | ||
425 | static const char segments_readme_str[] = | |
426 | "The segments group contains attributes that describe\n" | |
427 | "details about volume's segments.\n\n" | |
428 | "(1) segments_number\n\tshow number of segments on volume.\n\n" | |
429 | "(2) blocks_per_segment\n\tshow number of blocks in segment.\n\n" | |
430 | "(3) clean_segments\n\tshow count of clean segments.\n\n" | |
431 | "(4) dirty_segments\n\tshow count of dirty segments.\n\n"; | |
432 | ||
433 | static ssize_t | |
434 | nilfs_segments_README_show(struct nilfs_segments_attr *attr, | |
435 | struct the_nilfs *nilfs, | |
436 | char *buf) | |
437 | { | |
438 | return snprintf(buf, PAGE_SIZE, segments_readme_str); | |
439 | } | |
440 | ||
441 | NILFS_SEGMENTS_RO_ATTR(segments_number); | |
442 | NILFS_SEGMENTS_RO_ATTR(blocks_per_segment); | |
443 | NILFS_SEGMENTS_RO_ATTR(clean_segments); | |
444 | NILFS_SEGMENTS_RO_ATTR(dirty_segments); | |
445 | NILFS_SEGMENTS_RO_ATTR(README); | |
446 | ||
447 | static struct attribute *nilfs_segments_attrs[] = { | |
448 | NILFS_SEGMENTS_ATTR_LIST(segments_number), | |
449 | NILFS_SEGMENTS_ATTR_LIST(blocks_per_segment), | |
450 | NILFS_SEGMENTS_ATTR_LIST(clean_segments), | |
451 | NILFS_SEGMENTS_ATTR_LIST(dirty_segments), | |
452 | NILFS_SEGMENTS_ATTR_LIST(README), | |
453 | NULL, | |
454 | }; | |
455 | ||
456 | NILFS_DEV_INT_GROUP_OPS(segments, dev); | |
457 | NILFS_DEV_INT_GROUP_TYPE(segments, dev); | |
458 | NILFS_DEV_INT_GROUP_FNS(segments, dev); | |
459 | ||
abc968db VD |
460 | /************************************************************************ |
461 | * NILFS segctor attrs * | |
462 | ************************************************************************/ | |
463 | ||
464 | static ssize_t | |
465 | nilfs_segctor_last_pseg_block_show(struct nilfs_segctor_attr *attr, | |
466 | struct the_nilfs *nilfs, | |
467 | char *buf) | |
468 | { | |
469 | sector_t last_pseg; | |
470 | ||
471 | spin_lock(&nilfs->ns_last_segment_lock); | |
472 | last_pseg = nilfs->ns_last_pseg; | |
473 | spin_unlock(&nilfs->ns_last_segment_lock); | |
474 | ||
475 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
476 | (unsigned long long)last_pseg); | |
477 | } | |
478 | ||
479 | static ssize_t | |
480 | nilfs_segctor_last_seg_sequence_show(struct nilfs_segctor_attr *attr, | |
481 | struct the_nilfs *nilfs, | |
482 | char *buf) | |
483 | { | |
484 | u64 last_seq; | |
485 | ||
486 | spin_lock(&nilfs->ns_last_segment_lock); | |
487 | last_seq = nilfs->ns_last_seq; | |
488 | spin_unlock(&nilfs->ns_last_segment_lock); | |
489 | ||
490 | return snprintf(buf, PAGE_SIZE, "%llu\n", last_seq); | |
491 | } | |
492 | ||
493 | static ssize_t | |
494 | nilfs_segctor_last_seg_checkpoint_show(struct nilfs_segctor_attr *attr, | |
495 | struct the_nilfs *nilfs, | |
496 | char *buf) | |
497 | { | |
498 | __u64 last_cno; | |
499 | ||
500 | spin_lock(&nilfs->ns_last_segment_lock); | |
501 | last_cno = nilfs->ns_last_cno; | |
502 | spin_unlock(&nilfs->ns_last_segment_lock); | |
503 | ||
504 | return snprintf(buf, PAGE_SIZE, "%llu\n", last_cno); | |
505 | } | |
506 | ||
507 | static ssize_t | |
508 | nilfs_segctor_current_seg_sequence_show(struct nilfs_segctor_attr *attr, | |
509 | struct the_nilfs *nilfs, | |
510 | char *buf) | |
511 | { | |
512 | u64 seg_seq; | |
513 | ||
514 | down_read(&nilfs->ns_sem); | |
515 | seg_seq = nilfs->ns_seg_seq; | |
516 | up_read(&nilfs->ns_sem); | |
517 | ||
518 | return snprintf(buf, PAGE_SIZE, "%llu\n", seg_seq); | |
519 | } | |
520 | ||
521 | static ssize_t | |
522 | nilfs_segctor_current_last_full_seg_show(struct nilfs_segctor_attr *attr, | |
523 | struct the_nilfs *nilfs, | |
524 | char *buf) | |
525 | { | |
526 | __u64 segnum; | |
527 | ||
528 | down_read(&nilfs->ns_sem); | |
529 | segnum = nilfs->ns_segnum; | |
530 | up_read(&nilfs->ns_sem); | |
531 | ||
532 | return snprintf(buf, PAGE_SIZE, "%llu\n", segnum); | |
533 | } | |
534 | ||
535 | static ssize_t | |
536 | nilfs_segctor_next_full_seg_show(struct nilfs_segctor_attr *attr, | |
537 | struct the_nilfs *nilfs, | |
538 | char *buf) | |
539 | { | |
540 | __u64 nextnum; | |
541 | ||
542 | down_read(&nilfs->ns_sem); | |
543 | nextnum = nilfs->ns_nextnum; | |
544 | up_read(&nilfs->ns_sem); | |
545 | ||
546 | return snprintf(buf, PAGE_SIZE, "%llu\n", nextnum); | |
547 | } | |
548 | ||
549 | static ssize_t | |
550 | nilfs_segctor_next_pseg_offset_show(struct nilfs_segctor_attr *attr, | |
551 | struct the_nilfs *nilfs, | |
552 | char *buf) | |
553 | { | |
554 | unsigned long pseg_offset; | |
555 | ||
556 | down_read(&nilfs->ns_sem); | |
557 | pseg_offset = nilfs->ns_pseg_offset; | |
558 | up_read(&nilfs->ns_sem); | |
559 | ||
560 | return snprintf(buf, PAGE_SIZE, "%lu\n", pseg_offset); | |
561 | } | |
562 | ||
563 | static ssize_t | |
564 | nilfs_segctor_next_checkpoint_show(struct nilfs_segctor_attr *attr, | |
565 | struct the_nilfs *nilfs, | |
566 | char *buf) | |
567 | { | |
568 | __u64 cno; | |
569 | ||
570 | down_read(&nilfs->ns_sem); | |
571 | cno = nilfs->ns_cno; | |
572 | up_read(&nilfs->ns_sem); | |
573 | ||
574 | return snprintf(buf, PAGE_SIZE, "%llu\n", cno); | |
575 | } | |
576 | ||
577 | static ssize_t | |
578 | nilfs_segctor_last_seg_write_time_show(struct nilfs_segctor_attr *attr, | |
579 | struct the_nilfs *nilfs, | |
580 | char *buf) | |
581 | { | |
582 | time_t ctime; | |
583 | ||
584 | down_read(&nilfs->ns_sem); | |
585 | ctime = nilfs->ns_ctime; | |
586 | up_read(&nilfs->ns_sem); | |
587 | ||
588 | return NILFS_SHOW_TIME(ctime, buf); | |
589 | } | |
590 | ||
591 | static ssize_t | |
592 | nilfs_segctor_last_seg_write_time_secs_show(struct nilfs_segctor_attr *attr, | |
593 | struct the_nilfs *nilfs, | |
594 | char *buf) | |
595 | { | |
596 | time_t ctime; | |
597 | ||
598 | down_read(&nilfs->ns_sem); | |
599 | ctime = nilfs->ns_ctime; | |
600 | up_read(&nilfs->ns_sem); | |
601 | ||
602 | return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)ctime); | |
603 | } | |
604 | ||
605 | static ssize_t | |
606 | nilfs_segctor_last_nongc_write_time_show(struct nilfs_segctor_attr *attr, | |
607 | struct the_nilfs *nilfs, | |
608 | char *buf) | |
609 | { | |
610 | time_t nongc_ctime; | |
611 | ||
612 | down_read(&nilfs->ns_sem); | |
613 | nongc_ctime = nilfs->ns_nongc_ctime; | |
614 | up_read(&nilfs->ns_sem); | |
615 | ||
616 | return NILFS_SHOW_TIME(nongc_ctime, buf); | |
617 | } | |
618 | ||
619 | static ssize_t | |
620 | nilfs_segctor_last_nongc_write_time_secs_show(struct nilfs_segctor_attr *attr, | |
621 | struct the_nilfs *nilfs, | |
622 | char *buf) | |
623 | { | |
624 | time_t nongc_ctime; | |
625 | ||
626 | down_read(&nilfs->ns_sem); | |
627 | nongc_ctime = nilfs->ns_nongc_ctime; | |
628 | up_read(&nilfs->ns_sem); | |
629 | ||
630 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
631 | (unsigned long long)nongc_ctime); | |
632 | } | |
633 | ||
634 | static ssize_t | |
635 | nilfs_segctor_dirty_data_blocks_count_show(struct nilfs_segctor_attr *attr, | |
636 | struct the_nilfs *nilfs, | |
637 | char *buf) | |
638 | { | |
639 | u32 ndirtyblks; | |
640 | ||
641 | down_read(&nilfs->ns_sem); | |
642 | ndirtyblks = atomic_read(&nilfs->ns_ndirtyblks); | |
643 | up_read(&nilfs->ns_sem); | |
644 | ||
645 | return snprintf(buf, PAGE_SIZE, "%u\n", ndirtyblks); | |
646 | } | |
647 | ||
648 | static const char segctor_readme_str[] = | |
649 | "The segctor group contains attributes that describe\n" | |
650 | "segctor thread activity details.\n\n" | |
651 | "(1) last_pseg_block\n" | |
652 | "\tshow start block number of the latest segment.\n\n" | |
653 | "(2) last_seg_sequence\n" | |
654 | "\tshow sequence value of the latest segment.\n\n" | |
655 | "(3) last_seg_checkpoint\n" | |
656 | "\tshow checkpoint number of the latest segment.\n\n" | |
657 | "(4) current_seg_sequence\n\tshow segment sequence counter.\n\n" | |
658 | "(5) current_last_full_seg\n" | |
659 | "\tshow index number of the latest full segment.\n\n" | |
660 | "(6) next_full_seg\n" | |
661 | "\tshow index number of the full segment index to be used next.\n\n" | |
662 | "(7) next_pseg_offset\n" | |
663 | "\tshow offset of next partial segment in the current full segment.\n\n" | |
664 | "(8) next_checkpoint\n\tshow next checkpoint number.\n\n" | |
665 | "(9) last_seg_write_time\n" | |
666 | "\tshow write time of the last segment in human-readable format.\n\n" | |
667 | "(10) last_seg_write_time_secs\n" | |
668 | "\tshow write time of the last segment in seconds.\n\n" | |
669 | "(11) last_nongc_write_time\n" | |
670 | "\tshow write time of the last segment not for cleaner operation " | |
671 | "in human-readable format.\n\n" | |
672 | "(12) last_nongc_write_time_secs\n" | |
673 | "\tshow write time of the last segment not for cleaner operation " | |
674 | "in seconds.\n\n" | |
675 | "(13) dirty_data_blocks_count\n" | |
676 | "\tshow number of dirty data blocks.\n\n"; | |
677 | ||
678 | static ssize_t | |
679 | nilfs_segctor_README_show(struct nilfs_segctor_attr *attr, | |
680 | struct the_nilfs *nilfs, char *buf) | |
681 | { | |
682 | return snprintf(buf, PAGE_SIZE, segctor_readme_str); | |
683 | } | |
684 | ||
685 | NILFS_SEGCTOR_RO_ATTR(last_pseg_block); | |
686 | NILFS_SEGCTOR_RO_ATTR(last_seg_sequence); | |
687 | NILFS_SEGCTOR_RO_ATTR(last_seg_checkpoint); | |
688 | NILFS_SEGCTOR_RO_ATTR(current_seg_sequence); | |
689 | NILFS_SEGCTOR_RO_ATTR(current_last_full_seg); | |
690 | NILFS_SEGCTOR_RO_ATTR(next_full_seg); | |
691 | NILFS_SEGCTOR_RO_ATTR(next_pseg_offset); | |
692 | NILFS_SEGCTOR_RO_ATTR(next_checkpoint); | |
693 | NILFS_SEGCTOR_RO_ATTR(last_seg_write_time); | |
694 | NILFS_SEGCTOR_RO_ATTR(last_seg_write_time_secs); | |
695 | NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time); | |
696 | NILFS_SEGCTOR_RO_ATTR(last_nongc_write_time_secs); | |
697 | NILFS_SEGCTOR_RO_ATTR(dirty_data_blocks_count); | |
698 | NILFS_SEGCTOR_RO_ATTR(README); | |
699 | ||
700 | static struct attribute *nilfs_segctor_attrs[] = { | |
701 | NILFS_SEGCTOR_ATTR_LIST(last_pseg_block), | |
702 | NILFS_SEGCTOR_ATTR_LIST(last_seg_sequence), | |
703 | NILFS_SEGCTOR_ATTR_LIST(last_seg_checkpoint), | |
704 | NILFS_SEGCTOR_ATTR_LIST(current_seg_sequence), | |
705 | NILFS_SEGCTOR_ATTR_LIST(current_last_full_seg), | |
706 | NILFS_SEGCTOR_ATTR_LIST(next_full_seg), | |
707 | NILFS_SEGCTOR_ATTR_LIST(next_pseg_offset), | |
708 | NILFS_SEGCTOR_ATTR_LIST(next_checkpoint), | |
709 | NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time), | |
710 | NILFS_SEGCTOR_ATTR_LIST(last_seg_write_time_secs), | |
711 | NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time), | |
712 | NILFS_SEGCTOR_ATTR_LIST(last_nongc_write_time_secs), | |
713 | NILFS_SEGCTOR_ATTR_LIST(dirty_data_blocks_count), | |
714 | NILFS_SEGCTOR_ATTR_LIST(README), | |
715 | NULL, | |
716 | }; | |
717 | ||
718 | NILFS_DEV_INT_GROUP_OPS(segctor, dev); | |
719 | NILFS_DEV_INT_GROUP_TYPE(segctor, dev); | |
720 | NILFS_DEV_INT_GROUP_FNS(segctor, dev); | |
721 | ||
caa05d49 VD |
722 | /************************************************************************ |
723 | * NILFS superblock attrs * | |
724 | ************************************************************************/ | |
725 | ||
726 | static ssize_t | |
727 | nilfs_superblock_sb_write_time_show(struct nilfs_superblock_attr *attr, | |
728 | struct the_nilfs *nilfs, | |
729 | char *buf) | |
730 | { | |
731 | time_t sbwtime; | |
732 | ||
733 | down_read(&nilfs->ns_sem); | |
734 | sbwtime = nilfs->ns_sbwtime; | |
735 | up_read(&nilfs->ns_sem); | |
736 | ||
737 | return NILFS_SHOW_TIME(sbwtime, buf); | |
738 | } | |
739 | ||
740 | static ssize_t | |
741 | nilfs_superblock_sb_write_time_secs_show(struct nilfs_superblock_attr *attr, | |
742 | struct the_nilfs *nilfs, | |
743 | char *buf) | |
744 | { | |
745 | time_t sbwtime; | |
746 | ||
747 | down_read(&nilfs->ns_sem); | |
748 | sbwtime = nilfs->ns_sbwtime; | |
749 | up_read(&nilfs->ns_sem); | |
750 | ||
751 | return snprintf(buf, PAGE_SIZE, "%llu\n", (unsigned long long)sbwtime); | |
752 | } | |
753 | ||
754 | static ssize_t | |
755 | nilfs_superblock_sb_write_count_show(struct nilfs_superblock_attr *attr, | |
756 | struct the_nilfs *nilfs, | |
757 | char *buf) | |
758 | { | |
759 | unsigned sbwcount; | |
760 | ||
761 | down_read(&nilfs->ns_sem); | |
762 | sbwcount = nilfs->ns_sbwcount; | |
763 | up_read(&nilfs->ns_sem); | |
764 | ||
765 | return snprintf(buf, PAGE_SIZE, "%u\n", sbwcount); | |
766 | } | |
767 | ||
768 | static ssize_t | |
769 | nilfs_superblock_sb_update_frequency_show(struct nilfs_superblock_attr *attr, | |
770 | struct the_nilfs *nilfs, | |
771 | char *buf) | |
772 | { | |
773 | unsigned sb_update_freq; | |
774 | ||
775 | down_read(&nilfs->ns_sem); | |
776 | sb_update_freq = nilfs->ns_sb_update_freq; | |
777 | up_read(&nilfs->ns_sem); | |
778 | ||
779 | return snprintf(buf, PAGE_SIZE, "%u\n", sb_update_freq); | |
780 | } | |
781 | ||
782 | static ssize_t | |
783 | nilfs_superblock_sb_update_frequency_store(struct nilfs_superblock_attr *attr, | |
784 | struct the_nilfs *nilfs, | |
785 | const char *buf, size_t count) | |
786 | { | |
787 | unsigned val; | |
788 | int err; | |
789 | ||
790 | err = kstrtouint(skip_spaces(buf), 0, &val); | |
791 | if (err) { | |
792 | printk(KERN_ERR "NILFS: unable to convert string: err=%d\n", | |
793 | err); | |
794 | return err; | |
795 | } | |
796 | ||
797 | if (val < NILFS_SB_FREQ) { | |
798 | val = NILFS_SB_FREQ; | |
799 | printk(KERN_WARNING "NILFS: superblock update frequency cannot be lesser than 10 seconds\n"); | |
800 | } | |
801 | ||
802 | down_write(&nilfs->ns_sem); | |
803 | nilfs->ns_sb_update_freq = val; | |
804 | up_write(&nilfs->ns_sem); | |
805 | ||
806 | return count; | |
807 | } | |
808 | ||
809 | static const char sb_readme_str[] = | |
810 | "The superblock group contains attributes that describe\n" | |
811 | "superblock's details.\n\n" | |
812 | "(1) sb_write_time\n\tshow previous write time of super block " | |
813 | "in human-readable format.\n\n" | |
814 | "(2) sb_write_time_secs\n\tshow previous write time of super block " | |
815 | "in seconds.\n\n" | |
816 | "(3) sb_write_count\n\tshow write count of super block.\n\n" | |
817 | "(4) sb_update_frequency\n" | |
818 | "\tshow/set interval of periodical update of superblock (in seconds).\n\n" | |
819 | "\tYou can set preferable frequency of superblock update by command:\n\n" | |
820 | "\t'echo <val> > /sys/fs/<nilfs>/<dev>/superblock/sb_update_frequency'\n"; | |
821 | ||
822 | static ssize_t | |
823 | nilfs_superblock_README_show(struct nilfs_superblock_attr *attr, | |
824 | struct the_nilfs *nilfs, char *buf) | |
825 | { | |
826 | return snprintf(buf, PAGE_SIZE, sb_readme_str); | |
827 | } | |
828 | ||
829 | NILFS_SUPERBLOCK_RO_ATTR(sb_write_time); | |
830 | NILFS_SUPERBLOCK_RO_ATTR(sb_write_time_secs); | |
831 | NILFS_SUPERBLOCK_RO_ATTR(sb_write_count); | |
832 | NILFS_SUPERBLOCK_RW_ATTR(sb_update_frequency); | |
833 | NILFS_SUPERBLOCK_RO_ATTR(README); | |
834 | ||
835 | static struct attribute *nilfs_superblock_attrs[] = { | |
836 | NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time), | |
837 | NILFS_SUPERBLOCK_ATTR_LIST(sb_write_time_secs), | |
838 | NILFS_SUPERBLOCK_ATTR_LIST(sb_write_count), | |
839 | NILFS_SUPERBLOCK_ATTR_LIST(sb_update_frequency), | |
840 | NILFS_SUPERBLOCK_ATTR_LIST(README), | |
841 | NULL, | |
842 | }; | |
843 | ||
844 | NILFS_DEV_INT_GROUP_OPS(superblock, dev); | |
845 | NILFS_DEV_INT_GROUP_TYPE(superblock, dev); | |
846 | NILFS_DEV_INT_GROUP_FNS(superblock, dev); | |
847 | ||
da7141fb VD |
848 | /************************************************************************ |
849 | * NILFS device attrs * | |
850 | ************************************************************************/ | |
851 | ||
852 | static | |
853 | ssize_t nilfs_dev_revision_show(struct nilfs_dev_attr *attr, | |
854 | struct the_nilfs *nilfs, | |
855 | char *buf) | |
856 | { | |
857 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
858 | u32 major = le32_to_cpu(sbp[0]->s_rev_level); | |
859 | u16 minor = le16_to_cpu(sbp[0]->s_minor_rev_level); | |
860 | ||
861 | return snprintf(buf, PAGE_SIZE, "%d.%d\n", major, minor); | |
862 | } | |
863 | ||
864 | static | |
865 | ssize_t nilfs_dev_blocksize_show(struct nilfs_dev_attr *attr, | |
866 | struct the_nilfs *nilfs, | |
867 | char *buf) | |
868 | { | |
869 | return snprintf(buf, PAGE_SIZE, "%u\n", nilfs->ns_blocksize); | |
870 | } | |
871 | ||
872 | static | |
873 | ssize_t nilfs_dev_device_size_show(struct nilfs_dev_attr *attr, | |
874 | struct the_nilfs *nilfs, | |
875 | char *buf) | |
876 | { | |
877 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
878 | u64 dev_size = le64_to_cpu(sbp[0]->s_dev_size); | |
879 | ||
880 | return snprintf(buf, PAGE_SIZE, "%llu\n", dev_size); | |
881 | } | |
882 | ||
883 | static | |
884 | ssize_t nilfs_dev_free_blocks_show(struct nilfs_dev_attr *attr, | |
885 | struct the_nilfs *nilfs, | |
886 | char *buf) | |
887 | { | |
888 | sector_t free_blocks = 0; | |
889 | ||
890 | nilfs_count_free_blocks(nilfs, &free_blocks); | |
891 | return snprintf(buf, PAGE_SIZE, "%llu\n", | |
892 | (unsigned long long)free_blocks); | |
893 | } | |
894 | ||
895 | static | |
896 | ssize_t nilfs_dev_uuid_show(struct nilfs_dev_attr *attr, | |
897 | struct the_nilfs *nilfs, | |
898 | char *buf) | |
899 | { | |
900 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
901 | ||
902 | return snprintf(buf, PAGE_SIZE, "%pUb\n", sbp[0]->s_uuid); | |
903 | } | |
904 | ||
905 | static | |
906 | ssize_t nilfs_dev_volume_name_show(struct nilfs_dev_attr *attr, | |
907 | struct the_nilfs *nilfs, | |
908 | char *buf) | |
909 | { | |
910 | struct nilfs_super_block **sbp = nilfs->ns_sbp; | |
911 | ||
912 | return scnprintf(buf, sizeof(sbp[0]->s_volume_name), "%s\n", | |
913 | sbp[0]->s_volume_name); | |
914 | } | |
915 | ||
916 | static const char dev_readme_str[] = | |
917 | "The <device> group contains attributes that describe file system\n" | |
918 | "partition's details.\n\n" | |
919 | "(1) revision\n\tshow NILFS file system revision.\n\n" | |
920 | "(2) blocksize\n\tshow volume block size in bytes.\n\n" | |
921 | "(3) device_size\n\tshow volume size in bytes.\n\n" | |
922 | "(4) free_blocks\n\tshow count of free blocks on volume.\n\n" | |
923 | "(5) uuid\n\tshow volume's UUID.\n\n" | |
924 | "(6) volume_name\n\tshow volume's name.\n\n"; | |
925 | ||
926 | static ssize_t nilfs_dev_README_show(struct nilfs_dev_attr *attr, | |
927 | struct the_nilfs *nilfs, | |
928 | char *buf) | |
929 | { | |
930 | return snprintf(buf, PAGE_SIZE, dev_readme_str); | |
931 | } | |
932 | ||
933 | NILFS_DEV_RO_ATTR(revision); | |
934 | NILFS_DEV_RO_ATTR(blocksize); | |
935 | NILFS_DEV_RO_ATTR(device_size); | |
936 | NILFS_DEV_RO_ATTR(free_blocks); | |
937 | NILFS_DEV_RO_ATTR(uuid); | |
938 | NILFS_DEV_RO_ATTR(volume_name); | |
939 | NILFS_DEV_RO_ATTR(README); | |
940 | ||
941 | static struct attribute *nilfs_dev_attrs[] = { | |
942 | NILFS_DEV_ATTR_LIST(revision), | |
943 | NILFS_DEV_ATTR_LIST(blocksize), | |
944 | NILFS_DEV_ATTR_LIST(device_size), | |
945 | NILFS_DEV_ATTR_LIST(free_blocks), | |
946 | NILFS_DEV_ATTR_LIST(uuid), | |
947 | NILFS_DEV_ATTR_LIST(volume_name), | |
948 | NILFS_DEV_ATTR_LIST(README), | |
949 | NULL, | |
950 | }; | |
951 | ||
952 | static ssize_t nilfs_dev_attr_show(struct kobject *kobj, | |
953 | struct attribute *attr, char *buf) | |
954 | { | |
955 | struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, | |
956 | ns_dev_kobj); | |
957 | struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, | |
958 | attr); | |
959 | ||
960 | return a->show ? a->show(a, nilfs, buf) : 0; | |
961 | } | |
962 | ||
963 | static ssize_t nilfs_dev_attr_store(struct kobject *kobj, | |
964 | struct attribute *attr, | |
965 | const char *buf, size_t len) | |
966 | { | |
967 | struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, | |
968 | ns_dev_kobj); | |
969 | struct nilfs_dev_attr *a = container_of(attr, struct nilfs_dev_attr, | |
970 | attr); | |
971 | ||
972 | return a->store ? a->store(a, nilfs, buf, len) : 0; | |
973 | } | |
974 | ||
975 | static void nilfs_dev_attr_release(struct kobject *kobj) | |
976 | { | |
977 | struct the_nilfs *nilfs = container_of(kobj, struct the_nilfs, | |
978 | ns_dev_kobj); | |
979 | complete(&nilfs->ns_dev_kobj_unregister); | |
980 | } | |
981 | ||
982 | static const struct sysfs_ops nilfs_dev_attr_ops = { | |
983 | .show = nilfs_dev_attr_show, | |
984 | .store = nilfs_dev_attr_store, | |
985 | }; | |
986 | ||
987 | static struct kobj_type nilfs_dev_ktype = { | |
988 | .default_attrs = nilfs_dev_attrs, | |
989 | .sysfs_ops = &nilfs_dev_attr_ops, | |
990 | .release = nilfs_dev_attr_release, | |
991 | }; | |
992 | ||
993 | int nilfs_sysfs_create_device_group(struct super_block *sb) | |
994 | { | |
995 | struct the_nilfs *nilfs = sb->s_fs_info; | |
caa05d49 | 996 | size_t devgrp_size = sizeof(struct nilfs_sysfs_dev_subgroups); |
da7141fb VD |
997 | int err; |
998 | ||
caa05d49 VD |
999 | nilfs->ns_dev_subgroups = kzalloc(devgrp_size, GFP_KERNEL); |
1000 | if (unlikely(!nilfs->ns_dev_subgroups)) { | |
1001 | err = -ENOMEM; | |
1002 | printk(KERN_ERR "NILFS: unable to allocate memory for device group\n"); | |
1003 | goto failed_create_device_group; | |
1004 | } | |
1005 | ||
da7141fb VD |
1006 | nilfs->ns_dev_kobj.kset = nilfs_kset; |
1007 | init_completion(&nilfs->ns_dev_kobj_unregister); | |
1008 | err = kobject_init_and_add(&nilfs->ns_dev_kobj, &nilfs_dev_ktype, NULL, | |
1009 | "%s", sb->s_id); | |
1010 | if (err) | |
caa05d49 VD |
1011 | goto free_dev_subgroups; |
1012 | ||
a2ecb791 | 1013 | err = nilfs_sysfs_create_mounted_snapshots_group(nilfs); |
caa05d49 VD |
1014 | if (err) |
1015 | goto cleanup_dev_kobject; | |
da7141fb | 1016 | |
a2ecb791 VD |
1017 | err = nilfs_sysfs_create_checkpoints_group(nilfs); |
1018 | if (err) | |
1019 | goto delete_mounted_snapshots_group; | |
1020 | ||
02a0ba1c VD |
1021 | err = nilfs_sysfs_create_segments_group(nilfs); |
1022 | if (err) | |
1023 | goto delete_checkpoints_group; | |
1024 | ||
ef43d5cd VD |
1025 | err = nilfs_sysfs_create_superblock_group(nilfs); |
1026 | if (err) | |
1027 | goto delete_segments_group; | |
1028 | ||
abc968db VD |
1029 | err = nilfs_sysfs_create_segctor_group(nilfs); |
1030 | if (err) | |
1031 | goto delete_superblock_group; | |
1032 | ||
da7141fb VD |
1033 | return 0; |
1034 | ||
abc968db VD |
1035 | delete_superblock_group: |
1036 | nilfs_sysfs_delete_superblock_group(nilfs); | |
1037 | ||
ef43d5cd VD |
1038 | delete_segments_group: |
1039 | nilfs_sysfs_delete_segments_group(nilfs); | |
1040 | ||
02a0ba1c VD |
1041 | delete_checkpoints_group: |
1042 | nilfs_sysfs_delete_checkpoints_group(nilfs); | |
1043 | ||
a2ecb791 VD |
1044 | delete_mounted_snapshots_group: |
1045 | nilfs_sysfs_delete_mounted_snapshots_group(nilfs); | |
1046 | ||
caa05d49 VD |
1047 | cleanup_dev_kobject: |
1048 | kobject_del(&nilfs->ns_dev_kobj); | |
1049 | ||
1050 | free_dev_subgroups: | |
1051 | kfree(nilfs->ns_dev_subgroups); | |
1052 | ||
da7141fb VD |
1053 | failed_create_device_group: |
1054 | return err; | |
1055 | } | |
1056 | ||
1057 | void nilfs_sysfs_delete_device_group(struct the_nilfs *nilfs) | |
1058 | { | |
a2ecb791 | 1059 | nilfs_sysfs_delete_mounted_snapshots_group(nilfs); |
02a0ba1c | 1060 | nilfs_sysfs_delete_checkpoints_group(nilfs); |
ef43d5cd | 1061 | nilfs_sysfs_delete_segments_group(nilfs); |
caa05d49 | 1062 | nilfs_sysfs_delete_superblock_group(nilfs); |
abc968db | 1063 | nilfs_sysfs_delete_segctor_group(nilfs); |
da7141fb | 1064 | kobject_del(&nilfs->ns_dev_kobj); |
caa05d49 | 1065 | kfree(nilfs->ns_dev_subgroups); |
da7141fb VD |
1066 | } |
1067 | ||
aebe17f6 VD |
1068 | /************************************************************************ |
1069 | * NILFS feature attrs * | |
1070 | ************************************************************************/ | |
1071 | ||
1072 | static ssize_t nilfs_feature_revision_show(struct kobject *kobj, | |
1073 | struct attribute *attr, char *buf) | |
1074 | { | |
1075 | return snprintf(buf, PAGE_SIZE, "%d.%d\n", | |
1076 | NILFS_CURRENT_REV, NILFS_MINOR_REV); | |
1077 | } | |
1078 | ||
1079 | static const char features_readme_str[] = | |
1080 | "The features group contains attributes that describe NILFS file\n" | |
1081 | "system driver features.\n\n" | |
1082 | "(1) revision\n\tshow current revision of NILFS file system driver.\n"; | |
1083 | ||
1084 | static ssize_t nilfs_feature_README_show(struct kobject *kobj, | |
1085 | struct attribute *attr, | |
1086 | char *buf) | |
1087 | { | |
1088 | return snprintf(buf, PAGE_SIZE, features_readme_str); | |
1089 | } | |
1090 | ||
1091 | NILFS_FEATURE_RO_ATTR(revision); | |
1092 | NILFS_FEATURE_RO_ATTR(README); | |
1093 | ||
1094 | static struct attribute *nilfs_feature_attrs[] = { | |
1095 | NILFS_FEATURE_ATTR_LIST(revision), | |
1096 | NILFS_FEATURE_ATTR_LIST(README), | |
1097 | NULL, | |
1098 | }; | |
1099 | ||
1100 | static const struct attribute_group nilfs_feature_attr_group = { | |
1101 | .name = "features", | |
1102 | .attrs = nilfs_feature_attrs, | |
1103 | }; | |
1104 | ||
1105 | int __init nilfs_sysfs_init(void) | |
1106 | { | |
1107 | int err; | |
1108 | ||
1109 | nilfs_kset = kset_create_and_add(NILFS_ROOT_GROUP_NAME, NULL, fs_kobj); | |
1110 | if (!nilfs_kset) { | |
1111 | err = -ENOMEM; | |
1112 | printk(KERN_ERR "NILFS: unable to create sysfs entry: err %d\n", | |
1113 | err); | |
1114 | goto failed_sysfs_init; | |
1115 | } | |
1116 | ||
1117 | err = sysfs_create_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); | |
1118 | if (unlikely(err)) { | |
1119 | printk(KERN_ERR "NILFS: unable to create feature group: err %d\n", | |
1120 | err); | |
1121 | goto cleanup_sysfs_init; | |
1122 | } | |
1123 | ||
1124 | return 0; | |
1125 | ||
1126 | cleanup_sysfs_init: | |
1127 | kset_unregister(nilfs_kset); | |
1128 | ||
1129 | failed_sysfs_init: | |
1130 | return err; | |
1131 | } | |
1132 | ||
1133 | void nilfs_sysfs_exit(void) | |
1134 | { | |
1135 | sysfs_remove_group(&nilfs_kset->kobj, &nilfs_feature_attr_group); | |
1136 | kset_unregister(nilfs_kset); | |
1137 | } |