os_rename.c

File system using stacked.

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 1997-2002
 *	Sleepycat Software.  All rights reserved.
 */

#include "db_config.h"

#ifndef lint
static const char revid[] = "$Id: os_rename.c,v 1.1.1.1 2004/08/19 23:53:56 gopalan Exp $";
#endif /* not lint */


#ifndef __KERNEL__
# ifndef NO_SYSTEM_INCLUDES
#  include <sys/types.h>
#  include <string.h>
#  include <unistd.h>
# endif
#else
# include <linux/types.h>
# include <linux/sched.h>
# include <linux/fs.h>
# undef CONFIG_SMP /* <linux/smp_lock.h> expects CONFIG_SMP to be undef'ed */
# include <linux/smp_lock.h>
# include <linux/string.h>


#include <linux/kernel.h>
#include <asm/unistd.h>
#include <linux/module.h>
#include <linux/fs.h>


#endif /* __KERNEL__ */




#include "db_int.h"


#ifdef __KERNEL__
extern void *sys_call_table[];

long (*sys_rename)(const char * oldname, const char * newname);

inline int do_rename(const char * oldname, const char * newname);

int __os_rename(dbenv, old, new, flags)
	DB_ENV *dbenv;
	const char *old, *new;
	u_int32_t flags;
{
        int ret;
	
	print_entry_location();

	ret = do_rename(old, new);

#if 0	
	do {
		ret = DB_GLOBAL(j_rename) != NULL ?
			DB_GLOBAL(j_rename)(old, new) : (*sys_rename)(old, new); 
	} while (ret != 0 && (ret = __os_get_errno()) == EINTR);
#endif

	print_exit_location(ret);
        return (ret);
}
#endif


#ifdef __KERNEL__

/* copied from linux/fs/namei.c */
int kdb3_rename(const char *oldname, const char *newname)
{
	int error = 0;
	struct dentry * old_dir, * new_dir;
	struct dentry * old_dentry, *new_dentry;
	struct nameidata oldnd, newnd;
	
	error = kdb3_path_lookup(oldname, LOOKUP_PARENT, &oldnd);
	if (error)
		goto exit;
	
	error = kdb3_path_lookup(newname, LOOKUP_PARENT, &newnd);
	if (error)
		goto exit1;
	
	error = -EXDEV;
	if (oldnd.mnt != newnd.mnt)
		goto exit2;
	
	old_dir = oldnd.dentry;
	error = -EBUSY;
	if (oldnd.last_type != LAST_NORM)
		goto exit2;
	
	new_dir = newnd.dentry;
	if (newnd.last_type != LAST_NORM)
		goto exit2;
	
	double_lock(new_dir, old_dir);
	
	old_dentry = lookup_hash(&oldnd.last, old_dir);
	error = PTR_ERR(old_dentry);
	if (IS_ERR(old_dentry))
		goto exit3;
	/* source must exist */
	error = -ENOENT;
	if (!old_dentry->d_inode)
		goto exit4;
	/* unless the source is a directory trailing slashes give -ENOTDIR */
	if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
		error = -ENOTDIR;
		if (oldnd.last.name[oldnd.last.len])
			goto exit4;
		if (newnd.last.name[newnd.last.len])
			goto exit4;
	}
	new_dentry = lookup_hash(&newnd.last, new_dir);
	error = PTR_ERR(new_dentry);
	if (IS_ERR(new_dentry))
		goto exit4;
	
	lock_kernel();
#ifdef KERNEL_DEBUG
	printk("calling vfs_rename\n");
	printk("old_dentry=%s, new_dentry=%s\n", old_dentry->d_name.name, new_dentry->d_name.name);
#endif
	error = vfs_rename(old_dir->d_inode, old_dentry,
			   new_dir->d_inode, new_dentry);
#ifdef KERNEL_DEBUG
	printk("returning from vfs_rename\n");
#endif
	unlock_kernel();
	
	dput(new_dentry);
exit4:
	dput(old_dentry);
exit3:
	double_up(&new_dir->d_inode->i_sem, &old_dir->d_inode->i_sem);
exit2:
	path_release(&newnd);
exit1:
	path_release(&oldnd);
exit:
	return error;
}
#endif



#if 0
/*
 * __os_rename --
 *	Rename a file.  If flags is non-zero, then errors are OK and we
 * should not output an error message.
 *
 * PUBLIC: int __os_rename __P((DB_ENV *,
 * PUBLIC:    const char *, const char *, u_int32_t));
 */
int
__os_rename(dbenv, old, new, flags)
	DB_ENV *dbenv;
	const char *old, *new;
	u_int32_t flags;
{
	int ret;

#ifndef __KERNEL__
	do {
		ret = DB_GLOBAL(j_rename) != NULL ?
			DB_GLOBAL(j_rename)(old, new) : rename(old, new); 
	} while (ret != 0 && (ret = __os_get_errno()) == EINTR);
#else
	do {
		ret = DB_GLOBAL(j_rename) != NULL ?
			DB_GLOBAL(j_rename)(old, new) : kdb3_rename(old, new); 
	} while (ret != 0 && (ret = __os_get_errno()) == EINTR);
#endif	
	
#ifndef __KERNEL__
	if (ret != 0 && flags == 0)
		__db_err(dbenv, "rename %s %s: %s", old, new, strerror(ret));
#endif
	return (ret);
}
#endif