Subversion Repositories or1k

/*

 *  linux/fs/hfsplus/inode.c

 *

 * Copyright (C) 2001

 * Brad Boyer (flar@allandria.com)

 * (C) 2003 Ardis Technologies <roman@ardistech.com>

 *

 * Inode handling routines

 */

#include <linux/mm.h>

#include <linux/fs.h>

#include <linux/pagemap.h>

#include <linux/version.h>

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)

#include <linux/buffer_head.h>

#endif

#include "hfsplus_fs.h"

#include "hfsplus_raw.h"

static int hfsplus_readpage(struct file *file, struct page *page)

{

        //printk("readpage: %lu\n", page->index);

        return block_read_full_page(page, hfsplus_get_block);

}

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)

static int hfsplus_writepage(struct page *page, struct writeback_control *wbc)

{

        //printk("writepage: %lu\n", page->index);

        return block_write_full_page(page, hfsplus_get_block, wbc);

}

#else

static int hfsplus_writepage(struct page *page)

{

        //printk("writepage: %lu\n", page->index);

        return block_write_full_page(page, hfsplus_get_block);

}

#endif

static int hfsplus_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)

{

        return cont_prepare_write(page, from, to, hfsplus_get_block,

                &HFSPLUS_I(page->mapping->host).mmu_private);

}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)

static int hfsplus_bmap(struct address_space *mapping, long block)

#else

static sector_t hfsplus_bmap(struct address_space *mapping, sector_t block)

#endif

{

        return generic_block_bmap(mapping, block, hfsplus_get_block);

}

int hfsplus_releasepage(struct page *page, int mask)

{

        struct inode *inode = page->mapping->host;

        struct super_block *sb = inode->i_sb;

        struct hfsplus_btree *tree;

        hfsplus_bnode *node;

        u32 nidx;

        int i, res = 1;

        switch (inode->i_ino) {

        case HFSPLUS_EXT_CNID:

                tree = HFSPLUS_SB(sb).ext_tree;

                break;

        case HFSPLUS_CAT_CNID:

                tree = HFSPLUS_SB(sb).cat_tree;

                break;

        case HFSPLUS_ATTR_CNID:

                tree = HFSPLUS_SB(sb).attr_tree;

                break;

        default:

                BUG();

                return 0;

        }

        if (tree->node_size >= PAGE_CACHE_SIZE) {

                nidx = page->index >> (tree->node_size_shift - PAGE_CACHE_SHIFT);

                spin_lock(&tree->hash_lock);

                node = __hfsplus_find_bnode(tree, nidx);

                if (!node)

                        ;

                else if (atomic_read(&node->refcnt))

                        res = 0;

                else for (i = 0; i < tree->pages_per_bnode; i++) {

                        if (PageActive(node->page[i])) {

                                res = 0;

                                break;

                        }

                }

                if (res && node) {

                        __hfsplus_bnode_remove(node);

                        hfsplus_bnode_free(node);

                }

                spin_unlock(&tree->hash_lock);

        } else {

                nidx = page->index >> (PAGE_CACHE_SHIFT - tree->node_size_shift);

                i = 1 << (PAGE_CACHE_SHIFT - tree->node_size_shift);

                spin_lock(&tree->hash_lock);

                do {

                        node = __hfsplus_find_bnode(tree, nidx++);

                        if (!node)

                                continue;

                        if (atomic_read(&node->refcnt)) {

                                res = 0;

                                break;

                        }

                        __hfsplus_bnode_remove(node);

                        hfsplus_bnode_free(node);

                } while (--i);

                spin_unlock(&tree->hash_lock);

        }

        //printk("releasepage: %lu,%x = %d\n", page->index, mask, res);

        return res;

}

struct address_space_operations hfsplus_btree_aops = {

        .readpage       = hfsplus_readpage,

        .writepage      = hfsplus_writepage,

        .sync_page      = block_sync_page,

        .prepare_write  = hfsplus_prepare_write,

        .commit_write   = generic_commit_write,

        .bmap           = hfsplus_bmap,

        .releasepage    = hfsplus_releasepage,

};

struct address_space_operations hfsplus_aops = {

        .readpage       = hfsplus_readpage,

        .writepage      = hfsplus_writepage,

        .sync_page      = block_sync_page,

        .prepare_write  = hfsplus_prepare_write,

        .commit_write   = generic_commit_write,

        .bmap           = hfsplus_bmap,

};

static struct dentry *hfsplus_file_lookup(struct inode *dir, struct dentry *dentry)

{

        struct hfsplus_find_data fd;

