Currently various places in the VFS call vfs_dq_init directly. This means we tie the quota code into the VFS. Get rid of that and make the filesystem responsible for the initialization. For most metadata operations this is a straight forward move into the methods, but for truncate and open it's a bit more complicated. For truncate we currently only call vfs_dq_init for the sys_truncate case because open already takes care of it for ftruncate and open(O_TRUNC) - the new code causes an additional vfs_dq_init for those which is harmless. For open the initialization is moved from do_filp_open into the open method, which means it happens slightly earlier now, and only for regular files. The latter is fine because we don't need to initialize it for operations on special files, and we already do it as part of the namespace operations for directories. Add a dquot_file_open helper that filesystems that support generic quotas can use to fill in ->open. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Jan Kara <jack@suse.cz>
546 lines
13 KiB
C
546 lines
13 KiB
C
/*
|
|
* linux/fs/ufs/truncate.c
|
|
*
|
|
* Copyright (C) 1998
|
|
* Daniel Pirkl <daniel.pirkl@email.cz>
|
|
* Charles University, Faculty of Mathematics and Physics
|
|
*
|
|
* from
|
|
*
|
|
* linux/fs/ext2/truncate.c
|
|
*
|
|
* 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/fs/minix/truncate.c
|
|
*
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*
|
|
* Big-endian to little-endian byte-swapping/bitmaps by
|
|
* David S. Miller (davem@caip.rutgers.edu), 1995
|
|
*/
|
|
|
|
/*
|
|
* Real random numbers for secure rm added 94/02/18
|
|
* Idea from Pierre del Perugia <delperug@gla.ecoledoc.ibp.fr>
|
|
*/
|
|
|
|
/*
|
|
* Adoptation to use page cache and UFS2 write support by
|
|
* Evgeniy Dushistov <dushistov@mail.ru>, 2006-2007
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/fcntl.h>
|
|
#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>
|
|
#include <linux/quotaops.h>
|
|
|
|
#include "ufs_fs.h"
|
|
#include "ufs.h"
|
|
#include "swab.h"
|
|
#include "util.h"
|
|
|
|
/*
|
|
* Secure deletion currently doesn't work. It interacts very badly
|
|
* with buffers shared with memory mappings, and for that reason
|
|
* can't be done in the truncate() routines. It should instead be
|
|
* done separately in "release()" before calling the truncate routines
|
|
* that will release the actual file blocks.
|
|
*
|
|
* Linus
|
|
*/
|
|
|
|
#define DIRECT_BLOCK ((inode->i_size + uspi->s_bsize - 1) >> uspi->s_bshift)
|
|
#define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift)
|
|
|
|
|
|
static int ufs_trunc_direct(struct inode *inode)
|
|
{
|
|
struct ufs_inode_info *ufsi = UFS_I(inode);
|
|
struct super_block * sb;
|
|
struct ufs_sb_private_info * uspi;
|
|
void *p;
|
|
u64 frag1, frag2, frag3, frag4, block1, block2;
|
|
unsigned frag_to_free, free_count;
|
|
unsigned i, tmp;
|
|
int retry;
|
|
|
|
UFSD("ENTER: ino %lu\n", inode->i_ino);
|
|
|
|
sb = inode->i_sb;
|
|
uspi = UFS_SB(sb)->s_uspi;
|
|
|
|
frag_to_free = 0;
|
|
free_count = 0;
|
|
retry = 0;
|
|
|
|
frag1 = DIRECT_FRAGMENT;
|
|
frag4 = min_t(u32, UFS_NDIR_FRAGMENT, ufsi->i_lastfrag);
|
|
frag2 = ((frag1 & uspi->s_fpbmask) ? ((frag1 | uspi->s_fpbmask) + 1) : frag1);
|
|
frag3 = frag4 & ~uspi->s_fpbmask;
|
|
block1 = block2 = 0;
|
|
if (frag2 > frag3) {
|
|
frag2 = frag4;
|
|
frag3 = frag4 = 0;
|
|
} else if (frag2 < frag3) {
|
|
block1 = ufs_fragstoblks (frag2);
|
|
block2 = ufs_fragstoblks (frag3);
|
|
}
|
|
|
|
UFSD("ino %lu, frag1 %llu, frag2 %llu, block1 %llu, block2 %llu,"
|
|
" frag3 %llu, frag4 %llu\n", inode->i_ino,
|
|
(unsigned long long)frag1, (unsigned long long)frag2,
|
|
(unsigned long long)block1, (unsigned long long)block2,
|
|
(unsigned long long)frag3, (unsigned long long)frag4);
|
|
|
|
if (frag1 >= frag2)
|
|
goto next1;
|
|
|
|
/*
|
|
* Free first free fragments
|
|
*/
|
|
p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag1));
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
if (!tmp )
|
|
ufs_panic (sb, "ufs_trunc_direct", "internal error");
|
|
frag2 -= frag1;
|
|
frag1 = ufs_fragnum (frag1);
|
|
|
|
ufs_free_fragments(inode, tmp + frag1, frag2);
|
|
mark_inode_dirty(inode);
|
|
frag_to_free = tmp + frag1;
|
|
|
|
next1:
|
|
/*
|
|
* Free whole blocks
|
|
*/
|
|
for (i = block1 ; i < block2; i++) {
|
|
p = ufs_get_direct_data_ptr(uspi, ufsi, i);
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
if (!tmp)
|
|
continue;
|
|
ufs_data_ptr_clear(uspi, p);
|
|
|
|
if (free_count == 0) {
|
|
frag_to_free = tmp;
|
|
free_count = uspi->s_fpb;
|
|
} else if (free_count > 0 && frag_to_free == tmp - free_count)
|
|
free_count += uspi->s_fpb;
|
|
else {
|
|
ufs_free_blocks (inode, frag_to_free, free_count);
|
|
frag_to_free = tmp;
|
|
free_count = uspi->s_fpb;
|
|
}
|
|
mark_inode_dirty(inode);
|
|
}
|
|
|
|
if (free_count > 0)
|
|
ufs_free_blocks (inode, frag_to_free, free_count);
|
|
|
|
if (frag3 >= frag4)
|
|
goto next3;
|
|
|
|
/*
|
|
* Free last free fragments
|
|
*/
|
|
p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag3));
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
if (!tmp )
|
|
ufs_panic(sb, "ufs_truncate_direct", "internal error");
|
|
frag4 = ufs_fragnum (frag4);
|
|
ufs_data_ptr_clear(uspi, p);
|
|
|
|
ufs_free_fragments (inode, tmp, frag4);
|
|
mark_inode_dirty(inode);
|
|
next3:
|
|
|
|
UFSD("EXIT: ino %lu\n", inode->i_ino);
|
|
return retry;
|
|
}
|
|
|
|
|
|
static int ufs_trunc_indirect(struct inode *inode, u64 offset, void *p)
|
|
{
|
|
struct super_block * sb;
|
|
struct ufs_sb_private_info * uspi;
|
|
struct ufs_buffer_head * ind_ubh;
|
|
void *ind;
|
|
u64 tmp, indirect_block, i, frag_to_free;
|
|
unsigned free_count;
|
|
int retry;
|
|
|
|
UFSD("ENTER: ino %lu, offset %llu, p: %p\n",
|
|
inode->i_ino, (unsigned long long)offset, p);
|
|
|
|
BUG_ON(!p);
|
|
|
|
sb = inode->i_sb;
|
|
uspi = UFS_SB(sb)->s_uspi;
|
|
|
|
frag_to_free = 0;
|
|
free_count = 0;
|
|
retry = 0;
|
|
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
if (!tmp)
|
|
return 0;
|
|
ind_ubh = ubh_bread(sb, tmp, uspi->s_bsize);
|
|
if (tmp != ufs_data_ptr_to_cpu(sb, p)) {
|
|
ubh_brelse (ind_ubh);
|
|
return 1;
|
|
}
|
|
if (!ind_ubh) {
|
|
ufs_data_ptr_clear(uspi, p);
|
|
return 0;
|
|
}
|
|
|
|
indirect_block = (DIRECT_BLOCK > offset) ? (DIRECT_BLOCK - offset) : 0;
|
|
for (i = indirect_block; i < uspi->s_apb; i++) {
|
|
ind = ubh_get_data_ptr(uspi, ind_ubh, i);
|
|
tmp = ufs_data_ptr_to_cpu(sb, ind);
|
|
if (!tmp)
|
|
continue;
|
|
|
|
ufs_data_ptr_clear(uspi, ind);
|
|
ubh_mark_buffer_dirty(ind_ubh);
|
|
if (free_count == 0) {
|
|
frag_to_free = tmp;
|
|
free_count = uspi->s_fpb;
|
|
} else if (free_count > 0 && frag_to_free == tmp - free_count)
|
|
free_count += uspi->s_fpb;
|
|
else {
|
|
ufs_free_blocks (inode, frag_to_free, free_count);
|
|
frag_to_free = tmp;
|
|
free_count = uspi->s_fpb;
|
|
}
|
|
|
|
mark_inode_dirty(inode);
|
|
}
|
|
|
|
if (free_count > 0) {
|
|
ufs_free_blocks (inode, frag_to_free, free_count);
|
|
}
|
|
for (i = 0; i < uspi->s_apb; i++)
|
|
if (!ufs_is_data_ptr_zero(uspi,
|
|
ubh_get_data_ptr(uspi, ind_ubh, i)))
|
|
break;
|
|
if (i >= uspi->s_apb) {
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
ufs_data_ptr_clear(uspi, p);
|
|
|
|
ufs_free_blocks (inode, tmp, uspi->s_fpb);
|
|
mark_inode_dirty(inode);
|
|
ubh_bforget(ind_ubh);
|
|
ind_ubh = NULL;
|
|
}
|
|
if (IS_SYNC(inode) && ind_ubh && ubh_buffer_dirty(ind_ubh)) {
|
|
ubh_ll_rw_block(SWRITE, ind_ubh);
|
|
ubh_wait_on_buffer (ind_ubh);
|
|
}
|
|
ubh_brelse (ind_ubh);
|
|
|
|
UFSD("EXIT: ino %lu\n", inode->i_ino);
|
|
|
|
return retry;
|
|
}
|
|
|
|
static int ufs_trunc_dindirect(struct inode *inode, u64 offset, void *p)
|
|
{
|
|
struct super_block * sb;
|
|
struct ufs_sb_private_info * uspi;
|
|
struct ufs_buffer_head *dind_bh;
|
|
u64 i, tmp, dindirect_block;
|
|
void *dind;
|
|
int retry = 0;
|
|
|
|
UFSD("ENTER: ino %lu\n", inode->i_ino);
|
|
|
|
sb = inode->i_sb;
|
|
uspi = UFS_SB(sb)->s_uspi;
|
|
|
|
dindirect_block = (DIRECT_BLOCK > offset)
|
|
? ((DIRECT_BLOCK - offset) >> uspi->s_apbshift) : 0;
|
|
retry = 0;
|
|
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
if (!tmp)
|
|
return 0;
|
|
dind_bh = ubh_bread(sb, tmp, uspi->s_bsize);
|
|
if (tmp != ufs_data_ptr_to_cpu(sb, p)) {
|
|
ubh_brelse (dind_bh);
|
|
return 1;
|
|
}
|
|
if (!dind_bh) {
|
|
ufs_data_ptr_clear(uspi, p);
|
|
return 0;
|
|
}
|
|
|
|
for (i = dindirect_block ; i < uspi->s_apb ; i++) {
|
|
dind = ubh_get_data_ptr(uspi, dind_bh, i);
|
|
tmp = ufs_data_ptr_to_cpu(sb, dind);
|
|
if (!tmp)
|
|
continue;
|
|
retry |= ufs_trunc_indirect (inode, offset + (i << uspi->s_apbshift), dind);
|
|
ubh_mark_buffer_dirty(dind_bh);
|
|
}
|
|
|
|
for (i = 0; i < uspi->s_apb; i++)
|
|
if (!ufs_is_data_ptr_zero(uspi,
|
|
ubh_get_data_ptr(uspi, dind_bh, i)))
|
|
break;
|
|
if (i >= uspi->s_apb) {
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
ufs_data_ptr_clear(uspi, p);
|
|
|
|
ufs_free_blocks(inode, tmp, uspi->s_fpb);
|
|
mark_inode_dirty(inode);
|
|
ubh_bforget(dind_bh);
|
|
dind_bh = NULL;
|
|
}
|
|
if (IS_SYNC(inode) && dind_bh && ubh_buffer_dirty(dind_bh)) {
|
|
ubh_ll_rw_block(SWRITE, dind_bh);
|
|
ubh_wait_on_buffer (dind_bh);
|
|
}
|
|
ubh_brelse (dind_bh);
|
|
|
|
UFSD("EXIT: ino %lu\n", inode->i_ino);
|
|
|
|
return retry;
|
|
}
|
|
|
|
static int ufs_trunc_tindirect(struct inode *inode)
|
|
{
|
|
struct super_block *sb = inode->i_sb;
|
|
struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
|
|
struct ufs_inode_info *ufsi = UFS_I(inode);
|
|
struct ufs_buffer_head * tind_bh;
|
|
u64 tindirect_block, tmp, i;
|
|
void *tind, *p;
|
|
int retry;
|
|
|
|
UFSD("ENTER: ino %lu\n", inode->i_ino);
|
|
|
|
retry = 0;
|
|
|
|
tindirect_block = (DIRECT_BLOCK > (UFS_NDADDR + uspi->s_apb + uspi->s_2apb))
|
|
? ((DIRECT_BLOCK - UFS_NDADDR - uspi->s_apb - uspi->s_2apb) >> uspi->s_2apbshift) : 0;
|
|
|
|
p = ufs_get_direct_data_ptr(uspi, ufsi, UFS_TIND_BLOCK);
|
|
if (!(tmp = ufs_data_ptr_to_cpu(sb, p)))
|
|
return 0;
|
|
tind_bh = ubh_bread (sb, tmp, uspi->s_bsize);
|
|
if (tmp != ufs_data_ptr_to_cpu(sb, p)) {
|
|
ubh_brelse (tind_bh);
|
|
return 1;
|
|
}
|
|
if (!tind_bh) {
|
|
ufs_data_ptr_clear(uspi, p);
|
|
return 0;
|
|
}
|
|
|
|
for (i = tindirect_block ; i < uspi->s_apb ; i++) {
|
|
tind = ubh_get_data_ptr(uspi, tind_bh, i);
|
|
retry |= ufs_trunc_dindirect(inode, UFS_NDADDR +
|
|
uspi->s_apb + ((i + 1) << uspi->s_2apbshift), tind);
|
|
ubh_mark_buffer_dirty(tind_bh);
|
|
}
|
|
for (i = 0; i < uspi->s_apb; i++)
|
|
if (!ufs_is_data_ptr_zero(uspi,
|
|
ubh_get_data_ptr(uspi, tind_bh, i)))
|
|
break;
|
|
if (i >= uspi->s_apb) {
|
|
tmp = ufs_data_ptr_to_cpu(sb, p);
|
|
ufs_data_ptr_clear(uspi, p);
|
|
|
|
ufs_free_blocks(inode, tmp, uspi->s_fpb);
|
|
mark_inode_dirty(inode);
|
|
ubh_bforget(tind_bh);
|
|
tind_bh = NULL;
|
|
}
|
|
if (IS_SYNC(inode) && tind_bh && ubh_buffer_dirty(tind_bh)) {
|
|
ubh_ll_rw_block(SWRITE, tind_bh);
|
|
ubh_wait_on_buffer (tind_bh);
|
|
}
|
|
ubh_brelse (tind_bh);
|
|
|
|
UFSD("EXIT: ino %lu\n", inode->i_ino);
|
|
return retry;
|
|
}
|
|
|
|
static int ufs_alloc_lastblock(struct inode *inode)
|
|
{
|
|
int err = 0;
|
|
struct super_block *sb = inode->i_sb;
|
|
struct address_space *mapping = inode->i_mapping;
|
|
struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
|
|
unsigned i, end;
|
|
sector_t lastfrag;
|
|
struct page *lastpage;
|
|
struct buffer_head *bh;
|
|
u64 phys64;
|
|
|
|
lastfrag = (i_size_read(inode) + uspi->s_fsize - 1) >> uspi->s_fshift;
|
|
|
|
if (!lastfrag)
|
|
goto out;
|
|
|
|
lastfrag--;
|
|
|
|
lastpage = ufs_get_locked_page(mapping, lastfrag >>
|
|
(PAGE_CACHE_SHIFT - inode->i_blkbits));
|
|
if (IS_ERR(lastpage)) {
|
|
err = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
end = lastfrag & ((1 << (PAGE_CACHE_SHIFT - inode->i_blkbits)) - 1);
|
|
bh = page_buffers(lastpage);
|
|
for (i = 0; i < end; ++i)
|
|
bh = bh->b_this_page;
|
|
|
|
|
|
err = ufs_getfrag_block(inode, lastfrag, bh, 1);
|
|
|
|
if (unlikely(err))
|
|
goto out_unlock;
|
|
|
|
if (buffer_new(bh)) {
|
|
clear_buffer_new(bh);
|
|
unmap_underlying_metadata(bh->b_bdev,
|
|
bh->b_blocknr);
|
|
/*
|
|
* we do not zeroize fragment, because of
|
|
* if it maped to hole, it already contains zeroes
|
|
*/
|
|
set_buffer_uptodate(bh);
|
|
mark_buffer_dirty(bh);
|
|
set_page_dirty(lastpage);
|
|
}
|
|
|
|
if (lastfrag >= UFS_IND_FRAGMENT) {
|
|
end = uspi->s_fpb - ufs_fragnum(lastfrag) - 1;
|
|
phys64 = bh->b_blocknr + 1;
|
|
for (i = 0; i < end; ++i) {
|
|
bh = sb_getblk(sb, i + phys64);
|
|
lock_buffer(bh);
|
|
memset(bh->b_data, 0, sb->s_blocksize);
|
|
set_buffer_uptodate(bh);
|
|
mark_buffer_dirty(bh);
|
|
unlock_buffer(bh);
|
|
sync_dirty_buffer(bh);
|
|
brelse(bh);
|
|
}
|
|
}
|
|
out_unlock:
|
|
ufs_put_locked_page(lastpage);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
int ufs_truncate(struct inode *inode, loff_t old_i_size)
|
|
{
|
|
struct ufs_inode_info *ufsi = UFS_I(inode);
|
|
struct super_block *sb = inode->i_sb;
|
|
struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
|
|
int retry, err = 0;
|
|
|
|
UFSD("ENTER: ino %lu, i_size: %llu, old_i_size: %llu\n",
|
|
inode->i_ino, (unsigned long long)i_size_read(inode),
|
|
(unsigned long long)old_i_size);
|
|
|
|
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
|
|
S_ISLNK(inode->i_mode)))
|
|
return -EINVAL;
|
|
if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
|
|
return -EPERM;
|
|
|
|
err = ufs_alloc_lastblock(inode);
|
|
|
|
if (err) {
|
|
i_size_write(inode, old_i_size);
|
|
goto out;
|
|
}
|
|
|
|
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,
|
|
ufs_get_direct_data_ptr(uspi, ufsi,
|
|
UFS_IND_BLOCK));
|
|
retry |= ufs_trunc_dindirect(inode, UFS_IND_BLOCK + uspi->s_apb,
|
|
ufs_get_direct_data_ptr(uspi, ufsi,
|
|
UFS_DIND_BLOCK));
|
|
retry |= ufs_trunc_tindirect (inode);
|
|
if (!retry)
|
|
break;
|
|
if (IS_SYNC(inode) && (inode->i_state & I_DIRTY))
|
|
ufs_sync_inode (inode);
|
|
blk_run_address_space(inode->i_mapping);
|
|
yield();
|
|
}
|
|
|
|
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);
|
|
return err;
|
|
}
|
|
|
|
|
|
/*
|
|
* We don't define our `inode->i_op->truncate', and call it here,
|
|
* because of:
|
|
* - there is no way to know old size
|
|
* - there is no way inform user about error, if it happens in `truncate'
|
|
*/
|
|
static int ufs_setattr(struct dentry *dentry, struct iattr *attr)
|
|
{
|
|
struct inode *inode = dentry->d_inode;
|
|
unsigned int ia_valid = attr->ia_valid;
|
|
int error;
|
|
|
|
error = inode_change_ok(inode, attr);
|
|
if (error)
|
|
return error;
|
|
|
|
if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
|
|
(ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
|
|
error = dquot_transfer(inode, attr);
|
|
if (error)
|
|
return error;
|
|
}
|
|
if (ia_valid & ATTR_SIZE &&
|
|
attr->ia_size != i_size_read(inode)) {
|
|
loff_t old_i_size = inode->i_size;
|
|
|
|
vfs_dq_init(inode);
|
|
|
|
error = vmtruncate(inode, attr->ia_size);
|
|
if (error)
|
|
return error;
|
|
error = ufs_truncate(inode, old_i_size);
|
|
if (error)
|
|
return error;
|
|
}
|
|
return inode_setattr(inode, attr);
|
|
}
|
|
|
|
const struct inode_operations ufs_file_inode_operations = {
|
|
.setattr = ufs_setattr,
|
|
};
|