← Back to branch summary

~ubuntu-branches/ubuntu/vivid/aufs/vivid

« back to all changes in this revision

Viewing changes to fs/aufs/vfsub.c

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2007-12-15 23:32:51 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20071215233251-2vgs2lmg8mai5d9e
Tags: 0+20071211-1ubuntu1
https://launchpad.net/bugs/175705
* Merge from debian unstable (LP: #175705), remaining changes:
  - Fix for Ubuntu Kernels (updated)
* patches/01_vserver.dpatch: Removed
* patches/06_ubuntu.dpatch: Added (update of ubuntu patch)

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/aufs/vfsub.c
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: vfsub.c,v 1.8 2007/06/04 02:17:35 sfjro Exp $ */
 
19
/* $Id: vfsub.c,v 1.24 2007/12/10 01:20:14 sfjro Exp $ */
20
20
// I'm going to slightly mad
21
21
 
22
22
#include "aufs.h"
23
23
 
24
24
/* ---------------------------------------------------------------------- */
25
25
 
26
 
#ifdef CONFIG_AUFS_DLGT
 
26
#ifdef CONFIG_AUFS_HINOTIFY
 
27
/* cf. fsnotify_change() */
 
28
__u32 vfsub_events_notify_change(struct iattr *ia)
 
29
{
 
30
        __u32 events;
 
31
        const unsigned int amtime = (ATTR_ATIME | ATTR_MTIME);
 
32
 
 
33
        events = 0;
 
34
        if ((ia->ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE))
 
35
            || (ia->ia_valid & amtime) == amtime)
 
36
                events |= IN_ATTRIB;
 
37
        if ((ia->ia_valid & ATTR_SIZE)
 
38
            || (ia->ia_valid & amtime) == ATTR_MTIME)
 
39
                events |= IN_MODIFY;
 
40
        return events;
 
41
}
 
42
 
 
43
void vfsub_ign_hinode(struct vfsub_args *vargs, __u32 events,
 
44
                      struct aufs_hinode *hinode)
 
45
{
 
46
        struct aufs_hin_ignore *ign;
 
47
 
 
48
        AuDebugOn(!hinode);
 
49
 
 
50
        ign = vargs->ignore + vargs->nignore++;
 
51
        ign->ign_events = events;
 
52
        ign->ign_hinode = hinode;
 
53
}
 
54
 
 
55
void vfsub_ignore(struct vfsub_args *vargs)
 
56
{
 
57
        int n;
 
58
        struct aufs_hin_ignore *ign;
 
59
 
 
60
        n = vargs->nignore;
 
61
        ign = vargs->ignore;
 
62
        while (n-- > 0) {
 
63
                au_hin_ignore(ign->ign_hinode, ign->ign_events);
 
64
                ign++;
 
65
        }
 
66
}
 
67
 
 
68
void vfsub_unignore(struct vfsub_args *vargs)
 
69
{
 
70
        int n;
 
71
        struct aufs_hin_ignore *ign;
 
72
 
 
73
        n = vargs->nignore;
 
74
        ign = vargs->ignore;
 
75
        while (n-- > 0) {
 
76
                au_hin_unignore(ign->ign_hinode, ign->ign_events);
 
77
                ign++;
 
78
        }
 
79
}
 
80
#endif /* CONFIG_AUFS_HINOTIFY */
 
81
 
 
82
/* ---------------------------------------------------------------------- */
 
83
 
 
84
#if defined(CONFIG_AUFS_DLGT) || defined(CONFIG_AUFS_HINOTIFY)
27
85
struct permission_args {
28
86
        int *errp;
29
87
        struct inode *inode;
234
292
        int *errp;
235
293
        struct inode *src_dir, *dir;
236
294
        struct dentry *src_dentry, *dentry;
 
295
        struct vfsub_args *vargs;
237
296
};
238
297
 
239
298
static void call_rename(void *args)
240
299
{
241
300
        struct rename_args *a = args;
 
301
        vfsub_ignore(a->vargs);
242
302
        *a->errp = do_vfsub_rename(a->src_dir, a->src_dentry, a->dir,
243
303
                                   a->dentry);
 
304
        if (unlikely(*a->errp))
 
305
                vfsub_unignore(a->vargs);
244
306
}
245
307
 
