Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 407938e79edcadba1b5a17cf928584d8a191a8d7

Authored by Al Viro 2011-06-26 09:37:18 +0800

Exists in master and in 6 other branches

LOOKUP_CREATE and LOOKUP_RENAME_TARGET can be set only on the last step

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 3 changed files with 6 additions and 12 deletions Inline Diff

fs/cifs/dir.c
fs/fat/namei_vfat.c
fs/jfs/namei.c

fs/cifs/dir.c

Diff comments View file @ 407938e

 /*
  *   fs/cifs/dir.c
  *
  *   vfs operations that deal with dentries
  *
  *   Copyright (C) International Business Machines  Corp., 2002,2009
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   This library is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Lesser General Public License as published
  *   by the Free Software Foundation; either version 2.1 of the License, or
  *   (at your option) any later version.
  *
  *   This library 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 Lesser General Public License for more details.
  *
  *   You should have received a copy of the GNU Lesser General Public License
  *   along with this library; if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 #include <linux/fs.h>
 #include <linux/stat.h>
 #include <linux/slab.h>
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/file.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
 #include "cifsglob.h"
 #include "cifsproto.h"
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
 static void
 renew_parental_timestamps(struct dentry *direntry)
 {
 	/* BB check if there is a way to get the kernel to do this or if we
 	   really need this */
 	do {
 		direntry->d_time = jiffies;
 		direntry = direntry->d_parent;
 	} while (!IS_ROOT(direntry));
 }
 /* Note: caller must free return buffer */
 char *
 build_path_from_dentry(struct dentry *direntry)
 {
 	struct dentry *temp;
 	int namelen;
 	int dfsplen;
 	char *full_path;
 	char dirsep;
 	struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 	unsigned seq;
 	if (direntry == NULL)
 		return NULL;  /* not much we can do if dentry is freed and
 		we need to reopen the file after it was closed implicitly
 		when the server crashed */
 	dirsep = CIFS_DIR_SEP(cifs_sb);
 	if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
 		dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
 	else
 		dfsplen = 0;
 cifs_bp_rename_retry:
 	namelen = dfsplen;
 	seq = read_seqbegin(&rename_lock);
 	rcu_read_lock();
 	for (temp = direntry; !IS_ROOT(temp);) {
 		namelen += (1 + temp->d_name.len);
 		temp = temp->d_parent;
 		if (temp == NULL) {
 			cERROR(1, "corrupt dentry");
 			rcu_read_unlock();
 			return NULL;
 		}
 	}
 	rcu_read_unlock();
 	full_path = kmalloc(namelen+1, GFP_KERNEL);
 	if (full_path == NULL)
 		return full_path;
 	full_path[namelen] = 0;	/* trailing null */
 	rcu_read_lock();
 	for (temp = direntry; !IS_ROOT(temp);) {
 		spin_lock(&temp->d_lock);
 		namelen -= 1 + temp->d_name.len;
 		if (namelen < 0) {
 			spin_unlock(&temp->d_lock);
 			break;
 		} else {
 			full_path[namelen] = dirsep;
 			strncpy(full_path + namelen + 1, temp->d_name.name,
 				temp->d_name.len);
 			cFYI(0, "name: %s", full_path + namelen);
 		}
 		spin_unlock(&temp->d_lock);
 		temp = temp->d_parent;
 		if (temp == NULL) {
 			cERROR(1, "corrupt dentry");
 			rcu_read_unlock();
 			kfree(full_path);
 			return NULL;
 		}
 	}
 	rcu_read_unlock();
 	if (namelen != dfsplen || read_seqretry(&rename_lock, seq)) {
 		cERROR(1, "did not end path lookup where expected namelen is %d",
 			namelen);
 		/* presumably this is only possible if racing with a rename
 		of one of the parent directories  (we can not lock the dentries
 		above us to prevent this, but retrying should be harmless) */
 		kfree(full_path);
 		goto cifs_bp_rename_retry;
 	}
 	/* DIR_SEP already set for byte  0 / vs \ but not for
 	   subsequent slashes in prepath which currently must
 	   be entered the right way - not sure if there is an alternative
 	   since the '\' is a valid posix character so we can not switch
 	   those safely to '/' if any are found in the middle of the prepath */
 	/* BB test paths to Windows with '/' in the midst of prepath */
 	if (dfsplen) {
 		strncpy(full_path, tcon->treeName, dfsplen);
 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
 			int i;
 			for (i = 0; i < dfsplen; i++) {
 				if (full_path[i] == '\\')
 					full_path[i] = '/';
 			}
 		}
 	}
 	return full_path;
 }
 /* Inode operations in similar order to how they appear in Linux file fs.h */
 int
 cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 		struct nameidata *nd)
 {
 	int rc = -ENOENT;
 	int xid;
 	int create_options = CREATE_NOT_DIR;
 	__u32 oplock = 0;
 	int oflags;
 	/*
 	 * BB below access is probably too much for mknod to request
 	 *    but we have to do query and setpathinfo so requesting
 	 *    less could fail (unless we want to request getatr and setatr
 	 *    permissions (only).  At least for POSIX we do not have to
 	 *    request so much.
 	 */
 	int desiredAccess = GENERIC_READ | GENERIC_WRITE;
 	__u16 fileHandle;
 	struct cifs_sb_info *cifs_sb;
 	struct tcon_link *tlink;
 	struct cifs_tcon *tcon;
 	char *full_path = NULL;
 	FILE_ALL_INFO *buf = NULL;
 	struct inode *newinode = NULL;
 	int disposition = FILE_OVERWRITE_IF;
 	xid = GetXid();
 	cifs_sb = CIFS_SB(inode->i_sb);
 	tlink = cifs_sb_tlink(cifs_sb);
 	if (IS_ERR(tlink)) {
 		FreeXid(xid);
 		return PTR_ERR(tlink);
 	}
 	tcon = tlink_tcon(tlink);
 	if (oplockEnabled)
 		oplock = REQ_OPLOCK;
 	if (nd)
 		oflags = nd->intent.open.file->f_flags;
 	else
 		oflags = O_RDONLY | O_CREAT;
 	full_path = build_path_from_dentry(direntry);
 	if (full_path == NULL) {
 		rc = -ENOMEM;
 		goto cifs_create_out;
 	}
 	if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 			le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 		rc = cifs_posix_open(full_path, &newinode,
 			inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
 		/* EIO could indicate that (posix open) operation is not
 		   supported, despite what server claimed in capability
 		   negotiation.  EREMOTE indicates DFS junction, which is not
 		   handled in posix open */
 		if (rc == 0) {
 			if (newinode == NULL) /* query inode info */
 				goto cifs_create_get_file_info;
 			else /* success, no need to query */
 				goto cifs_create_set_dentry;
 		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
 			 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
 			goto cifs_create_out;
 		/* else fallthrough to retry, using older open call, this is
 		   case where server does not support this SMB level, and
 		   falsely claims capability (also get here for DFS case
 		   which should be rare for path not covered on files) */
 	}
 	if (nd) {
 		/* if the file is going to stay open, then we
 		   need to set the desired access properly */
 		desiredAccess = 0;
 		if (OPEN_FMODE(oflags) & FMODE_READ)
 			desiredAccess |= GENERIC_READ; /* is this too little? */
 		if (OPEN_FMODE(oflags) & FMODE_WRITE)
 			desiredAccess |= GENERIC_WRITE;
 		if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 			disposition = FILE_CREATE;
 		else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 			disposition = FILE_OVERWRITE_IF;
 		else if ((oflags & O_CREAT) == O_CREAT)
 			disposition = FILE_OPEN_IF;
 		else
 			cFYI(1, "Create flag not set in create function");
 	}
 	/* BB add processing to set equivalent of mode - e.g. via CreateX with
 	   ACLs */
 	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 	if (buf == NULL) {
 		rc = -ENOMEM;
 		goto cifs_create_out;
 	}
 	/*
 	 * if we're not using unix extensions, see if we need to set
 	 * ATTR_READONLY on the create call
 	 */
 	if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
 		create_options |= CREATE_OPTION_READONLY;
 	if (tcon->ses->capabilities & CAP_NT_SMBS)
 		rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 			 desiredAccess, create_options,
 			 &fileHandle, &oplock, buf, cifs_sb->local_nls,
 			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 	else
 		rc = -EIO; /* no NT SMB support fall into legacy open below */
 	if (rc == -EIO) {
 		/* old server, retry the open legacy style */
 		rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 			desiredAccess, create_options,
 			&fileHandle, &oplock, buf, cifs_sb->local_nls,
 			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 	}
 	if (rc) {
 		cFYI(1, "cifs_create returned 0x%x", rc);
 		goto cifs_create_out;
 	}
 	/* If Open reported that we actually created a file
 	   then we now have to set the mode if possible */
 	if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
 		struct cifs_unix_set_info_args args = {
 				.mode	= mode,
 				.ctime	= NO_CHANGE_64,
 				.atime	= NO_CHANGE_64,
 				.mtime	= NO_CHANGE_64,
 				.device	= 0,
 		};
 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 			args.uid = (__u64) current_fsuid();
 			if (inode->i_mode & S_ISGID)
 				args.gid = (__u64) inode->i_gid;
 			else
 				args.gid = (__u64) current_fsgid();
 		} else {
 			args.uid = NO_CHANGE_64;
 			args.gid = NO_CHANGE_64;
 		}
 		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
 					current->tgid);
 	} else {
 		/* BB implement mode setting via Windows security
 		   descriptors e.g. */
 		/* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
 		/* Could set r/o dos attribute if mode & 0222 == 0 */
 	}
 cifs_create_get_file_info:
 	/* server might mask mode so we have to query for it */
 	if (tcon->unix_ext)
 		rc = cifs_get_inode_info_unix(&newinode, full_path,
 					      inode->i_sb, xid);
 	else {
 		rc = cifs_get_inode_info(&newinode, full_path, buf,
 					 inode->i_sb, xid, &fileHandle);
 		if (newinode) {
 			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
 				newinode->i_mode = mode;
 			if ((oplock & CIFS_CREATE_ACTION) &&
 			    (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
 				newinode->i_uid = current_fsuid();
 				if (inode->i_mode & S_ISGID)
 					newinode->i_gid = inode->i_gid;
 				else
 					newinode->i_gid = current_fsgid();
 			}
 		}
 	}
 cifs_create_set_dentry:
 	if (rc == 0)
 		d_instantiate(direntry, newinode);
 	else
 		cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
 	if (newinode && nd) {
 		struct cifsFileInfo *pfile_info;
 		struct file *filp;
 		filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
 		if (IS_ERR(filp)) {
 			rc = PTR_ERR(filp);
 			CIFSSMBClose(xid, tcon, fileHandle);
 			goto cifs_create_out;
 		}
 		pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
 		if (pfile_info == NULL) {
 			fput(filp);
 			CIFSSMBClose(xid, tcon, fileHandle);
 			rc = -ENOMEM;
 		}
 	} else {
 		CIFSSMBClose(xid, tcon, fileHandle);
 	}
 cifs_create_out:
 	kfree(buf);
 	kfree(full_path);
 	cifs_put_tlink(tlink);
 	FreeXid(xid);
 	return rc;
 }
 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
 		dev_t device_number)
 {
 	int rc = -EPERM;
 	int xid;
 	struct cifs_sb_info *cifs_sb;
 	struct tcon_link *tlink;
 	struct cifs_tcon *pTcon;
 	struct cifs_io_parms io_parms;
 	char *full_path = NULL;
 	struct inode *newinode = NULL;
 	int oplock = 0;
 	u16 fileHandle;
 	FILE_ALL_INFO *buf = NULL;
 	unsigned int bytes_written;
 	struct win_dev *pdev;
 	if (!old_valid_dev(device_number))
 		return -EINVAL;
 	cifs_sb = CIFS_SB(inode->i_sb);
 	tlink = cifs_sb_tlink(cifs_sb);
 	if (IS_ERR(tlink))
 		return PTR_ERR(tlink);
 	pTcon = tlink_tcon(tlink);
 	xid = GetXid();
 	full_path = build_path_from_dentry(direntry);
 	if (full_path == NULL) {
 		rc = -ENOMEM;
 		goto mknod_out;
 	}
 	if (pTcon->unix_ext) {
 		struct cifs_unix_set_info_args args = {
 			.mode	= mode & ~current_umask(),
 			.ctime	= NO_CHANGE_64,
 			.atime	= NO_CHANGE_64,
 			.mtime	= NO_CHANGE_64,
 			.device	= device_number,
 		};
 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 			args.uid = (__u64) current_fsuid();
 			args.gid = (__u64) current_fsgid();
 		} else {
 			args.uid = NO_CHANGE_64;
 			args.gid = NO_CHANGE_64;
 		}
 		rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
 					    cifs_sb->local_nls,
 					    cifs_sb->mnt_cifs_flags &
 						CIFS_MOUNT_MAP_SPECIAL_CHR);
 		if (rc)
 			goto mknod_out;
 		rc = cifs_get_inode_info_unix(&newinode, full_path,
 						inode->i_sb, xid);
 		if (rc == 0)
 			d_instantiate(direntry, newinode);
 		goto mknod_out;
 	}
 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
 		goto mknod_out;
 	cFYI(1, "sfu compat create special file");
 	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 	if (buf == NULL) {
 		kfree(full_path);
 		rc = -ENOMEM;
 		FreeXid(xid);
 		return rc;
 	}
 	/* FIXME: would WRITE_OWNER | WRITE_DAC be better? */
 	rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
 			 GENERIC_WRITE, CREATE_NOT_DIR | CREATE_OPTION_SPECIAL,
 			 &fileHandle, &oplock, buf, cifs_sb->local_nls,
 			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 	if (rc)
 		goto mknod_out;
 	/* BB Do not bother to decode buf since no local inode yet to put
 	 * timestamps in, but we can reuse it safely */
 	pdev = (struct win_dev *)buf;
 	io_parms.netfid = fileHandle;
 	io_parms.pid = current->tgid;
 	io_parms.tcon = pTcon;
 	io_parms.offset = 0;
 	io_parms.length = sizeof(struct win_dev);
 	if (S_ISCHR(mode)) {
 		memcpy(pdev->type, "IntxCHR", 8);
 		pdev->major =
 		      cpu_to_le64(MAJOR(device_number));
 		pdev->minor =
 		      cpu_to_le64(MINOR(device_number));
 		rc = CIFSSMBWrite(xid, &io_parms,
 			&bytes_written, (char *)pdev,
 			NULL, 0);
 	} else if (S_ISBLK(mode)) {
 		memcpy(pdev->type, "IntxBLK", 8);
 		pdev->major =
 		      cpu_to_le64(MAJOR(device_number));
 		pdev->minor =
 		      cpu_to_le64(MINOR(device_number));
 		rc = CIFSSMBWrite(xid, &io_parms,
 			&bytes_written, (char *)pdev,
 			NULL, 0);
 	} /* else if (S_ISFIFO) */
 	CIFSSMBClose(xid, pTcon, fileHandle);
 	d_drop(direntry);
 	/* FIXME: add code here to set EAs */
 mknod_out:
 	kfree(full_path);
 	kfree(buf);
 	FreeXid(xid);
 	cifs_put_tlink(tlink);
 	return rc;
 }
 struct dentry *
 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
 	    struct nameidata *nd)
 {
 	int xid;
 	int rc = 0; /* to get around spurious gcc warning, set to zero here */
 	__u32 oplock = 0;
 	__u16 fileHandle = 0;
 	bool posix_open = false;
 	struct cifs_sb_info *cifs_sb;
 	struct tcon_link *tlink;
 	struct cifs_tcon *pTcon;
 	struct cifsFileInfo *cfile;
 	struct inode *newInode = NULL;
 	char *full_path = NULL;
 	struct file *filp;
 	xid = GetXid();
 	cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
 	      parent_dir_inode, direntry->d_name.name, direntry);
 	/* check whether path exists */
 	cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
 	tlink = cifs_sb_tlink(cifs_sb);
 	if (IS_ERR(tlink)) {
 		FreeXid(xid);
 		return (struct dentry *)tlink;
 	}
 	pTcon = tlink_tcon(tlink);
 	/*
 	 * Don't allow the separator character in a path component.
 	 * The VFS will not allow "/", but "\" is allowed by posix.
 	 */
 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
 		int i;
 		for (i = 0; i < direntry->d_name.len; i++)
 			if (direntry->d_name.name[i] == '\\') {
 				cFYI(1, "Invalid file name");
 				rc = -EINVAL;
 				goto lookup_out;
 			}
 	}
 	/*
 	 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
 	 * the VFS handle the create.
 	 */
 	if (nd && (nd->flags & LOOKUP_EXCL)) {
 		d_instantiate(direntry, NULL);
 		rc = 0;
 		goto lookup_out;
 	}
 	/* can not grab the rename sem here since it would
 	deadlock in the cases (beginning of sys_rename itself)
 	in which we already have the sb rename sem */
 	full_path = build_path_from_dentry(direntry);
 	if (full_path == NULL) {
 		rc = -ENOMEM;
 		goto lookup_out;
 	}
 	if (direntry->d_inode != NULL) {
 		cFYI(1, "non-NULL inode in lookup");
 	} else {
 		cFYI(1, "NULL inode in lookup");
 	}
 	cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
 	/* Posix open is only called (at lookup time) for file create now.
 	 * For opens (rather than creates), because we do not know if it
 	 * is a file or directory yet, and current Samba no longer allows
 	 * us to do posix open on dirs, we could end up wasting an open call
 	 * on what turns out to be a dir. For file opens, we wait to call posix
 	 * open till cifs_open.  It could be added here (lookup) in the future
 	 * but the performance tradeoff of the extra network request when EISDIR
 	 * or EACCES is returned would have to be weighed against the 50%
 	 * reduction in network traffic in the other paths.
 	 */
 	if (pTcon->unix_ext) {
 		if (nd && !(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY)) &&
 		     (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
 		     (nd->intent.open.file->f_flags & O_CREAT)) {
 			rc = cifs_posix_open(full_path, &newInode,
 					parent_dir_inode->i_sb,
 					nd->intent.open.create_mode,
 					nd->intent.open.file->f_flags, &oplock,
 					&fileHandle, xid);
 			/*
 			 * The check below works around a bug in POSIX
 			 * open in samba versions 3.3.1 and earlier where
 			 * open could incorrectly fail with invalid parameter.
 			 * If either that or op not supported returned, follow
 			 * the normal lookup.
 			 */
 			if ((rc == 0) || (rc == -ENOENT))
 				posix_open = true;
 			else if ((rc == -EINVAL) || (rc != -EOPNOTSUPP))
 				pTcon->broken_posix_open = true;
 		}
 		if (!posix_open)
 			rc = cifs_get_inode_info_unix(&newInode, full_path,
 						parent_dir_inode->i_sb, xid);
 	} else
 		rc = cifs_get_inode_info(&newInode, full_path, NULL,
 				parent_dir_inode->i_sb, xid, NULL);
 	if ((rc == 0) && (newInode != NULL)) {
 		d_add(direntry, newInode);
 		if (posix_open) {
 			filp = lookup_instantiate_filp(nd, direntry,
 						       generic_file_open);
 			if (IS_ERR(filp)) {
 				rc = PTR_ERR(filp);
 				CIFSSMBClose(xid, pTcon, fileHandle);
 				goto lookup_out;
 			}
 			cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
 						  oplock);
 			if (cfile == NULL) {
 				fput(filp);
 				CIFSSMBClose(xid, pTcon, fileHandle);
 				rc = -ENOMEM;
 				goto lookup_out;
 			}
 		}
 		/* since paths are not looked up by component - the parent
 		   directories are presumed to be good here */
 		renew_parental_timestamps(direntry);
 	} else if (rc == -ENOENT) {
 		rc = 0;
 		direntry->d_time = jiffies;
 		d_add(direntry, NULL);
 	/*	if it was once a directory (but how can we tell?) we could do
 		shrink_dcache_parent(direntry); */
 	} else if (rc != -EACCES) {
 		cERROR(1, "Unexpected lookup error %d", rc);
 		/* We special case check for Access Denied - since that
 		is a common return code */
 	}
 lookup_out:
 	kfree(full_path);
 	cifs_put_tlink(tlink);
 	FreeXid(xid);
 	return ERR_PTR(rc);
 }
 static int
 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
 {
 	if (nd->flags & LOOKUP_RCU)
 		return -ECHILD;
 	if (direntry->d_inode) {
 		if (cifs_revalidate_dentry(direntry))
 			return 0;
 		else
 			return 1;
 	}
 	/*
 	 * This may be nfsd (or something), anyway, we can't see the
 	 * intent of this. So, since this can be for creation, drop it.
 	 */
 	if (!nd)
 		return 0;
 	/*
 	 * Drop the negative dentry, in order to make sure to use the
 	 * case sensitive name which is specified by user if this is
 	 * for creation.
 	 */
-	if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
+	if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
-		if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+		return 0;
-			return 0;
-	}
 	if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
 		return 0;
 	return 1;
 }
 /* static int cifs_d_delete(struct dentry *direntry)
 {
 	int rc = 0;
 	cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
 	return rc;
 }     */
 const struct dentry_operations cifs_dentry_ops = {
 	.d_revalidate = cifs_d_revalidate,
 	.d_automount = cifs_dfs_d_automount,
 /* d_delete:       cifs_d_delete,      */ /* not needed except for debugging */
 };
 static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
 		struct qstr *q)
 {
 	struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
 	unsigned long hash;
 	int i;
 	hash = init_name_hash();
 	for (i = 0; i < q->len; i++)
 		hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
 					 hash);
 	q->hash = end_name_hash(hash);
 	return 0;
 }
 static int cifs_ci_compare(const struct dentry *parent,
 		const struct inode *pinode,
 		const struct dentry *dentry, const struct inode *inode,
 		unsigned int len, const char *str, const struct qstr *name)
 {
 	struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
 	if ((name->len == len) &&
 	    (nls_strnicmp(codepage, name->name, str, len) == 0))
 		return 0;
 	return 1;
 }
 const struct dentry_operations cifs_ci_dentry_ops = {
 	.d_revalidate = cifs_d_revalidate,
 	.d_hash = cifs_ci_hash,
 	.d_compare = cifs_ci_compare,
 	.d_automount = cifs_dfs_d_automount,
 };

fs/fat/namei_vfat.c

Diff comments View file @ 407938e

 /*
  *  linux/fs/vfat/namei.c
  *
  *  Written 1992,1993 by Werner Almesberger
  *
  *  Windows95/Windows NT compatible extended MSDOS filesystem
  *    by Gordon Chaffee Copyright (C) 1995.  Send bug reports for the
  *    VFAT filesystem to <chaffee@cs.berkeley.edu>.  Specify
  *    what file operation caused you trouble and if you can duplicate
  *    the problem, send a script that demonstrates it.
  *
  *  Short name translation 1999, 2001 by Wolfram Pienkoss <wp@bszh.de>
  *
  *  Support Multibyte characters and cleanup by
  *				OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
  */
 #include <linux/module.h>
 #include <linux/jiffies.h>
 #include <linux/ctype.h>
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/namei.h>
 #include "fat.h"
 /*
  * If new entry was created in the parent, it could create the 8.3
  * alias (the shortname of logname).  So, the parent may have the
  * negative-dentry which matches the created 8.3 alias.
  *
  * If it happened, the negative dentry isn't actually negative
  * anymore.  So, drop it.
  */
 static int vfat_revalidate_shortname(struct dentry *dentry)
 {
 	int ret = 1;
 	spin_lock(&dentry->d_lock);
 	if (dentry->d_time != dentry->d_parent->d_inode->i_version)
 		ret = 0;
 	spin_unlock(&dentry->d_lock);
 	return ret;
 }
 static int vfat_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
 	if (nd && nd->flags & LOOKUP_RCU)
 		return -ECHILD;
 	/* This is not negative dentry. Always valid. */
 	if (dentry->d_inode)
 		return 1;
 	return vfat_revalidate_shortname(dentry);
 }
 static int vfat_revalidate_ci(struct dentry *dentry, struct nameidata *nd)
 {
 	if (nd && nd->flags & LOOKUP_RCU)
 		return -ECHILD;
 	/*
 	 * This is not negative dentry. Always valid.
 	 *
 	 * Note, rename() to existing directory entry will have ->d_inode,
 	 * and will use existing name which isn't specified name by user.
 	 *
 	 * We may be able to drop this positive dentry here. But dropping
 	 * positive dentry isn't good idea. So it's unsupported like
 	 * rename("filename", "FILENAME") for now.
 	 */
 	if (dentry->d_inode)
 		return 1;
 	/*
 	 * This may be nfsd (or something), anyway, we can't see the
 	 * intent of this. So, since this can be for creation, drop it.
 	 */
 	if (!nd)
 		return 0;
 	/*
 	 * Drop the negative dentry, in order to make sure to use the
 	 * case sensitive name which is specified by user if this is
 	 * for creation.
 	 */
-	if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
+	if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
-		if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+		return 0;
-			return 0;
-	}
 	return vfat_revalidate_shortname(dentry);
 }
 /* returns the length of a struct qstr, ignoring trailing dots */
 static unsigned int __vfat_striptail_len(unsigned int len, const char *name)
 {
 	while (len && name[len - 1] == '.')
 		len--;
 	return len;
 }
 static unsigned int vfat_striptail_len(const struct qstr *qstr)
 {
 	return __vfat_striptail_len(qstr->len, qstr->name);
 }
 /*
  * Compute the hash for the vfat name corresponding to the dentry.
  * Note: if the name is invalid, we leave the hash code unchanged so
  * that the existing dentry can be used. The vfat fs routines will
  * return ENOENT or EINVAL as appropriate.
  */
 static int vfat_hash(const struct dentry *dentry, const struct inode *inode,
 		struct qstr *qstr)
 {
 	qstr->hash = full_name_hash(qstr->name, vfat_striptail_len(qstr));
 	return 0;
 }
 /*
  * Compute the hash for the vfat name corresponding to the dentry.
  * Note: if the name is invalid, we leave the hash code unchanged so
  * that the existing dentry can be used. The vfat fs routines will
  * return ENOENT or EINVAL as appropriate.
  */
 static int vfat_hashi(const struct dentry *dentry, const struct inode *inode,
 		struct qstr *qstr)
 {
 	struct nls_table *t = MSDOS_SB(dentry->d_sb)->nls_io;
 	const unsigned char *name;
 	unsigned int len;
 	unsigned long hash;
 	name = qstr->name;
 	len = vfat_striptail_len(qstr);
 	hash = init_name_hash();
 	while (len--)
 		hash = partial_name_hash(nls_tolower(t, *name++), hash);
 	qstr->hash = end_name_hash(hash);
 	return 0;
 }
 /*
  * Case insensitive compare of two vfat names.
  */
 static int vfat_cmpi(const struct dentry *parent, const struct inode *pinode,
 		const struct dentry *dentry, const struct inode *inode,
 		unsigned int len, const char *str, const struct qstr *name)
 {
 	struct nls_table *t = MSDOS_SB(parent->d_sb)->nls_io;
 	unsigned int alen, blen;
 	/* A filename cannot end in '.' or we treat it like it has none */
 	alen = vfat_striptail_len(name);
 	blen = __vfat_striptail_len(len, str);
 	if (alen == blen) {
 		if (nls_strnicmp(t, name->name, str, alen) == 0)
 			return 0;
 	}
 	return 1;
 }
 /*
  * Case sensitive compare of two vfat names.
  */
 static int vfat_cmp(const struct dentry *parent, const struct inode *pinode,
 		const struct dentry *dentry, const struct inode *inode,
 		unsigned int len, const char *str, const struct qstr *name)
 {
 	unsigned int alen, blen;
 	/* A filename cannot end in '.' or we treat it like it has none */
 	alen = vfat_striptail_len(name);
 	blen = __vfat_striptail_len(len, str);
 	if (alen == blen) {
 		if (strncmp(name->name, str, alen) == 0)
 			return 0;
 	}
 	return 1;
 }
 static const struct dentry_operations vfat_ci_dentry_ops = {
 	.d_revalidate	= vfat_revalidate_ci,
 	.d_hash		= vfat_hashi,
 	.d_compare	= vfat_cmpi,
 };
 static const struct dentry_operations vfat_dentry_ops = {
 	.d_revalidate	= vfat_revalidate,
 	.d_hash		= vfat_hash,
 	.d_compare	= vfat_cmp,
 };
 /* Characters that are undesirable in an MS-DOS file name */
 static inline wchar_t vfat_bad_char(wchar_t w)
 {
 	return (w < 0x0020)
 	    || (w == '*') || (w == '?') || (w == '<') || (w == '>')
 	    || (w == '|') || (w == '"') || (w == ':') || (w == '/')
 	    || (w == '\\');
 }
 static inline wchar_t vfat_replace_char(wchar_t w)
 {
 	return (w == '[') || (w == ']') || (w == ';') || (w == ',')
 	    || (w == '+') || (w == '=');
 }
 static wchar_t vfat_skip_char(wchar_t w)
 {
 	return (w == '.') || (w == ' ');
 }
 static inline int vfat_is_used_badchars(const wchar_t *s, int len)
 {
 	int i;
 	for (i = 0; i < len; i++)
 		if (vfat_bad_char(s[i]))
 			return -EINVAL;
 	if (s[i - 1] == ' ') /* last character cannot be space */
 		return -EINVAL;
 	return 0;
 }
 static int vfat_find_form(struct inode *dir, unsigned char *name)
 {
 	struct fat_slot_info sinfo;
 	int err = fat_scan(dir, name, &sinfo);
 	if (err)
 		return -ENOENT;
 	brelse(sinfo.bh);
 	return 0;
 }
 /*
  * 1) Valid characters for the 8.3 format alias are any combination of
  * letters, uppercase alphabets, digits, any of the
  * following special characters:
  *     $ % ' ` - @ { } ~ ! # ( ) & _ ^
  * In this case Longfilename is not stored in disk.
  *
  * WinNT's Extension:
  * File name and extension name is contain uppercase/lowercase
  * only. And it is expressed by CASE_LOWER_BASE and CASE_LOWER_EXT.
  *
  * 2) File name is 8.3 format, but it contain the uppercase and
  * lowercase char, muliti bytes char, etc. In this case numtail is not
  * added, but Longfilename is stored.
  *
  * 3) When the one except for the above, or the following special
  * character are contained:
  *        .   [ ] ; , + =
  * numtail is added, and Longfilename must be stored in disk .
  */
 struct shortname_info {
 	unsigned char lower:1,
 		      upper:1,
 		      valid:1;
 };
 #define INIT_SHORTNAME_INFO(x)	do {		\
 	(x)->lower = 1;				\
 	(x)->upper = 1;				\
 	(x)->valid = 1;				\
 } while (0)
 static inline int to_shortname_char(struct nls_table *nls,
 				    unsigned char *buf, int buf_size,
 				    wchar_t *src, struct shortname_info *info)
 {
 	int len;
 	if (vfat_skip_char(*src)) {
 		info->valid = 0;
 		return 0;
 	}
 	if (vfat_replace_char(*src)) {
 		info->valid = 0;
 		buf[0] = '_';
 		return 1;
 	}
 	len = nls->uni2char(*src, buf, buf_size);
 	if (len <= 0) {
 		info->valid = 0;
 		buf[0] = '_';
 		len = 1;
 	} else if (len == 1) {
 		unsigned char prev = buf[0];
 		if (buf[0] >= 0x7F) {
 			info->lower = 0;
 			info->upper = 0;
 		}
 		buf[0] = nls_toupper(nls, buf[0]);
 		if (isalpha(buf[0])) {
 			if (buf[0] == prev)
 				info->lower = 0;
 			else
 				info->upper = 0;
 		}
 	} else {
 		info->lower = 0;
 		info->upper = 0;
 	}
 	return len;
 }
 /*
  * Given a valid longname, create a unique shortname.  Make sure the
  * shortname does not exist
  * Returns negative number on error, 0 for a normal
  * return, and 1 for valid shortname
  */
 static int vfat_create_shortname(struct inode *dir, struct nls_table *nls,
 				 wchar_t *uname, int ulen,
 				 unsigned char *name_res, unsigned char *lcase)
 {
 	struct fat_mount_options *opts = &MSDOS_SB(dir->i_sb)->options;
 	wchar_t *ip, *ext_start, *end, *name_start;
 	unsigned char base[9], ext[4], buf[5], *p;
 	unsigned char charbuf[NLS_MAX_CHARSET_SIZE];
 	int chl, chi;
 	int sz = 0, extlen, baselen, i, numtail_baselen, numtail2_baselen;
 	int is_shortname;
 	struct shortname_info base_info, ext_info;
 	is_shortname = 1;
 	INIT_SHORTNAME_INFO(&base_info);
 	INIT_SHORTNAME_INFO(&ext_info);
 	/* Now, we need to create a shortname from the long name */
 	ext_start = end = &uname[ulen];
 	while (--ext_start >= uname) {
 		if (*ext_start == 0x002E) {	/* is `.' */
 			if (ext_start == end - 1) {
 				sz = ulen;
 				ext_start = NULL;
 			}
 			break;
 		}
 	}
 	if (ext_start == uname - 1) {
 		sz = ulen;
 		ext_start = NULL;
 	} else if (ext_start) {
 		/*
 		 * Names which start with a dot could be just
 		 * an extension eg. "...test".  In this case Win95
 		 * uses the extension as the name and sets no extension.
 		 */
 		name_start = &uname[0];
 		while (name_start < ext_start) {
 			if (!vfat_skip_char(*name_start))
 				break;
 			name_start++;
 		}
 		if (name_start != ext_start) {
 			sz = ext_start - uname;
 			ext_start++;
 		} else {
 			sz = ulen;
 			ext_start = NULL;
 		}
 	}
 	numtail_baselen = 6;
 	numtail2_baselen = 2;
 	for (baselen = i = 0, p = base, ip = uname; i < sz; i++, ip++) {
 		chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
 					ip, &base_info);
 		if (chl == 0)
 			continue;
 		if (baselen < 2 && (baselen + chl) > 2)
 			numtail2_baselen = baselen;
 		if (baselen < 6 && (baselen + chl) > 6)
 			numtail_baselen = baselen;
 		for (chi = 0; chi < chl; chi++) {
 			*p++ = charbuf[chi];
 			baselen++;
 			if (baselen >= 8)
 				break;
 		}
 		if (baselen >= 8) {
 			if ((chi < chl - 1) || (ip + 1) - uname < sz)
 				is_shortname = 0;
 			break;
 		}
 	}
 	if (baselen == 0) {
 		return -EINVAL;
 	}
 	extlen = 0;
 	if (ext_start) {
 		for (p = ext, ip = ext_start; extlen < 3 && ip < end; ip++) {
 			chl = to_shortname_char(nls, charbuf, sizeof(charbuf),
 						ip, &ext_info);
 			if (chl == 0)
 				continue;
 			if ((extlen + chl) > 3) {
 				is_shortname = 0;
 				break;
 			}
 			for (chi = 0; chi < chl; chi++) {
 				*p++ = charbuf[chi];
 				extlen++;
 			}
 			if (extlen >= 3) {
 				if (ip + 1 != end)
 					is_shortname = 0;
 				break;
 			}
 		}
 	}
 	ext[extlen] = '\0';
 	base[baselen] = '\0';
 	/* Yes, it can happen. ".\xe5" would do it. */
 	if (base[0] == DELETED_FLAG)
 		base[0] = 0x05;
 	/* OK, at this point we know that base is not longer than 8 symbols,
 	 * ext is not longer than 3, base is nonempty, both don't contain
 	 * any bad symbols (lowercase transformed to uppercase).
 	 */
 	memset(name_res, ' ', MSDOS_NAME);
 	memcpy(name_res, base, baselen);
 	memcpy(name_res + 8, ext, extlen);
 	*lcase = 0;
 	if (is_shortname && base_info.valid && ext_info.valid) {
 		if (vfat_find_form(dir, name_res) == 0)
 			return -EEXIST;
 		if (opts->shortname & VFAT_SFN_CREATE_WIN95) {
 			return (base_info.upper && ext_info.upper);
 		} else if (opts->shortname & VFAT_SFN_CREATE_WINNT) {
 			if ((base_info.upper || base_info.lower) &&
 			    (ext_info.upper || ext_info.lower)) {
 				if (!base_info.upper && base_info.lower)
 					*lcase |= CASE_LOWER_BASE;
 				if (!ext_info.upper && ext_info.lower)
 					*lcase |= CASE_LOWER_EXT;
 				return 1;
 			}
 			return 0;
 		} else {
 			BUG();
 		}
 	}
 	if (opts->numtail == 0)
 		if (vfat_find_form(dir, name_res) < 0)
 			return 0;
 	/*
 	 * Try to find a unique extension.  This used to
 	 * iterate through all possibilities sequentially,
 	 * but that gave extremely bad performance.  Windows
 	 * only tries a few cases before using random
 	 * values for part of the base.
 	 */
 	if (baselen > 6) {
 		baselen = numtail_baselen;
 		name_res[7] = ' ';
 	}
 	name_res[baselen] = '~';
 	for (i = 1; i < 10; i++) {
 		name_res[baselen + 1] = i + '0';
 		if (vfat_find_form(dir, name_res) < 0)
 			return 0;
 	}
 	i = jiffies;
 	sz = (jiffies >> 16) & 0x7;
 	if (baselen > 2) {
 		baselen = numtail2_baselen;
 		name_res[7] = ' ';
 	}
 	name_res[baselen + 4] = '~';
 	name_res[baselen + 5] = '1' + sz;
 	while (1) {
 		snprintf(buf, sizeof(buf), "%04X", i & 0xffff);
 		memcpy(&name_res[baselen], buf, 4);
 		if (vfat_find_form(dir, name_res) < 0)
 			break;
 		i -= 11;
 	}
 	return 0;
 }
 /* Translate a string, including coded sequences into Unicode */
 static int
 xlate_to_uni(const unsigned char *name, int len, unsigned char *outname,
 	     int *longlen, int *outlen, int escape, int utf8,
 	     struct nls_table *nls)
 {
 	const unsigned char *ip;
 	unsigned char nc;
 	unsigned char *op;
 	unsigned int ec;
 	int i, k, fill;
 	int charlen;
 	if (utf8) {
 		*outlen = utf8s_to_utf16s(name, len, (wchar_t *)outname);
 		if (*outlen < 0)
 			return *outlen;
 		else if (*outlen > FAT_LFN_LEN)
 			return -ENAMETOOLONG;
 		op = &outname[*outlen * sizeof(wchar_t)];
 	} else {
 		if (nls) {
 			for (i = 0, ip = name, op = outname, *outlen = 0;
 			     i < len && *outlen <= FAT_LFN_LEN;
 			     *outlen += 1)
 			{
 				if (escape && (*ip == ':')) {
 					if (i > len - 5)
 						return -EINVAL;
 					ec = 0;
 					for (k = 1; k < 5; k++) {
 						nc = ip[k];
 						ec <<= 4;
 						if (nc >= '0' && nc <= '9') {
 							ec |= nc - '0';
 							continue;
 						}
 						if (nc >= 'a' && nc <= 'f') {
 							ec |= nc - ('a' - 10);
 							continue;
 						}
 						if (nc >= 'A' && nc <= 'F') {
 							ec |= nc - ('A' - 10);
 							continue;
 						}
 						return -EINVAL;
 					}
 					*op++ = ec & 0xFF;
 					*op++ = ec >> 8;
 					ip += 5;
 					i += 5;
 				} else {
 					if ((charlen = nls->char2uni(ip, len - i, (wchar_t *)op)) < 0)
 						return -EINVAL;
 					ip += charlen;
 					i += charlen;
 					op += 2;
 				}
 			}
 			if (i < len)
 				return -ENAMETOOLONG;
 		} else {
 			for (i = 0, ip = name, op = outname, *outlen = 0;
 			     i < len && *outlen <= FAT_LFN_LEN;
 			     i++, *outlen += 1)
 			{
 				*op++ = *ip++;
 				*op++ = 0;
 			}
 			if (i < len)
 				return -ENAMETOOLONG;
 		}
 	}
 	*longlen = *outlen;
 	if (*outlen % 13) {
 		*op++ = 0;
 		*op++ = 0;
 		*outlen += 1;
 		if (*outlen % 13) {
 			fill = 13 - (*outlen % 13);
 			for (i = 0; i < fill; i++) {
 				*op++ = 0xff;
 				*op++ = 0xff;
 			}
 			*outlen += fill;
 		}
 	}
 	return 0;
 }
 static int vfat_build_slots(struct inode *dir, const unsigned char *name,
 			    int len, int is_dir, int cluster,
 			    struct timespec *ts,
 			    struct msdos_dir_slot *slots, int *nr_slots)
 {
 	struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb);
 	struct fat_mount_options *opts = &sbi->options;
 	struct msdos_dir_slot *ps;
 	struct msdos_dir_entry *de;
 	unsigned char cksum, lcase;
 	unsigned char msdos_name[MSDOS_NAME];
 	wchar_t *uname;
 	__le16 time, date;
 	u8 time_cs;
 	int err, ulen, usize, i;
 	loff_t offset;
 	*nr_slots = 0;
 	uname = __getname();
 	if (!uname)
 		return -ENOMEM;
 	err = xlate_to_uni(name, len, (unsigned char *)uname, &ulen, &usize,
 			   opts->unicode_xlate, opts->utf8, sbi->nls_io);
 	if (err)
 		goto out_free;
 	err = vfat_is_used_badchars(uname, ulen);
 	if (err)
 		goto out_free;
 	err = vfat_create_shortname(dir, sbi->nls_disk, uname, ulen,
 				    msdos_name, &lcase);
 	if (err < 0)
 		goto out_free;
 	else if (err == 1) {
 		de = (struct msdos_dir_entry *)slots;
 		err = 0;
 		goto shortname;
 	}
 	/* build the entry of long file name */
 	cksum = fat_checksum(msdos_name);
 	*nr_slots = usize / 13;
 	for (ps = slots, i = *nr_slots; i > 0; i--, ps++) {
 		ps->id = i;
 		ps->attr = ATTR_EXT;
 		ps->reserved = 0;
 		ps->alias_checksum = cksum;
 		ps->start = 0;
 		offset = (i - 1) * 13;
 		fatwchar_to16(ps->name0_4, uname + offset, 5);
 		fatwchar_to16(ps->name5_10, uname + offset + 5, 6);
 		fatwchar_to16(ps->name11_12, uname + offset + 11, 2);
 	}
 	slots[0].id |= 0x40;
 	de = (struct msdos_dir_entry *)ps;
 shortname:
 	/* build the entry of 8.3 alias name */
 	(*nr_slots)++;
 	memcpy(de->name, msdos_name, MSDOS_NAME);
 	de->attr = is_dir ? ATTR_DIR : ATTR_ARCH;
 	de->lcase = lcase;
 	fat_time_unix2fat(sbi, ts, &time, &date, &time_cs);
 	de->time = de->ctime = time;
 	de->date = de->cdate = de->adate = date;
 	de->ctime_cs = time_cs;
 	de->start = cpu_to_le16(cluster);
 	de->starthi = cpu_to_le16(cluster >> 16);
 	de->size = 0;
 out_free:
 	__putname(uname);
 	return err;
 }
 static int vfat_add_entry(struct inode *dir, struct qstr *qname, int is_dir,
 			  int cluster, struct timespec *ts,
 			  struct fat_slot_info *sinfo)
 {
 	struct msdos_dir_slot *slots;
 	unsigned int len;
 	int err, nr_slots;
 	len = vfat_striptail_len(qname);
 	if (len == 0)
 		return -ENOENT;
 	slots = kmalloc(sizeof(*slots) * MSDOS_SLOTS, GFP_NOFS);
 	if (slots == NULL)
 		return -ENOMEM;
 	err = vfat_build_slots(dir, qname->name, len, is_dir, cluster, ts,
 			       slots, &nr_slots);
 	if (err)
 		goto cleanup;
 	err = fat_add_entries(dir, slots, nr_slots, sinfo);
 	if (err)
 		goto cleanup;
 	/* update timestamp */
 	dir->i_ctime = dir->i_mtime = dir->i_atime = *ts;
 	if (IS_DIRSYNC(dir))
 		(void)fat_sync_inode(dir);
 	else
 		mark_inode_dirty(dir);
 cleanup:
 	kfree(slots);
 	return err;
 }
 static int vfat_find(struct inode *dir, struct qstr *qname,
 		     struct fat_slot_info *sinfo)
 {
 	unsigned int len = vfat_striptail_len(qname);
 	if (len == 0)
 		return -ENOENT;
 	return fat_search_long(dir, qname->name, len, sinfo);
 }
 /*
  * (nfsd's) anonymous disconnected dentry?
  * NOTE: !IS_ROOT() is not anonymous (I.e. d_splice_alias() did the job).
  */
 static int vfat_d_anon_disconn(struct dentry *dentry)
 {
 	return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
 }
 static struct dentry *vfat_lookup(struct inode *dir, struct dentry *dentry,
 				  struct nameidata *nd)
 {
 	struct super_block *sb = dir->i_sb;
 	struct fat_slot_info sinfo;
 	struct inode *inode;
 	struct dentry *alias;
 	int err;
 	lock_super(sb);
 	err = vfat_find(dir, &dentry->d_name, &sinfo);
 	if (err) {
 		if (err == -ENOENT) {
 			inode = NULL;
 			goto out;
 		}
 		goto error;
 	}
 	inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
 	brelse(sinfo.bh);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		goto error;
 	}
 	alias = d_find_alias(inode);
 	if (alias && !vfat_d_anon_disconn(alias)) {
 		/*
 		 * This inode has non anonymous-DCACHE_DISCONNECTED
 		 * dentry. This means, the user did ->lookup() by an
 		 * another name (longname vs 8.3 alias of it) in past.
 		 *
 		 * Switch to new one for reason of locality if possible.
 		 */
 		BUG_ON(d_unhashed(alias));
 		if (!S_ISDIR(inode->i_mode))
 			d_move(alias, dentry);
 		iput(inode);
 		unlock_super(sb);
 		return alias;
 	} else
 		dput(alias);
 out:
 	unlock_super(sb);
 	dentry->d_time = dentry->d_parent->d_inode->i_version;
 	dentry = d_splice_alias(inode, dentry);
 	if (dentry)
 		dentry->d_time = dentry->d_parent->d_inode->i_version;
 	return dentry;
 error:
 	unlock_super(sb);
 	return ERR_PTR(err);
 }
 static int vfat_create(struct inode *dir, struct dentry *dentry, int mode,
 		       struct nameidata *nd)
 {
 	struct super_block *sb = dir->i_sb;
 	struct inode *inode;
 	struct fat_slot_info sinfo;
 	struct timespec ts;
 	int err;
 	lock_super(sb);
 	ts = CURRENT_TIME_SEC;
 	err = vfat_add_entry(dir, &dentry->d_name, 0, 0, &ts, &sinfo);
 	if (err)
 		goto out;
 	dir->i_version++;
 	inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
 	brelse(sinfo.bh);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		goto out;
 	}
 	inode->i_version++;
 	inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
 	/* timestamp is already written, so mark_inode_dirty() is unneeded. */
 	dentry->d_time = dentry->d_parent->d_inode->i_version;
 	d_instantiate(dentry, inode);
 out:
 	unlock_super(sb);
 	return err;
 }
 static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
 {
 	struct inode *inode = dentry->d_inode;
 	struct super_block *sb = dir->i_sb;
 	struct fat_slot_info sinfo;
 	int err;
 	lock_super(sb);
 	err = fat_dir_empty(inode);
 	if (err)
 		goto out;
 	err = vfat_find(dir, &dentry->d_name, &sinfo);
 	if (err)
 		goto out;
 	err = fat_remove_entries(dir, &sinfo);	/* and releases bh */
 	if (err)
 		goto out;
 	drop_nlink(dir);
 	clear_nlink(inode);
 	inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
 	fat_detach(inode);
 out:
 	unlock_super(sb);
 	return err;
 }
 static int vfat_unlink(struct inode *dir, struct dentry *dentry)
 {
 	struct inode *inode = dentry->d_inode;
 	struct super_block *sb = dir->i_sb;
 	struct fat_slot_info sinfo;
 	int err;
 	lock_super(sb);
 	err = vfat_find(dir, &dentry->d_name, &sinfo);
 	if (err)
 		goto out;
 	err = fat_remove_entries(dir, &sinfo);	/* and releases bh */
 	if (err)
 		goto out;
 	clear_nlink(inode);
 	inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
 	fat_detach(inode);
 out:
 	unlock_super(sb);
 	return err;
 }
 static int vfat_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
 	struct super_block *sb = dir->i_sb;
 	struct inode *inode;
 	struct fat_slot_info sinfo;
 	struct timespec ts;
 	int err, cluster;
 	lock_super(sb);
 	ts = CURRENT_TIME_SEC;
 	cluster = fat_alloc_new_dir(dir, &ts);
 	if (cluster < 0) {
 		err = cluster;
 		goto out;
 	}
 	err = vfat_add_entry(dir, &dentry->d_name, 1, cluster, &ts, &sinfo);
 	if (err)
 		goto out_free;
 	dir->i_version++;
 	inc_nlink(dir);
 	inode = fat_build_inode(sb, sinfo.de, sinfo.i_pos);
 	brelse(sinfo.bh);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		/* the directory was completed, just return a error */
 		goto out;
 	}
 	inode->i_version++;
 	inode->i_nlink = 2;
 	inode->i_mtime = inode->i_atime = inode->i_ctime = ts;
 	/* timestamp is already written, so mark_inode_dirty() is unneeded. */
 	dentry->d_time = dentry->d_parent->d_inode->i_version;
 	d_instantiate(dentry, inode);
 	unlock_super(sb);
 	return 0;
 out_free:
 	fat_free_clusters(dir, cluster);
 out:
 	unlock_super(sb);
 	return err;
 }
 static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
 		       struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct buffer_head *dotdot_bh;
 	struct msdos_dir_entry *dotdot_de;
 	struct inode *old_inode, *new_inode;
 	struct fat_slot_info old_sinfo, sinfo;
 	struct timespec ts;
 	loff_t dotdot_i_pos, new_i_pos;
 	int err, is_dir, update_dotdot, corrupt = 0;
 	struct super_block *sb = old_dir->i_sb;
 	old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
 	old_inode = old_dentry->d_inode;
 	new_inode = new_dentry->d_inode;
 	lock_super(sb);
 	err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo);
 	if (err)
 		goto out;
 	is_dir = S_ISDIR(old_inode->i_mode);
 	update_dotdot = (is_dir && old_dir != new_dir);
 	if (update_dotdot) {
 		if (fat_get_dotdot_entry(old_inode, &dotdot_bh, &dotdot_de,
 					 &dotdot_i_pos) < 0) {
 			err = -EIO;
 			goto out;
 		}
 	}
 	ts = CURRENT_TIME_SEC;
 	if (new_inode) {
 		if (is_dir) {
 			err = fat_dir_empty(new_inode);
 			if (err)
 				goto out;
 		}
 		new_i_pos = MSDOS_I(new_inode)->i_pos;
 		fat_detach(new_inode);
 	} else {
 		err = vfat_add_entry(new_dir, &new_dentry->d_name, is_dir, 0,
 				     &ts, &sinfo);
 		if (err)
 			goto out;
 		new_i_pos = sinfo.i_pos;
 	}
 	new_dir->i_version++;
 	fat_detach(old_inode);
 	fat_attach(old_inode, new_i_pos);
 	if (IS_DIRSYNC(new_dir)) {
 		err = fat_sync_inode(old_inode);
 		if (err)
 			goto error_inode;
 	} else
 		mark_inode_dirty(old_inode);
 	if (update_dotdot) {
 		int start = MSDOS_I(new_dir)->i_logstart;
 		dotdot_de->start = cpu_to_le16(start);
 		dotdot_de->starthi = cpu_to_le16(start >> 16);
 		mark_buffer_dirty_inode(dotdot_bh, old_inode);
 		if (IS_DIRSYNC(new_dir)) {
 			err = sync_dirty_buffer(dotdot_bh);
 			if (err)
 				goto error_dotdot;
 		}
 		drop_nlink(old_dir);
 		if (!new_inode)
  			inc_nlink(new_dir);
 	}
 	err = fat_remove_entries(old_dir, &old_sinfo);	/* and releases bh */
 	old_sinfo.bh = NULL;
 	if (err)
 		goto error_dotdot;
 	old_dir->i_version++;
 	old_dir->i_ctime = old_dir->i_mtime = ts;
 	if (IS_DIRSYNC(old_dir))
 		(void)fat_sync_inode(old_dir);
 	else
 		mark_inode_dirty(old_dir);
 	if (new_inode) {
 		drop_nlink(new_inode);
 		if (is_dir)
 			drop_nlink(new_inode);
 		new_inode->i_ctime = ts;
 	}
 out:
 	brelse(sinfo.bh);
 	brelse(dotdot_bh);
 	brelse(old_sinfo.bh);
 	unlock_super(sb);
 	return err;
 error_dotdot:
 	/* data cluster is shared, serious corruption */
 	corrupt = 1;
 	if (update_dotdot) {
 		int start = MSDOS_I(old_dir)->i_logstart;
 		dotdot_de->start = cpu_to_le16(start);
 		dotdot_de->starthi = cpu_to_le16(start >> 16);
 		mark_buffer_dirty_inode(dotdot_bh, old_inode);
 		corrupt |= sync_dirty_buffer(dotdot_bh);
 	}
 error_inode:
 	fat_detach(old_inode);
 	fat_attach(old_inode, old_sinfo.i_pos);
 	if (new_inode) {
 		fat_attach(new_inode, new_i_pos);
 		if (corrupt)
 			corrupt |= fat_sync_inode(new_inode);
 	} else {
 		/*
 		 * If new entry was not sharing the data cluster, it
 		 * shouldn't be serious corruption.
 		 */
 		int err2 = fat_remove_entries(new_dir, &sinfo);
 		if (corrupt)
 			corrupt |= err2;
 		sinfo.bh = NULL;
 	}
 	if (corrupt < 0) {
 		fat_fs_error(new_dir->i_sb,
 			     "%s: Filesystem corrupted (i_pos %lld)",
 			     __func__, sinfo.i_pos);
 	}
 	goto out;
 }
 static const struct inode_operations vfat_dir_inode_operations = {
 	.create		= vfat_create,
 	.lookup		= vfat_lookup,
 	.unlink		= vfat_unlink,
 	.mkdir		= vfat_mkdir,
 	.rmdir		= vfat_rmdir,
 	.rename		= vfat_rename,
 	.setattr	= fat_setattr,
 	.getattr	= fat_getattr,
 };
 static void setup(struct super_block *sb)
 {
 	MSDOS_SB(sb)->dir_ops = &vfat_dir_inode_operations;
 	if (MSDOS_SB(sb)->options.name_check != 's')
 		sb->s_d_op = &vfat_ci_dentry_ops;
 	else
 		sb->s_d_op = &vfat_dentry_ops;
 }
 static int vfat_fill_super(struct super_block *sb, void *data, int silent)
 {
 	return fat_fill_super(sb, data, silent, 1, setup);
 }
 static struct dentry *vfat_mount(struct file_system_type *fs_type,
 		       int flags, const char *dev_name,
 		       void *data)
 {
 	return mount_bdev(fs_type, flags, dev_name, data, vfat_fill_super);
 }
 static struct file_system_type vfat_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "vfat",
 	.mount		= vfat_mount,
 	.kill_sb	= kill_block_super,
 	.fs_flags	= FS_REQUIRES_DEV,
 };
 static int __init init_vfat_fs(void)
 {
 	return register_filesystem(&vfat_fs_type);
 }
 static void __exit exit_vfat_fs(void)
 {
 	unregister_filesystem(&vfat_fs_type);
 }
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("VFAT filesystem support");
 MODULE_AUTHOR("Gordon Chaffee");
 module_init(init_vfat_fs)
 module_exit(exit_vfat_fs)

