History

make simple_positive() public

Al Viro committed 11 years ago

Commit dc3f4191 parent 5d754ce14 files · +25 −60Browse files

Unified · Split

14 files
  1. arch/powerpc/platforms/cell/spufs/inode.c +1 −1
  2. arch/s390/hypfs/inode.c +1 −6
  3. drivers/block/drbd/drbd_debugfs.c +1 −9
  4. drivers/infiniband/hw/ipath/ipath_fs.c +1 −1
  5. drivers/infiniband/hw/qib/qib_fs.c +1 −1
  6. fs/autofs4/autofs_i.h +0 −5
  7. fs/ceph/dir.c +1 −1
  8. fs/configfs/inode.c +1 −1
  9. fs/debugfs/inode.c +3 −8
  10. fs/libfs.c +0 −5
  11. fs/nfs/dir.c +1 −1
  12. fs/tracefs/inode.c +3 −8
  13. include/linux/dcache.h +5 −0
  14. security/inode.c +6 −13
arch/powerpc/platforms/cell/spufs/inode.c+1−1
@@ -166,7 +166,7 @@ static void spufs_prune_dir(struct dentry *dir) · 165 unmodified lines
166 mutex_lock(&d_inode(dir)->i_mutex);166 mutex_lock(&d_inode(dir)->i_mutex);
167 list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {167 list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
168 spin_lock(&dentry->d_lock);168 spin_lock(&dentry->d_lock);
169 if (!(d_unhashed(dentry)) && d_really_is_positive(dentry)) {169 if (simple_positive(dentry)) {
170 dget_dlock(dentry);170 dget_dlock(dentry);
171 __d_drop(dentry);171 __d_drop(dentry);
172 spin_unlock(&dentry->d_lock);172 spin_unlock(&dentry->d_lock);
arch/s390/hypfs/inode.c+1−6
@@ -62,18 +62,13 @@ static void hypfs_add_dentry(struct dentry *dentry) · 61 unmodified lines
62 hypfs_last_dentry = dentry;62 hypfs_last_dentry = dentry;
63}63}
64 64
65static inline int hypfs_positive(struct dentry *dentry)
66{
67 return d_really_is_positive(dentry) && !d_unhashed(dentry);
68}
69
70static void hypfs_remove(struct dentry *dentry)65static void hypfs_remove(struct dentry *dentry)
71{66{
72 struct dentry *parent;67 struct dentry *parent;
73 68
74 parent = dentry->d_parent;69 parent = dentry->d_parent;
75 mutex_lock(&d_inode(parent)->i_mutex);70 mutex_lock(&d_inode(parent)->i_mutex);
76 if (hypfs_positive(dentry)) {71 if (simple_positive(dentry)) {
77 if (d_is_dir(dentry))72 if (d_is_dir(dentry))
78 simple_rmdir(d_inode(parent), dentry);73 simple_rmdir(d_inode(parent), dentry);
79 else74 else
drivers/block/drbd/drbd_debugfs.c+1−9
@@ -419,14 +419,6 @@ static int in_flight_summary_show(struct seq_file *m, void *pos) · 418 unmodified lines
419 return 0;419 return 0;
420}420}
421 421
422/* simple_positive(file->f_path.dentry) respectively debugfs_positive(),
423 * but neither is "reachable" from here.
424 * So we have our own inline version of it above. :-( */
425static inline int debugfs_positive(struct dentry *dentry)
426{
427 return d_really_is_positive(dentry) && !d_unhashed(dentry);
428}
429
430/* make sure at *open* time that the respective object won't go away. */422/* make sure at *open* time that the respective object won't go away. */
431static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, void *),423static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, void *),
432 void *data, struct kref *kref,424 void *data, struct kref *kref,
@@ -444,7 +436,7 @@ static int drbd_single_open(struct file *file, int (*show)(struct seq_file *, vo · 11 unmodified lines
444 /* serialize with d_delete() */436 /* serialize with d_delete() */
445 mutex_lock(&d_inode(parent)->i_mutex);437 mutex_lock(&d_inode(parent)->i_mutex);
446 /* Make sure the object is still alive */438 /* Make sure the object is still alive */
447 if (debugfs_positive(file->f_path.dentry)439 if (simple_positive(file->f_path.dentry)
448 && kref_get_unless_zero(kref))440 && kref_get_unless_zero(kref))
449 ret = 0;441 ret = 0;
450 mutex_unlock(&d_inode(parent)->i_mutex);442 mutex_unlock(&d_inode(parent)->i_mutex);
drivers/infiniband/hw/ipath/ipath_fs.c+1−1
@@ -277,7 +277,7 @@ static int remove_file(struct dentry *parent, char *name) · 276 unmodified lines
277 }277 }
278 278
279 spin_lock(&tmp->d_lock);279 spin_lock(&tmp->d_lock);
280 if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {280 if (simple_positive(tmp)) {
281 dget_dlock(tmp);281 dget_dlock(tmp);
282 __d_drop(tmp);282 __d_drop(tmp);
283 spin_unlock(&tmp->d_lock);283 spin_unlock(&tmp->d_lock);
drivers/infiniband/hw/qib/qib_fs.c+1−1
@@ -455,7 +455,7 @@ static int remove_file(struct dentry *parent, char *name) · 454 unmodified lines
455 }455 }
456 456
457 spin_lock(&tmp->d_lock);457 spin_lock(&tmp->d_lock);
458 if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {458 if (simple_positive(tmp)) {
459 __d_drop(tmp);459 __d_drop(tmp);
460 spin_unlock(&tmp->d_lock);460 spin_unlock(&tmp->d_lock);
461 simple_unlink(d_inode(parent), tmp);461 simple_unlink(d_inode(parent), tmp);
fs/autofs4/autofs_i.h+0−5
@@ -238,11 +238,6 @@ static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi) · 237 unmodified lines
238 return d_inode(sbi->sb->s_root)->i_ino;238 return d_inode(sbi->sb->s_root)->i_ino;
239}239}
240 240
241static inline int simple_positive(struct dentry *dentry)
242{
243 return d_really_is_positive(dentry) && !d_unhashed(dentry);
244}
245
246static inline void __autofs4_add_expiring(struct dentry *dentry)241static inline void __autofs4_add_expiring(struct dentry *dentry)
247{242{
248 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);243 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
fs/ceph/dir.c+1−1
@@ -161,7 +161,7 @@ more: · 160 unmodified lines
161 }161 }
162 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);162 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
163 if (di->lease_shared_gen == shared_gen &&163 if (di->lease_shared_gen == shared_gen &&
164 !d_unhashed(dentry) && d_really_is_positive(dentry) &&164 simple_positive(dentry) &&
165 ceph_snap(d_inode(dentry)) != CEPH_SNAPDIR &&165 ceph_snap(d_inode(dentry)) != CEPH_SNAPDIR &&
166 ceph_ino(d_inode(dentry)) != CEPH_INO_CEPH &&166 ceph_ino(d_inode(dentry)) != CEPH_INO_CEPH &&
167 fpos_cmp(ctx->pos, di->offset) <= 0)167 fpos_cmp(ctx->pos, di->offset) <= 0)
fs/configfs/inode.c+1−1
@@ -236,7 +236,7 @@ void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent) · 235 unmodified lines
236 236
237 if (dentry) {237 if (dentry) {
238 spin_lock(&dentry->d_lock);238 spin_lock(&dentry->d_lock);
239 if (!d_unhashed(dentry) && d_really_is_positive(dentry)) {239 if (simple_positive(dentry)) {
240 dget_dlock(dentry);240 dget_dlock(dentry);
241 __d_drop(dentry);241 __d_drop(dentry);
242 spin_unlock(&dentry->d_lock);242 spin_unlock(&dentry->d_lock);
fs/debugfs/inode.c+3−8
@@ -44,11 +44,6 @@ static struct inode *debugfs_get_inode(struct super_block *sb) · 43 unmodified lines
44 return inode;44 return inode;
45}45}
46 46
47static inline int debugfs_positive(struct dentry *dentry)
48{
49 return d_really_is_positive(dentry) && !d_unhashed(dentry);
50}
51
52struct debugfs_mount_opts {47struct debugfs_mount_opts {
53 kuid_t uid;48 kuid_t uid;
54 kgid_t gid;49 kgid_t gid;
@@ -522,7 +517,7 @@ static int __debugfs_remove(struct dentry *dentry, struct dentry *parent) · 467 unmodified lines
522{517{
523 int ret = 0;518 int ret = 0;
524 519
525 if (debugfs_positive(dentry)) {520 if (simple_positive(dentry)) {
526 dget(dentry);521 dget(dentry);
527 if (d_is_dir(dentry))522 if (d_is_dir(dentry))
528 ret = simple_rmdir(d_inode(parent), dentry);523 ret = simple_rmdir(d_inode(parent), dentry);
@@ -602,7 +597,7 @@ void debugfs_remove_recursive(struct dentry *dentry) · 73 unmodified lines
602 */597 */
603 spin_lock(&parent->d_lock);598 spin_lock(&parent->d_lock);
604 list_for_each_entry(child, &parent->d_subdirs, d_child) {599 list_for_each_entry(child, &parent->d_subdirs, d_child) {
605 if (!debugfs_positive(child))600 if (!simple_positive(child))
606 continue;601 continue;
607 602
608 /* perhaps simple_empty(child) makes more sense */603 /* perhaps simple_empty(child) makes more sense */
@@ -623,7 +618,7 @@ void debugfs_remove_recursive(struct dentry *dentry) · 14 unmodified lines
623 * from d_subdirs. When releasing the parent->d_lock we can618 * from d_subdirs. When releasing the parent->d_lock we can
624 * no longer trust that the next pointer is valid.619 * no longer trust that the next pointer is valid.
625 * Restart the loop. We'll skip this one with the620 * Restart the loop. We'll skip this one with the
626 * debugfs_positive() check.621 * simple_positive() check.
627 */622 */
628 goto loop;623 goto loop;
629 }624 }
fs/libfs.c+0−5
@@ -20,11 +20,6 @@ · 19 unmodified lines
20 20
21#include "internal.h"21#include "internal.h"
22 22
23static inline int simple_positive(struct dentry *dentry)
24{
25 return d_really_is_positive(dentry) && !d_unhashed(dentry);
26}
27
28int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,23int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
29 struct kstat *stat)24 struct kstat *stat)
30{25{
fs/nfs/dir.c+1−1
@@ -1771,7 +1771,7 @@ EXPORT_SYMBOL_GPL(nfs_mkdir); · 1770 unmodified lines
1771 1771
1772static void nfs_dentry_handle_enoent(struct dentry *dentry)1772static void nfs_dentry_handle_enoent(struct dentry *dentry)
1773{1773{
1774 if (d_really_is_positive(dentry) && !d_unhashed(dentry))1774 if (simple_positive(dentry))
1775 d_delete(dentry);1775 d_delete(dentry);
1776}1776}
1777 1777
fs/tracefs/inode.c+3−8
@@ -496,16 +496,11 @@ struct dentry *tracefs_create_instance_dir(const char *name, struct dentry *pare · 495 unmodified lines
496 return dentry;496 return dentry;
497}497}
498 498
499static inline int tracefs_positive(struct dentry *dentry)
500{
501 return dentry->d_inode && !d_unhashed(dentry);
502}
503
504static int __tracefs_remove(struct dentry *dentry, struct dentry *parent)499static int __tracefs_remove(struct dentry *dentry, struct dentry *parent)
505{500{
506 int ret = 0;501 int ret = 0;
507 502
508 if (tracefs_positive(dentry)) {503 if (simple_positive(dentry)) {
509 if (dentry->d_inode) {504 if (dentry->d_inode) {
510 dget(dentry);505 dget(dentry);
511 switch (dentry->d_inode->i_mode & S_IFMT) {506 switch (dentry->d_inode->i_mode & S_IFMT) {
@@ -582,7 +577,7 @@ void tracefs_remove_recursive(struct dentry *dentry) · 70 unmodified lines
582 */577 */
583 spin_lock(&parent->d_lock);578 spin_lock(&parent->d_lock);
584 list_for_each_entry(child, &parent->d_subdirs, d_child) {579 list_for_each_entry(child, &parent->d_subdirs, d_child) {
585 if (!tracefs_positive(child))580 if (!simple_positive(child))
586 continue;581 continue;
587 582
588 /* perhaps simple_empty(child) makes more sense */583 /* perhaps simple_empty(child) makes more sense */
@@ -603,7 +598,7 @@ void tracefs_remove_recursive(struct dentry *dentry) · 14 unmodified lines
603 * from d_subdirs. When releasing the parent->d_lock we can598 * from d_subdirs. When releasing the parent->d_lock we can
604 * no longer trust that the next pointer is valid.599 * no longer trust that the next pointer is valid.
605 * Restart the loop. We'll skip this one with the600 * Restart the loop. We'll skip this one with the
606 * tracefs_positive() check.601 * simple_positive() check.
607 */602 */
608 goto loop;603 goto loop;
609 }604 }
include/linux/dcache.h+5−0
@@ -507,6 +507,11 @@ static inline bool d_really_is_positive(const struct dentry *dentry) · 506 unmodified lines
507 return dentry->d_inode != NULL;507 return dentry->d_inode != NULL;
508}508}
509 509
510static inline int simple_positive(struct dentry *dentry)
511{
512 return d_really_is_positive(dentry) && !d_unhashed(dentry);
513}
514
510extern void d_set_fallthru(struct dentry *dentry);515extern void d_set_fallthru(struct dentry *dentry);
511 516
512static inline bool d_is_fallthru(const struct dentry *dentry)517static inline bool d_is_fallthru(const struct dentry *dentry)
security/inode.c+6−13
@@ -25,11 +25,6 @@ · 24 unmodified lines
25static struct vfsmount *mount;25static struct vfsmount *mount;
26static int mount_count;26static int mount_count;
27 27
28static inline int positive(struct dentry *dentry)
29{
30 return d_really_is_positive(dentry) && !d_unhashed(dentry);
31}
32
33static int fill_super(struct super_block *sb, void *data, int silent)28static int fill_super(struct super_block *sb, void *data, int silent)
34{29{
35 static struct tree_descr files[] = {{""}};30 static struct tree_descr files[] = {{""}};
@@ -201,14 +196,12 @@ void securityfs_remove(struct dentry *dentry) · 165 unmodified lines
201 return;196 return;
202 197
203 mutex_lock(&d_inode(parent)->i_mutex);198 mutex_lock(&d_inode(parent)->i_mutex);
204 if (positive(dentry)) {199 if (simple_positive(dentry)) {
205 if (d_really_is_positive(dentry)) {200 if (d_is_dir(dentry))
206 if (d_is_dir(dentry))201 simple_rmdir(d_inode(parent), dentry);
207 simple_rmdir(d_inode(parent), dentry);202 else
208 else203 simple_unlink(d_inode(parent), dentry);
209 simple_unlink(d_inode(parent), dentry);204 dput(dentry);
210 dput(dentry);
211 }
212 }205 }
213 mutex_unlock(&d_inode(parent)->i_mutex);206 mutex_unlock(&d_inode(parent)->i_mutex);
214 simple_release_fs(&mount, &mount_count);207 simple_release_fs(&mount, &mount_count);