246
308
int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,
247
 
                 struct inode *dir, struct dentry *dentry, int dlgt)
 
309
                 struct inode *dir, struct dentry *dentry,
 
310
                 struct vfsub_args *vargs)
248
311
{
249
 
        if (!dlgt)
250
 
                return do_vfsub_rename(src_dir, src_dentry, dir, dentry);
251
 
        else {
252
 
                int err, wkq_err;
 
312
        int err;
 
313
 
 
314
        if (!vargs->dlgt) {
 
315
                vfsub_ignore(vargs);
 
316
                err = do_vfsub_rename(src_dir, src_dentry, dir, dentry);
 
317
                if (unlikely(err))
 
318
                        vfsub_unignore(vargs);
 
319
        } else {
 
320
                int wkq_err;
253
321
                struct rename_args args = {
254
322
                        .errp           = &err,
255
323
                        .src_dir        = src_dir,
256
324
                        .src_dentry     = src_dentry,
257
325
                        .dir            = dir,
258
 
                        .dentry         = dentry
 
326
                        .dentry         = dentry,
 
327
                        .vargs          = vargs
259
328
                };
260
329
                wkq_err = au_wkq_wait(call_rename, &args, /*dlgt*/1);
261
330
                if (unlikely(wkq_err))
262
331
                        err = wkq_err;
263
 
                return err;
264
332
        }
 
333
        return err;
265
334
}
266
335
 
267
336
struct rmdir_args {
268
337
        int *errp;
269
338
        struct inode *dir;
270
339
        struct dentry *dentry;
 
340
        struct vfsub_args *vargs;
271
341
};
272
342
 
273
343
static void call_rmdir(void *args)
274
344
{
275
345
        struct rmdir_args *a = args;
 
346
        vfsub_ignore(a->vargs);
276
347
        *a->errp = do_vfsub_rmdir(a->dir, a->dentry);
 
348
        if (unlikely(*a->errp))
 
349
                vfsub_unignore(a->vargs);
277
350
}
278
351
 
279
 
int vfsub_rmdir(struct inode *dir, struct dentry *dentry, int dlgt)
 
352
int vfsub_rmdir(struct inode *dir, struct dentry *dentry,
 
353
                struct vfsub_args *vargs)
280
354
{
281
 
        if (!dlgt)
282
 
                return do_vfsub_rmdir(dir, dentry);
283
 
        else {
284
 
                int err, wkq_err;
 
355
        int err;
 
356
 
 
357
        if (!vargs->dlgt) {
 
358
                vfsub_ignore(vargs);
 
359
                err = do_vfsub_rmdir(dir, dentry);
 
360
                if (unlikely(err))
 
361
                        vfsub_unignore(vargs);
 
362
        } else {
 
363
                int wkq_err;
285
364
                struct rmdir_args args = {
286
365
                        .errp   = &err,
287
366
                        .dir    = dir,
288
 
                        .dentry = dentry
 
367
                        .dentry = dentry,
 
368
                        .vargs  = vargs
289
369
                };
290
370
                wkq_err = au_wkq_wait(call_rmdir, &args, /*dlgt*/1);
291
371
                if (unlikely(wkq_err))
292
372
                        err = wkq_err;
293
 
                return err;
294
373
        }
 
374
        return err;
295
375
}
296
376
 
297
377
/* ---------------------------------------------------------------------- */
311
391
{
312
392
        struct read_args *a = args;
313
393
        LKTRTrace("%.*s, cnt %lu, pos %Ld\n",
314
 
                  DLNPair(a->file->f_dentry), (unsigned long)a->count,
 
394
                  AuDLNPair(a->file->f_dentry), (unsigned long)a->count,
315
395
                  *a->ppos);
316
396
        *a->errp = do_vfsub_read_k(a->file, a->kbuf, a->count, a->ppos);
317
397
}
343
423
                err = -ENOMEM;
344
424
                if (args.count > PAGE_SIZE)
345
425
                        args.count = PAGE_SIZE;
346
 
                args.kbuf = kmalloc(args.count, GFP_KERNEL);
 
426
                args.kbuf = kmalloc(args.count, GFP_TEMPORARY);
347
427
                if (unlikely(!args.kbuf))
348
428
                        goto out;
349
429
 
367
447
                        ubuf += err;
368
448
                        read += err;
369
449
                } while (count);
370
 
                smp_mb();
 
450
                smp_mb(); /* flush ubuf */
371
451
                err = read;
372
452
 
373
453
        out_free:
409
489
        void *buf;
410
490
        size_t count;
411
491
        loff_t *ppos;
 
492
        struct vfsub_args *vargs;
412
493
};
413
494
 
414
495
static void call_write_k(void *args)
415
496
{
416
497
        struct write_args *a = args;
417
498
        LKTRTrace("%.*s, cnt %lu, pos %Ld\n",
418
 
                  DLNPair(a->file->f_dentry), (unsigned long)a->count,
 
499
                  AuDLNPair(a->file->f_dentry), (unsigned long)a->count,
419
500
                  *a->ppos);
 
501
        vfsub_ignore(a->vargs);
420
502
        *a->errp = do_vfsub_write_k(a->file, a->kbuf, a->count, a->ppos);
 
503
        if (unlikely(*a->errp < 0))
 
504
                vfsub_unignore(a->vargs);
421
505
}
422
506
 
423
507
ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count,
424
 
                      loff_t *ppos, int dlgt)
 
508
                      loff_t *ppos, struct vfsub_args *vargs)
425
509
{
426
 
        if (!dlgt)
427
 
                return do_vfsub_write_u(file, ubuf, count, ppos);
428
 
        else {
429
 
                ssize_t err, written;
 
510
        ssize_t err;
 
511
 
 
512
        if (!vargs->dlgt) {
 
513
                vfsub_ignore(vargs);
 
514
                err = do_vfsub_write_u(file, ubuf, count, ppos);
 
515
                if (unlikely(err < 0))
 
516
                        vfsub_unignore(vargs);
 
517
        } else {
 
518
                ssize_t written;
430
519
                int wkq_err;
431
520
                struct write_args args = {
432
521
                        .errp   = &err,
433
522
                        .file   = file,
434
523
                        .count  = count,
435
 
                        .ppos   = ppos
 
524
                        .ppos   = ppos,
 
525
                        .vargs  = vargs
436
526
                };
437
527
 
438
528
                if (unlikely(!count))
447
537
                err = -ENOMEM;
448
538
                if (args.count > PAGE_SIZE)
449
539
                        args.count = PAGE_SIZE;
450
 
                args.kbuf = kmalloc(args.count, GFP_KERNEL);
 
540
                args.kbuf = kmalloc(args.count, GFP_TEMPORARY);
451
541
                if (unlikely(!args.kbuf))
452
542
                        goto out;
453
543
 
477
567
 
478
568
        out_free:
479
569
                kfree(args.kbuf);
480
 
        out:
481
 
                return err;
482
570
        }
 
571
 out:
 
572
        return err;
483
573
}
484
574
 
485
575
ssize_t vfsub_write_k(struct file *file, void *kbuf, size_t count, loff_t *ppos,
486
 
                      int dlgt)
 
576
                      struct vfsub_args *vargs)
487
577
{
488
 
        if (!dlgt)
489
 
                return do_vfsub_write_k(file, kbuf, count, ppos);
490
 
        else {
491
 
                ssize_t err;
 
578
        ssize_t err;
 
579
 
 
580
        if (!vargs->dlgt) {
 
581
                vfsub_ignore(vargs);
 
582
                err = do_vfsub_write_k(file, kbuf, count, ppos);
 
583
                if (unlikely(err < 0))
 
584
                        vfsub_unignore(vargs);
 
585
        } else {
492
586
                int wkq_err;
493
587
                struct write_args args = {
494
588
                        .errp   = &err,
495
589
                        .file   = file,
496
590
                        .count  = count,
497
 
                        .ppos   = ppos
 
591
                        .ppos   = ppos,
 
592
                        .vargs  = vargs
498
593
                };
499
594
                args.kbuf = kbuf;
500
595
                wkq_err = au_wkq_wait(call_write_k, &args, /*dlgt*/1);
501
596
                if (unlikely(wkq_err))
502
597
                        err = wkq_err;
503
 
                return err;
504
598
        }
 
599
        return err;
505
600
}
506
601
 
507
602
struct readdir_args {
535
630
                return err;
536
631
        }
537
632
}
538
 
#endif /* CONFIG_AUFS_DLGT */
 
633
 
 
634
struct splice_to_args {
 
635
        long *errp;
 
636
        struct file *in;
 
637
        loff_t *ppos;
 
638
        struct pipe_inode_info *pipe;
 
639
        size_t len;
 
640
        unsigned int flags;
 
641
};
 
642
 
 
643
static void call_splice_to(void *args)
 
644
{
 
645
        struct splice_to_args *a = args;
 
646
        *a->errp = do_vfsub_splice_to(a->in, a->ppos, a->pipe, a->len,
 
647
                                      a->flags);
 
648
}
 
649
 
 
650
long vfsub_splice_to(struct file *in, loff_t *ppos,
 
651
                     struct pipe_inode_info *pipe, size_t len,
 
652
                     unsigned int flags, int dlgt)
 
653
{
 
654
        if (!dlgt)
 
655
                return do_vfsub_splice_to(in, ppos, pipe, len, flags);
 
656
        else {
 
657
                long err;
 
658
                int wkq_err;
 
659
                struct splice_to_args args = {
 
660
                        .errp   = &err,
 
661
                        .in     = in,
 
662
                        .ppos   = ppos,
 
663
                        .pipe   = pipe,
 
664
                        .len    = len,
 
665
                        .flags  = flags
 
666
                };
 
667
                wkq_err = au_wkq_wait(call_splice_to, &args, /*dlgt*/1);
 
668
                if (unlikely(wkq_err))
 
669
                        err = wkq_err;
 
670
                return err;
 
671
        }
 
672
}
 
673
 
 
674
struct splice_from_args {
 
675
        long *errp;
 
676
        struct pipe_inode_info *pipe;
 
677
        struct file *out;
 
678
        loff_t *ppos;
 
679
        size_t len;
 
680
        unsigned int flags;
 
681
        struct vfsub_args *vargs;
 
682
};
 
683
 
 
684
static void call_splice_from(void *args)
 
685
{
 
686
        struct splice_from_args *a = args;
 
687
        vfsub_ignore(a->vargs);
 
688
        *a->errp = do_vfsub_splice_from(a->pipe, a->out, a->ppos, a->len,
 
689
                                        a->flags);
 
690
        if (unlikely(*a->errp < 0))
 
691
                vfsub_unignore(a->vargs);
 
692
}
 
693
 
 
694
long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out,
 
695
                       loff_t *ppos, size_t len, unsigned int flags,
 
696
                       struct vfsub_args *vargs)
 
697
{
 
698
        long err;
 
699
 
 
700
        if (!vargs->dlgt) {
 
701
                vfsub_ignore(vargs);
 
702
                err = do_vfsub_splice_from(pipe, out, ppos, len, flags);
 
703
                if (unlikely(err < 0))
 
704
                        vfsub_unignore(vargs);
 
705
        } else {
 
706
                int wkq_err;
 
707
                struct splice_from_args args = {
 
708
                        .errp   = &err,
 
709
                        .pipe   = pipe,
 
710
                        .out    = out,
 
711
                        .ppos   = ppos,
 
712
                        .len    = len,
 
713
                        .flags  = flags,
 
714
                        .vargs  = vargs
 
715
                };
 
716
                wkq_err = au_wkq_wait(call_splice_from, &args, /*dlgt*/1);
 
717
                if (unlikely(wkq_err))
 
718
                        err = wkq_err;
 
719
        }
 
720
        return err;
 
721
}
 
722
 
 
723
/* ---------------------------------------------------------------------- */
 
724
 
 
725
struct getattr_args {
 
726
        int *errp;
 
727
        struct vfsmount *mnt;
 
728
        struct dentry *dentry;
 
729
        struct kstat *st;
 
730
};
 
731
 
 
732
static void call_getattr(void *args)
 
733
{
 
734
        struct getattr_args *a = args;
 
735
        *a->errp = do_vfsub_getattr(a->mnt, a->dentry, a->st);
 
736
}
 
737
 
 
738
int vfsub_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *st,
 
739
                  int dlgt)
 
740
{
 
741
        if (!dlgt)
 
742
                return do_vfsub_getattr(mnt, dentry, st);
 
743
        else {
 
744
                int err, wkq_err;
 
745
                struct getattr_args args = {
 
746
                        .errp   = &err,
 
747
                        .mnt    = mnt,
 
748
                        .dentry = dentry,
 
749
                        .st     = st
 
750
                };
 
751
                wkq_err = au_wkq_wait(call_getattr, &args, /*dlgt*/1);
 
752
                if (unlikely(wkq_err))
 
753
                        err = wkq_err;
 
754
                return err;
 
755
        }
 
756
}
 
757
#endif /* CONFIG_AUFS_DLGT || CONFIG_AUFS_HINOTIFY */
 
758
 
 
759
/* ---------------------------------------------------------------------- */
 
760
 
 
761
struct au_vfsub_mkdir_args {
 
762
        int *errp;
 
763
        struct inode *dir;
 
764
        struct dentry *dentry;
 
765
        int mode;
 
766
        int dlgt;
 
767
};
 
768
 
 
769
static void au_call_vfsub_mkdir(void *args)
 
770
{
 
771
        struct au_vfsub_mkdir_args *a = args;
 
772
        *a->errp = vfsub_mkdir(a->dir, a->dentry, a->mode, a->dlgt);
 
773
}
 
774
 
 
775
int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry, int mode,
 
776
                    int dlgt)
 
777
{
 
778
        int err, do_sio, wkq_err;
 
779
 
 
780
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));
 
781
 
 
782
        do_sio = au_test_perm(dir, MAY_EXEC | MAY_WRITE, dlgt);
 
783
        if (!do_sio)
 
784
                err = vfsub_mkdir(dir, dentry, mode, dlgt);
 
785
        else {
 
786
                struct au_vfsub_mkdir_args args = {
 
787
                        .errp   = &err,
 
788
                        .dir    = dir,
 
789
                        .dentry = dentry,
 
790
                        .mode   = mode,
 
791
                        .dlgt   = dlgt
 
792
                };
 
793
                wkq_err = au_wkq_wait(au_call_vfsub_mkdir, &args, /*dlgt*/0);
 
794
                if (unlikely(wkq_err))
 
795
                        err = wkq_err;
 
796
        }
 
797
 
 
798
        AuTraceErr(err);
 
799
        return err;
 
800
}
 
801
 
 
802
struct au_vfsub_rmdir_args {
 
803
        int *errp;
 
804
        struct inode *dir;
 
805
        struct dentry *dentry;
 
806
        struct vfsub_args *vargs;
 
807
};
 
808
 
 
809
static void au_call_vfsub_rmdir(void *args)
 
810
{
 
811
        struct au_vfsub_rmdir_args *a = args;
 
812
        *a->errp = vfsub_rmdir(a->dir, a->dentry, a->vargs);
 
813
}
 
814
 
 
815
int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry, int dlgt)
 
816
{
 
817
        int err, do_sio, wkq_err;
 
818
        struct vfsub_args vargs;
 
819
 
 
820
        LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));
 
821
 
 
822
        vfsub_args_init(&vargs, /*ign*/NULL, dlgt, /*force_unlink*/0);
 
823
        do_sio = au_test_perm(dir, MAY_EXEC | MAY_WRITE, dlgt);
 
824
        if (!do_sio)
 
825
                err = vfsub_rmdir(dir, dentry, &vargs);
 
826
        else {
 
827
                struct au_vfsub_rmdir_args args = {
 
828
                        .errp           = &err,
 
829
                        .dir            = dir,
 
830
                        .dentry         = dentry,
 
831
                        .vargs          = &vargs
 
832
                };
 
833
                wkq_err = au_wkq_wait(au_call_vfsub_rmdir, &args, /*dlgt*/0);
 
834
                if (unlikely(wkq_err))
 
835
                        err = wkq_err;
 
836
        }
 
837
 
 
838
        AuTraceErr(err);
 
839
        return err;
 
840
}
539
841
 
540
842
/* ---------------------------------------------------------------------- */
541
843
 
543
845
        int *errp;
544
846
        struct dentry *h_dentry;
545
847
        struct iattr *ia;
 
848
        struct vfsub_args *vargs;
546
849
};
547
850
 
548
851
static void call_notify_change(void *args)
551
854
        struct inode *h_inode;
552
855
 
