[linux-2.6-block.git] / fs / ocfs2 / filecheck.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * filecheck.c
 *
 * Code which implements online file check.
 *
 * Copyright (C) 2016 SuSE.  All rights reserved.
 */

#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kmod.h>
#include <linux/fs.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/sysctl.h>
#include <cluster/masklog.h>

#include "ocfs2.h"
#include "ocfs2_fs.h"
#include "stackglue.h"
#include "inode.h"

#include "filecheck.h"


/* File check error strings,
 * must correspond with error number in header file.
 */
static const char * const ocfs2_filecheck_errs[] = {
	"SUCCESS",
	"FAILED",
	"INPROGRESS",
	"READONLY",
	"INJBD",
	"INVALIDINO",
	"BLOCKECC",
	"BLOCKNO",
	"VALIDFLAG",
	"GENERATION",
	"UNSUPPORTED"
};

struct ocfs2_filecheck_entry {
	struct list_head fe_list;
	unsigned long fe_ino;
	unsigned int fe_type;
	unsigned int fe_done:1;
	unsigned int fe_status:31;
};

struct ocfs2_filecheck_args {
	unsigned int fa_type;
	union {
		unsigned long fa_ino;
		unsigned int fa_len;
	};
};

static const char *
ocfs2_filecheck_error(int errno)
{
	if (!errno)
		return ocfs2_filecheck_errs[errno];

	BUG_ON(errno < OCFS2_FILECHECK_ERR_START ||
	       errno > OCFS2_FILECHECK_ERR_END);
	return ocfs2_filecheck_errs[errno - OCFS2_FILECHECK_ERR_START + 1];
}

static ssize_t ocfs2_filecheck_attr_show(struct kobject *kobj,
					struct kobj_attribute *attr,
					char *buf);
static ssize_t ocfs2_filecheck_attr_store(struct kobject *kobj,
					struct kobj_attribute *attr,
					const char *buf, size_t count);
static struct kobj_attribute ocfs2_filecheck_attr_chk =
					__ATTR(check, S_IRUSR | S_IWUSR,
					ocfs2_filecheck_attr_show,
					ocfs2_filecheck_attr_store);
static struct kobj_attribute ocfs2_filecheck_attr_fix =
					__ATTR(fix, S_IRUSR | S_IWUSR,
					ocfs2_filecheck_attr_show,
					ocfs2_filecheck_attr_store);
static struct kobj_attribute ocfs2_filecheck_attr_set =
					__ATTR(set, S_IRUSR | S_IWUSR,
					ocfs2_filecheck_attr_show,
					ocfs2_filecheck_attr_store);
static struct attribute *ocfs2_filecheck_attrs[] = {
	&ocfs2_filecheck_attr_chk.attr,
	&ocfs2_filecheck_attr_fix.attr,
	&ocfs2_filecheck_attr_set.attr,
	NULL
};

static void ocfs2_filecheck_release(struct kobject *kobj)
{
	struct ocfs2_filecheck_sysfs_entry *entry = container_of(kobj,
				struct ocfs2_filecheck_sysfs_entry, fs_kobj);

	complete(&entry->fs_kobj_unregister);
}

static ssize_t
ocfs2_filecheck_show(struct kobject *kobj, struct attribute *attr, char *buf)
{
	ssize_t ret = -EIO;
	struct kobj_attribute *kattr = container_of(attr,
					struct kobj_attribute, attr);

	kobject_get(kobj);
	if (kattr->show)
		ret = kattr->show(kobj, kattr, buf);
	kobject_put(kobj);
	return ret;
}

static ssize_t
ocfs2_filecheck_store(struct kobject *kobj, struct attribute *attr,
			const char *buf, size_t count)
{
	ssize_t ret = -EIO;
	struct kobj_attribute *kattr = container_of(attr,
					struct kobj_attribute, attr);

	kobject_get(kobj);
	if (kattr->store)
		ret = kattr->store(kobj, kattr, buf, count);
	kobject_put(kobj);
	return ret;
}

static const struct sysfs_ops ocfs2_filecheck_ops = {
	.show = ocfs2_filecheck_show,
	.store = ocfs2_filecheck_store,
};

