← Back to branch summary

~ubuntu-branches/ubuntu/utopic/aufs/utopic

« back to all changes in this revision

Viewing changes to fs/aufs/cpup.c

  • Committer: Bazaar Package Importer
  • Author(s): Julian Andres Klode
  • Date: 2007-06-04 15:17:03 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070604151703-ur9mjtbbpwoga2y6
Tags: 0+20070605-1
* New upstream snapshot
* Remove unionctl

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/aufs/cpup.c
16
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 */
18
18
 
19
 
/* $Id: cpup.c,v 1.36 2007/05/07 03:43:16 sfjro Exp $ */
 
19
/* $Id: cpup.c,v 1.40 2007/06/04 02:17:34 sfjro Exp $ */
20
20
 
21
21
#include <asm/uaccess.h>
22
22
#include "aufs.h"
29
29
        LKTRTrace("i%lu\n", inode->i_ino);
30
30
        //IMustLock(inode);
31
31
        hidden_inode = au_h_iptr(inode);
32
 
        DEBUG_ON(!hidden_inode);
 
32
        AuDebugOn(!hidden_inode);
33
33
        //IMustLock(!hidden_inode);
34
34
 
35
35
        inode->i_atime = hidden_inode->i_atime;
47
47
 
48
48
        LKTRTrace("i%lu\n", inode->i_ino);
49
49
        //IMustLock(inode);
50
 
        DEBUG_ON(!inode->i_mode);
 
50
        AuDebugOn(!inode->i_mode);
51
51
 
52
52
        h_inode = au_h_iptr(inode);
53
53
        inode->i_nlink = h_inode->i_nlink;
74
74
        LKTRTrace("i%lu\n", inode->i_ino);
75
75
        //IMustLock(inode);
76
76
        hidden_inode = au_h_iptr(inode);
77
 
        DEBUG_ON(!hidden_inode);
 
77
        AuDebugOn(!hidden_inode);
78
78
 
79
79
        inode->i_mode = hidden_inode->i_mode;
80
80
        inode->i_uid = hidden_inode->i_uid;
98
98
        LKTRTrace("i%lu\n", inode->i_ino);
99
99
        //IMustLock(inode);
100
100
        hidden_inode = au_h_iptr(inode);
101
 
        DEBUG_ON(!hidden_inode);
 
101
        AuDebugOn(!hidden_inode);
102
102
 
103
103
        au_cpup_attr_changable(inode);
104
104
        if (inode->i_nlink > 0)
125
125
        struct inode *inode;
126
126
 
127
127
        TraceEnter();
128
 
        DEBUG_ON(!dentry || !hidden_dentry || !hidden_dentry->d_inode);
 
128
        AuDebugOn(!dentry || !hidden_dentry || !hidden_dentry->d_inode);
129
129
 
130
130
        dt->dt_dentry = dentry;
131
131
        dt->dt_h_dentry = hidden_dentry;
226
226
 
227
227
        LKTRTrace("dentry %.*s, bdst %d, bsrc %d, len %lld\n",
228
228
                  DLNPair(dentry), bdst, bsrc, len);
229
 
        DEBUG_ON(bsrc <= bdst);
230
 
        DEBUG_ON(!len);
 
229
        AuDebugOn(bsrc <= bdst);
 
230
        AuDebugOn(!len);
231
231
        sb = dentry->d_sb;
232
 
        DEBUG_ON(test_ro(sb, bdst, dentry->d_inode));
 
232
        AuDebugOn(test_ro(sb, bdst, dentry->d_inode));
233
233
        // bsrc branch can be ro/rw.
234
234
 
235
235
        h = hidden;
236
236
        for (i = 0; i < 2; i++, h++) {
237
237
                h->dentry = au_h_dptr_i(dentry, h->bindex);
238
 
                DEBUG_ON(!h->dentry);
 
238
                AuDebugOn(!h->dentry);
239
239
                hidden_inode = h->dentry->d_inode;
240
 
                DEBUG_ON(!hidden_inode || !S_ISREG(hidden_inode->i_mode));
 
240
                AuDebugOn(!hidden_inode || !S_ISREG(hidden_inode->i_mode));
241
241
                h->file = hidden_open(dentry, h->bindex, h->flags);
242
242
                //if (LktrCond)
243
243
                //{fput(h->file); sbr_put(sb, h->bindex); h->file = ERR_PTR(-1);}
297
297
                  DLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,
298
298
                  flags);
299
299
        sb = dentry->d_sb;
300
 
        DEBUG_ON(bdst >= bsrc || test_ro(sb, bdst, NULL));
 
300
        AuDebugOn(bdst >= bsrc || test_ro(sb, bdst, NULL));
301
301
        // bsrc branch can be ro/rw.
302
302
 
303
303
        hidden_src = au_h_dptr_i(dentry, bsrc);
304
 
        DEBUG_ON(!hidden_src);
 
304
        AuDebugOn(!hidden_src);
305
305
        hidden_inode = hidden_src->d_inode;
306
 
        DEBUG_ON(!hidden_inode);
 
306
        AuDebugOn(!hidden_inode);
307
307
 
308
308
        /* stop refrencing while we are creating */
309
 
        //parent = dget_parent(dentry);
310
 
        parent = dentry->d_parent;
 
309
        parent = dget_parent(dentry);
311
310
        dir = parent->d_inode;
312
311
        hidden_dst = au_h_dptr_i(dentry, bdst);
313
 
        DEBUG_ON(hidden_dst && hidden_dst->d_inode);
314
 
        //hidden_parent = dget_parent(hidden_dst);
315
 
        hidden_parent = hidden_dst->d_parent;
 
312
        AuDebugOn(hidden_dst && hidden_dst->d_inode);
 
313
        hidden_parent = dget_parent(hidden_dst);
316
314
        hidden_dir = hidden_parent->d_inode;
317
315
        IMustLock(hidden_dir);
318
316
 
383
381
                break;
384
382
        case S_IFCHR:
385
383
        case S_IFBLK:
386
 
                DEBUG_ON(!capable(CAP_MKNOD));
 
384
                AuDebugOn(!capable(CAP_MKNOD));
387
385
                /*FALLTHROUGH*/
388
386
        case S_IFIFO:
389
387
        case S_IFSOCK:
398
396
 
399
397
        if (do_dt)
400
398
                dtime_revert(&dt, flags & CPUP_LOCKED_GHDIR);
401
 
        //dput(parent);
402
 
        //dput(hidden_parent);
 
399
        dput(parent);
 
400
        dput(hidden_parent);
403
401
        TraceErr(err);
404
402
        return err;
405
403
}
413
411
                loff_t len, unsigned int flags)
414
412
{
415
413
        int err, rerr, isdir, dlgt;
416
 
        struct dentry *hidden_src, *hidden_dst, *parent;//, *h_parent;
 
414
        struct dentry *hidden_src, *hidden_dst, *parent, *h_parent;
417
415
        struct inode *dst_inode, *hidden_dir, *inode, *src_inode;
418
416
        struct super_block *sb;
419
417
        aufs_bindex_t old_ibstart;
423
421
                  DLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,
424
422
                  flags);
425
423
        sb = dentry->d_sb;
426
 
        DEBUG_ON(bsrc <= bdst);
 
424
        AuDebugOn(bsrc <= bdst);
427
425
        hidden_dst = au_h_dptr_i(dentry, bdst);
428
 
        DEBUG_ON(!hidden_dst || hidden_dst->d_inode);
429
 
        //h_parent = dget_parent(hidden_dst);
430
 
        //hidden_dir = h_parent->d_inode;
431
 
        hidden_dir = hidden_dst->d_parent->d_inode;
 
426
        AuDebugOn(!hidden_dst || hidden_dst->d_inode);
 
427
        h_parent = dget_parent(hidden_dst);
 
428
        hidden_dir = h_parent->d_inode;
432
429
        IMustLock(hidden_dir);
433
430
        hidden_src = au_h_dptr_i(dentry, bsrc);
434
 
        DEBUG_ON(!hidden_src || !hidden_src->d_inode);
 
431
        AuDebugOn(!hidden_src || !hidden_src->d_inode);
435
432
        inode = dentry->d_inode;
436
433
        IiMustWriteLock(inode);
437
434
 
450
447
                        err = PTR_ERR(hidden_src);
451
448
                        if (IS_ERR(hidden_src))
452
449
                                goto out;
453
 
                        DEBUG_ON(!hidden_src->d_inode);
 
450
                        AuDebugOn(!hidden_src->d_inode);
454
451
                        // vfs_link() does lock the inode
455
 
                        err = vfsub_link(hidden_src, hidden_dir, hidden_dst, dlgt);
 
452
                        err = vfsub_link(hidden_src, hidden_dir, hidden_dst,
 
453
                                         dlgt);
456
454
                        dput(hidden_src);
457
455
                        goto out;
458
456
                } else
486
484
                        if (src_inode->i_nlink > 1
487
485
                            && au_flag_test(sb, AuFlag_PLINK))
488
486
                                append_plink(sb, inode, hidden_dst, bdst);
489
 
                        else
 
487
                        else {
 
488
                                /* braces are added to stop a warning */
490
489
                                ;//xino_write0(sb, bsrc, src_inode->i_ino);
491
 
                        /* ignore this error */
 
490
                                /* ignore this error */
 
491
                        }
492
492
                }
493
 
                //goto out; /* success */
494
 
                return 0; /* success */
 
493
                goto out; /* success */
495
494
        }
496
495
 
497
496
        /* revert */
498
497
        i_unlock(dst_inode);
499
498
        parent = dget_parent(dentry);
500
 
        //dtime_store(&dt, parent, h_parent);
