← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to fs/xfs/xfs_btree.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/xfs/xfs_btree.c
32
32
#include "xfs_inode.h"
33
33
#include "xfs_inode_item.h"
34
34
#include "xfs_btree.h"
35
 
#include "xfs_btree_trace.h"
36
35
#include "xfs_error.h"
37
36
#include "xfs_trace.h"
38
37
 
66
65
                be16_to_cpu(block->bb_numrecs) <=
67
66
                        cur->bc_ops->get_maxrecs(cur, level) &&
68
67
                block->bb_u.l.bb_leftsib &&
69
 
                (be64_to_cpu(block->bb_u.l.bb_leftsib) == NULLDFSBNO ||
 
68
                (block->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO) ||
70
69
                 XFS_FSB_SANITY_CHECK(mp,
71
70
                        be64_to_cpu(block->bb_u.l.bb_leftsib))) &&
72
71
                block->bb_u.l.bb_rightsib &&
73
 
                (be64_to_cpu(block->bb_u.l.bb_rightsib) == NULLDFSBNO ||
 
72
                (block->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO) ||
74
73
                 XFS_FSB_SANITY_CHECK(mp,
75
74
                        be64_to_cpu(block->bb_u.l.bb_rightsib)));
76
75
        if (unlikely(XFS_TEST_ERROR(!lblock_ok, mp,
105
104
                be16_to_cpu(block->bb_level) == level &&
106
105
                be16_to_cpu(block->bb_numrecs) <=
107
106
                        cur->bc_ops->get_maxrecs(cur, level) &&
108
 
                (be32_to_cpu(block->bb_u.s.bb_leftsib) == NULLAGBLOCK ||
 
107
                (block->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK) ||
109
108
                 be32_to_cpu(block->bb_u.s.bb_leftsib) < agflen) &&
110
109
                block->bb_u.s.bb_leftsib &&
111
 
                (be32_to_cpu(block->bb_u.s.bb_rightsib) == NULLAGBLOCK ||
 
110
                (block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK) ||
112
111
                 be32_to_cpu(block->bb_u.s.bb_rightsib) < agflen) &&
113
112
                block->bb_u.s.bb_rightsib;
114
113
        if (unlikely(XFS_TEST_ERROR(!sblock_ok, cur->bc_mp,
276
275
                                return error;
277
276
                        }
278
277
                        new->bc_bufs[i] = bp;
279
 
                        ASSERT(bp);
280
 
                        ASSERT(!XFS_BUF_GETERROR(bp));
 
278
                        ASSERT(!xfs_buf_geterror(bp));
281
279
                } else
282
280
                        new->bc_bufs[i] = NULL;
283
281
        }
468
466
        ASSERT(fsbno != NULLFSBLOCK);
469
467
        d = XFS_FSB_TO_DADDR(mp, fsbno);
470
468
        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
471
 
        ASSERT(bp);
472
 
        ASSERT(!XFS_BUF_GETERROR(bp));
 
469
        ASSERT(!xfs_buf_geterror(bp));
473
470
        return bp;
474
471
}
475
472
 
492
489
        ASSERT(agbno != NULLAGBLOCK);
493
490
        d = XFS_AGB_TO_DADDR(mp, agno, agbno);
494
491
        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
495
 
        ASSERT(bp);
496
 
        ASSERT(!XFS_BUF_GETERROR(bp));
 
492
        ASSERT(!xfs_buf_geterror(bp));
497
493
        return bp;
498
494
}
499
495
 
511
507
        block = xfs_btree_get_block(cur, level, &bp);
512
508
        xfs_btree_check_block(cur, block, level, bp);
513
509
        if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
514
 
                return be64_to_cpu(block->bb_u.l.bb_rightsib) == NULLDFSBNO;
 
510
                return block->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO);
515
511
        else
516
 
                return be32_to_cpu(block->bb_u.s.bb_rightsib) == NULLAGBLOCK;
 
512
                return block->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK);
517
513
}
518
514
 
