Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
convert rust_binderfs
Parallel to binderfs stuff:
* use simple_start_creating()/simple_done_creating()/d_make_persistent()
instead of manual inode_lock()/lookup_noperm()/d_instanitate()/inode_unlock().
* allocate inode first - simpler cleanup that way.
* use simple_recursive_removal() instead of open-coding it.
* switch to kill_anon_super()
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
+33
-88
+33
-88
drivers/android/binder/rust_binderfs.c
+33
-88
drivers/android/binder/rust_binderfs.c
···
178
178
}
179
179
180
180
root = sb->s_root;
181
-
inode_lock(d_inode(root));
182
-
183
-
/* look it up */
184
-
dentry = lookup_noperm(&QSTR(req->name), root);
181
+
dentry = simple_start_creating(root, req->name);
185
182
if (IS_ERR(dentry)) {
186
-
inode_unlock(d_inode(root));
187
183
ret = PTR_ERR(dentry);
188
184
goto err;
189
185
}
190
186
191
-
if (d_really_is_positive(dentry)) {
192
-
/* already exists */
193
-
dput(dentry);
194
-
inode_unlock(d_inode(root));
195
-
ret = -EEXIST;
196
-
goto err;
197
-
}
198
-
199
187
inode->i_private = device;
200
-
d_instantiate(dentry, inode);
188
+
d_make_persistent(dentry, inode);
189
+
201
190
fsnotify_create(root->d_inode, dentry);
202
-
inode_unlock(d_inode(root));
191
+
simple_done_creating(dentry);
203
192
204
193
return 0;
205
194
···
461
472
return ret;
462
473
}
463
474
464
-
static struct dentry *binderfs_create_dentry(struct dentry *parent,
465
-
const char *name)
466
-
{
467
-
struct dentry *dentry;
468
-
469
-
dentry = lookup_noperm(&QSTR(name), parent);
470
-
if (IS_ERR(dentry))
471
-
return dentry;
472
-
473
-
/* Return error if the file/dir already exists. */
474
-
if (d_really_is_positive(dentry)) {
475
-
dput(dentry);
476
-
return ERR_PTR(-EEXIST);
477
-
}
478
-
479
-
return dentry;
480
-
}
481
-
482
475
void rust_binderfs_remove_file(struct dentry *dentry)
483
476
{
484
-
struct inode *parent_inode;
485
-
486
-
parent_inode = d_inode(dentry->d_parent);
487
-
inode_lock(parent_inode);
488
-
if (simple_positive(dentry)) {
489
-
dget(dentry);
490
-
simple_unlink(parent_inode, dentry);
491
-
d_delete(dentry);
492
-
dput(dentry);
493
-
}
494
-
inode_unlock(parent_inode);
477
+
simple_recursive_removal(dentry, NULL);
495
478
}
496
479
497
480
static struct dentry *rust_binderfs_create_file(struct dentry *parent, const char *name,
···
471
510
void *data)
472
511
{
473
512
struct dentry *dentry;
474
-
struct inode *new_inode, *parent_inode;
475
-
struct super_block *sb;
513
+
struct inode *new_inode;
476
514
477
-
parent_inode = d_inode(parent);
478
-
inode_lock(parent_inode);
479
-
480
-
dentry = binderfs_create_dentry(parent, name);
481
-
if (IS_ERR(dentry))
482
-
goto out;
483
-
484
-
sb = parent_inode->i_sb;
485
-
new_inode = binderfs_make_inode(sb, S_IFREG | 0444);
486
-
if (!new_inode) {
487
-
dput(dentry);
488
-
dentry = ERR_PTR(-ENOMEM);
489
-
goto out;
490
-
}
491
-
515
+
new_inode = binderfs_make_inode(parent->d_sb, S_IFREG | 0444);
516
+
if (!new_inode)
517
+
return ERR_PTR(-ENOMEM);
492
518
new_inode->i_fop = fops;
493
519
new_inode->i_private = data;
494
-
d_instantiate(dentry, new_inode);
495
-
fsnotify_create(parent_inode, dentry);
496
520
497
-
out:
498
-
inode_unlock(parent_inode);
521
+
dentry = simple_start_creating(parent, name);
522
+
if (IS_ERR(dentry)) {
523
+
iput(new_inode);
524
+
return dentry;
525
+
}
526
+
527
+
d_make_persistent(dentry, new_inode);
528
+
fsnotify_create(parent->d_inode, dentry);
529
+
simple_done_creating(dentry);
499
530
return dentry;
500
531
}
501
532
···
509
556
const char *name)
510
557
{
511
558
struct dentry *dentry;
512
-
struct inode *new_inode, *parent_inode;
513
-
struct super_block *sb;
559
+
struct inode *new_inode;
514
560
515
-
parent_inode = d_inode(parent);
516
-
inode_lock(parent_inode);
517
-
518
-
dentry = binderfs_create_dentry(parent, name);
519
-
if (IS_ERR(dentry))
520
-
goto out;
521
-
522
-
sb = parent_inode->i_sb;
523
-
new_inode = binderfs_make_inode(sb, S_IFDIR | 0755);
524
-
if (!new_inode) {
525
-
dput(dentry);
526
-
dentry = ERR_PTR(-ENOMEM);
527
-
goto out;
528
-
}
561
+
new_inode = binderfs_make_inode(parent->d_sb, S_IFDIR | 0755);
562
+
if (!new_inode)
563
+
return ERR_PTR(-ENOMEM);
529
564
530
565
new_inode->i_fop = &simple_dir_operations;
531
566
new_inode->i_op = &simple_dir_inode_operations;
532
567
533
-
set_nlink(new_inode, 2);
534
-
d_instantiate(dentry, new_inode);
535
-
inc_nlink(parent_inode);
536
-
fsnotify_mkdir(parent_inode, dentry);
568
+
dentry = simple_start_creating(parent, name);
569
+
if (IS_ERR(dentry)) {
570
+
iput(new_inode);
571
+
return dentry;
572
+
}
537
573
538
-
out:
539
-
inode_unlock(parent_inode);
574
+
inc_nlink(parent->d_inode);
575
+
set_nlink(new_inode, 2);
576
+
d_make_persistent(dentry, new_inode);
577
+
fsnotify_mkdir(parent->d_inode, dentry);
578
+
simple_done_creating(dentry);
540
579
return dentry;
541
580
}
542
581
···
747
802
* During inode eviction struct binderfs_info is needed.
748
803
* So first wipe the super_block then free struct binderfs_info.
749
804
*/
750
-
kill_litter_super(sb);
805
+
kill_anon_super(sb);
751
806
752
807
if (info && info->ipc_ns)
753
808
put_ipc_ns(info->ipc_ns);