Subversion Repositories or1k

/*

 * linux/fs/hfs/inode.c

 *

 * Copyright (C) 1995-1997  Paul H. Hargrove

 * This file may be distributed under the terms of the GNU General Public License.

 *

 * This file contains inode-related functions which do not depend on

 * which scheme is being used to represent forks.

 *

 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds

 *

 * "XXX" in a comment is a note to myself to consider changing something.

 *

 * In function preconditions the term "valid" applied to a pointer to

 * a structure means that the pointer is non-NULL and the structure it

 * points to has all fields initialized to consistent values.

 */

#include "hfs.h"

#include <linux/hfs_fs_sb.h>

#include <linux/hfs_fs_i.h>

#include <linux/hfs_fs.h>

#include <linux/smp_lock.h>

/*================ Variable-like macros ================*/

#define HFS_VALID_MODE_BITS  (S_IFREG | S_IFDIR | S_IRWXUGO)

/*================ File-local functions ================*/

/*

 * init_file_inode()

 *

 * Given an HFS catalog entry initialize an inode for a file.

 */

static void init_file_inode(struct inode *inode, hfs_u8 fork)

{

        struct hfs_fork *fk;

        struct hfs_cat_entry *entry = HFS_I(inode)->entry;

        if (fork == HFS_FK_DATA) {

                inode->i_mode = S_IRWXUGO | S_IFREG;

        } else {

                inode->i_mode = S_IRUGO | S_IWUGO | S_IFREG;

        }

        if (fork == HFS_FK_DATA) {

#if 0 /* XXX: disable crlf translations for now */

                hfs_u32 type = hfs_get_nl(entry->info.file.finfo.fdType);

                HFS_I(inode)->convert =

                        ((HFS_SB(inode->i_sb)->s_conv == 't') ||

                         ((HFS_SB(inode->i_sb)->s_conv == 'a') &&

                          ((type == htonl(0x54455854)) ||   /* "TEXT" */

                           (type == htonl(0x7474726f)))));  /* "ttro" */

#else

                HFS_I(inode)->convert = 0;

#endif

                fk = &entry->u.file.data_fork;

        } else {

                fk = &entry->u.file.rsrc_fork;

                HFS_I(inode)->convert = 0;

        }

        HFS_I(inode)->fork = fk;

        inode->i_size = fk->lsize;

        inode->i_blocks = fk->psize;

        inode->i_nlink = 1;

}

/*================ Global functions ================*/

/*

 * hfs_put_inode()

 *

 * This is the put_inode() entry in the super_operations for HFS

 * filesystems.  The purpose is to perform any filesystem-dependent

 * cleanup necessary when the use-count of an inode falls to zero.

 */

void hfs_put_inode(struct inode * inode)

{

        struct hfs_cat_entry *entry = HFS_I(inode)->entry;

        lock_kernel();

        hfs_cat_put(entry);

        if (atomic_read(&inode->i_count) == 1) {

          struct hfs_hdr_layout *tmp = HFS_I(inode)->layout;

          if (tmp) {

                HFS_I(inode)->layout = NULL;

                HFS_DELETE(tmp);

          }

        }

        unlock_kernel();

}

/*

 * hfs_notify_change()

 *

 * Based very closely on fs/msdos/inode.c by Werner Almesberger

 *

 * This is the notify_change() field in the super_operations structure

 * for HFS file systems.  The purpose is to take that changes made to

 * an inode and apply then in a filesystem-dependent manner.  In this

 * case the process has a few of tasks to do:

 *  1) prevent changes to the i_uid and i_gid fields.

 *  2) map file permissions to the closest allowable permissions

 *  3) Since multiple Linux files can share the same on-disk inode under

 *     HFS (for instance the data and resource forks of a file) a change

 *     to permissions must be applied to all other in-core inodes which

 *     correspond to the same HFS file.

 */

enum {HFS_NORM, HFS_HDR, HFS_CAP};

static int __hfs_notify_change(struct dentry *dentry, struct iattr * attr, int kind)

{

        struct inode *inode = dentry->d_inode;

        struct hfs_cat_entry *entry = HFS_I(inode)->entry;

        struct dentry **de = entry->sys_entry;

        struct hfs_sb_info *hsb = HFS_SB(inode->i_sb);

        int error, i;

        error = inode_change_ok(inode, attr); /* basic permission checks */

        if (error) {

                /* Let netatalk's afpd think chmod() always succeeds */

                if (hsb->s_afpd &&

                    (attr->ia_valid == (ATTR_MODE | ATTR_CTIME))) {

                        return 0;

                } else {

                        return error;

                }

        }

        /* no uig/gid changes and limit which mode bits can be set */

        if (((attr->ia_valid & ATTR_UID) &&

             (attr->ia_uid != hsb->s_uid)) ||

            ((attr->ia_valid & ATTR_GID) &&

             (attr->ia_gid != hsb->s_gid)) ||

            ((attr->ia_valid & ATTR_MODE) &&

             (((entry->type == HFS_CDR_DIR) &&

               (attr->ia_mode != inode->i_mode))||

              (attr->ia_mode & ~HFS_VALID_MODE_BITS)))) {

                return hsb->s_quiet ? 0 : error;

        }

        if (entry->type == HFS_CDR_DIR) {

                attr->ia_valid &= ~ATTR_MODE;

        } else if (attr->ia_valid & ATTR_MODE) {

                /* Only the 'w' bits can ever change and only all together. */

                if (attr->ia_mode & S_IWUSR) {

                        attr->ia_mode = inode->i_mode | S_IWUGO;

                } else {

                        attr->ia_mode = inode->i_mode & ~S_IWUGO;

                }

                attr->ia_mode &= ~hsb->s_umask;

        }

        /*

         * Normal files handle size change in normal way.

         * Oddballs are served here.

         */

        if (attr->ia_valid & ATTR_SIZE) {

                if (kind == HFS_CAP) {

                        inode->i_size = attr->ia_size;

                        if (inode->i_size > HFS_FORK_MAX)

                                inode->i_size = HFS_FORK_MAX;

                        mark_inode_dirty(inode);

                        attr->ia_valid &= ~ATTR_SIZE;

                } else if (kind == HFS_HDR) {

                        hdr_truncate(inode, attr->ia_size);

                        attr->ia_valid &= ~ATTR_SIZE;

                }

        }

        error = inode_setattr(inode, attr);

        if (error)

                return error;

        /* We wouldn't want to mess with the sizes of the other fork */

        attr->ia_valid &= ~ATTR_SIZE;

        /* We must change all in-core inodes corresponding to this file. */

        for (i = 0; i < 4; ++i) {

          if (de[i] && (de[i] != dentry)) {

                inode_setattr(de[i]->d_inode, attr);

          }

        }

        /* Change the catalog entry if needed */

        if (attr->ia_valid & ATTR_MTIME) {

                entry->modify_date = hfs_u_to_mtime(inode->i_mtime);

                hfs_cat_mark_dirty(entry);

        }

        if (attr->ia_valid & ATTR_MODE) {

                hfs_u8 new_flags;

                if (inode->i_mode & S_IWUSR) {

                        new_flags = entry->u.file.flags & ~HFS_FIL_LOCK;

                } else {

                        new_flags = entry->u.file.flags | HFS_FIL_LOCK;

                }

                if (new_flags != entry->u.file.flags) {

                        entry->u.file.flags = new_flags;

                        hfs_cat_mark_dirty(entry);

                }

        }

        /* size changes handled in hfs_extent_adj() */

        return 0;

}

int hfs_notify_change(struct dentry *dentry, struct iattr * attr)

{

        return __hfs_notify_change(dentry, attr, HFS_NORM);

}

int hfs_notify_change_cap(struct dentry *dentry, struct iattr * attr)

{

        return __hfs_notify_change(dentry, attr, HFS_CAP);

}

int hfs_notify_change_hdr(struct dentry *dentry, struct iattr * attr)

{

        return __hfs_notify_change(dentry, attr, HFS_HDR);

}

static int hfs_writepage(struct page *page)

{

        return block_write_full_page(page,hfs_get_block);

}

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

{

        return block_read_full_page(page,hfs_get_block);

}

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

{

        return cont_prepare_write(page,from,to,hfs_get_block,

                &page->mapping->host->u.hfs_i.mmu_private);

}

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

{

        return generic_block_bmap(mapping,block,hfs_get_block);

}

struct address_space_operations hfs_aops = {

        readpage: hfs_readpage,

        writepage: hfs_writepage,

        sync_page: block_sync_page,

        prepare_write: hfs_prepare_write,

        commit_write: generic_commit_write,

        bmap: hfs_bmap

};

/*

 * __hfs_iget()

 *

 * Given the MDB for a HFS filesystem, a 'key' and an 'entry' in

 * the catalog B-tree and the 'type' of the desired file return the

 * inode for that file/directory or NULL.  Note that 'type' indicates

 * whether we want the actual file or directory, or the corresponding

 * metadata (AppleDouble header file or CAP metadata file).

 *

 * In an ideal world we could call iget() and would not need this

 * function.  However, since there is no way to even know the inode

 * number until we've found the file/directory in the catalog B-tree

 * that simply won't happen.

 *

 * The main idea here is to look in the catalog B-tree to get the

 * vital info about the file or directory (including the file id which

 * becomes the inode number) and then to call iget() and return the

 * inode if it is complete.  If it is not then we use the catalog

 * entry to fill in the missing info, by calling the appropriate

 * 'fillin' function.  Note that these fillin functions are

 * essentially hfs_*_read_inode() functions, but since there is no way

 * to pass the catalog entry through iget() to such a read_inode()

 * function, we have to call them after iget() returns an incomplete

 * inode to us.  This is pretty much the same problem faced in the NFS

 * code, and pretty much the same solution. The SMB filesystem deals

 * with this in a different way: by using the address of the

 * kmalloc()'d space which holds the data as the inode number.

 *

 * XXX: Both this function and NFS's corresponding nfs_fhget() would

 * benefit from a way to pass an additional (void *) through iget() to

 * the VFS read_inode() function.

 *

 * this will hfs_cat_put() the entry if it fails.

 */

struct inode *hfs_iget(struct hfs_cat_entry *entry, ino_t type,

                       struct dentry *dentry)

{

        struct dentry **sys_entry;

        struct super_block *sb;

        struct inode *inode;

        if (!entry) {

                return NULL;

        }

        /* If there are several processes all calling __iget() for

           the same inode then they will all get the same one back.

           The first one to return from __iget() will notice that the

           i_mode field of the inode is blank and KNOW that it is

           the first to return.  Therefore, it will set the appropriate

           'sys_entry' field in the entry and initialize the inode.

           All the initialization must be done without sleeping,

           or else other processes could end up using a partially

           initialized inode.                           */

        sb = entry->mdb->sys_mdb;

        sys_entry = &entry->sys_entry[HFS_ITYPE_TO_INT(type)];

        if (!(inode = iget(sb, ntohl(entry->cnid) | type))) {

                hfs_cat_put(entry);

                return NULL;

        }

        if (inode->i_dev != sb->s_dev) {

                iput(inode); /* automatically does an hfs_cat_put */

                inode = NULL;

        } else if (!inode->i_mode || (*sys_entry == NULL)) {

                /* Initialize the inode */

                struct hfs_sb_info *hsb = HFS_SB(sb);

                inode->i_rdev = 0;

                inode->i_ctime = inode->i_atime = inode->i_mtime =

                                        hfs_m_to_utime(entry->modify_date);

                inode->i_blksize = HFS_SECTOR_SIZE;

                inode->i_uid = hsb->s_uid;

                inode->i_gid = hsb->s_gid;

                memset(HFS_I(inode), 0, sizeof(struct hfs_inode_info));

                HFS_I(inode)->magic = HFS_INO_MAGIC;

                HFS_I(inode)->entry = entry;

                HFS_I(inode)->tz_secondswest = hfs_to_utc(0);

                hsb->s_ifill(inode, type, hsb->s_version);

                if (!hsb->s_afpd && (entry->type == HFS_CDR_FIL) &&

                    (entry->u.file.flags & HFS_FIL_LOCK)) {

                        inode->i_mode &= ~S_IWUGO;

                }

                inode->i_mode &= ~hsb->s_umask;

                if (!inode->i_mode) {

                        iput(inode); /* does an hfs_cat_put */

                        inode = NULL;

                } else

                        *sys_entry = dentry; /* cache dentry */

        }

        return inode;

}

/*================ Scheme-specific functions ================*/

/*

 * hfs_cap_ifill()

 *

 * This function serves the same purpose as a read_inode() function does

 * in other filesystems.  It is called by __hfs_iget() to fill in

 * the missing fields of an uninitialized inode under the CAP scheme.

 */

void hfs_cap_ifill(struct inode * inode, ino_t type, const int version)

{

        struct hfs_cat_entry *entry = HFS_I(inode)->entry;

        HFS_I(inode)->d_drop_op = hfs_cap_drop_dentry;

        if (type == HFS_CAP_FNDR) {

                inode->i_size = sizeof(struct hfs_cap_info);

                inode->i_blocks = 0;

                inode->i_nlink = 1;

                inode->i_mode = S_IRUGO | S_IWUGO | S_IFREG;

                inode->i_op = &hfs_cap_info_inode_operations;

                inode->i_fop = &hfs_cap_info_operations;

        } else if (entry->type == HFS_CDR_FIL) {

                init_file_inode(inode, (type == HFS_CAP_DATA) ?

                                                HFS_FK_DATA : HFS_FK_RSRC);

                inode->i_op = &hfs_file_inode_operations;

                inode->i_fop = &hfs_file_operations;

                inode->i_mapping->a_ops = &hfs_aops;

                inode->u.hfs_i.mmu_private = inode->i_size;

        } else { /* Directory */

                struct hfs_dir *hdir = &entry->u.dir;

                inode->i_blocks = 0;

                inode->i_size = hdir->files + hdir->dirs + 5;

                HFS_I(inode)->dir_size = 1;

                if (type == HFS_CAP_NDIR) {

                        inode->i_mode = S_IRWXUGO | S_IFDIR;

                        inode->i_nlink = hdir->dirs + 4;

                        inode->i_op = &hfs_cap_ndir_inode_operations;

                        inode->i_fop = &hfs_cap_dir_operations;

                        HFS_I(inode)->file_type = HFS_CAP_NORM;

                } else if (type == HFS_CAP_FDIR) {

                        inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;

                        inode->i_nlink = 2;

                        inode->i_op = &hfs_cap_fdir_inode_operations;

                        inode->i_fop = &hfs_cap_dir_operations;

                        HFS_I(inode)->file_type = HFS_CAP_FNDR;

                } else if (type == HFS_CAP_RDIR) {

                        inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;

                        inode->i_nlink = 2;

                        inode->i_op = &hfs_cap_rdir_inode_operations;

                        inode->i_fop = &hfs_cap_dir_operations;

                        HFS_I(inode)->file_type = HFS_CAP_RSRC;

                }

        }

}

/*

 * hfs_dbl_ifill()

 *

 * This function serves the same purpose as a read_inode() function does

 * in other filesystems.  It is called by __hfs_iget() to fill in

 * the missing fields of an uninitialized inode under the AppleDouble

 * scheme.

 */

void hfs_dbl_ifill(struct inode * inode, ino_t type, const int version)

{

        struct hfs_cat_entry *entry = HFS_I(inode)->entry;

        HFS_I(inode)->d_drop_op = hfs_dbl_drop_dentry;

        if (type == HFS_DBL_HDR) {

                if (entry->type == HFS_CDR_FIL) {

                        init_file_inode(inode, HFS_FK_RSRC);

                        inode->i_size += HFS_DBL_HDR_LEN;

                        HFS_I(inode)->default_layout = &hfs_dbl_fil_hdr_layout;

                } else {

                        inode->i_size = HFS_DBL_HDR_LEN;

                        inode->i_mode = S_IRUGO | S_IWUGO | S_IFREG;

                        inode->i_nlink = 1;

                        HFS_I(inode)->default_layout = &hfs_dbl_dir_hdr_layout;

                }

                inode->i_op = &hfs_hdr_inode_operations;

                inode->i_fop = &hfs_hdr_operations;

        } else if (entry->type == HFS_CDR_FIL) {

                init_file_inode(inode, HFS_FK_DATA);

                inode->i_op = &hfs_file_inode_operations;

                inode->i_fop = &hfs_file_operations;

                inode->i_mapping->a_ops = &hfs_aops;

                inode->u.hfs_i.mmu_private = inode->i_size;

        } else { /* Directory */

                struct hfs_dir *hdir = &entry->u.dir;

                inode->i_blocks = 0;

                inode->i_nlink = hdir->dirs + 2;

                inode->i_size = 3 + 2 * (hdir->dirs + hdir->files);

                inode->i_mode = S_IRWXUGO | S_IFDIR;

                inode->i_op = &hfs_dbl_dir_inode_operations;

                inode->i_fop = &hfs_dbl_dir_operations;

                HFS_I(inode)->file_type = HFS_DBL_NORM;

                HFS_I(inode)->dir_size = 2;

        }

}

/*

 * hfs_nat_ifill()

 *

 * This function serves the same purpose as a read_inode() function does

 * in other filesystems.  It is called by __hfs_iget() to fill in

 * the missing fields of an uninitialized inode under the Netatalk

 * scheme.

 */

void hfs_nat_ifill(struct inode * inode, ino_t type, const int version)

{

        struct hfs_cat_entry *entry = HFS_I(inode)->entry;

        HFS_I(inode)->d_drop_op = hfs_nat_drop_dentry;

        if (type == HFS_NAT_HDR) {

                if (entry->type == HFS_CDR_FIL) {

                        init_file_inode(inode, HFS_FK_RSRC);

                        inode->i_size += HFS_NAT_HDR_LEN;

                } else {

                        inode->i_size = HFS_NAT_HDR_LEN;

                        inode->i_mode = S_IRUGO | S_IWUGO | S_IFREG;

                        inode->i_nlink = 1;

                }

                inode->i_op = &hfs_hdr_inode_operations;

                inode->i_fop = &hfs_hdr_operations;

                HFS_I(inode)->default_layout = (version == 2) ?

                        &hfs_nat2_hdr_layout : &hfs_nat_hdr_layout;

        } else if (entry->type == HFS_CDR_FIL) {

                init_file_inode(inode, HFS_FK_DATA);

                inode->i_op = &hfs_file_inode_operations;

                inode->i_fop = &hfs_file_operations;

                inode->i_mapping->a_ops = &hfs_aops;

                inode->u.hfs_i.mmu_private = inode->i_size;

        } else { /* Directory */

                struct hfs_dir *hdir = &entry->u.dir;

                inode->i_blocks = 0;

                inode->i_size = hdir->files + hdir->dirs + 4;

                inode->i_mode = S_IRWXUGO | S_IFDIR;

                HFS_I(inode)->dir_size = 1;

                if (type == HFS_NAT_NDIR) {

                        inode->i_nlink = hdir->dirs + 3;

                        inode->i_op = &hfs_nat_ndir_inode_operations;

                        HFS_I(inode)->file_type = HFS_NAT_NORM;

                } else if (type == HFS_NAT_HDIR) {

                        inode->i_nlink = 2;

                        inode->i_op = &hfs_nat_hdir_inode_operations;

                        HFS_I(inode)->file_type = HFS_NAT_HDR;

                }

                inode->i_fop = &hfs_nat_dir_operations;

        }

}