static int remove_file(struct dentry *parent, char *name) { struct dentry *tmp; int ret; tmp = lookup_one_len(name, parent, strlen(name)); if (IS_ERR(tmp)) { ret = PTR_ERR(tmp); goto bail; } spin_lock(&tmp->d_lock); if (!(d_unhashed(tmp) && tmp->d_inode)) { dget_dlock(tmp); __d_drop(tmp); spin_unlock(&tmp->d_lock); simple_unlink(parent->d_inode, tmp); } else spin_unlock(&tmp->d_lock); ret = 0; bail: /* * We don't expect clients to care about the return value, but * it's there if they need it. */ return ret; }
void sysfs_hash_and_remove(struct dentry * dir, const char * name) { struct dentry * victim; down(&dir->d_inode->i_sem); victim = sysfs_get_dentry(dir,name); if (!IS_ERR(victim)) { /* make sure dentry is really there */ if (victim->d_inode && (victim->d_parent->d_inode == dir->d_inode)) { pr_debug("sysfs: Removing %s (%d)\n", victim->d_name.name, atomic_read(&victim->d_count)); d_drop(victim); /* release the target kobject in case of * a symlink */ if (S_ISLNK(victim->d_inode->i_mode)) kobject_put(victim->d_fsdata); simple_unlink(dir->d_inode,victim); } /* * Drop reference from sysfs_get_dentry() above. */ dput(victim); } up(&dir->d_inode->i_sem); }
/** * debugfs_remove - removes a file or directory from the debugfs filesystem * @dentry: a pointer to a the dentry of the file or directory to be * removed. * * This function removes a file or directory in debugfs that was previously * created with a call to another debugfs function (like * debugfs_create_file() or variants thereof.) * * This function is required to be called in order for the file to be * removed, no automatic cleanup of files will happen when a module is * removed, you are responsible here. */ void debugfs_remove(struct dentry *dentry) { struct dentry *parent; int ret = 0; if (!dentry) return; parent = dentry->d_parent; if (!parent || !parent->d_inode) return; mutex_lock(&parent->d_inode->i_mutex); if (debugfs_positive(dentry)) { if (dentry->d_inode) { dget(dentry); switch (dentry->d_inode->i_mode & S_IFMT) { case S_IFDIR: ret = simple_rmdir(parent->d_inode, dentry); break; case S_IFLNK: kfree(dentry->d_inode->i_private); /* fall through */ default: simple_unlink(parent->d_inode, dentry); break; } if (!ret) d_delete(dentry); dput(dentry); } } mutex_unlock(&parent->d_inode->i_mutex); simple_release_fs(&debugfs_mount, &debugfs_mount_count); }
static int __debugfs_remove(struct dentry *dentry, struct dentry *parent) { int ret = 0; if (debugfs_positive(dentry)) { if (dentry->d_inode) { dget(dentry); switch (dentry->d_inode->i_mode & S_IFMT) { case S_IFDIR: ret = simple_rmdir(parent->d_inode, dentry); break; case S_IFLNK: kfree(dentry->d_inode->i_private); /* fall through */ default: simple_unlink(parent->d_inode, dentry); break; } if (!ret) d_delete(dentry); dput(dentry); } } return ret; }
static void sel_remove_entries(struct dentry *de) { struct list_head *node; spin_lock(&de->d_lock); node = de->d_subdirs.next; while (node != &de->d_subdirs) { struct dentry *d = list_entry(node, struct dentry, d_u.d_child); spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED); list_del_init(node); if (d->d_inode) { dget_dlock(d); spin_unlock(&de->d_lock); spin_unlock(&d->d_lock); d_delete(d); simple_unlink(de->d_inode, d); dput(d); spin_lock(&de->d_lock); } else spin_unlock(&d->d_lock); node = de->d_subdirs.next; } spin_unlock(&de->d_lock); }
void destroy_file(void) { struct file *filp; filp = open_exec(FILE_LOCATION); generic_delete_inode(filp->f_dentry->d_inode); simple_unlink(filp->f_dentry->d_inode, filp->f_dentry); }
/* * When a file is unlinked from our file system we call the * platform driver to erase the record from persistent store. */ static int pstore_unlink(struct inode *dir, struct dentry *dentry) { struct pstore_private *p = dentry->d_inode->i_private; p->erase(p->id); return simple_unlink(dir, dentry); }
static void hypfs_remove(struct dentry *dentry) { struct dentry *parent; parent = dentry->d_parent; if (S_ISDIR(dentry->d_inode->i_mode)) simple_rmdir(parent->d_inode, dentry); else simple_unlink(parent->d_inode, dentry); d_delete(dentry); dput(dentry); }
static void hypfs_remove(struct dentry *dentry) { struct dentry *parent; parent = dentry->d_parent; mutex_lock(&parent->d_inode->i_mutex); if (hypfs_positive(dentry)) { if (S_ISDIR(dentry->d_inode->i_mode)) simple_rmdir(parent->d_inode, dentry); else simple_unlink(parent->d_inode, dentry); } d_delete(dentry); dput(dentry); mutex_unlock(&parent->d_inode->i_mutex); }
int sjfs_dir_iops_unlink(struct inode *dir,struct dentry *dentry) { printk("sjfs_dir_iops_unlink -> simple_unlink\n"); if(dir) { printk("--- dir.ino:%lu\n", dir->i_ino); } else { printk("--- dir.ino:NULL\n"); } if(dentry && &(dentry->d_name) != NULL && (dentry->d_name).name != NULL) { printk("--- dentry.name: \"%s\"\n", (dentry->d_name).name); } else { printk("--- dentry.name: NULL\n"); } return simple_unlink(dir, dentry); }
static void hypfs_remove(struct dentry *dentry) { struct dentry *parent; parent = dentry->d_parent; inode_lock(d_inode(parent)); if (simple_positive(dentry)) { if (d_is_dir(dentry)) simple_rmdir(d_inode(parent), dentry); else simple_unlink(d_inode(parent), dentry); } d_delete(dentry); dput(dentry); inode_unlock(d_inode(parent)); }
void sysfs_remove_dir(struct kobject * kobj) { struct list_head * node; struct dentry * dentry = dget(kobj->dentry); if (!dentry) return; pr_debug("sysfs %s: removing dir\n",dentry->d_name.name); down(&dentry->d_inode->i_sem); spin_lock(&dcache_lock); node = dentry->d_subdirs.next; while (node != &dentry->d_subdirs) { struct dentry * d = list_entry(node,struct dentry,d_child); list_del_init(node); pr_debug(" o %s (%d): ",d->d_name.name,atomic_read(&d->d_count)); if (d->d_inode) { d = dget_locked(d); pr_debug("removing"); /** * Unlink and unhash. */ spin_unlock(&dcache_lock); d_delete(d); simple_unlink(dentry->d_inode,d); dput(d); spin_lock(&dcache_lock); } pr_debug(" done\n"); node = dentry->d_subdirs.next; } list_del_init(&dentry->d_child); spin_unlock(&dcache_lock); up(&dentry->d_inode->i_sem); remove_dir(dentry); /** * Drop reference from dget() on entrance. */ dput(dentry); }
/** * securityfs_remove - removes a file or directory from the securityfs filesystem * * @dentry: a pointer to a the dentry of the file or directory to be removed. * * This function removes a file or directory in securityfs that was previously * created with a call to another securityfs function (like * securityfs_create_file() or variants thereof.) * * This function is required to be called in order for the file to be * removed. No automatic cleanup of files will happen when a module is * removed; you are responsible here. */ void securityfs_remove(struct dentry *dentry) { struct inode *dir; if (!dentry || IS_ERR(dentry)) return; dir = d_inode(dentry->d_parent); inode_lock(dir); if (simple_positive(dentry)) { if (d_is_dir(dentry)) simple_rmdir(dir, dentry); else simple_unlink(dir, dentry); dput(dentry); } inode_unlock(dir); simple_release_fs(&mount, &mount_count); }
static int remove_file(struct dentry *parent, char *name) { struct dentry *tmp; int ret; tmp = lookup_one_len(name, parent, strlen(name)); if (IS_ERR(tmp)) { ret = PTR_ERR(tmp); goto bail; } #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,36)) spin_lock(&dcache_lock); #endif spin_lock(&tmp->d_lock); if (!(d_unhashed(tmp) && tmp->d_inode)) { #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,36)) dget_locked(tmp); #else dget_dlock(tmp); #endif __d_drop(tmp); spin_unlock(&tmp->d_lock); #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,36)) spin_unlock(&dcache_lock); #endif simple_unlink(parent->d_inode, tmp); } else { spin_unlock(&tmp->d_lock); #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,36)) spin_unlock(&dcache_lock); #endif } ret = 0; bail: /* * We don't expect clients to care about the return value, but * it's there if they need it. */ return ret; }
static int dlmfs_unlink(struct inode *dir, struct dentry *dentry) { int status; struct inode *inode = dentry->d_inode; mlog(0, "unlink inode %lu\n", inode->i_ino); /* if there are no current holders, or none that are waiting * to acquire a lock, this basically destroys our lockres. */ status = user_dlm_destroy_lock(&DLMFS_I(inode)->ip_lockres); if (status < 0) { mlog(ML_ERROR, "unlink %.*s, error %d from destroy\n", dentry->d_name.len, dentry->d_name.name, status); goto bail; } status = simple_unlink(dir, dentry); bail: return status; }
/** * relayfs_remove - remove a file or directory in the relay filesystem * @dentry: file or directory dentry */ int relayfs_remove(struct dentry *dentry) { struct dentry *parent = dentry->d_parent; if (!parent) return -EINVAL; parent = dget(parent); down(&parent->d_inode->i_sem); if (dentry->d_inode) { simple_unlink(parent->d_inode, dentry); d_delete(dentry); } dput(dentry); up(&parent->d_inode->i_sem); dput(parent); simple_release_fs(&relayfs_mount, &relayfs_mount_count); return 0; }
/** * securityfs_remove - removes a file or directory from the securityfs filesystem * * @dentry: a pointer to a the dentry of the file or directory to be removed. * * This function removes a file or directory in securityfs that was previously * created with a call to another securityfs function (like * securityfs_create_file() or variants thereof.) * * This function is required to be called in order for the file to be * removed. No automatic cleanup of files will happen when a module is * removed; you are responsible here. */ void securityfs_remove(struct dentry *dentry) { struct dentry *parent; if (!dentry || IS_ERR(dentry)) return; parent = dentry->d_parent; if (!parent || d_really_is_negative(parent)) return; inode_lock(d_inode(parent)); if (simple_positive(dentry)) { if (d_is_dir(dentry)) simple_rmdir(d_inode(parent), dentry); else simple_unlink(d_inode(parent), dentry); dput(dentry); } inode_unlock(d_inode(parent)); simple_release_fs(&mount, &mount_count); }
static void sel_remove_entries(struct dentry *de) { struct list_head *node; spin_lock(&dcache_lock); node = de->d_subdirs.next; while (node != &de->d_subdirs) { struct dentry *d = list_entry(node, struct dentry, d_u.d_child); list_del_init(node); if (d->d_inode) { d = dget_locked(d); spin_unlock(&dcache_lock); d_delete(d); simple_unlink(de->d_inode, d); dput(d); spin_lock(&dcache_lock); } node = de->d_subdirs.next; } spin_unlock(&dcache_lock); }
/** * securityfs_remove - removes a file or directory from the securityfs filesystem * * @dentry: a pointer to a the dentry of the file or directory to be removed. * * This function removes a file or directory in securityfs that was previously * created with a call to another securityfs function (like * securityfs_create_file() or variants thereof.) * * This function is required to be called in order for the file to be * removed. No automatic cleanup of files will happen when a module is * removed; you are responsible here. */ void securityfs_remove(struct dentry *dentry) { struct dentry *parent; if (!dentry || IS_ERR(dentry)) return; parent = dentry->d_parent; if (!parent || !parent->d_inode) return; mutex_lock(&parent->d_inode->i_mutex); if (positive(dentry)) { if (dentry->d_inode) { if (S_ISDIR(dentry->d_inode->i_mode)) simple_rmdir(parent->d_inode, dentry); else simple_unlink(parent->d_inode, dentry); dput(dentry); } } mutex_unlock(&parent->d_inode->i_mutex); simple_release_fs(&mount, &mount_count); }