Commit 8bb1f229 authored by Linus Torvalds's avatar Linus Torvalds

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull second try at vfs part d#2 from Al Viro:
 "Miklos' first series (with do_lookup() rewrite split into edible
  chunks) + assorted bits and pieces.

  The 'untangling of do_lookup()' series is is a splitup of what used to
  be a monolithic patch from Miklos, so this series is basically "how do
  I convince myself that his patch is correct (or find a hole in it)".
  No holes found and I like the resulting cleanup, so in it went..."

Changes from try 1: Fix a boot problem with selinux, and commit messages
prettied up a bit.

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (24 commits)
  vfs: fix out-of-date dentry_unhash() comment
  vfs: split __lookup_hash
  untangling do_lookup() - take __lookup_hash()-calling case out of line.
  untangling do_lookup() - switch to calling __lookup_hash()
  untangling do_lookup() - merge d_alloc_and_lookup() callers
  untangling do_lookup() - merge failure exits in !dentry case
  untangling do_lookup() - massage !dentry case towards __lookup_hash()
  untangling do_lookup() - get rid of need_reval in !dentry case
  untangling do_lookup() - eliminate a loop.
  untangling do_lookup() - expand the area under ->i_mutex
  untangling do_lookup() - isolate !dentry stuff from the rest of it.
  vfs: move MAY_EXEC check from __lookup_hash()
  vfs: don't revalidate just looked up dentry
  vfs: fix d_need_lookup/d_revalidate order in do_lookup
  ext3: move headers to fs/ext3/
  migrate ext2_fs.h guts to fs/ext2/ext2.h
  new helper: ext2_image_size()
  get rid of pointless includes of ext2_fs.h
  ext2: No longer export ext2_fs.h to user space
  mtdchar: kill persistently held vfsmount
  ...