static struct kobj_type ocfs2_ktype_filecheck = {
	.default_attrs = ocfs2_filecheck_attrs,
	.sysfs_ops = &ocfs2_filecheck_ops,
	.release = ocfs2_filecheck_release,
};

static void
ocfs2_filecheck_sysfs_free(struct ocfs2_filecheck_sysfs_entry *entry)
{
	struct ocfs2_filecheck_entry *p;

	spin_lock(&entry->fs_fcheck->fc_lock);
	while (!list_empty(&entry->fs_fcheck->fc_head)) {
		p = list_first_entry(&entry->fs_fcheck->fc_head,
				     struct ocfs2_filecheck_entry, fe_list);
		list_del(&p->fe_list);
		BUG_ON(!p->fe_done); /* To free a undone file check entry */
		kfree(p);
	}
	spin_unlock(&entry->fs_fcheck->fc_lock);

	kfree(entry->fs_fcheck);
	entry->fs_fcheck = NULL;
}

int ocfs2_filecheck_create_sysfs(struct ocfs2_super *osb)
{
	int ret;
	struct ocfs2_filecheck *fcheck;
	struct ocfs2_filecheck_sysfs_entry *entry = &osb->osb_fc_ent;

	fcheck = kmalloc(sizeof(struct ocfs2_filecheck), GFP_NOFS);
	if (!fcheck)
		return -ENOMEM;

	INIT_LIST_HEAD(&fcheck->fc_head);
	spin_lock_init(&fcheck->fc_lock);
	fcheck->fc_max = OCFS2_FILECHECK_MINSIZE;
	fcheck->fc_size = 0;
	fcheck->fc_done = 0;

	entry->fs_kobj.kset = osb->osb_dev_kset;
	init_completion(&entry->fs_kobj_unregister);
	ret = kobject_init_and_add(&entry->fs_kobj, &ocfs2_ktype_filecheck,
					NULL, "filecheck");
	if (ret) {
		kobject_put(&entry->fs_kobj);
		kfree(fcheck);
		return ret;
	}

	entry->fs_fcheck = fcheck;
	return 0;
}

void ocfs2_filecheck_remove_sysfs(struct ocfs2_super *osb)
{
	if (!osb->osb_fc_ent.fs_fcheck)
		return;

	kobject_del(&osb->osb_fc_ent.fs_kobj);
	kobject_put(&osb->osb_fc_ent.fs_kobj);
	wait_for_completion(&osb->osb_fc_ent.fs_kobj_unregister);
	ocfs2_filecheck_sysfs_free(&osb->osb_fc_ent);
}

static int
ocfs2_filecheck_erase_entries(struct ocfs2_filecheck_sysfs_entry *ent,
			      unsigned int count);
static int
ocfs2_filecheck_adjust_max(struct ocfs2_filecheck_sysfs_entry *ent,
			   unsigned int len)
{
	int ret;

	if ((len < OCFS2_FILECHECK_MINSIZE) || (len > OCFS2_FILECHECK_MAXSIZE))
		return -EINVAL;

	spin_lock(&ent->fs_fcheck->fc_lock);
	if (len < (ent->fs_fcheck->fc_size - ent->fs_fcheck->fc_done)) {
		mlog(ML_NOTICE,
		"Cannot set online file check maximum entry number "
		"to %u due to too many pending entries(%u)\n",
		len, ent->fs_fcheck->fc_size - ent->fs_fcheck->fc_done);
		ret = -EBUSY;
	} else {
		if (len < ent->fs_fcheck->fc_size)
			BUG_ON(!ocfs2_filecheck_erase_entries(ent,
				ent->fs_fcheck->fc_size - len));

		ent->fs_fcheck->fc_max = len;
		ret = 0;
	}
	spin_unlock(&ent->fs_fcheck->fc_lock);

	return ret;
}

#define OCFS2_FILECHECK_ARGS_LEN	24
static int
ocfs2_filecheck_args_get_long(const char *buf, size_t count,
			      unsigned long *val)
{
	char buffer[OCFS2_FILECHECK_ARGS_LEN];

	memcpy(buffer, buf, count);
	buffer[count] = '\0';

	if (kstrtoul(buffer, 0, val))
		return 1;

	return 0;
}

