mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-31 04:01:48 -04:00
Merge branch 'config' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl
* 'config' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl: BKL: That's all, folks fs/locks.c: Remove stale FIXME left over from BKL conversion ipx: remove the BKL appletalk: remove the BKL x25: remove the BKL ufs: remove the BKL hpfs: remove the BKL drivers: remove extraneous includes of smp_lock.h tracing: don't trace the BKL adfs: remove the big kernel lock
This commit is contained in:
Linus Torvalds
commit
f74b944419
55 changed files with 220 additions and 619 deletions
|
|
@ -1,7 +1,6 @@
|
|||
config UFS_FS
|
||||
tristate "UFS file system support (read only)"
|
||||
depends on BLOCK
|
||||
depends on BKL # probably fixable
|
||||
help
|
||||
BSD and derivate versions of Unix (such as SunOS, FreeBSD, NetBSD,
|
||||
OpenBSD and NeXTstep) use a file system called UFS. Some System V
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@
|
|||
#include <linux/stat.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/smp_lock.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#include <linux/writeback.h>
|
||||
|
||||
|
|
@ -43,7 +42,7 @@
|
|||
#include "swab.h"
|
||||
#include "util.h"
|
||||
|
||||
static u64 ufs_frag_map(struct inode *inode, sector_t frag);
|
||||
static u64 ufs_frag_map(struct inode *inode, sector_t frag, bool needs_lock);
|
||||
|
||||
static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t offsets[4])
|
||||
{
|
||||
|
|
@ -82,7 +81,7 @@ static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t off
|
|||
* the begining of the filesystem.
|
||||
*/
|
||||
|
||||
static u64 ufs_frag_map(struct inode *inode, sector_t frag)
|
||||
static u64 ufs_frag_map(struct inode *inode, sector_t frag, bool needs_lock)
|
||||
{
|
||||
struct ufs_inode_info *ufsi = UFS_I(inode);
|
||||
struct super_block *sb = inode->i_sb;
|
||||
|
|
@ -107,7 +106,8 @@ static u64 ufs_frag_map(struct inode *inode, sector_t frag)
|
|||
|
||||
p = offsets;
|
||||
|
||||
lock_kernel();
|
||||
if (needs_lock)
|
||||
lock_ufs(sb);
|
||||
if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
|
||||
goto ufs2;
|
||||
|
||||
|
|
@ -152,7 +152,8 @@ ufs2:
|
|||
ret = temp + (u64) (frag & uspi->s_fpbmask);
|
||||
|
||||
out:
|
||||
unlock_kernel();
|
||||
if (needs_lock)
|
||||
unlock_ufs(sb);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -415,14 +416,16 @@ out:
|
|||
int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create)
|
||||
{
|
||||
struct super_block * sb = inode->i_sb;
|
||||
struct ufs_sb_private_info * uspi = UFS_SB(sb)->s_uspi;
|
||||
struct ufs_sb_info * sbi = UFS_SB(sb);
|
||||
struct ufs_sb_private_info * uspi = sbi->s_uspi;
|
||||
struct buffer_head * bh;
|
||||
int ret, err, new;
|
||||
unsigned long ptr,phys;
|
||||
u64 phys64 = 0;
|
||||
bool needs_lock = (sbi->mutex_owner != current);
|
||||
|
||||
if (!create) {
|
||||
phys64 = ufs_frag_map(inode, fragment);
|
||||
phys64 = ufs_frag_map(inode, fragment, needs_lock);
|
||||
UFSD("phys64 = %llu\n", (unsigned long long)phys64);
|
||||
if (phys64)
|
||||
map_bh(bh_result, sb, phys64);
|
||||
|
|
@ -436,7 +439,8 @@ int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head
|
|||
ret = 0;
|
||||
bh = NULL;
|
||||
|
||||
lock_kernel();
|
||||
if (needs_lock)
|
||||
lock_ufs(sb);
|
||||
|
||||
UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
|
||||
if (fragment >
|
||||
|
|
@ -498,7 +502,9 @@ out:
|
|||
set_buffer_new(bh_result);
|
||||
map_bh(bh_result, sb, phys);
|
||||
abort:
|
||||
unlock_kernel();
|
||||
if (needs_lock)
|
||||
unlock_ufs(sb);
|
||||
|
||||
return err;
|
||||
|
||||
abort_too_big:
|
||||
|
|
@ -506,48 +512,6 @@ abort_too_big:
|
|||
goto abort;
|
||||
}
|
||||
|
||||
static struct buffer_head *ufs_getfrag(struct inode *inode,
|
||||
unsigned int fragment,
|
||||
int create, int *err)
|
||||
{
|
||||
struct buffer_head dummy;
|
||||
int error;
|
||||
|
||||
dummy.b_state = 0;
|
||||
dummy.b_blocknr = -1000;
|
||||
error = ufs_getfrag_block(inode, fragment, &dummy, create);
|
||||
*err = error;
|
||||
if (!error && buffer_mapped(&dummy)) {
|
||||
struct buffer_head *bh;
|
||||
bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
|
||||
if (buffer_new(&dummy)) {
|
||||
memset(bh->b_data, 0, inode->i_sb->s_blocksize);
|
||||
set_buffer_uptodate(bh);
|
||||
mark_buffer_dirty(bh);
|
||||
}
|
||||
return bh;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct buffer_head * ufs_bread (struct inode * inode, unsigned fragment,
|
||||
int create, int * err)
|
||||
{
|
||||
struct buffer_head * bh;
|
||||
|
||||
UFSD("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment);
|
||||
bh = ufs_getfrag (inode, fragment, create, err);
|
||||
if (!bh || buffer_uptodate(bh))
|
||||
return bh;
|
||||
ll_rw_block (READ, 1, &bh);
|
||||
wait_on_buffer (bh);
|
||||
if (buffer_uptodate(bh))
|
||||
return bh;
|
||||
brelse (bh);
|
||||
*err = -EIO;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int ufs_writepage(struct page *page, struct writeback_control *wbc)
|
||||
{
|
||||
return block_write_full_page(page,ufs_getfrag_block,wbc);
|
||||
|
|
@ -900,9 +864,9 @@ static int ufs_update_inode(struct inode * inode, int do_sync)
|
|||
int ufs_write_inode(struct inode *inode, struct writeback_control *wbc)
|
||||
{
|
||||
int ret;
|
||||
lock_kernel();
|
||||
lock_ufs(inode->i_sb);
|
||||
ret = ufs_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
|
||||
unlock_kernel();
|
||||
unlock_ufs(inode->i_sb);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -922,22 +886,22 @@ void ufs_evict_inode(struct inode * inode)
|
|||
if (want_delete) {
|
||||
loff_t old_i_size;
|
||||
/*UFS_I(inode)->i_dtime = CURRENT_TIME;*/
|
||||
lock_kernel();
|
||||
lock_ufs(inode->i_sb);
|
||||
mark_inode_dirty(inode);
|
||||
ufs_update_inode(inode, IS_SYNC(inode));
|
||||
old_i_size = inode->i_size;
|
||||
inode->i_size = 0;
|
||||
if (inode->i_blocks && ufs_truncate(inode, old_i_size))
|
||||
ufs_warning(inode->i_sb, __func__, "ufs_truncate failed\n");
|
||||
unlock_kernel();
|
||||
unlock_ufs(inode->i_sb);
|
||||
}
|
||||
|
||||
invalidate_inode_buffers(inode);
|
||||
end_writeback(inode);
|
||||
|
||||
if (want_delete) {
|
||||
lock_kernel();
|
||||
lock_ufs(inode->i_sb);
|
||||
ufs_free_inode (inode);
|
||||
unlock_kernel();
|
||||
unlock_ufs(inode->i_sb);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,7 +29,6 @@
|
|||
|
||||
#include <linux/time.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/smp_lock.h>
|
||||
|
||||
#include "ufs_fs.h"
|
||||
#include "ufs.h"
|
||||
|
|
@ -55,16 +54,16 @@ static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, stru
|
|||
if (dentry->d_name.len > UFS_MAXNAMLEN)
|
||||
return ERR_PTR(-ENAMETOOLONG);
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
ino = ufs_inode_by_name(dir, &dentry->d_name);
|
||||
if (ino) {
|
||||
inode = ufs_iget(dir->i_sb, ino);
|
||||
if (IS_ERR(inode)) {
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
return ERR_CAST(inode);
|
||||
}
|
||||
}
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
d_add(dentry, inode);
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -93,9 +92,9 @@ static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
|
|||
inode->i_fop = &ufs_file_operations;
|
||||
inode->i_mapping->a_ops = &ufs_aops;
|
||||
mark_inode_dirty(inode);
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
err = ufs_add_nondir(dentry, inode);
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
}
|
||||
UFSD("END: err=%d\n", err);
|
||||
return err;
|
||||
|
|
@ -115,9 +114,9 @@ static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t
|
|||
init_special_inode(inode, mode, rdev);
|
||||
ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev);
|
||||
mark_inode_dirty(inode);
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
err = ufs_add_nondir(dentry, inode);
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
|
@ -133,7 +132,7 @@ static int ufs_symlink (struct inode * dir, struct dentry * dentry,
|
|||
if (l > sb->s_blocksize)
|
||||
goto out_notlocked;
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO);
|
||||
err = PTR_ERR(inode);
|
||||
if (IS_ERR(inode))
|
||||
|
|
@ -156,7 +155,7 @@ static int ufs_symlink (struct inode * dir, struct dentry * dentry,
|
|||
|
||||
err = ufs_add_nondir(dentry, inode);
|
||||
out:
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
out_notlocked:
|
||||
return err;
|
||||
|
||||
|
|
@ -172,9 +171,9 @@ static int ufs_link (struct dentry * old_dentry, struct inode * dir,
|
|||
struct inode *inode = old_dentry->d_inode;
|
||||
int error;
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
if (inode->i_nlink >= UFS_LINK_MAX) {
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
return -EMLINK;
|
||||
}
|
||||
|
||||
|
|
@ -183,7 +182,7 @@ static int ufs_link (struct dentry * old_dentry, struct inode * dir,
|
|||
ihold(inode);
|
||||
|
||||
error = ufs_add_nondir(dentry, inode);
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
return error;
|
||||
}
|
||||
|
||||
|
|
@ -195,7 +194,7 @@ static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
|
|||
if (dir->i_nlink >= UFS_LINK_MAX)
|
||||
goto out;
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
inode_inc_link_count(dir);
|
||||
|
||||
inode = ufs_new_inode(dir, S_IFDIR|mode);
|
||||
|
|
@ -216,7 +215,7 @@ static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
|
|||
err = ufs_add_link(dentry, inode);
|
||||
if (err)
|
||||
goto out_fail;
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
|
||||
d_instantiate(dentry, inode);
|
||||
out:
|
||||
|
|
@ -228,7 +227,7 @@ out_fail:
|
|||
iput (inode);
|
||||
out_dir:
|
||||
inode_dec_link_count(dir);
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
goto out;
|
||||
}
|
||||
|
||||
|
|
@ -259,7 +258,7 @@ static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
|
|||
struct inode * inode = dentry->d_inode;
|
||||
int err= -ENOTEMPTY;
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(dir->i_sb);
|
||||
if (ufs_empty_dir (inode)) {
|
||||
err = ufs_unlink(dir, dentry);
|
||||
if (!err) {
|
||||
|
|
@ -268,7 +267,7 @@ static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
|
|||
inode_dec_link_count(dir);
|
||||
}
|
||||
}
|
||||
unlock_kernel();
|
||||
unlock_ufs(dir->i_sb);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -84,7 +84,6 @@
|
|||
#include <linux/blkdev.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/parser.h>
|
||||
#include <linux/smp_lock.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#include <linux/vfs.h>
|
||||
#include <linux/log2.h>
|
||||
|
|
@ -96,6 +95,26 @@
|
|||
#include "swab.h"
|
||||
#include "util.h"
|
||||
|
||||
void lock_ufs(struct super_block *sb)
|
||||
{
|
||||
#if defined(CONFIG_SMP) || defined (CONFIG_PREEMPT)
|
||||
struct ufs_sb_info *sbi = UFS_SB(sb);
|
||||
|
||||
mutex_lock(&sbi->mutex);
|
||||
sbi->mutex_owner = current;
|
||||
#endif
|
||||
}
|
||||
|
||||
void unlock_ufs(struct super_block *sb)
|
||||
{
|
||||
#if defined(CONFIG_SMP) || defined (CONFIG_PREEMPT)
|
||||
struct ufs_sb_info *sbi = UFS_SB(sb);
|
||||
|
||||
sbi->mutex_owner = NULL;
|
||||
mutex_unlock(&sbi->mutex);
|
||||
#endif
|
||||
}
|
||||
|
||||
static struct inode *ufs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
|
||||
{
|
||||
struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
|
||||
|
|
@ -313,7 +332,6 @@ void ufs_panic (struct super_block * sb, const char * function,
|
|||
struct ufs_super_block_first * usb1;
|
||||
va_list args;
|
||||
|
||||
lock_kernel();
|
||||
uspi = UFS_SB(sb)->s_uspi;
|
||||
usb1 = ubh_get_usb_first(uspi);
|
||||
|
||||
|
|
@ -521,7 +539,7 @@ static int ufs_read_cylinder_structures(struct super_block *sb)
|
|||
*/
|
||||
size = uspi->s_cssize;
|
||||
blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
|
||||
base = space = kmalloc(size, GFP_KERNEL);
|
||||
base = space = kmalloc(size, GFP_NOFS);
|
||||
if (!base)
|
||||
goto failed;
|
||||
sbi->s_csp = (struct ufs_csum *)space;
|
||||
|
|
@ -546,7 +564,7 @@ static int ufs_read_cylinder_structures(struct super_block *sb)
|
|||
* Read cylinder group (we read only first fragment from block
|
||||
* at this time) and prepare internal data structures for cg caching.
|
||||
*/
|
||||
if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_KERNEL)))
|
||||
if (!(sbi->s_ucg = kmalloc (sizeof(struct buffer_head *) * uspi->s_ncg, GFP_NOFS)))
|
||||
goto failed;
|
||||
for (i = 0; i < uspi->s_ncg; i++)
|
||||
sbi->s_ucg[i] = NULL;
|
||||
|
|
@ -564,7 +582,7 @@ static int ufs_read_cylinder_structures(struct super_block *sb)
|
|||
ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
|
||||
}
|
||||
for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
|
||||
if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_KERNEL)))
|
||||
if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_NOFS)))
|
||||
goto failed;
|
||||
sbi->s_cgno[i] = UFS_CGNO_EMPTY;
|
||||
}
|
||||
|
|
@ -646,8 +664,6 @@ static void ufs_put_super_internal(struct super_block *sb)
|
|||
|
||||
UFSD("ENTER\n");
|
||||
|
||||
lock_kernel();
|
||||
|
||||
ufs_put_cstotal(sb);
|
||||
size = uspi->s_cssize;
|
||||
blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
|
||||
|
|
@ -676,8 +692,6 @@ static void ufs_put_super_internal(struct super_block *sb)
|
|||
kfree (sbi->s_ucg);
|
||||
kfree (base);
|
||||
|
||||
unlock_kernel();
|
||||
|
||||
UFSD("EXIT\n");
|
||||
}
|
||||
|
||||
|
|
@ -696,8 +710,6 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
|
|||
unsigned maxsymlen;
|
||||
int ret = -EINVAL;
|
||||
|
||||
lock_kernel();
|
||||
|
||||
uspi = NULL;
|
||||
ubh = NULL;
|
||||
flags = 0;
|
||||
|
|
@ -718,6 +730,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
|
|||
goto failed;
|
||||
}
|
||||
#endif
|
||||
mutex_init(&sbi->mutex);
|
||||
/*
|
||||
* Set default mount options
|
||||
* Parse mount options
|
||||
|
|
@ -1165,7 +1178,6 @@ magic_found:
|
|||
goto failed;
|
||||
|
||||
UFSD("EXIT\n");
|
||||
unlock_kernel();
|
||||
return 0;
|
||||
|
||||
dalloc_failed:
|
||||
|
|
@ -1177,12 +1189,10 @@ failed:
|
|||
kfree(sbi);
|
||||
sb->s_fs_info = NULL;
|
||||
UFSD("EXIT (FAILED)\n");
|
||||
unlock_kernel();
|
||||
return ret;
|
||||
|
||||
failed_nomem:
|
||||
UFSD("EXIT (NOMEM)\n");
|
||||
unlock_kernel();
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
|
|
@ -1193,8 +1203,8 @@ static int ufs_sync_fs(struct super_block *sb, int wait)
|
|||
struct ufs_super_block_third * usb3;
|
||||
unsigned flags;
|
||||
|
||||
lock_ufs(sb);
|
||||
lock_super(sb);
|
||||
lock_kernel();
|
||||
|
||||
UFSD("ENTER\n");
|
||||
|
||||
|
|
@ -1213,8 +1223,8 @@ static int ufs_sync_fs(struct super_block *sb, int wait)
|
|||
sb->s_dirt = 0;
|
||||
|
||||
UFSD("EXIT\n");
|
||||
unlock_kernel();
|
||||
unlock_super(sb);
|
||||
unlock_ufs(sb);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1256,7 +1266,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
|
|||
unsigned new_mount_opt, ufstype;
|
||||
unsigned flags;
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(sb);
|
||||
lock_super(sb);
|
||||
uspi = UFS_SB(sb)->s_uspi;
|
||||
flags = UFS_SB(sb)->s_flags;
|
||||
|
|
@ -1272,7 +1282,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
|
|||
ufs_set_opt (new_mount_opt, ONERROR_LOCK);
|
||||
if (!ufs_parse_options (data, &new_mount_opt)) {
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
|
||||
|
|
@ -1280,14 +1290,14 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
|
|||
} else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
|
||||
printk("ufstype can't be changed during remount\n");
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if ((*mount_flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
|
||||
UFS_SB(sb)->s_mount_opt = new_mount_opt;
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1313,7 +1323,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
|
|||
printk("ufs was compiled with read-only support, "
|
||||
"can't be mounted as read-write\n");
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return -EINVAL;
|
||||
#else
|
||||
if (ufstype != UFS_MOUNT_UFSTYPE_SUN &&
|
||||
|
|
@ -1323,13 +1333,13 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
|
|||
ufstype != UFS_MOUNT_UFSTYPE_UFS2) {
|
||||
printk("this ufstype is read-only supported\n");
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (!ufs_read_cylinder_structures(sb)) {
|
||||
printk("failed during remounting\n");
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return -EPERM;
|
||||
}
|
||||
sb->s_flags &= ~MS_RDONLY;
|
||||
|
|
@ -1337,7 +1347,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
|
|||
}
|
||||
UFS_SB(sb)->s_mount_opt = new_mount_opt;
|
||||
unlock_super(sb);
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1371,7 +1381,7 @@ static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|||
struct ufs_super_block_third *usb3;
|
||||
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
|
||||
|
||||
lock_kernel();
|
||||
lock_ufs(sb);
|
||||
|
||||
usb1 = ubh_get_usb_first(uspi);
|
||||
usb2 = ubh_get_usb_second(uspi);
|
||||
|
|
@ -1395,7 +1405,7 @@ static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|||
buf->f_fsid.val[0] = (u32)id;
|
||||
buf->f_fsid.val[1] = (u32)(id >> 32);
|
||||
|
||||
unlock_kernel();
|
||||
unlock_ufs(sb);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1405,7 +1415,7 @@ static struct kmem_cache * ufs_inode_cachep;
|
|||
static struct inode *ufs_alloc_inode(struct super_block *sb)
|
||||
{
|
||||
struct ufs_inode_info *ei;
|
||||
ei = (struct ufs_inode_info *)kmem_cache_alloc(ufs_inode_cachep, GFP_KERNEL);
|
||||
ei = (struct ufs_inode_info *)kmem_cache_alloc(ufs_inode_cachep, GFP_NOFS);
|
||||
if (!ei)
|
||||
return NULL;
|
||||
ei->vfs_inode.i_version = 1;
|
||||
|
|
|
|||
|
|
@ -40,7 +40,6 @@
|
|||
#include <linux/time.h>
|
||||
#include <linux/stat.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/smp_lock.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#include <linux/blkdev.h>
|
||||
#include <linux/sched.h>
|
||||
|
|
@ -467,7 +466,6 @@ int ufs_truncate(struct inode *inode, loff_t old_i_size)
|
|||
|
||||
block_truncate_page(inode->i_mapping, inode->i_size, ufs_getfrag_block);
|
||||
|
||||
lock_kernel();
|
||||
while (1) {
|
||||
retry = ufs_trunc_direct(inode);
|
||||
retry |= ufs_trunc_indirect(inode, UFS_IND_BLOCK,
|
||||
|
|
@ -487,7 +485,6 @@ int ufs_truncate(struct inode *inode, loff_t old_i_size)
|
|||
|
||||
inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
|
||||
ufsi->i_lastfrag = DIRECT_FRAGMENT;
|
||||
unlock_kernel();
|
||||
mark_inode_dirty(inode);
|
||||
out:
|
||||
UFSD("EXIT: err %d\n", err);
|
||||
|
|
@ -510,7 +507,9 @@ int ufs_setattr(struct dentry *dentry, struct iattr *attr)
|
|||
/* XXX(truncate): truncate_setsize should be called last */
|
||||
truncate_setsize(inode, attr->ia_size);
|
||||
|
||||
lock_ufs(inode->i_sb);
|
||||
error = ufs_truncate(inode, old_i_size);
|
||||
unlock_ufs(inode->i_sb);
|
||||
if (error)
|
||||
return error;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@ struct ufs_sb_info {
|
|||
unsigned s_cgno[UFS_MAX_GROUP_LOADED];
|
||||
unsigned short s_cg_loaded;
|
||||
unsigned s_mount_opt;
|
||||
struct mutex mutex;
|
||||
struct task_struct *mutex_owner;
|
||||
};
|
||||
|
||||
struct ufs_inode_info {
|
||||
|
|
@ -109,7 +111,6 @@ extern struct inode *ufs_iget(struct super_block *, unsigned long);
|
|||
extern int ufs_write_inode (struct inode *, struct writeback_control *);
|
||||
extern int ufs_sync_inode (struct inode *);
|
||||
extern void ufs_evict_inode (struct inode *);
|
||||
extern struct buffer_head * ufs_bread (struct inode *, unsigned, int, int *);
|
||||
extern int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create);
|
||||
|
||||
/* namei.c */
|
||||
|
|
@ -154,4 +155,7 @@ static inline u32 ufs_dtogd(struct ufs_sb_private_info * uspi, u64 b)
|
|||
return do_div(b, uspi->s_fpg);
|
||||
}
|
||||
|
||||
extern void lock_ufs(struct super_block *sb);
|
||||
extern void unlock_ufs(struct super_block *sb);
|
||||
|
||||
#endif /* _UFS_UFS_H */
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ struct ufs_buffer_head * _ubh_bread_ (struct ufs_sb_private_info * uspi,
|
|||
if (count > UFS_MAXFRAG)
|
||||
return NULL;
|
||||
ubh = (struct ufs_buffer_head *)
|
||||
kmalloc (sizeof (struct ufs_buffer_head), GFP_KERNEL);
|
||||
kmalloc (sizeof (struct ufs_buffer_head), GFP_NOFS);
|
||||
if (!ubh)
|
||||
return NULL;
|
||||
ubh->fragment = fragment;
|
||||
|
|
|
|||
Loading…
Reference in a new issue