519
515
/*
633
629
                        mp->m_bsize, lock, &bp))) {
634
630
                return error;
635
631
        }
636
 
        ASSERT(!bp || !XFS_BUF_GETERROR(bp));
 
632
        ASSERT(!xfs_buf_geterror(bp));
637
633
        if (bp)
638
 
                XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
 
634
                xfs_buf_set_ref(bp, refval);
639
635
        *bpp = bp;
640
636
        return 0;
641
637
}
777
773
 
778
774
        b = XFS_BUF_TO_BLOCK(bp);
779
775
        if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
780
 
                if (be64_to_cpu(b->bb_u.l.bb_leftsib) == NULLDFSBNO)
 
776
                if (b->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO))
781
777
                        cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
782
 
                if (be64_to_cpu(b->bb_u.l.bb_rightsib) == NULLDFSBNO)
 
778
                if (b->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO))
783
779
                        cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
784
780
        } else {
785
 
                if (be32_to_cpu(b->bb_u.s.bb_leftsib) == NULLAGBLOCK)
 
781
                if (b->bb_u.s.bb_leftsib == cpu_to_be32(NULLAGBLOCK))
786
782
                        cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
787
 
                if (be32_to_cpu(b->bb_u.s.bb_rightsib) == NULLAGBLOCK)
 
783
                if (b->bb_u.s.bb_rightsib == cpu_to_be32(NULLAGBLOCK))
788
784
                        cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
789
785
        }
790
786
}
795
791
        union xfs_btree_ptr     *ptr)
796
792
{
797
793
        if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
798
 
                return be64_to_cpu(ptr->l) == NULLDFSBNO;
 
794
                return ptr->l == cpu_to_be64(NULLDFSBNO);
799
795
        else
800
 
                return be32_to_cpu(ptr->s) == NULLAGBLOCK;
 
796
                return ptr->s == cpu_to_be32(NULLAGBLOCK);
801
797
}
802
798
 
803
799
STATIC void
923
919
        union xfs_btree_ptr     *ptr)
924
920
{
925
921
        if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
926
 
                ASSERT(be64_to_cpu(ptr->l) != NULLDFSBNO);
 
922
                ASSERT(ptr->l != cpu_to_be64(NULLDFSBNO));
927
923
 
928
924
                return XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l));
929
925
        } else {
930
926
                ASSERT(cur->bc_private.a.agno != NULLAGNUMBER);
931
 
                ASSERT(be32_to_cpu(ptr->s) != NULLAGBLOCK);
 
927
                ASSERT(ptr->s != cpu_to_be32(NULLAGBLOCK));
932
928
 
933
929
                return XFS_AGB_TO_DADDR(cur->bc_mp, cur->bc_private.a.agno,
934
930
                                        be32_to_cpu(ptr->s));
943
939
        switch (cur->bc_btnum) {
944
940
        case XFS_BTNUM_BNO:
945
941
        case XFS_BTNUM_CNT:
946
 
                XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, XFS_ALLOC_BTREE_REF);
 
942
                xfs_buf_set_ref(bp, XFS_ALLOC_BTREE_REF);
947
943
                break;
948
944
        case XFS_BTNUM_INO:
949
 
                XFS_BUF_SET_VTYPE_REF(bp, B_FS_INOMAP, XFS_INO_BTREE_REF);
 
945
                xfs_buf_set_ref(bp, XFS_INO_BTREE_REF);
950
946
                break;
951
947
        case XFS_BTNUM_BMAP:
952
 
                XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, XFS_BMAP_BTREE_REF);
 
948
                xfs_buf_set_ref(bp, XFS_BMAP_BTREE_REF);
953
949
                break;
954
950
        default:
955
951
                ASSERT(0);
974
970
        *bpp = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d,
975
971
                                 mp->m_bsize, flags);
976
972
 
977
 
        ASSERT(*bpp);
978
 
        ASSERT(!XFS_BUF_GETERROR(*bpp));
 
973
        if (!*bpp)
 
974
                return ENOMEM;
979
975
 
980
976
        *block = XFS_BUF_TO_BLOCK(*bpp);
981
977
        return 0;
1007
1003
        if (error)
1008
1004
                return error;
1009
1005
 
1010
 
        ASSERT(*bpp != NULL);
1011
 
        ASSERT(!XFS_BUF_GETERROR(*bpp));
 
1006
        ASSERT(!xfs_buf_geterror(*bpp));
1012
1007
 
1013
1008
        xfs_btree_set_refs(cur, *bpp);
1014
1009
        *block = XFS_BUF_TO_BLOCK(*bpp);