linux/fs/fat/nfs.c
<<
>>
Prefs
   1/* fs/fat/nfs.c
   2 *
   3 * This software is licensed under the terms of the GNU General Public
   4 * License version 2, as published by the Free Software Foundation, and
   5 * may be copied, distributed, and modified under those terms.
   6 *
   7 * This program is distributed in the hope that it will be useful,
   8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 * GNU General Public License for more details.
  11 *
  12 */
  13
  14#include <linux/exportfs.h>
  15#include "fat.h"
  16
  17struct fat_fid {
  18        u32 i_gen;
  19        u32 i_pos_low;
  20        u16 i_pos_hi;
  21        u16 parent_i_pos_hi;
  22        u32 parent_i_pos_low;
  23        u32 parent_i_gen;
  24};
  25
  26#define FAT_FID_SIZE_WITHOUT_PARENT 3
  27#define FAT_FID_SIZE_WITH_PARENT (sizeof(struct fat_fid)/sizeof(u32))
  28
  29/**
  30 * Look up a directory inode given its starting cluster.
  31 */
  32static struct inode *fat_dget(struct super_block *sb, int i_logstart)
  33{
  34        struct msdos_sb_info *sbi = MSDOS_SB(sb);
  35        struct hlist_head *head;
  36        struct msdos_inode_info *i;
  37        struct inode *inode = NULL;
  38
  39        head = sbi->dir_hashtable + fat_dir_hash(i_logstart);
  40        spin_lock(&sbi->dir_hash_lock);
  41        hlist_for_each_entry(i, head, i_dir_hash) {
  42                BUG_ON(i->vfs_inode.i_sb != sb);
  43                if (i->i_logstart != i_logstart)
  44                        continue;
  45                inode = igrab(&i->vfs_inode);
  46                if (inode)
  47                        break;
  48        }
  49        spin_unlock(&sbi->dir_hash_lock);
  50        return inode;
  51}
  52
  53static struct inode *fat_ilookup(struct super_block *sb, u64 ino, loff_t i_pos)
  54{
  55        if (MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO)
  56                return fat_iget(sb, i_pos);
  57
  58        else {
  59                if ((ino < MSDOS_ROOT_INO) || (ino == MSDOS_FSINFO_INO))
  60                        return NULL;
  61                return ilookup(sb, ino);
  62        }
  63}
  64
  65static struct inode *__fat_nfs_get_inode(struct super_block *sb,
  66                                       u64 ino, u32 generation, loff_t i_pos)
  67{
  68        struct inode *inode = fat_ilookup(sb, ino, i_pos);
  69
  70        if (inode && generation && (inode->i_generation != generation)) {
  71                iput(inode);
  72                inode = NULL;
  73        }
  74        if (inode == NULL && MSDOS_SB(sb)->options.nfs == FAT_NFS_NOSTALE_RO) {
  75                struct buffer_head *bh = NULL;
  76                struct msdos_dir_entry *de ;
  77                sector_t blocknr;
  78                int offset;
  79                fat_get_blknr_offset(MSDOS_SB(sb), i_pos, &blocknr, &offset);
  80                bh = sb_bread(sb, blocknr);
  81                if (!bh) {
  82                        fat_msg(sb, KERN_ERR,
  83                                "unable to read block(%llu) for building NFS inode",
  84                                (llu)blocknr);
  85                        return inode;
  86                }
  87                de = (struct msdos_dir_entry *)bh->b_data;
  88                /* If a file is deleted on server and client is not updated
  89                 * yet, we must not build the inode upon a lookup call.
  90                 */
  91                if (IS_FREE(de[offset].name))
  92                        inode = NULL;
  93                else
  94                        inode = fat_build_inode(sb, &de[offset], i_pos);
  95                brelse(bh);
  96        }
  97
  98        return inode;
  99}
 100
 101static struct inode *fat_nfs_get_inode(struct super_block *sb,
 102                                       u64 ino, u32 generation)
 103{
 104
 105        return __fat_nfs_get_inode(sb, ino, generation, 0);
 106}
 107
 108static int
 109fat_encode_fh_nostale(struct inode *inode, __u32 *fh, int *lenp,
 110                      struct inode *parent)
 111{
 112        int len = *lenp;
 113        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
 114        struct fat_fid *fid = (struct fat_fid *) fh;
 115        loff_t i_pos;
 116        int type = FILEID_FAT_WITHOUT_PARENT;
 117
 118        if (parent) {
 119                if (len < FAT_FID_SIZE_WITH_PARENT) {
 120                        *lenp = FAT_FID_SIZE_WITH_PARENT;
 121                        return FILEID_INVALID;
 122                }
 123        } else {
 124                if (len < FAT_FID_SIZE_WITHOUT_PARENT) {
 125                        *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
 126                        return FILEID_INVALID;
 127                }
 128        }
 129
 130        i_pos = fat_i_pos_read(sbi, inode);
 131        *lenp = FAT_FID_SIZE_WITHOUT_PARENT;
 132        fid->i_gen = inode->i_generation;
 133        fid->i_pos_low = i_pos & 0xFFFFFFFF;
 134        fid->i_pos_hi = (i_pos >> 32) & 0xFFFF;
 135        if (parent) {
 136                i_pos = fat_i_pos_read(sbi, parent);
 137                fid->parent_i_pos_hi = (i_pos >> 32) & 0xFFFF;
 138                fid->parent_i_pos_low = i_pos & 0xFFFFFFFF;
 139                fid->parent_i_gen = parent->i_generation;
 140                type = FILEID_FAT_WITH_PARENT;
 141                *lenp = FAT_FID_SIZE_WITH_PARENT;
 142        }
 143
 144        return type;
 145}
 146
 147/**
 148 * Map a NFS file handle to a corresponding dentry.
 149 * The dentry may or may not be connected to the filesystem root.
 150 */
 151static struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
 152                                int fh_len, int fh_type)
 153{
 154        return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
 155                                    fat_nfs_get_inode);
 156}
 157
 158static struct dentry *fat_fh_to_dentry_nostale(struct super_block *sb,
 159                                               struct fid *fh, int fh_len,
 160                                               int fh_type)
 161{
 162        struct inode *inode = NULL;
 163        struct fat_fid *fid = (struct fat_fid *)fh;
 164        loff_t i_pos;
 165
 166        switch (fh_type) {
 167        case FILEID_FAT_WITHOUT_PARENT:
 168                if (fh_len < FAT_FID_SIZE_WITHOUT_PARENT)
 169                        return NULL;
 170                break;
 171        case FILEID_FAT_WITH_PARENT:
 172                if (fh_len < FAT_FID_SIZE_WITH_PARENT)
 173                        return NULL;
 174                break;
 175        default:
 176                return NULL;
 177        }
 178        i_pos = fid->i_pos_hi;
 179        i_pos = (i_pos << 32) | (fid->i_pos_low);
 180        inode = __fat_nfs_get_inode(sb, 0, fid->i_gen, i_pos);
 181
 182        return d_obtain_alias(inode);
 183}
 184
 185/*
 186 * Find the parent for a file specified by NFS handle.
 187 * This requires that the handle contain the i_ino of the parent.
 188 */
 189static struct dentry *fat_fh_to_parent(struct super_block *sb, struct fid *fid,
 190                                int fh_len, int fh_type)
 191{
 192        return generic_fh_to_parent(sb, fid, fh_len, fh_type,
 193                                    fat_nfs_get_inode);
 194}
 195
 196static struct dentry *fat_fh_to_parent_nostale(struct super_block *sb,
 197                                               struct fid *fh, int fh_len,
 198                                               int fh_type)
 199{
 200        struct inode *inode = NULL;
 201        struct fat_fid *fid = (struct fat_fid *)fh;
 202        loff_t i_pos;
 203
 204        if (fh_len < FAT_FID_SIZE_WITH_PARENT)
 205                return NULL;
 206
 207        switch (fh_type) {
 208        case FILEID_FAT_WITH_PARENT:
 209                i_pos = fid->parent_i_pos_hi;
 210                i_pos = (i_pos << 32) | (fid->parent_i_pos_low);
 211                inode = __fat_nfs_get_inode(sb, 0, fid->parent_i_gen, i_pos);
 212                break;
 213        }
 214
 215        return d_obtain_alias(inode);
 216}
 217
 218/*
 219 * Rebuild the parent for a directory that is not connected
 220 *  to the filesystem root
 221 */
 222static
 223struct inode *fat_rebuild_parent(struct super_block *sb, int parent_logstart)
 224{
 225        int search_clus, clus_to_match;
 226        struct msdos_dir_entry *de;
 227        struct inode *parent = NULL;
 228        struct inode *dummy_grand_parent = NULL;
 229        struct fat_slot_info sinfo;
 230        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 231        sector_t blknr = fat_clus_to_blknr(sbi, parent_logstart);
 232        struct buffer_head *parent_bh = sb_bread(sb, blknr);
 233        if (!parent_bh) {
 234                fat_msg(sb, KERN_ERR,
 235                        "unable to read cluster of parent directory");
 236                return NULL;
 237        }
 238
 239        de = (struct msdos_dir_entry *) parent_bh->b_data;
 240        clus_to_match = fat_get_start(sbi, &de[0]);
 241        search_clus = fat_get_start(sbi, &de[1]);
 242
 243        dummy_grand_parent = fat_dget(sb, search_clus);
 244        if (!dummy_grand_parent) {
 245                dummy_grand_parent = new_inode(sb);
 246                if (!dummy_grand_parent) {
 247                        brelse(parent_bh);
 248                        return parent;
 249                }
 250
 251                dummy_grand_parent->i_ino = iunique(sb, MSDOS_ROOT_INO);
 252                fat_fill_inode(dummy_grand_parent, &de[1]);
 253                MSDOS_I(dummy_grand_parent)->i_pos = -1;
 254        }
 255
 256        if (!fat_scan_logstart(dummy_grand_parent, clus_to_match, &sinfo))
 257                parent = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
 258
 259        brelse(parent_bh);
 260        iput(dummy_grand_parent);
 261
 262        return parent;
 263}
 264
 265/*
 266 * Find the parent for a directory that is not currently connected to
 267 * the filesystem root.
 268 *
 269 * On entry, the caller holds child_dir->d_inode->i_mutex.
 270 */
 271static struct dentry *fat_get_parent(struct dentry *child_dir)
 272{
 273        struct super_block *sb = child_dir->d_sb;
 274        struct buffer_head *bh = NULL;
 275        struct msdos_dir_entry *de;
 276        struct inode *parent_inode = NULL;
 277        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 278
 279        if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) {
 280                int parent_logstart = fat_get_start(sbi, de);
 281                parent_inode = fat_dget(sb, parent_logstart);
 282                if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)
 283                        parent_inode = fat_rebuild_parent(sb, parent_logstart);
 284        }
 285        brelse(bh);
 286
 287        return d_obtain_alias(parent_inode);
 288}
 289
 290const struct export_operations fat_export_ops = {
 291        .fh_to_dentry   = fat_fh_to_dentry,
 292        .fh_to_parent   = fat_fh_to_parent,
 293        .get_parent     = fat_get_parent,
 294};
 295
 296const struct export_operations fat_export_ops_nostale = {
 297        .encode_fh      = fat_encode_fh_nostale,
 298        .fh_to_dentry   = fat_fh_to_dentry_nostale,
 299        .fh_to_parent   = fat_fh_to_parent_nostale,
 300        .get_parent     = fat_get_parent,
 301};
 302
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.