parents f22e08a7 c0d02594
...@@ -550,6 +550,7 @@ static __init void memory_setup(void) ...@@ -550,6 +550,7 @@ static __init void memory_setup(void)
{ {
#ifdef CONFIG_MTD_UCLINUX #ifdef CONFIG_MTD_UCLINUX
unsigned long mtd_phys = 0; unsigned long mtd_phys = 0;
unsigned long n;
#endif #endif
unsigned long max_mem; unsigned long max_mem;
...@@ -593,9 +594,9 @@ static __init void memory_setup(void) ...@@ -593,9 +594,9 @@ static __init void memory_setup(void)
mtd_size = PAGE_ALIGN(*((unsigned long *)(mtd_phys + 8))); mtd_size = PAGE_ALIGN(*((unsigned long *)(mtd_phys + 8)));
# if defined(CONFIG_EXT2_FS) || defined(CONFIG_EXT3_FS) # if defined(CONFIG_EXT2_FS) || defined(CONFIG_EXT3_FS)
if (*((unsigned short *)(mtd_phys + 0x438)) == EXT2_SUPER_MAGIC) n = ext2_image_size((void *)(mtd_phys + 0x400));
mtd_size = if (n)
PAGE_ALIGN(*((unsigned long *)(mtd_phys + 0x404)) << 10); mtd_size = PAGE_ALIGN(n * 1024);
# endif # endif
# if defined(CONFIG_CRAMFS) # if defined(CONFIG_CRAMFS)
......
...@@ -39,7 +39,6 @@ ...@@ -39,7 +39,6 @@
#include <asm/uaccess.h> #include <asm/uaccess.h>
static DEFINE_MUTEX(mtd_mutex); static DEFINE_MUTEX(mtd_mutex);
static struct vfsmount *mtd_inode_mnt __read_mostly;
/* /*
* Data structure to hold the pointer to the mtd device as well * Data structure to hold the pointer to the mtd device as well
...@@ -75,7 +74,9 @@ static loff_t mtdchar_lseek(struct file *file, loff_t offset, int orig) ...@@ -75,7 +74,9 @@ static loff_t mtdchar_lseek(struct file *file, loff_t offset, int orig)
return -EINVAL; return -EINVAL;
} }
static int count;
static struct vfsmount *mnt;
static struct file_system_type mtd_inodefs_type;
static int mtdchar_open(struct inode *inode, struct file *file) static int mtdchar_open(struct inode *inode, struct file *file)
{ {
...@@ -92,6 +93,10 @@ static int mtdchar_open(struct inode *inode, struct file *file) ...@@ -92,6 +93,10 @@ static int mtdchar_open(struct inode *inode, struct file *file)
if ((file->f_mode & FMODE_WRITE) && (minor & 1)) if ((file->f_mode & FMODE_WRITE) && (minor & 1))
return -EACCES; return -EACCES;
ret = simple_pin_fs(&mtd_inodefs_type, &mnt, &count);
if (ret)
return ret;
mutex_lock(&mtd_mutex); mutex_lock(&mtd_mutex);
mtd = get_mtd_device(NULL, devnum); mtd = get_mtd_device(NULL, devnum);
...@@ -106,7 +111,7 @@ static int mtdchar_open(struct inode *inode, struct file *file) ...@@ -106,7 +111,7 @@ static int mtdchar_open(struct inode *inode, struct file *file)
goto out; goto out;
} }
mtd_ino = iget_locked(mtd_inode_mnt->mnt_sb, devnum); mtd_ino = iget_locked(mnt->mnt_sb, devnum);
if (!mtd_ino) { if (!mtd_ino) {
put_mtd_device(mtd); put_mtd_device(mtd);
ret = -ENOMEM; ret = -ENOMEM;
...@@ -141,6 +146,7 @@ static int mtdchar_open(struct inode *inode, struct file *file) ...@@ -141,6 +146,7 @@ static int mtdchar_open(struct inode *inode, struct file *file)
out: out:
mutex_unlock(&mtd_mutex); mutex_unlock(&mtd_mutex);
simple_release_fs(&mnt, &count);
return ret; return ret;
} /* mtdchar_open */ } /* mtdchar_open */
...@@ -162,6 +168,7 @@ static int mtdchar_close(struct inode *inode, struct file *file) ...@@ -162,6 +168,7 @@ static int mtdchar_close(struct inode *inode, struct file *file)
put_mtd_device(mtd); put_mtd_device(mtd);
file->private_data = NULL; file->private_data = NULL;
kfree(mfi); kfree(mfi);
simple_release_fs(&mnt, &count);
return 0; return 0;
} /* mtdchar_close */ } /* mtdchar_close */
...@@ -1175,10 +1182,15 @@ static const struct file_operations mtd_fops = { ...@@ -1175,10 +1182,15 @@ static const struct file_operations mtd_fops = {
#endif #endif
}; };
static const struct super_operations mtd_ops = {
.drop_inode = generic_delete_inode,
.statfs = simple_statfs,
};
static struct dentry *mtd_inodefs_mount(struct file_system_type *fs_type, static struct dentry *mtd_inodefs_mount(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data) int flags, const char *dev_name, void *data)
{ {
return mount_pseudo(fs_type, "mtd_inode:", NULL, NULL, MTD_INODE_FS_MAGIC); return mount_pseudo(fs_type, "mtd_inode:", &mtd_ops, NULL, MTD_INODE_FS_MAGIC);
} }
static struct file_system_type mtd_inodefs_type = { static struct file_system_type mtd_inodefs_type = {
...@@ -1187,26 +1199,6 @@ static struct file_system_type mtd_inodefs_type = { ...@@ -1187,26 +1199,6 @@ static struct file_system_type mtd_inodefs_type = {
.kill_sb = kill_anon_super, .kill_sb = kill_anon_super,
}; };
static void mtdchar_notify_add(struct mtd_info *mtd)
{
}
static void mtdchar_notify_remove(struct mtd_info *mtd)
{
struct inode *mtd_ino = ilookup(mtd_inode_mnt->mnt_sb, mtd->index);
if (mtd_ino) {
/* Destroy the inode if it exists */
clear_nlink(mtd_ino);
iput(mtd_ino);
}
}
static struct mtd_notifier mtdchar_notifier = {
.add = mtdchar_notify_add,
.remove = mtdchar_notify_remove,
};
static int __init init_mtdchar(void) static int __init init_mtdchar(void)
{ {
int ret; int ret;
...@@ -1224,19 +1216,8 @@ static int __init init_mtdchar(void) ...@@ -1224,19 +1216,8 @@ static int __init init_mtdchar(void)
pr_notice("Can't register mtd_inodefs filesystem: %d\n", ret); pr_notice("Can't register mtd_inodefs filesystem: %d\n", ret);
goto err_unregister_chdev; goto err_unregister_chdev;
} }
mtd_inode_mnt = kern_mount(&mtd_inodefs_type);
if (IS_ERR(mtd_inode_mnt)) {
ret = PTR_ERR(mtd_inode_mnt);
pr_notice("Error mounting mtd_inodefs filesystem: %d\n", ret);
goto err_unregister_filesystem;
}
register_mtd_user(&mtdchar_notifier);
return ret; return ret;
err_unregister_filesystem:
unregister_filesystem(&mtd_inodefs_type);
err_unregister_chdev: err_unregister_chdev:
__unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd"); __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
return ret; return ret;
...@@ -1244,8 +1225,6 @@ static int __init init_mtdchar(void) ...@@ -1244,8 +1225,6 @@ static int __init init_mtdchar(void)
static void __exit cleanup_mtdchar(void) static void __exit cleanup_mtdchar(void)
{ {
unregister_mtd_user(&mtdchar_notifier);
kern_unmount(mtd_inode_mnt);
unregister_filesystem(&mtd_inodefs_type); unregister_filesystem(&mtd_inodefs_type);
__unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd"); __unregister_chrdev(MTD_CHAR_MAJOR, 0, 1 << MINORBITS, "mtd");
} }
......
...@@ -305,15 +305,18 @@ static struct kioctx *ioctx_alloc(unsigned nr_events) ...@@ -305,15 +305,18 @@ static struct kioctx *ioctx_alloc(unsigned nr_events)
return ERR_PTR(err); return ERR_PTR(err);
} }
/* aio_cancel_all /* kill_ctx
* Cancels all outstanding aio requests on an aio context. Used * Cancels all outstanding aio requests on an aio context. Used
* when the processes owning a context have all exited to encourage * when the processes owning a context have all exited to encourage
* the rapid destruction of the kioctx. * the rapid destruction of the kioctx.
*/ */
static void aio_cancel_all(struct kioctx *ctx) static void kill_ctx(struct kioctx *ctx)
{ {
int (*cancel)(struct kiocb *, struct io_event *); int (*cancel)(struct kiocb *, struct io_event *);
struct task_struct *tsk = current;
DECLARE_WAITQUEUE(wait, tsk);
struct io_event res; struct io_event res;
spin_lock_irq(&ctx->ctx_lock); spin_lock_irq(&ctx->ctx_lock);
ctx->dead = 1; ctx->dead = 1;
while (!list_empty(&ctx->active_reqs)) { while (!list_empty(&ctx->active_reqs)) {
...@@ -329,15 +332,7 @@ static void aio_cancel_all(struct kioctx *ctx) ...@@ -329,15 +332,7 @@ static void aio_cancel_all(struct kioctx *ctx)
spin_lock_irq(&ctx->ctx_lock); spin_lock_irq(&ctx->ctx_lock);
} }
} }
spin_unlock_irq(&ctx->ctx_lock);
}
static void wait_for_all_aios(struct kioctx *ctx)
{
struct task_struct *tsk = current;
DECLARE_WAITQUEUE(wait, tsk);
spin_lock_irq(&ctx->ctx_lock);
if (!ctx->reqs_active) if (!ctx->reqs_active)
goto out; goto out;
...@@ -387,9 +382,7 @@ void exit_aio(struct mm_struct *mm) ...@@ -387,9 +382,7 @@ void exit_aio(struct mm_struct *mm)
ctx = hlist_entry(mm->ioctx_list.first, struct kioctx, list); ctx = hlist_entry(mm->ioctx_list.first, struct kioctx, list);
hlist_del_rcu(&ctx->list); hlist_del_rcu(&ctx->list);
aio_cancel_all(ctx); kill_ctx(ctx);
wait_for_all_aios(ctx);
if (1 != atomic_read(&ctx->users)) if (1 != atomic_read(&ctx->users))
printk(KERN_DEBUG printk(KERN_DEBUG
...@@ -1269,8 +1262,7 @@ static void io_destroy(struct kioctx *ioctx) ...@@ -1269,8 +1262,7 @@ static void io_destroy(struct kioctx *ioctx)
if (likely(!was_dead)) if (likely(!was_dead))
put_ioctx(ioctx); /* twice for the list */ put_ioctx(ioctx); /* twice for the list */
aio_cancel_all(ioctx); kill_ctx(ioctx);
wait_for_all_aios(ioctx);
/* /*
* Wake up any waiters. The setting of ctx->dead must be seen * Wake up any waiters. The setting of ctx->dead must be seen
...@@ -1278,7 +1270,6 @@ static void io_destroy(struct kioctx *ioctx) ...@@ -1278,7 +1270,6 @@ static void io_destroy(struct kioctx *ioctx)
* locking done by the above calls to ensure this consistency. * locking done by the above calls to ensure this consistency.
*/ */
wake_up_all(&ioctx->wait); wake_up_all(&ioctx->wait);
put_ioctx(ioctx); /* once for the lookup */
} }
/* sys_io_setup: /* sys_io_setup:
...@@ -1315,11 +1306,9 @@ SYSCALL_DEFINE2(io_setup, unsigned, nr_events, aio_context_t __user *, ctxp) ...@@ -1315,11 +1306,9 @@ SYSCALL_DEFINE2(io_setup, unsigned, nr_events, aio_context_t __user *, ctxp)
ret = PTR_ERR(ioctx); ret = PTR_ERR(ioctx);
if (!IS_ERR(ioctx)) { if (!IS_ERR(ioctx)) {
ret = put_user(ioctx->user_id, ctxp); ret = put_user(ioctx->user_id, ctxp);
if (!ret) { if (ret)
put_ioctx(ioctx);
return 0;
}
io_destroy(ioctx); io_destroy(ioctx);
put_ioctx(ioctx);
} }
out: out:
...@@ -1337,6 +1326,7 @@ SYSCALL_DEFINE1(io_destroy, aio_context_t, ctx) ...@@ -1337,6 +1326,7 @@ SYSCALL_DEFINE1(io_destroy, aio_context_t, ctx)
struct kioctx *ioctx = lookup_ioctx(ctx); struct kioctx *ioctx = lookup_ioctx(ctx);
if (likely(NULL != ioctx)) { if (likely(NULL != ioctx)) {
io_destroy(ioctx); io_destroy(ioctx);
put_ioctx(ioctx);
return 0; return 0;
} }
pr_debug("EINVAL: io_destroy: invalid context id\n"); pr_debug("EINVAL: io_destroy: invalid context id\n");
......
This diff is collapsed.
...@@ -3,10 +3,7 @@ ...@@ -3,10 +3,7 @@
* Handler for storing security labels as extended attributes. * Handler for storing security labels as extended attributes.
*/ */
#include <linux/slab.h> #include "ext2.h"
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/ext2_fs.h>
#include <linux/security.h> #include <linux/security.h>
#include "xattr.h" #include "xattr.h"
......
...@@ -5,10 +5,7 @@ ...@@ -5,10 +5,7 @@
* Copyright (C) 2003 by Andreas Gruenbacher, <a.gruenbacher@computer.org> * Copyright (C) 2003 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
*/ */
#include <linux/string.h> #include "ext2.h"
#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/ext2_fs.h>
#include "xattr.h" #include "xattr.h"
static size_t static size_t
......
...@@ -9,8 +9,6 @@ ...@@ -9,8 +9,6 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/genhd.h> #include <linux/genhd.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/ext2_fs_sb.h>
#include <linux/ext2_fs.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include "ext2.h" #include "ext2.h"
#include "xip.h" #include "xip.h"
......
...@@ -4,13 +4,7 @@ ...@@ -4,13 +4,7 @@
* Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de> * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
*/ */
#include <linux/init.h> #include "ext3.h"
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/ext3_jbd.h>
#include <linux/ext3_fs.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
......
...@@ -11,17 +11,9 @@ ...@@ -11,17 +11,9 @@
* David S. Miller (davem@caip.rutgers.edu), 1995 * David S. Miller (davem@caip.rutgers.edu), 1995
*/ */
#include <linux/time.h>
#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#include <linux/ext3_jbd.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/buffer_head.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <trace/events/ext3.h> #include "ext3.h"
/* /*
* balloc.c contains the blocks allocation and deallocation routines * balloc.c contains the blocks allocation and deallocation routines
......
...@@ -7,9 +7,7 @@ ...@@ -7,9 +7,7 @@
* Universite Pierre et Marie Curie (Paris VI) * Universite Pierre et Marie Curie (Paris VI)
*/ */
#include <linux/buffer_head.h> #include "ext3.h"
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#ifdef EXT3FS_DEBUG #ifdef EXT3FS_DEBUG
......
...@@ -21,12 +21,7 @@ ...@@ -21,12 +21,7 @@
* *
*/ */
#include <linux/fs.h> #include "ext3.h"
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#include <linux/buffer_head.h>
#include <linux/slab.h>
#include <linux/rbtree.h>
static unsigned char ext3_filetype_table[] = { static unsigned char ext3_filetype_table[] = {
DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
......
This diff is collapsed.
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* Interface between ext3 and JBD * Interface between ext3 and JBD
*/ */
#include <linux/ext3_jbd.h> #include "ext3.h"
int __ext3_journal_get_undo_access(const char *where, handle_t *handle, int __ext3_journal_get_undo_access(const char *where, handle_t *handle,
struct buffer_head *bh) struct buffer_head *bh)
......
...@@ -18,12 +18,8 @@ ...@@ -18,12 +18,8 @@
* (jj@sunsite.ms.mff.cuni.cz) * (jj@sunsite.ms.mff.cuni.cz)
*/ */
#include <linux/time.h>
#include <linux/fs.h>
#include <linux/jbd.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/ext3_fs.h> #include "ext3.h"
#include <linux/ext3_jbd.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
......
...@@ -22,15 +22,9 @@ ...@@ -22,15 +22,9 @@
* we can depend on generic_block_fdatasync() to sync the data blocks. * we can depend on generic_block_fdatasync() to sync the data blocks.
*/ */
#include <linux/time.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/writeback.h> #include <linux/writeback.h>
#include <linux/jbd.h> #include "ext3.h"
#include <linux/ext3_fs.h>
#include <linux/ext3_jbd.h>
#include <trace/events/ext3.h>
/* /*
* akpm: A new design for ext3_sync_file(). * akpm: A new design for ext3_sync_file().
......
...@@ -9,9 +9,7 @@ ...@@ -9,9 +9,7 @@
* License. * License.
*/ */
#include <linux/fs.h> #include "ext3.h"
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#include <linux/cryptohash.h> #include <linux/cryptohash.h>
#define DELTA 0x9E3779B9 #define DELTA 0x9E3779B9
......
...@@ -12,21 +12,10 @@ ...@@ -12,21 +12,10 @@
* David S. Miller (davem@caip.rutgers.edu), 1995 * David S. Miller (davem@caip.rutgers.edu), 1995
*/ */
#include <linux/time.h>
#include <linux/fs.h>
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#include <linux/ext3_jbd.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/buffer_head.h>
#include <linux/random.h> #include <linux/random.h>
#include <linux/bitops.h>
#include <trace/events/ext3.h>
#include <asm/byteorder.h>
#include "ext3.h"
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
......
...@@ -22,22 +22,12 @@ ...@@ -22,22 +22,12 @@
* Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000 * Assorted race fixes, rewrite of ext3_get_block() by Al Viro, 2000
*/ */
#include <linux/fs.h>
#include <linux/time.h>
#include <linux/ext3_jbd.h>
#include <linux/jbd.h>
#include <linux/highuid.h> #include <linux/highuid.h>
#include <linux/pagemap.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/string.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h> #include <linux/writeback.h>
#include <linux/mpage.h> #include <linux/mpage.h>
#include <linux/uio.h>
#include <linux/bio.h>
#include <linux/fiemap.h>
#include <linux/namei.h> #include <linux/namei.h>
#include <trace/events/ext3.h> #include "ext3.h"
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
......
...@@ -7,15 +7,10 @@ ...@@ -7,15 +7,10 @@
* Universite Pierre et Marie Curie (Paris VI) * Universite Pierre et Marie Curie (Paris VI)
*/ */
#include <linux/fs.h>
#include <linux/jbd.h>
#include <linux/capability.h>
#include <linux/ext3_fs.h>
#include <linux/ext3_jbd.h>
#include <linux/mount.h> #include <linux/mount.h>
#include <linux/time.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include "ext3.h"
long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{ {
......
...@@ -24,20 +24,8 @@ ...@@ -24,20 +24,8 @@
* Theodore Ts'o, 2002 * Theodore Ts'o, 2002
*/ */
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/jbd.h>
#include <linux/time.h>
#include <linux/ext3_fs.h>
#include <linux/ext3_jbd.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/buffer_head.h> #include "ext3.h"
#include <linux/bio.h>
#include <trace/events/ext3.h>
#include "namei.h" #include "namei.h"
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
......
...@@ -11,10 +11,7 @@ ...@@ -11,10 +11,7 @@
#define EXT3FS_DEBUG #define EXT3FS_DEBUG
#include <linux/ext3_jbd.h> #include "ext3.h"
#include <linux/errno.h>
#include <linux/slab.h>
#define outside(b, first, last) ((b) < (first) || (b) >= (last)) #define outside(b, first, last) ((b) < (first) || (b) >= (last))
......
...@@ -17,22 +17,12 @@ ...@@ -17,22 +17,12 @@
*/ */
#include <linux/module.h> #include <linux/module.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/time.h>
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#include <linux/ext3_jbd.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/parser.h> #include <linux/parser.h>
#include <linux/buffer_head.h>
#include <linux/exportfs.h> #include <linux/exportfs.h>
#include <linux/vfs.h> #include <linux/statfs.h>
#include <linux/random.h> #include <linux/random.h>
#include <linux/mount.h> #include <linux/mount.h>
#include <linux/namei.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/log2.h> #include <linux/log2.h>
...@@ -40,13 +30,13 @@ ...@@ -40,13 +30,13 @@
#include <asm/uaccess.h> #include <asm/uaccess.h>
#define CREATE_TRACE_POINTS
#include "ext3.h"
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
#include "namei.h" #include "namei.h"
#define CREATE_TRACE_POINTS
#include <trace/events/ext3.h>
#ifdef CONFIG_EXT3_DEFAULTS_TO_ORDERED #ifdef CONFIG_EXT3_DEFAULTS_TO_ORDERED
#define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_ORDERED_DATA #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_ORDERED_DATA
#else #else
......
...@@ -17,10 +17,8 @@ ...@@ -17,10 +17,8 @@
* ext3 symlink handling code * ext3 symlink handling code
*/ */
#include <linux/fs.h>
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#include <linux/namei.h> #include <linux/namei.h>
#include "ext3.h"
#include "xattr.h" #include "xattr.h"
static void * ext3_follow_link(struct dentry *dentry, struct nameidata *nd) static void * ext3_follow_link(struct dentry *dentry, struct nameidata *nd)
......
...@@ -50,14 +50,9 @@ ...@@ -50,14 +50,9 @@
* by the buffer lock. * by the buffer lock.
*/ */
#include <linux/init.h> #include "ext3.h"
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/ext3_jbd.h>
#include <linux/ext3_fs.h>
#include <linux/mbcache.h> #include <linux/mbcache.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/rwsem.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
......
...@@ -3,12 +3,8 @@ ...@@ -3,12 +3,8 @@
* Handler for storing security labels as extended attributes. * Handler for storing security labels as extended attributes.
*/ */
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/ext3_jbd.h>
#include <linux/ext3_fs.h>
#include <linux/security.h> #include <linux/security.h>
#include "ext3.h"
#include "xattr.h" #include "xattr.h"
static size_t static size_t
......
...@@ -5,11 +5,7 @@ ...@@ -5,11 +5,7 @@
* Copyright (C) 2003 by Andreas Gruenbacher, <a.gruenbacher@computer.org> * Copyright (C) 2003 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
*/ */
#include <linux/string.h> #include "ext3.h"
#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/ext3_jbd.h>
#include <linux/ext3_fs.h>
#include "xattr.h" #include "xattr.h"
static size_t static size_t
......
...@@ -5,10 +5,7 @@ ...@@ -5,10 +5,7 @@
* Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org> * Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
*/ */
#include <linux/string.h> #include "ext3.h"
#include <linux/fs.h>
#include <linux/ext3_jbd.h>
#include <linux/ext3_fs.h>
#include "xattr.h" #include "xattr.h"
static size_t static size_t
......
...@@ -18,7 +18,6 @@ ...@@ -18,7 +18,6 @@
#include <linux/mount.h> #include <linux/mount.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/gfs2_ondisk.h> #include <linux/gfs2_ondisk.h>
#include <linux/ext2_fs.h>
#include <linux/falloc.h> #include <linux/falloc.h>
#include <linux/swap.h> #include <linux/swap.h>
#include <linux/crc32.h> #include <linux/crc32.h>
......
...@@ -1054,53 +1054,65 @@ static void follow_dotdot(struct nameidata *nd) ...@@ -1054,53 +1054,65 @@ static void follow_dotdot(struct nameidata *nd)
} }
/* /*
* Allocate a dentry with name and parent, and perform a parent * This looks up the name in dcache, possibly revalidates the old dentry and
* directory ->lookup on it. Returns the new dentry, or ERR_PTR * allocates a new one if not found or not valid. In the need_lookup argument
* on error. parent->d_inode->i_mutex must be held. d_lookup must * returns whether i_op->lookup is necessary.
* have verified that no child exists while under i_mutex. *
* dir->d_inode->i_mutex must be held
*/ */
static struct dentry *d_alloc_and_lookup(struct dentry *parent, static struct dentry *lookup_dcache(struct qstr *name, struct dentry *dir,
struct qstr *name, struct nameidata *nd) struct nameidata *nd, bool *need_lookup)
{ {
struct inode *inode = parent->d_inode;
struct dentry *dentry; struct dentry *dentry;
struct dentry *old; int error;
/* Don't create child dentry for a dead directory. */ *need_lookup = false;
if (unlikely(IS_DEADDIR(inode))) dentry = d_lookup(dir, name);
return ERR_PTR(-ENOENT); if (dentry) {
if (d_need_lookup(dentry)) {
*need_lookup = true;
} else if (dentry->d_flags & DCACHE_OP_REVALIDATE) {
error = d_revalidate(dentry, nd);
if (unlikely(error <= 0)) {
if (error < 0) {
dput(dentry);
return ERR_PTR(error);
} else if (!d_invalidate(dentry)) {
dput(dentry);
dentry = NULL;
}
}
}
}
dentry = d_alloc(parent, name); if (!dentry) {
dentry = d_alloc(dir, name);
if (unlikely(!dentry)) if (unlikely(!dentry))
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
old = inode->i_op->lookup(inode, dentry, nd); *need_lookup = true;
if (unlikely(old)) {
dput(dentry);
dentry = old;
} }
return dentry; return dentry;
} }
/* /*
* We already have a dentry, but require a lookup to be performed on the parent * Call i_op->lookup on the dentry. The dentry must be negative but may be
* directory to fill in d_inode. Returns the new dentry, or ERR_PTR on error. * hashed if it was pouplated with DCACHE_NEED_LOOKUP.
* parent->d_inode->i_mutex must be held. d_lookup must have verified that no *
* child exists while under i_mutex. * dir->d_inode->i_mutex must be held
*/ */
static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentry, static struct dentry *lookup_real(struct inode *dir, struct dentry *dentry,
struct nameidata *nd) struct nameidata *nd)
{ {
struct inode *inode = parent->d_inode;
struct dentry *old; struct dentry *old;
/* Don't create child dentry for a dead directory. */ /* Don't create child dentry for a dead directory. */
if (unlikely(IS_DEADDIR(inode))) { if (unlikely(IS_DEADDIR(dir))) {
dput(dentry); dput(dentry);
return ERR_PTR(-ENOENT); return ERR_PTR(-ENOENT);
} }
old = inode->i_op->lookup(inode, dentry, nd); old = dir->i_op->lookup(dir, dentry, nd);
if (unlikely(old)) { if (unlikely(old)) {
dput(dentry); dput(dentry);
dentry = old; dentry = old;
...@@ -1108,6 +1120,19 @@ static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentr ...@@ -1108,6 +1120,19 @@ static struct dentry *d_inode_lookup(struct dentry *parent, struct dentry *dentr
return dentry; return dentry;
} }
static struct dentry *__lookup_hash(struct qstr *name,
struct dentry *base, struct nameidata *nd)
{
bool need_lookup;
struct dentry *dentry;
dentry = lookup_dcache(name, base, nd, &need_lookup);
if (!need_lookup)
return dentry;
return lookup_real(base->d_inode, dentry, nd);
}
/* /*
* It's more convoluted than I'd like it to be, but... it's still fairly * It's more convoluted than I'd like it to be, but... it's still fairly
* small and for now I'd prefer to have fast path as straight as possible. * small and for now I'd prefer to have fast path as straight as possible.
...@@ -1139,6 +1164,8 @@ static int do_lookup(struct nameidata *nd, struct qstr *name, ...@@ -1139,6 +1164,8 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
return -ECHILD; return -ECHILD;
nd->seq = seq; nd->seq = seq;
if (unlikely(d_need_lookup(dentry)))
goto unlazy;
if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) { if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) {
status = d_revalidate(dentry, nd); status = d_revalidate(dentry, nd);
if (unlikely(status <= 0)) { if (unlikely(status <= 0)) {
...@@ -1147,8 +1174,6 @@ static int do_lookup(struct nameidata *nd, struct qstr *name, ...@@ -1147,8 +1174,6 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
goto unlazy; goto unlazy;
} }
} }
if (unlikely(d_need_lookup(dentry)))
goto unlazy;
path->mnt = mnt; path->mnt = mnt;
path->dentry = dentry; path->dentry = dentry;
if (unlikely(!__follow_mount_rcu(nd, path, inode))) if (unlikely(!__follow_mount_rcu(nd, path, inode)))
...@@ -1163,38 +1188,14 @@ static int do_lookup(struct nameidata *nd, struct qstr *name, ...@@ -1163,38 +1188,14 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
dentry = __d_lookup(parent, name); dentry = __d_lookup(parent, name);
} }
if (dentry && unlikely(d_need_lookup(dentry))) { if (unlikely(!dentry))
goto need_lookup;
if (unlikely(d_need_lookup(dentry))) {
dput(dentry); dput(dentry);
dentry = NULL; goto need_lookup;
}
retry:
if (unlikely(!dentry)) {
struct inode *dir = parent->d_inode;
BUG_ON(nd->inode != dir);
mutex_lock(&dir->i_mutex);
dentry = d_lookup(parent, name);
if (likely(!dentry)) {
dentry = d_alloc_and_lookup(parent, name, nd);
if (IS_ERR(dentry)) {
mutex_unlock(&dir->i_mutex);
return PTR_ERR(dentry);
}
/* known good */
need_reval = 0;
status = 1;
} else if (unlikely(d_need_lookup(dentry))) {
dentry = d_inode_lookup(parent, dentry, nd);
if (IS_ERR(dentry)) {
mutex_unlock(&dir->i_mutex);
return PTR_ERR(dentry);
}
/* known good */
need_reval = 0;
status = 1;
}
mutex_unlock(&dir->i_mutex);
} }
if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval) if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval)
status = d_revalidate(dentry, nd); status = d_revalidate(dentry, nd);
if (unlikely(status <= 0)) { if (unlikely(status <= 0)) {
...@@ -1204,12 +1205,10 @@ static int do_lookup(struct nameidata *nd, struct qstr *name, ...@@ -1204,12 +1205,10 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
} }
if (!d_invalidate(dentry)) { if (!d_invalidate(dentry)) {
dput(dentry); dput(dentry);
dentry = NULL; goto need_lookup;
need_reval = 1;
goto retry;
} }
} }
done:
path->mnt = mnt; path->mnt = mnt;
path->dentry = dentry; path->dentry = dentry;
err = follow_managed(path, nd->flags); err = follow_managed(path, nd->flags);
...@@ -1221,6 +1220,16 @@ static int do_lookup(struct nameidata *nd, struct qstr *name, ...@@ -1221,6 +1220,16 @@ static int do_lookup(struct nameidata *nd, struct qstr *name,
nd->flags |= LOOKUP_JUMPED; nd->flags |= LOOKUP_JUMPED;
*inode = path->dentry->d_inode; *inode = path->dentry->d_inode;
return 0; return 0;
need_lookup:
BUG_ON(nd->inode != parent->d_inode);
mutex_lock(&parent->d_inode->i_mutex);
dentry = __lookup_hash(name, parent, nd);
mutex_unlock(&parent->d_inode->i_mutex);
if (IS_ERR(dentry))
return PTR_ERR(dentry);
goto done;
} }
static inline int may_lookup(struct nameidata *nd) static inline int may_lookup(struct nameidata *nd)
...@@ -1846,59 +1855,6 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, ...@@ -1846,59 +1855,6 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
return err; return err;
} }
static struct dentry *__lookup_hash(struct qstr *name,
struct dentry *base, struct nameidata *nd)
{
struct inode *inode = base->d_inode;
struct dentry *dentry;
int err;
err = inode_permission(inode, MAY_EXEC);
if (err)
return ERR_PTR(err);
/*
* Don't bother with __d_lookup: callers are for creat as
* well as unlink, so a lot of the time it would cost
* a double lookup.
*/
dentry = d_lookup(base, name);
if (dentry && d_need_lookup(dentry)) {
/*
* __lookup_hash is called with the parent dir's i_mutex already
* held, so we are good to go here.
*/
dentry = d_inode_lookup(base, dentry, nd);
if (IS_ERR(dentry))
return dentry;
}
if (dentry && (dentry->d_flags & DCACHE_OP_REVALIDATE)) {
int status = d_revalidate(dentry, nd);
if (unlikely(status <= 0)) {
/*
* The dentry failed validation.
* If d_revalidate returned 0 attempt to invalidate
* the dentry otherwise d_revalidate is asking us
* to return a fail status.
*/
if (status < 0) {
dput(dentry);
return ERR_PTR(status);
} else if (!d_invalidate(dentry)) {
dput(dentry);
dentry = NULL;
}
}
}
if (!dentry)
dentry = d_alloc_and_lookup(base, name, nd);
return dentry;
}
/* /*
* Restricted form of lookup. Doesn't follow links, single-component only, * Restricted form of lookup. Doesn't follow links, single-component only,
* needs parent already locked. Doesn't follow mounts. * needs parent already locked. Doesn't follow mounts.
...@@ -1924,6 +1880,7 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len) ...@@ -1924,6 +1880,7 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
{ {
struct qstr this; struct qstr this;
unsigned int c; unsigned int c;
int err;
WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex)); WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex));
...@@ -1948,6 +1905,10 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len) ...@@ -1948,6 +1905,10 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
return ERR_PTR(err); return ERR_PTR(err);
} }
err = inode_permission(base->d_inode, MAY_EXEC);
if (err)
return ERR_PTR(err);
return __lookup_hash(&this, base, NULL); return __lookup_hash(&this, base, NULL);
} }
...@@ -2749,7 +2710,7 @@ SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode) ...@@ -2749,7 +2710,7 @@ SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
/* /*
* The dentry_unhash() helper will try to drop the dentry early: we * The dentry_unhash() helper will try to drop the dentry early: we
* should have a usage count of 2 if we're the only user of this * should have a usage count of 1 if we're the only user of this
* dentry, and if that is true (possibly after pruning the dcache), * dentry, and if that is true (possibly after pruning the dcache),
* then we drop the dentry now. * then we drop the dentry now.
* *
......
...@@ -28,8 +28,6 @@ ...@@ -28,8 +28,6 @@
#include "suballoc.h" #include "suballoc.h"
#include "move_extents.h" #include "move_extents.h"
#include <linux/ext2_fs.h>
#define o2info_from_user(a, b) \ #define o2info_from_user(a, b) \
copy_from_user(&(a), (b), sizeof(a)) copy_from_user(&(a), (b), sizeof(a))
#define o2info_to_user(a, b) \ #define o2info_to_user(a, b) \
......
...@@ -105,26 +105,12 @@ static const struct inode_operations pstore_dir_inode_operations = { ...@@ -105,26 +105,12 @@ static const struct inode_operations pstore_dir_inode_operations = {
.unlink = pstore_unlink, .unlink = pstore_unlink,
}; };
static struct inode *pstore_get_inode(struct super_block *sb, static struct inode *pstore_get_inode(struct super_block *sb)
const struct inode *dir, int mode, dev_t dev)
{ {
struct inode *inode = new_inode(sb); struct inode *inode = new_inode(sb);
if (inode) { if (inode) {
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode->i_uid = inode->i_gid = 0;
inode->i_mode = mode;
inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
switch (mode & S_IFMT) {
case S_IFREG:
inode->i_fop = &pstore_file_operations;
break;
case S_IFDIR:
inode->i_op = &pstore_dir_inode_operations;
inode->i_fop = &simple_dir_operations;
inc_nlink(inode);
break;
}
} }
return inode; return inode;
} }
...@@ -216,9 +202,11 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, ...@@ -216,9 +202,11 @@ int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id,
return rc; return rc;
rc = -ENOMEM; rc = -ENOMEM;
inode = pstore_get_inode(pstore_sb, root->d_inode, S_IFREG | 0444, 0); inode = pstore_get_inode(pstore_sb);
if (!inode) if (!inode)
goto fail; goto fail;
inode->i_mode = S_IFREG | 0444;
inode->i_fop = &pstore_file_operations;
private = kmalloc(sizeof *private + size, GFP_KERNEL); private = kmalloc(sizeof *private + size, GFP_KERNEL);
if (!private) if (!private)
goto fail_alloc; goto fail_alloc;
...@@ -293,10 +281,12 @@ int pstore_fill_super(struct super_block *sb, void *data, int silent) ...@@ -293,10 +281,12 @@ int pstore_fill_super(struct super_block *sb, void *data, int silent)
parse_options(data); parse_options(data);
inode = pstore_get_inode(sb, NULL, S_IFDIR | 0755, 0); inode = pstore_get_inode(sb);
if (inode) { if (inode) {
/* override ramfs "dir" options so we catch unlink(2) */ inode->i_mode = S_IFDIR | 0755;
inode->i_op = &pstore_dir_inode_operations; inode->i_op = &pstore_dir_inode_operations;
inode->i_fop = &simple_dir_operations;
inc_nlink(inode);
} }
sb->s_root = d_make_root(inode); sb->s_root = d_make_root(inode);
if (!sb->s_root) if (!sb->s_root)
......
...@@ -120,7 +120,6 @@ header-y += errno.h ...@@ -120,7 +120,6 @@ header-y += errno.h
header-y += errqueue.h header-y += errqueue.h
header-y += ethtool.h header-y += ethtool.h
header-y += eventpoll.h header-y += eventpoll.h
header-y += ext2_fs.h
header-y += fadvise.h header-y += fadvise.h
header-y += falloc.h header-y += falloc.h
header-y += fanotify.h header-y += fanotify.h
......
This diff is collapsed.
/*
* linux/include/linux/ext2_fs_sb.h
*
* Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr)
* Laboratoire MASI - Institut Blaise Pascal
* Universite Pierre et Marie Curie (Paris VI)
*
* from
*
* linux/include/linux/minix_fs_sb.h
*
* Copyright (C) 1991, 1992 Linus Torvalds
*/
#ifndef _LINUX_EXT2_FS_SB
#define _LINUX_EXT2_FS_SB
#include <linux/blockgroup_lock.h>
#include <linux/percpu_counter.h>
#include <linux/rbtree.h>
/* XXX Here for now... not interested in restructing headers JUST now */
/* data type for block offset of block group */
typedef int ext2_grpblk_t;
/* data type for filesystem-wide blocks number */
typedef unsigned long ext2_fsblk_t;
#define E2FSBLK "%lu"
struct ext2_reserve_window {
ext2_fsblk_t _rsv_start; /* First byte reserved */
ext2_fsblk_t _rsv_end; /* Last byte reserved or 0 */
};
struct ext2_reserve_window_node {
struct rb_node rsv_node;
__u32 rsv_goal_size;
__u32 rsv_alloc_hit;
struct ext2_reserve_window rsv_window;
};
struct ext2_block_alloc_info {
/* information about reservation window */
struct ext2_reserve_window_node rsv_window_node;
/*
* was i_next_alloc_block in ext2_inode_info
* is the logical (file-relative) number of the
* most-recently-allocated block in this file.
* We use this for detecting linearly ascending allocation requests.
*/
__u32 last_alloc_logical_block;
/*
* Was i_next_alloc_goal in ext2_inode_info
* is the *physical* companion to i_next_alloc_block.
* it the the physical block number of the block which was most-recentl
* allocated to this file. This give us the goal (target) for the next
* allocation when we detect linearly ascending requests.
*/
ext2_fsblk_t last_alloc_physical_block;
};
#define rsv_start rsv_window._rsv_start
#define rsv_end rsv_window._rsv_end
/*
* second extended-fs super-block data in memory
*/
struct ext2_sb_info {
unsigned long s_frag_size; /* Size of a fragment in bytes */
unsigned long s_frags_per_block;/* Number of fragments per block */
unsigned long s_inodes_per_block;/* Number of inodes per block */
unsigned long s_frags_per_group;/* Number of fragments in a group */
unsigned long s_blocks_per_group;/* Number of blocks in a group */
unsigned long s_inodes_per_group;/* Number of inodes in a group */
unsigned long s_itb_per_group; /* Number of inode table blocks per group */
unsigned long s_gdb_count; /* Number of group descriptor blocks */
unsigned long s_desc_per_block; /* Number of group descriptors per block */
unsigned long s_groups_count; /* Number of groups in the fs */
unsigned long s_overhead_last; /* Last calculated overhead */
unsigned long s_blocks_last; /* Last seen block count */
struct buffer_head * s_sbh; /* Buffer containing the super block */
struct ext2_super_block * s_es; /* Pointer to the super block in the buffer */
struct buffer_head ** s_group_desc;
unsigned long s_mount_opt;
unsigned long s_sb_block;
uid_t s_resuid;
gid_t s_resgid;
unsigned short s_mount_state;
unsigned short s_pad;
int s_addr_per_block_bits;
int s_desc_per_block_bits;
int s_inode_size;
int s_first_ino;
spinlock_t s_next_gen_lock;
u32 s_next_generation;
unsigned long s_dir_count;
u8 *s_debts;
struct percpu_counter s_freeblocks_counter;
struct percpu_counter s_freeinodes_counter;
struct percpu_counter s_dirs_counter;
struct blockgroup_lock *s_blockgroup_lock;
/* root of the per fs reservation window tree */
spinlock_t s_rsv_window_lock;
struct rb_root s_rsv_window_root;
struct ext2_reserve_window_node s_rsv_window_head;
/*
* s_lock protects against concurrent modifications of s_mount_state,
* s_blocks_last, s_overhead_last and the content of superblock's
* buffer pointed to by sbi->s_es.
*
* Note: It is used in ext2_show_options() to provide a consistent view
* of the mount options.
*/
spinlock_t s_lock;
};
static inline spinlock_t *
sb_bgl_lock(struct ext2_sb_info *sbi, unsigned int block_group)
{
return bgl_lock_ptr(sbi->s_blockgroup_lock, block_group);
}
#endif /* _LINUX_EXT2_FS_SB */
/*
* linux/include/linux/ext3_fs_i.h
*
* Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr)
* Laboratoire MASI - Institut Blaise Pascal
* Universite Pierre et Marie Curie (Paris VI)
*
* from
*
* linux/include/linux/minix_fs_i.h
*
* Copyright (C) 1991, 1992 Linus Torvalds
*/
#ifndef _LINUX_EXT3_FS_I
#define _LINUX_EXT3_FS_I
#include <linux/rwsem.h>
#include <linux/rbtree.h>
#include <linux/seqlock.h>
#include <linux/mutex.h>
/* data type for block offset of block group */
typedef int ext3_grpblk_t;
/* data type for filesystem-wide blocks number */
typedef unsigned long ext3_fsblk_t;
#define E3FSBLK "%lu"
struct ext3_reserve_window {
ext3_fsblk_t _rsv_start; /* First byte reserved */
ext3_fsblk_t _rsv_end; /* Last byte reserved or 0 */
};
struct ext3_reserve_window_node {
struct rb_node rsv_node;
__u32 rsv_goal_size;
__u32 rsv_alloc_hit;
struct ext3_reserve_window rsv_window;
};
struct ext3_block_alloc_info {
/* information about reservation window */
struct ext3_reserve_window_node rsv_window_node;
/*
* was i_next_alloc_block in ext3_inode_info
* is the logical (file-relative) number of the
* most-recently-allocated block in this file.
* We use this for detecting linearly ascending allocation requests.
*/
__u32 last_alloc_logical_block;
/*
* Was i_next_alloc_goal in ext3_inode_info
* is the *physical* companion to i_next_alloc_block.
* it the physical block number of the block which was most-recentl
* allocated to this file. This give us the goal (target) for the next
* allocation when we detect linearly ascending requests.
*/
ext3_fsblk_t last_alloc_physical_block;
};
#define rsv_start rsv_window._rsv_start
#define rsv_end rsv_window._rsv_end
/*
* third extended file system inode data in memory
*/
struct ext3_inode_info {
__le32 i_data[15]; /* unconverted */
__u32 i_flags;
#ifdef EXT3_FRAGMENTS
__u32 i_faddr;
__u8 i_frag_no;
__u8 i_frag_size;
#endif
ext3_fsblk_t i_file_acl;
__u32 i_dir_acl;
__u32 i_dtime;
/*
* i_block_group is the number of the block group which contains
* this file's inode. Constant across the lifetime of the inode,
* it is ued for making block allocation decisions - we try to
* place a file's data blocks near its inode block, and new inodes
* near to their parent directory's inode.
*/
__u32 i_block_group;
unsigned long i_state_flags; /* Dynamic state flags for ext3 */
/* block reservation info */
struct ext3_block_alloc_info *i_block_alloc_info;
__u32 i_dir_start_lookup;
#ifdef CONFIG_EXT3_FS_XATTR
/*
* Extended attributes can be read independently of the main file
* data. Taking i_mutex even when reading would cause contention
* between readers of EAs and writers of regular file data, so
* instead we synchronize on xattr_sem when reading or changing
* EAs.
*/
struct rw_semaphore xattr_sem;
#endif
struct list_head i_orphan; /* unlinked but open inodes */
/*
* i_disksize keeps track of what the inode size is ON DISK, not
* in memory. During truncate, i_size is set to the new size by
* the VFS prior to calling ext3_truncate(), but the filesystem won't
* set i_disksize to 0 until the truncate is actually under way.
*
* The intent is that i_disksize always represents the blocks which
* are used by this file. This allows recovery to restart truncate
* on orphans if we crash during truncate. We actually write i_disksize
* into the on-disk inode when writing inodes out, instead of i_size.
*
* The only time when i_disksize and i_size may be different is when
* a truncate is in progress. The only things which change i_disksize
* are ext3_get_block (growth) and ext3_truncate (shrinkth).
*/
loff_t i_disksize;
/* on-disk additional length */
__u16 i_extra_isize;
/*
* truncate_mutex is for serialising ext3_truncate() against
* ext3_getblock(). In the 2.4 ext2 design, great chunks of inode's
* data tree are chopped off during truncate. We can't do that in
* ext3 because whenever we perform intermediate commits during
* truncate, the inode and all the metadata blocks *must* be in a
* consistent state which allows truncation of the orphans to restart
* during recovery. Hence we must fix the get_block-vs-truncate race
* by other means, so we have truncate_mutex.
*/
struct mutex truncate_mutex;
/*
* Transactions that contain inode's metadata needed to complete
* fsync and fdatasync, respectively.
*/
atomic_t i_sync_tid;
atomic_t i_datasync_tid;
struct inode vfs_inode;
};
#endif /* _LINUX_EXT3_FS_I */
/*
* linux/include/linux/ext3_fs_sb.h
*
* Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr)
* Laboratoire MASI - Institut Blaise Pascal
* Universite Pierre et Marie Curie (Paris VI)
*
* from
*
* linux/include/linux/minix_fs_sb.h
*
* Copyright (C) 1991, 1992 Linus Torvalds
*/
#ifndef _LINUX_EXT3_FS_SB
#define _LINUX_EXT3_FS_SB
#ifdef __KERNEL__
#include <linux/timer.h>
#include <linux/wait.h>
#include <linux/blockgroup_lock.h>
#include <linux/percpu_counter.h>
#endif
#include <linux/rbtree.h>
/*
* third extended-fs super-block data in memory
*/
struct ext3_sb_info {
unsigned long s_frag_size; /* Size of a fragment in bytes */
unsigned long s_frags_per_block;/* Number of fragments per block */
unsigned long s_inodes_per_block;/* Number of inodes per block */
unsigned long s_frags_per_group;/* Number of fragments in a group */
unsigned long s_blocks_per_group;/* Number of blocks in a group */
unsigned long s_inodes_per_group;/* Number of inodes in a group */
unsigned long s_itb_per_group; /* Number of inode table blocks per group */
unsigned long s_gdb_count; /* Number of group descriptor blocks */
unsigned long s_desc_per_block; /* Number of group descriptors per block */
unsigned long s_groups_count; /* Number of groups in the fs */
unsigned long s_overhead_last; /* Last calculated overhead */
unsigned long s_blocks_last; /* Last seen block count */
struct buffer_head * s_sbh; /* Buffer containing the super block */
struct ext3_super_block * s_es; /* Pointer to the super block in the buffer */
struct buffer_head ** s_group_desc;
unsigned long s_mount_opt;
ext3_fsblk_t s_sb_block;
uid_t s_resuid;
gid_t s_resgid;
unsigned short s_mount_state;
unsigned short s_pad;
int s_addr_per_block_bits;
int s_desc_per_block_bits;
int s_inode_size;
int s_first_ino;
spinlock_t s_next_gen_lock;
u32 s_next_generation;
u32 s_hash_seed[4];
int s_def_hash_version;
int s_hash_unsigned; /* 3 if hash should be signed, 0 if not */
struct percpu_counter s_freeblocks_counter;
struct percpu_counter s_freeinodes_counter;
struct percpu_counter s_dirs_counter;
struct blockgroup_lock *s_blockgroup_lock;
/* root of the per fs reservation window tree */
spinlock_t s_rsv_window_lock;
struct rb_root s_rsv_window_root;
struct ext3_reserve_window_node s_rsv_window_head;
/* Journaling */
struct inode * s_journal_inode;
struct journal_s * s_journal;
struct list_head s_orphan;
struct mutex s_orphan_lock;
struct mutex s_resize_lock;
unsigned long s_commit_interval;
struct block_device *journal_bdev;
#ifdef CONFIG_QUOTA
char *s_qf_names[MAXQUOTAS]; /* Names of quota files with journalled quota */
int s_jquota_fmt; /* Format of quota to use */
#endif
};
static inline spinlock_t *
sb_bgl_lock(struct ext3_sb_info *sbi, unsigned int block_group)
{
return bgl_lock_ptr(sbi->s_blockgroup_lock, block_group);
}
#endif /* _LINUX_EXT3_FS_SB */
/*
* linux/include/linux/ext3_jbd.h
*
* Written by Stephen C. Tweedie <sct@redhat.com>, 1999
*
* Copyright 1998--1999 Red Hat corp --- All Rights Reserved
*
* This file is part of the Linux kernel and is made available under
* the terms of the GNU General Public License, version 2, or at your
* option, any later version, incorporated herein by reference.
*
* Ext3-specific journaling extensions.
*/
#ifndef _LINUX_EXT3_JBD_H
#define _LINUX_EXT3_JBD_H
#include <linux/fs.h>
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
#define EXT3_JOURNAL(inode) (EXT3_SB((inode)->i_sb)->s_journal)
/* Define the number of blocks we need to account to a transaction to
* modify one block of data.
*
* We may have to touch one inode, one bitmap buffer, up to three
* indirection blocks, the group and superblock summaries, and the data
* block to complete the transaction. */
#define EXT3_SINGLEDATA_TRANS_BLOCKS 8U
/* Extended attribute operations touch at most two data buffers,
* two bitmap buffers, and two group summaries, in addition to the inode
* and the superblock, which are already accounted for. */
#define EXT3_XATTR_TRANS_BLOCKS 6U
/* Define the minimum size for a transaction which modifies data. This
* needs to take into account the fact that we may end up modifying two
* quota files too (one for the group, one for the user quota). The
* superblock only gets updated once, of course, so don't bother
* counting that again for the quota updates. */
#define EXT3_DATA_TRANS_BLOCKS(sb) (EXT3_SINGLEDATA_TRANS_BLOCKS + \
EXT3_XATTR_TRANS_BLOCKS - 2 + \
EXT3_MAXQUOTAS_TRANS_BLOCKS(sb))
/* Delete operations potentially hit one directory's namespace plus an
* entire inode, plus arbitrary amounts of bitmap/indirection data. Be
* generous. We can grow the delete transaction later if necessary. */
#define EXT3_DELETE_TRANS_BLOCKS(sb) (EXT3_MAXQUOTAS_TRANS_BLOCKS(sb) + 64)
/* Define an arbitrary limit for the amount of data we will anticipate
* writing to any given transaction. For unbounded transactions such as
* write(2) and truncate(2) we can write more than this, but we always
* start off at the maximum transaction size and grow the transaction
* optimistically as we go. */
#define EXT3_MAX_TRANS_DATA 64U
/* We break up a large truncate or write transaction once the handle's
* buffer credits gets this low, we need either to extend the
* transaction or to start a new one. Reserve enough space here for
* inode, bitmap, superblock, group and indirection updates for at least
* one block, plus two quota updates. Quota allocations are not
* needed. */
#define EXT3_RESERVE_TRANS_BLOCKS 12U
#define EXT3_INDEX_EXTRA_TRANS_BLOCKS 8
#ifdef CONFIG_QUOTA
/* Amount of blocks needed for quota update - we know that the structure was
* allocated so we need to update only inode+data */
#define EXT3_QUOTA_TRANS_BLOCKS(sb) (test_opt(sb, QUOTA) ? 2 : 0)
/* Amount of blocks needed for quota insert/delete - we do some block writes
* but inode, sb and group updates are done only once */
#define EXT3_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\
(EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_INIT_REWRITE) : 0)
#define EXT3_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\
(EXT3_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_DEL_REWRITE) : 0)
#else
#define EXT3_QUOTA_TRANS_BLOCKS(sb) 0
#define EXT3_QUOTA_INIT_BLOCKS(sb) 0
#define EXT3_QUOTA_DEL_BLOCKS(sb) 0
#endif
#define EXT3_MAXQUOTAS_TRANS_BLOCKS(sb) (MAXQUOTAS*EXT3_QUOTA_TRANS_BLOCKS(sb))
#define EXT3_MAXQUOTAS_INIT_BLOCKS(sb) (MAXQUOTAS*EXT3_QUOTA_INIT_BLOCKS(sb))
#define EXT3_MAXQUOTAS_DEL_BLOCKS(sb) (MAXQUOTAS*EXT3_QUOTA_DEL_BLOCKS(sb))
int
ext3_mark_iloc_dirty(handle_t *handle,
struct inode *inode,
struct ext3_iloc *iloc);
/*
* On success, We end up with an outstanding reference count against
* iloc->bh. This _must_ be cleaned up later.
*/
int ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
struct ext3_iloc *iloc);
int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode);
/*
* Wrapper functions with which ext3 calls into JBD. The intent here is
* to allow these to be turned into appropriate stubs so ext3 can control
* ext2 filesystems, so ext2+ext3 systems only nee one fs. This work hasn't
* been done yet.
*/
static inline void ext3_journal_release_buffer(handle_t *handle,
struct buffer_head *bh)
{
journal_release_buffer(handle, bh);
}
void ext3_journal_abort_handle(const char *caller, const char *err_fn,
struct buffer_head *bh, handle_t *handle, int err);
int __ext3_journal_get_undo_access(const char *where, handle_t *handle,
struct buffer_head *bh);
int __ext3_journal_get_write_access(const char *where, handle_t *handle,
struct buffer_head *bh);
int __ext3_journal_forget(const char *where, handle_t *handle,
struct buffer_head *bh);
int __ext3_journal_revoke(const char *where, handle_t *handle,
unsigned long blocknr, struct buffer_head *bh);
int __ext3_journal_get_create_access(const char *where,
handle_t *handle, struct buffer_head *bh);
int __ext3_journal_dirty_metadata(const char *where,
handle_t *handle, struct buffer_head *bh);
#define ext3_journal_get_undo_access(handle, bh) \
__ext3_journal_get_undo_access(__func__, (handle), (bh))
#define ext3_journal_get_write_access(handle, bh) \
__ext3_journal_get_write_access(__func__, (handle), (bh))
#define ext3_journal_revoke(handle, blocknr, bh) \
__ext3_journal_revoke(__func__, (handle), (blocknr), (bh))
#define ext3_journal_get_create_access(handle, bh) \
__ext3_journal_get_create_access(__func__, (handle), (bh))
#define ext3_journal_dirty_metadata(handle, bh) \
__ext3_journal_dirty_metadata(__func__, (handle), (bh))
#define ext3_journal_forget(handle, bh) \
__ext3_journal_forget(__func__, (handle), (bh))
int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh);
handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks);
int __ext3_journal_stop(const char *where, handle_t *handle);
static inline handle_t *ext3_journal_start(struct inode *inode, int nblocks)
{
return ext3_journal_start_sb(inode->i_sb, nblocks);
}
#define ext3_journal_stop(handle) \
__ext3_journal_stop(__func__, (handle))
static inline handle_t *ext3_journal_current_handle(void)
{
return journal_current_handle();
}
static inline int ext3_journal_extend(handle_t *handle, int nblocks)
{
return journal_extend(handle, nblocks);
}
static inline int ext3_journal_restart(handle_t *handle, int nblocks)
{
return journal_restart(handle, nblocks);
}
static inline int ext3_journal_blocks_per_page(struct inode *inode)
{
return journal_blocks_per_page(inode);
}
static inline int ext3_journal_force_commit(journal_t *journal)
{
return journal_force_commit(journal);
}
/* super.c */
int ext3_force_commit(struct super_block *sb);
static inline int ext3_should_journal_data(struct inode *inode)
{
if (!S_ISREG(inode->i_mode))
return 1;
if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA)
return 1;
if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
return 1;
return 0;
}
static inline int ext3_should_order_data(struct inode *inode)
{
if (!S_ISREG(inode->i_mode))
return 0;
if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
return 0;
if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA)
return 1;
return 0;
}
static inline int ext3_should_writeback_data(struct inode *inode)
{
if (!S_ISREG(inode->i_mode))
return 0;
if (EXT3_I(inode)->i_flags & EXT3_JOURNAL_DATA_FL)
return 0;
if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)
return 1;
return 0;
}
#endif /* _LINUX_EXT3_JBD_H */
...@@ -2,7 +2,6 @@ ...@@ -2,7 +2,6 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/minix_fs.h> #include <linux/minix_fs.h>
#include <linux/ext2_fs.h>
#include <linux/romfs_fs.h> #include <linux/romfs_fs.h>
#include <linux/initrd.h> #include <linux/initrd.h>
#include <linux/sched.h> #include <linux/sched.h>
......
...@@ -54,20 +54,19 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor) ...@@ -54,20 +54,19 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
{ {
const int size = 512; const int size = 512;
struct minix_super_block *minixsb; struct minix_super_block *minixsb;
struct ext2_super_block *ext2sb;
struct romfs_super_block *romfsb; struct romfs_super_block *romfsb;
struct cramfs_super *cramfsb; struct cramfs_super *cramfsb;
struct squashfs_super_block *squashfsb; struct squashfs_super_block *squashfsb;
int nblocks = -1; int nblocks = -1;
unsigned char *buf; unsigned char *buf;
const char *compress_name; const char *compress_name;
unsigned long n;
buf = kmalloc(size, GFP_KERNEL); buf = kmalloc(size, GFP_KERNEL);
if (!buf) if (!buf)
return -ENOMEM; return -ENOMEM;
minixsb = (struct minix_super_block *) buf; minixsb = (struct minix_super_block *) buf;
ext2sb = (struct ext2_super_block *) buf;
romfsb = (struct romfs_super_block *) buf; romfsb = (struct romfs_super_block *) buf;
cramfsb = (struct cramfs_super *) buf; cramfsb = (struct cramfs_super *) buf;
squashfsb = (struct squashfs_super_block *) buf; squashfsb = (struct squashfs_super_block *) buf;
...@@ -150,12 +149,12 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor) ...@@ -150,12 +149,12 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
} }
/* Try ext2 */ /* Try ext2 */
if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) { n = ext2_image_size(buf);
if (n) {
printk(KERN_NOTICE printk(KERN_NOTICE
"RAMDISK: ext2 filesystem found at block %d\n", "RAMDISK: ext2 filesystem found at block %d\n",
start_block); start_block);
nblocks = le32_to_cpu(ext2sb->s_blocks_count) << nblocks = n;
le32_to_cpu(ext2sb->s_log_block_size);
goto done; goto done;
} }
......
...@@ -28,7 +28,6 @@ ...@@ -28,7 +28,6 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/tracehook.h> #include <linux/tracehook.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/ext2_fs.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/security.h> #include <linux/security.h>
#include <linux/xattr.h> #include <linux/xattr.h>
...@@ -2971,15 +2970,15 @@ static int selinux_file_ioctl(struct file *file, unsigned int cmd, ...@@ -2971,15 +2970,15 @@ static int selinux_file_ioctl(struct file *file, unsigned int cmd,
/* fall through */ /* fall through */
case FIGETBSZ: case FIGETBSZ:
/* fall through */ /* fall through */
case EXT2_IOC_GETFLAGS: case FS_IOC_GETFLAGS:
/* fall through */ /* fall through */
case EXT2_IOC_GETVERSION: case FS_IOC_GETVERSION:
error = file_has_perm(cred, file, FILE__GETATTR); error = file_has_perm(cred, file, FILE__GETATTR);
break; break;
case EXT2_IOC_SETFLAGS: case FS_IOC_SETFLAGS:
/* fall through */ /* fall through */
case EXT2_IOC_SETVERSION: case FS_IOC_SETVERSION:
error = file_has_perm(cred, file, FILE__SETATTR); error = file_has_perm(cred, file, FILE__SETATTR);
break; break;
......
...@@ -344,7 +344,7 @@ static int sel_make_classes(void); ...@@ -344,7 +344,7 @@ static int sel_make_classes(void);
static int sel_make_policycap(void); static int sel_make_policycap(void);
/* declaration for sel_make_class_dirs */ /* declaration for sel_make_class_dirs */
static int sel_make_dir(struct inode *dir, struct dentry *dentry, static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
unsigned long *ino); unsigned long *ino);
static ssize_t sel_read_mls(struct file *filp, char __user *buf, static ssize_t sel_read_mls(struct file *filp, char __user *buf,
...@@ -1678,13 +1678,9 @@ static int sel_make_class_dir_entries(char *classname, int index, ...@@ -1678,13 +1678,9 @@ static int sel_make_class_dir_entries(char *classname, int index,
inode->i_ino = sel_class_to_ino(index); inode->i_ino = sel_class_to_ino(index);
d_add(dentry, inode); d_add(dentry, inode);
dentry = d_alloc_name(dir, "perms"); dentry = sel_make_dir(dir, "perms", &last_class_ino);
if (!dentry) if (IS_ERR(dentry))
return -ENOMEM; return PTR_ERR(dentry);
rc = sel_make_dir(dir->d_inode, dentry, &last_class_ino);
if (rc)
return rc;
rc = sel_make_perm_files(classname, index, dentry); rc = sel_make_perm_files(classname, index, dentry);
...@@ -1733,15 +1729,12 @@ static int sel_make_classes(void) ...@@ -1733,15 +1729,12 @@ static int sel_make_classes(void)
for (i = 0; i < nclasses; i++) { for (i = 0; i < nclasses; i++) {
struct dentry *class_name_dir; struct dentry *class_name_dir;
rc = -ENOMEM; class_name_dir = sel_make_dir(class_dir, classes[i],
class_name_dir = d_alloc_name(class_dir, classes[i]);
if (!class_name_dir)
goto out;
rc = sel_make_dir(class_dir->d_inode, class_name_dir,
&last_class_ino); &last_class_ino);
if (rc) if (IS_ERR(class_name_dir)) {
rc = PTR_ERR(class_name_dir);
goto out; goto out;
}
/* i+1 since class values are 1-indexed */ /* i+1 since class values are 1-indexed */
rc = sel_make_class_dir_entries(classes[i], i + 1, rc = sel_make_class_dir_entries(classes[i], i + 1,
...@@ -1787,14 +1780,20 @@ static int sel_make_policycap(void) ...@@ -1787,14 +1780,20 @@ static int sel_make_policycap(void)
return 0; return 0;
} }
static int sel_make_dir(struct inode *dir, struct dentry *dentry, static struct dentry *sel_make_dir(struct dentry *dir, const char *name,
unsigned long *ino) unsigned long *ino)
{ {
struct dentry *dentry = d_alloc_name(dir, name);
struct inode *inode; struct inode *inode;
inode = sel_make_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO); if (!dentry)
if (!inode) return ERR_PTR(-ENOMEM);
return -ENOMEM;
inode = sel_make_inode(dir->d_sb, S_IFDIR | S_IRUGO | S_IXUGO);
if (!inode) {
dput(dentry);
return ERR_PTR(-ENOMEM);
}
inode->i_op = &simple_dir_inode_operations; inode->i_op = &simple_dir_inode_operations;
inode->i_fop = &simple_dir_operations; inode->i_fop = &simple_dir_operations;
...@@ -1803,16 +1802,16 @@ static int sel_make_dir(struct inode *dir, struct dentry *dentry, ...@@ -1803,16 +1802,16 @@ static int sel_make_dir(struct inode *dir, struct dentry *dentry,
inc_nlink(inode); inc_nlink(inode);
d_add(dentry, inode); d_add(dentry, inode);
/* bump link count on parent directory, too */ /* bump link count on parent directory, too */
inc_nlink(dir); inc_nlink(dir->d_inode);
return 0; return dentry;
} }
static int sel_fill_super(struct super_block *sb, void *data, int silent) static int sel_fill_super(struct super_block *sb, void *data, int silent)
{ {
int ret; int ret;
struct dentry *dentry; struct dentry *dentry;
struct inode *inode, *root_inode; struct inode *inode;
struct inode_security_struct *isec; struct inode_security_struct *isec;
static struct tree_descr selinux_files[] = { static struct tree_descr selinux_files[] = {
...@@ -1839,18 +1838,12 @@ static int sel_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1839,18 +1838,12 @@ static int sel_fill_super(struct super_block *sb, void *data, int silent)
if (ret) if (ret)
goto err; goto err;
root_inode = sb->s_root->d_inode; bool_dir = sel_make_dir(sb->s_root, BOOL_DIR_NAME, &sel_last_ino);
if (IS_ERR(bool_dir)) {
ret = -ENOMEM; ret = PTR_ERR(bool_dir);
dentry = d_alloc_name(sb->s_root, BOOL_DIR_NAME); bool_dir = NULL;
if (!dentry)
goto err; goto err;
}
ret = sel_make_dir(root_inode, dentry, &sel_last_ino);
if (ret)
goto err;
bool_dir = dentry;
ret = -ENOMEM; ret = -ENOMEM;
dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME); dentry = d_alloc_name(sb->s_root, NULL_FILE_NAME);
...@@ -1872,54 +1865,39 @@ static int sel_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1872,54 +1865,39 @@ static int sel_fill_super(struct super_block *sb, void *data, int silent)
d_add(dentry, inode); d_add(dentry, inode);
selinux_null = dentry; selinux_null = dentry;
ret = -ENOMEM; dentry = sel_make_dir(sb->s_root, "avc", &sel_last_ino);
dentry = d_alloc_name(sb->s_root, "avc"); if (IS_ERR(dentry)) {
if (!dentry) ret = PTR_ERR(dentry);
goto err;
ret = sel_make_dir(root_inode, dentry, &sel_last_ino);
if (ret)
goto err; goto err;
}
ret = sel_make_avc_files(dentry); ret = sel_make_avc_files(dentry);
if (ret) if (ret)
goto err; goto err;
ret = -ENOMEM; dentry = sel_make_dir(sb->s_root, "initial_contexts", &sel_last_ino);
dentry = d_alloc_name(sb->s_root, "initial_contexts"); if (IS_ERR(dentry)) {
if (!dentry) ret = PTR_ERR(dentry);
goto err;
ret = sel_make_dir(root_inode, dentry, &sel_last_ino);
if (ret)
goto err; goto err;
}
ret = sel_make_initcon_files(dentry); ret = sel_make_initcon_files(dentry);
if (ret) if (ret)
goto err; goto err;
ret = -ENOMEM; class_dir = sel_make_dir(sb->s_root, "class", &sel_last_ino);
dentry = d_alloc_name(sb->s_root, "class"); if (IS_ERR(class_dir)) {
if (!dentry) ret = PTR_ERR(class_dir);
goto err; class_dir = NULL;
ret = sel_make_dir(root_inode, dentry, &sel_last_ino);
if (ret)
goto err;
class_dir = dentry;
ret = -ENOMEM;
dentry = d_alloc_name(sb->s_root, "policy_capabilities");
if (!dentry)
goto err; goto err;
}
ret = sel_make_dir(root_inode, dentry, &sel_last_ino); policycap_dir = sel_make_dir(sb->s_root, "policy_capabilities", &sel_last_ino);
if (ret) if (IS_ERR(policycap_dir)) {
ret = PTR_ERR(policycap_dir);
policycap_dir = NULL;
goto err; goto err;
}
policycap_dir = dentry;
return 0; return 0;
err: err:
printk(KERN_ERR "SELinux: %s: failed while creating inodes\n", printk(KERN_ERR "SELinux: %s: failed while creating inodes\n",
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment