Viewing file:  dir.c (10.45 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* linux/fs/hfs/dir.c
*
* Copyright (C) 1995-1997 Paul H. Hargrove
* This file may be distributed under the terms of the GNU General Public License.
*
* This file contains directory-related functions independent of which
* scheme is being used to represent forks.
*
* Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
*
* "XXX" in a comment is a note to myself to consider changing something.
*
* In function preconditions the term "valid" applied to a pointer to
* a structure means that the pointer is non-NULL and the structure it
* points to has all fields initialized to consistent values.
*/
#include "hfs.h"
#include <linux/hfs_fs_sb.h>
#include <linux/hfs_fs_i.h>
#include <linux/hfs_fs.h>
/*================ File-local functions ================*/
/*
* build_key()
*
* Build a key for a file by the given name in the given directory.
* If the name matches one of the reserved names returns 1 otherwise 0.
*/
static int build_key(struct hfs_cat_key *key, struct inode *dir,
const char *name, int len)
{
struct hfs_name cname;
const struct hfs_name *reserved;
/* mangle the name */
hfs_nameout(dir, &cname, name, len);
/* check against reserved names */
reserved = HFS_SB(dir->i_sb)->s_reserved1;
while (reserved->Len) {
if (hfs_streq(reserved->Name, reserved->Len,
cname.Name, cname.Len)) {
return 1;
}
++reserved;
}
/* check against the names reserved only in the root directory */
if (HFS_I(dir)->entry->cnid == htonl(HFS_ROOT_CNID)) {
reserved = HFS_SB(dir->i_sb)->s_reserved2;
while (reserved->Len) {
if (hfs_streq(reserved->Name, reserved->Len,
cname.Name, cname.Len)) {
return 1;
}
++reserved;
}
}
/* build the key */
hfs_cat_build_key(HFS_I(dir)->entry->cnid, &cname, key);
return 0;
}
/*
* update_dirs_plus()
*
* Update the fields 'i_size', 'i_nlink', 'i_ctime', 'i_mtime' and
* 'i_version' of the inodes associated with a directory that has
* had a file ('is_dir'==0) or directory ('is_dir'!=0) added to it.
*/
static inline void update_dirs_plus(struct hfs_cat_entry *dir, int is_dir)
{
int i;
for (i = 0; i < 4; ++i) {
struct dentry *de = dir->sys_entry[i];
if (de) {
struct inode *tmp = de->d_inode;
if (S_ISDIR(tmp->i_mode)) {
if (is_dir &&
(i == HFS_ITYPE_TO_INT(HFS_ITYPE_NORM))) {
/* In "normal" directory only */
++(tmp->i_nlink);
}
tmp->i_size += HFS_I(tmp)->dir_size;
tmp->i_version = ++event;
}
tmp->i_ctime = tmp->i_mtime = CURRENT_TIME;
mark_inode_dirty(tmp);
}
}
}
/*
* update_dirs_minus()
*
* Update the fields 'i_size', 'i_nlink', 'i_ctime', 'i_mtime' and
* 'i_version' of the inodes associated with a directory that has
* had a file ('is_dir'==0) or directory ('is_dir'!=0) removed.
*/
static inline void update_dirs_minus(struct hfs_cat_entry *dir, int is_dir)
{
int i;
for (i = 0; i < 4; ++i) {
struct dentry *de = dir->sys_entry[i];
if (de) {
struct inode *tmp = de->d_inode;
if (S_ISDIR(tmp->i_mode)) {
if (is_dir &&
(i == HFS_ITYPE_TO_INT(HFS_ITYPE_NORM))) {
/* In "normal" directory only */
--(tmp->i_nlink);
}
tmp->i_size -= HFS_I(tmp)->dir_size;
tmp->i_version = ++event;
}
tmp->i_ctime = tmp->i_mtime = CURRENT_TIME;
mark_inode_dirty(tmp);
}
}
}
/*
* mark_inodes_deleted()
*
* Update inodes associated with a deleted entry to reflect its deletion.
* Well, we really just drop the dentry.
*
* XXX: we should be using delete_inode for some of this stuff.
*/
static inline void mark_inodes_deleted(struct hfs_cat_entry *entry,
struct dentry *dentry)
{
struct dentry *de;
struct inode *tmp;
int i;
for (i = 0; i < 4; ++i) {
if ((de = entry->sys_entry[i]) && (dentry != de)) {
dget(de);
tmp = de->d_inode;
tmp->i_nlink = 0;
tmp->i_ctime = CURRENT_TIME;
mark_inode_dirty(tmp);
d_delete(de);
dput(de);
}
}
}
/*================ Global functions ================*/
/*
* hfs_create()
*
* This is the create() entry in the inode_operations structure for
* regular HFS directories. The purpose is to create a new file in
* a directory and return a corresponding inode, given the inode for
* the directory and the name (and its length) of the new file.
*/
int hfs_create(struct inode * dir, struct dentry *dentry, int mode)
{
struct hfs_cat_entry *entry = HFS_I(dir)->entry;
struct hfs_cat_entry *new;
struct hfs_cat_key key;
struct inode *inode;
int error;
/* build the key, checking against reserved names */
if (build_key(&key, dir, dentry->d_name.name, dentry->d_name.len))
return -EEXIST;
if ((error = hfs_cat_create(entry, &key,
(mode & S_IWUSR) ? 0 : HFS_FIL_LOCK,
HFS_SB(dir->i_sb)->s_type,
HFS_SB(dir->i_sb)->s_creator, &new)))
return error;
/* create an inode for the new file. back out if we run
* into trouble. */
new->count++; /* hfs_iget() eats one */
if (!(inode = hfs_iget(new, HFS_I(dir)->file_type, dentry))) {
hfs_cat_delete(entry, new, 1);
hfs_cat_put(new);
return -EIO;
}
hfs_cat_put(new);
update_dirs_plus(entry, 0);
/* toss any relevant negative dentries */
if (HFS_I(dir)->d_drop_op)
HFS_I(dir)->d_drop_op(dentry, HFS_I(dir)->file_type);
mark_inode_dirty(inode);
d_instantiate(dentry, inode);
return 0;
}
/*
* hfs_mkdir()
*
* This is the mkdir() entry in the inode_operations structure for
* regular HFS directories. The purpose is to create a new directory
* in a directory, given the inode for the parent directory and the
* name (and its length) of the new directory.
*/
int hfs_mkdir(struct inode * parent, struct dentry *dentry, int mode)
{
struct hfs_cat_entry *entry = HFS_I(parent)->entry;
struct hfs_cat_entry *new;
struct hfs_cat_key key;
struct inode *inode;
int error;
/* build the key, checking against reserved names */
if (build_key(&key, parent, dentry->d_name.name,
dentry->d_name.len))
return -EEXIST;
/* try to create the directory */
if ((error = hfs_cat_mkdir(entry, &key, &new)))
return error;
/* back out if we run into trouble */
new->count++; /* hfs_iget eats one */
if (!(inode = hfs_iget(new, HFS_I(parent)->file_type, dentry))) {
hfs_cat_delete(entry, new, 1);
hfs_cat_put(new);
return -EIO;
}
hfs_cat_put(new);
update_dirs_plus(entry, 1);
mark_inode_dirty(inode);
d_instantiate(dentry, inode);
return 0;
}
/*
* hfs_unlink()
*
* This is the unlink() entry in the inode_operations structure for
* regular HFS directories. The purpose is to delete an existing
* file, given the inode for the parent directory and the name
* (and its length) of the existing file.
*/
int hfs_unlink(struct inode * dir, struct dentry *dentry)
{
struct hfs_cat_entry *entry = HFS_I(dir)->entry;
struct hfs_cat_entry *victim = NULL;
struct hfs_cat_key key;
int error;
if (build_key(&key, dir, dentry->d_name.name,
dentry->d_name.len))
return -EPERM;
if (!(victim = hfs_cat_get(entry->mdb, &key)))
return -ENOENT;
error = -EPERM;
if (victim->type != HFS_CDR_FIL)
goto hfs_unlink_put;
if (!(error = hfs_cat_delete(entry, victim, 1))) {
struct inode *inode = dentry->d_inode;
mark_inodes_deleted(victim, dentry);
inode->i_nlink--;
inode->i_ctime = CURRENT_TIME;
mark_inode_dirty(inode);
update_dirs_minus(entry, 0);
}
hfs_unlink_put:
hfs_cat_put(victim); /* Note that hfs_cat_put(NULL) is safe. */
return error;
}
/*
* hfs_rmdir()
*
* This is the rmdir() entry in the inode_operations structure for
* regular HFS directories. The purpose is to delete an existing
* directory, given the inode for the parent directory and the name
* (and its length) of the existing directory.
*/
int hfs_rmdir(struct inode * parent, struct dentry *dentry)
{
struct hfs_cat_entry *entry = HFS_I(parent)->entry;
struct hfs_cat_entry *victim = NULL;
struct inode *inode = dentry->d_inode;
struct hfs_cat_key key;
int error;
if (build_key(&key, parent, dentry->d_name.name,
dentry->d_name.len))
return -EPERM;
if (!(victim = hfs_cat_get(entry->mdb, &key)))
return -ENOENT;
error = -ENOTDIR;
if (victim->type != HFS_CDR_DIR)
goto hfs_rmdir_put;
error = -EBUSY;
if (!d_unhashed(dentry))
goto hfs_rmdir_put;
/* we only have to worry about 2 and 3 for mount points */
if (victim->sys_entry[2] && d_mountpoint(victim->sys_entry[2]))
goto hfs_rmdir_put;
if (victim->sys_entry[3] && d_mountpoint(victim->sys_entry[3]))
goto hfs_rmdir_put;
if ((error = hfs_cat_delete(entry, victim, 1)))
goto hfs_rmdir_put;
mark_inodes_deleted(victim, dentry);
inode->i_nlink = 0;
inode->i_ctime = CURRENT_TIME;
mark_inode_dirty(inode);
update_dirs_minus(entry, 1);
hfs_rmdir_put:
hfs_cat_put(victim); /* Note that hfs_cat_put(NULL) is safe. */
return error;
}
/*
* hfs_rename()
*
* This is the rename() entry in the inode_operations structure for
* regular HFS directories. The purpose is to rename an existing
* file or directory, given the inode for the current directory and
* the name (and its length) of the existing file/directory and the
* inode for the new directory and the name (and its length) of the
* new file/directory.
* XXX: how do you handle must_be dir?
*/
int hfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
struct hfs_cat_entry *old_parent = HFS_I(old_dir)->entry;
struct hfs_cat_entry *new_parent = HFS_I(new_dir)->entry;
struct hfs_cat_entry *victim = NULL;
struct hfs_cat_entry *deleted;
struct hfs_cat_key key;
int error;
if (build_key(&key, old_dir, old_dentry->d_name.name,
old_dentry->d_name.len) ||
(HFS_ITYPE(old_dir->i_ino) != HFS_ITYPE(new_dir->i_ino)))
return -EPERM;
if (!(victim = hfs_cat_get(old_parent->mdb, &key)))
return -ENOENT;
error = -EPERM;
if (build_key(&key, new_dir, new_dentry->d_name.name,
new_dentry->d_name.len))
goto hfs_rename_put;
if (!(error = hfs_cat_move(old_parent, new_parent,
victim, &key, &deleted))) {
int is_dir = (victim->type == HFS_CDR_DIR);
/* drop the old dentries */
mark_inodes_deleted(victim, old_dentry);
update_dirs_minus(old_parent, is_dir);
if (deleted) {
mark_inodes_deleted(deleted, new_dentry);
hfs_cat_put(deleted);
} else {
/* no existing inodes. just drop negative dentries */
if (HFS_I(new_dir)->d_drop_op)
HFS_I(new_dir)->d_drop_op(new_dentry,
HFS_I(new_dir)->file_type);
update_dirs_plus(new_parent, is_dir);
}
}
hfs_rename_put:
hfs_cat_put(victim); /* Note that hfs_cat_put(NULL) is safe. */
return error;
}
|