553
856
        LKTRTrace("%.*s, ia_valid 0x%x\n",
554
 
                  DLNPair(a->h_dentry), a->ia->ia_valid);
 
857
                  AuDLNPair(a->h_dentry), a->ia->ia_valid);
555
858
        h_inode = a->h_dentry->d_inode;
556
859
        IMustLock(h_inode);
557
860
 
558
861
        *a->errp = -EPERM;
559
862
        if (!IS_IMMUTABLE(h_inode) && !IS_APPEND(h_inode)) {
 
863
                vfsub_ignore(a->vargs);
560
864
                lockdep_off();
561
 
                *a->errp = notify_change(a->h_dentry, NULL, a->ia);
 
865
                *a->errp = notify_change(a->h_dentry, a->ia);
562
866
                lockdep_on();
 
867
                if (!*a->errp)
 
868
                        au_update_fuse_h_inode(NULL, a->h_dentry); /*ignore*/
 
869
                else
 
870
                        vfsub_unignore(a->vargs);
563
871
        }
564
 
        TraceErr(*a->errp);
 
872
        AuTraceErr(*a->errp);
565
873
}
566
874
 
567
 
int vfsub_notify_change(struct dentry *dentry, struct iattr *ia, int dlgt)
 
875
int vfsub_notify_change(struct dentry *dentry, struct iattr *ia,
 
876
                        struct vfsub_args *vargs)
568
877
{
569
878
        int err;
570
879
        struct notify_change_args args = {
571
880
                .errp           = &err,
572
881
                .h_dentry       = dentry,
573
 
                .ia             = ia
 
882
                .ia             = ia,
 
883
                .vargs          = vargs
574
884
        };
575
885
 
576
886
#ifndef CONFIG_AUFS_DLGT
577
887
        call_notify_change(&args);
578
888
#else
579
 
        if (!dlgt)
 
889
        if (!vargs->dlgt)
580
890
                call_notify_change(&args);
581
891
        else {
582
892
                int wkq_err;
586
896
        }
587
897
#endif
588
898
 
589
 
        TraceErr(err);
 
899
        AuTraceErr(err);
590
900
        return err;
591
901
}
592
902
 
596
906
        int *errp;
597
907
        struct inode *dir;
598
908
        struct dentry *dentry;
 
909
        struct vfsub_args *vargs;
599
910
};
600
911
 
601
912
static void call_unlink(void *args)
602
913
{
603
914
        struct unlink_args *a = args;
604
915
        struct inode *h_inode;
605
 
        const int stop_sillyrename = (au_is_nfs(a->dentry->d_sb)
 
916
        const int stop_sillyrename = (au_test_nfs(a->dentry->d_sb)
606
917
                                      && atomic_read(&a->dentry->d_count) == 1);
607
918
 
608
919
        LKTRTrace("%.*s, stop_silly %d, cnt %d\n",
609
 
                  DLNPair(a->dentry), stop_sillyrename,
 
920
                  AuDLNPair(a->dentry), stop_sillyrename,
610
921
                  atomic_read(&a->dentry->d_count));
611
922
        IMustLock(a->dir);
612
923
 
614
925
                dget(a->dentry);
615
926
        h_inode = a->dentry->d_inode;
616
927
        if (h_inode)
617
 
                atomic_inc(&h_inode->i_count);
 
928
                atomic_inc_return(&h_inode->i_count);
618
929
#if 0 // partial testing
619
930
        {
620
931
                struct qstr *name = &a->dentry->d_name;
621
932
                if (name->len == sizeof(AUFS_XINO_FNAME) - 1
622
 
                    && !strncmp(name->name, AUFS_XINO_FNAME, name->len)) {
623
 
                        lockdep_off();
 
933
                    && !strncmp(name->name, AUFS_XINO_FNAME, name->len))
624
934
                        *a->errp = do_vfsub_unlink(a->dir, a->dentry);
625
 
                        lockdep_on();
626
 
                } else
 
935
                else
627
936
                        err = -1;
628
937
        }
629
938
#else
630
 
        // vfs_unlink() locks inode
631
 
        lockdep_off();
632
939
        *a->errp = do_vfsub_unlink(a->dir, a->dentry);
633
 
        lockdep_on();
634
940
#endif
635
941
 
636
942
        if (!stop_sillyrename)
638
944
        if (h_inode)
639
945
                iput(h_inode);
640
946
 
641
 
        TraceErr(*a->errp);
 
947
        AuTraceErr(*a->errp);
642
948
}
643
949
 
