![Linus Torvalds](/assets/img/avatar_default.png)
and COLLAPSE_RANGE fallocate operations, and scalability improvements in the jbd2 layer and in xattr handling when the extended attributes spill over into an external block. Other than that, the usual clean ups and minor bug fixes. -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.22 (GNU/Linux) iQIcBAABCAAGBQJTPbD2AAoJENNvdpvBGATwDmUQANSfGYIQazB8XKKgtNTMiG/Y Ky7n1JzN9lTX/6nMsqQnbfCweLRmxqpWUBuyKDRHUi8IG0/voXSTFsAOOgz0R15A ERRRWkVvHixLpohuL/iBdEMFHwNZYPGr3jkm0EIgzhtXNgk5DNmiuMwvHmCY27kI kdNZIw9fip/WRNoFLDBGnLGC37aanoHhCIbVlySy5o9LN1pkC8BgXAYV0Rk19SVd bWCudSJEirFEqWS5H8vsBAEm/ioxTjwnNL8tX8qms6orZ6h8yMLFkHoIGWPw3Q15 a0TSUoMyav50Yr59QaDeWx9uaPQVeK41wiYFI2rZOnyG2ts0u0YXs/nLwJqTovgs rzvbdl6cd3Nj++rPi97MTA7iXK96WQPjsDJoeeEgnB0d/qPyTk6mLKgftzLTNgSa ZmWjrB19kr6CMbebMC4L6eqJ8Fr66pCT8c/iue8wc4MUHi7FwHKH64fqWvzp2YT/ +165dqqo2JnUv7tIp6sUi1geun+bmDHLZFXgFa7fNYFtcU3I+uY1mRr3eMVAJndA 2d6ASe/KhQbpVnjKJdQ8/b833ZS3p+zkgVPrd68bBr3t7gUmX91wk+p1ct6rUPLr 700F+q/pQWL8ap0pU9Ht/h3gEJIfmRzTwxlOeYyOwDseqKuS87PSB3BzV3dDunSU DrPKlXwIgva7zq5/S0Vr =4s1Z -----END PGP SIGNATURE----- Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 Pull ext4 updates from Ted Ts'o: "Major changes for 3.14 include support for the newly added ZERO_RANGE and COLLAPSE_RANGE fallocate operations, and scalability improvements in the jbd2 layer and in xattr handling when the extended attributes spill over into an external block. Other than that, the usual clean ups and minor bug fixes" * tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (42 commits) ext4: fix premature freeing of partial clusters split across leaf blocks ext4: remove unneeded test of ret variable ext4: fix comment typo ext4: make ext4_block_zero_page_range static ext4: atomically set inode->i_flags in ext4_set_inode_flags() ext4: optimize Hurd tests when reading/writing inodes ext4: kill i_version support for Hurd-castrated file systems ext4: each filesystem creates and uses its own mb_cache fs/mbcache.c: doucple the locking of local from global data fs/mbcache.c: change block and index hash chain to hlist_bl_node ext4: Introduce FALLOC_FL_ZERO_RANGE flag for fallocate ext4: refactor ext4_fallocate code ext4: Update inode i_size after the preallocation ext4: fix partial cluster handling for bigalloc file systems ext4: delete path dealloc code in ext4_ext_handle_uninitialized_extents ext4: only call sync_filesystm() when remounting read-only fs: push sync_filesystem() down to the file system's remount_fs() jbd2: improve error messages for inconsistent journal heads jbd2: minimize region locked by j_list_lock in jbd2_journal_forget() jbd2: minimize region locked by j_list_lock in journal_get_create_access() ...
691 lines
18 KiB
C
691 lines
18 KiB
C
/*
|
|
* linux/fs/minix/inode.c
|
|
*
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*
|
|
* Copyright (C) 1996 Gertjan van Wingerde
|
|
* Minix V2 fs support.
|
|
*
|
|
* Modified for 680x0 by Andreas Schwab
|
|
* Updated to filesystem version 3 by Daniel Aragones
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include "minix.h"
|
|
#include <linux/buffer_head.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/init.h>
|
|
#include <linux/highuid.h>
|
|
#include <linux/vfs.h>
|
|
#include <linux/writeback.h>
|
|
|
|
static int minix_write_inode(struct inode *inode,
|
|
struct writeback_control *wbc);
|
|
static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
|
|
static int minix_remount (struct super_block * sb, int * flags, char * data);
|
|
|
|
static void minix_evict_inode(struct inode *inode)
|
|
{
|
|
truncate_inode_pages_final(&inode->i_data);
|
|
if (!inode->i_nlink) {
|
|
inode->i_size = 0;
|
|
minix_truncate(inode);
|
|
}
|
|
invalidate_inode_buffers(inode);
|
|
clear_inode(inode);
|
|
if (!inode->i_nlink)
|
|
minix_free_inode(inode);
|
|
}
|
|
|
|
static void minix_put_super(struct super_block *sb)
|
|
{
|
|
int i;
|
|
struct minix_sb_info *sbi = minix_sb(sb);
|
|
|
|
if (!(sb->s_flags & MS_RDONLY)) {
|
|
if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
|
|
sbi->s_ms->s_state = sbi->s_mount_state;
|
|
mark_buffer_dirty(sbi->s_sbh);
|
|
}
|
|
for (i = 0; i < sbi->s_imap_blocks; i++)
|
|
brelse(sbi->s_imap[i]);
|
|
for (i = 0; i < sbi->s_zmap_blocks; i++)
|
|
brelse(sbi->s_zmap[i]);
|
|
brelse (sbi->s_sbh);
|
|
kfree(sbi->s_imap);
|
|
sb->s_fs_info = NULL;
|
|
kfree(sbi);
|
|
}
|
|
|
|
static struct kmem_cache * minix_inode_cachep;
|
|
|
|
static struct inode *minix_alloc_inode(struct super_block *sb)
|
|
{
|
|
struct minix_inode_info *ei;
|
|
ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
|
|
if (!ei)
|
|
return NULL;
|
|
return &ei->vfs_inode;
|
|
}
|
|
|
|
static void minix_i_callback(struct rcu_head *head)
|
|
{
|
|
struct inode *inode = container_of(head, struct inode, i_rcu);
|
|
kmem_cache_free(minix_inode_cachep, minix_i(inode));
|
|
}
|
|
|
|
static void minix_destroy_inode(struct inode *inode)
|
|
{
|
|
call_rcu(&inode->i_rcu, minix_i_callback);
|
|
}
|
|
|
|
static void init_once(void *foo)
|
|
{
|
|
struct minix_inode_info *ei = (struct minix_inode_info *) foo;
|
|
|
|
inode_init_once(&ei->vfs_inode);
|
|
}
|
|
|
|
static int __init init_inodecache(void)
|
|
{
|
|
minix_inode_cachep = kmem_cache_create("minix_inode_cache",
|
|
sizeof(struct minix_inode_info),
|
|
0, (SLAB_RECLAIM_ACCOUNT|
|
|
SLAB_MEM_SPREAD),
|
|
init_once);
|
|
if (minix_inode_cachep == NULL)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
static void destroy_inodecache(void)
|
|
{
|
|
/*
|
|
* Make sure all delayed rcu free inodes are flushed before we
|
|
* destroy cache.
|
|
*/
|
|
rcu_barrier();
|
|
kmem_cache_destroy(minix_inode_cachep);
|
|
}
|
|
|
|
static const struct super_operations minix_sops = {
|
|
.alloc_inode = minix_alloc_inode,
|
|
.destroy_inode = minix_destroy_inode,
|
|
.write_inode = minix_write_inode,
|
|
.evict_inode = minix_evict_inode,
|
|
.put_super = minix_put_super,
|
|
.statfs = minix_statfs,
|
|
.remount_fs = minix_remount,
|
|
};
|
|
|
|
static int minix_remount (struct super_block * sb, int * flags, char * data)
|
|
{
|
|
struct minix_sb_info * sbi = minix_sb(sb);
|
|
struct minix_super_block * ms;
|
|
|
|
sync_filesystem(sb);
|
|
ms = sbi->s_ms;
|
|
if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
|
|
return 0;
|
|
if (*flags & MS_RDONLY) {
|
|
if (ms->s_state & MINIX_VALID_FS ||
|
|
!(sbi->s_mount_state & MINIX_VALID_FS))
|
|
return 0;
|
|
/* Mounting a rw partition read-only. */
|
|
if (sbi->s_version != MINIX_V3)
|
|
ms->s_state = sbi->s_mount_state;
|
|
mark_buffer_dirty(sbi->s_sbh);
|
|
} else {
|
|
/* Mount a partition which is read-only, read-write. */
|
|
if (sbi->s_version != MINIX_V3) {
|
|
sbi->s_mount_state = ms->s_state;
|
|
ms->s_state &= ~MINIX_VALID_FS;
|
|
} else {
|
|
sbi->s_mount_state = MINIX_VALID_FS;
|
|
}
|
|
mark_buffer_dirty(sbi->s_sbh);
|
|
|
|
if (!(sbi->s_mount_state & MINIX_VALID_FS))
|
|
printk("MINIX-fs warning: remounting unchecked fs, "
|
|
"running fsck is recommended\n");
|
|
else if ((sbi->s_mount_state & MINIX_ERROR_FS))
|
|
printk("MINIX-fs warning: remounting fs with errors, "
|
|
"running fsck is recommended\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int minix_fill_super(struct super_block *s, void *data, int silent)
|
|
{
|
|
struct buffer_head *bh;
|
|
struct buffer_head **map;
|
|
struct minix_super_block *ms;
|
|
struct minix3_super_block *m3s = NULL;
|
|
unsigned long i, block;
|
|
struct inode *root_inode;
|
|
struct minix_sb_info *sbi;
|
|
int ret = -EINVAL;
|
|
|
|
sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
|
|
if (!sbi)
|
|
return -ENOMEM;
|
|
s->s_fs_info = sbi;
|
|
|
|
BUILD_BUG_ON(32 != sizeof (struct minix_inode));
|
|
BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
|
|
|
|
if (!sb_set_blocksize(s, BLOCK_SIZE))
|
|
goto out_bad_hblock;
|
|
|
|
if (!(bh = sb_bread(s, 1)))
|
|
goto out_bad_sb;
|
|
|
|
ms = (struct minix_super_block *) bh->b_data;
|
|
sbi->s_ms = ms;
|
|
sbi->s_sbh = bh;
|
|
sbi->s_mount_state = ms->s_state;
|
|
sbi->s_ninodes = ms->s_ninodes;
|
|
sbi->s_nzones = ms->s_nzones;
|
|
sbi->s_imap_blocks = ms->s_imap_blocks;
|
|
sbi->s_zmap_blocks = ms->s_zmap_blocks;
|
|
sbi->s_firstdatazone = ms->s_firstdatazone;
|
|
sbi->s_log_zone_size = ms->s_log_zone_size;
|
|
sbi->s_max_size = ms->s_max_size;
|
|
s->s_magic = ms->s_magic;
|
|
if (s->s_magic == MINIX_SUPER_MAGIC) {
|
|
sbi->s_version = MINIX_V1;
|
|
sbi->s_dirsize = 16;
|
|
sbi->s_namelen = 14;
|
|
s->s_max_links = MINIX_LINK_MAX;
|
|
} else if (s->s_magic == MINIX_SUPER_MAGIC2) {
|
|
sbi->s_version = MINIX_V1;
|
|
sbi->s_dirsize = 32;
|
|
sbi->s_namelen = 30;
|
|
s->s_max_links = MINIX_LINK_MAX;
|
|
} else if (s->s_magic == MINIX2_SUPER_MAGIC) {
|
|
sbi->s_version = MINIX_V2;
|
|
sbi->s_nzones = ms->s_zones;
|
|
sbi->s_dirsize = 16;
|
|
sbi->s_namelen = 14;
|
|
s->s_max_links = MINIX2_LINK_MAX;
|
|
} else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
|
|
sbi->s_version = MINIX_V2;
|
|
sbi->s_nzones = ms->s_zones;
|
|
sbi->s_dirsize = 32;
|
|
sbi->s_namelen = 30;
|
|
s->s_max_links = MINIX2_LINK_MAX;
|
|
} else if ( *(__u16 *)(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {
|
|
m3s = (struct minix3_super_block *) bh->b_data;
|
|
s->s_magic = m3s->s_magic;
|
|
sbi->s_imap_blocks = m3s->s_imap_blocks;
|
|
sbi->s_zmap_blocks = m3s->s_zmap_blocks;
|
|
sbi->s_firstdatazone = m3s->s_firstdatazone;
|
|
sbi->s_log_zone_size = m3s->s_log_zone_size;
|
|
sbi->s_max_size = m3s->s_max_size;
|
|
sbi->s_ninodes = m3s->s_ninodes;
|
|
sbi->s_nzones = m3s->s_zones;
|
|
sbi->s_dirsize = 64;
|
|
sbi->s_namelen = 60;
|
|
sbi->s_version = MINIX_V3;
|
|
sbi->s_mount_state = MINIX_VALID_FS;
|
|
sb_set_blocksize(s, m3s->s_blocksize);
|
|
s->s_max_links = MINIX2_LINK_MAX;
|
|
} else
|
|
goto out_no_fs;
|
|
|
|
/*
|
|
* Allocate the buffer map to keep the superblock small.
|
|
*/
|
|
if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)
|
|
goto out_illegal_sb;
|
|
i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
|
|
map = kzalloc(i, GFP_KERNEL);
|
|
if (!map)
|
|
goto out_no_map;
|
|
sbi->s_imap = &map[0];
|
|
sbi->s_zmap = &map[sbi->s_imap_blocks];
|
|
|
|
block=2;
|
|
for (i=0 ; i < sbi->s_imap_blocks ; i++) {
|
|
if (!(sbi->s_imap[i]=sb_bread(s, block)))
|
|
goto out_no_bitmap;
|
|
block++;
|
|
}
|
|
for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
|
|
if (!(sbi->s_zmap[i]=sb_bread(s, block)))
|
|
goto out_no_bitmap;
|
|
block++;
|
|
}
|
|
|
|
minix_set_bit(0,sbi->s_imap[0]->b_data);
|
|
minix_set_bit(0,sbi->s_zmap[0]->b_data);
|
|
|
|
/* Apparently minix can create filesystems that allocate more blocks for
|
|
* the bitmaps than needed. We simply ignore that, but verify it didn't
|
|
* create one with not enough blocks and bail out if so.
|
|
*/
|
|
block = minix_blocks_needed(sbi->s_ninodes, s->s_blocksize);
|
|
if (sbi->s_imap_blocks < block) {
|
|
printk("MINIX-fs: file system does not have enough "
|
|
"imap blocks allocated. Refusing to mount\n");
|
|
goto out_no_bitmap;
|
|
}
|
|
|
|
block = minix_blocks_needed(
|
|
(sbi->s_nzones - (sbi->s_firstdatazone + 1)),
|
|
s->s_blocksize);
|
|
if (sbi->s_zmap_blocks < block) {
|
|
printk("MINIX-fs: file system does not have enough "
|
|
"zmap blocks allocated. Refusing to mount.\n");
|
|
goto out_no_bitmap;
|
|
}
|
|
|
|
/* set up enough so that it can read an inode */
|
|
s->s_op = &minix_sops;
|
|
root_inode = minix_iget(s, MINIX_ROOT_INO);
|
|
if (IS_ERR(root_inode)) {
|
|
ret = PTR_ERR(root_inode);
|
|
goto out_no_root;
|
|
}
|
|
|
|
ret = -ENOMEM;
|
|
s->s_root = d_make_root(root_inode);
|
|
if (!s->s_root)
|
|
goto out_no_root;
|
|
|
|
if (!(s->s_flags & MS_RDONLY)) {
|
|
if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
|
|
ms->s_state &= ~MINIX_VALID_FS;
|
|
mark_buffer_dirty(bh);
|
|
}
|
|
if (!(sbi->s_mount_state & MINIX_VALID_FS))
|
|
printk("MINIX-fs: mounting unchecked file system, "
|
|
"running fsck is recommended\n");
|
|
else if (sbi->s_mount_state & MINIX_ERROR_FS)
|
|
printk("MINIX-fs: mounting file system with errors, "
|
|
"running fsck is recommended\n");
|
|
|
|
return 0;
|
|
|
|
out_no_root:
|
|
if (!silent)
|
|
printk("MINIX-fs: get root inode failed\n");
|
|
goto out_freemap;
|
|
|
|
out_no_bitmap:
|
|
printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
|
|
out_freemap:
|
|
for (i = 0; i < sbi->s_imap_blocks; i++)
|
|
brelse(sbi->s_imap[i]);
|
|
for (i = 0; i < sbi->s_zmap_blocks; i++)
|
|
brelse(sbi->s_zmap[i]);
|
|
kfree(sbi->s_imap);
|
|
goto out_release;
|
|
|
|
out_no_map:
|
|
ret = -ENOMEM;
|
|
if (!silent)
|
|
printk("MINIX-fs: can't allocate map\n");
|
|
goto out_release;
|
|
|
|
out_illegal_sb:
|
|
if (!silent)
|
|
printk("MINIX-fs: bad superblock\n");
|
|
goto out_release;
|
|
|
|
out_no_fs:
|
|
if (!silent)
|
|
printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
|
|
"on device %s.\n", s->s_id);
|
|
out_release:
|
|
brelse(bh);
|
|
goto out;
|
|
|
|
out_bad_hblock:
|
|
printk("MINIX-fs: blocksize too small for device\n");
|
|
goto out;
|
|
|
|
out_bad_sb:
|
|
printk("MINIX-fs: unable to read superblock\n");
|
|
out:
|
|
s->s_fs_info = NULL;
|
|
kfree(sbi);
|
|
return ret;
|
|
}
|
|
|
|
static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|
{
|
|
struct super_block *sb = dentry->d_sb;
|
|
struct minix_sb_info *sbi = minix_sb(sb);
|
|
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
|
|
buf->f_type = sb->s_magic;
|
|
buf->f_bsize = sb->s_blocksize;
|
|
buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
|
|
buf->f_bfree = minix_count_free_blocks(sb);
|
|
buf->f_bavail = buf->f_bfree;
|
|
buf->f_files = sbi->s_ninodes;
|
|
buf->f_ffree = minix_count_free_inodes(sb);
|
|
buf->f_namelen = sbi->s_namelen;
|
|
buf->f_fsid.val[0] = (u32)id;
|
|
buf->f_fsid.val[1] = (u32)(id >> 32);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int minix_get_block(struct inode *inode, sector_t block,
|
|
struct buffer_head *bh_result, int create)
|
|
{
|
|
if (INODE_VERSION(inode) == MINIX_V1)
|
|
return V1_minix_get_block(inode, block, bh_result, create);
|
|
else
|
|
return V2_minix_get_block(inode, block, bh_result, create);
|
|
}
|
|
|
|
static int minix_writepage(struct page *page, struct writeback_control *wbc)
|
|
{
|
|
return block_write_full_page(page, minix_get_block, wbc);
|
|
}
|
|
|
|
static int minix_readpage(struct file *file, struct page *page)
|
|
{
|
|
return block_read_full_page(page,minix_get_block);
|
|
}
|
|
|
|
int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len)
|
|
{
|
|
return __block_write_begin(page, pos, len, minix_get_block);
|
|
}
|
|
|
|
static void minix_write_failed(struct address_space *mapping, loff_t to)
|
|
{
|
|
struct inode *inode = mapping->host;
|
|
|
|
if (to > inode->i_size) {
|
|
truncate_pagecache(inode, inode->i_size);
|
|
minix_truncate(inode);
|
|
}
|
|
}
|
|
|
|
static int minix_write_begin(struct file *file, struct address_space *mapping,
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
struct page **pagep, void **fsdata)
|
|
{
|
|
int ret;
|
|
|
|
ret = block_write_begin(mapping, pos, len, flags, pagep,
|
|
minix_get_block);
|
|
if (unlikely(ret))
|
|
minix_write_failed(mapping, pos + len);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static sector_t minix_bmap(struct address_space *mapping, sector_t block)
|
|
{
|
|
return generic_block_bmap(mapping,block,minix_get_block);
|
|
}
|
|
|
|
static const struct address_space_operations minix_aops = {
|
|
.readpage = minix_readpage,
|
|
.writepage = minix_writepage,
|
|
.write_begin = minix_write_begin,
|
|
.write_end = generic_write_end,
|
|
.bmap = minix_bmap
|
|
};
|
|
|
|
static const struct inode_operations minix_symlink_inode_operations = {
|
|
.readlink = generic_readlink,
|
|
.follow_link = page_follow_link_light,
|
|
.put_link = page_put_link,
|
|
.getattr = minix_getattr,
|
|
};
|
|
|
|
void minix_set_inode(struct inode *inode, dev_t rdev)
|
|
{
|
|
if (S_ISREG(inode->i_mode)) {
|
|
inode->i_op = &minix_file_inode_operations;
|
|
inode->i_fop = &minix_file_operations;
|
|
inode->i_mapping->a_ops = &minix_aops;
|
|
} else if (S_ISDIR(inode->i_mode)) {
|
|
inode->i_op = &minix_dir_inode_operations;
|
|
inode->i_fop = &minix_dir_operations;
|
|
inode->i_mapping->a_ops = &minix_aops;
|
|
} else if (S_ISLNK(inode->i_mode)) {
|
|
inode->i_op = &minix_symlink_inode_operations;
|
|
inode->i_mapping->a_ops = &minix_aops;
|
|
} else
|
|
init_special_inode(inode, inode->i_mode, rdev);
|
|
}
|
|
|
|
/*
|
|
* The minix V1 function to read an inode.
|
|
*/
|
|
static struct inode *V1_minix_iget(struct inode *inode)
|
|
{
|
|
struct buffer_head * bh;
|
|
struct minix_inode * raw_inode;
|
|
struct minix_inode_info *minix_inode = minix_i(inode);
|
|
int i;
|
|
|
|
raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
|
|
if (!raw_inode) {
|
|
iget_failed(inode);
|
|
return ERR_PTR(-EIO);
|
|
}
|
|
inode->i_mode = raw_inode->i_mode;
|
|
i_uid_write(inode, raw_inode->i_uid);
|
|
i_gid_write(inode, raw_inode->i_gid);
|
|
set_nlink(inode, raw_inode->i_nlinks);
|
|
inode->i_size = raw_inode->i_size;
|
|
inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_time;
|
|
inode->i_mtime.tv_nsec = 0;
|
|
inode->i_atime.tv_nsec = 0;
|
|
inode->i_ctime.tv_nsec = 0;
|
|
inode->i_blocks = 0;
|
|
for (i = 0; i < 9; i++)
|
|
minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
|
|
minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
|
|
brelse(bh);
|
|
unlock_new_inode(inode);
|
|
return inode;
|
|
}
|
|
|
|
/*
|
|
* The minix V2 function to read an inode.
|
|
*/
|
|
static struct inode *V2_minix_iget(struct inode *inode)
|
|
{
|
|
struct buffer_head * bh;
|
|
struct minix2_inode * raw_inode;
|
|
struct minix_inode_info *minix_inode = minix_i(inode);
|
|
int i;
|
|
|
|
raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
|
|
if (!raw_inode) {
|
|
iget_failed(inode);
|
|
return ERR_PTR(-EIO);
|
|
}
|
|
inode->i_mode = raw_inode->i_mode;
|
|
i_uid_write(inode, raw_inode->i_uid);
|
|
i_gid_write(inode, raw_inode->i_gid);
|
|
set_nlink(inode, raw_inode->i_nlinks);
|
|
inode->i_size = raw_inode->i_size;
|
|
inode->i_mtime.tv_sec = raw_inode->i_mtime;
|
|
inode->i_atime.tv_sec = raw_inode->i_atime;
|
|
inode->i_ctime.tv_sec = raw_inode->i_ctime;
|
|
inode->i_mtime.tv_nsec = 0;
|
|
inode->i_atime.tv_nsec = 0;
|
|
inode->i_ctime.tv_nsec = 0;
|
|
inode->i_blocks = 0;
|
|
for (i = 0; i < 10; i++)
|
|
minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
|
|
minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
|
|
brelse(bh);
|
|
unlock_new_inode(inode);
|
|
return inode;
|
|
}
|
|
|
|
/*
|
|
* The global function to read an inode.
|
|
*/
|
|
struct inode *minix_iget(struct super_block *sb, unsigned long ino)
|
|
{
|
|
struct inode *inode;
|
|
|
|
inode = iget_locked(sb, ino);
|
|
if (!inode)
|
|
return ERR_PTR(-ENOMEM);
|
|
if (!(inode->i_state & I_NEW))
|
|
return inode;
|
|
|
|
if (INODE_VERSION(inode) == MINIX_V1)
|
|
return V1_minix_iget(inode);
|
|
else
|
|
return V2_minix_iget(inode);
|
|
}
|
|
|
|
/*
|
|
* The minix V1 function to synchronize an inode.
|
|
*/
|
|
static struct buffer_head * V1_minix_update_inode(struct inode * inode)
|
|
{
|
|
struct buffer_head * bh;
|
|
struct minix_inode * raw_inode;
|
|
struct minix_inode_info *minix_inode = minix_i(inode);
|
|
int i;
|
|
|
|
raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
|
|
if (!raw_inode)
|
|
return NULL;
|
|
raw_inode->i_mode = inode->i_mode;
|
|
raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
|
|
raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
|
|
raw_inode->i_nlinks = inode->i_nlink;
|
|
raw_inode->i_size = inode->i_size;
|
|
raw_inode->i_time = inode->i_mtime.tv_sec;
|
|
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
|
|
raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
|
|
else for (i = 0; i < 9; i++)
|
|
raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
|
|
mark_buffer_dirty(bh);
|
|
return bh;
|
|
}
|
|
|
|
/*
|
|
* The minix V2 function to synchronize an inode.
|
|
*/
|
|
static struct buffer_head * V2_minix_update_inode(struct inode * inode)
|
|
{
|
|
struct buffer_head * bh;
|
|
struct minix2_inode * raw_inode;
|
|
struct minix_inode_info *minix_inode = minix_i(inode);
|
|
int i;
|
|
|
|
raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
|
|
if (!raw_inode)
|
|
return NULL;
|
|
raw_inode->i_mode = inode->i_mode;
|
|
raw_inode->i_uid = fs_high2lowuid(i_uid_read(inode));
|
|
raw_inode->i_gid = fs_high2lowgid(i_gid_read(inode));
|
|
raw_inode->i_nlinks = inode->i_nlink;
|
|
raw_inode->i_size = inode->i_size;
|
|
raw_inode->i_mtime = inode->i_mtime.tv_sec;
|
|
raw_inode->i_atime = inode->i_atime.tv_sec;
|
|
raw_inode->i_ctime = inode->i_ctime.tv_sec;
|
|
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
|
|
raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
|
|
else for (i = 0; i < 10; i++)
|
|
raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
|
|
mark_buffer_dirty(bh);
|
|
return bh;
|
|
}
|
|
|
|
static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
|
|
{
|
|
int err = 0;
|
|
struct buffer_head *bh;
|
|
|
|
if (INODE_VERSION(inode) == MINIX_V1)
|
|
bh = V1_minix_update_inode(inode);
|
|
else
|
|
bh = V2_minix_update_inode(inode);
|
|
if (!bh)
|
|
return -EIO;
|
|
if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
|
|
sync_dirty_buffer(bh);
|
|
if (buffer_req(bh) && !buffer_uptodate(bh)) {
|
|
printk("IO error syncing minix inode [%s:%08lx]\n",
|
|
inode->i_sb->s_id, inode->i_ino);
|
|
err = -EIO;
|
|
}
|
|
}
|
|
brelse (bh);
|
|
return err;
|
|
}
|
|
|
|
int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
|
|
{
|
|
struct super_block *sb = dentry->d_sb;
|
|
generic_fillattr(dentry->d_inode, stat);
|
|
if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
|
|
stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
|
|
else
|
|
stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
|
|
stat->blksize = sb->s_blocksize;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The function that is called for file truncation.
|
|
*/
|
|
void minix_truncate(struct inode * inode)
|
|
{
|
|
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
|
|
return;
|
|
if (INODE_VERSION(inode) == MINIX_V1)
|
|
V1_minix_truncate(inode);
|
|
else
|
|
V2_minix_truncate(inode);
|
|
}
|
|
|
|
static struct dentry *minix_mount(struct file_system_type *fs_type,
|
|
int flags, const char *dev_name, void *data)
|
|
{
|
|
return mount_bdev(fs_type, flags, dev_name, data, minix_fill_super);
|
|
}
|
|
|
|
static struct file_system_type minix_fs_type = {
|
|
.owner = THIS_MODULE,
|
|
.name = "minix",
|
|
.mount = minix_mount,
|
|
.kill_sb = kill_block_super,
|
|
.fs_flags = FS_REQUIRES_DEV,
|
|
};
|
|
MODULE_ALIAS_FS("minix");
|
|
|
|
static int __init init_minix_fs(void)
|
|
{
|
|
int err = init_inodecache();
|
|
if (err)
|
|
goto out1;
|
|
err = register_filesystem(&minix_fs_type);
|
|
if (err)
|
|
goto out;
|
|
return 0;
|
|
out:
|
|
destroy_inodecache();
|
|
out1:
|
|
return err;
|
|
}
|
|
|
|
static void __exit exit_minix_fs(void)
|
|
{
|
|
unregister_filesystem(&minix_fs_type);
|
|
destroy_inodecache();
|
|
}
|
|
|
|
module_init(init_minix_fs)
|
|
module_exit(exit_minix_fs)
|
|
MODULE_LICENSE("GPL");
|
|
|