From 08f87f769b595151be1afeff53e144f543faa614 Mon Sep 17 00:00:00 2001
From: hc <hc@nodka.com>
Date: Wed, 06 Dec 2023 09:51:13 +0000
Subject: [PATCH] add dts config
---
kernel/fs/incfs/vfs.c | 1659 ++++++++++++++++++++++------------------------------------
1 files changed, 633 insertions(+), 1,026 deletions(-)
diff --git a/kernel/fs/incfs/vfs.c b/kernel/fs/incfs/vfs.c
index 8386722..342998f 100644
--- a/kernel/fs/incfs/vfs.c
+++ b/kernel/fs/incfs/vfs.c
@@ -4,32 +4,27 @@
*/
#include <linux/blkdev.h>
-#include <linux/cred.h>
-#include <linux/eventpoll.h>
+#include <linux/compat.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/fs_stack.h>
+#include <linux/fsnotify.h>
+#include <linux/fsverity.h>
+#include <linux/mmap_lock.h>
#include <linux/namei.h>
#include <linux/parser.h>
-#include <linux/poll.h>
#include <linux/seq_file.h>
-#include <linux/syscalls.h>
-#include <linux/xattr.h>
#include <uapi/linux/incrementalfs.h>
#include "vfs.h"
+
#include "data_mgmt.h"
#include "format.h"
-#include "integrity.h"
#include "internal.h"
-
-#define INCFS_PENDING_READS_INODE 2
-#define INCFS_LOG_INODE 3
-#define INCFS_START_INO_RANGE 10
-#define READ_FILE_MODE 0444
-#define READ_EXEC_FILE_MODE 0555
-#define READ_WRITE_FILE_MODE 0666
+#include "pseudo_files.h"
+#include "sysfs.h"
+#include "verity.h"
static int incfs_remount_fs(struct super_block *sb, int *flags, char *data);
@@ -52,23 +47,19 @@
static int read_single_page(struct file *f, struct page *page);
static long dispatch_ioctl(struct file *f, unsigned int req, unsigned long arg);
-static ssize_t pending_reads_read(struct file *f, char __user *buf, size_t len,
- loff_t *ppos);
-static __poll_t pending_reads_poll(struct file *file, poll_table *wait);
-static int pending_reads_open(struct inode *inode, struct file *file);
-static int pending_reads_release(struct inode *, struct file *);
-
-static ssize_t log_read(struct file *f, char __user *buf, size_t len,
- loff_t *ppos);
-static __poll_t log_poll(struct file *file, poll_table *wait);
-static int log_open(struct inode *inode, struct file *file);
-static int log_release(struct inode *, struct file *);
+#ifdef CONFIG_COMPAT
+static long incfs_compat_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg);
+#endif
static struct inode *alloc_inode(struct super_block *sb);
static void free_inode(struct inode *inode);
static void evict_inode(struct inode *inode);
static int incfs_setattr(struct dentry *dentry, struct iattr *ia);
+static int incfs_getattr(const struct path *path,
+ struct kstat *stat, u32 request_mask,
+ unsigned int query_flags);
static ssize_t incfs_getxattr(struct dentry *d, const char *name,
void *value, size_t size);
static ssize_t incfs_setxattr(struct dentry *d, const char *name,
@@ -109,8 +100,6 @@
.iterate = iterate_incfs_dir,
.open = file_open,
.release = file_release,
- .unlocked_ioctl = dispatch_ioctl,
- .compat_ioctl = dispatch_ioctl
};
static const struct dentry_operations incfs_dentry_ops = {
@@ -123,51 +112,54 @@
/* .readpages = readpages */
};
-static const struct file_operations incfs_file_ops = {
+static vm_fault_t incfs_fault(struct vm_fault *vmf)
+{
+ vmf->flags &= ~FAULT_FLAG_ALLOW_RETRY;
+ return filemap_fault(vmf);
+}
+
+static const struct vm_operations_struct incfs_file_vm_ops = {
+ .fault = incfs_fault,
+ .map_pages = filemap_map_pages,
+ .page_mkwrite = filemap_page_mkwrite,
+};
+
+/* This is used for a general mmap of a disk file */
+
+static int incfs_file_mmap(struct file *file, struct vm_area_struct *vma)
+{
+ struct address_space *mapping = file->f_mapping;
+
+ if (!mapping->a_ops->readpage)
+ return -ENOEXEC;
+ file_accessed(file);
+ vma->vm_ops = &incfs_file_vm_ops;
+ return 0;
+}
+
+const struct file_operations incfs_file_ops = {
.open = file_open,
.release = file_release,
.read_iter = generic_file_read_iter,
- .mmap = generic_file_mmap,
+ .mmap = incfs_file_mmap,
.splice_read = generic_file_splice_read,
.llseek = generic_file_llseek,
.unlocked_ioctl = dispatch_ioctl,
- .compat_ioctl = dispatch_ioctl
+#ifdef CONFIG_COMPAT
+ .compat_ioctl = incfs_compat_ioctl,
+#endif
};
-enum FILL_PERMISSION {
- CANT_FILL = 0,
- CAN_FILL = 1,
-};
-
-static const struct file_operations incfs_pending_read_file_ops = {
- .read = pending_reads_read,
- .poll = pending_reads_poll,
- .open = pending_reads_open,
- .release = pending_reads_release,
- .llseek = noop_llseek,
- .unlocked_ioctl = dispatch_ioctl,
- .compat_ioctl = dispatch_ioctl
-};
-
-static const struct file_operations incfs_log_file_ops = {
- .read = log_read,
- .poll = log_poll,
- .open = log_open,
- .release = log_release,
- .llseek = noop_llseek,
- .unlocked_ioctl = dispatch_ioctl,
- .compat_ioctl = dispatch_ioctl
-};
-
-static const struct inode_operations incfs_file_inode_ops = {
+const struct inode_operations incfs_file_inode_ops = {
.setattr = incfs_setattr,
- .getattr = simple_getattr,
+ .getattr = incfs_getattr,
.listxattr = incfs_listxattr
};
static int incfs_handler_getxattr(const struct xattr_handler *xh,
struct dentry *d, struct inode *inode,
- const char *name, void *buffer, size_t size)
+ const char *name, void *buffer, size_t size,
+ int flags)
{
return incfs_getxattr(d, name, buffer, size);
}
@@ -191,56 +183,41 @@
NULL,
};
-/* State of an open .pending_reads file, unique for each file descriptor. */
-struct pending_reads_state {
- /* A serial number of the last pending read obtained from this file. */
- int last_pending_read_sn;
-};
-
-/* State of an open .log file, unique for each file descriptor. */
-struct log_file_state {
- struct read_log_state state;
-};
-
struct inode_search {
unsigned long ino;
struct dentry *backing_dentry;
size_t size;
+
+ bool verity;
};
enum parse_parameter {
Opt_read_timeout,
Opt_readahead_pages,
- Opt_no_backing_file_cache,
- Opt_no_backing_file_readahead,
Opt_rlog_pages,
Opt_rlog_wakeup_cnt,
+ Opt_report_uid,
+ Opt_sysfs_name,
Opt_err
-};
-
-static const char pending_reads_file_name[] = INCFS_PENDING_READS_FILENAME;
-static struct mem_range pending_reads_file_name_range = {
- .data = (u8 *)pending_reads_file_name,
- .len = ARRAY_SIZE(pending_reads_file_name) - 1
-};
-
-static const char log_file_name[] = INCFS_LOG_FILENAME;
-static struct mem_range log_file_name_range = {
- .data = (u8 *)log_file_name,
- .len = ARRAY_SIZE(log_file_name) - 1
};
static const match_table_t option_tokens = {
{ Opt_read_timeout, "read_timeout_ms=%u" },
{ Opt_readahead_pages, "readahead=%u" },
- { Opt_no_backing_file_cache, "no_bf_cache=%u" },
- { Opt_no_backing_file_readahead, "no_bf_readahead=%u" },
{ Opt_rlog_pages, "rlog_pages=%u" },
{ Opt_rlog_wakeup_cnt, "rlog_wakeup_cnt=%u" },
+ { Opt_report_uid, "report_uid" },
+ { Opt_sysfs_name, "sysfs_name=%s" },
{ Opt_err, NULL }
};
+
+static void free_options(struct mount_options *opts)
+{
+ kfree(opts->sysfs_name);
+ opts->sysfs_name = NULL;
+}
static int parse_options(struct mount_options *opts, char *str)
{
@@ -251,12 +228,13 @@
if (opts == NULL)
return -EFAULT;
- opts->read_timeout_ms = 1000; /* Default: 1s */
- opts->readahead_pages = 10;
- opts->read_log_pages = 2;
- opts->read_log_wakeup_count = 10;
- opts->no_backing_file_cache = false;
- opts->no_backing_file_readahead = false;
+ *opts = (struct mount_options) {
+ .read_timeout_ms = 1000, /* Default: 1s */
+ .readahead_pages = 10,
+ .read_log_pages = 2,
+ .read_log_wakeup_count = 10,
+ };
+
if (str == NULL || *str == 0)
return 0;
@@ -272,22 +250,14 @@
case Opt_read_timeout:
if (match_int(&args[0], &value))
return -EINVAL;
+ if (value > 3600000)
+ return -EINVAL;
opts->read_timeout_ms = value;
break;
case Opt_readahead_pages:
if (match_int(&args[0], &value))
return -EINVAL;
opts->readahead_pages = value;
- break;
- case Opt_no_backing_file_cache:
- if (match_int(&args[0], &value))
- return -EINVAL;
- opts->no_backing_file_cache = (value != 0);
- break;
- case Opt_no_backing_file_readahead:
- if (match_int(&args[0], &value))
- return -EINVAL;
- opts->no_backing_file_readahead = (value != 0);
break;
case Opt_rlog_pages:
if (match_int(&args[0], &value))
@@ -299,26 +269,19 @@
return -EINVAL;
opts->read_log_wakeup_count = value;
break;
+ case Opt_report_uid:
+ opts->report_uid = true;
+ break;
+ case Opt_sysfs_name:
+ opts->sysfs_name = match_strdup(&args[0]);
+ break;
default:
+ free_options(opts);
return -EINVAL;
}
}
return 0;
-}
-
-static struct super_block *file_superblock(struct file *f)
-{
- struct inode *inode = file_inode(f);
-
- return inode->i_sb;
-}
-
-static struct mount_info *get_mount_info(struct super_block *sb)
-{
- struct mount_info *result = sb->s_fs_info;
-
- return result;
}
/* Read file size from the attribute. Quicker than reading the header */
@@ -336,100 +299,66 @@
return le64_to_cpu(attr_value);
}
+/* Read verity flag from the attribute. Quicker than reading the header */
+static bool read_verity_attr(struct dentry *backing_dentry)
+{
+ return vfs_getxattr(backing_dentry, INCFS_XATTR_VERITY_NAME, NULL, 0)
+ >= 0;
+}
+
static int inode_test(struct inode *inode, void *opaque)
{
struct inode_search *search = opaque;
struct inode_info *node = get_incfs_node(inode);
+ struct inode *backing_inode = d_inode(search->backing_dentry);
if (!node)
return 0;
- if (search->backing_dentry) {
- struct inode *backing_inode = d_inode(search->backing_dentry);
-
- return (node->n_backing_inode == backing_inode) &&
- inode->i_ino == search->ino;
- } else
- return inode->i_ino == search->ino;
+ return node->n_backing_inode == backing_inode &&
+ inode->i_ino == search->ino;
}
static int inode_set(struct inode *inode, void *opaque)
{
struct inode_search *search = opaque;
struct inode_info *node = get_incfs_node(inode);
+ struct dentry *backing_dentry = search->backing_dentry;
+ struct inode *backing_inode = d_inode(backing_dentry);
- if (search->backing_dentry) {
- /* It's a regular inode that has corresponding backing inode */
- struct dentry *backing_dentry = search->backing_dentry;
- struct inode *backing_inode = d_inode(backing_dentry);
+ fsstack_copy_attr_all(inode, backing_inode);
+ if (S_ISREG(inode->i_mode)) {
+ u64 size = search->size;
- fsstack_copy_attr_all(inode, backing_inode);
- if (S_ISREG(inode->i_mode)) {
- u64 size = search->size;
-
- inode->i_size = size;
- inode->i_blocks = get_blocks_count_for_size(size);
- inode->i_mapping->a_ops = &incfs_address_space_ops;
- inode->i_op = &incfs_file_inode_ops;
- inode->i_fop = &incfs_file_ops;
- inode->i_mode &= ~0222;
- } else if (S_ISDIR(inode->i_mode)) {
- inode->i_size = 0;
- inode->i_blocks = 1;
- inode->i_mapping->a_ops = &incfs_address_space_ops;
- inode->i_op = &incfs_dir_inode_ops;
- inode->i_fop = &incfs_dir_fops;
- } else {
- pr_warn_once("incfs: Unexpected inode type\n");
- return -EBADF;
- }
-
- ihold(backing_inode);
- node->n_backing_inode = backing_inode;
- node->n_mount_info = get_mount_info(inode->i_sb);
- inode->i_ctime = backing_inode->i_ctime;
- inode->i_mtime = backing_inode->i_mtime;
- inode->i_atime = backing_inode->i_atime;
- inode->i_ino = backing_inode->i_ino;
- if (backing_inode->i_ino < INCFS_START_INO_RANGE) {
- pr_warn("incfs: ino conflict with backing FS %ld\n",
- backing_inode->i_ino);
- }
-
- return 0;
- } else if (search->ino == INCFS_PENDING_READS_INODE) {
- /* It's an inode for .pending_reads pseudo file. */
-
- inode->i_ctime = (struct timespec64){};
- inode->i_mtime = inode->i_ctime;
- inode->i_atime = inode->i_ctime;
- inode->i_size = 0;
- inode->i_ino = INCFS_PENDING_READS_INODE;
- inode->i_private = NULL;
-
- inode_init_owner(inode, NULL, S_IFREG | READ_WRITE_FILE_MODE);
-
+ inode->i_size = size;
+ inode->i_blocks = get_blocks_count_for_size(size);
+ inode->i_mapping->a_ops = &incfs_address_space_ops;
inode->i_op = &incfs_file_inode_ops;
- inode->i_fop = &incfs_pending_read_file_ops;
-
- } else if (search->ino == INCFS_LOG_INODE) {
- /* It's an inode for .log pseudo file. */
-
- inode->i_ctime = (struct timespec64){};
- inode->i_mtime = inode->i_ctime;
- inode->i_atime = inode->i_ctime;
+ inode->i_fop = &incfs_file_ops;
+ inode->i_mode &= ~0222;
+ if (search->verity)
+ inode_set_flags(inode, S_VERITY, S_VERITY);
+ } else if (S_ISDIR(inode->i_mode)) {
inode->i_size = 0;
- inode->i_ino = INCFS_LOG_INODE;
- inode->i_private = NULL;
-
- inode_init_owner(inode, NULL, S_IFREG | READ_WRITE_FILE_MODE);
-
- inode->i_op = &incfs_file_inode_ops;
- inode->i_fop = &incfs_log_file_ops;
-
+ inode->i_blocks = 1;
+ inode->i_mapping->a_ops = &incfs_address_space_ops;
+ inode->i_op = &incfs_dir_inode_ops;
+ inode->i_fop = &incfs_dir_fops;
} else {
- /* Unknown inode requested. */
- return -EINVAL;
+ pr_warn_once("incfs: Unexpected inode type\n");
+ return -EBADF;
+ }
+
+ ihold(backing_inode);
+ node->n_backing_inode = backing_inode;
+ node->n_mount_info = get_mount_info(inode->i_sb);
+ inode->i_ctime = backing_inode->i_ctime;
+ inode->i_mtime = backing_inode->i_mtime;
+ inode->i_atime = backing_inode->i_atime;
+ inode->i_ino = backing_inode->i_ino;
+ if (backing_inode->i_ino < INCFS_START_INO_RANGE) {
+ pr_warn("incfs: ino conflict with backing FS %ld\n",
+ backing_inode->i_ino);
}
return 0;
@@ -443,222 +372,7 @@
.ino = backing_inode->i_ino,
.backing_dentry = backing_dentry,
.size = read_size_attr(backing_dentry),
- };
- struct inode *inode = iget5_locked(sb, search.ino, inode_test,
- inode_set, &search);
-
- if (!inode)
- return ERR_PTR(-ENOMEM);
-
- if (inode->i_state & I_NEW)
- unlock_new_inode(inode);
-
- return inode;
-}
-
-static ssize_t pending_reads_read(struct file *f, char __user *buf, size_t len,
- loff_t *ppos)
-{
- struct pending_reads_state *pr_state = f->private_data;
- struct mount_info *mi = get_mount_info(file_superblock(f));
- struct incfs_pending_read_info *reads_buf = NULL;
- size_t reads_to_collect = len / sizeof(*reads_buf);
- int last_known_read_sn = READ_ONCE(pr_state->last_pending_read_sn);
- int new_max_sn = last_known_read_sn;
- int reads_collected = 0;
- ssize_t result = 0;
- int i = 0;
-
- if (!incfs_fresh_pending_reads_exist(mi, last_known_read_sn))
- return 0;
-
- reads_buf = (struct incfs_pending_read_info *)get_zeroed_page(GFP_NOFS);
- if (!reads_buf)
- return -ENOMEM;
-
- reads_to_collect =
- min_t(size_t, PAGE_SIZE / sizeof(*reads_buf), reads_to_collect);
-
- reads_collected = incfs_collect_pending_reads(
- mi, last_known_read_sn, reads_buf, reads_to_collect);
- if (reads_collected < 0) {
- result = reads_collected;
- goto out;
- }
-
- for (i = 0; i < reads_collected; i++)
- if (reads_buf[i].serial_number > new_max_sn)
- new_max_sn = reads_buf[i].serial_number;
-
- /*
- * Just to make sure that we don't accidentally copy more data
- * to reads buffer than userspace can handle.
- */
- reads_collected = min_t(size_t, reads_collected, reads_to_collect);
- result = reads_collected * sizeof(*reads_buf);
-
- /* Copy reads info to the userspace buffer */
- if (copy_to_user(buf, reads_buf, result)) {
- result = -EFAULT;
- goto out;
- }
-
- WRITE_ONCE(pr_state->last_pending_read_sn, new_max_sn);
- *ppos = 0;
-out:
- if (reads_buf)
- free_page((unsigned long)reads_buf);
- return result;
-}
-
-
-static __poll_t pending_reads_poll(struct file *file, poll_table *wait)
-{
- struct pending_reads_state *state = file->private_data;
- struct mount_info *mi = get_mount_info(file_superblock(file));
- __poll_t ret = 0;
-
- poll_wait(file, &mi->mi_pending_reads_notif_wq, wait);
- if (incfs_fresh_pending_reads_exist(mi,
- state->last_pending_read_sn))
- ret = EPOLLIN | EPOLLRDNORM;
-
- return ret;
-}
-
-static int pending_reads_open(struct inode *inode, struct file *file)
-{
- struct pending_reads_state *state = NULL;
-
- state = kzalloc(sizeof(*state), GFP_NOFS);
- if (!state)
- return -ENOMEM;
-
- file->private_data = state;
- return 0;
-}
-
-static int pending_reads_release(struct inode *inode, struct file *file)
-{
- kfree(file->private_data);
- return 0;
-}
-
-static struct inode *fetch_pending_reads_inode(struct super_block *sb)
-{
- struct inode_search search = {
- .ino = INCFS_PENDING_READS_INODE
- };
- struct inode *inode = iget5_locked(sb, search.ino, inode_test,
- inode_set, &search);
-
- if (!inode)
- return ERR_PTR(-ENOMEM);
-
- if (inode->i_state & I_NEW)
- unlock_new_inode(inode);
-
- return inode;
-}
-
-static int log_open(struct inode *inode, struct file *file)
-{
- struct log_file_state *log_state = NULL;
- struct mount_info *mi = get_mount_info(file_superblock(file));
-
- log_state = kzalloc(sizeof(*log_state), GFP_NOFS);
- if (!log_state)
- return -ENOMEM;
-
- log_state->state = incfs_get_log_state(mi);
- file->private_data = log_state;
- return 0;
-}
-
-static int log_release(struct inode *inode, struct file *file)
-{
- kfree(file->private_data);
- return 0;
-}
-
-static ssize_t log_read(struct file *f, char __user *buf, size_t len,
- loff_t *ppos)
-{
- struct log_file_state *log_state = f->private_data;
- struct mount_info *mi = get_mount_info(file_superblock(f));
- int total_reads_collected = 0;
- int rl_size;
- ssize_t result = 0;
- struct incfs_pending_read_info *reads_buf;
- ssize_t reads_to_collect = len / sizeof(*reads_buf);
- ssize_t reads_per_page = PAGE_SIZE / sizeof(*reads_buf);
-
- rl_size = READ_ONCE(mi->mi_log.rl_size);
- if (rl_size == 0)
- return 0;
-
- reads_buf = (struct incfs_pending_read_info *)__get_free_page(GFP_NOFS);
- if (!reads_buf)
- return -ENOMEM;
-
- reads_to_collect = min_t(ssize_t, rl_size, reads_to_collect);
- while (reads_to_collect > 0) {
- struct read_log_state next_state;
- int reads_collected;
-
- memcpy(&next_state, &log_state->state, sizeof(next_state));
- reads_collected = incfs_collect_logged_reads(
- mi, &next_state, reads_buf,
- min_t(ssize_t, reads_to_collect, reads_per_page));
- if (reads_collected <= 0) {
- result = total_reads_collected ?
- total_reads_collected *
- sizeof(*reads_buf) :
- reads_collected;
- goto out;
- }
- if (copy_to_user(buf, reads_buf,
- reads_collected * sizeof(*reads_buf))) {
- result = total_reads_collected ?
- total_reads_collected *
- sizeof(*reads_buf) :
- -EFAULT;
- goto out;
- }
-
- memcpy(&log_state->state, &next_state, sizeof(next_state));
- total_reads_collected += reads_collected;
- buf += reads_collected * sizeof(*reads_buf);
- reads_to_collect -= reads_collected;
- }
-
- result = total_reads_collected * sizeof(*reads_buf);
- *ppos = 0;
-out:
- if (reads_buf)
- free_page((unsigned long)reads_buf);
- return result;
-}
-
-static __poll_t log_poll(struct file *file, poll_table *wait)
-{
- struct log_file_state *log_state = file->private_data;
- struct mount_info *mi = get_mount_info(file_superblock(file));
- int count;
- __poll_t ret = 0;
-
- poll_wait(file, &mi->mi_log.ml_notif_wq, wait);
- count = incfs_get_uncollected_logs_count(mi, &log_state->state);
- if (count >= mi->mi_options.read_log_wakeup_count)
- ret = EPOLLIN | EPOLLRDNORM;
-
- return ret;
-}
-
-static struct inode *fetch_log_inode(struct super_block *sb)
-{
- struct inode_search search = {
- .ino = INCFS_LOG_INODE
+ .verity = read_verity_attr(backing_dentry),
};
struct inode *inode = iget5_locked(sb, search.ino, inode_test,
inode_set, &search);
@@ -679,7 +393,7 @@
struct mount_info *mi = get_mount_info(file_superblock(file));
bool root;
- if (!dir || !mi) {
+ if (!dir) {
error = -EBADF;
goto out;
}
@@ -687,29 +401,15 @@
root = dir->backing_dir->f_inode
== d_inode(mi->mi_backing_dir_path.dentry);
- if (root && ctx->pos == 0) {
- if (!dir_emit(ctx, pending_reads_file_name,
- ARRAY_SIZE(pending_reads_file_name) - 1,
- INCFS_PENDING_READS_INODE, DT_REG)) {
- error = -EINVAL;
+ if (root) {
+ error = emit_pseudo_files(ctx);
+ if (error)
goto out;
- }
- ctx->pos++;
}
- if (root && ctx->pos == 1) {
- if (!dir_emit(ctx, log_file_name,
- ARRAY_SIZE(log_file_name) - 1,
- INCFS_LOG_INODE, DT_REG)) {
- error = -EINVAL;
- goto out;
- }
- ctx->pos++;
- }
-
- ctx->pos -= 2;
+ ctx->pos -= PSEUDO_FILE_COUNT;
error = iterate_dir(dir->backing_dir, ctx);
- ctx->pos += 2;
+ ctx->pos += PSEUDO_FILE_COUNT;
file->f_pos = dir->backing_dir->f_pos;
out:
if (error)
@@ -736,29 +436,10 @@
return 0;
}
-static struct dentry *incfs_lookup_dentry(struct dentry *parent,
- const char *name)
+static struct dentry *open_or_create_special_dir(struct dentry *backing_dir,
+ const char *name,
+ bool *created)
{
- struct inode *inode;
- struct dentry *result = NULL;
-
- if (!parent)
- return ERR_PTR(-EFAULT);
-
- inode = d_inode(parent);
- inode_lock_nested(inode, I_MUTEX_PARENT);
- result = lookup_one_len(name, parent, strlen(name));
- inode_unlock(inode);
-
- if (IS_ERR(result))
- pr_warn("%s err:%ld\n", __func__, PTR_ERR(result));
-
- return result;
-}
-
-static struct dentry *open_or_create_index_dir(struct dentry *backing_dir)
-{
- static const char name[] = ".index";
struct dentry *index_dentry;
struct inode *backing_inode = d_inode(backing_dir);
int err = 0;
@@ -770,6 +451,7 @@
return index_dentry;
} else if (d_really_is_positive(index_dentry)) {
/* Index already exists. */
+ *created = false;
return index_dentry;
}
@@ -783,12 +465,51 @@
return ERR_PTR(err);
}
- if (!d_really_is_positive(index_dentry)) {
+ if (!d_really_is_positive(index_dentry) ||
+ unlikely(d_unhashed(index_dentry))) {
dput(index_dentry);
return ERR_PTR(-EINVAL);
}
+ *created = true;
return index_dentry;
+}
+
+static int read_single_page_timeouts(struct data_file *df, struct file *f,
+ int block_index, struct mem_range range,
+ struct mem_range tmp)
+{
+ struct mount_info *mi = df->df_mount_info;
+ struct incfs_read_data_file_timeouts timeouts = {
+ .max_pending_time_us = U32_MAX,
+ };
+ int uid = current_uid().val;
+ int i;
+
+ spin_lock(&mi->mi_per_uid_read_timeouts_lock);
+ for (i = 0; i < mi->mi_per_uid_read_timeouts_size /
+ sizeof(*mi->mi_per_uid_read_timeouts); ++i) {
+ struct incfs_per_uid_read_timeouts *t =
+ &mi->mi_per_uid_read_timeouts[i];
+
+ if(t->uid == uid) {
+ timeouts.min_time_us = t->min_time_us;
+ timeouts.min_pending_time_us = t->min_pending_time_us;
+ timeouts.max_pending_time_us = t->max_pending_time_us;
+ break;
+ }
+ }
+ spin_unlock(&mi->mi_per_uid_read_timeouts_lock);
+ if (timeouts.max_pending_time_us == U32_MAX) {
+ u64 read_timeout_us = (u64)mi->mi_options.read_timeout_ms *
+ 1000;
+
+ timeouts.max_pending_time_us = read_timeout_us <= U32_MAX ?
+ read_timeout_us : U32_MAX;
+ }
+
+ return incfs_read_data_file_block(range, f, block_index, tmp,
+ &timeouts);
}
static int read_single_page(struct file *f, struct page *page)
@@ -799,28 +520,34 @@
ssize_t read_result = 0;
struct data_file *df = get_incfs_data_file(f);
int result = 0;
- void *page_start = kmap(page);
+ void *page_start;
int block_index;
- int timeout_ms;
- if (!df)
+ if (!df) {
+ SetPageError(page);
+ unlock_page(page);
return -EBADF;
+ }
+ page_start = kmap(page);
offset = page_offset(page);
- block_index = offset / INCFS_DATA_FILE_BLOCK_SIZE;
+ block_index = (offset + df->df_mapped_offset) /
+ INCFS_DATA_FILE_BLOCK_SIZE;
size = df->df_size;
- timeout_ms = df->df_mount_info->mi_options.read_timeout_ms;
if (offset < size) {
struct mem_range tmp = {
.len = 2 * INCFS_DATA_FILE_BLOCK_SIZE
};
-
tmp.data = (u8 *)__get_free_pages(GFP_NOFS, get_order(tmp.len));
+ if (!tmp.data) {
+ read_result = -ENOMEM;
+ goto err;
+ }
bytes_to_read = min_t(loff_t, size - offset, PAGE_SIZE);
- read_result = incfs_read_data_file_block(
- range(page_start, bytes_to_read), f, block_index,
- timeout_ms, tmp);
+
+ read_result = read_single_page_timeouts(df, f, block_index,
+ range(page_start, bytes_to_read), tmp);
free_pages((unsigned long)tmp.data, get_order(tmp.len));
} else {
@@ -828,6 +555,7 @@
read_result = 0;
}
+err:
if (read_result < 0)
result = read_result;
else if (read_result < PAGE_SIZE)
@@ -844,137 +572,7 @@
return result;
}
-static char *file_id_to_str(incfs_uuid_t id)
-{
- char *result = kmalloc(1 + sizeof(id.bytes) * 2, GFP_NOFS);
- char *end;
-
- if (!result)
- return NULL;
-
- end = bin2hex(result, id.bytes, sizeof(id.bytes));
- *end = 0;
- return result;
-}
-
-static struct mem_range incfs_copy_signature_info_from_user(u8 __user *original,
- u64 size)
-{
- u8 *result;
-
- if (!original)
- return range(NULL, 0);
-
- if (size > INCFS_MAX_SIGNATURE_SIZE)
- return range(ERR_PTR(-EFAULT), 0);
-
- result = kzalloc(size, GFP_NOFS | __GFP_COMP);
- if (!result)
- return range(ERR_PTR(-ENOMEM), 0);
-
- if (copy_from_user(result, original, size)) {
- kfree(result);
- return range(ERR_PTR(-EFAULT), 0);
- }
-
- return range(result, size);
-}
-
-static int init_new_file(struct mount_info *mi, struct dentry *dentry,
- incfs_uuid_t *uuid, u64 size, struct mem_range attr,
- u8 __user *user_signature_info, u64 signature_size)
-{
- struct path path = {};
- struct file *new_file;
- int error = 0;
- struct backing_file_context *bfc = NULL;
- u32 block_count;
- struct mem_range raw_signature = { NULL };
- struct mtree *hash_tree = NULL;
-
- if (!mi || !dentry || !uuid)
- return -EFAULT;
-
- /* Resize newly created file to its true size. */
- path = (struct path) {
- .mnt = mi->mi_backing_dir_path.mnt,
- .dentry = dentry
- };
- new_file = dentry_open(&path, O_RDWR | O_NOATIME | O_LARGEFILE,
- current_cred());
-
- if (IS_ERR(new_file)) {
- error = PTR_ERR(new_file);
- goto out;
- }
-
- bfc = incfs_alloc_bfc(mi, new_file);
- fput(new_file);
- if (IS_ERR(bfc)) {
- error = PTR_ERR(bfc);
- bfc = NULL;
- goto out;
- }
-
- mutex_lock(&bfc->bc_mutex);
- error = incfs_write_fh_to_backing_file(bfc, uuid, size);
- if (error)
- goto out;
-
- if (attr.data && attr.len) {
- error = incfs_write_file_attr_to_backing_file(bfc,
- attr, NULL);
- if (error)
- goto out;
- }
-
- block_count = (u32)get_blocks_count_for_size(size);
-
- if (user_signature_info) {
- raw_signature = incfs_copy_signature_info_from_user(
- user_signature_info, signature_size);
-
- if (IS_ERR(raw_signature.data)) {
- error = PTR_ERR(raw_signature.data);
- raw_signature.data = NULL;
- goto out;
- }
-
- hash_tree = incfs_alloc_mtree(raw_signature, block_count);
- if (IS_ERR(hash_tree)) {
- error = PTR_ERR(hash_tree);
- hash_tree = NULL;
- goto out;
- }
-
- error = incfs_write_signature_to_backing_file(
- bfc, raw_signature, hash_tree->hash_tree_area_size);
- if (error)
- goto out;
-
- block_count += get_blocks_count_for_size(
- hash_tree->hash_tree_area_size);
- }
-
- if (block_count)
- error = incfs_write_blockmap_to_backing_file(bfc, block_count);
-
- if (error)
- goto out;
-out:
- if (bfc) {
- mutex_unlock(&bfc->bc_mutex);
- incfs_free_bfc(bfc);
- }
- incfs_free_mtree(hash_tree);
- kfree(raw_signature.data);
-
- if (error)
- pr_debug("incfs: %s error: %d\n", __func__, error);
- return error;
-}
-
-static int incfs_link(struct dentry *what, struct dentry *where)
+int incfs_link(struct dentry *what, struct dentry *where)
{
struct dentry *parent_dentry = dget_parent(where);
struct inode *pinode = d_inode(parent_dentry);
@@ -988,7 +586,7 @@
return error;
}
-static int incfs_unlink(struct dentry *dentry)
+int incfs_unlink(struct dentry *dentry)
{
struct dentry *parent_dentry = dget_parent(dentry);
struct inode *pinode = d_inode(parent_dentry);
@@ -1016,274 +614,112 @@
return error;
}
-static int dir_relative_path_resolve(
- struct mount_info *mi,
- const char __user *relative_path,
- struct path *result_path)
+static void notify_unlink(struct dentry *dentry, const char *file_id_str,
+ const char *special_directory)
{
- struct path *base_path = &mi->mi_backing_dir_path;
- int dir_fd = get_unused_fd_flags(0);
- struct file *dir_f = NULL;
+ struct dentry *root = dentry;
+ struct dentry *file = NULL;
+ struct dentry *dir = NULL;
int error = 0;
+ bool take_lock = root->d_parent != root->d_parent->d_parent;
- if (dir_fd < 0)
- return dir_fd;
+ while (root != root->d_parent)
+ root = root->d_parent;
- dir_f = dentry_open(base_path, O_RDONLY | O_NOATIME, current_cred());
+ if (take_lock)
+ dir = incfs_lookup_dentry(root, special_directory);
+ else
+ dir = lookup_one_len(special_directory, root,
+ strlen(special_directory));
- if (IS_ERR(dir_f)) {
- error = PTR_ERR(dir_f);
+ if (IS_ERR(dir)) {
+ error = PTR_ERR(dir);
goto out;
}
- fd_install(dir_fd, dir_f);
-
- if (!relative_path) {
- /* No relative path given, just return the base dir. */
- *result_path = *base_path;
- path_get(result_path);
+ if (d_is_negative(dir)) {
+ error = -ENOENT;
goto out;
}
- error = user_path_at_empty(dir_fd, relative_path,
- LOOKUP_FOLLOW | LOOKUP_DIRECTORY, result_path, NULL);
+ file = incfs_lookup_dentry(dir, file_id_str);
+ if (IS_ERR(file)) {
+ error = PTR_ERR(file);
+ goto out;
+ }
+ if (d_is_negative(file)) {
+ error = -ENOENT;
+ goto out;
+ }
+
+ fsnotify_unlink(d_inode(dir), file);
+ d_delete(file);
out:
- ksys_close(dir_fd);
if (error)
- pr_debug("incfs: %s %d\n", __func__, error);
- return error;
+ pr_warn("%s failed with error %d\n", __func__, error);
+
+ dput(dir);
+ dput(file);
}
-static int validate_name(char *file_name)
+static void maybe_delete_incomplete_file(struct file *f,
+ struct data_file *df)
{
- struct mem_range name = range(file_name, strlen(file_name));
- int i = 0;
-
- if (name.len > INCFS_MAX_NAME_LEN)
- return -ENAMETOOLONG;
-
- if (incfs_equal_ranges(pending_reads_file_name_range, name))
- return -EINVAL;
-
- for (i = 0; i < name.len; i++)
- if (name.data[i] == '/')
- return -EINVAL;
-
- return 0;
-}
-
-static int chmod(struct dentry *dentry, umode_t mode)
-{
- struct inode *inode = dentry->d_inode;
- struct inode *delegated_inode = NULL;
- struct iattr newattrs;
+ struct backing_file_context *bfc;
+ struct mount_info *mi = df->df_mount_info;
+ char *file_id_str = NULL;
+ struct dentry *incomplete_file_dentry = NULL;
+ const struct cred *old_cred = override_creds(mi->mi_owner);
int error;
-retry_deleg:
- inode_lock(inode);
- newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
- newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
- error = notify_change(dentry, &newattrs, &delegated_inode);
- inode_unlock(inode);
- if (delegated_inode) {
- error = break_deleg_wait(&delegated_inode);
- if (!error)
- goto retry_deleg;
- }
- return error;
-}
-
-static long ioctl_create_file(struct mount_info *mi,
- struct incfs_new_file_args __user *usr_args)
-{
- struct incfs_new_file_args args;
- char *file_id_str = NULL;
- struct dentry *index_file_dentry = NULL;
- struct dentry *named_file_dentry = NULL;
- struct path parent_dir_path = {};
- struct inode *index_dir_inode = NULL;
- __le64 size_attr_value = 0;
- char *file_name = NULL;
- char *attr_value = NULL;
- int error = 0;
- bool locked = false;
-
- if (!mi || !mi->mi_index_dir) {
- error = -EFAULT;
- goto out;
- }
-
- if (copy_from_user(&args, usr_args, sizeof(args)) > 0) {
- error = -EFAULT;
- goto out;
- }
-
- file_name = strndup_user(u64_to_user_ptr(args.file_name), PATH_MAX);
- if (IS_ERR(file_name)) {
- error = PTR_ERR(file_name);
- file_name = NULL;
- goto out;
- }
-
- error = validate_name(file_name);
- if (error)
+ if (atomic_read(&df->df_data_blocks_written) < df->df_data_block_count)
goto out;
- file_id_str = file_id_to_str(args.file_id);
- if (!file_id_str) {
- error = -ENOMEM;
- goto out;
- }
+ /* Truncate file to remove any preallocated space */
+ bfc = df->df_backing_file_context;
+ if (bfc) {
+ struct file *f = bfc->bc_file;
- error = mutex_lock_interruptible(&mi->mi_dir_struct_mutex);
- if (error)
- goto out;
- locked = true;
+ if (f) {
+ loff_t size = i_size_read(file_inode(f));
- /* Find a directory to put the file into. */
- error = dir_relative_path_resolve(mi,
- u64_to_user_ptr(args.directory_path),
- &parent_dir_path);
- if (error)
- goto out;
-
- if (parent_dir_path.dentry == mi->mi_index_dir) {
- /* Can't create a file directly inside .index */
- error = -EBUSY;
- goto out;
- }
-
- /* Look up a dentry in the parent dir. It should be negative. */
- named_file_dentry = incfs_lookup_dentry(parent_dir_path.dentry,
- file_name);
- if (!named_file_dentry) {
- error = -EFAULT;
- goto out;
- }
- if (IS_ERR(named_file_dentry)) {
- error = PTR_ERR(named_file_dentry);
- named_file_dentry = NULL;
- goto out;
- }
- if (d_really_is_positive(named_file_dentry)) {
- /* File with this path already exists. */
- error = -EEXIST;
- goto out;
- }
- /* Look up a dentry in the .index dir. It should be negative. */
- index_file_dentry = incfs_lookup_dentry(mi->mi_index_dir, file_id_str);
- if (!index_file_dentry) {
- error = -EFAULT;
- goto out;
- }
- if (IS_ERR(index_file_dentry)) {
- error = PTR_ERR(index_file_dentry);
- index_file_dentry = NULL;
- goto out;
- }
- if (d_really_is_positive(index_file_dentry)) {
- /* File with this ID already exists in index. */
- error = -EEXIST;
- goto out;
- }
-
- /* Creating a file in the .index dir. */
- index_dir_inode = d_inode(mi->mi_index_dir);
- inode_lock_nested(index_dir_inode, I_MUTEX_PARENT);
- error = vfs_create(index_dir_inode, index_file_dentry, args.mode | 0222,
- true);
- inode_unlock(index_dir_inode);
-
- if (error)
- goto out;
- if (!d_really_is_positive(index_file_dentry)) {
- error = -EINVAL;
- goto out;
- }
-
- error = chmod(index_file_dentry, args.mode | 0222);
- if (error) {
- pr_debug("incfs: chmod err: %d\n", error);
- goto delete_index_file;
- }
-
- /* Save the file's ID as an xattr for easy fetching in future. */
- error = vfs_setxattr(index_file_dentry, INCFS_XATTR_ID_NAME,
- file_id_str, strlen(file_id_str), XATTR_CREATE);
- if (error) {
- pr_debug("incfs: vfs_setxattr err:%d\n", error);
- goto delete_index_file;
- }
-
- /* Save the file's size as an xattr for easy fetching in future. */
- size_attr_value = cpu_to_le64(args.size);
- error = vfs_setxattr(index_file_dentry, INCFS_XATTR_SIZE_NAME,
- (char *)&size_attr_value, sizeof(size_attr_value),
- XATTR_CREATE);
- if (error) {
- pr_debug("incfs: vfs_setxattr err:%d\n", error);
- goto delete_index_file;
- }
-
- /* Save the file's attribute as an xattr */
- if (args.file_attr_len && args.file_attr) {
- if (args.file_attr_len > INCFS_MAX_FILE_ATTR_SIZE) {
- error = -E2BIG;
- goto delete_index_file;
+ error = vfs_truncate(&f->f_path, size);
+ if (error)
+ /* No useful action on failure */
+ pr_warn("incfs: Failed to truncate complete file: %d\n",
+ error);
}
-
- attr_value = kmalloc(args.file_attr_len, GFP_NOFS);
- if (!attr_value) {
- error = -ENOMEM;
- goto delete_index_file;
- }
-
- if (copy_from_user(attr_value,
- u64_to_user_ptr(args.file_attr),
- args.file_attr_len) > 0) {
- error = -EFAULT;
- goto delete_index_file;
- }
-
- error = vfs_setxattr(index_file_dentry,
- INCFS_XATTR_METADATA_NAME,
- attr_value, args.file_attr_len,
- XATTR_CREATE);
-
- if (error)
- goto delete_index_file;
}
- /* Initializing a newly created file. */
- error = init_new_file(mi, index_file_dentry, &args.file_id, args.size,
- range(attr_value, args.file_attr_len),
- (u8 __user *)args.signature_info,
- args.signature_size);
- if (error)
- goto delete_index_file;
-
- /* Linking a file with it's real name from the requested dir. */
- error = incfs_link(index_file_dentry, named_file_dentry);
-
- if (!error)
+ /* This is best effort - there is no useful action to take on failure */
+ file_id_str = file_id_to_str(df->df_id);
+ if (!file_id_str)
goto out;
-delete_index_file:
- incfs_unlink(index_file_dentry);
+ incomplete_file_dentry = incfs_lookup_dentry(
+ df->df_mount_info->mi_incomplete_dir,
+ file_id_str);
+ if (!incomplete_file_dentry || IS_ERR(incomplete_file_dentry)) {
+ incomplete_file_dentry = NULL;
+ goto out;
+ }
+
+ if (!d_really_is_positive(incomplete_file_dentry))
+ goto out;
+
+ vfs_fsync(df->df_backing_file_context->bc_file, 0);
+ error = incfs_unlink(incomplete_file_dentry);
+ if (error) {
+ pr_warn("incfs: Deleting incomplete file failed: %d\n", error);
+ goto out;
+ }
+
+ notify_unlink(f->f_path.dentry, file_id_str, INCFS_INCOMPLETE_NAME);
out:
- if (error)
- pr_debug("incfs: %s err:%d\n", __func__, error);
-
+ dput(incomplete_file_dentry);
kfree(file_id_str);
- kfree(file_name);
- kfree(attr_value);
- dput(named_file_dentry);
- dput(index_file_dentry);
- path_put(&parent_dir_path);
- if (locked)
- mutex_unlock(&mi->mi_dir_struct_mutex);
- return error;
+ revert_creds(old_cred);
}
static long ioctl_fill_blocks(struct file *f, void __user *arg)
@@ -1292,6 +728,7 @@
struct incfs_fill_blocks fill_blocks;
struct incfs_fill_block __user *usr_fill_block_array;
struct data_file *df = get_incfs_data_file(f);
+ struct incfs_file_data *fd = f->private_data;
const ssize_t data_buf_size = 2 * INCFS_DATA_FILE_BLOCK_SIZE;
u8 *data_buf = NULL;
ssize_t error = 0;
@@ -1300,7 +737,7 @@
if (!df)
return -EBADF;
- if ((uintptr_t)f->private_data != CAN_FILL)
+ if (!fd || fd->fd_fill_permission != CAN_FILL)
return -EPERM;
if (copy_from_user(&fill_blocks, usr_fill_blocks, sizeof(fill_blocks)))
@@ -1346,6 +783,8 @@
if (data_buf)
free_pages((unsigned long)data_buf, get_order(data_buf_size));
+ maybe_delete_incomplete_file(f, df);
+
/*
* Only report the error if no records were processed, otherwise
* just return how many were processed successfully.
@@ -1354,53 +793,6 @@
return error;
return i;
-}
-
-static long ioctl_permit_fill(struct file *f, void __user *arg)
-{
- struct incfs_permit_fill __user *usr_permit_fill = arg;
- struct incfs_permit_fill permit_fill;
- long error = 0;
- struct file *file = NULL;
-
- if (f->f_op != &incfs_pending_read_file_ops)
- return -EPERM;
-
- if (copy_from_user(&permit_fill, usr_permit_fill, sizeof(permit_fill)))
- return -EFAULT;
-
- file = fget(permit_fill.file_descriptor);
- if (IS_ERR(file))
- return PTR_ERR(file);
-
- if (file->f_op != &incfs_file_ops) {
- error = -EPERM;
- goto out;
- }
-
- if (file->f_inode->i_sb != f->f_inode->i_sb) {
- error = -EPERM;
- goto out;
- }
-
- switch ((uintptr_t)file->private_data) {
- case CANT_FILL:
- file->private_data = (void *)CAN_FILL;
- break;
-
- case CAN_FILL:
- pr_debug("CAN_FILL already set");
- break;
-
- default:
- pr_warn("Invalid file private data");
- error = -EFAULT;
- goto out;
- }
-
-out:
- fput(file);
- return error;
}
static long ioctl_read_file_signature(struct file *f, void __user *arg)
@@ -1456,18 +848,19 @@
struct incfs_get_filled_blocks_args __user *args_usr_ptr = arg;
struct incfs_get_filled_blocks_args args = {};
struct data_file *df = get_incfs_data_file(f);
+ struct incfs_file_data *fd = f->private_data;
int error;
- if (!df)
+ if (!df || !fd)
return -EINVAL;
- if ((uintptr_t)f->private_data != CAN_FILL)
+ if (fd->fd_fill_permission != CAN_FILL)
return -EPERM;
if (copy_from_user(&args, args_usr_ptr, sizeof(args)) > 0)
return -EINVAL;
- error = incfs_get_filled_blocks(df, &args);
+ error = incfs_get_filled_blocks(df, fd, &args);
if (copy_to_user(args_usr_ptr, &args, sizeof(args)))
return -EFAULT;
@@ -1475,25 +868,80 @@
return error;
}
+static long ioctl_get_block_count(struct file *f, void __user *arg)
+{
+ struct incfs_get_block_count_args __user *args_usr_ptr = arg;
+ struct incfs_get_block_count_args args = {};
+ struct data_file *df = get_incfs_data_file(f);
+
+ if (!df)
+ return -EINVAL;
+
+ args.total_data_blocks_out = df->df_data_block_count;
+ args.filled_data_blocks_out = atomic_read(&df->df_data_blocks_written);
+ args.total_hash_blocks_out = df->df_total_block_count -
+ df->df_data_block_count;
+ args.filled_hash_blocks_out = atomic_read(&df->df_hash_blocks_written);
+
+ if (copy_to_user(args_usr_ptr, &args, sizeof(args)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static int incfs_ioctl_get_flags(struct file *f, void __user *arg)
+{
+ u32 flags = IS_VERITY(file_inode(f)) ? FS_VERITY_FL : 0;
+
+ return put_user(flags, (int __user *) arg);
+}
+
static long dispatch_ioctl(struct file *f, unsigned int req, unsigned long arg)
{
- struct mount_info *mi = get_mount_info(file_superblock(f));
-
switch (req) {
- case INCFS_IOC_CREATE_FILE:
- return ioctl_create_file(mi, (void __user *)arg);
case INCFS_IOC_FILL_BLOCKS:
return ioctl_fill_blocks(f, (void __user *)arg);
- case INCFS_IOC_PERMIT_FILL:
- return ioctl_permit_fill(f, (void __user *)arg);
case INCFS_IOC_READ_FILE_SIGNATURE:
return ioctl_read_file_signature(f, (void __user *)arg);
case INCFS_IOC_GET_FILLED_BLOCKS:
return ioctl_get_filled_blocks(f, (void __user *)arg);
+ case INCFS_IOC_GET_BLOCK_COUNT:
+ return ioctl_get_block_count(f, (void __user *)arg);
+ case FS_IOC_ENABLE_VERITY:
+ return incfs_ioctl_enable_verity(f, (const void __user *)arg);
+ case FS_IOC_GETFLAGS:
+ return incfs_ioctl_get_flags(f, (void __user *) arg);
+ case FS_IOC_MEASURE_VERITY:
+ return incfs_ioctl_measure_verity(f, (void __user *)arg);
+ case FS_IOC_READ_VERITY_METADATA:
+ return incfs_ioctl_read_verity_metadata(f, (void __user *)arg);
default:
return -EINVAL;
}
}
+
+#ifdef CONFIG_COMPAT
+static long incfs_compat_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ switch (cmd) {
+ case FS_IOC32_GETFLAGS:
+ cmd = FS_IOC_GETFLAGS;
+ break;
+ case INCFS_IOC_FILL_BLOCKS:
+ case INCFS_IOC_READ_FILE_SIGNATURE:
+ case INCFS_IOC_GET_FILLED_BLOCKS:
+ case INCFS_IOC_GET_BLOCK_COUNT:
+ case FS_IOC_ENABLE_VERITY:
+ case FS_IOC_MEASURE_VERITY:
+ case FS_IOC_READ_VERITY_METADATA:
+ break;
+ default:
+ return -ENOIOCTLCMD;
+ }
+ return dispatch_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
+}
+#endif
static struct dentry *dir_lookup(struct inode *dir_inode, struct dentry *dentry,
unsigned int flags)
@@ -1503,40 +951,18 @@
struct dentry *backing_dentry = NULL;
struct path dir_backing_path = {};
struct inode_info *dir_info = get_incfs_node(dir_inode);
- struct mem_range name_range =
- range((u8 *)dentry->d_name.name, dentry->d_name.len);
int err = 0;
+
+ if (!mi || !dir_info || !dir_info->n_backing_inode)
+ return ERR_PTR(-EBADF);
if (d_inode(mi->mi_backing_dir_path.dentry) ==
dir_info->n_backing_inode) {
/* We do lookup in the FS root. Show pseudo files. */
-
- if (incfs_equal_ranges(pending_reads_file_name_range,
- name_range)) {
- struct inode *inode = fetch_pending_reads_inode(
- dir_inode->i_sb);
-
- if (IS_ERR(inode)) {
- err = PTR_ERR(inode);
- goto out;
- }
-
- d_add(dentry, inode);
+ err = dir_lookup_pseudo_files(dir_inode->i_sb, dentry);
+ if (err != -ENOENT)
goto out;
- }
-
- if (incfs_equal_ranges(log_file_name_range, name_range)) {
- struct inode *inode = fetch_log_inode(
- dir_inode->i_sb);
-
- if (IS_ERR(inode)) {
- err = PTR_ERR(inode);
- goto out;
- }
-
- d_add(dentry, inode);
- goto out;
- }
+ err = 0;
}
dir_dentry = dget_parent(dentry);
@@ -1622,7 +1048,7 @@
if (!backing_dentry) {
err = -EBADF;
- goto out;
+ goto path_err;
}
if (backing_dentry->d_parent == mi->mi_index_dir) {
@@ -1631,13 +1057,19 @@
goto out;
}
+ if (backing_dentry->d_parent == mi->mi_incomplete_dir) {
+ /* Can't create a subdir inside .incomplete */
+ err = -EBUSY;
+ goto out;
+ }
inode_lock_nested(dir_node->n_backing_inode, I_MUTEX_PARENT);
err = vfs_mkdir(dir_node->n_backing_inode, backing_dentry, mode | 0222);
inode_unlock(dir_node->n_backing_inode);
if (!err) {
struct inode *inode = NULL;
- if (d_really_is_negative(backing_dentry)) {
+ if (d_really_is_negative(backing_dentry) ||
+ unlikely(d_unhashed(backing_dentry))) {
err = -EINVAL;
goto out;
}
@@ -1654,23 +1086,33 @@
if (d_really_is_negative(dentry))
d_drop(dentry);
path_put(&backing_path);
+
+path_err:
mutex_unlock(&mi->mi_dir_struct_mutex);
if (err)
pr_debug("incfs: %s err:%d\n", __func__, err);
return err;
}
-/* Delete file referenced by backing_dentry and also its hardlink from .index */
-static int final_file_delete(struct mount_info *mi,
- struct dentry *backing_dentry)
+/*
+ * Delete file referenced by backing_dentry and if appropriate its hardlink
+ * from .index and .incomplete
+ */
+static int file_delete(struct mount_info *mi, struct dentry *dentry,
+ struct dentry *backing_dentry, int nlink)
{
struct dentry *index_file_dentry = NULL;
+ struct dentry *incomplete_file_dentry = NULL;
/* 2 chars per byte of file ID + 1 char for \0 */
char file_id_str[2 * sizeof(incfs_uuid_t) + 1] = {0};
ssize_t uuid_size = 0;
int error = 0;
WARN_ON(!mutex_is_locked(&mi->mi_dir_struct_mutex));
+
+ if (nlink > 3)
+ goto just_unlink;
+
uuid_size = vfs_getxattr(backing_dentry, INCFS_XATTR_ID_NAME,
file_id_str, 2 * sizeof(incfs_uuid_t));
if (uuid_size < 0) {
@@ -1686,17 +1128,50 @@
index_file_dentry = incfs_lookup_dentry(mi->mi_index_dir, file_id_str);
if (IS_ERR(index_file_dentry)) {
error = PTR_ERR(index_file_dentry);
+ index_file_dentry = NULL;
goto out;
}
- error = incfs_unlink(backing_dentry);
- if (error)
- goto out;
+ if (d_really_is_positive(index_file_dentry) && nlink > 0)
+ nlink--;
- if (d_really_is_positive(index_file_dentry))
+ if (nlink > 2)
+ goto just_unlink;
+
+ incomplete_file_dentry = incfs_lookup_dentry(mi->mi_incomplete_dir,
+ file_id_str);
+ if (IS_ERR(incomplete_file_dentry)) {
+ error = PTR_ERR(incomplete_file_dentry);
+ incomplete_file_dentry = NULL;
+ goto out;
+ }
+
+ if (d_really_is_positive(incomplete_file_dentry) && nlink > 0)
+ nlink--;
+
+ if (nlink > 1)
+ goto just_unlink;
+
+ if (d_really_is_positive(index_file_dentry)) {
error = incfs_unlink(index_file_dentry);
+ if (error)
+ goto out;
+ notify_unlink(dentry, file_id_str, INCFS_INDEX_NAME);
+ }
+
+ if (d_really_is_positive(incomplete_file_dentry)) {
+ error = incfs_unlink(incomplete_file_dentry);
+ if (error)
+ goto out;
+ notify_unlink(dentry, file_id_str, INCFS_INCOMPLETE_NAME);
+ }
+
+just_unlink:
+ error = incfs_unlink(backing_dentry);
+
out:
dput(index_file_dentry);
+ dput(incomplete_file_dentry);
if (error)
pr_debug("incfs: delete_file_from_index err:%d\n", error);
return error;
@@ -1709,6 +1184,9 @@
struct kstat stat;
int err = 0;
+ if (!mi)
+ return -EBADF;
+
err = mutex_lock_interruptible(&mi->mi_dir_struct_mutex);
if (err)
return err;
@@ -1716,11 +1194,17 @@
get_incfs_backing_path(dentry, &backing_path);
if (!backing_path.dentry) {
err = -EBADF;
- goto out;
+ goto path_err;
}
if (backing_path.dentry->d_parent == mi->mi_index_dir) {
/* Direct unlink from .index are not allowed. */
+ err = -EBUSY;
+ goto out;
+ }
+
+ if (backing_path.dentry->d_parent == mi->mi_incomplete_dir) {
+ /* Direct unlink from .incomplete are not allowed. */
err = -EBUSY;
goto out;
}
@@ -1730,20 +1214,12 @@
if (err)
goto out;
- if (stat.nlink == 2) {
- /*
- * This is the last named link to this file. The only one left
- * is in .index. Remove them both now.
- */
- err = final_file_delete(mi, backing_path.dentry);
- } else {
- /* There are other links to this file. Remove just this one. */
- err = incfs_unlink(backing_path.dentry);
- }
+ err = file_delete(mi, dentry, backing_path.dentry, stat.nlink);
d_drop(dentry);
out:
path_put(&backing_path);
+path_err:
if (err)
pr_debug("incfs: %s err:%d\n", __func__, err);
mutex_unlock(&mi->mi_dir_struct_mutex);
@@ -1758,6 +1234,9 @@
struct path backing_new_path = {};
int error = 0;
+ if (!mi)
+ return -EBADF;
+
error = mutex_lock_interruptible(&mi->mi_dir_struct_mutex);
if (error)
return error;
@@ -1767,6 +1246,12 @@
if (backing_new_path.dentry->d_parent == mi->mi_index_dir) {
/* Can't link to .index */
+ error = -EBUSY;
+ goto out;
+ }
+
+ if (backing_new_path.dentry->d_parent == mi->mi_incomplete_dir) {
+ /* Can't link to .incomplete */
error = -EBUSY;
goto out;
}
@@ -1804,6 +1289,9 @@
struct path backing_path = {};
int err = 0;
+ if (!mi)
+ return -EBADF;
+
err = mutex_lock_interruptible(&mi->mi_dir_struct_mutex);
if (err)
return err;
@@ -1811,11 +1299,17 @@
get_incfs_backing_path(dentry, &backing_path);
if (!backing_path.dentry) {
err = -EBADF;
- goto out;
+ goto path_err;
}
if (backing_path.dentry == mi->mi_index_dir) {
/* Can't delete .index */
+ err = -EBUSY;
+ goto out;
+ }
+
+ if (backing_path.dentry == mi->mi_incomplete_dir) {
+ /* Can't delete .incomplete */
err = -EBUSY;
goto out;
}
@@ -1825,6 +1319,8 @@
d_drop(dentry);
out:
path_put(&backing_path);
+
+path_err:
if (err)
pr_debug("incfs: %s err:%d\n", __func__, err);
mutex_unlock(&mi->mi_dir_struct_mutex);
@@ -1843,14 +1339,19 @@
struct dentry *trap;
int error = 0;
- if (!mi)
- return -EBADF;
-
error = mutex_lock_interruptible(&mi->mi_dir_struct_mutex);
if (error)
return error;
backing_old_dentry = get_incfs_dentry(old_dentry)->backing_path.dentry;
+
+ if (!backing_old_dentry || backing_old_dentry == mi->mi_index_dir ||
+ backing_old_dentry == mi->mi_incomplete_dir) {
+ /* Renaming .index or .incomplete not allowed */
+ error = -EBUSY;
+ goto exit;
+ }
+
backing_new_dentry = get_incfs_dentry(new_dentry)->backing_path.dentry;
dget(backing_old_dentry);
dget(backing_new_dentry);
@@ -1859,8 +1360,9 @@
backing_new_dir_dentry = dget_parent(backing_new_dentry);
target_inode = d_inode(new_dentry);
- if (backing_old_dir_dentry == mi->mi_index_dir) {
- /* Direct moves from .index are not allowed. */
+ if (backing_old_dir_dentry == mi->mi_index_dir ||
+ backing_old_dir_dentry == mi->mi_incomplete_dir) {
+ /* Direct moves from .index or .incomplete are not allowed. */
error = -EBUSY;
goto out;
}
@@ -1897,6 +1399,7 @@
dput(backing_new_dentry);
dput(backing_old_dentry);
+exit:
mutex_unlock(&mi->mi_dir_struct_mutex);
if (error)
pr_debug("incfs: %s err:%d\n", __func__, error);
@@ -1910,12 +1413,21 @@
struct file *backing_file = NULL;
struct path backing_path = {};
int err = 0;
+ int flags = O_NOATIME | O_LARGEFILE |
+ (S_ISDIR(inode->i_mode) ? O_RDONLY : O_RDWR);
const struct cred *old_cred;
+ WARN_ON(file->private_data);
+
+ if (!mi)
+ return -EBADF;
+
get_incfs_backing_path(file->f_path.dentry, &backing_path);
+ if (!backing_path.dentry)
+ return -EBADF;
+
old_cred = override_creds(mi->mi_owner);
- backing_file = dentry_open(&backing_path,
- O_RDWR | O_NOATIME | O_LARGEFILE, current_cred());
+ backing_file = dentry_open(&backing_path, flags, current_cred());
revert_creds(old_cred);
path_put(&backing_path);
@@ -1926,8 +1438,25 @@
}
if (S_ISREG(inode->i_mode)) {
+ struct incfs_file_data *fd = kzalloc(sizeof(*fd), GFP_NOFS);
+
+ if (!fd) {
+ err = -ENOMEM;
+ goto out;
+ }
+
+ *fd = (struct incfs_file_data) {
+ .fd_fill_permission = CANT_FILL,
+ };
+ file->private_data = fd;
+
err = make_inode_ready_for_data_ops(mi, inode, backing_file);
- file->private_data = (void *)CANT_FILL;
+ if (err)
+ goto out;
+
+ err = incfs_fsverity_file_open(inode, file);
+ if (err)
+ goto out;
} else if (S_ISDIR(inode->i_mode)) {
struct dir_file *dir = NULL;
@@ -1940,9 +1469,17 @@
err = -EBADF;
out:
- if (err)
- pr_debug("incfs: %s name:%s err: %d\n", __func__,
- file->f_path.dentry->d_name.name, err);
+ if (err) {
+ pr_debug("name:%s err: %d\n",
+ file->f_path.dentry->d_name.name, err);
+ if (S_ISREG(inode->i_mode))
+ kfree(file->private_data);
+ else if (S_ISDIR(inode->i_mode))
+ incfs_free_dir_file(file->private_data);
+
+ file->private_data = NULL;
+ }
+
if (backing_file)
fput(backing_file);
return err;
@@ -1951,9 +1488,8 @@
static int file_release(struct inode *inode, struct file *file)
{
if (S_ISREG(inode->i_mode)) {
- /* Do nothing.
- * data_file is released only by inode eviction.
- */
+ kfree(file->private_data);
+ file->private_data = NULL;
} else if (S_ISDIR(inode->i_mode)) {
struct dir_file *dir = get_incfs_dir_file(file);
@@ -2056,6 +1592,10 @@
if (ia->ia_valid & ATTR_SIZE)
return -EINVAL;
+ if ((ia->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) &&
+ (ia->ia_valid & ATTR_MODE))
+ return -EINVAL;
+
if (!di)
return -EINVAL;
backing_dentry = di->backing_path.dentry;
@@ -2085,6 +1625,43 @@
return simple_setattr(dentry, ia);
}
+
+static int incfs_getattr(const struct path *path,
+ struct kstat *stat, u32 request_mask,
+ unsigned int query_flags)
+{
+ struct inode *inode = d_inode(path->dentry);
+
+ generic_fillattr(inode, stat);
+
+ if (inode->i_ino < INCFS_START_INO_RANGE)
+ return 0;
+
+ stat->attributes &= ~STATX_ATTR_VERITY;
+ if (IS_VERITY(inode))
+ stat->attributes |= STATX_ATTR_VERITY;
+ stat->attributes_mask |= STATX_ATTR_VERITY;
+
+ if (request_mask & STATX_BLOCKS) {
+ struct kstat backing_kstat;
+ struct dentry_info *di = get_incfs_dentry(path->dentry);
+ int error = 0;
+ struct path *backing_path;
+
+ if (!di)
+ return -EFSCORRUPTED;
+ backing_path = &di->backing_path;
+ error = vfs_getattr(backing_path, &backing_kstat, STATX_BLOCKS,
+ AT_STATX_SYNC_AS_STAT);
+ if (error)
+ return error;
+
+ stat->blocks = backing_kstat.blocks;
+ }
+
+ return 0;
+}
+
static ssize_t incfs_getxattr(struct dentry *d, const char *name,
void *value, size_t size)
{
@@ -2092,9 +1669,7 @@
struct mount_info *mi = get_mount_info(d->d_sb);
char *stored_value;
size_t stored_size;
-
- if (!mi)
- return -EBADF;
+ int i;
if (di && di->backing_path.dentry)
return vfs_getxattr(di->backing_path.dentry, name, value, size);
@@ -2102,16 +1677,14 @@
if (strcmp(name, "security.selinux"))
return -ENODATA;
- if (!strcmp(d->d_iname, INCFS_PENDING_READS_FILENAME)) {
- stored_value = mi->pending_read_xattr;
- stored_size = mi->pending_read_xattr_size;
- } else if (!strcmp(d->d_iname, INCFS_LOG_FILENAME)) {
- stored_value = mi->log_xattr;
- stored_size = mi->log_xattr_size;
- } else {
+ for (i = 0; i < PSEUDO_FILE_COUNT; ++i)
+ if (!strcmp(d->d_iname, incfs_pseudo_file_names[i].data))
+ break;
+ if (i == PSEUDO_FILE_COUNT)
return -ENODATA;
- }
+ stored_value = mi->pseudo_file_xattr[i].data;
+ stored_size = mi->pseudo_file_xattr[i].len;
if (!stored_value)
return -ENODATA;
@@ -2120,7 +1693,6 @@
memcpy(value, stored_value, stored_size);
return stored_size;
-
}
@@ -2129,11 +1701,9 @@
{
struct dentry_info *di = get_incfs_dentry(d);
struct mount_info *mi = get_mount_info(d->d_sb);
- void **stored_value;
+ u8 **stored_value;
size_t *stored_size;
-
- if (!mi)
- return -EBADF;
+ int i;
if (di && di->backing_path.dentry)
return vfs_setxattr(di->backing_path.dentry, name, value, size,
@@ -2145,16 +1715,14 @@
if (size > INCFS_MAX_FILE_ATTR_SIZE)
return -E2BIG;
- if (!strcmp(d->d_iname, INCFS_PENDING_READS_FILENAME)) {
- stored_value = &mi->pending_read_xattr;
- stored_size = &mi->pending_read_xattr_size;
- } else if (!strcmp(d->d_iname, INCFS_LOG_FILENAME)) {
- stored_value = &mi->log_xattr;
- stored_size = &mi->log_xattr_size;
- } else {
+ for (i = 0; i < PSEUDO_FILE_COUNT; ++i)
+ if (!strcmp(d->d_iname, incfs_pseudo_file_names[i].data))
+ break;
+ if (i == PSEUDO_FILE_COUNT)
return -ENODATA;
- }
+ stored_value = &mi->pseudo_file_xattr[i].data;
+ stored_size = &mi->pseudo_file_xattr[i].len;
kfree (*stored_value);
*stored_value = kzalloc(size, GFP_NOFS);
if (!*stored_value)
@@ -2175,22 +1743,18 @@
return vfs_listxattr(di->backing_path.dentry, list, size);
}
-static int incfs_test_super(struct super_block *s, void *p)
-{
- return s->s_fs_info != NULL;
-}
-
struct dentry *incfs_mount_fs(struct file_system_type *type, int flags,
const char *dev_name, void *data)
{
struct mount_options options = {};
struct mount_info *mi = NULL;
struct path backing_dir_path = {};
- struct dentry *index_dir;
+ struct dentry *index_dir = NULL;
+ struct dentry *incomplete_dir = NULL;
struct super_block *src_fs_sb = NULL;
struct inode *root_inode = NULL;
- struct super_block *sb = sget(type, incfs_test_super, set_anon_super,
- flags, NULL);
+ struct super_block *sb = sget(type, NULL, set_anon_super, flags, NULL);
+ bool dir_created = false;
int error = 0;
if (IS_ERR(sb))
@@ -2199,7 +1763,7 @@
sb->s_op = &incfs_super_ops;
sb->s_d_op = &incfs_dentry_ops;
sb->s_flags |= S_NOATIME;
- sb->s_magic = (long)INCFS_MAGIC_NUMBER;
+ sb->s_magic = INCFS_MAGIC_NUMBER;
sb->s_time_gran = 1;
sb->s_blocksize = INCFS_DATA_FILE_BLOCK_SIZE;
sb->s_blocksize_bits = blksize_bits(sb->s_blocksize);
@@ -2207,17 +1771,23 @@
BUILD_BUG_ON(PAGE_SIZE != INCFS_DATA_FILE_BLOCK_SIZE);
+ if (!dev_name) {
+ pr_err("incfs: Backing dir is not set, filesystem can't be mounted.\n");
+ error = -ENOENT;
+ goto err_deactivate;
+ }
+
error = parse_options(&options, (char *)data);
if (error != 0) {
pr_err("incfs: Options parsing error. %d\n", error);
- goto err;
+ goto err_deactivate;
}
sb->s_bdi->ra_pages = options.readahead_pages;
if (!dev_name) {
pr_err("incfs: Backing dir is not set, filesystem can't be mounted.\n");
error = -ENOENT;
- goto err;
+ goto err_free_opts;
}
error = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
@@ -2226,62 +1796,80 @@
!d_really_is_positive(backing_dir_path.dentry)) {
pr_err("incfs: Error accessing: %s.\n",
dev_name);
- goto err;
+ goto err_free_opts;
}
src_fs_sb = backing_dir_path.dentry->d_sb;
sb->s_maxbytes = src_fs_sb->s_maxbytes;
+ sb->s_stack_depth = src_fs_sb->s_stack_depth + 1;
- if (!sb->s_fs_info) {
- mi = incfs_alloc_mount_info(sb, &options, &backing_dir_path);
-
- if (IS_ERR_OR_NULL(mi)) {
- error = PTR_ERR(mi);
- pr_err("incfs: Error allocating mount info. %d\n",
- error);
- mi = NULL;
- goto err;
- }
- sb->s_fs_info = mi;
- } else {
- mi = sb->s_fs_info;
+ if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
+ error = -EINVAL;
+ goto err_put_path;
}
- index_dir = open_or_create_index_dir(backing_dir_path.dentry);
+ mi = incfs_alloc_mount_info(sb, &options, &backing_dir_path);
+ if (IS_ERR_OR_NULL(mi)) {
+ error = PTR_ERR(mi);
+ pr_err("incfs: Error allocating mount info. %d\n", error);
+ goto err_put_path;
+ }
+
+ sb->s_fs_info = mi;
+ mi->mi_backing_dir_path = backing_dir_path;
+ index_dir = open_or_create_special_dir(backing_dir_path.dentry,
+ INCFS_INDEX_NAME, &dir_created);
if (IS_ERR_OR_NULL(index_dir)) {
error = PTR_ERR(index_dir);
pr_err("incfs: Can't find or create .index dir in %s\n",
dev_name);
- goto err;
+ /* No need to null index_dir since we don't put it */
+ goto err_put_path;
}
+
mi->mi_index_dir = index_dir;
+ mi->mi_index_free = dir_created;
+
+ incomplete_dir = open_or_create_special_dir(backing_dir_path.dentry,
+ INCFS_INCOMPLETE_NAME,
+ &dir_created);
+ if (IS_ERR_OR_NULL(incomplete_dir)) {
+ error = PTR_ERR(incomplete_dir);
+ pr_err("incfs: Can't find or create .incomplete dir in %s\n",
+ dev_name);
+ /* No need to null incomplete_dir since we don't put it */
+ goto err_put_path;
+ }
+ mi->mi_incomplete_dir = incomplete_dir;
+ mi->mi_incomplete_free = dir_created;
root_inode = fetch_regular_inode(sb, backing_dir_path.dentry);
if (IS_ERR(root_inode)) {
error = PTR_ERR(root_inode);
- goto err;
+ goto err_put_path;
}
+ sb->s_root = d_make_root(root_inode);
if (!sb->s_root) {
- sb->s_root = d_make_root(root_inode);
- if (!sb->s_root) {
- error = -ENOMEM;
- goto err;
- }
- error = incfs_init_dentry(sb->s_root, &backing_dir_path);
- if (error)
- goto err;
+ error = -ENOMEM;
+ goto err_put_path;
}
+ error = incfs_init_dentry(sb->s_root, &backing_dir_path);
+ if (error)
+ goto err_put_path;
- mi->mi_backing_dir_path = backing_dir_path;
+ path_put(&backing_dir_path);
sb->s_flags |= SB_ACTIVE;
pr_debug("incfs: mount\n");
return dget(sb->s_root);
-err:
- sb->s_fs_info = NULL;
+
+err_put_path:
path_put(&backing_dir_path);
- incfs_free_mount_info(mi);
+err_free_opts:
+ free_options(&options);
+err_deactivate:
deactivate_locked_super(sb);
+ pr_err("incfs: mount failed %d\n", error);
return ERR_PTR(error);
}
@@ -2291,39 +1879,56 @@
struct mount_info *mi = get_mount_info(sb);
int err = 0;
- if (!mi)
- return err;
-
sync_filesystem(sb);
err = parse_options(&options, (char *)data);
if (err)
return err;
+ if (options.report_uid != mi->mi_options.report_uid) {
+ pr_err("incfs: Can't change report_uid mount option on remount\n");
+ err = -EOPNOTSUPP;
+ goto out;
+ }
+
err = incfs_realloc_mount_info(mi, &options);
if (err)
- return err;
+ goto out;
pr_debug("incfs: remount\n");
- return 0;
+
+out:
+ free_options(&options);
+ return err;
}
void incfs_kill_sb(struct super_block *sb)
{
struct mount_info *mi = sb->s_fs_info;
+ struct inode *dinode = NULL;
pr_debug("incfs: unmount\n");
- vfs_rmdir(d_inode(mi->mi_backing_dir_path.dentry), mi->mi_index_dir);
+
+ if (mi) {
+ if (mi->mi_backing_dir_path.dentry)
+ dinode = d_inode(mi->mi_backing_dir_path.dentry);
+
+ if (dinode) {
+ if (mi->mi_index_dir && mi->mi_index_free)
+ vfs_rmdir(dinode, mi->mi_index_dir);
+
+ if (mi->mi_incomplete_dir && mi->mi_incomplete_free)
+ vfs_rmdir(dinode, mi->mi_incomplete_dir);
+ }
+
+ incfs_free_mount_info(mi);
+ sb->s_fs_info = NULL;
+ }
kill_anon_super(sb);
- incfs_free_mount_info(mi);
- sb->s_fs_info = NULL;
}
static int show_options(struct seq_file *m, struct dentry *root)
{
struct mount_info *mi = get_mount_info(root->d_sb);
-
- if (!mi)
- return -EBADF;
seq_printf(m, ",read_timeout_ms=%u", mi->mi_options.read_timeout_ms);
seq_printf(m, ",readahead=%u", mi->mi_options.readahead_pages);
@@ -2332,9 +1937,11 @@
seq_printf(m, ",rlog_wakeup_cnt=%u",
mi->mi_options.read_log_wakeup_count);
}
- if (mi->mi_options.no_backing_file_cache)
- seq_puts(m, ",no_bf_cache");
- if (mi->mi_options.no_backing_file_readahead)
- seq_puts(m, ",no_bf_readahead");
+ if (mi->mi_options.report_uid)
+ seq_puts(m, ",report_uid");
+
+ if (mi->mi_sysfs_node)
+ seq_printf(m, ",sysfs_name=%s",
+ kobject_name(&mi->mi_sysfs_node->isn_sysfs_node));
return 0;
}
--
Gitblit v1.6.2