be                144 arch/arc/include/asm/arcregs.h 	unsigned int div_rem:4, pad2:4, ldd:1, unalign:1, atomic:1, be:1,
be                147 arch/arc/include/asm/arcregs.h 	unsigned int ver:8, pad1:12, be:1, atomic:1, unalign:1,
be                179 arch/arc/include/asm/entry-arcv2.h 	;  - for K mode, it will be implicitly restored as stack is unwound
be                 30 arch/arc/include/asm/tlb-mmu1.h ; -- should be in cache since in same line
be                 77 arch/arc/include/asm/tlb-mmu1.h ; Always checks whether instruction will be kicked out by dtlb miss
be                259 arch/arc/kernel/setup.c 		cpu->isa.be = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN);
be                285 arch/arc/kernel/setup.c 		       IS_AVAIL1(cpu->isa.be, "[Big-Endian]"),
be                158 arch/arm/include/asm/kvm_host.h 	bool		be;
be                 75 arch/arm/kvm/reset.c 		if (vcpu->arch.reset_state.be)
be                240 arch/arm64/include/asm/kvm_host.h 	bool		be;
be                321 arch/arm64/kvm/reset.c 		if (vcpu->arch.reset_state.be)
be                102 arch/ia64/include/asm/native/inst.h 	rsm psr.be | psr.i
be                 87 arch/ia64/include/asm/processor.h 	__u64 be : 1;
be                293 arch/ia64/kernel/signal.c 	ia64_psr(&scr->pt)->be = 0;			/* force little-endian byte-order */
be               1308 arch/ia64/kernel/unaligned.c 	if (ia64_psr(regs)->be) {
be                 66 arch/m68k/fpsp040/fpsp.h |	a second fsave frame can be pushed onto the stack and the
be                 70 arch/m68k/fpsp040/fpsp.h |	restored from the "local variable" area and can be used as
be                306 arch/m68k/fpsp040/fpsp.h |				this can only be used if in a data register
be               16332 arch/m68k/ifpsp060/src/fpsp.S # if the NAN bit is set, in which case BSUN and AIOP will be set.	#
be               16960 arch/m68k/ifpsp060/src/fpsp.S # if the NAN bit is set, in which case BSUN and AIOP will be set.	#
be               17530 arch/m68k/ifpsp060/src/fpsp.S # if the NAN bit is set, in which case BSUN and AIOP will be set.	#
be                116 arch/mips/include/asm/mach-cavium-octeon/kernel-entry-init.h 	# Get the core id of the next to be booted
be                 47 arch/powerpc/include/asm/bitops.h #define PPC_BITLSHIFT(be)	(BITS_PER_LONG - 1 - (be))
be                 49 arch/powerpc/include/asm/bitops.h #define PPC_BITMASK(bs, be)	((PPC_BIT(bs) - PPC_BIT(be)) | PPC_BIT(bs))
be                 55 arch/powerpc/include/asm/bitops.h #define PPC_BITLSHIFT32(be)	(32 - 1 - (be))
be                 57 arch/powerpc/include/asm/bitops.h #define PPC_BITMASK32(bs, be)	((PPC_BIT32(bs) - PPC_BIT32(be))|PPC_BIT32(bs))
be                 59 arch/powerpc/include/asm/bitops.h #define PPC_BITLSHIFT8(be)	(8 - 1 - (be))
be                 61 arch/powerpc/include/asm/bitops.h #define PPC_BITMASK8(bs, be)	((PPC_BIT8(bs) - PPC_BIT8(be))|PPC_BIT8(bs))
be                930 arch/powerpc/include/asm/kvm_ppc.h 	       return be##size##_to_cpu(vcpu->arch.shared->reg);	\
be                158 arch/powerpc/lib/rheap.c 	unsigned long s, e, bs, be;
be                176 arch/powerpc/lib/rheap.c 		be = bs + blk->size;
be                181 arch/powerpc/lib/rheap.c 		if (be == s)
be                374 arch/powerpc/lib/rheap.c 	unsigned long s, e, m, bs, be;
be                399 arch/powerpc/lib/rheap.c 		be = blk->start + blk->size;
be                400 arch/powerpc/lib/rheap.c 		if (s >= bs && e <= be)
be                409 arch/powerpc/lib/rheap.c 	if (bs == s && be == e) {
be                417 arch/powerpc/lib/rheap.c 	if (bs == s || be == e) {
be                429 arch/powerpc/lib/rheap.c 		newblk->size = be - e;
be                531 arch/powerpc/lib/rheap.c 	unsigned long s, e, m, bs = 0, be = 0;
be                556 arch/powerpc/lib/rheap.c 		be = blk->start + blk->size;
be                557 arch/powerpc/lib/rheap.c 		if (s >= bs && e <= be)
be                566 arch/powerpc/lib/rheap.c 	if (bs == s && be == e) {
be                579 arch/powerpc/lib/rheap.c 	if (bs == s || be == e) {
be                591 arch/powerpc/lib/rheap.c 		newblk2->size = be - e;
be                196 arch/powerpc/platforms/cell/cbe_regs.c 		struct device_node *be, *np;
be                198 arch/powerpc/platforms/cell/cbe_regs.c 		be = map->be_node;
be                201 arch/powerpc/platforms/cell/cbe_regs.c 			if (of_get_parent(np) == be)
be                205 arch/powerpc/platforms/cell/cbe_regs.c 			if (of_get_parent(np) == be)
be                209 arch/powerpc/platforms/cell/cbe_regs.c 			if (of_get_parent(np) == be)
be                 29 arch/sparc/include/asm/asm.h 	be		DEST
be                 32 arch/sparc/include/asm/asm.h 	be,a		DEST
be                 47 arch/sparc/include/asm/head_64.h 	be,pn	%icc, label;			\
be                 56 arch/sparc/include/asm/head_64.h 	be,pn	%icc, label;			\
be                184 arch/sparc/include/asm/tsb.h 	be,pn		%xcc, 698f; \
be                219 arch/sparc/include/asm/tsb.h 	be,pt		%xcc, 700f;			\
be                248 arch/sparc/include/asm/tsb.h 	be,pt		%xcc, 700f;			\
be                354 arch/sparc/include/asm/tsb.h 	be,a,pt		%xcc, OK_LABEL; \
be                376 arch/sparc/include/asm/tsb.h 	be,a,pt		%xcc, OK_LABEL; \
be                 18 arch/sparc/include/asm/visasm.h 	be,pt		%icc, 297f;			\
be                 40 arch/sparc/include/asm/visasm.h 	be,pt		%icc, 297f;			\
be                 61 arch/x86/kernel/kprobes/core.c #define W(row, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf)\
be                 65 arch/x86/kernel/kprobes/core.c 	  (bc##UL << 0xc)|(bd##UL << 0xd)|(be##UL << 0xe)|(bf##UL << 0xf))    \
be                 46 arch/x86/kernel/uprobes.c #define W(row, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf)\
be                 50 arch/x86/kernel/uprobes.c 	  (bc##UL << 0xc)|(bd##UL << 0xd)|(be##UL << 0xe)|(bf##UL << 0xf))    \
be               2881 arch/x86/kvm/vmx/nested.c 		CC_SET(be)
be               2882 arch/x86/kvm/vmx/nested.c 	      : ASM_CALL_CONSTRAINT, CC_OUT(be) (vm_fail)
be                316 drivers/atm/ambassador.c   __be32 be = cpu_to_be32 (data);
be                317 drivers/atm/ambassador.c   PRINTD (DBG_FLOW|DBG_REGS, "wr: %08zx <- %08x b[%08x]", addr, data, be);
be                319 drivers/atm/ambassador.c   dev->membase[addr / sizeof(u32)] = be;
be                321 drivers/atm/ambassador.c   outl (be, dev->iobase + addr);
be                327 drivers/atm/ambassador.c   __be32 be = dev->membase[addr / sizeof(u32)];
be                329 drivers/atm/ambassador.c   __be32 be = inl (dev->iobase + addr);
be                331 drivers/atm/ambassador.c   u32 data = be32_to_cpu (be);
be                332 drivers/atm/ambassador.c   PRINTD (DBG_FLOW|DBG_REGS, "rd: %08zx -> %08x b[%08x]", addr, data, be);
be                536 drivers/block/xen-blkback/blkback.c 	struct xenbus_device *dev = xen_blkbk_xenbus(blkif->be);
be               1085 drivers/block/xen-blkback/blkback.c 		xen_blkbk_flush_diskcache(XBT_NIL, pending_req->ring->blkif->be, 0);
be               1090 drivers/block/xen-blkback/blkback.c 		xen_blkbk_barrier(XBT_NIL, pending_req->ring->blkif->be, 0);
be                311 drivers/block/xen-blkback/common.h 	struct backend_info	*be;
be                388 drivers/block/xen-blkback/common.h 			      struct backend_info *be, int state);
be                391 drivers/block/xen-blkback/common.h 		      struct backend_info *be, int state);
be                392 drivers/block/xen-blkback/common.h struct xenbus_device *xen_blkbk_xenbus(struct backend_info *be);
be                 38 drivers/block/xen-blkback/xenbus.c struct xenbus_device *xen_blkbk_xenbus(struct backend_info *be)
be                 40 drivers/block/xen-blkback/xenbus.c 	return be->dev;
be                 58 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = blkif->be->dev;
be                 88 drivers/block/xen-blkback/xenbus.c 	if (blkif->be->dev->state == XenbusStateConnected)
be                 92 drivers/block/xen-blkback/xenbus.c 	connect(blkif->be);
be                 93 drivers/block/xen-blkback/xenbus.c 	if (blkif->be->dev->state != XenbusStateConnected)
be                 98 drivers/block/xen-blkback/xenbus.c 		xenbus_dev_error(blkif->be->dev, err, "get blkback dev name");
be                104 drivers/block/xen-blkback/xenbus.c 		xenbus_dev_error(blkif->be->dev, err, "block flush");
be                115 drivers/block/xen-blkback/xenbus.c 			xenbus_dev_fatal(blkif->be->dev, err,
be                198 drivers/block/xen-blkback/xenbus.c 	err = xenbus_map_ring_valloc(blkif->be->dev, gref, nr_grefs,
be                236 drivers/block/xen-blkback/xenbus.c 		xenbus_unmap_ring_vfree(blkif->be->dev, ring->blk_ring);
be                278 drivers/block/xen-blkback/xenbus.c 			xenbus_unmap_ring_vfree(blkif->be->dev, ring->blk_ring);
be                327 drivers/block/xen-blkback/xenbus.c 	kfree(blkif->be->mode);
be                328 drivers/block/xen-blkback/xenbus.c 	kfree(blkif->be);
be                356 drivers/block/xen-blkback/xenbus.c 		struct backend_info *be = dev_get_drvdata(&dev->dev);	\
be                357 drivers/block/xen-blkback/xenbus.c 		struct xen_blkif *blkif = be->blkif;			\
be                405 drivers/block/xen-blkback/xenbus.c 		struct backend_info *be = dev_get_drvdata(&dev->dev);	\
be                411 drivers/block/xen-blkback/xenbus.c VBD_SHOW(physical_device, "%x:%x\n", be->major, be->minor);
be                412 drivers/block/xen-blkback/xenbus.c VBD_SHOW(mode, "%s\n", be->mode);
be                504 drivers/block/xen-blkback/xenbus.c 	struct backend_info *be = dev_get_drvdata(&dev->dev);
be                508 drivers/block/xen-blkback/xenbus.c 	if (be->major || be->minor)
be                511 drivers/block/xen-blkback/xenbus.c 	if (be->backend_watch.node) {
be                512 drivers/block/xen-blkback/xenbus.c 		unregister_xenbus_watch(&be->backend_watch);
be                513 drivers/block/xen-blkback/xenbus.c 		kfree(be->backend_watch.node);
be                514 drivers/block/xen-blkback/xenbus.c 		be->backend_watch.node = NULL;
be                519 drivers/block/xen-blkback/xenbus.c 	if (be->blkif) {
be                520 drivers/block/xen-blkback/xenbus.c 		xen_blkif_disconnect(be->blkif);
be                523 drivers/block/xen-blkback/xenbus.c 		xen_blkif_put(be->blkif);
be                530 drivers/block/xen-blkback/xenbus.c 			      struct backend_info *be, int state)
be                532 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                543 drivers/block/xen-blkback/xenbus.c static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info *be)
be                545 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                546 drivers/block/xen-blkback/xenbus.c 	struct xen_blkif *blkif = be->blkif;
be                549 drivers/block/xen-blkback/xenbus.c 	struct block_device *bdev = be->blkif->vbd.bdev;
be                586 drivers/block/xen-blkback/xenbus.c 		      struct backend_info *be, int state)
be                588 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                608 drivers/block/xen-blkback/xenbus.c 	struct backend_info *be = kzalloc(sizeof(struct backend_info),
be                614 drivers/block/xen-blkback/xenbus.c 	if (!be) {
be                619 drivers/block/xen-blkback/xenbus.c 	be->dev = dev;
be                620 drivers/block/xen-blkback/xenbus.c 	dev_set_drvdata(&dev->dev, be);
be                622 drivers/block/xen-blkback/xenbus.c 	be->blkif = xen_blkif_alloc(dev->otherend_id);
be                623 drivers/block/xen-blkback/xenbus.c 	if (IS_ERR(be->blkif)) {
be                624 drivers/block/xen-blkback/xenbus.c 		err = PTR_ERR(be->blkif);
be                625 drivers/block/xen-blkback/xenbus.c 		be->blkif = NULL;
be                645 drivers/block/xen-blkback/xenbus.c 	be->blkif->be = be;
be                647 drivers/block/xen-blkback/xenbus.c 	err = xenbus_watch_pathfmt(dev, &be->backend_watch, backend_changed,
be                681 drivers/block/xen-blkback/xenbus.c 	struct backend_info *be
be                683 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                705 drivers/block/xen-blkback/xenbus.c 	if (be->major | be->minor) {
be                706 drivers/block/xen-blkback/xenbus.c 		if (be->major != major || be->minor != minor)
be                708 drivers/block/xen-blkback/xenbus.c 				be->major, be->minor, major, minor);
be                712 drivers/block/xen-blkback/xenbus.c 	be->mode = xenbus_read(XBT_NIL, dev->nodename, "mode", NULL);
be                713 drivers/block/xen-blkback/xenbus.c 	if (IS_ERR(be->mode)) {
be                714 drivers/block/xen-blkback/xenbus.c 		err = PTR_ERR(be->mode);
be                715 drivers/block/xen-blkback/xenbus.c 		be->mode = NULL;
be                729 drivers/block/xen-blkback/xenbus.c 		kfree(be->mode);
be                730 drivers/block/xen-blkback/xenbus.c 		be->mode = NULL;
be                734 drivers/block/xen-blkback/xenbus.c 	be->major = major;
be                735 drivers/block/xen-blkback/xenbus.c 	be->minor = minor;
be                737 drivers/block/xen-blkback/xenbus.c 	err = xen_vbd_create(be->blkif, handle, major, minor,
be                738 drivers/block/xen-blkback/xenbus.c 			     !strchr(be->mode, 'w'), cdrom);
be                745 drivers/block/xen-blkback/xenbus.c 			xen_vbd_free(&be->blkif->vbd);
be                751 drivers/block/xen-blkback/xenbus.c 		kfree(be->mode);
be                752 drivers/block/xen-blkback/xenbus.c 		be->mode = NULL;
be                753 drivers/block/xen-blkback/xenbus.c 		be->major = 0;
be                754 drivers/block/xen-blkback/xenbus.c 		be->minor = 0;
be                757 drivers/block/xen-blkback/xenbus.c 		xen_update_blkif_status(be->blkif);
be                768 drivers/block/xen-blkback/xenbus.c 	struct backend_info *be = dev_get_drvdata(&dev->dev);
be                795 drivers/block/xen-blkback/xenbus.c 		err = xen_blkif_disconnect(be->blkif);
be                801 drivers/block/xen-blkback/xenbus.c 		err = connect_ring(be);
be                807 drivers/block/xen-blkback/xenbus.c 			xen_blkif_disconnect(be->blkif);
be                810 drivers/block/xen-blkback/xenbus.c 		xen_update_blkif_status(be->blkif);
be                818 drivers/block/xen-blkback/xenbus.c 		xen_blkif_disconnect(be->blkif);
be                844 drivers/block/xen-blkback/xenbus.c static void connect(struct backend_info *be)
be                848 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                861 drivers/block/xen-blkback/xenbus.c 	xen_blkbk_flush_diskcache(xbt, be, be->blkif->vbd.flush_support);
be                863 drivers/block/xen-blkback/xenbus.c 	xen_blkbk_discard(xbt, be);
be                865 drivers/block/xen-blkback/xenbus.c 	xen_blkbk_barrier(xbt, be, be->blkif->vbd.flush_support);
be                875 drivers/block/xen-blkback/xenbus.c 			    (unsigned long long)vbd_sz(&be->blkif->vbd));
be                884 drivers/block/xen-blkback/xenbus.c 			    be->blkif->vbd.type |
be                885 drivers/block/xen-blkback/xenbus.c 			    (be->blkif->vbd.readonly ? VDISK_READONLY : 0));
be                893 drivers/block/xen-blkback/xenbus.c 			    bdev_logical_block_size(be->blkif->vbd.bdev));
be                900 drivers/block/xen-blkback/xenbus.c 			    bdev_physical_block_size(be->blkif->vbd.bdev));
be                930 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = blkif->be->dev;
be               1024 drivers/block/xen-blkback/xenbus.c static int connect_ring(struct backend_info *be)
be               1026 drivers/block/xen-blkback/xenbus.c 	struct xenbus_device *dev = be->dev;
be               1027 drivers/block/xen-blkback/xenbus.c 	struct xen_blkif *blkif = be->blkif;
be                405 drivers/crypto/caam/desc_constr.h APPEND_CMD_RAW_IMM2(load, LOAD, be, 32);
be                 82 drivers/crypto/caam/regs.h 		return be##len ## _to_cpu((__force __be##len)val);	\
be                249 drivers/dma/fsldma.h 			fsl_ioread##width##be(addr) : fsl_ioread##width(addr))
be                253 drivers/dma/fsldma.h 			fsl_iowrite##width##be(val, addr) : fsl_iowrite	\
be                258 drivers/dma/fsldma.h 			be##width##_to_cpu((__force __be##width)(v##width)d) : \
be                283 drivers/hwmon/applesmc.c 	__be32 be;
be                286 drivers/hwmon/applesmc.c 	ret = read_smc(APPLESMC_READ_CMD, KEY_COUNT_KEY, (u8 *)&be, 4);
be                290 drivers/hwmon/applesmc.c 	*count = be32_to_cpu(be);
be                332 drivers/hwmon/applesmc.c 	__be32 be;
be                342 drivers/hwmon/applesmc.c 	be = cpu_to_be32(index);
be                343 drivers/hwmon/applesmc.c 	ret = read_smc(APPLESMC_GET_KEY_BY_INDEX_CMD, (u8 *)&be, key, 4);
be                660 drivers/i2c/busses/i2c-ocores.c 		bool be = pdata ? pdata->big_endian :
be                670 drivers/i2c/busses/i2c-ocores.c 			i2c->setreg = be ? oc_setreg_16be : oc_setreg_16;
be                671 drivers/i2c/busses/i2c-ocores.c 			i2c->getreg = be ? oc_getreg_16be : oc_getreg_16;
be                675 drivers/i2c/busses/i2c-ocores.c 			i2c->setreg = be ? oc_setreg_32be : oc_setreg_32;
be                676 drivers/i2c/busses/i2c-ocores.c 			i2c->getreg = be ? oc_getreg_32be : oc_getreg_32;
be                 92 drivers/misc/cxl/pci.c #define EXTRACT_PPC_BITS(val, bs, be)	((val & PPC_BITMASK(bs, be)) >> PPC_BITLSHIFT(be))
be               1900 drivers/misc/vmw_vmci/vmci_queue_pair.c 	struct qp_broker_entry *be;
be               1905 drivers/misc/vmw_vmci/vmci_queue_pair.c 		be = (struct qp_broker_entry *)entry;
be               1908 drivers/misc/vmw_vmci/vmci_queue_pair.c 		kfree(be);
be               1462 drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c 		__be32 *be = (__be32 *)buf;
be               1465 drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c 			*buf++ = be32_to_cpu(*be++);
be                978 drivers/net/ethernet/cavium/thunder/nicvf_queues.c 		qs_cfg->be = 1;
be                678 drivers/net/ethernet/cavium/thunder/q_struct.h 	u64 be:1;
be                684 drivers/net/ethernet/cavium/thunder/q_struct.h 	u64 be:1;
be               8510 drivers/net/ethernet/mellanox/mlxsw/reg.h MLXSW_ITEM32(reg, mpat, be, 0x04, 25, 1);
be                 28 drivers/net/phy/mdio-boardinfo.c 	struct mdio_board_entry *be;
be                 34 drivers/net/phy/mdio-boardinfo.c 	list_for_each_entry_safe(be, tmp, &mdio_board_list, list) {
be                 35 drivers/net/phy/mdio-boardinfo.c 		bi = &be->board_info;
be                 63 drivers/net/phy/mdio-boardinfo.c 	struct mdio_board_entry *be;
be                 66 drivers/net/phy/mdio-boardinfo.c 	be = kcalloc(n, sizeof(*be), GFP_KERNEL);
be                 67 drivers/net/phy/mdio-boardinfo.c 	if (!be)
be                 70 drivers/net/phy/mdio-boardinfo.c 	for (i = 0; i < n; i++, be++, info++) {
be                 71 drivers/net/phy/mdio-boardinfo.c 		memcpy(&be->board_info, info, sizeof(*info));
be                 73 drivers/net/phy/mdio-boardinfo.c 		list_add_tail(&be->list, &mdio_board_list);
be                348 drivers/net/tun.c 	int be = !!(tun->flags & TUN_VNET_BE);
be                350 drivers/net/tun.c 	if (put_user(be, argp))
be                358 drivers/net/tun.c 	int be;
be                360 drivers/net/tun.c 	if (get_user(be, argp))
be                363 drivers/net/tun.c 	if (be)
be                302 drivers/net/xen-netback/common.h 	struct backend_info *be;
be                 13 drivers/net/xen-netback/xenbus.c static int connect_data_rings(struct backend_info *be,
be                 15 drivers/net/xen-netback/xenbus.c static void connect(struct backend_info *be);
be                 16 drivers/net/xen-netback/xenbus.c static int read_xenbus_vif_flags(struct backend_info *be);
be                 17 drivers/net/xen-netback/xenbus.c static int backend_create_xenvif(struct backend_info *be);
be                 18 drivers/net/xen-netback/xenbus.c static void unregister_hotplug_status_watch(struct backend_info *be);
be                 20 drivers/net/xen-netback/xenbus.c static void set_backend_state(struct backend_info *be,
be                200 drivers/net/xen-netback/xenbus.c 	struct backend_info *be = dev_get_drvdata(&dev->dev);
be                202 drivers/net/xen-netback/xenbus.c 	set_backend_state(be, XenbusStateClosed);
be                204 drivers/net/xen-netback/xenbus.c 	unregister_hotplug_status_watch(be);
be                205 drivers/net/xen-netback/xenbus.c 	if (be->vif) {
be                207 drivers/net/xen-netback/xenbus.c 		xen_unregister_watchers(be->vif);
be                209 drivers/net/xen-netback/xenbus.c 		xenvif_free(be->vif);
be                210 drivers/net/xen-netback/xenbus.c 		be->vif = NULL;
be                212 drivers/net/xen-netback/xenbus.c 	kfree(be->hotplug_script);
be                213 drivers/net/xen-netback/xenbus.c 	kfree(be);
be                231 drivers/net/xen-netback/xenbus.c 	struct backend_info *be = kzalloc(sizeof(struct backend_info),
be                233 drivers/net/xen-netback/xenbus.c 	if (!be) {
be                239 drivers/net/xen-netback/xenbus.c 	be->dev = dev;
be                240 drivers/net/xen-netback/xenbus.c 	dev_set_drvdata(&dev->dev, be);
be                242 drivers/net/xen-netback/xenbus.c 	be->state = XenbusStateInitialising;
be                357 drivers/net/xen-netback/xenbus.c 	be->hotplug_script = script;
be                361 drivers/net/xen-netback/xenbus.c 	err = backend_create_xenvif(be);
be                385 drivers/net/xen-netback/xenbus.c 	struct backend_info *be = dev_get_drvdata(&xdev->dev);
be                387 drivers/net/xen-netback/xenbus.c 	if (!be)
be                390 drivers/net/xen-netback/xenbus.c 	if (add_uevent_var(env, "script=%s", be->hotplug_script))
be                393 drivers/net/xen-netback/xenbus.c 	if (!be->vif)
be                396 drivers/net/xen-netback/xenbus.c 	return add_uevent_var(env, "vif=%s", be->vif->dev->name);
be                400 drivers/net/xen-netback/xenbus.c static int backend_create_xenvif(struct backend_info *be)
be                404 drivers/net/xen-netback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                407 drivers/net/xen-netback/xenbus.c 	if (be->vif != NULL)
be                422 drivers/net/xen-netback/xenbus.c 	be->vif = vif;
be                423 drivers/net/xen-netback/xenbus.c 	vif->be = be;
be                429 drivers/net/xen-netback/xenbus.c static void backend_disconnect(struct backend_info *be)
be                431 drivers/net/xen-netback/xenbus.c 	struct xenvif *vif = be->vif;
be                459 drivers/net/xen-netback/xenbus.c static void backend_connect(struct backend_info *be)
be                461 drivers/net/xen-netback/xenbus.c 	if (be->vif)
be                462 drivers/net/xen-netback/xenbus.c 		connect(be);
be                465 drivers/net/xen-netback/xenbus.c static inline void backend_switch_state(struct backend_info *be,
be                468 drivers/net/xen-netback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                471 drivers/net/xen-netback/xenbus.c 	be->state = state;
be                476 drivers/net/xen-netback/xenbus.c 	if (!be->have_hotplug_status_watch)
be                500 drivers/net/xen-netback/xenbus.c static void set_backend_state(struct backend_info *be,
be                503 drivers/net/xen-netback/xenbus.c 	while (be->state != state) {
be                504 drivers/net/xen-netback/xenbus.c 		switch (be->state) {
be                510 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateInitWait);
be                513 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateClosed);
be                523 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateInitWait);
be                526 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateClosing);
be                535 drivers/net/xen-netback/xenbus.c 				backend_connect(be);
be                536 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateConnected);
be                540 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateClosing);
be                551 drivers/net/xen-netback/xenbus.c 				backend_disconnect(be);
be                552 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateClosing);
be                563 drivers/net/xen-netback/xenbus.c 				backend_switch_state(be, XenbusStateClosed);
be                581 drivers/net/xen-netback/xenbus.c 	struct backend_info *be = dev_get_drvdata(&dev->dev);
be                585 drivers/net/xen-netback/xenbus.c 	be->frontend_state = frontend_state;
be                589 drivers/net/xen-netback/xenbus.c 		set_backend_state(be, XenbusStateInitWait);
be                596 drivers/net/xen-netback/xenbus.c 		set_backend_state(be, XenbusStateConnected);
be                600 drivers/net/xen-netback/xenbus.c 		set_backend_state(be, XenbusStateClosing);
be                604 drivers/net/xen-netback/xenbus.c 		set_backend_state(be, XenbusStateClosed);
be                609 drivers/net/xen-netback/xenbus.c 		set_backend_state(be, XenbusStateClosed);
be                802 drivers/net/xen-netback/xenbus.c static void unregister_hotplug_status_watch(struct backend_info *be)
be                804 drivers/net/xen-netback/xenbus.c 	if (be->have_hotplug_status_watch) {
be                805 drivers/net/xen-netback/xenbus.c 		unregister_xenbus_watch(&be->hotplug_status_watch);
be                806 drivers/net/xen-netback/xenbus.c 		kfree(be->hotplug_status_watch.node);
be                808 drivers/net/xen-netback/xenbus.c 	be->have_hotplug_status_watch = 0;
be                815 drivers/net/xen-netback/xenbus.c 	struct backend_info *be = container_of(watch,
be                821 drivers/net/xen-netback/xenbus.c 	str = xenbus_read(XBT_NIL, be->dev->nodename, "hotplug-status", &len);
be                826 drivers/net/xen-netback/xenbus.c 		xenbus_switch_state(be->dev, be->state);
be                829 drivers/net/xen-netback/xenbus.c 		unregister_hotplug_status_watch(be);
be                834 drivers/net/xen-netback/xenbus.c static int connect_ctrl_ring(struct backend_info *be)
be                836 drivers/net/xen-netback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                837 drivers/net/xen-netback/xenbus.c 	struct xenvif *vif = be->vif;
be                876 drivers/net/xen-netback/xenbus.c static void connect(struct backend_info *be)
be                879 drivers/net/xen-netback/xenbus.c 	struct xenbus_device *dev = be->dev;
be                898 drivers/net/xen-netback/xenbus.c 	err = xen_net_read_mac(dev, be->vif->fe_dev_addr);
be                905 drivers/net/xen-netback/xenbus.c 	xen_unregister_watchers(be->vif);
be                906 drivers/net/xen-netback/xenbus.c 	xen_register_watchers(dev, be->vif);
be                907 drivers/net/xen-netback/xenbus.c 	read_xenbus_vif_flags(be);
be                909 drivers/net/xen-netback/xenbus.c 	err = connect_ctrl_ring(be);
be                916 drivers/net/xen-netback/xenbus.c 	be->vif->queues = vzalloc(array_size(requested_num_queues,
be                918 drivers/net/xen-netback/xenbus.c 	if (!be->vif->queues) {
be                924 drivers/net/xen-netback/xenbus.c 	be->vif->num_queues = requested_num_queues;
be                925 drivers/net/xen-netback/xenbus.c 	be->vif->stalled_queues = requested_num_queues;
be                928 drivers/net/xen-netback/xenbus.c 		queue = &be->vif->queues[queue_index];
be                929 drivers/net/xen-netback/xenbus.c 		queue->vif = be->vif;
be                932 drivers/net/xen-netback/xenbus.c 				be->vif->dev->name, queue->id);
be                942 drivers/net/xen-netback/xenbus.c 			be->vif->num_queues = queue_index;
be                950 drivers/net/xen-netback/xenbus.c 		err = connect_data_rings(be, queue);
be                958 drivers/net/xen-netback/xenbus.c 			be->vif->num_queues = queue_index;
be                964 drivers/net/xen-netback/xenbus.c 	xenvif_debugfs_addif(be->vif);
be                971 drivers/net/xen-netback/xenbus.c 	netif_set_real_num_tx_queues(be->vif->dev, requested_num_queues);
be                972 drivers/net/xen-netback/xenbus.c 	netif_set_real_num_rx_queues(be->vif->dev, requested_num_queues);
be                975 drivers/net/xen-netback/xenbus.c 	xenvif_carrier_on(be->vif);
be                977 drivers/net/xen-netback/xenbus.c 	unregister_hotplug_status_watch(be);
be                978 drivers/net/xen-netback/xenbus.c 	err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch,
be                982 drivers/net/xen-netback/xenbus.c 		be->have_hotplug_status_watch = 1;
be                984 drivers/net/xen-netback/xenbus.c 	netif_tx_wake_all_queues(be->vif->dev);
be                989 drivers/net/xen-netback/xenbus.c 	if (be->vif->num_queues > 0)
be                990 drivers/net/xen-netback/xenbus.c 		xenvif_disconnect_data(be->vif); /* Clean up existing queues */
be                991 drivers/net/xen-netback/xenbus.c 	for (queue_index = 0; queue_index < be->vif->num_queues; ++queue_index)
be                992 drivers/net/xen-netback/xenbus.c 		xenvif_deinit_queue(&be->vif->queues[queue_index]);
be                993 drivers/net/xen-netback/xenbus.c 	vfree(be->vif->queues);
be                994 drivers/net/xen-netback/xenbus.c 	be->vif->queues = NULL;
be                995 drivers/net/xen-netback/xenbus.c 	be->vif->num_queues = 0;
be                996 drivers/net/xen-netback/xenbus.c 	xenvif_disconnect_ctrl(be->vif);
be               1001 drivers/net/xen-netback/xenbus.c static int connect_data_rings(struct backend_info *be,
be               1004 drivers/net/xen-netback/xenbus.c 	struct xenbus_device *dev = be->dev;
be               1082 drivers/net/xen-netback/xenbus.c static int read_xenbus_vif_flags(struct backend_info *be)
be               1084 drivers/net/xen-netback/xenbus.c 	struct xenvif *vif = be->vif;
be               1085 drivers/net/xen-netback/xenbus.c 	struct xenbus_device *dev = be->dev;
be               1108 drivers/net/xen-netback/xenbus.c 		be->vif->drain_timeout = msecs_to_jiffies(30);
be               1109 drivers/net/xen-netback/xenbus.c 		be->vif->stall_timeout = 0;
be                 63 drivers/pci/controller/pcie-altera.c #define TLP_CFG_DW1(pcie, tag, be)	\
be                 64 drivers/pci/controller/pcie-altera.c 	(((TLP_REQ_ID(pcie->root_bus_nr,  RP_DEVFN)) << 16) | (tag << 8) | (be))
be                177 drivers/s390/scsi/zfcp_dbf.c 	memcpy(&rec->u.be, &sr_buf->payload.bit_error,
be                199 drivers/s390/scsi/zfcp_dbf.h 		struct fsf_bit_error_payload be;
be               3718 drivers/scsi/ncr53c8xx.c 	u_char *be = &np->rv_ctest0;
be               3719 drivers/scsi/ncr53c8xx.c 	*be		&= ~0x80;
be               3724 drivers/scsi/ncr53c8xx.c 		*be		|= 0x80;
be                 62 drivers/spi/spi-bcm-qspi.h static inline u32 bcm_qspi_readl(bool be, void __iomem *addr)
be                 64 drivers/spi/spi-bcm-qspi.h 	if (be)
be                 71 drivers/spi/spi-bcm-qspi.h static inline void bcm_qspi_writel(bool be,
be                 74 drivers/spi/spi-bcm-qspi.h 	if (be)
be                154 drivers/staging/uwb/beacon.c 	kfree(bce->be);
be                251 drivers/staging/uwb/beacon.c 				  struct uwb_rc_evt_beacon *be,
be                300 drivers/staging/uwb/beacon.c static void uwb_beacon_print(struct uwb_rc *rc, struct uwb_rc_evt_beacon *be,
be                312 drivers/staging/uwb/beacon.c 		 devbuf, dstbuf, be->bChannelNumber, be->wBPSTOffset,
be                323 drivers/staging/uwb/beacon.c 	struct uwb_rc_evt_beacon *be;
be                330 drivers/staging/uwb/beacon.c 	be = bce->be;
be                331 drivers/staging/uwb/beacon.c 	if (be) {
be                332 drivers/staging/uwb/beacon.c 		bf = (struct uwb_beacon_frame *)bce->be->BeaconInfo;
be                333 drivers/staging/uwb/beacon.c 		ies_len = be->wBeaconInfoLength - sizeof(struct uwb_beacon_frame);
be                348 drivers/staging/uwb/beacon.c 			     struct uwb_rc_evt_beacon *be)
be                355 drivers/staging/uwb/beacon.c 	if (evt->notif.size < sizeof(*be) + sizeof(*bf)) {
be                358 drivers/staging/uwb/beacon.c 			sizeof(*be) + sizeof(*bf));
be                383 drivers/staging/uwb/beacon.c 	struct uwb_rc_evt_beacon *be;
be                388 drivers/staging/uwb/beacon.c 	be = container_of(evt->notif.rceb, struct uwb_rc_evt_beacon, rceb);
be                389 drivers/staging/uwb/beacon.c 	result = uwb_verify_beacon(rc, evt, be);
be                394 drivers/staging/uwb/beacon.c 	if (be->bBeaconType == UWB_RC_BEACON_TYPE_OL_ALIEN ||
be                395 drivers/staging/uwb/beacon.c 	    be->bBeaconType == UWB_RC_BEACON_TYPE_NOL_ALIEN) {
be                399 drivers/staging/uwb/beacon.c 	bf = (struct uwb_beacon_frame *) be->BeaconInfo;
be                416 drivers/staging/uwb/beacon.c 		uwb_beacon_print(evt->rc, be, bf);
be                417 drivers/staging/uwb/beacon.c 		bce = __uwb_beca_add(rc, be, bf, evt->ts_jiffies);
be                427 drivers/staging/uwb/beacon.c 	kfree(bce->be);
be                431 drivers/staging/uwb/beacon.c 	bce->be = be;
be                434 drivers/staging/uwb/beacon.c 	be->wBPSTOffset = le16_to_cpu(be->wBPSTOffset);
be                435 drivers/staging/uwb/beacon.c 	be->wBeaconInfoLength = le16_to_cpu(be->wBeaconInfoLength);
be                436 drivers/staging/uwb/beacon.c 	stats_add_sample(&bce->lqe_stats, be->bLQI - 7);
be                437 drivers/staging/uwb/beacon.c 	stats_add_sample(&bce->rssi_stats, be->bRSSI + 18);
be                105 drivers/staging/uwb/hwa-rc.c 	struct uwb_rc_evt_beacon_WUSB_0100 *be;
be                110 drivers/staging/uwb/hwa-rc.c 	be = container_of(*header, struct uwb_rc_evt_beacon_WUSB_0100, rceb);
be                112 drivers/staging/uwb/hwa-rc.c 	if (bytes_left < sizeof(*be)) {
be                115 drivers/staging/uwb/hwa-rc.c 			bytes_left, sizeof(*be));
be                118 drivers/staging/uwb/hwa-rc.c 	bytes_left -= sizeof(*be);
be                119 drivers/staging/uwb/hwa-rc.c 	ielength = le16_to_cpu(be->wBeaconInfoLength);
be                129 drivers/staging/uwb/hwa-rc.c 	newbe->rceb = be->rceb;
be                130 drivers/staging/uwb/hwa-rc.c 	newbe->bChannelNumber = be->bChannelNumber;
be                132 drivers/staging/uwb/hwa-rc.c 	newbe->wBPSTOffset = be->wBPSTOffset;
be                133 drivers/staging/uwb/hwa-rc.c 	newbe->bLQI = be->bLQI;
be                134 drivers/staging/uwb/hwa-rc.c 	newbe->bRSSI = be->bRSSI;
be                135 drivers/staging/uwb/hwa-rc.c 	newbe->wBeaconInfoLength = be->wBeaconInfoLength;
be                136 drivers/staging/uwb/hwa-rc.c 	memcpy(newbe->BeaconInfo, be->BeaconInfo, ielength);
be                142 drivers/staging/uwb/lc-dev.c 	bf = (struct uwb_beacon_frame *)bce->be->BeaconInfo;
be                143 drivers/staging/uwb/lc-dev.c 	bpst = bce->be->wBPSTOffset
be                273 drivers/staging/uwb/uwb-internal.h 	struct uwb_rc_evt_beacon *be;
be                267 drivers/usb/host/ohci-dbg.c 		u32	cbp, be;
be                286 drivers/usb/host/ohci-dbg.c 		be = hc32_to_cpup (ohci, &td->hwBE);
be                287 drivers/usb/host/ohci-dbg.c 		ohci_dbg (ohci, "     cbp %08x be %08x (len %d)\n", cbp, be,
be                288 drivers/usb/host/ohci-dbg.c 			cbp ? (be + 1 - cbp) : 0);
be                434 drivers/usb/host/ohci-dbg.c 			u32		cbp, be;
be                439 drivers/usb/host/ohci-dbg.c 			be = hc32_to_cpup (ohci, &td->hwBE);
be                450 drivers/usb/host/ohci-dbg.c 					cbp ? (be + 1 - cbp) : 0,
be                346 drivers/xen/xenbus/xenbus_probe_frontend.c static void xenbus_reset_wait_for_backend(char *be, int expected)
be                352 drivers/xen/xenbus/xenbus_probe_frontend.c 		pr_info("backend %s timed out\n", be);
be                360 drivers/xen/xenbus/xenbus_probe_frontend.c static void xenbus_reset_frontend(char *fe, char *be, int be_state)
be                365 drivers/xen/xenbus/xenbus_probe_frontend.c 			be, xenbus_strstate(be_state));
be                368 drivers/xen/xenbus/xenbus_probe_frontend.c 	be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", be);
be                375 drivers/xen/xenbus/xenbus_probe_frontend.c 	pr_info("triggering reconnect on %s\n", be);
be                382 drivers/xen/xenbus/xenbus_probe_frontend.c 		xenbus_reset_wait_for_backend(be, XenbusStateClosing);
be                387 drivers/xen/xenbus/xenbus_probe_frontend.c 		xenbus_reset_wait_for_backend(be, XenbusStateClosed);
be                392 drivers/xen/xenbus/xenbus_probe_frontend.c 		xenbus_reset_wait_for_backend(be, XenbusStateInitWait);
be                396 drivers/xen/xenbus/xenbus_probe_frontend.c 	pr_info("reconnect done on %s\n", be);
be                 76 fs/btrfs/ref-verify.c 					      struct block_entry *be)
be                 85 fs/btrfs/ref-verify.c 		if (entry->bytenr > be->bytenr)
be                 87 fs/btrfs/ref-verify.c 		else if (entry->bytenr < be->bytenr)
be                 93 fs/btrfs/ref-verify.c 	rb_link_node(&be->node, parent_node, p);
be                 94 fs/btrfs/ref-verify.c 	rb_insert_color(&be->node, root);
be                232 fs/btrfs/ref-verify.c static void free_block_entry(struct block_entry *be)
be                239 fs/btrfs/ref-verify.c 	while ((n = rb_first(&be->roots))) {
be                241 fs/btrfs/ref-verify.c 		rb_erase(&re->node, &be->roots);
be                245 fs/btrfs/ref-verify.c 	while((n = rb_first(&be->refs))) {
be                247 fs/btrfs/ref-verify.c 		rb_erase(&ref->node, &be->refs);
be                251 fs/btrfs/ref-verify.c 	while (!list_empty(&be->actions)) {
be                252 fs/btrfs/ref-verify.c 		ra = list_first_entry(&be->actions, struct ref_action,
be                257 fs/btrfs/ref-verify.c 	kfree(be);
be                264 fs/btrfs/ref-verify.c 	struct block_entry *be = NULL, *exist;
be                268 fs/btrfs/ref-verify.c 	be = kzalloc(sizeof(struct block_entry), GFP_KERNEL);
be                269 fs/btrfs/ref-verify.c 	if (!be || !re) {
be                271 fs/btrfs/ref-verify.c 		kfree(be);
be                274 fs/btrfs/ref-verify.c 	be->bytenr = bytenr;
be                275 fs/btrfs/ref-verify.c 	be->len = len;
be                281 fs/btrfs/ref-verify.c 	exist = insert_block_entry(&fs_info->block_tree, be);
be                290 fs/btrfs/ref-verify.c 		kfree(be);
be                294 fs/btrfs/ref-verify.c 	be->num_refs = 0;
be                295 fs/btrfs/ref-verify.c 	be->metadata = 0;
be                296 fs/btrfs/ref-verify.c 	be->from_disk = 0;
be                297 fs/btrfs/ref-verify.c 	be->roots = RB_ROOT;
be                298 fs/btrfs/ref-verify.c 	be->refs = RB_ROOT;
be                299 fs/btrfs/ref-verify.c 	INIT_LIST_HEAD(&be->actions);
be                301 fs/btrfs/ref-verify.c 		insert_root_entry(&be->roots, re);
be                304 fs/btrfs/ref-verify.c 	return be;
be                310 fs/btrfs/ref-verify.c 	struct block_entry *be;
be                327 fs/btrfs/ref-verify.c 	be = add_block_entry(fs_info, bytenr, fs_info->nodesize, ref_root);
be                328 fs/btrfs/ref-verify.c 	if (IS_ERR(be)) {
be                330 fs/btrfs/ref-verify.c 		return PTR_ERR(be);
be                332 fs/btrfs/ref-verify.c 	be->num_refs++;
be                333 fs/btrfs/ref-verify.c 	be->from_disk = 1;
be                334 fs/btrfs/ref-verify.c 	be->metadata = 1;
be                338 fs/btrfs/ref-verify.c 		re = lookup_root_entry(&be->roots, ref_root);
be                342 fs/btrfs/ref-verify.c 	exist = insert_ref_entry(&be->refs, ref);
be                356 fs/btrfs/ref-verify.c 	struct block_entry *be;
be                362 fs/btrfs/ref-verify.c 	be = add_block_entry(fs_info, bytenr, num_bytes, 0);
be                363 fs/btrfs/ref-verify.c 	if (IS_ERR(be)) {
be                365 fs/btrfs/ref-verify.c 		return PTR_ERR(be);
be                367 fs/btrfs/ref-verify.c 	be->num_refs += num_refs;
be                371 fs/btrfs/ref-verify.c 	if (insert_ref_entry(&be->refs, ref)) {
be                386 fs/btrfs/ref-verify.c 	struct block_entry *be;
be                397 fs/btrfs/ref-verify.c 	be = add_block_entry(fs_info, bytenr, num_bytes, ref_root);
be                398 fs/btrfs/ref-verify.c 	if (IS_ERR(be)) {
be                400 fs/btrfs/ref-verify.c 		return PTR_ERR(be);
be                402 fs/btrfs/ref-verify.c 	be->num_refs += num_refs;
be                409 fs/btrfs/ref-verify.c 	if (insert_ref_entry(&be->refs, ref)) {
be                416 fs/btrfs/ref-verify.c 	re = lookup_root_entry(&be->roots, ref_root);
be                631 fs/btrfs/ref-verify.c 			     struct block_entry *be)
be                640 fs/btrfs/ref-verify.c 		  be->bytenr, be->len, be->num_refs, be->metadata,
be                641 fs/btrfs/ref-verify.c 		  be->from_disk);
be                643 fs/btrfs/ref-verify.c 	for (n = rb_first(&be->refs); n; n = rb_next(n)) {
be                651 fs/btrfs/ref-verify.c 	for (n = rb_first(&be->roots); n; n = rb_next(n)) {
be                657 fs/btrfs/ref-verify.c 	list_for_each_entry(ra, &be->actions, list)
be                674 fs/btrfs/ref-verify.c 	struct block_entry *be = NULL;
be                745 fs/btrfs/ref-verify.c 		be = add_block_entry(fs_info, bytenr, num_bytes, ref_root);
be                746 fs/btrfs/ref-verify.c 		if (IS_ERR(be)) {
be                749 fs/btrfs/ref-verify.c 			ret = PTR_ERR(be);
be                752 fs/btrfs/ref-verify.c 		be->num_refs++;
be                754 fs/btrfs/ref-verify.c 			be->metadata = 1;
be                756 fs/btrfs/ref-verify.c 		if (be->num_refs != 1) {
be                759 fs/btrfs/ref-verify.c 			dump_block_entry(fs_info, be);
be                766 fs/btrfs/ref-verify.c 		while (!list_empty(&be->actions)) {
be                769 fs/btrfs/ref-verify.c 			tmp = list_first_entry(&be->actions, struct ref_action,
be                796 fs/btrfs/ref-verify.c 		be = lookup_block_entry(&fs_info->block_tree, bytenr);
be                797 fs/btrfs/ref-verify.c 		if (!be) {
be                809 fs/btrfs/ref-verify.c 			tmp = insert_root_entry(&be->roots, re);
be                817 fs/btrfs/ref-verify.c 	exist = insert_ref_entry(&be->refs, ref);
be                823 fs/btrfs/ref-verify.c 				dump_block_entry(fs_info, be);
be                831 fs/btrfs/ref-verify.c 				rb_erase(&exist->node, &be->refs);
be                834 fs/btrfs/ref-verify.c 		} else if (!be->metadata) {
be                839 fs/btrfs/ref-verify.c 			dump_block_entry(fs_info, be);
be                850 fs/btrfs/ref-verify.c 			dump_block_entry(fs_info, be);
be                858 fs/btrfs/ref-verify.c 		re = lookup_root_entry(&be->roots, ref_root);
be                867 fs/btrfs/ref-verify.c 				  generic_ref->real_root, be->bytenr);
be                868 fs/btrfs/ref-verify.c 			dump_block_entry(fs_info, be);
be                877 fs/btrfs/ref-verify.c 		be->num_refs--;
be                879 fs/btrfs/ref-verify.c 		be->num_refs++;
be                883 fs/btrfs/ref-verify.c 	list_add_tail(&ra->list, &be->actions);
be                896 fs/btrfs/ref-verify.c 	struct block_entry *be;
be                904 fs/btrfs/ref-verify.c 		be = rb_entry(n, struct block_entry, node);
be                905 fs/btrfs/ref-verify.c 		rb_erase(&be->node, &fs_info->block_tree);
be                906 fs/btrfs/ref-verify.c 		free_block_entry(be);
be                915 fs/btrfs/ref-verify.c 	struct block_entry *be = NULL, *entry;
be                930 fs/btrfs/ref-verify.c 			be = entry;
be                934 fs/btrfs/ref-verify.c 		if (be == NULL ||
be                935 fs/btrfs/ref-verify.c 		    (entry->bytenr < start && be->bytenr > start) ||
be                936 fs/btrfs/ref-verify.c 		    (entry->bytenr < start && entry->bytenr > be->bytenr))
be                937 fs/btrfs/ref-verify.c 			be = entry;
be                944 fs/btrfs/ref-verify.c 	if (!be) {
be                949 fs/btrfs/ref-verify.c 	n = &be->node;
be                951 fs/btrfs/ref-verify.c 		be = rb_entry(n, struct block_entry, node);
be                953 fs/btrfs/ref-verify.c 		if (be->bytenr < start && be->bytenr + be->len > start) {
be                957 fs/btrfs/ref-verify.c 			dump_block_entry(fs_info, be);
be                960 fs/btrfs/ref-verify.c 		if (be->bytenr < start)
be                962 fs/btrfs/ref-verify.c 		if (be->bytenr >= start + len)
be                964 fs/btrfs/ref-verify.c 		if (be->bytenr + be->len > start + len) {
be                968 fs/btrfs/ref-verify.c 			dump_block_entry(fs_info, be);
be                970 fs/btrfs/ref-verify.c 		rb_erase(&be->node, &fs_info->block_tree);
be                971 fs/btrfs/ref-verify.c 		free_block_entry(be);
be                 52 fs/nfs/blocklayout/blocklayout.c static bool is_hole(struct pnfs_block_extent *be)
be                 54 fs/nfs/blocklayout/blocklayout.c 	switch (be->be_state) {
be                 58 fs/nfs/blocklayout/blocklayout.c 		return be->be_tag ? false : true;
be                148 fs/nfs/blocklayout/blocklayout.c 		struct pnfs_block_extent *be, bio_end_io_t end_io,
be                152 fs/nfs/blocklayout/blocklayout.c 		container_of(be->be_device, struct pnfs_block_dev, node);
be                159 fs/nfs/blocklayout/blocklayout.c 	isect += be->be_v_offset;
be                160 fs/nfs/blocklayout/blocklayout.c 	isect -= be->be_f_offset;
be                197 fs/nfs/blocklayout/blocklayout.c 	struct pnfs_block_extent be;
be                203 fs/nfs/blocklayout/blocklayout.c 		if (!ext_tree_lookup(bl, isect, &be, rw))
be                205 fs/nfs/blocklayout/blocklayout.c 		extent_length = be.be_length - (isect - be.be_f_offset);
be                206 fs/nfs/blocklayout/blocklayout.c 		nfs4_mark_deviceid_unavailable(be.be_device);
be                258 fs/nfs/blocklayout/blocklayout.c 	struct pnfs_block_extent be;
be                289 fs/nfs/blocklayout/blocklayout.c 			if (!ext_tree_lookup(bl, isect, &be, false)) {
be                293 fs/nfs/blocklayout/blocklayout.c 			extent_length = be.be_length - (isect - be.be_f_offset);
be                306 fs/nfs/blocklayout/blocklayout.c 		if (is_hole(&be)) {
be                318 fs/nfs/blocklayout/blocklayout.c 						 isect, pages[i], &map, &be,
be                403 fs/nfs/blocklayout/blocklayout.c 	struct pnfs_block_extent be;
be                436 fs/nfs/blocklayout/blocklayout.c 			if (!ext_tree_lookup(bl, isect, &be, true)) {
be                441 fs/nfs/blocklayout/blocklayout.c 			extent_length = be.be_length - (isect - be.be_f_offset);
be                446 fs/nfs/blocklayout/blocklayout.c 					 WRITE, isect, pages[i], &map, &be,
be                529 fs/nfs/blocklayout/blocklayout.c static int verify_extent(struct pnfs_block_extent *be,
be                533 fs/nfs/blocklayout/blocklayout.c 		if (be->be_state == PNFS_BLOCK_READWRITE_DATA ||
be                534 fs/nfs/blocklayout/blocklayout.c 		    be->be_state == PNFS_BLOCK_INVALID_DATA)
be                536 fs/nfs/blocklayout/blocklayout.c 		if (be->be_f_offset != lv->start)
be                538 fs/nfs/blocklayout/blocklayout.c 		lv->start += be->be_length;
be                542 fs/nfs/blocklayout/blocklayout.c 	if (be->be_state == PNFS_BLOCK_READWRITE_DATA) {
be                543 fs/nfs/blocklayout/blocklayout.c 		if (be->be_f_offset != lv->start)
be                547 fs/nfs/blocklayout/blocklayout.c 		lv->start += be->be_length;
be                550 fs/nfs/blocklayout/blocklayout.c 	} else if (be->be_state == PNFS_BLOCK_INVALID_DATA) {
be                551 fs/nfs/blocklayout/blocklayout.c 		if (be->be_f_offset != lv->start)
be                553 fs/nfs/blocklayout/blocklayout.c 		lv->start += be->be_length;
be                555 fs/nfs/blocklayout/blocklayout.c 	} else if (be->be_state == PNFS_BLOCK_READ_DATA) {
be                556 fs/nfs/blocklayout/blocklayout.c 		if (be->be_f_offset > lv->start)
be                558 fs/nfs/blocklayout/blocklayout.c 		if (be->be_f_offset < lv->inval)
be                560 fs/nfs/blocklayout/blocklayout.c 		if (be->be_f_offset < lv->cowread)
be                565 fs/nfs/blocklayout/blocklayout.c 		lv->inval = lv->inval + be->be_length;
be                566 fs/nfs/blocklayout/blocklayout.c 		lv->cowread = be->be_f_offset + be->be_length;
be                615 fs/nfs/blocklayout/blocklayout.c 	struct pnfs_block_extent *be;
be                624 fs/nfs/blocklayout/blocklayout.c 	be = kzalloc(sizeof(*be), GFP_NOFS);
be                625 fs/nfs/blocklayout/blocklayout.c 	if (!be)
be                631 fs/nfs/blocklayout/blocklayout.c 	be->be_device = bl_find_get_deviceid(NFS_SERVER(lo->plh_inode), &id,
be                633 fs/nfs/blocklayout/blocklayout.c 	if (IS_ERR(be->be_device)) {
be                634 fs/nfs/blocklayout/blocklayout.c 		error = PTR_ERR(be->be_device);
be                643 fs/nfs/blocklayout/blocklayout.c 	if (decode_sector_number(&p, &be->be_f_offset) < 0)
be                645 fs/nfs/blocklayout/blocklayout.c 	if (decode_sector_number(&p, &be->be_length) < 0)
be                647 fs/nfs/blocklayout/blocklayout.c 	if (decode_sector_number(&p, &be->be_v_offset) < 0)
be                649 fs/nfs/blocklayout/blocklayout.c 	be->be_state = be32_to_cpup(p++);
be                651 fs/nfs/blocklayout/blocklayout.c 	error = verify_extent(be, lv);
be                657 fs/nfs/blocklayout/blocklayout.c 	list_add_tail(&be->be_list, extents);
be                661 fs/nfs/blocklayout/blocklayout.c 	nfs4_put_deviceid_node(be->be_device);
be                663 fs/nfs/blocklayout/blocklayout.c 	kfree(be);
be                734 fs/nfs/blocklayout/blocklayout.c 		struct pnfs_block_extent *be =
be                737 fs/nfs/blocklayout/blocklayout.c 		list_del(&be->be_list);
be                740 fs/nfs/blocklayout/blocklayout.c 			status = ext_tree_insert(bl, be);
be                743 fs/nfs/blocklayout/blocklayout.c 			nfs4_put_deviceid_node(be->be_device);
be                744 fs/nfs/blocklayout/blocklayout.c 			kfree(be);
be                 26 fs/nfs/blocklayout/extent_tree.c ext_tree_prev(struct pnfs_block_extent *be)
be                 28 fs/nfs/blocklayout/extent_tree.c 	struct rb_node *node = rb_prev(&be->be_node);
be                 33 fs/nfs/blocklayout/extent_tree.c ext_tree_next(struct pnfs_block_extent *be)
be                 35 fs/nfs/blocklayout/extent_tree.c 	struct rb_node *node = rb_next(&be->be_node);
be                 40 fs/nfs/blocklayout/extent_tree.c ext_f_end(struct pnfs_block_extent *be)
be                 42 fs/nfs/blocklayout/extent_tree.c 	return be->be_f_offset + be->be_length;
be                 49 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be = NULL;
be                 52 fs/nfs/blocklayout/extent_tree.c 		be = ext_node(node);
be                 53 fs/nfs/blocklayout/extent_tree.c 		if (start < be->be_f_offset)
be                 55 fs/nfs/blocklayout/extent_tree.c 		else if (start >= ext_f_end(be))
be                 58 fs/nfs/blocklayout/extent_tree.c 			return be;
be                 61 fs/nfs/blocklayout/extent_tree.c 	if (be) {
be                 62 fs/nfs/blocklayout/extent_tree.c 		if (start < be->be_f_offset)
be                 63 fs/nfs/blocklayout/extent_tree.c 			return be;
be                 65 fs/nfs/blocklayout/extent_tree.c 		if (start >= ext_f_end(be))
be                 66 fs/nfs/blocklayout/extent_tree.c 			return ext_tree_next(be);
be                 95 fs/nfs/blocklayout/extent_tree.c ext_try_to_merge_left(struct rb_root *root, struct pnfs_block_extent *be)
be                 97 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *left = ext_tree_prev(be);
be                 99 fs/nfs/blocklayout/extent_tree.c 	if (left && ext_can_merge(left, be)) {
be                100 fs/nfs/blocklayout/extent_tree.c 		left->be_length += be->be_length;
be                101 fs/nfs/blocklayout/extent_tree.c 		rb_erase(&be->be_node, root);
be                102 fs/nfs/blocklayout/extent_tree.c 		nfs4_put_deviceid_node(be->be_device);
be                103 fs/nfs/blocklayout/extent_tree.c 		kfree(be);
be                107 fs/nfs/blocklayout/extent_tree.c 	return be;
be                111 fs/nfs/blocklayout/extent_tree.c ext_try_to_merge_right(struct rb_root *root, struct pnfs_block_extent *be)
be                113 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *right = ext_tree_next(be);
be                115 fs/nfs/blocklayout/extent_tree.c 	if (right && ext_can_merge(be, right)) {
be                116 fs/nfs/blocklayout/extent_tree.c 		be->be_length += right->be_length;
be                122 fs/nfs/blocklayout/extent_tree.c 	return be;
be                127 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be, *tmp;
be                129 fs/nfs/blocklayout/extent_tree.c 	list_for_each_entry_safe(be, tmp, head, be_list) {
be                130 fs/nfs/blocklayout/extent_tree.c 		nfs4_put_deviceid_node(be->be_device);
be                131 fs/nfs/blocklayout/extent_tree.c 		kfree(be);
be                140 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                144 fs/nfs/blocklayout/extent_tree.c 		be = ext_node(parent);
be                146 fs/nfs/blocklayout/extent_tree.c 		if (new->be_f_offset < be->be_f_offset) {
be                147 fs/nfs/blocklayout/extent_tree.c 			if (merge_ok && ext_can_merge(new, be)) {
be                148 fs/nfs/blocklayout/extent_tree.c 				be->be_f_offset = new->be_f_offset;
be                149 fs/nfs/blocklayout/extent_tree.c 				if (be->be_state != PNFS_BLOCK_NONE_DATA)
be                150 fs/nfs/blocklayout/extent_tree.c 					be->be_v_offset = new->be_v_offset;
be                151 fs/nfs/blocklayout/extent_tree.c 				be->be_length += new->be_length;
be                152 fs/nfs/blocklayout/extent_tree.c 				be = ext_try_to_merge_left(root, be);
be                156 fs/nfs/blocklayout/extent_tree.c 		} else if (new->be_f_offset >= ext_f_end(be)) {
be                157 fs/nfs/blocklayout/extent_tree.c 			if (merge_ok && ext_can_merge(be, new)) {
be                158 fs/nfs/blocklayout/extent_tree.c 				be->be_length += new->be_length;
be                159 fs/nfs/blocklayout/extent_tree.c 				be = ext_try_to_merge_right(root, be);
be                180 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                185 fs/nfs/blocklayout/extent_tree.c 	be = __ext_tree_search(root, start);
be                186 fs/nfs/blocklayout/extent_tree.c 	if (!be)
be                188 fs/nfs/blocklayout/extent_tree.c 	if (be->be_f_offset >= end)
be                191 fs/nfs/blocklayout/extent_tree.c 	orig_v_offset = be->be_v_offset;
be                192 fs/nfs/blocklayout/extent_tree.c 	orig_len = be->be_length;
be                194 fs/nfs/blocklayout/extent_tree.c 	if (start > be->be_f_offset)
be                195 fs/nfs/blocklayout/extent_tree.c 		len1 = start - be->be_f_offset;
be                196 fs/nfs/blocklayout/extent_tree.c 	if (ext_f_end(be) > end)
be                197 fs/nfs/blocklayout/extent_tree.c 		len2 = ext_f_end(be) - end;
be                207 fs/nfs/blocklayout/extent_tree.c 			be->be_length = len1;
be                210 fs/nfs/blocklayout/extent_tree.c 			if (be->be_state != PNFS_BLOCK_NONE_DATA) {
be                215 fs/nfs/blocklayout/extent_tree.c 			new->be_state = be->be_state;
be                216 fs/nfs/blocklayout/extent_tree.c 			new->be_tag = be->be_tag;
be                217 fs/nfs/blocklayout/extent_tree.c 			new->be_device = nfs4_get_deviceid(be->be_device);
be                221 fs/nfs/blocklayout/extent_tree.c 			be->be_f_offset = end;
be                222 fs/nfs/blocklayout/extent_tree.c 			if (be->be_state != PNFS_BLOCK_NONE_DATA) {
be                223 fs/nfs/blocklayout/extent_tree.c 				be->be_v_offset =
be                226 fs/nfs/blocklayout/extent_tree.c 			be->be_length = len2;
be                230 fs/nfs/blocklayout/extent_tree.c 			be->be_length = len1;
be                231 fs/nfs/blocklayout/extent_tree.c 			be = ext_tree_next(be);
be                234 fs/nfs/blocklayout/extent_tree.c 		while (be && ext_f_end(be) <= end) {
be                235 fs/nfs/blocklayout/extent_tree.c 			struct pnfs_block_extent *next = ext_tree_next(be);
be                237 fs/nfs/blocklayout/extent_tree.c 			rb_erase(&be->be_node, root);
be                238 fs/nfs/blocklayout/extent_tree.c 			list_add_tail(&be->be_list, tmp);
be                239 fs/nfs/blocklayout/extent_tree.c 			be = next;
be                242 fs/nfs/blocklayout/extent_tree.c 		if (be && be->be_f_offset < end) {
be                243 fs/nfs/blocklayout/extent_tree.c 			len1 = ext_f_end(be) - end;
be                244 fs/nfs/blocklayout/extent_tree.c 			be->be_f_offset = end;
be                245 fs/nfs/blocklayout/extent_tree.c 			if (be->be_state != PNFS_BLOCK_NONE_DATA)
be                246 fs/nfs/blocklayout/extent_tree.c 				be->be_v_offset += be->be_length - len1;
be                247 fs/nfs/blocklayout/extent_tree.c 			be->be_length = len1;
be                257 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                277 fs/nfs/blocklayout/extent_tree.c 	be = __ext_tree_search(root, new->be_f_offset);
be                278 fs/nfs/blocklayout/extent_tree.c 	if (!be || be->be_f_offset >= ext_f_end(new)) {
be                280 fs/nfs/blocklayout/extent_tree.c 	} else if (new->be_f_offset >= be->be_f_offset) {
be                281 fs/nfs/blocklayout/extent_tree.c 		if (ext_f_end(new) <= ext_f_end(be)) {
be                285 fs/nfs/blocklayout/extent_tree.c 			sector_t new_len = ext_f_end(new) - ext_f_end(be);
be                293 fs/nfs/blocklayout/extent_tree.c 	} else if (ext_f_end(new) <= ext_f_end(be)) {
be                294 fs/nfs/blocklayout/extent_tree.c 		new->be_length = be->be_f_offset - new->be_f_offset;
be                298 fs/nfs/blocklayout/extent_tree.c 		sector_t new_len = ext_f_end(new) - ext_f_end(be);
be                307 fs/nfs/blocklayout/extent_tree.c 		split->be_length = be->be_f_offset - split->be_f_offset;
be                326 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                330 fs/nfs/blocklayout/extent_tree.c 		be = ext_node(node);
be                331 fs/nfs/blocklayout/extent_tree.c 		if (isect < be->be_f_offset)
be                333 fs/nfs/blocklayout/extent_tree.c 		else if (isect >= ext_f_end(be))
be                336 fs/nfs/blocklayout/extent_tree.c 			*ret = *be;
be                380 fs/nfs/blocklayout/extent_tree.c ext_tree_split(struct rb_root *root, struct pnfs_block_extent *be,
be                384 fs/nfs/blocklayout/extent_tree.c 	sector_t orig_len = be->be_length;
be                390 fs/nfs/blocklayout/extent_tree.c 	be->be_length = split - be->be_f_offset;
be                393 fs/nfs/blocklayout/extent_tree.c 	if (be->be_state != PNFS_BLOCK_NONE_DATA)
be                394 fs/nfs/blocklayout/extent_tree.c 		new->be_v_offset = be->be_v_offset + be->be_length;
be                395 fs/nfs/blocklayout/extent_tree.c 	new->be_length = orig_len - be->be_length;
be                396 fs/nfs/blocklayout/extent_tree.c 	new->be_state = be->be_state;
be                397 fs/nfs/blocklayout/extent_tree.c 	new->be_tag = be->be_tag;
be                398 fs/nfs/blocklayout/extent_tree.c 	new->be_device = nfs4_get_deviceid(be->be_device);
be                410 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                425 fs/nfs/blocklayout/extent_tree.c 	for (be = __ext_tree_search(root, start); be; be = ext_tree_next(be)) {
be                426 fs/nfs/blocklayout/extent_tree.c 		if (be->be_f_offset >= end)
be                429 fs/nfs/blocklayout/extent_tree.c 		if (be->be_state != PNFS_BLOCK_INVALID_DATA || be->be_tag)
be                432 fs/nfs/blocklayout/extent_tree.c 		if (be->be_f_offset < start) {
be                433 fs/nfs/blocklayout/extent_tree.c 			struct pnfs_block_extent *left = ext_tree_prev(be);
be                435 fs/nfs/blocklayout/extent_tree.c 			if (left && ext_can_merge(left, be)) {
be                436 fs/nfs/blocklayout/extent_tree.c 				sector_t diff = start - be->be_f_offset;
be                440 fs/nfs/blocklayout/extent_tree.c 				be->be_f_offset += diff;
be                441 fs/nfs/blocklayout/extent_tree.c 				be->be_v_offset += diff;
be                442 fs/nfs/blocklayout/extent_tree.c 				be->be_length -= diff;
be                444 fs/nfs/blocklayout/extent_tree.c 				err = ext_tree_split(root, be, start);
be                450 fs/nfs/blocklayout/extent_tree.c 		if (ext_f_end(be) > end) {
be                451 fs/nfs/blocklayout/extent_tree.c 			struct pnfs_block_extent *right = ext_tree_next(be);
be                453 fs/nfs/blocklayout/extent_tree.c 			if (right && ext_can_merge(be, right)) {
be                454 fs/nfs/blocklayout/extent_tree.c 				sector_t diff = end - be->be_f_offset;
be                456 fs/nfs/blocklayout/extent_tree.c 				be->be_length -= diff;
be                462 fs/nfs/blocklayout/extent_tree.c 				err = ext_tree_split(root, be, end);
be                468 fs/nfs/blocklayout/extent_tree.c 		if (be->be_f_offset >= start && ext_f_end(be) <= end) {
be                469 fs/nfs/blocklayout/extent_tree.c 			be->be_tag = EXTENT_WRITTEN;
be                470 fs/nfs/blocklayout/extent_tree.c 			be = ext_try_to_merge_left(root, be);
be                471 fs/nfs/blocklayout/extent_tree.c 			be = ext_try_to_merge_right(root, be);
be                506 fs/nfs/blocklayout/extent_tree.c static __be32 *encode_block_extent(struct pnfs_block_extent *be, __be32 *p)
be                508 fs/nfs/blocklayout/extent_tree.c 	p = xdr_encode_opaque_fixed(p, be->be_device->deviceid.data,
be                510 fs/nfs/blocklayout/extent_tree.c 	p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);
be                511 fs/nfs/blocklayout/extent_tree.c 	p = xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);
be                517 fs/nfs/blocklayout/extent_tree.c static __be32 *encode_scsi_range(struct pnfs_block_extent *be, __be32 *p)
be                519 fs/nfs/blocklayout/extent_tree.c 	p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);
be                520 fs/nfs/blocklayout/extent_tree.c 	return xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);
be                526 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                530 fs/nfs/blocklayout/extent_tree.c 	for (be = ext_tree_first(&bl->bl_ext_rw); be; be = ext_tree_next(be)) {
be                531 fs/nfs/blocklayout/extent_tree.c 		if (be->be_state != PNFS_BLOCK_INVALID_DATA ||
be                532 fs/nfs/blocklayout/extent_tree.c 		    be->be_tag != EXTENT_WRITTEN)
be                543 fs/nfs/blocklayout/extent_tree.c 			p = encode_scsi_range(be, p);
be                545 fs/nfs/blocklayout/extent_tree.c 			p = encode_block_extent(be, p);
be                546 fs/nfs/blocklayout/extent_tree.c 		be->be_tag = EXTENT_COMMITTING;
be                619 fs/nfs/blocklayout/extent_tree.c 	struct pnfs_block_extent *be;
be                626 fs/nfs/blocklayout/extent_tree.c 	for (be = ext_tree_first(root); be; be = ext_tree_next(be)) {
be                627 fs/nfs/blocklayout/extent_tree.c 		if (be->be_state != PNFS_BLOCK_INVALID_DATA ||
be                628 fs/nfs/blocklayout/extent_tree.c 		    be->be_tag != EXTENT_COMMITTING)
be                637 fs/nfs/blocklayout/extent_tree.c 			be->be_tag = EXTENT_WRITTEN;
be                639 fs/nfs/blocklayout/extent_tree.c 			be->be_state = PNFS_BLOCK_READWRITE_DATA;
be                640 fs/nfs/blocklayout/extent_tree.c 			be->be_tag = 0;
be                643 fs/nfs/blocklayout/extent_tree.c 		be = ext_try_to_merge_left(root, be);
be                644 fs/nfs/blocklayout/extent_tree.c 		be = ext_try_to_merge_right(root, be);
be                136 include/linux/bitfield.h 	____MAKE_OP(be##size,u##size,cpu_to_be##size,be##size##_to_cpu)	\
be                 39 include/linux/mtd/cfi_endian.h #define _swap_to_cpu(w, s, x) (cfi_be(s)?be##w##_to_cpu(x):le##w##_to_cpu(x))
be                674 include/net/ipv6.h 	const __be64 *be = (const __be64 *)a;
be                676 include/net/ipv6.h 	return (be[0] | (be[1] ^ cpu_to_be64(1))) == 0UL;
be                 71 include/sound/soc-dpcm.h 	struct snd_soc_pcm_runtime *be;
be                106 include/sound/soc-dpcm.h #define for_each_dpcm_fe(be, stream, dpcm)				\
be                107 include/sound/soc-dpcm.h 	list_for_each_entry(dpcm, &(be)->dpcm[stream].fe_clients, list_fe)
be                118 include/sound/soc-dpcm.h 		struct snd_soc_pcm_runtime *be, int stream);
be                122 include/sound/soc-dpcm.h 		struct snd_soc_pcm_runtime *be, int stream);
be                129 include/sound/soc-dpcm.h 		struct snd_soc_pcm_runtime *be, int stream);
be                133 include/sound/soc-dpcm.h 	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream);
be                137 include/sound/soc-dpcm.h 	snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime *be, int stream);
be                140 include/sound/soc-dpcm.h void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime *be, int stream,
be                 13 include/sound/wavefront.h      You will not be able to compile this file correctly without gcc, because
be                 17 include/sound/wavefront.h      then WavePatch-format files cannot be read/written correctly.
be                110 lib/842/842_compress.c 	be##b##_to_cpu(get_unaligned((__be##b *)((p)->in + (o))))
be                 47 lib/test_bitfield.c 			_res = be##tp##_encode_bits(v, field);		\
be                 50 lib/test_bitfield.c 					(u64)be##tp##_to_cpu(_res),	\
be                 54 lib/test_bitfield.c 			if (be##tp##_get_bits(_res, field) != v)	\
be                 15 lib/test_uuid.c 	uuid_t be;
be                 22 lib/test_uuid.c 		.be = UUID_INIT(0xc33f4995, 0x3701, 0x450e, 0x9f, 0xbf, 0x20, 0x6a, 0x2e, 0x98, 0xe5, 0x76),
be                 27 lib/test_uuid.c 		.be = UUID_INIT(0x64b4371c, 0x77c1, 0x48f9, 0x82, 0x21, 0x29, 0xf0, 0x54, 0xfc, 0x02, 0x3b),
be                 32 lib/test_uuid.c 		.be = UUID_INIT(0x0cb4ddff, 0xa545, 0x4401, 0x9d, 0x06, 0x68, 0x8a, 0xf5, 0x3e, 0x7f, 0x84),
be                 45 lib/test_uuid.c static void __init test_uuid_failed(const char *prefix, bool wrong, bool be,
be                 52 lib/test_uuid.c 	       be ? "BE" : "LE",
be                 65 lib/test_uuid.c 	uuid_t be;
be                 81 lib/test_uuid.c 	if (uuid_parse(data->uuid, &be))
be                 85 lib/test_uuid.c 	if (!uuid_equal(&data->be, &be)) {
be                 86 lib/test_uuid.c 		sprintf(buf, "%pUb", &be);
be                 94 lib/test_uuid.c 	uuid_t be;
be                103 lib/test_uuid.c 	if (!uuid_parse(data, &be))
be                536 net/atm/br2684.c 	struct atm_backend_br2684 be;
be                539 net/atm/br2684.c 	if (copy_from_user(&be, arg, sizeof be))
be                552 net/atm/br2684.c 	net_dev = br2684_find_dev(&be.ifspec);
be                568 net/atm/br2684.c 	if (be.fcs_in != BR2684_FCSIN_NO ||
be                569 net/atm/br2684.c 	    be.fcs_out != BR2684_FCSOUT_NO ||
be                570 net/atm/br2684.c 	    be.fcs_auto || be.has_vpiid || be.send_padding ||
be                571 net/atm/br2684.c 	    (be.encaps != BR2684_ENCAPS_VC &&
be                572 net/atm/br2684.c 	     be.encaps != BR2684_ENCAPS_LLC) ||
be                573 net/atm/br2684.c 	    be.min_size != 0) {
be                577 net/atm/br2684.c 	pr_debug("vcc=%p, encaps=%d, brvcc=%p\n", atmvcc, be.encaps, brvcc);
be                590 net/atm/br2684.c 	brvcc->encaps = (enum br2684_encaps)be.encaps;
be                389 net/atm/pppoatm.c 	struct atm_backend_ppp be;
be                397 net/atm/pppoatm.c 	if (copy_from_user(&be, arg, sizeof be))
be                399 net/atm/pppoatm.c 	if (be.encaps != PPPOATM_ENCAPS_AUTODETECT &&
be                400 net/atm/pppoatm.c 	    be.encaps != PPPOATM_ENCAPS_VC && be.encaps != PPPOATM_ENCAPS_LLC)
be                413 net/atm/pppoatm.c 	pvcc->encaps = (enum pppoatm_encaps) be.encaps;
be                417 net/atm/pppoatm.c 	    (be.encaps == e_vc ? 0 : LLC_LEN);
be                 93 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be;
be                 95 net/netfilter/nft_set_bitmap.c 	list_for_each_entry_rcu(be, &priv->list, head) {
be                 96 net/netfilter/nft_set_bitmap.c 		if (memcmp(nft_set_ext_key(&be->ext),
be                 98 net/netfilter/nft_set_bitmap.c 		    !nft_set_elem_active(&be->ext, genmask))
be                101 net/netfilter/nft_set_bitmap.c 		return be;
be                111 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be;
be                113 net/netfilter/nft_set_bitmap.c 	list_for_each_entry_rcu(be, &priv->list, head) {
be                114 net/netfilter/nft_set_bitmap.c 		if (memcmp(nft_set_ext_key(&be->ext), elem->key.val.data, set->klen) ||
be                115 net/netfilter/nft_set_bitmap.c 		    !nft_set_elem_active(&be->ext, genmask))
be                118 net/netfilter/nft_set_bitmap.c 		return be;
be                128 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *new = elem->priv, *be;
be                132 net/netfilter/nft_set_bitmap.c 	be = nft_bitmap_elem_find(set, new, genmask);
be                133 net/netfilter/nft_set_bitmap.c 	if (be) {
be                134 net/netfilter/nft_set_bitmap.c 		*ext = &be->ext;
be                151 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be = elem->priv;
be                155 net/netfilter/nft_set_bitmap.c 	nft_bitmap_location(set, nft_set_ext_key(&be->ext), &idx, &off);
be                158 net/netfilter/nft_set_bitmap.c 	list_del_rcu(&be->head);
be                166 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be = elem->priv;
be                170 net/netfilter/nft_set_bitmap.c 	nft_bitmap_location(set, nft_set_ext_key(&be->ext), &idx, &off);
be                173 net/netfilter/nft_set_bitmap.c 	nft_set_elem_change_active(net, set, &be->ext);
be                181 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be = _be;
be                184 net/netfilter/nft_set_bitmap.c 	nft_bitmap_location(set, nft_set_ext_key(&be->ext), &idx, &off);
be                187 net/netfilter/nft_set_bitmap.c 	nft_set_elem_change_active(net, set, &be->ext);
be                197 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *this = elem->priv, *be;
be                203 net/netfilter/nft_set_bitmap.c 	be = nft_bitmap_elem_find(set, this, genmask);
be                204 net/netfilter/nft_set_bitmap.c 	if (!be)
be                209 net/netfilter/nft_set_bitmap.c 	nft_set_elem_change_active(net, set, &be->ext);
be                211 net/netfilter/nft_set_bitmap.c 	return be;
be                219 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be;
be                222 net/netfilter/nft_set_bitmap.c 	list_for_each_entry_rcu(be, &priv->list, head) {
be                225 net/netfilter/nft_set_bitmap.c 		if (!nft_set_elem_active(&be->ext, iter->genmask))
be                228 net/netfilter/nft_set_bitmap.c 		elem.priv = be;
be                276 net/netfilter/nft_set_bitmap.c 	struct nft_bitmap_elem *be, *n;
be                278 net/netfilter/nft_set_bitmap.c 	list_for_each_entry_safe(be, n, &priv->list, head)
be                279 net/netfilter/nft_set_bitmap.c 		nft_set_elem_destroy(set, be, true);
be               1543 net/tipc/node.c 	struct tipc_bclink_entry *be = &n->bc_entry;
be               1546 net/tipc/node.c 	spin_lock_bh(&be->inputq2.lock);
be               1547 net/tipc/node.c 	spin_lock_bh(&be->inputq1.lock);
be               1548 net/tipc/node.c 	skb_queue_splice_tail_init(&be->inputq1, &be->arrvq);
be               1549 net/tipc/node.c 	spin_unlock_bh(&be->inputq1.lock);
be               1550 net/tipc/node.c 	spin_unlock_bh(&be->inputq2.lock);
be               1551 net/tipc/node.c 	tipc_sk_mcast_rcv(n->net, &be->arrvq, &be->inputq2);
be               1594 net/tipc/node.c 	struct tipc_bclink_entry *be;
be               1612 net/tipc/node.c 	be = &n->bc_entry;
be               1615 net/tipc/node.c 	rc = tipc_bcast_rcv(net, be->link, skb);
be               1627 net/tipc/node.c 	if (!skb_queue_empty(&be->inputq1))
be                155 sound/soc/fsl/fsl_asrc_dma.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be                157 sound/soc/fsl/fsl_asrc_dma.c 		struct snd_soc_dai *dai = be->cpu_dai;
be                162 sound/soc/fsl/fsl_asrc_dma.c 		substream_be = snd_soc_dpcm_get_substream(be, stream);
be                258 sound/soc/intel/boards/bdw-rt5677.c SND_SOC_DAILINK_DEF(be,
be                294 sound/soc/intel/boards/bdw-rt5677.c 		SND_SOC_DAILINK_REG(dummy, be, dummy),
be                288 sound/soc/intel/boards/kbl_da7219_max98927.c 	struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link;
be                407 sound/soc/intel/boards/kbl_rt5663_max98927.c 	struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link;
be                277 sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c 	struct snd_soc_dai_link *be_dai_link = dpcm->be->dai_link;
be               2943 sound/soc/intel/skylake/skl-topology.c static int skl_init_algo_data(struct device *dev, struct soc_bytes_ext *be,
be               2968 sound/soc/intel/skylake/skl-topology.c 	be->dobj.private  = ac;
be                176 sound/soc/meson/axg-card.c 	struct axg_dai_link_tdm_data *be =
be                182 sound/soc/meson/axg-card.c 	if (be->mclk_fs) {
be                183 sound/soc/meson/axg-card.c 		mclk = params_rate(params) * be->mclk_fs;
be                208 sound/soc/meson/axg-card.c 	struct axg_dai_link_tdm_data *be =
be                215 sound/soc/meson/axg-card.c 					       be->codec_masks[i].tx,
be                216 sound/soc/meson/axg-card.c 					       be->codec_masks[i].rx,
be                217 sound/soc/meson/axg-card.c 					       be->slots, be->slot_width);
be                225 sound/soc/meson/axg-card.c 	ret = axg_tdm_set_tdm_slots(rtd->cpu_dai, be->tx_mask, be->rx_mask,
be                226 sound/soc/meson/axg-card.c 				    be->slots, be->slot_width);
be                238 sound/soc/meson/axg-card.c 	struct axg_dai_link_tdm_data *be =
be                243 sound/soc/meson/axg-card.c 	ret = axg_tdm_set_tdm_slots(rtd->cpu_dai, NULL, be->tx_mask,
be                244 sound/soc/meson/axg-card.c 				    be->slots, be->slot_width);
be                336 sound/soc/meson/axg-card.c 					struct axg_dai_link_tdm_data *be)
be                342 sound/soc/meson/axg-card.c 	be->tx_mask = devm_kcalloc(card->dev, AXG_TDM_NUM_LANES,
be                343 sound/soc/meson/axg-card.c 				   sizeof(*be->tx_mask), GFP_KERNEL);
be                344 sound/soc/meson/axg-card.c 	be->rx_mask = devm_kcalloc(card->dev, AXG_TDM_NUM_LANES,
be                345 sound/soc/meson/axg-card.c 				   sizeof(*be->rx_mask), GFP_KERNEL);
be                346 sound/soc/meson/axg-card.c 	if (!be->tx_mask || !be->rx_mask)
be                351 sound/soc/meson/axg-card.c 		snd_soc_of_get_slot_mask(node, propname, &be->tx_mask[i]);
be                352 sound/soc/meson/axg-card.c 		tx = max(tx, be->tx_mask[i]);
be                361 sound/soc/meson/axg-card.c 		snd_soc_of_get_slot_mask(node, propname, &be->rx_mask[i]);
be                362 sound/soc/meson/axg-card.c 		rx = max(rx, be->rx_mask[i]);
be                375 sound/soc/meson/axg-card.c 	of_property_read_u32(node, "dai-tdm-slot-num", &be->slots);
be                376 sound/soc/meson/axg-card.c 	if (!be->slots) {
be                381 sound/soc/meson/axg-card.c 		be->slots = fls(max(tx, rx));
be                382 sound/soc/meson/axg-card.c 	} else if (be->slots < fls(max(tx, rx)) || be->slots > 32) {
be                391 sound/soc/meson/axg-card.c 	of_property_read_u32(node, "dai-tdm-slot-width", &be->slot_width);
be                399 sound/soc/meson/axg-card.c 				       struct axg_dai_link_tdm_data *be)
be                409 sound/soc/meson/axg-card.c 	be->codec_masks = codec_mask;
be                429 sound/soc/meson/axg-card.c 	struct axg_dai_link_tdm_data *be;
be                433 sound/soc/meson/axg-card.c 	be = devm_kzalloc(card->dev, sizeof(*be), GFP_KERNEL);
be                434 sound/soc/meson/axg-card.c 	if (!be)
be                436 sound/soc/meson/axg-card.c 	priv->link_data[*index] = be;
be                443 sound/soc/meson/axg-card.c 	of_property_read_u32(node, "mclk-fs", &be->mclk_fs);
be                445 sound/soc/meson/axg-card.c 	ret = axg_card_parse_cpu_tdm_slots(card, link, node, be);
be                451 sound/soc/meson/axg-card.c 	ret = axg_card_parse_codecs_masks(card, link, node, be);
be                 61 sound/soc/meson/axg-tdmin.c 	struct snd_soc_dai *be;
be                 70 sound/soc/meson/axg-tdmin.c 		be = axg_tdmin_get_be(p->source);
be                 71 sound/soc/meson/axg-tdmin.c 		if (be)
be                 72 sound/soc/meson/axg-tdmin.c 			return be;
be                 81 sound/soc/meson/axg-tdmin.c 	struct snd_soc_dai *be = axg_tdmin_get_be(w);
be                 83 sound/soc/meson/axg-tdmin.c 	if (!be)
be                 86 sound/soc/meson/axg-tdmin.c 	return be->capture_dma_data;
be                 59 sound/soc/meson/axg-tdmout.c 	struct snd_soc_dai *be;
be                 68 sound/soc/meson/axg-tdmout.c 		be = axg_tdmout_get_be(p->sink);
be                 69 sound/soc/meson/axg-tdmout.c 		if (be)
be                 70 sound/soc/meson/axg-tdmout.c 			return be;
be                 79 sound/soc/meson/axg-tdmout.c 	struct snd_soc_dai *be = axg_tdmout_get_be(w);
be                 81 sound/soc/meson/axg-tdmout.c 	if (!be)
be                 84 sound/soc/meson/axg-tdmout.c 	return be->playback_dma_data;
be                161 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be                163 sound/soc/soc-pcm.c 		dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
be                164 sound/soc/soc-pcm.c 				be->dai_link->name, event, dir);
be                167 sound/soc/soc-pcm.c 		    (be->dpcm[dir].users >= 1))
be                170 sound/soc/soc-pcm.c 		snd_soc_dapm_stream_event(be, dir, event);
be               1147 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be, int stream)
be               1157 sound/soc/soc-pcm.c 		if (dpcm->be == be && dpcm->fe == fe)
be               1165 sound/soc/soc-pcm.c 	dpcm->be = be;
be               1167 sound/soc/soc-pcm.c 	be->dpcm[stream].runtime = fe->dpcm[stream].runtime;
be               1171 sound/soc/soc-pcm.c 	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
be               1176 sound/soc/soc-pcm.c 			stream ? "<-" : "->", be->dai_link->name);
be               1179 sound/soc/soc-pcm.c 	name = kasprintf(GFP_KERNEL, "%s:%s", be->dai_link->name,
be               1194 sound/soc/soc-pcm.c 			struct snd_soc_pcm_runtime *be, int stream)
be               1200 sound/soc/soc-pcm.c 	if (!be->dpcm[stream].users)
be               1203 sound/soc/soc-pcm.c 	be_substream = snd_soc_dpcm_get_substream(be, stream);
be               1205 sound/soc/soc-pcm.c 	for_each_dpcm_fe(be, stream, dpcm) {
be               1212 sound/soc/soc-pcm.c 			stream ? "<-" : "->", dpcm->be->dai_link->name);
be               1229 sound/soc/soc-pcm.c 				dpcm->be->dai_link->name);
be               1236 sound/soc/soc-pcm.c 			stream ? "<-" : "->", dpcm->be->dai_link->name);
be               1239 sound/soc/soc-pcm.c 		dpcm_be_reparent(fe, dpcm->be, stream);
be               1256 sound/soc/soc-pcm.c 	struct snd_soc_pcm_runtime *be;
be               1263 sound/soc/soc-pcm.c 		for_each_card_rtds(card, be) {
be               1265 sound/soc/soc-pcm.c 			if (!be->dai_link->no_pcm)
be               1269 sound/soc/soc-pcm.c 				be->cpu_dai->playback_widget ?
be               1270 sound/soc/soc-pcm.c 				be->cpu_dai->playback_widget->name : "(not set)");
be               1272 sound/soc/soc-pcm.c 			if (be->cpu_dai->playback_widget == widget)
be               1273 sound/soc/soc-pcm.c 				return be;
be               1275 sound/soc/soc-pcm.c 			for_each_rtd_codec_dai(be, i, dai) {
be               1277 sound/soc/soc-pcm.c 					return be;
be               1282 sound/soc/soc-pcm.c 		for_each_card_rtds(card, be) {
be               1284 sound/soc/soc-pcm.c 			if (!be->dai_link->no_pcm)
be               1288 sound/soc/soc-pcm.c 				be->cpu_dai->capture_widget ?
be               1289 sound/soc/soc-pcm.c 				be->cpu_dai->capture_widget->name : "(not set)");
be               1291 sound/soc/soc-pcm.c 			if (be->cpu_dai->capture_widget == widget)
be               1292 sound/soc/soc-pcm.c 				return be;
be               1294 sound/soc/soc-pcm.c 			for_each_rtd_codec_dai(be, i, dai) {
be               1296 sound/soc/soc-pcm.c 					return be;
be               1399 sound/soc/soc-pcm.c 		widget = dai_get_widget(dpcm->be->cpu_dai, stream);
be               1407 sound/soc/soc-pcm.c 		for_each_rtd_codec_dai(dpcm->be, i, dai) {
be               1419 sound/soc/soc-pcm.c 			dpcm->be->dai_link->name, fe->dai_link->name);
be               1421 sound/soc/soc-pcm.c 		dpcm->be->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
be               1434 sound/soc/soc-pcm.c 	struct snd_soc_pcm_runtime *be;
be               1454 sound/soc/soc-pcm.c 		be = dpcm_get_be(card, list->widgets[i], stream);
be               1455 sound/soc/soc-pcm.c 		if (!be) {
be               1462 sound/soc/soc-pcm.c 		if (!be->dai_link->no_pcm)
be               1470 sound/soc/soc-pcm.c 		err = dpcm_be_connect(fe, be, stream);
be               1479 sound/soc/soc-pcm.c 		be->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE;
be               1507 sound/soc/soc-pcm.c 		dpcm->be->dpcm[stream].runtime_update =
be               1520 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1522 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               1524 sound/soc/soc-pcm.c 		if (be->dpcm[stream].users == 0)
be               1525 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
be               1527 sound/soc/soc-pcm.c 				be->dpcm[stream].state);
be               1529 sound/soc/soc-pcm.c 		if (--be->dpcm[stream].users != 0)
be               1532 sound/soc/soc-pcm.c 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)
be               1537 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
be               1549 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1551 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               1554 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: no backend %s stream\n",
be               1560 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               1564 sound/soc/soc-pcm.c 		if (be->dpcm[stream].users == DPCM_MAX_BE_USERS)
be               1565 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: too many users %s at open %d\n",
be               1567 sound/soc/soc-pcm.c 				be->dpcm[stream].state);
be               1569 sound/soc/soc-pcm.c 		if (be->dpcm[stream].users++ != 0)
be               1572 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
be               1573 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
be               1576 sound/soc/soc-pcm.c 		dev_dbg(be->dev, "ASoC: open %s BE %s\n",
be               1577 sound/soc/soc-pcm.c 			stream ? "capture" : "playback", be->dai_link->name);
be               1579 sound/soc/soc-pcm.c 		be_substream->runtime = be->dpcm[stream].runtime;
be               1582 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: BE open failed %d\n", err);
be               1583 sound/soc/soc-pcm.c 			be->dpcm[stream].users--;
be               1584 sound/soc/soc-pcm.c 			if (be->dpcm[stream].users < 0)
be               1585 sound/soc/soc-pcm.c 				dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
be               1587 sound/soc/soc-pcm.c 					be->dpcm[stream].state);
be               1589 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
be               1593 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
be               1602 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1604 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               1606 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               1609 sound/soc/soc-pcm.c 		if (be->dpcm[stream].users == 0)
be               1610 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: no users %s at close %d\n",
be               1612 sound/soc/soc-pcm.c 				be->dpcm[stream].state);
be               1614 sound/soc/soc-pcm.c 		if (--be->dpcm[stream].users != 0)
be               1617 sound/soc/soc-pcm.c 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)
be               1622 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
be               1659 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1664 sound/soc/soc-pcm.c 		for_each_rtd_codec_dai(be, i, dai) {
be               1700 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1701 sound/soc/soc-pcm.c 		struct snd_soc_dai_driver *cpu_dai_drv =  be->cpu_dai->driver;
be               1718 sound/soc/soc-pcm.c 		if (be->num_codecs == 1) {
be               1719 sound/soc/soc-pcm.c 			codec_dai_drv = be->codec_dais[0]->driver;
be               1752 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1753 sound/soc/soc-pcm.c 		struct snd_soc_dai_driver *cpu_dai_drv =  be->cpu_dai->driver;
be               1769 sound/soc/soc-pcm.c 		for_each_rtd_codec_dai(be, i, dai) {
be               1855 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1857 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               1946 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               1948 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               1951 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               1954 sound/soc/soc-pcm.c 		if (be->dpcm[stream].users == 0)
be               1955 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
be               1957 sound/soc/soc-pcm.c 				be->dpcm[stream].state);
be               1959 sound/soc/soc-pcm.c 		if (--be->dpcm[stream].users != 0)
be               1962 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
be               1963 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN)) {
be               1965 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
be               1968 sound/soc/soc-pcm.c 		dev_dbg(be->dev, "ASoC: close BE %s\n",
be               1969 sound/soc/soc-pcm.c 			be->dai_link->name);
be               1974 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
be               2010 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2012 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               2015 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               2019 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
be               2023 sound/soc/soc-pcm.c 		if (be->dpcm[stream].users > 1)
be               2026 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
be               2027 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
be               2028 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
be               2029 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
be               2030 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
be               2031 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
be               2034 sound/soc/soc-pcm.c 		dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
be               2035 sound/soc/soc-pcm.c 			be->dai_link->name);
be               2039 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
be               2079 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2081 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               2084 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               2092 sound/soc/soc-pcm.c 		if (be->dai_link->be_hw_params_fixup) {
be               2093 sound/soc/soc-pcm.c 			ret = be->dai_link->be_hw_params_fixup(be,
be               2096 sound/soc/soc-pcm.c 				dev_err(be->dev,
be               2104 sound/soc/soc-pcm.c 		memcpy(&be->dpcm[stream].hw_params, &dpcm->hw_params,
be               2108 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_can_be_params(fe, be, stream))
be               2111 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
be               2112 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
be               2113 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
be               2116 sound/soc/soc-pcm.c 		dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
be               2117 sound/soc/soc-pcm.c 			be->dai_link->name);
be               2121 sound/soc/soc-pcm.c 			dev_err(dpcm->be->dev,
be               2126 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
be               2133 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2135 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               2137 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               2141 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
be               2144 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
be               2145 sound/soc/soc-pcm.c 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
be               2146 sound/soc/soc-pcm.c 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
be               2147 sound/soc/soc-pcm.c 		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
be               2196 sound/soc/soc-pcm.c 	dev_dbg(dpcm->be->dev, "ASoC: trigger BE %s cmd %d\n",
be               2197 sound/soc/soc-pcm.c 			dpcm->be->dai_link->name, cmd);
be               2201 sound/soc/soc-pcm.c 		dev_err(dpcm->be->dev,"ASoC: trigger BE failed %d\n", ret);
be               2214 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2216 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               2219 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               2224 sound/soc/soc-pcm.c 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
be               2225 sound/soc/soc-pcm.c 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
be               2226 sound/soc/soc-pcm.c 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
be               2233 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
be               2236 sound/soc/soc-pcm.c 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
be               2243 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
be               2246 sound/soc/soc-pcm.c 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
be               2253 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
be               2256 sound/soc/soc-pcm.c 			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
be               2257 sound/soc/soc-pcm.c 			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
be               2260 sound/soc/soc-pcm.c 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
be               2267 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
be               2270 sound/soc/soc-pcm.c 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
be               2273 sound/soc/soc-pcm.c 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
be               2280 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
be               2283 sound/soc/soc-pcm.c 			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
be               2286 sound/soc/soc-pcm.c 			if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
be               2293 sound/soc/soc-pcm.c 			be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
be               2443 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2445 sound/soc/soc-pcm.c 			snd_soc_dpcm_get_substream(be, stream);
be               2448 sound/soc/soc-pcm.c 		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
be               2451 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
be               2452 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
be               2453 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND) &&
be               2454 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
be               2457 sound/soc/soc-pcm.c 		dev_dbg(be->dev, "ASoC: prepare BE %s\n",
be               2458 sound/soc/soc-pcm.c 			be->dai_link->name);
be               2462 sound/soc/soc-pcm.c 			dev_err(be->dev, "ASoC: backend prepare failed %d\n",
be               2467 sound/soc/soc-pcm.c 		be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
be               2634 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2635 sound/soc/soc-pcm.c 		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
be               2783 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               2786 sound/soc/soc-pcm.c 		if (be->dai_link->ignore_suspend)
be               2789 sound/soc/soc-pcm.c 		for_each_rtd_codec_dai(be, i, dai) {
be               2792 sound/soc/soc-pcm.c 			dev_dbg(be->dev, "ASoC: BE digital mute %s\n",
be               2793 sound/soc/soc-pcm.c 					 be->dai_link->name);
be               3035 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be, int stream)
be               3039 sound/soc/soc-pcm.c 		  be->dpcm[stream].runtime_update))
be               3047 sound/soc/soc-pcm.c 	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
be               3049 sound/soc/soc-pcm.c 	return be->pcm->streams[stream].substream;
be               3055 sound/soc/soc-pcm.c 	snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime *be, int stream)
be               3057 sound/soc/soc-pcm.c 	return be->dpcm[stream].state;
be               3062 sound/soc/soc-pcm.c void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime *be,
be               3065 sound/soc/soc-pcm.c 	be->dpcm[stream].state = state;
be               3074 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be, int stream)
be               3082 sound/soc/soc-pcm.c 	for_each_dpcm_fe(be, stream, dpcm) {
be               3107 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be, int stream)
be               3115 sound/soc/soc-pcm.c 	for_each_dpcm_fe(be, stream, dpcm) {
be               3201 sound/soc/soc-pcm.c 		struct snd_soc_pcm_runtime *be = dpcm->be;
be               3205 sound/soc/soc-pcm.c 				"- %s\n", be->dai_link->name);
be               3209 sound/soc/soc-pcm.c 				dpcm_state_string(be->dpcm[stream].state));
be               3211 sound/soc/soc-pcm.c 		if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
be               3212 sound/soc/soc-pcm.c 		    (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
be                593 sound/soc/soc-topology.c 		struct snd_soc_tplg_bytes_control *be;
be                596 sound/soc/soc-topology.c 		be = container_of(hdr, struct snd_soc_tplg_bytes_control, hdr);
be                608 sound/soc/soc-topology.c 			    ext_ops[i].id == le32_to_cpu(be->ext_ops.put))
be                611 sound/soc/soc-topology.c 			    ext_ops[i].id == le32_to_cpu(be->ext_ops.get))
be                750 sound/soc/soc-topology.c 	struct snd_soc_tplg_bytes_control *be;
be                764 sound/soc/soc-topology.c 		be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
be                767 sound/soc/soc-topology.c 		if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
be                776 sound/soc/soc-topology.c 			      le32_to_cpu(be->priv.size));
be                780 sound/soc/soc-topology.c 			be->hdr.name, be->hdr.access);
be                783 sound/soc/soc-topology.c 		kc.name = be->hdr.name;
be                786 sound/soc/soc-topology.c 		kc.access = le32_to_cpu(be->hdr.access);
be                788 sound/soc/soc-topology.c 		sbe->max = le32_to_cpu(be->max);
be                794 sound/soc/soc-topology.c 		err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc, tplg);
be                796 sound/soc/soc-topology.c 			soc_control_err(tplg, &be->hdr, be->hdr.name);
be                803 sound/soc/soc-topology.c 			(struct snd_soc_tplg_ctl_hdr *)be);
be                806 sound/soc/soc-topology.c 				be->hdr.name);
be                816 sound/soc/soc-topology.c 				be->hdr.name);
be               1515 sound/soc/soc-topology.c 	struct snd_soc_tplg_bytes_control *be;
be               1525 sound/soc/soc-topology.c 		be = (struct snd_soc_tplg_bytes_control *)tplg->pos;
be               1528 sound/soc/soc-topology.c 		if (strnlen(be->hdr.name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN) ==
be               1537 sound/soc/soc-topology.c 			      le32_to_cpu(be->priv.size));
be               1541 sound/soc/soc-topology.c 			be->hdr.name, be->hdr.access);
be               1544 sound/soc/soc-topology.c 		kc[i].name = kstrdup(be->hdr.name, GFP_KERNEL);
be               1548 sound/soc/soc-topology.c 		kc[i].access = le32_to_cpu(be->hdr.access);
be               1550 sound/soc/soc-topology.c 		sbe->max = le32_to_cpu(be->max);
be               1554 sound/soc/soc-topology.c 		err = soc_tplg_kcontrol_bind_io(&be->hdr, &kc[i], tplg);
be               1556 sound/soc/soc-topology.c 			soc_control_err(tplg, &be->hdr, be->hdr.name);
be               1562 sound/soc/soc-topology.c 			(struct snd_soc_tplg_ctl_hdr *)be);
be               1565 sound/soc/soc-topology.c 				be->hdr.name);
be                182 sound/soc/sof/control.c 	struct soc_bytes_ext *be =
be                184 sound/soc/sof/control.c 	struct snd_sof_control *scontrol = be->dobj.private;
be                191 sound/soc/sof/control.c 	if (be->max > sizeof(ucontrol->value.bytes.data)) {
be                194 sound/soc/sof/control.c 				    be->max);
be                199 sound/soc/sof/control.c 	if (size > be->max) {
be                202 sound/soc/sof/control.c 				    size, be->max);
be                217 sound/soc/sof/control.c 	struct soc_bytes_ext *be =
be                219 sound/soc/sof/control.c 	struct snd_sof_control *scontrol = be->dobj.private;
be                225 sound/soc/sof/control.c 	if (be->max > sizeof(ucontrol->value.bytes.data)) {
be                228 sound/soc/sof/control.c 				    be->max);
be                232 sound/soc/sof/control.c 	if (size > be->max) {
be                235 sound/soc/sof/control.c 				    size, be->max);
be                257 sound/soc/sof/control.c 	struct soc_bytes_ext *be =
be                259 sound/soc/sof/control.c 	struct snd_sof_control *scontrol = be->dobj.private;
be                275 sound/soc/sof/control.c 	if (header.length > be->max) {
be                277 sound/soc/sof/control.c 				    header.length, be->max);
be                305 sound/soc/sof/control.c 	if (cdata->data->size + sizeof(const struct sof_abi_hdr) > be->max) {
be                325 sound/soc/sof/control.c 	struct soc_bytes_ext *be =
be                327 sound/soc/sof/control.c 	struct snd_sof_control *scontrol = be->dobj.private;
be                350 sound/soc/sof/control.c 	if (data_size > be->max) {
be                352 sound/soc/sof/control.c 				    data_size, be->max);
be                 91 tools/iio/iio_generic_buffer.c 	if (info->be)
be                114 tools/iio/iio_generic_buffer.c 	if (info->be)
be                137 tools/iio/iio_generic_buffer.c 	if (info->be)
be                 86 tools/iio/iio_utils.c 		      unsigned *shift, uint64_t *mask, unsigned *be,
be                156 tools/iio/iio_utils.c 			*be = (endianchar == 'b');
be                503 tools/iio/iio_utils.c 						&current->be,
be                 47 tools/iio/iio_utils.h 	unsigned be;
be                 61 tools/iio/iio_utils.h 		      unsigned *shift, uint64_t *mask, unsigned *be,
be                964 tools/perf/util/cs-etm.c 	struct branch_entry *be;
be                977 tools/perf/util/cs-etm.c 	be       = &bs->entries[tidq->last_branch_pos];
be                978 tools/perf/util/cs-etm.c 	be->from = cs_etm__last_executed_instr(tidq->prev_packet);
be                979 tools/perf/util/cs-etm.c 	be->to	 = cs_etm__first_executed_instr(tidq->packet);
be                981 tools/perf/util/cs-etm.c 	be->flags.mispred = 0;
be                982 tools/perf/util/cs-etm.c 	be->flags.predicted = 1;
be                 46 tools/perf/util/genelf_debug.c buffer_ext_dump(struct buffer_ext *be, const char *msg)
be                 50 tools/perf/util/genelf_debug.c 	for (i = 0 ; i < be->cur_pos; i++)
be                 51 tools/perf/util/genelf_debug.c 		warnx("%4zu 0x%02x", i, (((char *)be->data)[i]) & 0xff);
be                 55 tools/perf/util/genelf_debug.c buffer_ext_add(struct buffer_ext *be, void *addr, size_t sz)
be                 58 tools/perf/util/genelf_debug.c 	size_t be_sz = be->max_sz;
be                 61 tools/perf/util/genelf_debug.c 	if ((be->cur_pos + sz) < be_sz) {
be                 62 tools/perf/util/genelf_debug.c 		memcpy(be->data + be->cur_pos, addr, sz);
be                 63 tools/perf/util/genelf_debug.c 		be->cur_pos += sz;
be                 72 tools/perf/util/genelf_debug.c 	tmp = realloc(be->data, be_sz);
be                 76 tools/perf/util/genelf_debug.c 	be->data   = tmp;
be                 77 tools/perf/util/genelf_debug.c 	be->max_sz = be_sz;
be                 83 tools/perf/util/genelf_debug.c buffer_ext_init(struct buffer_ext *be)
be                 85 tools/perf/util/genelf_debug.c 	be->data = NULL;
be                 86 tools/perf/util/genelf_debug.c 	be->cur_pos = 0;
be                 87 tools/perf/util/genelf_debug.c 	be->max_sz = 0;
be                 91 tools/perf/util/genelf_debug.c buffer_ext_size(struct buffer_ext *be)
be                 93 tools/perf/util/genelf_debug.c 	return be->cur_pos;
be                 97 tools/perf/util/genelf_debug.c buffer_ext_addr(struct buffer_ext *be)
be                 99 tools/perf/util/genelf_debug.c 	return be->data;
be                179 tools/perf/util/genelf_debug.c static void emit_uword(struct buffer_ext *be, uword data)
be                181 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &data, sizeof(uword));
be                184 tools/perf/util/genelf_debug.c static void emit_string(struct buffer_ext *be, const char *s)
be                186 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, (void *)s, strlen(s) + 1);
be                189 tools/perf/util/genelf_debug.c static void emit_unsigned_LEB128(struct buffer_ext *be,
be                197 tools/perf/util/genelf_debug.c 		buffer_ext_add(be, &cur, 1);
be                201 tools/perf/util/genelf_debug.c static void emit_signed_LEB128(struct buffer_ext *be, long data)
be                216 tools/perf/util/genelf_debug.c 		buffer_ext_add(be, &cur, 1);
be                220 tools/perf/util/genelf_debug.c static void emit_extended_opcode(struct buffer_ext *be, ubyte opcode,
be                223 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, (char *)"", 1);
be                225 tools/perf/util/genelf_debug.c 	emit_unsigned_LEB128(be, data_len + 1);
be                227 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &opcode, 1);
be                228 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, data, data_len);
be                231 tools/perf/util/genelf_debug.c static void emit_opcode(struct buffer_ext *be, ubyte opcode)
be                233 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &opcode, 1);
be                236 tools/perf/util/genelf_debug.c static void emit_opcode_signed(struct buffer_ext  *be,
be                239 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &opcode, 1);
be                240 tools/perf/util/genelf_debug.c 	emit_signed_LEB128(be, data);
be                243 tools/perf/util/genelf_debug.c static void emit_opcode_unsigned(struct buffer_ext *be, ubyte opcode,
be                246 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &opcode, 1);
be                247 tools/perf/util/genelf_debug.c 	emit_unsigned_LEB128(be, data);
be                250 tools/perf/util/genelf_debug.c static void emit_advance_pc(struct buffer_ext *be, unsigned long delta_pc)
be                252 tools/perf/util/genelf_debug.c 	emit_opcode_unsigned(be, DW_LNS_advance_pc, delta_pc);
be                255 tools/perf/util/genelf_debug.c static void emit_advance_lineno(struct buffer_ext  *be, long delta_lineno)
be                257 tools/perf/util/genelf_debug.c 	emit_opcode_signed(be, DW_LNS_advance_line, delta_lineno);
be                260 tools/perf/util/genelf_debug.c static void emit_lne_end_of_sequence(struct buffer_ext *be)
be                262 tools/perf/util/genelf_debug.c 	emit_extended_opcode(be, DW_LNE_end_sequence, NULL, 0);
be                265 tools/perf/util/genelf_debug.c static void emit_set_file(struct buffer_ext *be, unsigned long idx)
be                267 tools/perf/util/genelf_debug.c 	emit_opcode_unsigned(be, DW_LNS_set_file, idx);
be                270 tools/perf/util/genelf_debug.c static void emit_lne_define_filename(struct buffer_ext *be,
be                273 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, (void *)"", 1);
be                276 tools/perf/util/genelf_debug.c 	emit_unsigned_LEB128(be, strlen(filename) + 5);
be                277 tools/perf/util/genelf_debug.c 	emit_opcode(be, DW_LNE_define_file);
be                278 tools/perf/util/genelf_debug.c 	emit_string(be, filename);
be                280 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 0);
be                282 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 0);
be                284 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 0);
be                287 tools/perf/util/genelf_debug.c static void emit_lne_set_address(struct buffer_ext *be,
be                290 tools/perf/util/genelf_debug.c 	emit_extended_opcode(be, DW_LNE_set_address, &address, sizeof(unsigned long));
be                327 tools/perf/util/genelf_debug.c static void emit_lineno_info(struct buffer_ext *be,
be                350 tools/perf/util/genelf_debug.c 	emit_lne_set_address(be, (void *)code_addr);
be                360 tools/perf/util/genelf_debug.c 			emit_lne_define_filename(be, ent->name);
be                362 tools/perf/util/genelf_debug.c 			emit_set_file(be, ++cur_file_idx);
be                370 tools/perf/util/genelf_debug.c 			emit_opcode(be, special_opcode);
be                376 tools/perf/util/genelf_debug.c 				emit_advance_lineno(be, ent->lineno - last_line);
be                384 tools/perf/util/genelf_debug.c 				emit_advance_pc(be, ent->addr - last_vma);
be                392 tools/perf/util/genelf_debug.c 				emit_opcode(be, DW_LNS_copy);
be                397 tools/perf/util/genelf_debug.c static void add_debug_line(struct buffer_ext *be,
be                404 tools/perf/util/genelf_debug.c 	old_size = buffer_ext_size(be);
be                406 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, (void *)&default_debug_line_header,
be                409 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &standard_opcode_length,  sizeof(standard_opcode_length));
be                412 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, (void *)"", 1);
be                415 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, (void *)"", 1);
be                417 tools/perf/util/genelf_debug.c 	dbg_header = buffer_ext_addr(be) + old_size;
be                418 tools/perf/util/genelf_debug.c 	dbg_header->prolog_length = (buffer_ext_size(be) - old_size) -
be                421 tools/perf/util/genelf_debug.c 	emit_lineno_info(be, ent, nr_entry, code_addr);
be                423 tools/perf/util/genelf_debug.c 	emit_lne_end_of_sequence(be);
be                425 tools/perf/util/genelf_debug.c 	dbg_header = buffer_ext_addr(be) + old_size;
be                426 tools/perf/util/genelf_debug.c 	dbg_header->total_length = (buffer_ext_size(be) - old_size) -
be                431 tools/perf/util/genelf_debug.c add_debug_abbrev(struct buffer_ext *be)
be                433 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 1);
be                434 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, DW_TAG_compile_unit);
be                435 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, DW_CHILDREN_yes);
be                436 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, DW_AT_stmt_list);
be                437 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, DW_FORM_data4);
be                438 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 0);
be                439 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 0);
be                440 tools/perf/util/genelf_debug.c         emit_unsigned_LEB128(be, 0);
be                444 tools/perf/util/genelf_debug.c add_compilation_unit(struct buffer_ext *be,
be                448 tools/perf/util/genelf_debug.c 	size_t old_size = buffer_ext_size(be);
be                450 tools/perf/util/genelf_debug.c 	buffer_ext_add(be, &default_comp_unit_header,
be                453 tools/perf/util/genelf_debug.c 	emit_unsigned_LEB128(be, 1);
be                454 tools/perf/util/genelf_debug.c 	emit_uword(be, offset_debug_line);
be                456 tools/perf/util/genelf_debug.c 	comp_unit_header = buffer_ext_addr(be) + old_size;
be                457 tools/perf/util/genelf_debug.c 	comp_unit_header->total_length = (buffer_ext_size(be) - old_size) -
be               1166 tools/perf/util/intel-pt.c 	struct branch_entry *be;
be               1173 tools/perf/util/intel-pt.c 	be              = &bs->entries[ptq->last_branch_pos];
be               1174 tools/perf/util/intel-pt.c 	be->from        = state->from_ip;
be               1175 tools/perf/util/intel-pt.c 	be->to          = state->to_ip;
be               1176 tools/perf/util/intel-pt.c 	be->flags.abort = !!(state->flags & INTEL_PT_ABORT_TX);
be               1177 tools/perf/util/intel-pt.c 	be->flags.in_tx = !!(state->flags & INTEL_PT_IN_TX);
be               1179 tools/perf/util/intel-pt.c 	be->flags.mispred = ptq->pt->mispred_all;
be               2098 tools/perf/util/machine.c 			    struct branch_entry *be, int nr)
be               2106 tools/perf/util/machine.c 		iter->cycles += be[i].flags.cycles;
be               2321 tools/perf/util/machine.c 		struct branch_entry be[nr];
be               2331 tools/perf/util/machine.c 				be[i] = branch->entries[i];
be               2346 tools/perf/util/machine.c 				else if (be[i].from < chain->ips[first_call] &&
be               2347 tools/perf/util/machine.c 				    be[i].from >= chain->ips[first_call] - 8)
be               2350 tools/perf/util/machine.c 				be[i] = branch->entries[branch->nr - i - 1];
be               2354 tools/perf/util/machine.c 		nr = remove_loops(be, nr, iter);
be               2359 tools/perf/util/machine.c 					       NULL, be[i].to,
be               2360 tools/perf/util/machine.c 					       true, &be[i].flags,
be               2361 tools/perf/util/machine.c 					       NULL, be[i].from);
be               2365 tools/perf/util/machine.c 						       NULL, be[i].from,
be               2366 tools/perf/util/machine.c 						       true, &be[i].flags,
be                 42 tools/perf/util/trace-event.c 	int be = tep_is_bigendian();
be                 50 tools/perf/util/trace-event.c 	tep_set_file_bigendian(pevent, be);
be                 51 tools/perf/util/trace-event.c 	tep_set_local_bigendian(pevent, be);
be                532 tools/testing/nvdimm/test/nfit.c 	struct badrange_entry *be;
be                544 tools/testing/nvdimm/test/nfit.c 	list_for_each_entry(be, &badrange->list, list) {
be                545 tools/testing/nvdimm/test/nfit.c 		u64 be_end = be->start + be->length - 1;
be                549 tools/testing/nvdimm/test/nfit.c 		if (be_end < addr || be->start > end)
be                552 tools/testing/nvdimm/test/nfit.c 		rstart = (be->start < addr) ? addr : be->start;
be                882 tools/testing/nvdimm/test/nfit.c 	struct badrange_entry *be;
be                888 tools/testing/nvdimm/test/nfit.c 	list_for_each_entry(be, &t->badrange.list, list) {
be                889 tools/testing/nvdimm/test/nfit.c 		err_stat->record[i].err_inj_stat_spa_range_base = be->start;
be                890 tools/testing/nvdimm/test/nfit.c 		err_stat->record[i].err_inj_stat_spa_range_length = be->length;
be                125 virt/kvm/arm/psci.c 	reset_state->be = kvm_vcpu_is_be(source_vcpu);