static int
ocfs2_filecheck_type_parse(const char *name, unsigned int *type)
{
	if (!strncmp(name, "fix", 4))
		*type = OCFS2_FILECHECK_TYPE_FIX;
	else if (!strncmp(name, "check", 6))
		*type = OCFS2_FILECHECK_TYPE_CHK;
	else if (!strncmp(name, "set", 4))
		*type = OCFS2_FILECHECK_TYPE_SET;
	else
		return 1;

	return 0;
}

static int
ocfs2_filecheck_args_parse(const char *name, const char *buf, size_t count,
			   struct ocfs2_filecheck_args *args)
{
	unsigned long val = 0;
	unsigned int type;

	/* too short/long args length */
	if ((count < 1) || (count >= OCFS2_FILECHECK_ARGS_LEN))
		return 1;

	if (ocfs2_filecheck_type_parse(name, &type))
		return 1;
	if (ocfs2_filecheck_args_get_long(buf, count, &val))
		return 1;

	if (val <= 0)
		return 1;

	args->fa_type = type;
	if (type == OCFS2_FILECHECK_TYPE_SET)
		args->fa_len = (unsigned int)val;
	else
		args->fa_ino = val;

	return 0;
}

static ssize_t ocfs2_filecheck_attr_show(struct kobject *kobj,
				    struct kobj_attribute *attr,
				    char *buf)
{

	ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
	unsigned int type;
	struct ocfs2_filecheck_entry *p;
	struct ocfs2_filecheck_sysfs_entry *ent = container_of(kobj,
				struct ocfs2_filecheck_sysfs_entry, fs_kobj);

	if (ocfs2_filecheck_type_parse(attr->attr.name, &type))
		return -EINVAL;

	if (type == OCFS2_FILECHECK_TYPE_SET) {
		spin_lock(&ent->fs_fcheck->fc_lock);
		total = snprintf(buf, remain, "%u\n", ent->fs_fcheck->fc_max);
		spin_unlock(&ent->fs_fcheck->fc_lock);
		goto exit;
	}

	ret = snprintf(buf, remain, "INO\t\tDONE\tERROR\n");
	total += ret;
	remain -= ret;
	spin_lock(&ent->fs_fcheck->fc_lock);
	list_for_each_entry(p, &ent->fs_fcheck->fc_head, fe_list) {
		if (p->fe_type != type)
			continue;

		ret = snprintf(buf + total, remain, "%lu\t\t%u\t%s\n",
			       p->fe_ino, p->fe_done,
			       ocfs2_filecheck_error(p->fe_status));
		if (ret >= remain) {
			/* snprintf() didn't fit */
			total = -E2BIG;
			break;
		}
		total += ret;
		remain -= ret;
	}
	spin_unlock(&ent->fs_fcheck->fc_lock);

exit:
	return total;
}

static inline int
ocfs2_filecheck_is_dup_entry(struct ocfs2_filecheck_sysfs_entry *ent,
				unsigned long ino)
{
	struct ocfs2_filecheck_entry *p;

	list_for_each_entry(p, &ent->fs_fcheck->fc_head, fe_list) {
		if (!p->fe_done) {
			if (p->fe_ino == ino)
				return 1;
		}
	}

	return 0;
}

static inline int
ocfs2_filecheck_erase_entry(struct ocfs2_filecheck_sysfs_entry *ent)
{
	struct ocfs2_filecheck_entry *p;

	list_for_each_entry(p, &ent->fs_fcheck->fc_head, fe_list) {
		if (p->fe_done) {
			list_del(&p->fe_list);
			kfree(p);
			ent->fs_fcheck->fc_size--;
			ent->fs_fcheck->fc_done--;
			return 1;
		}
	}

	return 0;
}

static int
ocfs2_filecheck_erase_entries(struct ocfs2_filecheck_sysfs_entry *ent,
			      unsigned int count)
{
	unsigned int i = 0;
	unsigned int ret = 0;

	while (i++ < count) {
		if (ocfs2_filecheck_erase_entry(ent))
			ret++;
		else
			break;
	}

	return (ret == count ? 1 : 0);
}

static void
ocfs2_filecheck_done_entry(struct ocfs2_filecheck_sysfs_entry *ent,
			   struct ocfs2_filecheck_entry *entry)
{
	spin_lock(&ent->fs_fcheck->fc_lock);
	entry->fe_done = 1;
	ent->fs_fcheck->fc_done++;
	spin_unlock(&ent->fs_fcheck->fc_lock);
}