fs/jfs/namei.c

Diff comments View file @ 407938e

 /*
  *   Copyright (C) International Business Machines Corp., 2000-2004
  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   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.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program;  if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 #include <linux/fs.h>
 #include <linux/namei.h>
 #include <linux/ctype.h>
 #include <linux/quotaops.h>
 #include <linux/exportfs.h>
 #include "jfs_incore.h"
 #include "jfs_superblock.h"
 #include "jfs_inode.h"
 #include "jfs_dinode.h"
 #include "jfs_dmap.h"
 #include "jfs_unicode.h"
 #include "jfs_metapage.h"
 #include "jfs_xattr.h"
 #include "jfs_acl.h"
 #include "jfs_debug.h"
 /*
  * forward references
  */
 const struct dentry_operations jfs_ci_dentry_operations;
 static s64 commitZeroLink(tid_t, struct inode *);
 /*
  * NAME:	free_ea_wmap(inode)
  *
  * FUNCTION:	free uncommitted extended attributes from working map
  *
  */
 static inline void free_ea_wmap(struct inode *inode)
 {
 	dxd_t *ea = &JFS_IP(inode)->ea;
 	if (ea->flag & DXD_EXTENT) {
 		/* free EA pages from cache */
 		invalidate_dxd_metapages(inode, *ea);
 		dbFree(inode, addressDXD(ea), lengthDXD(ea));
 	}
 	ea->flag = 0;
 }
 /*
  * NAME:	jfs_create(dip, dentry, mode)
  *
  * FUNCTION:	create a regular file in the parent directory <dip>
  *		with name = <from dentry> and mode = <mode>
  *
  * PARAMETER:	dip	- parent directory vnode
  *		dentry	- dentry of new file
  *		mode	- create mode (rwxrwxrwx).
  *		nd- nd struct
  *
  * RETURN:	Errors from subroutines
  *
  */
 static int jfs_create(struct inode *dip, struct dentry *dentry, int mode,
 		struct nameidata *nd)
 {
 	int rc = 0;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = NULL;	/* child directory inode */
 	ino_t ino;
 	struct component_name dname;	/* child directory name */
 	struct btstack btstack;
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	jfs_info("jfs_create: dip:0x%p name:%s", dip, dentry->d_name.name);
 	dquot_initialize(dip);
 	/*
 	 * search parent directory for entry/freespace
 	 * (dtSearch() returns parent directory page pinned)
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out1;
 	/*
 	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we
 	 * block there while holding dtree page, so we allocate the inode &
 	 * begin the transaction before we search the directory.
 	 */
 	ip = ialloc(dip, mode);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out2;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_acl(tid, ip, dip);
 	if (rc)
 		goto out3;
 	rc = jfs_init_security(tid, ip, dip, &dentry->d_name);
 	if (rc) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {
 		jfs_err("jfs_create: dtSearch returned %d", rc);
 		txAbort(tid, 0);
 		goto out3;
 	}
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	iplist[0] = dip;
 	iplist[1] = ip;
 	/*
 	 * initialize the child XAD tree root in-line in inode
 	 */
 	xtInitRoot(tid, ip);
 	/*
 	 * create entry in parent directory for child directory
 	 * (dtInsert() releases parent directory page)
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {
 		if (rc == -EIO) {
 			jfs_err("jfs_create: dtInsert returned -EIO");
 			txAbort(tid, 1);	/* Marks Filesystem dirty */
 		} else
 			txAbort(tid, 0);	/* Filesystem full */
 		goto out3;
 	}
 	ip->i_op = &jfs_file_inode_operations;
 	ip->i_fop = &jfs_file_operations;
 	ip->i_mapping->a_ops = &jfs_aops;
 	mark_inode_dirty(ip);
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	rc = txCommit(tid, 2, &iplist[0], 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		unlock_new_inode(ip);
 		iput(ip);
 	} else {
 		d_instantiate(dentry, ip);
 		unlock_new_inode(ip);
 	}
       out2:
 	free_UCSname(&dname);
       out1:
 	jfs_info("jfs_create: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_mkdir(dip, dentry, mode)
  *
  * FUNCTION:	create a child directory in the parent directory <dip>
  *		with name = <from dentry> and mode = <mode>
  *
  * PARAMETER:	dip	- parent directory vnode
  *		dentry	- dentry of child directory
  *		mode	- create mode (rwxrwxrwx).
  *
  * RETURN:	Errors from subroutines
  *
  * note:
  * EACCESS: user needs search+write permission on the parent directory
  */
 static int jfs_mkdir(struct inode *dip, struct dentry *dentry, int mode)
 {
 	int rc = 0;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = NULL;	/* child directory inode */
 	ino_t ino;
 	struct component_name dname;	/* child directory name */
 	struct btstack btstack;
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	jfs_info("jfs_mkdir: dip:0x%p name:%s", dip, dentry->d_name.name);
 	dquot_initialize(dip);
 	/* link count overflow on parent directory ? */
 	if (dip->i_nlink == JFS_LINK_MAX) {
 		rc = -EMLINK;
 		goto out1;
 	}
 	/*
 	 * search parent directory for entry/freespace
 	 * (dtSearch() returns parent directory page pinned)
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out1;
 	/*
 	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we
 	 * block there while holding dtree page, so we allocate the inode &
 	 * begin the transaction before we search the directory.
 	 */
 	ip = ialloc(dip, S_IFDIR | mode);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out2;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_acl(tid, ip, dip);
 	if (rc)
 		goto out3;
 	rc = jfs_init_security(tid, ip, dip, &dentry->d_name);
 	if (rc) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {
 		jfs_err("jfs_mkdir: dtSearch returned %d", rc);
 		txAbort(tid, 0);
 		goto out3;
 	}
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	iplist[0] = dip;
 	iplist[1] = ip;
 	/*
 	 * initialize the child directory in-line in inode
 	 */
 	dtInitRoot(tid, ip, dip->i_ino);
 	/*
 	 * create entry in parent directory for child directory
 	 * (dtInsert() releases parent directory page)
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {
 		if (rc == -EIO) {
 			jfs_err("jfs_mkdir: dtInsert returned -EIO");
 			txAbort(tid, 1);	/* Marks Filesystem dirty */
 		} else
 			txAbort(tid, 0);	/* Filesystem full */
 		goto out3;
 	}
 	ip->i_nlink = 2;	/* for '.' */
 	ip->i_op = &jfs_dir_inode_operations;
 	ip->i_fop = &jfs_dir_operations;
 	mark_inode_dirty(ip);
 	/* update parent directory inode */
 	inc_nlink(dip);		/* for '..' from child directory */
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	rc = txCommit(tid, 2, &iplist[0], 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		unlock_new_inode(ip);
 		iput(ip);
 	} else {
 		d_instantiate(dentry, ip);
 		unlock_new_inode(ip);
 	}
       out2:
 	free_UCSname(&dname);
       out1:
 	jfs_info("jfs_mkdir: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_rmdir(dip, dentry)
  *
  * FUNCTION:	remove a link to child directory
  *
  * PARAMETER:	dip	- parent inode
  *		dentry	- child directory dentry
  *
  * RETURN:	-EINVAL	- if name is . or ..
  *		-EINVAL - if . or .. exist but are invalid.
  *		errors from subroutines
  *
  * note:
  * if other threads have the directory open when the last link
  * is removed, the "." and ".." entries, if present, are removed before
  * rmdir() returns and no new entries may be created in the directory,
  * but the directory is not removed until the last reference to
  * the directory is released (cf.unlink() of regular file).
  */
 static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
 {
 	int rc;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = dentry->d_inode;
 	ino_t ino;
 	struct component_name dname;
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);
 	/* Init inode for quota operations. */
 	dquot_initialize(dip);
 	dquot_initialize(ip);
 	/* directory must be empty to be removed */
 	if (!dtEmpty(ip)) {
 		rc = -ENOTEMPTY;
 		goto out;
 	}
 	if ((rc = get_UCSname(&dname, dentry))) {
 		goto out;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	iplist[0] = dip;
 	iplist[1] = ip;
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_DELETE;
 	tblk->u.ip = ip;
 	/*
 	 * delete the entry of target directory from parent directory
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {
 		jfs_err("jfs_rmdir: dtDelete returned %d", rc);
 		if (rc == -EIO)
 			txAbort(tid, 1);
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
 		mutex_unlock(&JFS_IP(dip)->commit_mutex);
 		goto out2;
 	}
 	/* update parent directory's link count corresponding
 	 * to ".." entry of the target directory deleted
 	 */
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	inode_dec_link_count(dip);
 	/*
 	 * OS/2 could have created EA and/or ACL
 	 */
 	/* free EA from both persistent and working map */
 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {
 		/* free EA pages */
 		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);
 	}
 	JFS_IP(ip)->ea.flag = 0;
 	/* free ACL from both persistent and working map */
 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {
 		/* free ACL pages */
 		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);
 	}
 	JFS_IP(ip)->acl.flag = 0;
 	/* mark the target directory as deleted */
 	clear_nlink(ip);
 	mark_inode_dirty(ip);
 	rc = txCommit(tid, 2, &iplist[0], 0);
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	/*
 	 * Truncating the directory index table is not guaranteed.  It
 	 * may need to be done iteratively
 	 */
 	if (test_cflag(COMMIT_Stale, dip)) {
 		if (dip->i_size > 1)
 			jfs_truncate_nolock(dip, 0);
 		clear_cflag(COMMIT_Stale, dip);
 	}
       out2:
 	free_UCSname(&dname);
       out:
 	jfs_info("jfs_rmdir: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_unlink(dip, dentry)
  *
  * FUNCTION:	remove a link to object <vp> named by <name>
  *		from parent directory <dvp>
  *
  * PARAMETER:	dip	- inode of parent directory
  *		dentry	- dentry of object to be removed
  *
  * RETURN:	errors from subroutines
  *
  * note:
  * temporary file: if one or more processes have the file open
  * when the last link is removed, the link will be removed before
  * unlink() returns, but the removal of the file contents will be
  * postponed until all references to the files are closed.
  *
  * JFS does NOT support unlink() on directories.
  *
  */
 static int jfs_unlink(struct inode *dip, struct dentry *dentry)
 {
 	int rc;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = dentry->d_inode;
 	ino_t ino;
 	struct component_name dname;	/* object name */
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	s64 new_size = 0;
 	int commit_flag;
 	jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name);
 	/* Init inode for quota operations. */
 	dquot_initialize(dip);
 	dquot_initialize(ip);
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out;
 	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	iplist[0] = dip;
 	iplist[1] = ip;
 	/*
 	 * delete the entry of target file from parent directory
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {
 		jfs_err("jfs_unlink: dtDelete returned %d", rc);
 		if (rc == -EIO)
 			txAbort(tid, 1);	/* Marks FS Dirty */
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
 		mutex_unlock(&JFS_IP(dip)->commit_mutex);
 		IWRITE_UNLOCK(ip);
 		goto out1;
 	}
 	ASSERT(ip->i_nlink);
 	ip->i_ctime = dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	/* update target's inode */
 	inode_dec_link_count(ip);
 	/*
 	 *	commit zero link count object
 	 */
 	if (ip->i_nlink == 0) {
 		assert(!test_cflag(COMMIT_Nolink, ip));
 		/* free block resources */
 		if ((new_size = commitZeroLink(tid, ip)) < 0) {
 			txAbort(tid, 1);	/* Marks FS Dirty */
 			txEnd(tid);
 			mutex_unlock(&JFS_IP(ip)->commit_mutex);
 			mutex_unlock(&JFS_IP(dip)->commit_mutex);
 			IWRITE_UNLOCK(ip);
 			rc = new_size;
 			goto out1;
 		}
 		tblk = tid_to_tblock(tid);
 		tblk->xflag |= COMMIT_DELETE;
 		tblk->u.ip = ip;
 	}
 	/*
 	 * Incomplete truncate of file data can
 	 * result in timing problems unless we synchronously commit the
 	 * transaction.
 	 */
 	if (new_size)
 		commit_flag = COMMIT_SYNC;
 	else
 		commit_flag = 0;
 	/*
 	 * If xtTruncate was incomplete, commit synchronously to avoid
 	 * timing complications
 	 */
 	rc = txCommit(tid, 2, &iplist[0], commit_flag);
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	while (new_size && (rc == 0)) {
 		tid = txBegin(dip->i_sb, 0);
 		mutex_lock(&JFS_IP(ip)->commit_mutex);
 		new_size = xtTruncate_pmap(tid, ip, new_size);
 		if (new_size < 0) {
 			txAbort(tid, 1);	/* Marks FS Dirty */
 			rc = new_size;
 		} else
 			rc = txCommit(tid, 2, &iplist[0], COMMIT_SYNC);
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	}
 	if (ip->i_nlink == 0)
 		set_cflag(COMMIT_Nolink, ip);
 	IWRITE_UNLOCK(ip);
 	/*
 	 * Truncating the directory index table is not guaranteed.  It
 	 * may need to be done iteratively
 	 */
 	if (test_cflag(COMMIT_Stale, dip)) {
 		if (dip->i_size > 1)
 			jfs_truncate_nolock(dip, 0);
 		clear_cflag(COMMIT_Stale, dip);
 	}
       out1:
 	free_UCSname(&dname);
       out:
 	jfs_info("jfs_unlink: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	commitZeroLink()
  *
  * FUNCTION:	for non-directory, called by jfs_remove(),
  *		truncate a regular file, directory or symbolic
  *		link to zero length. return 0 if type is not
  *		one of these.
  *
  *		if the file is currently associated with a VM segment
  *		only permanent disk and inode map resources are freed,
  *		and neither the inode nor indirect blocks are modified
  *		so that the resources can be later freed in the work
  *		map by ctrunc1.
  *		if there is no VM segment on entry, the resources are
  *		freed in both work and permanent map.
  *		(? for temporary file - memory object is cached even
  *		after no reference:
  *		reference count > 0 -   )
  *
  * PARAMETERS:	cd	- pointer to commit data structure.
  *			  current inode is the one to truncate.
  *
  * RETURN:	Errors from subroutines
  */
 static s64 commitZeroLink(tid_t tid, struct inode *ip)
 {
 	int filetype;
 	struct tblock *tblk;
 	jfs_info("commitZeroLink: tid = %d, ip = 0x%p", tid, ip);
 	filetype = ip->i_mode & S_IFMT;
 	switch (filetype) {
 	case S_IFREG:
 		break;
 	case S_IFLNK:
 		/* fast symbolic link */
 		if (ip->i_size < IDATASIZE) {
 			ip->i_size = 0;
 			return 0;
 		}
 		break;
 	default:
 		assert(filetype != S_IFDIR);
 		return 0;
 	}
 	set_cflag(COMMIT_Freewmap, ip);
 	/* mark transaction of block map update type */
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_PMAP;
 	/*
 	 * free EA
 	 */
 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT)
 		/* acquire maplock on EA to be freed from block map */
 		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);
 	/*
 	 * free ACL
 	 */
 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT)
 		/* acquire maplock on EA to be freed from block map */
 		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);
 	/*
 	 * free xtree/data (truncate to zero length):
 	 * free xtree/data pages from cache if COMMIT_PWMAP,
 	 * free xtree/data blocks from persistent block map, and
 	 * free xtree/data blocks from working block map if COMMIT_PWMAP;
 	 */
 	if (ip->i_size)
 		return xtTruncate_pmap(tid, ip, 0);
 	return 0;
 }
 /*
  * NAME:	jfs_free_zero_link()
  *
  * FUNCTION:	for non-directory, called by iClose(),
  *		free resources of a file from cache and WORKING map
  *		for a file previously committed with zero link count
  *		while associated with a pager object,
  *
  * PARAMETER:	ip	- pointer to inode of file.
  */
 void jfs_free_zero_link(struct inode *ip)
 {
 	int type;
 	jfs_info("jfs_free_zero_link: ip = 0x%p", ip);
 	/* return if not reg or symbolic link or if size is
 	 * already ok.
 	 */
 	type = ip->i_mode & S_IFMT;
 	switch (type) {
 	case S_IFREG:
 		break;
 	case S_IFLNK:
 		/* if its contained in inode nothing to do */
 		if (ip->i_size < IDATASIZE)
 			return;
 		break;
 	default:
 		return;
 	}
 	/*
 	 * free EA
 	 */
 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {
 		s64 xaddr = addressDXD(&JFS_IP(ip)->ea);
 		int xlen = lengthDXD(&JFS_IP(ip)->ea);
 		struct maplock maplock;	/* maplock for COMMIT_WMAP */
 		struct pxd_lock *pxdlock;	/* maplock for COMMIT_WMAP */
 		/* free EA pages from cache */
 		invalidate_dxd_metapages(ip, JFS_IP(ip)->ea);
 		/* free EA extent from working block map */
 		maplock.index = 1;
 		pxdlock = (struct pxd_lock *) & maplock;
 		pxdlock->flag = mlckFREEPXD;
 		PXDaddress(&pxdlock->pxd, xaddr);
 		PXDlength(&pxdlock->pxd, xlen);
 		txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
 	}
 	/*
 	 * free ACL
 	 */
 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {
 		s64 xaddr = addressDXD(&JFS_IP(ip)->acl);
 		int xlen = lengthDXD(&JFS_IP(ip)->acl);
 		struct maplock maplock;	/* maplock for COMMIT_WMAP */
 		struct pxd_lock *pxdlock;	/* maplock for COMMIT_WMAP */
 		invalidate_dxd_metapages(ip, JFS_IP(ip)->acl);
 		/* free ACL extent from working block map */
 		maplock.index = 1;
 		pxdlock = (struct pxd_lock *) & maplock;
 		pxdlock->flag = mlckFREEPXD;
 		PXDaddress(&pxdlock->pxd, xaddr);
 		PXDlength(&pxdlock->pxd, xlen);
 		txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
 	}
 	/*
 	 * free xtree/data (truncate to zero length):
 	 * free xtree/data pages from cache, and
 	 * free xtree/data blocks from working block map;
 	 */
 	if (ip->i_size)
 		xtTruncate(0, ip, 0, COMMIT_WMAP);
 }
 /*
  * NAME:	jfs_link(vp, dvp, name, crp)
  *
  * FUNCTION:	create a link to <vp> by the name = <name>
  *		in the parent directory <dvp>
  *
  * PARAMETER:	vp	- target object
  *		dvp	- parent directory of new link
  *		name	- name of new link to target object
  *		crp	- credential
  *
  * RETURN:	Errors from subroutines
  *
  * note:
  * JFS does NOT support link() on directories (to prevent circular
  * path in the directory hierarchy);
  * EPERM: the target object is a directory, and either the caller
  * does not have appropriate privileges or the implementation prohibits
  * using link() on directories [XPG4.2].
  *
  * JFS does NOT support links between file systems:
  * EXDEV: target object and new link are on different file systems and
  * implementation does not support links between file systems [XPG4.2].
  */
 static int jfs_link(struct dentry *old_dentry,
 	     struct inode *dir, struct dentry *dentry)
 {
 	int rc;
 	tid_t tid;
 	struct inode *ip = old_dentry->d_inode;
 	ino_t ino;
 	struct component_name dname;
 	struct btstack btstack;
 	struct inode *iplist[2];
 	jfs_info("jfs_link: %s %s", old_dentry->d_name.name,
 		 dentry->d_name.name);
 	if (ip->i_nlink == JFS_LINK_MAX)
 		return -EMLINK;
 	dquot_initialize(dir);
 	tid = txBegin(ip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	/*
 	 * scan parent directory for entry/freespace
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out;
 	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))
 		goto free_dname;
 	/*
 	 * create entry for new link in parent directory
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))
 		goto free_dname;
 	/* update object inode */
 	inc_nlink(ip);		/* for new link */
 	ip->i_ctime = CURRENT_TIME;
 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dir);
 	ihold(ip);
 	iplist[0] = ip;
 	iplist[1] = dir;
 	rc = txCommit(tid, 2, &iplist[0], 0);
 	if (rc) {
 		ip->i_nlink--; /* never instantiated */
 		iput(ip);
 	} else
 		d_instantiate(dentry, ip);
       free_dname:
 	free_UCSname(&dname);
       out:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dir)->commit_mutex);
 	jfs_info("jfs_link: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_symlink(dip, dentry, name)
  *
  * FUNCTION:	creates a symbolic link to <symlink> by name <name>
  *			in directory <dip>
  *
  * PARAMETER:	dip	- parent directory vnode
  *		dentry	- dentry of symbolic link
  *		name	- the path name of the existing object
  *			  that will be the source of the link
  *
  * RETURN:	errors from subroutines
  *
  * note:
  * ENAMETOOLONG: pathname resolution of a symbolic link produced
  * an intermediate result whose length exceeds PATH_MAX [XPG4.2]
 */
 static int jfs_symlink(struct inode *dip, struct dentry *dentry,
 		const char *name)
 {
 	int rc;
 	tid_t tid;
 	ino_t ino = 0;
 	struct component_name dname;
 	int ssize;		/* source pathname size */
 	struct btstack btstack;
 	struct inode *ip = dentry->d_inode;
 	unchar *i_fastsymlink;
 	s64 xlen = 0;
 	int bmask = 0, xsize;
 	s64 extent = 0, xaddr;
 	struct metapage *mp;
 	struct super_block *sb;
 	struct tblock *tblk;
 	struct inode *iplist[2];
 	jfs_info("jfs_symlink: dip:0x%p name:%s", dip, name);
 	dquot_initialize(dip);
 	ssize = strlen(name) + 1;
 	/*
 	 * search parent directory for entry/freespace
 	 * (dtSearch() returns parent directory page pinned)
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out1;
 	/*
 	 * allocate on-disk/in-memory inode for symbolic link:
 	 * (iAlloc() returns new, locked inode)
 	 */
 	ip = ialloc(dip, S_IFLNK | 0777);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out2;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_security(tid, ip, dip, &dentry->d_name);
 	if (rc)
 		goto out3;
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	/* fix symlink access permission
 	 * (dir_create() ANDs in the u.u_cmask,
 	 * but symlinks really need to be 777 access)
 	 */
 	ip->i_mode |= 0777;
 	/*
 	 * write symbolic link target path name
 	 */
 	xtInitRoot(tid, ip);
 	/*
 	 * write source path name inline in on-disk inode (fast symbolic link)
 	 */
 	if (ssize <= IDATASIZE) {
 		ip->i_op = &jfs_fast_symlink_inode_operations;
 		i_fastsymlink = JFS_IP(ip)->i_inline;
 		memcpy(i_fastsymlink, name, ssize);
 		ip->i_size = ssize - 1;
 		/*
 		 * if symlink is > 128 bytes, we don't have the space to
 		 * store inline extended attributes
 		 */
 		if (ssize > sizeof (JFS_IP(ip)->i_inline))
 			JFS_IP(ip)->mode2 &= ~INLINEEA;
 		jfs_info("jfs_symlink: fast symlink added  ssize:%d name:%s ",
 			 ssize, name);
 	}
 	/*
 	 * write source path name in a single extent
 	 */
 	else {
 		jfs_info("jfs_symlink: allocate extent ip:0x%p", ip);
 		ip->i_op = &jfs_symlink_inode_operations;
 		ip->i_mapping->a_ops = &jfs_aops;
 		/*
 		 * even though the data of symlink object (source
 		 * path name) is treated as non-journaled user data,
 		 * it is read/written thru buffer cache for performance.
 		 */
 		sb = ip->i_sb;
 		bmask = JFS_SBI(sb)->bsize - 1;
 		xsize = (ssize + bmask) & ~bmask;
 		xaddr = 0;
 		xlen = xsize >> JFS_SBI(sb)->l2bsize;
 		if ((rc = xtInsert(tid, ip, 0, 0, xlen, &xaddr, 0))) {
 			txAbort(tid, 0);
 			goto out3;
 		}
 		extent = xaddr;
 		ip->i_size = ssize - 1;
 		while (ssize) {
 			/* This is kind of silly since PATH_MAX == 4K */
 			int copy_size = min(ssize, PSIZE);
 			mp = get_metapage(ip, xaddr, PSIZE, 1);
 			if (mp == NULL) {
 				xtTruncate(tid, ip, 0, COMMIT_PWMAP);
 				rc = -EIO;
 				txAbort(tid, 0);
 				goto out3;
 			}
 			memcpy(mp->data, name, copy_size);
 			flush_metapage(mp);
 			ssize -= copy_size;
 			name += copy_size;
 			xaddr += JFS_SBI(sb)->nbperpage;
 		}
 	}
 	/*
 	 * create entry for symbolic link in parent directory
 	 */
 	rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE);
 	if (rc == 0) {
 		ino = ip->i_ino;
 		rc = dtInsert(tid, dip, &dname, &ino, &btstack);
 	}
 	if (rc) {
 		if (xlen)
 			xtTruncate(tid, ip, 0, COMMIT_PWMAP);
 		txAbort(tid, 0);
 		/* discard new inode */
 		goto out3;
 	}
 	mark_inode_dirty(ip);
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	/*
 	 * commit update of parent directory and link object
 	 */
 	iplist[0] = dip;
 	iplist[1] = ip;
 	rc = txCommit(tid, 2, &iplist[0], 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		unlock_new_inode(ip);
 		iput(ip);
 	} else {
 		d_instantiate(dentry, ip);
 		unlock_new_inode(ip);
 	}
       out2:
 	free_UCSname(&dname);
       out1:
 	jfs_info("jfs_symlink: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_rename
  *
  * FUNCTION:	rename a file or directory
  */
 static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 	       struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct btstack btstack;
 	ino_t ino;
 	struct component_name new_dname;
 	struct inode *new_ip;
 	struct component_name old_dname;
 	struct inode *old_ip;
 	int rc;
 	tid_t tid;
 	struct tlock *tlck;
 	struct dt_lock *dtlck;
 	struct lv *lv;
 	int ipcount;
 	struct inode *iplist[4];
 	struct tblock *tblk;
 	s64 new_size = 0;
 	int commit_flag;
 	jfs_info("jfs_rename: %s %s", old_dentry->d_name.name,
 		 new_dentry->d_name.name);
 	dquot_initialize(old_dir);
 	dquot_initialize(new_dir);
 	old_ip = old_dentry->d_inode;
 	new_ip = new_dentry->d_inode;
 	if ((rc = get_UCSname(&old_dname, old_dentry)))
 		goto out1;
 	if ((rc = get_UCSname(&new_dname, new_dentry)))
 		goto out2;
 	/*
 	 * Make sure source inode number is what we think it is
 	 */
 	rc = dtSearch(old_dir, &old_dname, &ino, &btstack, JFS_LOOKUP);
 	if (rc || (ino != old_ip->i_ino)) {
 		rc = -ENOENT;
 		goto out3;
 	}
 	/*
 	 * Make sure dest inode number (if any) is what we think it is
 	 */
 	rc = dtSearch(new_dir, &new_dname, &ino, &btstack, JFS_LOOKUP);
 	if (!rc) {
 		if ((!new_ip) || (ino != new_ip->i_ino)) {
 			rc = -ESTALE;
 			goto out3;
 		}
 	} else if (rc != -ENOENT)
 		goto out3;
 	else if (new_ip) {
 		/* no entry exists, but one was expected */
 		rc = -ESTALE;
 		goto out3;
 	}
 	if (S_ISDIR(old_ip->i_mode)) {
 		if (new_ip) {
 			if (!dtEmpty(new_ip)) {
 				rc = -ENOTEMPTY;
 				goto out3;
 			}
 		} else if ((new_dir != old_dir) &&
 			   (new_dir->i_nlink == JFS_LINK_MAX)) {
 			rc = -EMLINK;
 			goto out3;
 		}
 	} else if (new_ip) {
 		IWRITE_LOCK(new_ip, RDWRLOCK_NORMAL);
 		/* Init inode for quota operations. */
 		dquot_initialize(new_ip);
 	}
 	/*
 	 * The real work starts here
 	 */
 	tid = txBegin(new_dir->i_sb, 0);
 	/*
 	 * How do we know the locking is safe from deadlocks?
 	 * The vfs does the hard part for us.  Any time we are taking nested
 	 * commit_mutexes, the vfs already has i_mutex held on the parent.
 	 * Here, the vfs has already taken i_mutex on both old_dir and new_dir.
 	 */
 	mutex_lock_nested(&JFS_IP(new_dir)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(old_ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	if (old_dir != new_dir)
 		mutex_lock_nested(&JFS_IP(old_dir)->commit_mutex,
 				  COMMIT_MUTEX_SECOND_PARENT);
 	if (new_ip) {
 		mutex_lock_nested(&JFS_IP(new_ip)->commit_mutex,
 				  COMMIT_MUTEX_VICTIM);
 		/*
 		 * Change existing directory entry to new inode number
 		 */
 		ino = new_ip->i_ino;
 		rc = dtModify(tid, new_dir, &new_dname, &ino,
 			      old_ip->i_ino, JFS_RENAME);
 		if (rc)
 			goto out4;
 		drop_nlink(new_ip);
 		if (S_ISDIR(new_ip->i_mode)) {
 			drop_nlink(new_ip);
 			if (new_ip->i_nlink) {
 				mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
 				if (old_dir != new_dir)
 					mutex_unlock(&JFS_IP(old_dir)->commit_mutex);
 				mutex_unlock(&JFS_IP(old_ip)->commit_mutex);
 				mutex_unlock(&JFS_IP(new_dir)->commit_mutex);
 				if (!S_ISDIR(old_ip->i_mode) && new_ip)
 					IWRITE_UNLOCK(new_ip);
 				jfs_error(new_ip->i_sb,
 					  "jfs_rename: new_ip->i_nlink != 0");
 				return -EIO;
 			}
 			tblk = tid_to_tblock(tid);
 			tblk->xflag |= COMMIT_DELETE;
 			tblk->u.ip = new_ip;
 		} else if (new_ip->i_nlink == 0) {
 			assert(!test_cflag(COMMIT_Nolink, new_ip));
 			/* free block resources */
 			if ((new_size = commitZeroLink(tid, new_ip)) < 0) {
 				txAbort(tid, 1);	/* Marks FS Dirty */
 				rc = new_size;
 				goto out4;
 			}
 			tblk = tid_to_tblock(tid);
 			tblk->xflag |= COMMIT_DELETE;
 			tblk->u.ip = new_ip;
 		} else {
 			new_ip->i_ctime = CURRENT_TIME;
 			mark_inode_dirty(new_ip);
 		}
 	} else {
 		/*
 		 * Add new directory entry
 		 */
 		rc = dtSearch(new_dir, &new_dname, &ino, &btstack,
 			      JFS_CREATE);
 		if (rc) {
 			jfs_err("jfs_rename didn't expect dtSearch to fail "
 				"w/rc = %d", rc);
 			goto out4;
 		}
 		ino = old_ip->i_ino;
 		rc = dtInsert(tid, new_dir, &new_dname, &ino, &btstack);
 		if (rc) {
 			if (rc == -EIO)
 				jfs_err("jfs_rename: dtInsert returned -EIO");
 			goto out4;
 		}
 		if (S_ISDIR(old_ip->i_mode))
 			inc_nlink(new_dir);
 	}
 	/*
 	 * Remove old directory entry
 	 */
 	ino = old_ip->i_ino;
 	rc = dtDelete(tid, old_dir, &old_dname, &ino, JFS_REMOVE);
 	if (rc) {
 		jfs_err("jfs_rename did not expect dtDelete to return rc = %d",
 			rc);
 		txAbort(tid, 1);	/* Marks Filesystem dirty */
 		goto out4;
 	}
 	if (S_ISDIR(old_ip->i_mode)) {
 		drop_nlink(old_dir);
 		if (old_dir != new_dir) {
 			/*
 			 * Change inode number of parent for moved directory
 			 */
 			JFS_IP(old_ip)->i_dtroot.header.idotdot =
 				cpu_to_le32(new_dir->i_ino);
 			/* Linelock header of dtree */
 			tlck = txLock(tid, old_ip,
 				    (struct metapage *) &JFS_IP(old_ip)->bxflag,
 				      tlckDTREE | tlckBTROOT | tlckRELINK);
 			dtlck = (struct dt_lock *) & tlck->lock;
 			ASSERT(dtlck->index == 0);
 			lv = & dtlck->lv[0];
 			lv->offset = 0;
 			lv->length = 1;
 			dtlck->index++;
 		}
 	}
 	/*
 	 * Update ctime on changed/moved inodes & mark dirty
 	 */
 	old_ip->i_ctime = CURRENT_TIME;
 	mark_inode_dirty(old_ip);
 	new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb);
 	mark_inode_dirty(new_dir);
 	/* Build list of inodes modified by this transaction */
 	ipcount = 0;
 	iplist[ipcount++] = old_ip;
 	if (new_ip)
 		iplist[ipcount++] = new_ip;
 	iplist[ipcount++] = old_dir;
 	if (old_dir != new_dir) {
 		iplist[ipcount++] = new_dir;
 		old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
 		mark_inode_dirty(old_dir);
 	}
 	/*
 	 * Incomplete truncate of file data can
 	 * result in timing problems unless we synchronously commit the
 	 * transaction.
 	 */
 	if (new_size)
 		commit_flag = COMMIT_SYNC;
 	else
 		commit_flag = 0;
 	rc = txCommit(tid, ipcount, iplist, commit_flag);
       out4:
 	txEnd(tid);
 	if (new_ip)
 		mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
 	if (old_dir != new_dir)
 		mutex_unlock(&JFS_IP(old_dir)->commit_mutex);
 	mutex_unlock(&JFS_IP(old_ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(new_dir)->commit_mutex);
 	while (new_size && (rc == 0)) {
 		tid = txBegin(new_ip->i_sb, 0);
 		mutex_lock(&JFS_IP(new_ip)->commit_mutex);
 		new_size = xtTruncate_pmap(tid, new_ip, new_size);
 		if (new_size < 0) {
 			txAbort(tid, 1);
 			rc = new_size;
 		} else
 			rc = txCommit(tid, 1, &new_ip, COMMIT_SYNC);
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
 	}
 	if (new_ip && (new_ip->i_nlink == 0))
 		set_cflag(COMMIT_Nolink, new_ip);
       out3:
 	free_UCSname(&new_dname);
       out2:
 	free_UCSname(&old_dname);
       out1:
 	if (new_ip && !S_ISDIR(new_ip->i_mode))
 		IWRITE_UNLOCK(new_ip);
 	/*
 	 * Truncating the directory index table is not guaranteed.  It
 	 * may need to be done iteratively
 	 */
 	if (test_cflag(COMMIT_Stale, old_dir)) {
 		if (old_dir->i_size > 1)
 			jfs_truncate_nolock(old_dir, 0);
 		clear_cflag(COMMIT_Stale, old_dir);
 	}
 	jfs_info("jfs_rename: returning %d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_mknod
  *
  * FUNCTION:	Create a special file (device)
  */
 static int jfs_mknod(struct inode *dir, struct dentry *dentry,
 		int mode, dev_t rdev)
 {
 	struct jfs_inode_info *jfs_ip;
 	struct btstack btstack;
 	struct component_name dname;
 	ino_t ino;
 	struct inode *ip;
 	struct inode *iplist[2];
 	int rc;
 	tid_t tid;
 	struct tblock *tblk;
 	if (!new_valid_dev(rdev))
 		return -EINVAL;
 	jfs_info("jfs_mknod: %s", dentry->d_name.name);
 	dquot_initialize(dir);
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out;
 	ip = ialloc(dir, mode);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out1;
 	}
 	jfs_ip = JFS_IP(ip);
 	tid = txBegin(dir->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_acl(tid, ip, dir);
 	if (rc)
 		goto out3;
 	rc = jfs_init_security(tid, ip, dir, &dentry->d_name);
 	if (rc) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE))) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack))) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	ip->i_op = &jfs_file_inode_operations;
 	jfs_ip->dev = new_encode_dev(rdev);
 	init_special_inode(ip, ip->i_mode, rdev);
 	mark_inode_dirty(ip);
 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dir);
 	iplist[0] = dir;
 	iplist[1] = ip;
 	rc = txCommit(tid, 2, iplist, 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dir)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		unlock_new_inode(ip);
 		iput(ip);
 	} else {
 		d_instantiate(dentry, ip);
 		unlock_new_inode(ip);
 	}
       out1:
 	free_UCSname(&dname);
       out:
 	jfs_info("jfs_mknod: returning %d", rc);
 	return rc;
 }
 static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struct nameidata *nd)
 {
 	struct btstack btstack;
 	ino_t inum;
 	struct inode *ip;
 	struct component_name key;
 	const char *name = dentry->d_name.name;
 	int len = dentry->d_name.len;
 	int rc;
 	jfs_info("jfs_lookup: name = %s", name);
 	if ((name[0] == '.') && (len == 1))
 		inum = dip->i_ino;
 	else if (strcmp(name, "..") == 0)
 		inum = PARENT(dip);
 	else {
 		if ((rc = get_UCSname(&key, dentry)))
 			return ERR_PTR(rc);
 		rc = dtSearch(dip, &key, &inum, &btstack, JFS_LOOKUP);
 		free_UCSname(&key);
 		if (rc == -ENOENT) {
 			d_add(dentry, NULL);
 			return NULL;
 		} else if (rc) {
 			jfs_err("jfs_lookup: dtSearch returned %d", rc);
 			return ERR_PTR(rc);
 		}
 	}
 	ip = jfs_iget(dip->i_sb, inum);
 	if (IS_ERR(ip)) {
 		jfs_err("jfs_lookup: iget failed on inum %d", (uint) inum);
 		return ERR_CAST(ip);
 	}
 	return d_splice_alias(ip, dentry);
 }
 static struct inode *jfs_nfs_get_inode(struct super_block *sb,
 		u64 ino, u32 generation)
 {
 	struct inode *inode;
 	if (ino == 0)
 		return ERR_PTR(-ESTALE);
 	inode = jfs_iget(sb, ino);
 	if (IS_ERR(inode))
 		return ERR_CAST(inode);
 	if (generation && inode->i_generation != generation) {
 		iput(inode);
 		return ERR_PTR(-ESTALE);
 	}
 	return inode;
 }
 struct dentry *jfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
 		int fh_len, int fh_type)
 {
 	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
 				    jfs_nfs_get_inode);
 }
 struct dentry *jfs_fh_to_parent(struct super_block *sb, struct fid *fid,
 		int fh_len, int fh_type)
 {
 	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
 				    jfs_nfs_get_inode);
 }
 struct dentry *jfs_get_parent(struct dentry *dentry)
 {
 	unsigned long parent_ino;
 	parent_ino =
 		le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot);
 	return d_obtain_alias(jfs_iget(dentry->d_inode->i_sb, parent_ino));
 }
 const struct inode_operations jfs_dir_inode_operations = {
 	.create		= jfs_create,
 	.lookup		= jfs_lookup,
 	.link		= jfs_link,
 	.unlink		= jfs_unlink,
 	.symlink	= jfs_symlink,
 	.mkdir		= jfs_mkdir,
 	.rmdir		= jfs_rmdir,
 	.mknod		= jfs_mknod,
 	.rename		= jfs_rename,
 	.setxattr	= jfs_setxattr,
 	.getxattr	= jfs_getxattr,
 	.listxattr	= jfs_listxattr,
 	.removexattr	= jfs_removexattr,
 	.setattr	= jfs_setattr,
 #ifdef CONFIG_JFS_POSIX_ACL
 	.check_acl	= jfs_check_acl,
 #endif
 };
 const struct file_operations jfs_dir_operations = {
 	.read		= generic_read_dir,
 	.readdir	= jfs_readdir,
 	.fsync		= jfs_fsync,
 	.unlocked_ioctl = jfs_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl	= jfs_compat_ioctl,
 #endif
 	.llseek		= generic_file_llseek,
 };
 static int jfs_ci_hash(const struct dentry *dir, const struct inode *inode,
 		struct qstr *this)
 {
 	unsigned long hash;
 	int i;
 	hash = init_name_hash();
 	for (i=0; i < this->len; i++)
 		hash = partial_name_hash(tolower(this->name[i]), hash);
 	this->hash = end_name_hash(hash);
 	return 0;
 }
 static int jfs_ci_compare(const struct dentry *parent,
 		const struct inode *pinode,
 		const struct dentry *dentry, const struct inode *inode,
 		unsigned int len, const char *str, const struct qstr *name)
 {
 	int i, result = 1;
 	if (len != name->len)
 		goto out;
 	for (i=0; i < len; i++) {
 		if (tolower(str[i]) != tolower(name->name[i]))
 			goto out;
 	}
 	result = 0;
 out:
 	return result;
 }
 static int jfs_ci_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
 	if (nd && nd->flags & LOOKUP_RCU)
 		return -ECHILD;
 	/*
 	 * This is not negative dentry. Always valid.
 	 *
 	 * Note, rename() to existing directory entry will have ->d_inode,
 	 * and will use existing name which isn't specified name by user.
 	 *
 	 * We may be able to drop this positive dentry here. But dropping
 	 * positive dentry isn't good idea. So it's unsupported like
 	 * rename("filename", "FILENAME") for now.
 	 */
 	if (dentry->d_inode)
 		return 1;
 	/*
 	 * This may be nfsd (or something), anyway, we can't see the
 	 * intent of this. So, since this can be for creation, drop it.
 	 */
 	if (!nd)
 		return 0;
 	/*
 	 * Drop the negative dentry, in order to make sure to use the
 	 * case sensitive name which is specified by user if this is
 	 * for creation.
 	 */
-	if (!(nd->flags & (LOOKUP_CONTINUE | LOOKUP_PARENT))) {
+	if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
-		if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
+		return 0;
-			return 0;
-	}
 	return 1;
 }
 const struct dentry_operations jfs_ci_dentry_operations =
 {
 	.d_hash = jfs_ci_hash,
 	.d_compare = jfs_ci_compare,
 	.d_revalidate = jfs_ci_revalidate,
 };