X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=fs%2Fntfs%2Fnamei.c;h=eddb2247cec5897319eb719805e19e62295c008b;hb=97bf2856c6014879bd04983a3e9dfcdac1e7fe85;hp=6a62738119622f4b89e4960941189803a6183498;hpb=9213980e6a70d8473e0ffd4b39ab5b6caaba9ff5;p=linux-2.6.git diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c index 6a6273811..eddb2247c 100644 --- a/fs/ntfs/namei.c +++ b/fs/ntfs/namei.c @@ -2,7 +2,7 @@ * namei.c - NTFS kernel directory inode operations. Part of the Linux-NTFS * project. * - * Copyright (c) 2001-2004 Anton Altaparmakov + * Copyright (c) 2001-2006 Anton Altaparmakov * * This program/include file is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as published @@ -23,8 +23,11 @@ #include #include -#include "ntfs.h" +#include "attrib.h" +#include "debug.h" #include "dir.h" +#include "mft.h" +#include "ntfs.h" /** * ntfs_lookup - find the inode represented by a dentry in a directory inode @@ -92,6 +95,8 @@ * file name in the WIN32 namespace corresponding to the matched short file * name. We then convert the name to the current NLS code page, and proceed * searching for a dentry with this name, etc, as in case 2), above. + * + * Locking: Caller must hold i_mutex on the directory. */ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent, struct nameidata *nd) @@ -110,7 +115,9 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent, uname_len = ntfs_nlstoucs(vol, dent->d_name.name, dent->d_name.len, &uname); if (uname_len < 0) { - ntfs_error(vol->sb, "Failed to convert name to Unicode."); + if (uname_len != -ENAMETOOLONG) + ntfs_error(vol->sb, "Failed to convert name to " + "Unicode."); return ERR_PTR(uname_len); } mref = ntfs_lookup_inode_by_name(NTFS_I(dir_ino), uname, uname_len, @@ -122,15 +129,16 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent, dent_inode = ntfs_iget(vol->sb, dent_ino); if (likely(!IS_ERR(dent_inode))) { /* Consistency check. */ - if (MSEQNO(mref) == NTFS_I(dent_inode)->seq_no || + if (is_bad_inode(dent_inode) || MSEQNO(mref) == + NTFS_I(dent_inode)->seq_no || dent_ino == FILE_MFT) { /* Perfect WIN32/POSIX match. -- Case 1. */ if (!name) { - ntfs_debug("Done."); + ntfs_debug("Done. (Case 1.)"); return d_splice_alias(dent_inode, dent); } /* - * We are too indented. Handle imperfect + * We are too indented. Handle imperfect * matches and short file names further below. */ goto handle_name; @@ -147,12 +155,11 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent, ntfs_error(vol->sb, "ntfs_iget(0x%lx) failed with " "error code %li.", dent_ino, PTR_ERR(dent_inode)); - if (name) - kfree(name); + kfree(name); /* Return the error code. */ return (struct dentry *)dent_inode; } - /* It is guaranteed that name is no longer allocated at this point. */ + /* It is guaranteed that @name is no longer allocated at this point. */ if (MREF_ERR(mref) == -ENOENT) { ntfs_debug("Entry was not found, adding negative dentry."); /* The dcache will handle negative entries. */ @@ -163,19 +170,19 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent, ntfs_error(vol->sb, "ntfs_lookup_ino_by_name() failed with error " "code %i.", -MREF_ERR(mref)); return ERR_PTR(MREF_ERR(mref)); - // TODO: Consider moving this lot to a separate function! (AIA) handle_name: { struct dentry *real_dent, *new_dent; MFT_RECORD *m; - attr_search_context *ctx; + ntfs_attr_search_ctx *ctx; ntfs_inode *ni = NTFS_I(dent_inode); int err; struct qstr nls_name; nls_name.name = NULL; if (name->type != FILE_NAME_DOS) { /* Case 2. */ + ntfs_debug("Case 2."); nls_name.len = (unsigned)ntfs_ucstonls(vol, (ntfschar*)&name->name, name->len, (unsigned char**)&nls_name.name, 0); @@ -183,6 +190,7 @@ handle_name: } else /* if (name->type == FILE_NAME_DOS) */ { /* Case 3. */ FILE_NAME_ATTR *fn; + ntfs_debug("Case 3."); kfree(name); /* Find the WIN32 name corresponding to the matched DOS name. */ @@ -194,8 +202,8 @@ handle_name: ctx = NULL; goto err_out; } - ctx = get_attr_search_ctx(ni, m); - if (!ctx) { + ctx = ntfs_attr_get_search_ctx(ni, m); + if (unlikely(!ctx)) { err = -ENOMEM; goto err_out; } @@ -203,12 +211,14 @@ handle_name: ATTR_RECORD *a; u32 val_len; - if (!lookup_attr(AT_FILE_NAME, NULL, 0, 0, 0, NULL, 0, - ctx)) { + err = ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, 0, 0, + NULL, 0, ctx); + if (unlikely(err)) { ntfs_error(vol->sb, "Inode corrupt: No WIN32 " "namespace counterpart to DOS " "file name. Run chkdsk."); - err = -EIO; + if (err == -ENOENT) + err = -EIO; goto err_out; } /* Consistency checks. */ @@ -231,7 +241,7 @@ handle_name: (ntfschar*)&fn->file_name, fn->file_name_length, (unsigned char**)&nls_name.name, 0); - put_attr_search_ctx(ctx); + ntfs_attr_put_search_ctx(ctx); unmap_mft_record(ni); } m = NULL; @@ -245,7 +255,7 @@ handle_name: nls_name.hash = full_name_hash(nls_name.name, nls_name.len); /* - * Note: No need for dent->d_lock lock as i_sem is held on the + * Note: No need for dent->d_lock lock as i_mutex is held on the * parent inode. */ @@ -264,12 +274,17 @@ handle_name: dput(real_dent); else new_dent = real_dent; + ntfs_debug("Done. (Created new dentry.)"); return new_dent; } kfree(nls_name.name); /* Matching dentry exists, check if it is negative. */ if (real_dent->d_inode) { - BUG_ON(real_dent->d_inode != dent_inode); + if (unlikely(real_dent->d_inode != dent_inode)) { + /* This can happen because bad inodes are unhashed. */ + BUG_ON(!is_bad_inode(dent_inode)); + BUG_ON(!is_bad_inode(real_dent->d_inode)); + } /* * Already have the inode and the dentry attached, decrement * the reference count to balance the ntfs_iget() we did @@ -278,6 +293,7 @@ handle_name: * about any NFS/disconnectedness issues here. */ iput(dent_inode); + ntfs_debug("Done. (Already had inode and dentry.)"); return real_dent; } /* @@ -288,6 +304,7 @@ handle_name: if (!S_ISDIR(dent_inode->i_mode)) { /* Not a directory; everything is easy. */ d_instantiate(real_dent, dent_inode); + ntfs_debug("Done. (Already had negative file dentry.)"); return real_dent; } spin_lock(&dcache_lock); @@ -301,6 +318,7 @@ handle_name: real_dent->d_inode = dent_inode; spin_unlock(&dcache_lock); security_d_instantiate(real_dent, dent_inode); + ntfs_debug("Done. (Already had negative directory dentry.)"); return real_dent; } /* @@ -320,6 +338,8 @@ handle_name: /* Throw away real_dent. */ dput(real_dent); /* Use new_dent as the actual dentry. */ + ntfs_debug("Done. (Already had negative, disconnected directory " + "dentry.)"); return new_dent; eio_err_out: @@ -327,10 +347,11 @@ eio_err_out: err = -EIO; err_out: if (ctx) - put_attr_search_ctx(ctx); + ntfs_attr_put_search_ctx(ctx); if (m) unmap_mft_record(ni); iput(dent_inode); + ntfs_error(vol->sb, "Failed, returning error code %i.", err); return ERR_PTR(err); } } @@ -354,42 +375,46 @@ struct inode_operations ntfs_dir_inode_ops = { * The code is based on the ext3 ->get_parent() implementation found in * fs/ext3/namei.c::ext3_get_parent(). * - * Note: ntfs_get_parent() is called with @child_dent->d_inode->i_sem down. + * Note: ntfs_get_parent() is called with @child_dent->d_inode->i_mutex down. * * Return the dentry of the parent directory on success or the error code on * error (IS_ERR() is true). */ -struct dentry *ntfs_get_parent(struct dentry *child_dent) +static struct dentry *ntfs_get_parent(struct dentry *child_dent) { struct inode *vi = child_dent->d_inode; ntfs_inode *ni = NTFS_I(vi); MFT_RECORD *mrec; - attr_search_context *ctx; + ntfs_attr_search_ctx *ctx; ATTR_RECORD *attr; FILE_NAME_ATTR *fn; struct inode *parent_vi; struct dentry *parent_dent; unsigned long parent_ino; + int err; ntfs_debug("Entering for inode 0x%lx.", vi->i_ino); /* Get the mft record of the inode belonging to the child dentry. */ mrec = map_mft_record(ni); - if (unlikely(IS_ERR(mrec))) + if (IS_ERR(mrec)) return (struct dentry *)mrec; /* Find the first file name attribute in the mft record. */ - ctx = get_attr_search_ctx(ni, mrec); + ctx = ntfs_attr_get_search_ctx(ni, mrec); if (unlikely(!ctx)) { unmap_mft_record(ni); return ERR_PTR(-ENOMEM); } try_next: - if (unlikely(!lookup_attr(AT_FILE_NAME, NULL, 0, IGNORE_CASE, 0, - NULL, 0, ctx))) { - put_attr_search_ctx(ctx); + err = ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, CASE_SENSITIVE, 0, NULL, + 0, ctx); + if (unlikely(err)) { + ntfs_attr_put_search_ctx(ctx); unmap_mft_record(ni); - ntfs_error(vi->i_sb, "Inode 0x%lx does not have a file name " - "attribute. Run chkdsk.", vi->i_ino); - return ERR_PTR(-ENOENT); + if (err == -ENOENT) + ntfs_error(vi->i_sb, "Inode 0x%lx does not have a " + "file name attribute. Run chkdsk.", + vi->i_ino); + return ERR_PTR(err); } attr = ctx->attr; if (unlikely(attr->non_resident)) @@ -402,11 +427,11 @@ try_next: /* Get the inode number of the parent directory. */ parent_ino = MREF_LE(fn->parent_directory); /* Release the search context and the mft record of the child. */ - put_attr_search_ctx(ctx); + ntfs_attr_put_search_ctx(ctx); unmap_mft_record(ni); /* Get the inode of the parent directory. */ parent_vi = ntfs_iget(vi->i_sb, parent_ino); - if (unlikely(IS_ERR(parent_vi) || is_bad_inode(parent_vi))) { + if (IS_ERR(parent_vi) || unlikely(is_bad_inode(parent_vi))) { if (!IS_ERR(parent_vi)) iput(parent_vi); ntfs_error(vi->i_sb, "Failed to get parent directory inode " @@ -440,7 +465,7 @@ try_next: * * Return the dentry on success or the error code on error (IS_ERR() is true). */ -struct dentry *ntfs_get_dentry(struct super_block *sb, void *fh) +static struct dentry *ntfs_get_dentry(struct super_block *sb, void *fh) { struct inode *vi; struct dentry *dent; @@ -449,7 +474,7 @@ struct dentry *ntfs_get_dentry(struct super_block *sb, void *fh) ntfs_debug("Entering for inode 0x%lx, generation 0x%x.", ino, gen); vi = ntfs_iget(sb, ino); - if (unlikely(IS_ERR(vi))) { + if (IS_ERR(vi)) { ntfs_error(sb, "Failed to get inode 0x%lx.", ino); return (struct dentry *)vi; } @@ -471,3 +496,30 @@ struct dentry *ntfs_get_dentry(struct super_block *sb, void *fh) ntfs_debug("Done for inode 0x%lx, generation 0x%x.", ino, gen); return dent; } + +/** + * Export operations allowing NFS exporting of mounted NTFS partitions. + * + * We use the default ->decode_fh() and ->encode_fh() for now. Note that they + * use 32 bits to store the inode number which is an unsigned long so on 64-bit + * architectures is usually 64 bits so it would all fail horribly on huge + * volumes. I guess we need to define our own encode and decode fh functions + * that store 64-bit inode numbers at some point but for now we will ignore the + * problem... + * + * We also use the default ->get_name() helper (used by ->decode_fh() via + * fs/exportfs/expfs.c::find_exported_dentry()) as that is completely fs + * independent. + * + * The default ->get_parent() just returns -EACCES so we have to provide our + * own and the default ->get_dentry() is incompatible with NTFS due to not + * allowing the inode number 0 which is used in NTFS for the system file $MFT + * and due to using iget() whereas NTFS needs ntfs_iget(). + */ +struct export_operations ntfs_export_ops = { + .get_parent = ntfs_get_parent, /* Find the parent of a given + directory. */ + .get_dentry = ntfs_get_dentry, /* Find a dentry for the inode + given a file handle + sub-fragment. */ +};