ocfs2: sysfile interfaces for online file check (a860f6eb) · Commits · 戴 / test

fs/ocfs2/Makefile

+2 −1

Original line number	Diff line number	Diff line
		@@ -41,7 +41,8 @@ ocfs2-objs := \
		quota_local.o \
		quota_global.o \
		xattr.o \
		acl.o
		acl.o \
		filecheck.o

		ocfs2_stackglue-objs := stackglue.o
		ocfs2_stack_o2cb-objs := stack_o2cb.o

fs/ocfs2/filecheck.c

0 → 100644

+606 −0

Original line number	Diff line number	Diff line
		/* -- mode: c; c-basic-offset: 8; --
		* vim: noexpandtab sw=8 ts=8 sts=0:
		*
		* filecheck.c
		*
		* Code which implements online file check.
		*
		* Copyright (C) 2016 SuSE. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or
		* modify it under the terms of the GNU General Public
		* License as published by the Free Software Foundation, version 2.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		* General Public License for more details.
		*/

		#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"
		};

		static DEFINE_SPINLOCK(ocfs2_filecheck_sysfs_lock);
		static LIST_HEAD(ocfs2_filecheck_sysfs_list);

		struct ocfs2_filecheck {
		struct list_head fc_head; /* File check entry list head */
		spinlock_t fc_lock;
		unsigned int fc_max; /* Maximum number of entry in list */
		unsigned int fc_size; /* Current entry count in list */
		unsigned int fc_done; /* Finished entry count in list */
		};

		struct ocfs2_filecheck_sysfs_entry { /* sysfs entry per mounting */
		struct list_head fs_list;
		atomic_t fs_count;
		struct super_block *fs_sb;
		struct kset *fs_devicekset;
		struct kset *fs_fcheckkset;
		struct ocfs2_filecheck *fs_fcheck;
		};

		#define OCFS2_FILECHECK_MAXSIZE 100
		#define OCFS2_FILECHECK_MINSIZE 10

		/* File check operation type */
		enum {
		OCFS2_FILECHECK_TYPE_CHK = 0, /* Check a file(inode) */
		OCFS2_FILECHECK_TYPE_FIX, /* Fix a file(inode) */
		OCFS2_FILECHECK_TYPE_SET = 100 /* Set entry list maximum size */
		};

		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_show(struct kobject *kobj,
		struct kobj_attribute *attr,
		char *buf);
		static ssize_t ocfs2_filecheck_store(struct kobject *kobj,
		struct kobj_attribute *attr,
		const char *buf, size_t count);
		static struct kobj_attribute ocfs2_attr_filecheck_chk =
		__ATTR(check, S_IRUSR \| S_IWUSR,
		ocfs2_filecheck_show,
		ocfs2_filecheck_store);
		static struct kobj_attribute ocfs2_attr_filecheck_fix =
		__ATTR(fix, S_IRUSR \| S_IWUSR,
		ocfs2_filecheck_show,
		ocfs2_filecheck_store);
		static struct kobj_attribute ocfs2_attr_filecheck_set =
		__ATTR(set, S_IRUSR \| S_IWUSR,
		ocfs2_filecheck_show,
		ocfs2_filecheck_store);

		static int ocfs2_filecheck_sysfs_wait(atomic_t *p)
		{
		schedule();
		return 0;
		}

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

		if (!atomic_dec_and_test(&entry->fs_count))
		wait_on_atomic_t(&entry->fs_count, ocfs2_filecheck_sysfs_wait,
		TASK_UNINTERRUPTIBLE);

		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);

		kset_unregister(entry->fs_fcheckkset);
		kset_unregister(entry->fs_devicekset);
		kfree(entry->fs_fcheck);
		kfree(entry);
		}

		static void
		ocfs2_filecheck_sysfs_add(struct ocfs2_filecheck_sysfs_entry *entry)
		{
		spin_lock(&ocfs2_filecheck_sysfs_lock);
		list_add_tail(&entry->fs_list, &ocfs2_filecheck_sysfs_list);
		spin_unlock(&ocfs2_filecheck_sysfs_lock);
		}

		static int ocfs2_filecheck_sysfs_del(const char *devname)
		{
		struct ocfs2_filecheck_sysfs_entry *p;

		spin_lock(&ocfs2_filecheck_sysfs_lock);
		list_for_each_entry(p, &ocfs2_filecheck_sysfs_list, fs_list) {
		if (!strcmp(p->fs_sb->s_id, devname)) {
		list_del(&p->fs_list);
		spin_unlock(&ocfs2_filecheck_sysfs_lock);
		ocfs2_filecheck_sysfs_free(p);
		return 0;
		}
		}
		spin_unlock(&ocfs2_filecheck_sysfs_lock);
		return 1;
		}

		static void
		ocfs2_filecheck_sysfs_put(struct ocfs2_filecheck_sysfs_entry *entry)
		{
		if (atomic_dec_and_test(&entry->fs_count))
		wake_up_atomic_t(&entry->fs_count);
		}

		static struct ocfs2_filecheck_sysfs_entry *
		ocfs2_filecheck_sysfs_get(const char *devname)
		{
		struct ocfs2_filecheck_sysfs_entry *p = NULL;

		spin_lock(&ocfs2_filecheck_sysfs_lock);
		list_for_each_entry(p, &ocfs2_filecheck_sysfs_list, fs_list) {
		if (!strcmp(p->fs_sb->s_id, devname)) {
		atomic_inc(&p->fs_count);
		spin_unlock(&ocfs2_filecheck_sysfs_lock);
		return p;
		}
		}
		spin_unlock(&ocfs2_filecheck_sysfs_lock);
		return NULL;
		}

		int ocfs2_filecheck_create_sysfs(struct super_block *sb)
		{
		int ret = 0;
		struct kset *device_kset = NULL;
		struct kset *fcheck_kset = NULL;
		struct ocfs2_filecheck *fcheck = NULL;
		struct ocfs2_filecheck_sysfs_entry *entry = NULL;
		struct attribute **attrs = NULL;
		struct attribute_group attrgp;

		if (!ocfs2_kset)
		return -ENOMEM;

		attrs = kmalloc(sizeof(struct attribute ) 4, GFP_NOFS);
		if (!attrs) {
		ret = -ENOMEM;
		goto error;
		} else {
		attrs[0] = &ocfs2_attr_filecheck_chk.attr;
		attrs[1] = &ocfs2_attr_filecheck_fix.attr;
		attrs[2] = &ocfs2_attr_filecheck_set.attr;
		attrs[3] = NULL;
		memset(&attrgp, 0, sizeof(attrgp));
		attrgp.attrs = attrs;
		}

		fcheck = kmalloc(sizeof(struct ocfs2_filecheck), GFP_NOFS);
		if (!fcheck) {
		ret = -ENOMEM;
		goto error;
		} else {
		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;
		}

		if (strlen(sb->s_id) <= 0) {
		mlog(ML_ERROR,
		"Cannot get device basename when create filecheck sysfs\n");
		ret = -ENODEV;
		goto error;
		}

		device_kset = kset_create_and_add(sb->s_id, NULL, &ocfs2_kset->kobj);
		if (!device_kset) {
		ret = -ENOMEM;
		goto error;
		}

		fcheck_kset = kset_create_and_add("filecheck", NULL,
		&device_kset->kobj);
		if (!fcheck_kset) {
		ret = -ENOMEM;
		goto error;
		}

		ret = sysfs_create_group(&fcheck_kset->kobj, &attrgp);
		if (ret)
		goto error;

		entry = kmalloc(sizeof(struct ocfs2_filecheck_sysfs_entry), GFP_NOFS);
		if (!entry) {
		ret = -ENOMEM;
		goto error;
		} else {
		atomic_set(&entry->fs_count, 1);
		entry->fs_sb = sb;
		entry->fs_devicekset = device_kset;
		entry->fs_fcheckkset = fcheck_kset;
		entry->fs_fcheck = fcheck;
		ocfs2_filecheck_sysfs_add(entry);
		}

		kfree(attrs);
		return 0;

		error:
		kfree(attrs);
		kfree(entry);
		kfree(fcheck);
		kset_unregister(fcheck_kset);
		kset_unregister(device_kset);
		return ret;
		}

		int ocfs2_filecheck_remove_sysfs(struct super_block *sb)
		{
		return ocfs2_filecheck_sysfs_del(sb->s_id);
		}

		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_ERROR,
		"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_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;

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

		ent = ocfs2_filecheck_sysfs_get(kobj->parent->name);
		if (!ent) {
		mlog(ML_ERROR,
		"Cannot get the corresponding entry via device basename %s\n",
		kobj->name);
		return -ENODEV;
		}

		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 < 0) {
		total = ret;
		break;
		}
		if (ret == remain) {
		/* snprintf() didn't fit */
		total = -E2BIG;
		break;
		}
		total += ret;
		remain -= ret;
		}
		spin_unlock(&ent->fs_fcheck->fc_lock);

		exit:
		ocfs2_filecheck_sysfs_put(ent);
		return total;
		}

		static 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)
		{
		entry->fe_done = 1;
		spin_lock(&ent->fs_fcheck->fc_lock);
		ent->fs_fcheck->fc_done++;
		spin_unlock(&ent->fs_fcheck->fc_lock);
		}

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

		inode = ocfs2_iget(OCFS2_SB(sb), 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)
		{
		if (entry->fe_type == OCFS2_FILECHECK_TYPE_CHK)
		entry->fe_status = ocfs2_filecheck_handle(ent->fs_sb,
		entry->fe_ino, OCFS2_FI_FLAG_FILECHECK_CHK);
		else if (entry->fe_type == OCFS2_FILECHECK_TYPE_FIX)
		entry->fe_status = ocfs2_filecheck_handle(ent->fs_sb,
		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_store(struct kobject *kobj,
		struct kobj_attribute *attr,
		const char *buf, size_t count)
		{
		struct ocfs2_filecheck_args args;
		struct ocfs2_filecheck_entry *entry;
		struct ocfs2_filecheck_sysfs_entry *ent;
		ssize_t ret = 0;

		if (count == 0)
		return count;

		if (ocfs2_filecheck_args_parse(attr->attr.name, buf, count, &args)) {
		mlog(ML_ERROR, "Invalid arguments for online file check\n");
		return -EINVAL;
		}

		ent = ocfs2_filecheck_sysfs_get(kobj->parent->name);
		if (!ent) {
		mlog(ML_ERROR,
		"Cannot get the corresponding entry via device basename %s\n",
		kobj->parent->name);
		return -ENODEV;
		}

		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 ((ent->fs_fcheck->fc_size >= ent->fs_fcheck->fc_max) &&
		(ent->fs_fcheck->fc_done == 0)) {
		mlog(ML_ERROR,
		"Cannot do more file check "
		"since file check queue(%u) is full now\n",
		ent->fs_fcheck->fc_max);
		ret = -EBUSY;
		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:
		ocfs2_filecheck_sysfs_put(ent);
		return (!ret ? count : ret);
		}

fs/ocfs2/filecheck.h

0 → 100644

+49 −0

Original line number	Diff line number	Diff line
		/* -- mode: c; c-basic-offset: 8; --
		* vim: noexpandtab sw=8 ts=8 sts=0:
		*
		* filecheck.h
		*
		* Online file check.
		*
		* Copyright (C) 2016 SuSE. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or
		* modify it under the terms of the GNU General Public
		* License as published by the Free Software Foundation, version 2.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		* General Public License for more details.
		*/


		#ifndef FILECHECK_H
		#define FILECHECK_H

		#include <linux/types.h>
		#include <linux/list.h>


		/* File check errno */
		enum {
		OCFS2_FILECHECK_ERR_SUCCESS = 0, /* Success */
		OCFS2_FILECHECK_ERR_FAILED = 1000, /* Other failure */
		OCFS2_FILECHECK_ERR_INPROGRESS, /* In progress */
		OCFS2_FILECHECK_ERR_READONLY, /* Read only */
		OCFS2_FILECHECK_ERR_INJBD, /* Buffer in jbd */
		OCFS2_FILECHECK_ERR_INVALIDINO, /* Invalid ino */
		OCFS2_FILECHECK_ERR_BLOCKECC, /* Block ecc */
		OCFS2_FILECHECK_ERR_BLOCKNO, /* Block number */
		OCFS2_FILECHECK_ERR_VALIDFLAG, /* Inode valid flag */
		OCFS2_FILECHECK_ERR_GENERATION, /* Inode generation */
		OCFS2_FILECHECK_ERR_UNSUPPORTED /* Unsupported */
		};

		#define OCFS2_FILECHECK_ERR_START OCFS2_FILECHECK_ERR_FAILED
		#define OCFS2_FILECHECK_ERR_END OCFS2_FILECHECK_ERR_UNSUPPORTED

		int ocfs2_filecheck_create_sysfs(struct super_block *sb);
		int ocfs2_filecheck_remove_sysfs(struct super_block *sb);

		#endif /* FILECHECK_H */

fs/ocfs2/inode.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -139,6 +139,9 @@ int ocfs2_drop_inode(struct inode *inode);
		/* Flags for ocfs2_iget() */
		#define OCFS2_FI_FLAG_SYSFILE 0x1
		#define OCFS2_FI_FLAG_ORPHAN_RECOVERY 0x2
		#define OCFS2_FI_FLAG_FILECHECK_CHK 0x4
		#define OCFS2_FI_FLAG_FILECHECK_FIX 0x8

		struct inode ocfs2_ilookup(struct super_block sb, u64 feoff);
		struct inode ocfs2_iget(struct ocfs2_super osb, u64 feoff, unsigned flags,
		int sysfile_type);

Admin message