[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
};
ATTRIBUTE_GROUPS(ocfs2_filecheck);

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