152 lines
3.9 KiB
C
152 lines
3.9 KiB
C
/* fs/fat/nfs.c
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <linux/exportfs.h>
|
|
#include "fat.h"
|
|
|
|
/*
|
|
* a FAT file handle with fhtype 3 is
|
|
* 0/ i_ino - for fast, reliable lookup if still in the cache
|
|
* 1/ i_generation - to see if i_ino is still valid
|
|
* bit 0 == 0 iff directory
|
|
* 2/ i_pos(8-39) - if ino has changed, but still in cache
|
|
* 3/ i_pos(4-7)|i_logstart - to semi-verify inode found at i_pos
|
|
* 4/ i_pos(0-3)|parent->i_logstart - maybe used to hunt for the file on disc
|
|
*
|
|
* Hack for NFSv2: Maximum FAT entry number is 28bits and maximum
|
|
* i_pos is 40bits (blocknr(32) + dir offset(8)), so two 4bits
|
|
* of i_logstart is used to store the directory entry offset.
|
|
*/
|
|
|
|
int
|
|
fat_encode_fh(struct inode *inode, __u32 *fh, int *lenp, struct inode *parent)
|
|
{
|
|
int len = *lenp;
|
|
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
|
|
loff_t i_pos;
|
|
|
|
if (len < 5) {
|
|
*lenp = 5;
|
|
return 255; /* no room */
|
|
}
|
|
|
|
i_pos = fat_i_pos_read(sbi, inode);
|
|
*lenp = 5;
|
|
fh[0] = inode->i_ino;
|
|
fh[1] = inode->i_generation;
|
|
fh[2] = i_pos >> 8;
|
|
fh[3] = ((i_pos & 0xf0) << 24) | MSDOS_I(inode)->i_logstart;
|
|
fh[4] = (i_pos & 0x0f) << 28;
|
|
if (parent)
|
|
fh[4] |= MSDOS_I(parent)->i_logstart;
|
|
return 3;
|
|
}
|
|
|
|
static int fat_is_valid_fh(int fh_len, int fh_type)
|
|
{
|
|
return ((fh_len >= 5) && (fh_type == 3));
|
|
}
|
|
|
|
/**
|
|
* Map a NFS file handle to a corresponding dentry.
|
|
* The dentry may or may not be connected to the filesystem root.
|
|
*/
|
|
struct dentry *fat_fh_to_dentry(struct super_block *sb, struct fid *fid,
|
|
int fh_len, int fh_type)
|
|
{
|
|
struct inode *inode = NULL;
|
|
u32 *fh = fid->raw;
|
|
loff_t i_pos;
|
|
unsigned long i_ino;
|
|
__u32 i_generation;
|
|
int i_logstart;
|
|
|
|
if (!fat_is_valid_fh(fh_len, fh_type))
|
|
return NULL;
|
|
|
|
i_ino = fh[0];
|
|
i_generation = fh[1];
|
|
i_logstart = fh[3] & 0x0fffffff;
|
|
|
|
/* Try i_ino lookup first - fastest and most reliable */
|
|
inode = ilookup(sb, i_ino);
|
|
if (inode && (inode->i_generation != i_generation)) {
|
|
iput(inode);
|
|
inode = NULL;
|
|
}
|
|
if (!inode) {
|
|
i_pos = (loff_t)fh[2] << 8;
|
|
i_pos |= ((fh[3] >> 24) & 0xf0) | (fh[4] >> 28);
|
|
|
|
/* try 2 - see if i_pos is in F-d-c
|
|
* require i_logstart to be the same
|
|
* Will fail if you truncate and then re-write
|
|
*/
|
|
|
|
inode = fat_iget(sb, i_pos);
|
|
if (inode && MSDOS_I(inode)->i_logstart != i_logstart) {
|
|
iput(inode);
|
|
inode = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* For now, do nothing if the inode is not found.
|
|
*
|
|
* What we could do is:
|
|
*
|
|
* - follow the file starting at fh[4], and record the ".." entry,
|
|
* and the name of the fh[2] entry.
|
|
* - then follow the ".." file finding the next step up.
|
|
*
|
|
* This way we build a path to the root of the tree. If this works, we
|
|
* lookup the path and so get this inode into the cache. Finally try
|
|
* the fat_iget lookup again. If that fails, then we are totally out
|
|
* of luck. But all that is for another day
|
|
*/
|
|
return d_obtain_alias(inode);
|
|
}
|
|
|
|
/*
|
|
* Find the parent for a directory that is not currently connected to
|
|
* the filesystem root.
|
|
*
|
|
* On entry, the caller holds child_dir->d_inode->i_mutex.
|
|
*/
|
|
struct dentry *fat_get_parent(struct dentry *child_dir)
|
|
{
|
|
struct super_block *sb = child_dir->d_sb;
|
|
struct buffer_head *bh = NULL;
|
|
struct msdos_dir_entry *de;
|
|
loff_t i_pos;
|
|
struct dentry *parent;
|
|
struct inode *inode;
|
|
int err;
|
|
|
|
lock_super(sb);
|
|
|
|
err = fat_get_dotdot_entry(child_dir->d_inode, &bh, &de, &i_pos);
|
|
if (err) {
|
|
parent = ERR_PTR(err);
|
|
goto out;
|
|
}
|
|
inode = fat_build_inode(sb, de, i_pos);
|
|
|
|
parent = d_obtain_alias(inode);
|
|
out:
|
|
brelse(bh);
|
|
unlock_super(sb);
|
|
|
|
return parent;
|
|
}
|