501
 
        dtime_store(&dt, parent, hidden_dst->d_parent);
 
499
        dtime_store(&dt, parent, h_parent);
502
500
        dput(parent);
503
501
        if (!isdir)
504
502
                rerr = vfsub_unlink(hidden_dir, hidden_dst, dlgt);
512
510
        }
513
511
 
514
512
 out:
515
 
        //dput(h_parent);
 
513
        dput(h_parent);
516
514
        TraceErr(err);
517
515
        return err;
518
516
}
534
532
int sio_cpup_single(struct dentry *dentry, aufs_bindex_t bdst,
535
533
                    aufs_bindex_t bsrc, loff_t len, unsigned int flags)
536
534
{
537
 
        int err;
 
535
        int err, wkq_err;
538
536
        struct dentry *hidden_dentry;
539
537
        umode_t mode;
540
538
 
556
554
                        .len    = len,
557
555
                        .flags  = flags
558
556
                };
559
 
                au_wkq_wait(call_cpup_single, &args, /*dlgt*/0);
 
557
                wkq_err = au_wkq_wait(call_cpup_single, &args, /*dlgt*/0);
 
558
                if (unlikely(wkq_err))
 
559
                        err = wkq_err;
560
560
        }
561
561
 
562
562
        TraceErr(err);
577
577
        LKTRTrace("%.*s, bdst %d, len %Ld, flags 0x%x\n",
578
578
                  DLNPair(dentry), bdst, len, flags);
579
579
        inode = dentry->d_inode;
580
 
        DEBUG_ON(!S_ISDIR(inode->i_mode) && dbstart(dentry) < bdst);
 
580
        AuDebugOn(!S_ISDIR(inode->i_mode) && dbstart(dentry) < bdst);
581
581
 
582
582
        bend = dbend(dentry);
583
583
        for (bsrc = bdst + 1; bsrc <= bend; bsrc++)
584
584
                if (au_h_dptr_i(dentry, bsrc))
585
585
                        break;
586
 
        DEBUG_ON(!au_h_dptr_i(dentry, bsrc));
 
586
        AuDebugOn(!au_h_dptr_i(dentry, bsrc));
587
587
 
588
588
        err = lkup_neg(dentry, bdst);
589
589
        //err = -1;
618
618
int sio_cpup_simple(struct dentry *dentry, aufs_bindex_t bdst, loff_t len,
619
619
                    unsigned int flags)
620
620
{
621
 
        int err, do_sio, dlgt;
622
 
        //struct dentry *parent;
 
621
        int err, do_sio, dlgt, wkq_err;
 
622
        struct dentry *parent;
623
623
        struct inode *hidden_dir, *dir;
624
624
 
625
625
        LKTRTrace("%.*s, b%d, len %Ld, flags 0x%x\n",
626
626
                  DLNPair(dentry), bdst, len, flags);
627
627
 
628
 
        //parent = dget_parent(dentry);
629
 
        //dir = parent->d_inode;
630
 
        dir = dentry->d_parent->d_inode;
 
628
        parent = dget_parent(dentry);
 
629
        dir = parent->d_inode;
631
630
        hidden_dir = au_h_iptr_i(dir, bdst);
632
631
        dlgt = need_dlgt(dir->i_sb);
633
632
        do_sio = au_test_perm(hidden_dir, MAY_EXEC | MAY_WRITE, dlgt);
646
645
                        .len    = len,
647
646
                        .flags  = flags
648
647
                };
649
 
                au_wkq_wait(call_cpup_simple, &args, /*dlgt*/0);
 
648
                wkq_err = au_wkq_wait(call_cpup_simple, &args, /*dlgt*/0);
 
649
                if (unlikely(wkq_err))
 
650
                        err = wkq_err;
650
651
        }
651
652
 
652
 
        //dput(parent);
 
653
        dput(parent);
653
654
        TraceErr(err);
654
655
        return err;
655
656
}
666
667
        LKTRTrace("%.*s, b%d, parent i%lu, locked %p\n",
667
668
                  DLNPair(dentry), bdst, parent_ino(dentry), locked);
668
669
        sb = dentry->d_sb;
669
 
        DEBUG_ON(test_ro(sb, bdst, NULL));
 
670
        AuDebugOn(test_ro(sb, bdst, NULL));
670
671
        parent = dentry->d_parent;
671
672
        IiMustWriteLock(parent->d_inode);
672
673
        if (unlikely(IS_ROOT(parent)))
707
708
 
708
709
                        if (au_h_dptr_i(d, bdst))
709
710
                                au_update_dbstart(d);
710
 
                        //DEBUG_ON(dbstart(d) <= bdst);
 
711
                        //AuDebugOn(dbstart(d) <= bdst);
711
712
                        if (parent != locked)
712
713
                                di_read_lock_parent3(parent, AUFS_I_RLOCK);
713
714
                        h_gdir = gdir = NULL;