        struct super_block *sb = dir->i_sb;

        struct inode *inode = NULL;

        int err;

        if (HFSPLUS_IS_RSRC(dir) || strcmp(dentry->d_name.name, "rsrc"))

                goto out;

        inode = HFSPLUS_I(dir).rsrc_inode;

        if (inode)

                goto out;

        inode = new_inode(sb);

        if (!inode)

                return ERR_PTR(-ENOMEM);

        inode->i_ino = dir->i_ino;

        HFSPLUS_I(inode).flags = HFSPLUS_FLG_RSRC;

        hfsplus_find_init(HFSPLUS_SB(sb).cat_tree, &fd);

        err = hfsplus_find_cat(sb, dir->i_ino, &fd);

        if (!err)

                err = hfsplus_cat_read_inode(inode, &fd);

        hfsplus_find_exit(&fd);

        if (err) {

                iput(inode);

                return ERR_PTR(err);

        }

        HFSPLUS_I(inode).rsrc_inode = dir;

        HFSPLUS_I(dir).rsrc_inode = inode;

        igrab(dir);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)

        list_add(&inode->i_hash, &HFSPLUS_SB(sb).rsrc_inodes);

#else

        hlist_add_head(&inode->i_hash, &HFSPLUS_SB(sb).rsrc_inodes);

#endif

        mark_inode_dirty(inode);

        {

        void hfsplus_inode_check(struct super_block *sb);

        atomic_inc(&HFSPLUS_SB(sb).inode_cnt);

        hfsplus_inode_check(sb);

        }

out:

        d_add(dentry, inode);

        return NULL;

}

static void hfsplus_get_perms(struct inode *inode, hfsplus_perm *perms, int dir)

{

        struct super_block *sb = inode->i_sb;

        int mode;

        mode = be32_to_cpu(perms->mode) & 0xffff;

        inode->i_uid = be32_to_cpu(perms->owner);

        if (!inode->i_uid && !mode)

                inode->i_uid = HFSPLUS_SB(sb).uid;

        inode->i_gid = be32_to_cpu(perms->group);

        if (!inode->i_gid && !mode)

                inode->i_gid = HFSPLUS_SB(sb).gid;

        if (dir) {

                mode = mode ? (mode & S_IALLUGO) :

                        (S_IRWXUGO & ~(HFSPLUS_SB(sb).umask));

                mode |= S_IFDIR;

        } else if (!mode)

                mode = S_IFREG | ((S_IRUGO|S_IWUGO) &

                        ~(HFSPLUS_SB(sb).umask));

        inode->i_mode = mode;

}

static void hfsplus_set_perms(struct inode *inode, hfsplus_perm *perms)

{

        perms->mode = cpu_to_be32(inode->i_mode);

        perms->owner = cpu_to_be32(inode->i_uid);

        perms->group = cpu_to_be32(inode->i_gid);

        perms->dev = cpu_to_be32(HFSPLUS_I(inode).dev);

}

static int hfsplus_file_open(struct inode *inode, struct file *file)

{

        if (HFSPLUS_IS_RSRC(inode))

                inode = HFSPLUS_I(inode).rsrc_inode;

        if (atomic_read(&file->f_count) != 1)

                return 0;

        atomic_inc(&HFSPLUS_I(inode).opencnt);

        return 0;

}

static int hfsplus_file_release(struct inode *inode, struct file *file)

{

        struct super_block *sb = inode->i_sb;

        if (HFSPLUS_IS_RSRC(inode))

                inode = HFSPLUS_I(inode).rsrc_inode;

        if (atomic_read(&file->f_count) != 0)

                return 0;

        if (atomic_dec_and_test(&HFSPLUS_I(inode).opencnt)) {

                down(&inode->i_sem);

                if (inode->i_flags & S_DEAD) {

                        hfsplus_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);

                        hfsplus_delete_inode(inode);

                }

                up(&inode->i_sem);

        }

        return 0;

}

extern struct inode_operations hfsplus_dir_inode_operations;

extern struct file_operations hfsplus_dir_operations;

struct inode_operations hfsplus_file_inode_operations = {

        .lookup         = hfsplus_file_lookup,

        .truncate       = hfsplus_truncate,

};

struct file_operations hfsplus_file_operations = {

        .llseek         = generic_file_llseek,

        .read           = generic_file_read,

        //.write        = hfsplus_file_write,

        .write          = generic_file_write,

        .mmap           = generic_file_mmap,

        .fsync          = file_fsync,

        .open           = hfsplus_file_open,

        .release        = hfsplus_file_release,

};

