Subversion Repositories test_project

/*

 *  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/ufs_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 "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_SIZE &&

            attr->ia_size != i_size_read(inode)) {

                loff_t old_i_size = inode->i_size;

                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,

};