xref: /linux/fs/ocfs2/filecheck.c (revision 3213486f2e442831e324cc6201a2f9e924ecc235) 
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * filecheck.c
5  *
6  * Code which implements online file check.
7  *
8  * Copyright (C) 2016 SuSE.  All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public
12  * License as published by the Free Software Foundation, version 2.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  */
19 
20 #include <linux/list.h>
21 #include <linux/spinlock.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/kmod.h>
25 #include <linux/fs.h>
26 #include <linux/kobject.h>
27 #include <linux/sysfs.h>
28 #include <linux/sysctl.h>
29 #include <cluster/masklog.h>
30 
31 #include "ocfs2.h"
32 #include "ocfs2_fs.h"
33 #include "stackglue.h"
34 #include "inode.h"
35 
36 #include "filecheck.h"
37 
38 
39 /* File check error strings,
40  * must correspond with error number in header file.
41  */
42 static const char * const ocfs2_filecheck_errs[] = {
43 	"SUCCESS",
44 	"FAILED",
45 	"INPROGRESS",
46 	"READONLY",
47 	"INJBD",
48 	"INVALIDINO",
49 	"BLOCKECC",
50 	"BLOCKNO",
51 	"VALIDFLAG",
52 	"GENERATION",
53 	"UNSUPPORTED"
54 };
55 
56 struct ocfs2_filecheck_entry {
57 	struct list_head fe_list;
58 	unsigned long fe_ino;
59 	unsigned int fe_type;
60 	unsigned int fe_done:1;
61 	unsigned int fe_status:31;
62 };
63 
64 struct ocfs2_filecheck_args {
65 	unsigned int fa_type;
66 	union {
67 		unsigned long fa_ino;
68 		unsigned int fa_len;
69 	};
70 };
71 
72 static const char *
73 ocfs2_filecheck_error(int errno)
74 {
75 	if (!errno)
76 		return ocfs2_filecheck_errs[errno];
77 
78 	BUG_ON(errno < OCFS2_FILECHECK_ERR_START ||
79 	       errno > OCFS2_FILECHECK_ERR_END);
80 	return ocfs2_filecheck_errs[errno - OCFS2_FILECHECK_ERR_START + 1];
81 }
82 
83 static ssize_t ocfs2_filecheck_attr_show(struct kobject *kobj,
84 					struct kobj_attribute *attr,
85 					char *buf);
86 static ssize_t ocfs2_filecheck_attr_store(struct kobject *kobj,
87 					struct kobj_attribute *attr,
88 					const char *buf, size_t count);
89 static struct kobj_attribute ocfs2_filecheck_attr_chk =
90 					__ATTR(check, S_IRUSR | S_IWUSR,
91 					ocfs2_filecheck_attr_show,
92 					ocfs2_filecheck_attr_store);
93 static struct kobj_attribute ocfs2_filecheck_attr_fix =
94 					__ATTR(fix, S_IRUSR | S_IWUSR,
95 					ocfs2_filecheck_attr_show,
96 					ocfs2_filecheck_attr_store);
97 static struct kobj_attribute ocfs2_filecheck_attr_set =
98 					__ATTR(set, S_IRUSR | S_IWUSR,
99 					ocfs2_filecheck_attr_show,
100 					ocfs2_filecheck_attr_store);
101 static struct attribute *ocfs2_filecheck_attrs[] = {
102 	&ocfs2_filecheck_attr_chk.attr,
103 	&ocfs2_filecheck_attr_fix.attr,
104 	&ocfs2_filecheck_attr_set.attr,
105 	NULL
106 };
107 
108 static void ocfs2_filecheck_release(struct kobject *kobj)
109 {
110 	struct ocfs2_filecheck_sysfs_entry *entry = container_of(kobj,
111 				struct ocfs2_filecheck_sysfs_entry, fs_kobj);
112 
113 	complete(&entry->fs_kobj_unregister);
114 }
115 
116 static ssize_t
117 ocfs2_filecheck_show(struct kobject *kobj, struct attribute *attr, char *buf)
118 {
119 	ssize_t ret = -EIO;
120 	struct kobj_attribute *kattr = container_of(attr,
121 					struct kobj_attribute, attr);
122 
123 	kobject_get(kobj);
124 	if (kattr->show)
125 		ret = kattr->show(kobj, kattr, buf);
126 	kobject_put(kobj);
127 	return ret;
128 }
129 
130 static ssize_t
131 ocfs2_filecheck_store(struct kobject *kobj, struct attribute *attr,
132 			const char *buf, size_t count)
133 {
134 	ssize_t ret = -EIO;
135 	struct kobj_attribute *kattr = container_of(attr,
136 					struct kobj_attribute, attr);
137 
138 	kobject_get(kobj);
139 	if (kattr->store)
140 		ret = kattr->store(kobj, kattr, buf, count);
141 	kobject_put(kobj);
142 	return ret;
143 }
144 
145 static const struct sysfs_ops ocfs2_filecheck_ops = {
146 	.show = ocfs2_filecheck_show,
147 	.store = ocfs2_filecheck_store,
148 };
149 
150 static struct kobj_type ocfs2_ktype_filecheck = {
151 	.default_attrs = ocfs2_filecheck_attrs,
152 	.sysfs_ops = &ocfs2_filecheck_ops,
153 	.release = ocfs2_filecheck_release,
154 };
155 
156 static void
157 ocfs2_filecheck_sysfs_free(struct ocfs2_filecheck_sysfs_entry *entry)
158 {
159 	struct ocfs2_filecheck_entry *p;
160 
161 	spin_lock(&entry->fs_fcheck->fc_lock);
162 	while (!list_empty(&entry->fs_fcheck->fc_head)) {
163 		p = list_first_entry(&entry->fs_fcheck->fc_head,
164 				     struct ocfs2_filecheck_entry, fe_list);
165 		list_del(&p->fe_list);
166 		BUG_ON(!p->fe_done); /* To free a undone file check entry */
167 		kfree(p);
168 	}
169 	spin_unlock(&entry->fs_fcheck->fc_lock);
170 
171 	kfree(entry->fs_fcheck);
172 	entry->fs_fcheck = NULL;
173 }
174 
175 int ocfs2_filecheck_create_sysfs(struct ocfs2_super *osb)
176 {
177 	int ret;
178 	struct ocfs2_filecheck *fcheck;
179 	struct ocfs2_filecheck_sysfs_entry *entry = &osb->osb_fc_ent;
180 
181 	fcheck = kmalloc(sizeof(struct ocfs2_filecheck), GFP_NOFS);
182 	if (!fcheck)
183 		return -ENOMEM;
184 
185 	INIT_LIST_HEAD(&fcheck->fc_head);
186 	spin_lock_init(&fcheck->fc_lock);
187 	fcheck->fc_max = OCFS2_FILECHECK_MINSIZE;
188 	fcheck->fc_size = 0;
189 	fcheck->fc_done = 0;
190 
191 	entry->fs_kobj.kset = osb->osb_dev_kset;
192 	init_completion(&entry->fs_kobj_unregister);
193 	ret = kobject_init_and_add(&entry->fs_kobj, &ocfs2_ktype_filecheck,
194 					NULL, "filecheck");
195 	if (ret) {
196 		kfree(fcheck);
197 		return ret;
198 	}
199 
200 	entry->fs_fcheck = fcheck;
201 	return 0;
202 }
203 
204 void ocfs2_filecheck_remove_sysfs(struct ocfs2_super *osb)
205 {
206 	if (!osb->osb_fc_ent.fs_fcheck)
207 		return;
208 
209 	kobject_del(&osb->osb_fc_ent.fs_kobj);
210 	kobject_put(&osb->osb_fc_ent.fs_kobj);
211 	wait_for_completion(&osb->osb_fc_ent.fs_kobj_unregister);
212 	ocfs2_filecheck_sysfs_free(&osb->osb_fc_ent);
213 }
214 
215 static int
216 ocfs2_filecheck_erase_entries(struct ocfs2_filecheck_sysfs_entry *ent,
217 			      unsigned int count);
218 static int
219 ocfs2_filecheck_adjust_max(struct ocfs2_filecheck_sysfs_entry *ent,
220 			   unsigned int len)
221 {
222 	int ret;
223 
224 	if ((len < OCFS2_FILECHECK_MINSIZE) || (len > OCFS2_FILECHECK_MAXSIZE))
225 		return -EINVAL;
226 
227 	spin_lock(&ent->fs_fcheck->fc_lock);
228 	if (len < (ent->fs_fcheck->fc_size - ent->fs_fcheck->fc_done)) {
229 		mlog(ML_NOTICE,
230 		"Cannot set online file check maximum entry number "
231 		"to %u due to too many pending entries(%u)\n",
232 		len, ent->fs_fcheck->fc_size - ent->fs_fcheck->fc_done);
233 		ret = -EBUSY;
234 	} else {
235 		if (len < ent->fs_fcheck->fc_size)
236 			BUG_ON(!ocfs2_filecheck_erase_entries(ent,
237 				ent->fs_fcheck->fc_size - len));
238 
239 		ent->fs_fcheck->fc_max = len;
240 		ret = 0;
241 	}
242 	spin_unlock(&ent->fs_fcheck->fc_lock);
243 
244 	return ret;
245 }
246 
247 #define OCFS2_FILECHECK_ARGS_LEN	24
248 static int
249 ocfs2_filecheck_args_get_long(const char *buf, size_t count,
250 			      unsigned long *val)
251 {
252 	char buffer[OCFS2_FILECHECK_ARGS_LEN];
253 
254 	memcpy(buffer, buf, count);
255 	buffer[count] = '\0';
256 
257 	if (kstrtoul(buffer, 0, val))
258 		return 1;
259 
260 	return 0;
261 }
262 
263 static int
264 ocfs2_filecheck_type_parse(const char *name, unsigned int *type)
265 {
266 	if (!strncmp(name, "fix", 4))
267 		*type = OCFS2_FILECHECK_TYPE_FIX;
268 	else if (!strncmp(name, "check", 6))
269 		*type = OCFS2_FILECHECK_TYPE_CHK;
270 	else if (!strncmp(name, "set", 4))
271 		*type = OCFS2_FILECHECK_TYPE_SET;
272 	else
273 		return 1;
274 
275 	return 0;
276 }
277 
278 static int
279 ocfs2_filecheck_args_parse(const char *name, const char *buf, size_t count,
280 			   struct ocfs2_filecheck_args *args)
281 {
282 	unsigned long val = 0;
283 	unsigned int type;
284 
285 	/* too short/long args length */
286 	if ((count < 1) || (count >= OCFS2_FILECHECK_ARGS_LEN))
287 		return 1;
288 
289 	if (ocfs2_filecheck_type_parse(name, &type))
290 		return 1;
291 	if (ocfs2_filecheck_args_get_long(buf, count, &val))
292 		return 1;
293 
294 	if (val <= 0)
295 		return 1;
296 
297 	args->fa_type = type;
298 	if (type == OCFS2_FILECHECK_TYPE_SET)
299 		args->fa_len = (unsigned int)val;
300 	else
301 		args->fa_ino = val;
302 
303 	return 0;
304 }
305 
306 static ssize_t ocfs2_filecheck_attr_show(struct kobject *kobj,
307 				    struct kobj_attribute *attr,
308 				    char *buf)
309 {
310 
311 	ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
312 	unsigned int type;
313 	struct ocfs2_filecheck_entry *p;
314 	struct ocfs2_filecheck_sysfs_entry *ent = container_of(kobj,
315 				struct ocfs2_filecheck_sysfs_entry, fs_kobj);
316 
317 	if (ocfs2_filecheck_type_parse(attr->attr.name, &type))
318 		return -EINVAL;
319 
320 	if (type == OCFS2_FILECHECK_TYPE_SET) {
321 		spin_lock(&ent->fs_fcheck->fc_lock);
322 		total = snprintf(buf, remain, "%u\n", ent->fs_fcheck->fc_max);
323 		spin_unlock(&ent->fs_fcheck->fc_lock);
324 		goto exit;
325 	}
326 
327 	ret = snprintf(buf, remain, "INO\t\tDONE\tERROR\n");
328 	total += ret;
329 	remain -= ret;
330 	spin_lock(&ent->fs_fcheck->fc_lock);
331 	list_for_each_entry(p, &ent->fs_fcheck->fc_head, fe_list) {
332 		if (p->fe_type != type)
333 			continue;
334 
335 		ret = snprintf(buf + total, remain, "%lu\t\t%u\t%s\n",
336 			       p->fe_ino, p->fe_done,
337 			       ocfs2_filecheck_error(p->fe_status));
338 		if (ret < 0) {
339 			total = ret;
340 			break;
341 		}
342 		if (ret == remain) {
343 			/* snprintf() didn't fit */
344 			total = -E2BIG;
345 			break;
346 		}
347 		total += ret;
348 		remain -= ret;
349 	}
350 	spin_unlock(&ent->fs_fcheck->fc_lock);
351 
352 exit:
353 	return total;
354 }
355 
356 static inline int
357 ocfs2_filecheck_is_dup_entry(struct ocfs2_filecheck_sysfs_entry *ent,
358 				unsigned long ino)
359 {
360 	struct ocfs2_filecheck_entry *p;
361 
362 	list_for_each_entry(p, &ent->fs_fcheck->fc_head, fe_list) {
363 		if (!p->fe_done) {
364 			if (p->fe_ino == ino)
365 				return 1;
366 		}
367 	}
368 
369 	return 0;
370 }
371 
372 static inline int
373 ocfs2_filecheck_erase_entry(struct ocfs2_filecheck_sysfs_entry *ent)
374 {
375 	struct ocfs2_filecheck_entry *p;
376 
377 	list_for_each_entry(p, &ent->fs_fcheck->fc_head, fe_list) {
378 		if (p->fe_done) {
379 			list_del(&p->fe_list);
380 			kfree(p);
381 			ent->fs_fcheck->fc_size--;
382 			ent->fs_fcheck->fc_done--;
383 			return 1;
384 		}
385 	}
386 
387 	return 0;
388 }
389 
390 static int
391 ocfs2_filecheck_erase_entries(struct ocfs2_filecheck_sysfs_entry *ent,
392 			      unsigned int count)
393 {
394 	unsigned int i = 0;
395 	unsigned int ret = 0;
396 
397 	while (i++ < count) {
398 		if (ocfs2_filecheck_erase_entry(ent))
399 			ret++;
400 		else
401 			break;
402 	}
403 
404 	return (ret == count ? 1 : 0);
405 }
406 
407 static void
408 ocfs2_filecheck_done_entry(struct ocfs2_filecheck_sysfs_entry *ent,
409 			   struct ocfs2_filecheck_entry *entry)
410 {
411 	spin_lock(&ent->fs_fcheck->fc_lock);
412 	entry->fe_done = 1;
413 	ent->fs_fcheck->fc_done++;
414 	spin_unlock(&ent->fs_fcheck->fc_lock);
415 }
416 
417 static unsigned int
418 ocfs2_filecheck_handle(struct ocfs2_super *osb,
419 		       unsigned long ino, unsigned int flags)
420 {
421 	unsigned int ret = OCFS2_FILECHECK_ERR_SUCCESS;
422 	struct inode *inode = NULL;
423 	int rc;
424 
425 	inode = ocfs2_iget(osb, ino, flags, 0);
426 	if (IS_ERR(inode)) {
427 		rc = (int)(-(long)inode);
428 		if (rc >= OCFS2_FILECHECK_ERR_START &&
429 		    rc < OCFS2_FILECHECK_ERR_END)
430 			ret = rc;
431 		else
432 			ret = OCFS2_FILECHECK_ERR_FAILED;
433 	} else
434 		iput(inode);
435 
436 	return ret;
437 }
438 
439 static void
440 ocfs2_filecheck_handle_entry(struct ocfs2_filecheck_sysfs_entry *ent,
441 			     struct ocfs2_filecheck_entry *entry)
442 {
443 	struct ocfs2_super *osb = container_of(ent, struct ocfs2_super,
444 						osb_fc_ent);
445 
446 	if (entry->fe_type == OCFS2_FILECHECK_TYPE_CHK)
447 		entry->fe_status = ocfs2_filecheck_handle(osb,
448 				entry->fe_ino, OCFS2_FI_FLAG_FILECHECK_CHK);
449 	else if (entry->fe_type == OCFS2_FILECHECK_TYPE_FIX)
450 		entry->fe_status = ocfs2_filecheck_handle(osb,
451 				entry->fe_ino, OCFS2_FI_FLAG_FILECHECK_FIX);
452 	else
453 		entry->fe_status = OCFS2_FILECHECK_ERR_UNSUPPORTED;
454 
455 	ocfs2_filecheck_done_entry(ent, entry);
456 }
457 
458 static ssize_t ocfs2_filecheck_attr_store(struct kobject *kobj,
459 				     struct kobj_attribute *attr,
460 				     const char *buf, size_t count)
461 {
462 	ssize_t ret = 0;
463 	struct ocfs2_filecheck_args args;
464 	struct ocfs2_filecheck_entry *entry;
465 	struct ocfs2_filecheck_sysfs_entry *ent = container_of(kobj,
466 				struct ocfs2_filecheck_sysfs_entry, fs_kobj);
467 
468 	if (count == 0)
469 		return count;
470 
471 	if (ocfs2_filecheck_args_parse(attr->attr.name, buf, count, &args))
472 		return -EINVAL;
473 
474 	if (args.fa_type == OCFS2_FILECHECK_TYPE_SET) {
475 		ret = ocfs2_filecheck_adjust_max(ent, args.fa_len);
476 		goto exit;
477 	}
478 
479 	entry = kmalloc(sizeof(struct ocfs2_filecheck_entry), GFP_NOFS);
480 	if (!entry) {
481 		ret = -ENOMEM;
482 		goto exit;
483 	}
484 
485 	spin_lock(&ent->fs_fcheck->fc_lock);
486 	if (ocfs2_filecheck_is_dup_entry(ent, args.fa_ino)) {
487 		ret = -EEXIST;
488 		kfree(entry);
489 	} else if ((ent->fs_fcheck->fc_size >= ent->fs_fcheck->fc_max) &&
490 		(ent->fs_fcheck->fc_done == 0)) {
491 		mlog(ML_NOTICE,
492 		"Cannot do more file check "
493 		"since file check queue(%u) is full now\n",
494 		ent->fs_fcheck->fc_max);
495 		ret = -EAGAIN;
496 		kfree(entry);
497 	} else {
498 		if ((ent->fs_fcheck->fc_size >= ent->fs_fcheck->fc_max) &&
499 		    (ent->fs_fcheck->fc_done > 0)) {
500 			/* Delete the oldest entry which was done,
501 			 * make sure the entry size in list does
502 			 * not exceed maximum value
503 			 */
504 			BUG_ON(!ocfs2_filecheck_erase_entry(ent));
505 		}
506 
507 		entry->fe_ino = args.fa_ino;
508 		entry->fe_type = args.fa_type;
509 		entry->fe_done = 0;
510 		entry->fe_status = OCFS2_FILECHECK_ERR_INPROGRESS;
511 		list_add_tail(&entry->fe_list, &ent->fs_fcheck->fc_head);
512 		ent->fs_fcheck->fc_size++;
513 	}
514 	spin_unlock(&ent->fs_fcheck->fc_lock);
515 
516 	if (!ret)
517 		ocfs2_filecheck_handle_entry(ent, entry);
518 
519 exit:
520 	return (!ret ? count : ret);
521 }
522