struct inode *hfsplus_new_inode(struct super_block *sb, int mode)

{

        struct inode *inode = new_inode(sb);

        if (!inode)

                return NULL;

        {

        void hfsplus_inode_check(struct super_block *sb);

        atomic_inc(&HFSPLUS_SB(sb).inode_cnt);

        hfsplus_inode_check(sb);

        }

        inode->i_ino = HFSPLUS_SB(sb).next_cnid++;

        inode->i_mode = mode;

        inode->i_uid = current->fsuid;

        inode->i_gid = current->fsgid;

        inode->i_nlink = 1;

        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;

        if (S_ISDIR(inode->i_mode)) {

                inode->i_size = 2;

                HFSPLUS_SB(sb).folder_count++;

                inode->i_op = &hfsplus_dir_inode_operations;

                inode->i_fop = &hfsplus_dir_operations;

                INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list);

        } else if (S_ISREG(inode->i_mode)) {

                HFSPLUS_SB(sb).file_count++;

                inode->i_op = &hfsplus_file_inode_operations;

                inode->i_fop = &hfsplus_file_operations;

                inode->i_mapping->a_ops = &hfsplus_aops;

        } else if (S_ISLNK(inode->i_mode)) {

                HFSPLUS_SB(sb).file_count++;

                inode->i_op = &page_symlink_inode_operations;

                inode->i_mapping->a_ops = &hfsplus_aops;

        } else

                HFSPLUS_SB(sb).file_count++;

        insert_inode_hash(inode);

        mark_inode_dirty(inode);

        sb->s_dirt = 1;

        return inode;

}

void hfsplus_delete_inode(struct inode *inode)

{

        struct super_block *sb = inode->i_sb;

        if (S_ISDIR(inode->i_mode)) {

                HFSPLUS_SB(sb).folder_count--;

                sb->s_dirt = 1;

                return;

        }

        HFSPLUS_SB(sb).file_count--;

        if (S_ISREG(inode->i_mode)) {

                if (!inode->i_nlink) {

                        inode->i_size = 0;

                        hfsplus_truncate(inode);

                }

        } else if (S_ISLNK(inode->i_mode)) {

                inode->i_size = 0;

                hfsplus_truncate(inode);

        }

        sb->s_dirt = 1;

}

void hfsplus_inode_read_fork(struct inode *inode, hfsplus_fork_raw *fork)

{

        u32 count;

        int i;

        memcpy(&HFSPLUS_I(inode).extents, &fork->extents,

               sizeof(hfsplus_extent_rec));

        for (count = 0, i = 0; i < 8; i++)

                count += be32_to_cpu(fork->extents[i].block_count);

        HFSPLUS_I(inode).extent_blocks = count;

        HFSPLUS_I(inode).total_blocks = HFSPLUS_I(inode).alloc_blocks =

                be32_to_cpu(fork->total_blocks);

        inode->i_size = HFSPLUS_I(inode).mmu_private = be64_to_cpu(fork->total_size);

        inode->i_blocks = be32_to_cpu(fork->total_blocks);

}

void hfsplus_inode_write_fork(struct inode *inode, hfsplus_fork_raw *fork)

{

        memcpy(&fork->extents, &HFSPLUS_I(inode).extents,

               sizeof(hfsplus_extent_rec));

        fork->total_size = cpu_to_be64(inode->i_size);

        fork->total_blocks = cpu_to_be32(HFSPLUS_I(inode).alloc_blocks);

}

int hfsplus_cat_read_inode(struct inode *inode, struct hfsplus_find_data *fd)

