static void file_unlink(struct dir_entry_info *entry)
{
struct file_info *file = entry->entry.file;
char *path;
path = dir_path(entry->parent, entry->name);
/* Remove file entry from parent directory */
remove_dir_entry(entry);
/* Unlink the file */
CHECK(unlink(path) != -1);
free(path);
/* Free struct file_info if file is not open and not linked */
if (!file->fds && !file->links) {
struct write_info *w, *next;
free(file->name);
w = file->writes;
while (w) {
next = w->next;
free(w);
w = next;
}
free(file);
} else if (!file->links)
file->deleted = 1;
}
static void dir_remove(struct dir_info *dir)
{
char *path;
/* Remove directory contents */
while (dir->first) {
struct dir_entry_info *entry;
entry = dir->first;
if (entry->type == 'd')
dir_remove(entry->entry.dir);
else if (entry->type == 'f')
file_unlink(entry);
else if (entry->type == 's')
symlink_remove(entry->entry.symlink);
else
CHECK(0); /* Invalid struct dir_entry_info */
}
/* Remove entry from parent directory */
remove_dir_entry(dir->entry);
/* Remove directory itself */
path = dir_path(dir->parent, dir->name);
CHECK(rmdir(path) != -1);
free(dir);
}
int ext2_rename(inode_t *old_dir, dentry_t *old_dentry, inode_t *new_dir, dentry_t *new_dentry) {
// Remove inode from parent dir.
remove_dir_entry((ext2_fs_instance_t*)old_dir->i_instance, old_dir->i_ino, old_dentry->d_name);
add_dir_entry((ext2_fs_instance_t*)new_dir->i_instance, new_dir->i_ino, new_dentry->d_name, EXT2_FT_REG_FILE, old_dentry->d_inode->i_ino); //XXX
return 0;
}
int ext2_rmdir(inode_t *dir, dentry_t *dentry) {
if (S_ISDIR(dentry->d_inode->i_mode)) {
remove_dir_entry((ext2_fs_instance_t*)dir->i_instance, dir->i_ino, dentry->d_name);
return 0;
} else {
return -ENOTDIR;
}
}
void remove_name_hash(struct index_state *istate, struct cache_entry *ce)
{
if (!istate->name_hash_initialized || !(ce->ce_flags & CE_HASHED))
return;
ce->ce_flags &= ~CE_HASHED;
hashmap_remove(&istate->name_hash, ce, ce);
if (ignore_case)
remove_dir_entry(istate, ce);
}
static void symlink_remove(struct symlink_info *symlink)
{
char *path;
path = dir_path(symlink->entry->parent, symlink->entry->name);
remove_dir_entry(symlink->entry);
CHECK(unlink(path) != -1);
free(path);
}
int ext2_rmdir(inode_t *dir, dentry_t *dentry) {
if (S_ISDIR(dentry->d_inode->i_mode)) {
remove_dir_entry((ext2_fs_instance_t*)dir->i_instance, dir->i_ino, dentry->d_name);
free_inode((ext2_fs_instance_t*)dir->i_instance, dentry->d_inode->i_ino);
return 0;
} else {
return -ENOTDIR;
}
// TODO: Check is empty.
// TODO: Call rmdir_inode!
// décompter link!
}
static BOOL do_unlink(MESSAGE *message){
int inode_index,flags,sector_index,sector_length;
const char *path;
char dir_name[MAX_FILENAME_LENGTH]={0};
char file_name[MAX_FILENAME_LENGTH]={0};
INODE inode;
flags=message->flags;
path=message->arg_pointer;
//分离父目录路径和文件名
if(!strip_path(path,dir_name,file_name)){
return FALSE;
}
//1.get inode_index,and remove the dir_entry
inode_index=search_file(dir_name,file_name,GET_FILE_TYPE(flags));
#ifdef DEBUG_FS
printl("inode_index=%d(in do_unlink)\n",inode_index);
#endif
if(inode_index<0){
set_error_index(FILE_NOT_EXIST);
return FALSE;
}
if(!remove_dir_entry(dir_name,inode_index)){
set_error_index(FILE_NOT_EXIST);
return FALSE;
}
//2.get file inode by inode_index
get_inode_by_index(inode_index,&inode);
//3.clear imap by inode_index
free_imap_bit(inode_index);
//4.clear smap inode
sector_index=inode.i_start_sector_index-get_data_block_first_index(super_block);
sector_length=inode.i_sectors_length;
/* printl("sector_index=%d sector_length=%d data_first_index=%d\n",inode.i_start_sector_index,sector_length,get_data_block_first_index(super_block)); */
free_smap_bit(sector_index,sector_length);
return TRUE;
}
int ext2_unlink(inode_t *dir, dentry_t *dentry) {
remove_dir_entry((ext2_fs_instance_t*)dir->i_instance, dir->i_ino, dentry->d_name);
// TODO: nlink--
return 0;
}
static void rename_entry(struct dir_entry_info *entry)
{
struct dir_entry_info *rename_entry = NULL;
struct dir_info *parent;
char *path, *to, *name;
int ret, isdir, retry;
if (!entry->parent)
return;
for (retry = 0; retry < 3; retry++) {
path = dir_path(entry->parent, entry->name);
isdir = entry->type == 'd' ? 1 : 0;
name = pick_rename_name(&parent, &rename_entry, isdir);
to = dir_path(parent, name);
/*
* Check we are not trying to move a directory to a subdirectory
* of itself.
*/
if (isdir) {
struct dir_info *p;
for (p = parent; p; p = p->parent)
if (p == entry->entry.dir)
break;
if (p == entry->entry.dir) {
free(path);
free(name);
free(to);
path = NULL;
continue;
}
}
break;
}
if (!path)
return;
ret = rename(path, to);
if (ret == -1) {
if (errno == ENOSPC)
full = 1;
CHECK(errno == ENOSPC || errno == EBUSY);
free(path);
free(name);
free(to);
return;
}
free(path);
free(to);
if (rename_entry && rename_entry->type == entry->type &&
rename_entry->entry.target == entry->entry.target) {
free(name);
return;
}
add_dir_entry(parent, entry->type, name, entry->entry.target);
if (rename_entry)
remove_dir_entry(rename_entry);
remove_dir_entry(entry);
free(name);
}
