1 /* 2 * f2fs sysfs interface 3 * 4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com/ 6 * Copyright (c) 2017 Chao Yu <chao@kernel.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 #include <linux/proc_fs.h> 13 #include <linux/f2fs_fs.h> 14 #include <linux/seq_file.h> 15 16 #include "f2fs.h" 17 #include "segment.h" 18 #include "gc.h" 19 20 static struct proc_dir_entry *f2fs_proc_root; 21 static struct kset *f2fs_kset; 22 23 /* Sysfs support for f2fs */ 24 enum { 25 GC_THREAD, /* struct f2fs_gc_thread */ 26 SM_INFO, /* struct f2fs_sm_info */ 27 DCC_INFO, /* struct discard_cmd_control */ 28 NM_INFO, /* struct f2fs_nm_info */ 29 F2FS_SBI, /* struct f2fs_sb_info */ 30 #ifdef CONFIG_F2FS_FAULT_INJECTION 31 FAULT_INFO_RATE, /* struct f2fs_fault_info */ 32 FAULT_INFO_TYPE, /* struct f2fs_fault_info */ 33 #endif 34 RESERVED_BLOCKS, 35 }; 36 37 struct f2fs_attr { 38 struct attribute attr; 39 ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *); 40 ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *, 41 const char *, size_t); 42 int struct_type; 43 int offset; 44 }; 45 46 static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type) 47 { 48 if (struct_type == GC_THREAD) 49 return (unsigned char *)sbi->gc_thread; 50 else if (struct_type == SM_INFO) 51 return (unsigned char *)SM_I(sbi); 52 else if (struct_type == DCC_INFO) 53 return (unsigned char *)SM_I(sbi)->dcc_info; 54 else if (struct_type == NM_INFO) 55 return (unsigned char *)NM_I(sbi); 56 else if (struct_type == F2FS_SBI || struct_type == RESERVED_BLOCKS) 57 return (unsigned char *)sbi; 58 #ifdef CONFIG_F2FS_FAULT_INJECTION 59 else if (struct_type == FAULT_INFO_RATE || 60 struct_type == FAULT_INFO_TYPE) 61 return (unsigned char *)&sbi->fault_info; 62 #endif 63 return NULL; 64 } 65 66 static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a, 67 struct f2fs_sb_info *sbi, char *buf) 68 { 69 struct super_block *sb = sbi->sb; 70 71 if (!sb->s_bdev->bd_part) 72 return snprintf(buf, PAGE_SIZE, "0\n"); 73 74 return snprintf(buf, PAGE_SIZE, "%llu\n", 75 (unsigned long long)(sbi->kbytes_written + 76 BD_PART_WRITTEN(sbi))); 77 } 78 79 static ssize_t f2fs_sbi_show(struct f2fs_attr *a, 80 struct f2fs_sb_info *sbi, char *buf) 81 { 82 unsigned char *ptr = NULL; 83 unsigned int *ui; 84 85 ptr = __struct_ptr(sbi, a->struct_type); 86 if (!ptr) 87 return -EINVAL; 88 89 ui = (unsigned int *)(ptr + a->offset); 90 91 return snprintf(buf, PAGE_SIZE, "%u\n", *ui); 92 } 93 94 static ssize_t f2fs_sbi_store(struct f2fs_attr *a, 95 struct f2fs_sb_info *sbi, 96 const char *buf, size_t count) 97 { 98 unsigned char *ptr; 99 unsigned long t; 100 unsigned int *ui; 101 ssize_t ret; 102 103 ptr = __struct_ptr(sbi, a->struct_type); 104 if (!ptr) 105 return -EINVAL; 106 107 ui = (unsigned int *)(ptr + a->offset); 108 109 ret = kstrtoul(skip_spaces(buf), 0, &t); 110 if (ret < 0) 111 return ret; 112 #ifdef CONFIG_F2FS_FAULT_INJECTION 113 if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX)) 114 return -EINVAL; 115 #endif 116 if (a->struct_type == RESERVED_BLOCKS) { 117 spin_lock(&sbi->stat_lock); 118 if ((unsigned long)sbi->total_valid_block_count + t > 119 (unsigned long)sbi->user_block_count) { 120 spin_unlock(&sbi->stat_lock); 121 return -EINVAL; 122 } 123 *ui = t; 124 spin_unlock(&sbi->stat_lock); 125 return count; 126 } 127 *ui = t; 128 return count; 129 } 130 131 static ssize_t f2fs_attr_show(struct kobject *kobj, 132 struct attribute *attr, char *buf) 133 { 134 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 135 s_kobj); 136 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 137 138 return a->show ? a->show(a, sbi, buf) : 0; 139 } 140 141 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr, 142 const char *buf, size_t len) 143 { 144 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 145 s_kobj); 146 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 147 148 return a->store ? a->store(a, sbi, buf, len) : 0; 149 } 150 151 static void f2fs_sb_release(struct kobject *kobj) 152 { 153 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 154 s_kobj); 155 complete(&sbi->s_kobj_unregister); 156 } 157 158 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ 159 static struct f2fs_attr f2fs_attr_##_name = { \ 160 .attr = {.name = __stringify(_name), .mode = _mode }, \ 161 .show = _show, \ 162 .store = _store, \ 163 .struct_type = _struct_type, \ 164 .offset = _offset \ 165 } 166 167 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ 168 F2FS_ATTR_OFFSET(struct_type, name, 0644, \ 169 f2fs_sbi_show, f2fs_sbi_store, \ 170 offsetof(struct struct_name, elname)) 171 172 #define F2FS_GENERAL_RO_ATTR(name) \ 173 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL) 174 175 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); 176 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); 177 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); 178 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle); 179 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); 180 F2FS_RW_ATTR(DCC_INFO, discard_cmd_control, max_small_discards, max_discards); 181 F2FS_RW_ATTR(RESERVED_BLOCKS, f2fs_sb_info, reserved_blocks, reserved_blocks); 182 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections); 183 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); 184 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); 185 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); 186 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_hot_blocks, min_hot_blocks); 187 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); 188 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages); 189 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio); 190 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); 191 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); 192 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]); 193 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]); 194 #ifdef CONFIG_F2FS_FAULT_INJECTION 195 F2FS_RW_ATTR(FAULT_INFO_RATE, f2fs_fault_info, inject_rate, inject_rate); 196 F2FS_RW_ATTR(FAULT_INFO_TYPE, f2fs_fault_info, inject_type, inject_type); 197 #endif 198 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes); 199 200 #define ATTR_LIST(name) (&f2fs_attr_##name.attr) 201 static struct attribute *f2fs_attrs[] = { 202 ATTR_LIST(gc_min_sleep_time), 203 ATTR_LIST(gc_max_sleep_time), 204 ATTR_LIST(gc_no_gc_sleep_time), 205 ATTR_LIST(gc_idle), 206 ATTR_LIST(reclaim_segments), 207 ATTR_LIST(max_small_discards), 208 ATTR_LIST(batched_trim_sections), 209 ATTR_LIST(ipu_policy), 210 ATTR_LIST(min_ipu_util), 211 ATTR_LIST(min_fsync_blocks), 212 ATTR_LIST(min_hot_blocks), 213 ATTR_LIST(max_victim_search), 214 ATTR_LIST(dir_level), 215 ATTR_LIST(ram_thresh), 216 ATTR_LIST(ra_nid_pages), 217 ATTR_LIST(dirty_nats_ratio), 218 ATTR_LIST(cp_interval), 219 ATTR_LIST(idle_interval), 220 #ifdef CONFIG_F2FS_FAULT_INJECTION 221 ATTR_LIST(inject_rate), 222 ATTR_LIST(inject_type), 223 #endif 224 ATTR_LIST(lifetime_write_kbytes), 225 ATTR_LIST(reserved_blocks), 226 NULL, 227 }; 228 229 static const struct sysfs_ops f2fs_attr_ops = { 230 .show = f2fs_attr_show, 231 .store = f2fs_attr_store, 232 }; 233 234 static struct kobj_type f2fs_ktype = { 235 .default_attrs = f2fs_attrs, 236 .sysfs_ops = &f2fs_attr_ops, 237 .release = f2fs_sb_release, 238 }; 239 240 static int segment_info_seq_show(struct seq_file *seq, void *offset) 241 { 242 struct super_block *sb = seq->private; 243 struct f2fs_sb_info *sbi = F2FS_SB(sb); 244 unsigned int total_segs = 245 le32_to_cpu(sbi->raw_super->segment_count_main); 246 int i; 247 248 seq_puts(seq, "format: segment_type|valid_blocks\n" 249 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 250 251 for (i = 0; i < total_segs; i++) { 252 struct seg_entry *se = get_seg_entry(sbi, i); 253 254 if ((i % 10) == 0) 255 seq_printf(seq, "%-10d", i); 256 seq_printf(seq, "%d|%-3u", se->type, 257 get_valid_blocks(sbi, i, false)); 258 if ((i % 10) == 9 || i == (total_segs - 1)) 259 seq_putc(seq, '\n'); 260 else 261 seq_putc(seq, ' '); 262 } 263 264 return 0; 265 } 266 267 static int segment_bits_seq_show(struct seq_file *seq, void *offset) 268 { 269 struct super_block *sb = seq->private; 270 struct f2fs_sb_info *sbi = F2FS_SB(sb); 271 unsigned int total_segs = 272 le32_to_cpu(sbi->raw_super->segment_count_main); 273 int i, j; 274 275 seq_puts(seq, "format: segment_type|valid_blocks|bitmaps\n" 276 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 277 278 for (i = 0; i < total_segs; i++) { 279 struct seg_entry *se = get_seg_entry(sbi, i); 280 281 seq_printf(seq, "%-10d", i); 282 seq_printf(seq, "%d|%-3u|", se->type, 283 get_valid_blocks(sbi, i, false)); 284 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) 285 seq_printf(seq, " %.2x", se->cur_valid_map[j]); 286 seq_putc(seq, '\n'); 287 } 288 return 0; 289 } 290 291 #define F2FS_PROC_FILE_DEF(_name) \ 292 static int _name##_open_fs(struct inode *inode, struct file *file) \ 293 { \ 294 return single_open(file, _name##_seq_show, PDE_DATA(inode)); \ 295 } \ 296 \ 297 static const struct file_operations f2fs_seq_##_name##_fops = { \ 298 .open = _name##_open_fs, \ 299 .read = seq_read, \ 300 .llseek = seq_lseek, \ 301 .release = single_release, \ 302 }; 303 304 F2FS_PROC_FILE_DEF(segment_info); 305 F2FS_PROC_FILE_DEF(segment_bits); 306 307 int __init f2fs_register_sysfs(void) 308 { 309 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); 310 311 f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj); 312 if (!f2fs_kset) 313 return -ENOMEM; 314 return 0; 315 } 316 317 void f2fs_unregister_sysfs(void) 318 { 319 kset_unregister(f2fs_kset); 320 remove_proc_entry("fs/f2fs", NULL); 321 } 322 323 int f2fs_init_sysfs(struct f2fs_sb_info *sbi) 324 { 325 struct super_block *sb = sbi->sb; 326 int err; 327 328 if (f2fs_proc_root) 329 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); 330 331 if (sbi->s_proc) { 332 proc_create_data("segment_info", S_IRUGO, sbi->s_proc, 333 &f2fs_seq_segment_info_fops, sb); 334 proc_create_data("segment_bits", S_IRUGO, sbi->s_proc, 335 &f2fs_seq_segment_bits_fops, sb); 336 } 337 338 sbi->s_kobj.kset = f2fs_kset; 339 init_completion(&sbi->s_kobj_unregister); 340 err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL, 341 "%s", sb->s_id); 342 if (err) 343 goto err_out; 344 return 0; 345 err_out: 346 if (sbi->s_proc) { 347 remove_proc_entry("segment_info", sbi->s_proc); 348 remove_proc_entry("segment_bits", sbi->s_proc); 349 remove_proc_entry(sb->s_id, f2fs_proc_root); 350 } 351 return err; 352 } 353 354 void f2fs_exit_sysfs(struct f2fs_sb_info *sbi) 355 { 356 kobject_del(&sbi->s_kobj); 357 kobject_put(&sbi->s_kobj); 358 wait_for_completion(&sbi->s_kobj_unregister); 359 360 if (sbi->s_proc) { 361 remove_proc_entry("segment_info", sbi->s_proc); 362 remove_proc_entry("segment_bits", sbi->s_proc); 363 remove_proc_entry(sbi->sb->s_id, f2fs_proc_root); 364 } 365 } 366