static unsigned int
ocfs2_filecheck_handle(struct ocfs2_super *osb,
		       unsigned long ino, unsigned int flags)
{
	unsigned int ret = OCFS2_FILECHECK_ERR_SUCCESS;
	struct inode *inode = NULL;
	int rc;

	inode = ocfs2_iget(osb, ino, flags, 0);
	if (IS_ERR(inode)) {
		rc = (int)(-(long)inode);
		if (rc >= OCFS2_FILECHECK_ERR_START &&
		    rc < OCFS2_FILECHECK_ERR_END)
			ret = rc;
		else
			ret = OCFS2_FILECHECK_ERR_FAILED;
	} else
		iput(inode);

	return ret;
}

static void
ocfs2_filecheck_handle_entry(struct ocfs2_filecheck_sysfs_entry *ent,
			     struct ocfs2_filecheck_entry *entry)
{
	struct ocfs2_super *osb = container_of(ent, struct ocfs2_super,
						osb_fc_ent);

	if (entry->fe_type == OCFS2_FILECHECK_TYPE_CHK)
		entry->fe_status = ocfs2_filecheck_handle(osb,
				entry->fe_ino, OCFS2_FI_FLAG_FILECHECK_CHK);
	else if (entry->fe_type == OCFS2_FILECHECK_TYPE_FIX)
		entry->fe_status = ocfs2_filecheck_handle(osb,
				entry->fe_ino, OCFS2_FI_FLAG_FILECHECK_FIX);
	else
		entry->fe_status = OCFS2_FILECHECK_ERR_UNSUPPORTED;

	ocfs2_filecheck_done_entry(ent, entry);
}

static ssize_t ocfs2_filecheck_attr_store(struct kobject *kobj,
				     struct kobj_attribute *attr,
				     const char *buf, size_t count)
{
	ssize_t ret = 0;
	struct ocfs2_filecheck_args args;
	struct ocfs2_filecheck_entry *entry;
	struct ocfs2_filecheck_sysfs_entry *ent = container_of(kobj,
				struct ocfs2_filecheck_sysfs_entry, fs_kobj);

	if (count == 0)
		return count;

	if (ocfs2_filecheck_args_parse(attr->attr.name, buf, count, &args))
		return -EINVAL;

	if (args.fa_type == OCFS2_FILECHECK_TYPE_SET) {
		ret = ocfs2_filecheck_adjust_max(ent, args.fa_len);
		goto exit;
	}

	entry = kmalloc(sizeof(struct ocfs2_filecheck_entry), GFP_NOFS);
	if (!entry) {
		ret = -ENOMEM;
		goto exit;
	}

	spin_lock(&ent->fs_fcheck->fc_lock);
	if (ocfs2_filecheck_is_dup_entry(ent, args.fa_ino)) {
		ret = -EEXIST;
		kfree(entry);
	} else if ((ent->fs_fcheck->fc_size >= ent->fs_fcheck->fc_max) &&
		(ent->fs_fcheck->fc_done == 0)) {
		mlog(ML_NOTICE,
		"Cannot do more file check "
		"since file check queue(%u) is full now\n",
		ent->fs_fcheck->fc_max);
		ret = -EAGAIN;
		kfree(entry);
	} else {
		if ((ent->fs_fcheck->fc_size >= ent->fs_fcheck->fc_max) &&
		    (ent->fs_fcheck->fc_done > 0)) {
			/* Delete the oldest entry which was done,
			 * make sure the entry size in list does
			 * not exceed maximum value
			 */
			BUG_ON(!ocfs2_filecheck_erase_entry(ent));
		}

		entry->fe_ino = args.fa_ino;
		entry->fe_type = args.fa_type;
		entry->fe_done = 0;
		entry->fe_status = OCFS2_FILECHECK_ERR_INPROGRESS;
		list_add_tail(&entry->fe_list, &ent->fs_fcheck->fc_head);
		ent->fs_fcheck->fc_size++;
	}
	spin_unlock(&ent->fs_fcheck->fc_lock);

	if (!ret)
		ocfs2_filecheck_handle_entry(ent, entry);

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