forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
509 lines
12 KiB
509 lines
12 KiB
// 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); |
|
}
|
|
|