{

        hfsplus_cat_entry entry;

        int res = 0;

        u16 type;

        type = hfsplus_bnode_read_u16(fd->bnode, fd->entryoffset);

        HFSPLUS_I(inode).dev = 0;

        inode->i_blksize = PAGE_SIZE; /* Doesn't seem to be useful... */

        if (type == HFSPLUS_FOLDER) {

                hfsplus_cat_folder *folder = &entry.folder;

                if (fd->entrylength < sizeof(hfsplus_cat_folder))

                        /* panic? */;

                hfsplus_bnode_readbytes(fd->bnode, &entry, fd->entryoffset,

                                        sizeof(hfsplus_cat_folder));

                memset(&HFSPLUS_I(inode).extents, 0,

                       sizeof(hfsplus_extent_rec));

                hfsplus_get_perms(inode, &folder->permissions, 1);

                inode->i_nlink = 1;

                inode->i_size = 2 + be32_to_cpu(folder->valence);

                inode->i_atime = hfsp_mt2ut(folder->access_date);

                inode->i_mtime = hfsp_mt2ut(folder->content_mod_date);

                inode->i_ctime = inode->i_mtime;

                inode->i_blocks = 0;

                inode->i_op = &hfsplus_dir_inode_operations;

                inode->i_fop = &hfsplus_dir_operations;

                INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list);

        } else if (type == HFSPLUS_FILE) {

                hfsplus_cat_file *file = &entry.file;

                if (fd->entrylength < sizeof(hfsplus_cat_file))

                        /* panic? */;

                hfsplus_bnode_readbytes(fd->bnode, &entry, fd->entryoffset,

                                        sizeof(hfsplus_cat_file));

                hfsplus_inode_read_fork(inode, HFSPLUS_IS_DATA(inode) ?

                                        &file->data_fork : &file->rsrc_fork);

                hfsplus_get_perms(inode, &file->permissions, 0);

                inode->i_nlink = 1;

                if (S_ISREG(inode->i_mode)) {

                        if (file->permissions.dev)

                                inode->i_nlink = be32_to_cpu(file->permissions.dev);

                        inode->i_op = &hfsplus_file_inode_operations;

                        inode->i_fop = &hfsplus_file_operations;

                        inode->i_mapping->a_ops = &hfsplus_aops;

                } else if (S_ISLNK(inode->i_mode)) {

                        inode->i_op = &page_symlink_inode_operations;

                        inode->i_mapping->a_ops = &hfsplus_aops;

                } else {

                        init_special_inode(inode, inode->i_mode,

                                           be32_to_cpu(file->permissions.dev));

                }

                inode->i_atime = hfsp_mt2ut(file->access_date);

                inode->i_mtime = hfsp_mt2ut(file->content_mod_date);

                inode->i_ctime = inode->i_mtime;

        } else {

                printk("HFS+-fs: bad catalog entry used to create inode\n");

                res = -EIO;

        }

        return res;

}

void hfsplus_cat_write_inode(struct inode *inode)

{

        struct hfsplus_find_data fd;

        hfsplus_cat_entry entry;

        if (HFSPLUS_IS_RSRC(inode)) {

                mark_inode_dirty(HFSPLUS_I(inode).rsrc_inode);

                return;

        }

        if (!inode->i_nlink)

                return;

        if (hfsplus_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd))

                /* panic? */

                return;

        if (hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd))

                /* panic? */

                goto out;

        if (S_ISDIR(inode->i_mode)) {

                hfsplus_cat_folder *folder = &entry.folder;

                if (fd.entrylength < sizeof(hfsplus_cat_folder))

                        /* panic? */;

                hfsplus_bnode_readbytes(fd.bnode, &entry, fd.entryoffset,

                                        sizeof(hfsplus_cat_folder));

                /* simple node checks? */

                hfsplus_set_perms(inode, &folder->permissions);

                folder->access_date = hfsp_ut2mt(inode->i_atime);

                folder->content_mod_date = hfsp_ut2mt(inode->i_mtime);

                folder->attribute_mod_date = hfsp_ut2mt(inode->i_ctime);

                folder->valence = cpu_to_be32(inode->i_size - 2);

                hfsplus_bnode_writebytes(fd.bnode, &entry, fd.entryoffset,

                                         sizeof(hfsplus_cat_folder));

        } else {

                hfsplus_cat_file *file = &entry.file;

                if (fd.entrylength < sizeof(hfsplus_cat_file))

                        /* panic? */;

                hfsplus_bnode_readbytes(fd.bnode, &entry, fd.entryoffset,

                                        sizeof(hfsplus_cat_file));

                hfsplus_inode_write_fork(inode, &file->data_fork);

                if (HFSPLUS_I(inode).rsrc_inode)

                        hfsplus_inode_write_fork(HFSPLUS_I(inode).rsrc_inode, &file->rsrc_fork);

                if (S_ISREG(inode->i_mode))

                        HFSPLUS_I(inode).dev = inode->i_nlink;

                if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))

                        HFSPLUS_I(inode).dev = kdev_t_to_nr(inode->i_rdev);

                hfsplus_set_perms(inode, &file->permissions);

                file->access_date = hfsp_ut2mt(inode->i_atime);

                file->content_mod_date = hfsp_ut2mt(inode->i_mtime);

                file->attribute_mod_date = hfsp_ut2mt(inode->i_ctime);

                hfsplus_bnode_writebytes(fd.bnode, &entry, fd.entryoffset,

                                         sizeof(hfsplus_cat_file));

        }

out:

        hfsplus_find_exit(&fd);

}