644
950
/*
645
951
 * @dir: must be locked.
646
952
 * @dentry: target dentry.
647
953
 */
648
 
int vfsub_unlink(struct inode *dir, struct dentry *dentry, int dlgt)
 
954
int vfsub_unlink(struct inode *dir, struct dentry *dentry,
 
955
                 struct vfsub_args *vargs)
649
956
{
650
957
        int err;
651
958
        struct unlink_args args = {
652
959
                .errp   = &err,
653
960
                .dir    = dir,
654
 
                .dentry = dentry
 
961
                .dentry = dentry,
 
962
                .vargs  = vargs
655
963
        };
656
964
 
657
 
#ifndef CONFIG_AUFS_DLGT
658
 
        call_unlink(&args);
659
 
#else
660
 
        if (!dlgt)
 
965
        if (!vargs->dlgt && !vargs->force_unlink)
661
966
                call_unlink(&args);
662
967
        else {
663
968
                int wkq_err;
664
 
                wkq_err = au_wkq_wait(call_unlink, &args, /*dlgt*/1);
 
969
                wkq_err = au_wkq_wait(call_unlink, &args, vargs->dlgt);
665
970
                if (unlikely(wkq_err))
666
971
                        err = wkq_err;
667
972
        }
668
 
#endif
 
973
 
669
974
        return err;
670
975
}
671
976
 
706
1011
#endif
707
1012
        return err;
708
1013
}
 
1014
 
 
1015
/* ---------------------------------------------------------------------- */
 
1016
 
 
1017
#ifdef CONFIG_AUFS_WORKAROUND_FUSE
 
1018
/* h_mnt can be NULL, is it safe? */
 
1019
int au_update_fuse_h_inode(struct vfsmount *h_mnt, struct dentry *h_dentry)
 
1020
{
 
1021
        int err;
 
1022
        struct kstat st;
 
1023
 
 
1024
        LKTRTrace("%.*s\n", AuDLNPair(h_dentry));
 
1025
 
 
1026
        err = 0;
 
1027
        if (unlikely(h_dentry->d_inode
 
1028
                     //&& atomic_read(&h_dentry->d_inode->i_count)
 
1029
                     && au_test_fuse(h_dentry->d_sb))) {
 
1030
                err = vfsub_getattr(h_mnt, h_dentry, &st, /*dlgt*/0);
 
1031
                if (unlikely(err)) {
 
1032
                        AuDbg("err %d\n", err);
 
1033
                        au_debug_on();
 
1034
                        AuDbgDentry(h_dentry);
 
1035
                        au_debug_off();
 
1036
                        WARN_ON(err);
 
1037
                }
 
1038
        }
 
1039
        return err;
 
1040
}
 
1041
#endif
 
1042
 
 
1043
#if 0 // temp
 
1044
/*
 
1045
 * This function was born after a discussion with the FUSE developer.
 
1046
 * The inode attributes on a filesystem who defines i_op->getattr()
 
1047
 * is unreliable since such fs may not maintain the attributes at lookup.
 
1048
 * This function doesn't want the result of stat, instead wants the side-effect
 
1049
 * which refreshes the attributes.
 
1050
 * Hmm, there seems to be no such filesystem except fuse.
 
1051
 */
 
1052
int vfsub_i_attr(struct vfsmount *mnt, struct dentry *dentry, int dlgt)
 
1053
{
 
1054
        int err;
 
1055
        struct inode *inode;
 
1056
        struct inode_operations *op;
 
1057
        struct kstat st;
 
1058
 
 
1059
        inode = dentry->d_inode;
 
1060
        AuDebugOn(!inode);
 
1061
 
 
1062
        err = 0;
 
1063
        op = inode->i_op;
 
1064
        if (unlikely(op && op->getattr && !au_test_aufs(dentry->d_sb))) {
 
1065
                err = security_inode_getattr(mnt, dentry);
 
1066
                if (!err)
 
1067
                        err = op->getattr(mnt, dentry, &st);
 
1068
        }
 
1069
        AuTraceErr(err);
 
1070
        return err;
 
1071
}
 
1072
#endif