es                133 arch/arm/mach-omap1/lcd_dma.c 	int es;
es                142 arch/arm/mach-omap1/lcd_dma.c 		es = 1;
es                145 arch/arm/mach-omap1/lcd_dma.c 		es = 2;
es                148 arch/arm/mach-omap1/lcd_dma.c 		es = 4;
es                161 arch/arm/mach-omap1/lcd_dma.c 		((y) * vxres * yscale + (x) * xscale) * es)
es                162 arch/arm/mach-omap1/lcd_dma.c #define PIXSTEP(sx, sy, dx, dy) (PIXADDR(dx, dy) - PIXADDR(sx, sy) - es + 1)
es                 20 arch/mips/include/asm/mach-ip27/kernel-entry-init.h 	dli	\res, LOCAL_HUB_ADDR(NI_STATUS_REV_ID)
es                 21 arch/mips/include/asm/mach-ip27/kernel-entry-init.h 	ld	\res, (\res)
es                 22 arch/mips/include/asm/mach-ip27/kernel-entry-init.h 	and	\res, NSRI_NODEID_MASK
es                 23 arch/mips/include/asm/mach-ip27/kernel-entry-init.h 	dsrl	\res, NSRI_NODEID_SHFT
es               3375 arch/mips/include/asm/octeon/cvmx-npei-defs.h 		uint64_t es:64;
es               3377 arch/mips/include/asm/octeon/cvmx-npei-defs.h 		uint64_t es:64;
es               3632 arch/mips/include/asm/octeon/cvmx-npei-defs.h 		uint64_t es:64;
es               3634 arch/mips/include/asm/octeon/cvmx-npei-defs.h 		uint64_t es:64;
es                195 arch/mips/include/asm/octeon/cvmx-pciercx-defs.h 		__BITFIELD_FIELD(uint32_t es:1,
es                 96 arch/mips/math-emu/ieee754dp.c 		int es = DP_EMIN - xe;
es                133 arch/mips/math-emu/ieee754dp.c 			xm = XDPSRS(xm, es);
es                134 arch/mips/math-emu/ieee754dp.c 			xe += es;
es                 96 arch/mips/math-emu/ieee754sp.c 		int es = SP_EMIN - xe;
es                132 arch/mips/math-emu/ieee754sp.c 			xm = XSPSRS(xm, es);
es                133 arch/mips/math-emu/ieee754sp.c 			xe += es;
es                 49 arch/mips/pci/pcie-octeon.c 		uint64_t es:2;	/* Endian swap = 1 */
es                 80 arch/mips/pci/pcie-octeon.c 		uint64_t es:2;	/* Endian swap = 1 */
es                113 arch/mips/pci/pcie-octeon.c 	pcie_addr.io.es = 1;
es                244 arch/mips/pci/pcie-octeon.c 	pcie_addr.config.es = 1;
es                 63 arch/s390/include/asm/cpu_mf.h 	unsigned int es:1;	    /* 22: basic-sampling enable control */
es                 86 arch/s390/include/asm/cpu_mf.h 	unsigned int es:1;	    /* 54: basic-sampling enable control */
es                989 arch/s390/kernel/perf_cpum_sf.c 			    cpuhw->lsctl.es, cpuhw->lsctl.cs, cpuhw->lsctl.ed,
es               1027 arch/s390/kernel/perf_cpum_sf.c 		if (si.es) {
es               1909 arch/s390/kernel/perf_cpum_sf.c 	if (WARN_ON_ONCE(cpuhw->lsctl.es == 1 || cpuhw->lsctl.ed == 1)) {
es               1924 arch/s390/kernel/perf_cpum_sf.c 	cpuhw->lsctl.es = 1;
es               1945 arch/s390/kernel/perf_cpum_sf.c 	cpuhw->lsctl.es = 0;
es                150 arch/s390/kernel/perf_event.c 			si.as, si.es, si.cs, si.bsdes, si.tear, si.dear);
es                252 arch/x86/boot/boot.h 			u16 es, ds;
es                108 arch/x86/boot/edd.c 	ireg.es = 0;
es                 24 arch/x86/boot/regs.c 	reg->es = ds();
es                 82 arch/x86/boot/string.c 	const char *es = s;
es                 83 arch/x86/boot/string.c 	while (*es && maxlen) {
es                 84 arch/x86/boot/string.c 		es++;
es                 88 arch/x86/boot/string.c 	return (es - s);
es                200 arch/x86/boot/video-vesa.c 	boot_params.screen_info.vesapm_seg = oreg.es;
es                251 arch/x86/boot/video-vesa.c 	ireg.es = 0;			/* ES:DI must be 0 by spec */
es                264 arch/x86/boot/video-vesa.c 	ireg.es = ds();
es                236 arch/x86/ia32/ia32_aout.c 	loadsegment(es, __USER32_DS);
es                 45 arch/x86/ia32/ia32_signal.c #define loadsegment_es(v)	loadsegment(es, v)
es                 75 arch/x86/ia32/ia32_signal.c 	u16 gs, fs, es, ds;
es                 86 arch/x86/ia32/ia32_signal.c 		es = GET_SEG(es);
es                113 arch/x86/ia32/ia32_signal.c 	RELOAD_SEG(es);
es                190 arch/x86/ia32/ia32_signal.c 		put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
es                322 arch/x86/ia32/ia32_signal.c 	loadsegment(es, __USER32_DS);
es                401 arch/x86/ia32/ia32_signal.c 	loadsegment(es, __USER32_DS);
es                131 arch/x86/include/asm/elf.h 	pr_reg[8] = regs->es;			\
es                182 arch/x86/include/asm/elf.h 	t->ds = t->es = ds;
es                 96 arch/x86/include/asm/kexec.h 		asm volatile("movl %%es, %%eax;" :"=a"(newregs->es));
es                288 arch/x86/include/asm/processor.h 	unsigned short		es, __esh;
es                450 arch/x86/include/asm/processor.h 	unsigned short		es;
es                 36 arch/x86/include/asm/ptrace.h 	unsigned short es;
es                223 arch/x86/include/asm/ptrace.h 	    offset == offsetof(struct pt_regs, es) ||
es                334 arch/x86/include/asm/segment.h #define __loadsegment_es(value) __loadsegment_simple(es, (value))
es                 28 arch/x86/include/asm/suspend_64.h 	u16 ds, es, fs, gs;
es                162 arch/x86/include/asm/svm.h 	struct vmcb_seg es;
es                 38 arch/x86/include/asm/user32.h 	unsigned short ds, __ds, es, __es;
es                 87 arch/x86/include/asm/user_32.h 	unsigned long	es;
es                 94 arch/x86/include/asm/user_64.h 	unsigned long	es;
es                 25 arch/x86/include/asm/vm86.h 	unsigned short es, __esh;
es                 66 arch/x86/include/asm/xen/interface_32.h     uint16_t es, _pad2;
es                124 arch/x86/include/asm/xen/interface_64.h     uint16_t es, _pad3[3];
es                151 arch/x86/include/uapi/asm/kvm.h 	struct kvm_segment cs, ds, es, fs, gs, ss;
es                205 arch/x86/include/uapi/asm/sigcontext.h 	__u16				es, __esh;
es                303 arch/x86/include/uapi/asm/sigcontext.h 	__u16				es, __esh;
es                 87 arch/x86/include/uapi/asm/vm86.h 	unsigned short es, __esh;
es                 35 arch/x86/kernel/asm-offsets_32.c 	OFFSET(PT_ES,  pt_regs, es);
es                 63 arch/x86/kernel/doublefault.c 	.es		= __USER_DS,
es                 62 arch/x86/kernel/kgdb.c 	{ "es", 4, offsetof(struct pt_regs, es) },
es                 45 arch/x86/kernel/ldt.c 	savesegment(es, sel);
es                 47 arch/x86/kernel/ldt.c 		loadsegment(es, sel);
es                 35 arch/x86/kernel/perf_regs.c 	PT_REGS_OFFSET(PERF_REG_X86_ES, es),
es                 79 arch/x86/kernel/process_32.c 	       (u16)regs->ds, (u16)regs->es, (u16)regs->fs, gs, regs->ss, regs->flags);
es                189 arch/x86/kernel/process_32.c 	regs->es		= __USER_DS;
es                 72 arch/x86/kernel/process_64.c 	unsigned int ds, es;
es                104 arch/x86/kernel/process_64.c 	asm("movl %%es,%0" : "=r" (es));
es                120 arch/x86/kernel/process_64.c 			es, cr0);
es                396 arch/x86/kernel/process_64.c 	savesegment(es, p->thread.es);
es                463 arch/x86/kernel/process_64.c 	loadsegment(es, _ds);
es                552 arch/x86/kernel/process_64.c 	savesegment(es, prev->es);
es                553 arch/x86/kernel/process_64.c 	if (unlikely(next->es | prev->es))
es                554 arch/x86/kernel/process_64.c 		loadsegment(es, next->es);
es                 86 arch/x86/kernel/ptrace.c 	REG_OFFSET_NAME(es),
es                257 arch/x86/kernel/ptrace.c 	case offsetof(struct user_regs_struct, es):
es                262 arch/x86/kernel/ptrace.c 		return task->thread.es;
es                296 arch/x86/kernel/ptrace.c 	case offsetof(struct user_regs_struct,es):
es                297 arch/x86/kernel/ptrace.c 		task->thread.es = value;
es                299 arch/x86/kernel/ptrace.c 			loadsegment(es, task->thread.es);
es                360 arch/x86/kernel/ptrace.c 	case offsetof(struct user_regs_struct, es):
es                402 arch/x86/kernel/ptrace.c 	case offsetof(struct user_regs_struct, es):
es                873 arch/x86/kernel/ptrace.c 	SEG32(es);
es                945 arch/x86/kernel/ptrace.c 	SEG32(es);
es                114 arch/x86/kernel/signal.c 		COPY_SEG(es);
es                169 arch/x86/kernel/signal.c 		put_user_ex(regs->es, (unsigned int __user *)&sc->es);
es                368 arch/x86/kernel/signal.c 	regs->es = __USER_DS;
es                434 arch/x86/kernel/signal.c 	regs->es = __USER_DS;
es                595 arch/x86/kernel/signal.c 	loadsegment(es, __USER_DS);
es                160 arch/x86/kernel/tls.c 		savesegment(es, sel);
es                162 arch/x86/kernel/tls.c 			loadsegment(es, sel);
es                137 arch/x86/kernel/vm86_32.c 		put_user_ex(regs->es, &user->regs.es);
es                303 arch/x86/kernel/vm86_32.c 		get_user_ex(vm86regs.es, &user_vm86->regs.es);
es               3064 arch/x86/kvm/emulate.c 	tss->es = get_segment_selector(ctxt, VCPU_SREG_ES);
es               3093 arch/x86/kvm/emulate.c 	set_segment_selector(ctxt, tss->es, VCPU_SREG_ES);
es               3108 arch/x86/kvm/emulate.c 	ret = __load_segment_descriptor(ctxt, tss->es, VCPU_SREG_ES, cpl,
es               3178 arch/x86/kvm/emulate.c 	tss->es = get_segment_selector(ctxt, VCPU_SREG_ES);
es               3213 arch/x86/kvm/emulate.c 	set_segment_selector(ctxt, tss->es, VCPU_SREG_ES);
es               3241 arch/x86/kvm/emulate.c 	ret = __load_segment_descriptor(ctxt, tss->es, VCPU_SREG_ES, cpl,
es               1606 arch/x86/kvm/svm.c 	init_seg(&save->es);
es               2440 arch/x86/kvm/svm.c 	case VCPU_SREG_ES: return &save->es;
es               3381 arch/x86/kvm/svm.c 	nested_vmcb->save.es     = vmcb->save.es;
es               3451 arch/x86/kvm/svm.c 	svm->vmcb->save.es = hsave->save.es;
es               3555 arch/x86/kvm/svm.c 	svm->vmcb->save.es = nested_vmcb->save.es;
es               3697 arch/x86/kvm/svm.c 	hsave->save.es     = vmcb->save.es;
es               4899 arch/x86/kvm/svm.c 	       save->es.selector, save->es.attrib,
es               4900 arch/x86/kvm/svm.c 	       save->es.limit, save->es.base);
es                 24 arch/x86/kvm/tss.h 	u32 es;
es                 53 arch/x86/kvm/tss.h 	u16 es;
es               1146 arch/x86/kvm/vmx/vmx.c 	savesegment(es, host_state->es_sel);
es               1201 arch/x86/kvm/vmx/vmx.c 		loadsegment(es, host_state->es_sel);
es               6609 arch/x86/kvm/vmx/vmx.c 	loadsegment(es, __USER_DS);
es               8728 arch/x86/kvm/x86.c 	kvm_get_segment(vcpu, &sregs->es, VCPU_SREG_ES);
es               8929 arch/x86/kvm/x86.c 	kvm_set_segment(vcpu, &sregs->es, VCPU_SREG_ES);
es                336 arch/x86/lib/insn-eval.c 		savesegment(es, sel);
es                359 arch/x86/lib/insn-eval.c 			return vm86regs->es;
es                379 arch/x86/lib/insn-eval.c 		return (unsigned short)(regs->es & 0xffff);
es                 48 arch/x86/math-emu/get_address.c 	offsetof(struct kernel_vm86_regs, es),
es                 61 arch/x86/math-emu/get_address.c 	offsetof(struct pt_regs, es),
es                109 arch/x86/power/cpu.c 	savesegment(es, ctxt->es);
es                223 arch/x86/power/cpu.c 	loadsegment(es, __USER_DS);
es                244 arch/x86/power/cpu.c 	loadsegment(ds, ctxt->es);
es                245 arch/x86/power/cpu.c 	loadsegment(es, ctxt->es);
es                171 arch/x86/um/signal.c 	GETREG(ES, es);
es                250 arch/x86/um/signal.c 	PUTREG(ES, es);
es                219 arch/x86/xen/smp_pv.c 	loadsegment(es, __USER_DS);
es                317 arch/x86/xen/smp_pv.c 	ctxt->user_regs.es = __USER_DS;
es                 33 drivers/clk/bcm/clk-cygnus.c #define ASIU_DIV_VAL(o, es, hs, hw, ls, lw) \
es                 34 drivers/clk/bcm/clk-cygnus.c 		{ .offset = o, .en_shift = es, .high_shift = hs, \
es                 46 drivers/clk/bcm/clk-cygnus.c #define ENABLE_VAL(o, es, hs, bs) { .offset = o, .enable_shift = es, \
es                 49 drivers/clk/bcm/clk-cygnus.c #define ASIU_GATE_VAL(o, es) { .offset = o, .en_shift = es }
es                 38 drivers/clk/bcm/clk-ns2.c #define ENABLE_VAL(o, es, hs, bs) { .offset = o, .enable_shift = es, \
es                 36 drivers/clk/bcm/clk-nsp.c #define ENABLE_VAL(o, es, hs, bs) { .offset = o, .enable_shift = es, \
es                 30 drivers/clk/bcm/clk-sr.c #define ENABLE_VAL(o, es, hs, bs) { .offset = o, .enable_shift = es, \
es                673 drivers/dma/fsl-edma-common.c 	edma->regs.es = edma->membase + EDMA_ES;
es                 89 drivers/dma/fsl-edma-common.h 	void __iomem *es;
es                129 drivers/dma/moxart-dma.c 	uint8_t				es;
es                279 drivers/dma/moxart-dma.c 	unsigned int es;
es                298 drivers/dma/moxart-dma.c 		es = MOXART_DMA_DATA_TYPE_S8;
es                301 drivers/dma/moxart-dma.c 		es = MOXART_DMA_DATA_TYPE_S16;
es                304 drivers/dma/moxart-dma.c 		es = MOXART_DMA_DATA_TYPE_S32;
es                318 drivers/dma/moxart-dma.c 	d->es = es;
es                381 drivers/dma/moxart-dma.c 	unsigned int sglen_div = es_bytes[d->es];
es                470 drivers/dma/moxart-dma.c 	size -= completed_cycles << es_bytes[ch->desc->es];
es                318 drivers/dma/mpc512x_dma.c static void mpc_dma_irq_process(struct mpc_dma *mdma, u32 is, u32 es, int off)
es                322 drivers/dma/mpc512x_dma.c 	u32 status = is | es;
es                335 drivers/dma/mpc512x_dma.c 		if (es & (1 << ch))
es                352 drivers/dma/mpc512x_dma.c 	uint es;
es                355 drivers/dma/mpc512x_dma.c 	es = in_be32(&mdma->regs->dmaes);
es                357 drivers/dma/mpc512x_dma.c 	if ((es & MPC_DMA_DMAES_VLD) && mdma->error_status == 0)
es                358 drivers/dma/mpc512x_dma.c 		mdma->error_status = es;
es                421 drivers/dma/mpc512x_dma.c 	uint es;
es                424 drivers/dma/mpc512x_dma.c 	es = mdma->error_status;
es                429 drivers/dma/mpc512x_dma.c 	if (es) {
es                432 drivers/dma/mpc512x_dma.c 						      MPC_DMA_DMAES_ERRCHN(es));
es                434 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_GPE)
es                436 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_CPE)
es                438 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_SAE)
es                440 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_SOE)
es                442 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_DAE)
es                444 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_DOE)
es                446 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_NCE)
es                448 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_SGE)
es                450 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_SBE)
es                452 drivers/dma/mpc512x_dma.c 		if (es & MPC_DMA_DMAES_DBE)
es                 98 drivers/dma/ti/omap-dma.c 	uint8_t es;		/* CSDP_DATA_TYPE_xxx */
es                725 drivers/dma/ti/omap-dma.c 	return size * es_bytes[d->es];
es                731 drivers/dma/ti/omap-dma.c 	size_t size, es_size = es_bytes[d->es];
es                895 drivers/dma/ti/omap-dma.c 	unsigned i, es, en, frame_bytes;
es                918 drivers/dma/ti/omap-dma.c 		es = CSDP_DATA_TYPE_8;
es                921 drivers/dma/ti/omap-dma.c 		es = CSDP_DATA_TYPE_16;
es                924 drivers/dma/ti/omap-dma.c 		es = CSDP_DATA_TYPE_32;
es                937 drivers/dma/ti/omap-dma.c 	d->es = es;
es                942 drivers/dma/ti/omap-dma.c 		port_window_bytes = port_window * es_bytes[es];
es                991 drivers/dma/ti/omap-dma.c 	d->csdp |= es;
es               1022 drivers/dma/ti/omap-dma.c 	frame_bytes = es_bytes[es] * en;
es               1076 drivers/dma/ti/omap-dma.c 	unsigned es;
es               1095 drivers/dma/ti/omap-dma.c 		es = CSDP_DATA_TYPE_8;
es               1098 drivers/dma/ti/omap-dma.c 		es = CSDP_DATA_TYPE_16;
es               1101 drivers/dma/ti/omap-dma.c 		es = CSDP_DATA_TYPE_32;
es               1115 drivers/dma/ti/omap-dma.c 	d->es = es;
es               1117 drivers/dma/ti/omap-dma.c 	d->sg[0].en = period_len / es_bytes[es];
es               1131 drivers/dma/ti/omap-dma.c 	d->csdp = es;
es               1187 drivers/dma/ti/omap-dma.c 	d->es = data_type;
es               1242 drivers/dma/ti/omap-dma.c 	d->es = data_type;
es                 65 drivers/md/dm-cache-policy-smq.c static int space_init(struct entry_space *es, unsigned nr_entries)
es                 68 drivers/md/dm-cache-policy-smq.c 		es->begin = es->end = NULL;
es                 72 drivers/md/dm-cache-policy-smq.c 	es->begin = vzalloc(array_size(nr_entries, sizeof(struct entry)));
es                 73 drivers/md/dm-cache-policy-smq.c 	if (!es->begin)
es                 76 drivers/md/dm-cache-policy-smq.c 	es->end = es->begin + nr_entries;
es                 80 drivers/md/dm-cache-policy-smq.c static void space_exit(struct entry_space *es)
es                 82 drivers/md/dm-cache-policy-smq.c 	vfree(es->begin);
es                 85 drivers/md/dm-cache-policy-smq.c static struct entry *__get_entry(struct entry_space *es, unsigned block)
es                 89 drivers/md/dm-cache-policy-smq.c 	e = es->begin + block;
es                 90 drivers/md/dm-cache-policy-smq.c 	BUG_ON(e >= es->end);
es                 95 drivers/md/dm-cache-policy-smq.c static unsigned to_index(struct entry_space *es, struct entry *e)
es                 97 drivers/md/dm-cache-policy-smq.c 	BUG_ON(e < es->begin || e >= es->end);
es                 98 drivers/md/dm-cache-policy-smq.c 	return e - es->begin;
es                101 drivers/md/dm-cache-policy-smq.c static struct entry *to_entry(struct entry_space *es, unsigned block)
es                106 drivers/md/dm-cache-policy-smq.c 	return __get_entry(es, block);
es                122 drivers/md/dm-cache-policy-smq.c static struct entry *l_head(struct entry_space *es, struct ilist *l)
es                124 drivers/md/dm-cache-policy-smq.c 	return to_entry(es, l->head);
es                127 drivers/md/dm-cache-policy-smq.c static struct entry *l_tail(struct entry_space *es, struct ilist *l)
es                129 drivers/md/dm-cache-policy-smq.c 	return to_entry(es, l->tail);
es                132 drivers/md/dm-cache-policy-smq.c static struct entry *l_next(struct entry_space *es, struct entry *e)
es                134 drivers/md/dm-cache-policy-smq.c 	return to_entry(es, e->next);
es                137 drivers/md/dm-cache-policy-smq.c static struct entry *l_prev(struct entry_space *es, struct entry *e)
es                139 drivers/md/dm-cache-policy-smq.c 	return to_entry(es, e->prev);
es                147 drivers/md/dm-cache-policy-smq.c static void l_add_head(struct entry_space *es, struct ilist *l, struct entry *e)
es                149 drivers/md/dm-cache-policy-smq.c 	struct entry *head = l_head(es, l);
es                155 drivers/md/dm-cache-policy-smq.c 		head->prev = l->head = to_index(es, e);
es                157 drivers/md/dm-cache-policy-smq.c 		l->head = l->tail = to_index(es, e);
es                163 drivers/md/dm-cache-policy-smq.c static void l_add_tail(struct entry_space *es, struct ilist *l, struct entry *e)
es                165 drivers/md/dm-cache-policy-smq.c 	struct entry *tail = l_tail(es, l);
es                171 drivers/md/dm-cache-policy-smq.c 		tail->next = l->tail = to_index(es, e);
es                173 drivers/md/dm-cache-policy-smq.c 		l->head = l->tail = to_index(es, e);
es                179 drivers/md/dm-cache-policy-smq.c static void l_add_before(struct entry_space *es, struct ilist *l,
es                182 drivers/md/dm-cache-policy-smq.c 	struct entry *prev = l_prev(es, old);
es                185 drivers/md/dm-cache-policy-smq.c 		l_add_head(es, l, e);
es                189 drivers/md/dm-cache-policy-smq.c 		e->next = to_index(es, old);
es                190 drivers/md/dm-cache-policy-smq.c 		prev->next = old->prev = to_index(es, e);
es                197 drivers/md/dm-cache-policy-smq.c static void l_del(struct entry_space *es, struct ilist *l, struct entry *e)
es                199 drivers/md/dm-cache-policy-smq.c 	struct entry *prev = l_prev(es, e);
es                200 drivers/md/dm-cache-policy-smq.c 	struct entry *next = l_next(es, e);
es                216 drivers/md/dm-cache-policy-smq.c static struct entry *l_pop_head(struct entry_space *es, struct ilist *l)
es                220 drivers/md/dm-cache-policy-smq.c 	for (e = l_head(es, l); e; e = l_next(es, e))
es                222 drivers/md/dm-cache-policy-smq.c 			l_del(es, l, e);
es                229 drivers/md/dm-cache-policy-smq.c static struct entry *l_pop_tail(struct entry_space *es, struct ilist *l)
es                233 drivers/md/dm-cache-policy-smq.c 	for (e = l_tail(es, l); e; e = l_prev(es, e))
es                235 drivers/md/dm-cache-policy-smq.c 			l_del(es, l, e);
es                253 drivers/md/dm-cache-policy-smq.c 	struct entry_space *es;
es                269 drivers/md/dm-cache-policy-smq.c static void q_init(struct queue *q, struct entry_space *es, unsigned nr_levels)
es                273 drivers/md/dm-cache-policy-smq.c 	q->es = es;
es                302 drivers/md/dm-cache-policy-smq.c 	l_add_tail(q->es, q->qs + e->level, e);
es                312 drivers/md/dm-cache-policy-smq.c 	l_add_head(q->es, q->qs + e->level, e);
es                322 drivers/md/dm-cache-policy-smq.c 	l_add_before(q->es, q->qs + e->level, old, e);
es                327 drivers/md/dm-cache-policy-smq.c 	l_del(q->es, q->qs + e->level, e);
es                343 drivers/md/dm-cache-policy-smq.c 		for (e = l_head(q->es, q->qs + level); e; e = l_next(q->es, e)) {
es                377 drivers/md/dm-cache-policy-smq.c 		for (e = l_head(q->es, q->qs + level); e; e = l_next(q->es, e))
es                379 drivers/md/dm-cache-policy-smq.c 				l_del(q->es, q->qs + e->level, e);
es                450 drivers/md/dm-cache-policy-smq.c 			l_add_tail(q->es, l, e);
es                458 drivers/md/dm-cache-policy-smq.c 			e = l_pop_tail(q->es, l);
es                465 drivers/md/dm-cache-policy-smq.c 			l_add_tail(q->es, l_above, e);
es                479 drivers/md/dm-cache-policy-smq.c 		for (de = l_head(q->es, q->qs + new_level); de && de->sentinel; de = l_next(q->es, de))
es                574 drivers/md/dm-cache-policy-smq.c 	struct entry_space *es;
es                583 drivers/md/dm-cache-policy-smq.c static int h_init(struct smq_hash_table *ht, struct entry_space *es, unsigned nr_entries)
es                587 drivers/md/dm-cache-policy-smq.c 	ht->es = es;
es                608 drivers/md/dm-cache-policy-smq.c 	return to_entry(ht->es, ht->buckets[bucket]);
es                613 drivers/md/dm-cache-policy-smq.c 	return to_entry(ht->es, e->hash_next);
es                619 drivers/md/dm-cache-policy-smq.c 	ht->buckets[bucket] = to_index(ht->es, e);
es                691 drivers/md/dm-cache-policy-smq.c 	struct entry_space *es;
es                698 drivers/md/dm-cache-policy-smq.c static void init_allocator(struct entry_alloc *ea, struct entry_space *es,
es                703 drivers/md/dm-cache-policy-smq.c 	ea->es = es;
es                709 drivers/md/dm-cache-policy-smq.c 		l_add_tail(ea->es, &ea->free, __get_entry(ea->es, i));
es                735 drivers/md/dm-cache-policy-smq.c 	e = l_pop_head(ea->es, &ea->free);
es                747 drivers/md/dm-cache-policy-smq.c 	struct entry *e = __get_entry(ea->es, ea->begin + i);
es                751 drivers/md/dm-cache-policy-smq.c 	l_del(ea->es, &ea->free, e);
es                765 drivers/md/dm-cache-policy-smq.c 	l_add_tail(ea->es, &ea->free, e);
es                775 drivers/md/dm-cache-policy-smq.c 	return to_index(ea->es, e) - ea->begin;
es                780 drivers/md/dm-cache-policy-smq.c 	return __get_entry(ea->es, ea->begin + index);
es                807 drivers/md/dm-cache-policy-smq.c 	struct entry_space es;
es               1359 drivers/md/dm-cache-policy-smq.c 	space_exit(&mq->es);
es               1742 drivers/md/dm-cache-policy-smq.c 	if (space_init(&mq->es, total_sentinels + mq->nr_hotspot_blocks + from_cblock(cache_size))) {
es               1747 drivers/md/dm-cache-policy-smq.c 	init_allocator(&mq->writeback_sentinel_alloc, &mq->es, 0, nr_sentinels_per_queue);
es               1751 drivers/md/dm-cache-policy-smq.c 	init_allocator(&mq->demote_sentinel_alloc, &mq->es, nr_sentinels_per_queue, total_sentinels);
es               1755 drivers/md/dm-cache-policy-smq.c 	init_allocator(&mq->hotspot_alloc, &mq->es, total_sentinels,
es               1758 drivers/md/dm-cache-policy-smq.c 	init_allocator(&mq->cache_alloc, &mq->es,
es               1782 drivers/md/dm-cache-policy-smq.c 	q_init(&mq->hotspot, &mq->es, NR_HOTSPOT_LEVELS);
es               1787 drivers/md/dm-cache-policy-smq.c 	q_init(&mq->clean, &mq->es, NR_CACHE_LEVELS);
es               1788 drivers/md/dm-cache-policy-smq.c 	q_init(&mq->dirty, &mq->es, NR_CACHE_LEVELS);
es               1793 drivers/md/dm-cache-policy-smq.c 	if (h_init(&mq->table, &mq->es, from_cblock(cache_size)))
es               1796 drivers/md/dm-cache-policy-smq.c 	if (h_init(&mq->hotspot_table, &mq->es, mq->nr_hotspot_blocks))
es               1822 drivers/md/dm-cache-policy-smq.c 	space_exit(&mq->es);
es                237 drivers/mmc/core/sd.c 	unsigned int au, es, et, eo;
es                273 drivers/mmc/core/sd.c 			es = UNSTUFF_BITS(card->raw_ssr, 408 - 384, 16);
es                275 drivers/mmc/core/sd.c 			if (es && et) {
es                277 drivers/mmc/core/sd.c 				card->ssr.erase_timeout = (et * 1000) / es;
es                105 drivers/mtd/devices/spear_smi.c #define FLASH_ID(n, es, id, psize, ssize, size)	\
es                108 drivers/mtd/devices/spear_smi.c 	.erase_cmd = es,	\
es                628 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 					const struct kvaser_usb_err_summary *es,
es                635 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	netdev_dbg(priv->netdev, "Error status: 0x%02x\n", es->status);
es                640 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	if (es->status & (M16C_STATE_BUS_OFF | M16C_STATE_BUS_RESET)) {
es                642 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	} else if (es->status & M16C_STATE_BUS_PASSIVE) {
es                644 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	} else if (es->status & M16C_STATE_BUS_ERROR) {
es                647 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->txerr >= 128 || es->rxerr >= 128)
es                649 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			else if (es->txerr >= 96 || es->rxerr >= 96)
es                656 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	if (!es->status)
es                660 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		tx_state = (es->txerr >= es->rxerr) ? new_state : 0;
es                661 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		rx_state = (es->txerr <= es->rxerr) ? new_state : 0;
es                673 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->leaf.error_factor) {
es                679 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_TX_ERROR)
es                681 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_RX_ERROR)
es                683 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
es                688 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	priv->bec.txerr = es->txerr;
es                689 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	priv->bec.rxerr = es->rxerr;
es                693 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 				     const struct kvaser_usb_err_summary *es)
es                703 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	if (es->channel >= dev->nchannels) {
es                705 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			"Invalid channel number (%d)\n", es->channel);
es                709 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	priv = dev->nets[es->channel];
es                723 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	kvaser_usb_leaf_rx_error_update_can_state(priv, es, &tmp_cf);
es                734 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->status &
es                752 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->leaf.error_factor) {
es                755 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_ACKE)
es                757 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_CRCE)
es                759 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_FORME)
es                761 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_STFE)
es                763 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_BITE0)
es                765 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_BITE1)
es                767 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			if (es->leaf.error_factor & M16C_EF_TRE)
es                772 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		if (es->usbcan.error_state & USBCAN_ERROR_STATE_BUSERROR)
es                777 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	cf->data[6] = es->txerr;
es                778 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	cf->data[7] = es->rxerr;
es                790 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 					      struct kvaser_usb_err_summary *es)
es                796 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	channel = es->channel;
es                806 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	if (es->txerr != priv->bec.txerr) {
es                807 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es->usbcan.error_state |= USBCAN_ERROR_STATE_TX_ERROR;
es                810 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	if (es->rxerr != priv->bec.rxerr) {
es                811 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es->usbcan.error_state |= USBCAN_ERROR_STATE_RX_ERROR;
es                814 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	if ((es->status & M16C_STATE_BUS_ERROR) &&
es                815 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	    !(es->usbcan.other_ch_status & M16C_STATE_BUS_ERROR)) {
es                816 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es->usbcan.error_state |= USBCAN_ERROR_STATE_BUSERROR;
es                821 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		kvaser_usb_leaf_rx_error(dev, es);
es                827 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	struct kvaser_usb_err_summary es = { };
es                832 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.channel = cmd->u.usbcan.chip_state_event.channel;
es                833 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.status = cmd->u.usbcan.chip_state_event.status;
es                834 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.txerr = cmd->u.usbcan.chip_state_event.tx_errors_count;
es                835 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.rxerr = cmd->u.usbcan.chip_state_event.rx_errors_count;
es                836 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
es                840 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.channel = 0;
es                841 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.status = cmd->u.usbcan.error_event.status_ch0;
es                842 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.txerr = cmd->u.usbcan.error_event.tx_errors_count_ch0;
es                843 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.rxerr = cmd->u.usbcan.error_event.rx_errors_count_ch0;
es                844 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.usbcan.other_ch_status =
es                846 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
es                852 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			es.channel = 1;
es                853 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			es.status = cmd->u.usbcan.error_event.status_ch1;
es                854 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			es.txerr =
es                856 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			es.rxerr =
es                858 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			es.usbcan.other_ch_status =
es                860 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 			kvaser_usb_leaf_usbcan_conditionally_rx_error(dev, &es);
es                872 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	struct kvaser_usb_err_summary es = { };
es                876 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.channel = cmd->u.leaf.error_event.channel;
es                877 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.status = cmd->u.leaf.error_event.status;
es                878 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.txerr = cmd->u.leaf.error_event.tx_errors_count;
es                879 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.rxerr = cmd->u.leaf.error_event.rx_errors_count;
es                880 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.leaf.error_factor = cmd->u.leaf.error_event.error_factor;
es                883 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.channel = cmd->u.leaf.log_message.channel;
es                884 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.status = cmd->u.leaf.log_message.data[0];
es                885 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.txerr = cmd->u.leaf.log_message.data[2];
es                886 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.rxerr = cmd->u.leaf.log_message.data[3];
es                887 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.leaf.error_factor = cmd->u.leaf.log_message.data[1];
es                890 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.channel = cmd->u.leaf.chip_state_event.channel;
es                891 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.status = cmd->u.leaf.chip_state_event.status;
es                892 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.txerr = cmd->u.leaf.chip_state_event.tx_errors_count;
es                893 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.rxerr = cmd->u.leaf.chip_state_event.rx_errors_count;
es                894 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 		es.leaf.error_factor = 0;
es                901 drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c 	kvaser_usb_leaf_rx_error(dev, &es);
es                629 drivers/net/ethernet/intel/i40e/i40e_main.c 	struct i40e_eth_stats *es;     /* device's eth stats */
es                631 drivers/net/ethernet/intel/i40e/i40e_main.c 	es = &vsi->eth_stats;
es                637 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_errors, &es->tx_errors);
es                640 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_discards, &es->rx_discards);
es                643 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_unknown_protocol, &es->rx_unknown_protocol);
es                648 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_bytes, &es->rx_bytes);
es                652 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_unicast, &es->rx_unicast);
es                656 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_multicast, &es->rx_multicast);
es                660 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_broadcast, &es->rx_broadcast);
es                665 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_bytes, &es->tx_bytes);
es                669 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_unicast, &es->tx_unicast);
es                673 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_multicast, &es->tx_multicast);
es                677 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_broadcast, &es->tx_broadcast);
es                690 drivers/net/ethernet/intel/i40e/i40e_main.c 	struct i40e_eth_stats *es;     /* device's eth stats */
es                696 drivers/net/ethernet/intel/i40e/i40e_main.c 	es = &veb->stats;
es                704 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_discards, &es->tx_discards);
es                709 drivers/net/ethernet/intel/i40e/i40e_main.c 				   &es->rx_unknown_protocol);
es                712 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_bytes, &es->rx_bytes);
es                715 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_unicast, &es->rx_unicast);
es                718 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_multicast, &es->rx_multicast);
es                721 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->rx_broadcast, &es->rx_broadcast);
es                725 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_bytes, &es->tx_bytes);
es                728 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_unicast, &es->tx_unicast);
es                731 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_multicast, &es->tx_multicast);
es                734 drivers/net/ethernet/intel/i40e/i40e_main.c 			   &oes->tx_broadcast, &es->tx_broadcast);
es                776 drivers/net/ethernet/intel/i40e/i40e_main.c 	struct i40e_eth_stats *es;     /* device's eth stats */
es                794 drivers/net/ethernet/intel/i40e/i40e_main.c 	es = &vsi->eth_stats;
es                850 drivers/net/ethernet/intel/i40e/i40e_main.c 	ns->tx_errors = es->tx_errors;
es                852 drivers/net/ethernet/intel/i40e/i40e_main.c 	ns->multicast = es->rx_multicast;
es                854 drivers/net/ethernet/intel/i40e/i40e_main.c 	ns->rx_dropped = es->rx_discards;
es                856 drivers/net/ethernet/intel/i40e/i40e_main.c 	ns->tx_dropped = es->tx_discards;
es                912 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 	u16 es;				/* # extraction sequence entries */
es               1240 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 	struct ice_sw_fv_section *es;
es               1317 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 			es = (struct ice_sw_fv_section *)sect;
es               1318 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 			src = (u8 *)es->fv;
es               1319 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 			sect_len = (u32)(le16_to_cpu(es->count) *
es               1320 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 					 hw->blk[block_id].es.fvw) *
es               1321 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 				sizeof(*hw->blk[block_id].es.t);
es               1322 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 			dst = (u8 *)hw->blk[block_id].es.t;
es               1323 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 			dst_len = (u32)(hw->blk[block_id].es.count *
es               1324 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 					hw->blk[block_id].es.fvw) *
es               1325 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 				sizeof(*hw->blk[block_id].es.t);
es               1370 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		ice_fill_tbl(hw, blk_id, hw->blk[blk_id].es.sid);
es               1395 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		devm_kfree(ice_hw_to_dev(hw), hw->blk[i].es.t);
es               1396 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		devm_kfree(ice_hw_to_dev(hw), hw->blk[i].es.ref_count);
es               1397 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		devm_kfree(ice_hw_to_dev(hw), hw->blk[i].es.written);
es               1416 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		struct ice_es *es = &hw->blk[i].es;
es               1432 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		memset(es->t, 0, es->count * sizeof(*es->t));
es               1433 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		memset(es->ref_count, 0, es->count * sizeof(*es->ref_count));
es               1434 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		memset(es->written, 0, es->count * sizeof(*es->written));
es               1451 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		struct ice_es *es = &hw->blk[i].es;
es               1460 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->reverse = blk_sizes[i].reverse;
es               1526 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->sid = ice_blk_sids[i][ICE_SID_ES_OFF];
es               1527 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->count = blk_sizes[i].es;
es               1528 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->fvw = blk_sizes[i].fvw;
es               1529 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->t = devm_kcalloc(ice_hw_to_dev(hw),
es               1530 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 				     (u32)(es->count * es->fvw),
es               1531 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 				     sizeof(*es->t), GFP_KERNEL);
es               1532 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		if (!es->t)
es               1535 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->ref_count = devm_kcalloc(ice_hw_to_dev(hw), es->count,
es               1536 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 					     sizeof(*es->ref_count),
es               1539 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		es->written = devm_kcalloc(ice_hw_to_dev(hw), es->count,
es               1540 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 					   sizeof(*es->written), GFP_KERNEL);
es               1541 drivers/net/ethernet/intel/ice/ice_flex_pipe.c 		if (!es->ref_count)
es                369 drivers/net/ethernet/intel/ice/ice_flex_type.h 	struct ice_es es;
es               3319 drivers/net/macsec.c 	bool es, scb, sci;
es               3368 drivers/net/macsec.c 	es  = data[IFLA_MACSEC_ES] ? nla_get_u8(data[IFLA_MACSEC_ES]) : false;
es               3372 drivers/net/macsec.c 	if ((sci && (scb || es)) || (scb && es))
es                314 drivers/parisc/eisa_enumerator.c 			     struct eeprom_eisa_slot_info *es, 
es                332 drivers/parisc/eisa_enumerator.c 	print_eisa_id(board, es->eisa_slot_id);
es                334 drivers/parisc/eisa_enumerator.c 	       slot, board, es->flags&HPEE_FLAG_BOARD_IS_ISA ? "ISA" : "EISA");
es                336 drivers/parisc/eisa_enumerator.c 	maxlen = es->config_data_length < HPEE_MAX_LENGTH ?
es                337 drivers/parisc/eisa_enumerator.c 			 es->config_data_length : HPEE_MAX_LENGTH;
es                338 drivers/parisc/eisa_enumerator.c 	while ((pos < maxlen) && (num_func <= es->num_functions)) {
es                409 drivers/parisc/eisa_enumerator.c 	if (pos != es->config_data_length) {
es                411 drivers/parisc/eisa_enumerator.c 			pos, es->config_data_length);
es                415 drivers/parisc/eisa_enumerator.c 	if (num_func != es->num_functions) {
es                417 drivers/parisc/eisa_enumerator.c 			num_func, es->num_functions);
es                425 drivers/parisc/eisa_enumerator.c static int init_slot(int slot, struct eeprom_eisa_slot_info *es)
es                431 drivers/parisc/eisa_enumerator.c 	if (!(es->slot_info&HPEE_SLOT_INFO_NO_READID)) {
es                437 drivers/parisc/eisa_enumerator.c 			if (es->eisa_slot_id == 0xffffffff)
es                446 drivers/parisc/eisa_enumerator.c 			print_eisa_id(id_string, es->eisa_slot_id);
es                452 drivers/parisc/eisa_enumerator.c 		if (es->eisa_slot_id != id) {
es                457 drivers/parisc/eisa_enumerator.c 			print_eisa_id(id_string, es->eisa_slot_id);
es                470 drivers/parisc/eisa_enumerator.c 	if (es->slot_features & HPEE_SLOT_FEATURES_ENABLE) {
es                495 drivers/parisc/eisa_enumerator.c 		struct eeprom_eisa_slot_info *es;
es                497 drivers/parisc/eisa_enumerator.c 		es = (struct eeprom_eisa_slot_info*)
es                500 drivers/parisc/eisa_enumerator.c 		if (-1==init_slot(i+1, es)) {
es                504 drivers/parisc/eisa_enumerator.c 		if (es->config_data_offset < HPEE_MAX_LENGTH) {
es                505 drivers/parisc/eisa_enumerator.c 			if (parse_slot_config(i+1, &eeprom_buf[es->config_data_offset],
es                506 drivers/parisc/eisa_enumerator.c 					      es, io_parent, mem_parent)) {
es                510 drivers/parisc/eisa_enumerator.c 			printk (KERN_WARNING "EISA EEPROM offset 0x%x out of range\n",es->config_data_offset);
es                591 drivers/pci/hotplug/ibmphp.h #define SLOT_ATTN(s, es)	((u8) ((es & HPC_SLOT_BLINK_ATTN) \
es                608 drivers/pci/hotplug/ibmphp.h #define SLOT_PCIX(es)	((u8) ((es & HPC_SLOT_PCIX) \
es                611 drivers/pci/hotplug/ibmphp.h #define SLOT_SPEED(es)	((u8) ((es & HPC_SLOT_SPEED2) \
es                612 drivers/pci/hotplug/ibmphp.h 	? ((es & HPC_SLOT_SPEED1) ? HPC_SLOT_SPEED_133   \
es                616 drivers/pci/hotplug/ibmphp.h #define SLOT_BUS_MODE(es)	((u8) ((es & HPC_SLOT_BUS_MODE) \
es                141 drivers/rtc/rtc-ds2404.c 	u8 ta01, ta02, es;
es                156 drivers/rtc/rtc-ds2404.c 	es = ds2404_read_byte(dev);
es                169 drivers/rtc/rtc-ds2404.c 	ds2404_write_byte(dev, es);
es                429 drivers/spi/spi-omap2-mcspi.c 				unsigned es)
es                453 drivers/spi/spi-omap2-mcspi.c 		transfer_reduction = es;
es                475 drivers/spi/spi-omap2-mcspi.c 			transfer_reduction += es;
es                591 drivers/spi/spi-omap2-mcspi.c 	unsigned es;
es                601 drivers/spi/spi-omap2-mcspi.c 		es = 1;
es                604 drivers/spi/spi-omap2-mcspi.c 		es = 2;
es                607 drivers/spi/spi-omap2-mcspi.c 		es = 4;
es                637 drivers/spi/spi-omap2-mcspi.c 		count = omap2_mcspi_rx_dma(spi, xfer, cfg, es);
es                879 drivers/staging/exfat/exfat.h void release_entry_set(struct entry_set_cache_t *es);
es                880 drivers/staging/exfat/exfat.h s32 write_whole_entry_set(struct super_block *sb, struct entry_set_cache_t *es);
es                882 drivers/staging/exfat/exfat.h 				       struct entry_set_cache_t *es,
es                903 drivers/staging/exfat/exfat.h 					struct entry_set_cache_t *es);
es               1559 drivers/staging/exfat/exfat_core.c 					struct entry_set_cache_t *es)
es               1565 drivers/staging/exfat/exfat_core.c 	ep = (struct dentry_t *)&(es->__buf);
es               1566 drivers/staging/exfat/exfat_core.c 	for (i = 0; i < es->num_entries; i++) {
es               1574 drivers/staging/exfat/exfat_core.c 	ep = (struct dentry_t *)&(es->__buf);
es               1576 drivers/staging/exfat/exfat_core.c 	write_whole_entry_set(sb, es);
es               1698 drivers/staging/exfat/exfat_core.c 	struct entry_set_cache_t *es = NULL;
es               1743 drivers/staging/exfat/exfat_core.c 	es = kmalloc(bufsize, GFP_KERNEL);
es               1744 drivers/staging/exfat/exfat_core.c 	if (!es)
es               1747 drivers/staging/exfat/exfat_core.c 	es->num_entries = num_entries;
es               1748 drivers/staging/exfat/exfat_core.c 	es->sector = sec;
es               1749 drivers/staging/exfat/exfat_core.c 	es->offset = off;
es               1750 drivers/staging/exfat/exfat_core.c 	es->alloc_flag = p_dir->flags;
es               1752 drivers/staging/exfat/exfat_core.c 	pos = (struct dentry_t *)&es->__buf;
es               1812 drivers/staging/exfat/exfat_core.c 				if (es->alloc_flag == 0x03) {
es               1835 drivers/staging/exfat/exfat_core.c 		*file_ep = (struct dentry_t *)&(es->__buf);
es               1838 drivers/staging/exfat/exfat_core.c 		   __func__, es, (unsigned long long)es->sector, es->offset,
es               1839 drivers/staging/exfat/exfat_core.c 		   es->alloc_flag, es->num_entries, &es->__buf);
es               1840 drivers/staging/exfat/exfat_core.c 	return es;
es               1842 drivers/staging/exfat/exfat_core.c 	pr_debug("%s exited NULL (es %p)\n", __func__, es);
es               1843 drivers/staging/exfat/exfat_core.c 	kfree(es);
es               1847 drivers/staging/exfat/exfat_core.c void release_entry_set(struct entry_set_cache_t *es)
es               1849 drivers/staging/exfat/exfat_core.c 	pr_debug("%s es=%p\n", __func__, es);
es               1850 drivers/staging/exfat/exfat_core.c 	kfree(es);
es               1854 drivers/staging/exfat/exfat_core.c 						struct entry_set_cache_t *es,
es               1857 drivers/staging/exfat/exfat_core.c 	s32 num_entries, buf_off = (off - es->offset);
es               1862 drivers/staging/exfat/exfat_core.c 	u8 *buf, *esbuf = (u8 *)&(es->__buf);
es               1865 drivers/staging/exfat/exfat_core.c 		__func__, es, (unsigned long long)sec, off, count);
es               1890 drivers/staging/exfat/exfat_core.c 				if (es->alloc_flag == 0x03) {
es               1913 drivers/staging/exfat/exfat_core.c s32 write_whole_entry_set(struct super_block *sb, struct entry_set_cache_t *es)
es               1915 drivers/staging/exfat/exfat_core.c 	return __write_partial_entries_in_entry_set(sb, es, es->sector,
es               1916 drivers/staging/exfat/exfat_core.c 						    es->offset,
es               1917 drivers/staging/exfat/exfat_core.c 						    es->num_entries);
es               1922 drivers/staging/exfat/exfat_core.c 	struct entry_set_cache_t *es, struct dentry_t *ep, u32 count)
es               1932 drivers/staging/exfat/exfat_core.c 	if (ep + count  > ((struct dentry_t *)&(es->__buf)) + es->num_entries)
es               1935 drivers/staging/exfat/exfat_core.c 	dir.dir = GET_CLUSTER_FROM_SECTOR(es->sector);
es               1936 drivers/staging/exfat/exfat_core.c 	dir.flags = es->alloc_flag;
es               1939 drivers/staging/exfat/exfat_core.c 	byte_offset = (es->sector - START_SECTOR(dir.dir)) <<
es               1941 drivers/staging/exfat/exfat_core.c 	byte_offset += ((void **)ep - &(es->__buf)) + es->offset;
es               1956 drivers/staging/exfat/exfat_core.c 	return __write_partial_entries_in_entry_set(sb, es, sec, off, count);
es               2650 drivers/staging/exfat/exfat_core.c 	struct entry_set_cache_t *es;
es               2653 drivers/staging/exfat/exfat_core.c 	es = get_entry_set_in_dir(sb, p_dir, entry, ES_ALL_ENTRIES, &ep);
es               2654 drivers/staging/exfat/exfat_core.c 	if (!es || es->num_entries < 3) {
es               2655 drivers/staging/exfat/exfat_core.c 		if (es)
es               2656 drivers/staging/exfat/exfat_core.c 			release_entry_set(es);
es               2668 drivers/staging/exfat/exfat_core.c 	for (i = 2; i < es->num_entries; i++, ep++) {
es               2678 drivers/staging/exfat/exfat_core.c 	release_entry_set(es);
es                554 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es                601 drivers/staging/exfat/exfat_super.c 			es = get_entry_set_in_dir(sb, &dir, dentry,
es                603 drivers/staging/exfat/exfat_super.c 			if (!es) {
es                632 drivers/staging/exfat/exfat_super.c 			release_entry_set(es);
es                822 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es               1006 drivers/staging/exfat/exfat_super.c 		es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
es               1008 drivers/staging/exfat/exfat_super.c 		if (!es)
es               1039 drivers/staging/exfat/exfat_super.c 		update_dir_checksum_with_entry_set(sb, es);
es               1040 drivers/staging/exfat/exfat_super.c 		release_entry_set(es);
es               1078 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es               1137 drivers/staging/exfat/exfat_super.c 		es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
es               1139 drivers/staging/exfat/exfat_super.c 		if (!es) {
es               1165 drivers/staging/exfat/exfat_super.c 		update_dir_checksum_with_entry_set(sb, es);
es               1166 drivers/staging/exfat/exfat_super.c 		release_entry_set(es);
es               1419 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es               1441 drivers/staging/exfat/exfat_super.c 		es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
es               1443 drivers/staging/exfat/exfat_super.c 		if (!es) {
es               1465 drivers/staging/exfat/exfat_super.c 			release_entry_set(es);
es               1478 drivers/staging/exfat/exfat_super.c 		update_dir_checksum_with_entry_set(sb, es);
es               1479 drivers/staging/exfat/exfat_super.c 		release_entry_set(es);
es               1509 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es               1557 drivers/staging/exfat/exfat_super.c 		es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
es               1559 drivers/staging/exfat/exfat_super.c 		if (!es) {
es               1621 drivers/staging/exfat/exfat_super.c 		release_entry_set(es);
es               1656 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es               1681 drivers/staging/exfat/exfat_super.c 		es = get_entry_set_in_dir(sb, &(fid->dir), fid->entry,
es               1683 drivers/staging/exfat/exfat_super.c 		if (!es) {
es               1722 drivers/staging/exfat/exfat_super.c 		update_dir_checksum_with_entry_set(sb, es);
es               1723 drivers/staging/exfat/exfat_super.c 		release_entry_set(es);
es               1747 drivers/staging/exfat/exfat_super.c 	struct entry_set_cache_t *es = NULL;
es               1835 drivers/staging/exfat/exfat_super.c 			es = get_entry_set_in_dir(sb, &fid->dir, fid->entry,
es               1837 drivers/staging/exfat/exfat_super.c 			if (!es) {
es               1868 drivers/staging/exfat/exfat_super.c 			update_dir_checksum_with_entry_set(sb, es);
es               1869 drivers/staging/exfat/exfat_super.c 			release_entry_set(es);
es                828 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	a->fmt.width = preview_port->es.video.width;
es                829 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	a->fmt.height = preview_port->es.video.height;
es                831 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	a->fmt.bytesperline = preview_port->es.video.width;
es                832 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	a->fmt.sizeimage = (preview_port->es.video.width *
es                833 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 			       preview_port->es.video.height * 3) >> 1;
es               1081 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.width = f->fmt.pix.width;
es               1082 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.height = f->fmt.pix.height;
es               1083 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.crop.x = 0;
es               1084 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.crop.y = 0;
es               1085 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.crop.width = f->fmt.pix.width;
es               1086 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.crop.height = f->fmt.pix.height;
es               1087 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.frame_rate.num = 0;
es               1088 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.frame_rate.den = 1;
es               1089 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	camera_port->es.video.color_space = MMAL_COLOR_SPACE_JPEG_JFIF;
es               1115 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.width = f->fmt.pix.width;
es               1116 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.height = f->fmt.pix.height;
es               1117 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.crop.x = 0;
es               1118 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.crop.y = 0;
es               1119 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.crop.width = f->fmt.pix.width;
es               1120 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.crop.height = f->fmt.pix.height;
es               1121 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.frame_rate.num =
es               1123 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 		preview_port->es.video.frame_rate.den =
es               1169 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.width = f->fmt.pix.width;
es               1170 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.height = f->fmt.pix.height;
es               1171 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.crop.x = 0;
es               1172 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.crop.y = 0;
es               1173 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.crop.width = f->fmt.pix.width;
es               1174 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.crop.height = f->fmt.pix.height;
es               1175 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.frame_rate.num =
es               1177 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 				port->es.video.frame_rate.den =
es               1251 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 			dev->capture.width = camera_port->es.video.crop.width;
es               1252 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 			dev->capture.height = camera_port->es.video.crop.height;
es               1613 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.width = 1024;
es               1614 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.height = 768;
es               1615 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.x = 0;
es               1616 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.y = 0;
es               1617 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.width = 1024;
es               1618 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.height = 768;
es               1619 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.frame_rate.num = 0; /* Rely on fps_range */
es               1620 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.frame_rate.den = 1;
es               1627 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.width = 1024;
es               1628 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.height = 768;
es               1629 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.x = 0;
es               1630 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.y = 0;
es               1631 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.width = 1024;
es               1632 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.height = 768;
es               1633 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.frame_rate.num = 0; /* Rely on fps_range */
es               1634 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.frame_rate.den = 1;
es               1640 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.width = 2592;
es               1641 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.height = 1944;
es               1642 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.x = 0;
es               1643 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.y = 0;
es               1644 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.width = 2592;
es               1645 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.crop.height = 1944;
es               1646 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.frame_rate.num = 0; /* Rely on fps_range */
es               1647 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	format->es->video.frame_rate.den = 1;
es               1649 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	dev->capture.width = format->es->video.width;
es               1650 drivers/staging/vc04_services/bcm2835-camera/bcm2835-camera.c 	dev->capture.height = format->es->video.height;
es                 66 drivers/staging/vc04_services/bcm2835-camera/mmal-msg-format.h 	union mmal_es_specific_format *es;	/* Type specific
es                 92 drivers/staging/vc04_services/bcm2835-camera/mmal-msg-format.h 	u32 es;	/* Type specific
es                165 drivers/staging/vc04_services/bcm2835-camera/mmal-msg.h 	union mmal_es_specific_format es; /* es type specific data */
es                176 drivers/staging/vc04_services/bcm2835-camera/mmal-msg.h 	union mmal_es_specific_format es;
es                190 drivers/staging/vc04_services/bcm2835-camera/mmal-msg.h 	union mmal_es_specific_format es;
es                730 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 		     port->es.video.width, port->es.video.height,
es                731 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 		     port->es.video.color_space);
es                734 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 			 port->es.video.crop.x,
es                735 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 			 port->es.video.crop.y,
es                736 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 			 port->es.video.crop.width, port->es.video.crop.height);
es                738 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 			 port->es.video.frame_rate.num,
es                739 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 			 port->es.video.frame_rate.den,
es                740 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 			 port->es.video.par.num, port->es.video.par.den);
es                792 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	memcpy(&m.u.port_info_set.es, &port->es,
es                894 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	memcpy(&port->es,
es                895 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	       &rmsg->u.port_info_get_reply.es,
es                897 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	port->format.es = &port->es;
es               1527 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.width = src->es.video.width;
es               1528 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.height = src->es.video.height;
es               1529 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.crop.x = src->es.video.crop.x;
es               1530 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.crop.y = src->es.video.crop.y;
es               1531 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.crop.width = src->es.video.crop.width;
es               1532 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.crop.height = src->es.video.crop.height;
es               1533 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.frame_rate.num = src->es.video.frame_rate.num;
es               1534 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.c 	dst->es.video.frame_rate.den = src->es.video.frame_rate.den;
es                 69 drivers/staging/vc04_services/bcm2835-camera/mmal-vchiq.h 	union mmal_es_specific_format es;
es                303 drivers/usb/gadget/udc/fsl_udc_core.c 	if (udc->pdata->es)
es                530 drivers/usb/host/ehci-fsl.c 	tmp = USBMODE_CM_HOST | (pdata->es ? USBMODE_ES : 0);
es                335 drivers/usb/host/fsl-mph-dr-of.c 	.es = 1,
es                902 drivers/usb/phy/phy-fsl-usb.c 	temp = USB_MODE_STREAM_DISABLE | (pdata->es ? USB_MODE_ES : 0);
es                564 drivers/video/fbdev/uvesafb.c 	if ((task->t.regs.eax & 0xffff) != 0x4f || task->t.regs.es < 0xc000) {
es                567 drivers/video/fbdev/uvesafb.c 		par->pmi_base = (u16 *)phys_to_virt(((u32)task->t.regs.es << 4)
es                572 drivers/video/fbdev/uvesafb.c 			(u16)task->t.regs.es, (u16)task->t.regs.edi);
es                150 drivers/w1/slaves/w1_ds2431.c 	u8 es = (addr + len - 1) % W1_F2D_SCRATCH_SIZE;
es                174 drivers/w1/slaves/w1_ds2431.c 	    (rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0)) {
es                191 drivers/w1/slaves/w1_ds2431.c 	wrbuf[3] = es;
es                159 drivers/w1/slaves/w1_ds2433.c 	u8 es = (addr + len - 1) & 0x1f;
es                181 drivers/w1/slaves/w1_ds2433.c 	    (rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0))
es                189 drivers/w1/slaves/w1_ds2433.c 	wrbuf[3] = es;
es                164 drivers/w1/slaves/w1_ds28e04.c 	u8 es = (addr + len - 1) & 0x1f;
es                189 drivers/w1/slaves/w1_ds28e04.c 	    (rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0))
es                197 drivers/w1/slaves/w1_ds28e04.c 	wrbuf[3] = es;
es                490 fs/ext2/balloc.c 	struct ext2_super_block * es = sbi->s_es;
es                504 fs/ext2/balloc.c 	block_group = (block - le32_to_cpu(es->s_first_data_block)) /
es                506 fs/ext2/balloc.c 	bit = (block - le32_to_cpu(es->s_first_data_block)) %
es               1245 fs/ext2/balloc.c 	struct ext2_super_block *es;
es               1267 fs/ext2/balloc.c 	es = EXT2_SB(sb)->s_es;
es               1292 fs/ext2/balloc.c 	if (goal < le32_to_cpu(es->s_first_data_block) ||
es               1293 fs/ext2/balloc.c 	    goal >= le32_to_cpu(es->s_blocks_count))
es               1294 fs/ext2/balloc.c 		goal = le32_to_cpu(es->s_first_data_block);
es               1295 fs/ext2/balloc.c 	group_no = (goal - le32_to_cpu(es->s_first_data_block)) /
es               1314 fs/ext2/balloc.c 		grp_target_blk = ((goal - le32_to_cpu(es->s_first_data_block)) %
es               1412 fs/ext2/balloc.c 	if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
es               1416 fs/ext2/balloc.c 			le32_to_cpu(es->s_blocks_count), group_no, es);
es               1473 fs/ext2/balloc.c 	struct ext2_super_block *es;
es               1475 fs/ext2/balloc.c 	es = EXT2_SB(sb)->s_es;
es               1496 fs/ext2/balloc.c 		(long)le32_to_cpu(es->s_free_blocks_count),
es                779 fs/ext2/ext2.h extern void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
es                112 fs/ext2/ialloc.c 	struct ext2_super_block * es;
es                125 fs/ext2/ialloc.c 	es = EXT2_SB(sb)->s_es;
es                129 fs/ext2/ialloc.c 	    ino > le32_to_cpu(es->s_inodes_count)) {
es                259 fs/ext2/ialloc.c 	struct ext2_super_block *es = sbi->s_es;
es                312 fs/ext2/ialloc.c 	blocks_per_dir = (le32_to_cpu(es->s_blocks_count)-free_blocks) / ndirs;
es                437 fs/ext2/ialloc.c 	struct ext2_super_block *es;
es                449 fs/ext2/ialloc.c 	es = sbi->s_es;
es                522 fs/ext2/ialloc.c 	if (ino < EXT2_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
es                627 fs/ext2/ialloc.c 	struct ext2_super_block *es;
es                631 fs/ext2/ialloc.c 	es = EXT2_SB(sb)->s_es;
es                 55 fs/ext2/super.c 	struct ext2_super_block *es = sbi->s_es;
es                 60 fs/ext2/super.c 		es->s_state |= cpu_to_le16(EXT2_ERROR_FS);
es                 62 fs/ext2/super.c 		ext2_sync_super(sb, es, 1);
es                105 fs/ext2/super.c 	struct ext2_super_block *es = EXT2_SB(sb)->s_es;
es                107 fs/ext2/super.c 	if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
es                115 fs/ext2/super.c 	es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);
es                116 fs/ext2/super.c 	es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);
es                117 fs/ext2/super.c 	es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);
es                156 fs/ext2/super.c 		struct ext2_super_block *es = sbi->s_es;
es                159 fs/ext2/super.c 		es->s_state = cpu_to_le16(sbi->s_mount_state);
es                161 fs/ext2/super.c 		ext2_sync_super(sb, es, 1);
es                243 fs/ext2/super.c 	struct ext2_super_block *es = sbi->s_es;
es                247 fs/ext2/super.c 	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
es                258 fs/ext2/super.c 	    le16_to_cpu(es->s_def_resuid) != EXT2_DEF_RESUID) {
es                263 fs/ext2/super.c 	    le16_to_cpu(es->s_def_resgid) != EXT2_DEF_RESGID) {
es                268 fs/ext2/super.c 		int def_errors = le16_to_cpu(es->s_errors);
es                645 fs/ext2/super.c 			      struct ext2_super_block * es,
es                651 fs/ext2/super.c 	if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {
es                667 fs/ext2/super.c 	else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
es                668 fs/ext2/super.c 		 le16_to_cpu(es->s_mnt_count) >=
es                669 fs/ext2/super.c 		 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
es                673 fs/ext2/super.c 	else if (le32_to_cpu(es->s_checkinterval) &&
es                674 fs/ext2/super.c 		(le32_to_cpu(es->s_lastcheck) +
es                675 fs/ext2/super.c 			le32_to_cpu(es->s_checkinterval) <=
es                680 fs/ext2/super.c 	if (!le16_to_cpu(es->s_max_mnt_count))
es                681 fs/ext2/super.c 		es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
es                682 fs/ext2/super.c 	le16_add_cpu(&es->s_mnt_count, 1);
es                828 fs/ext2/super.c 	struct ext2_super_block * es;
es                892 fs/ext2/super.c 	es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
es                893 fs/ext2/super.c 	sbi->s_es = es;
es                894 fs/ext2/super.c 	sb->s_magic = le16_to_cpu(es->s_magic);
es                901 fs/ext2/super.c 	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
es                924 fs/ext2/super.c 	opts.s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
es                925 fs/ext2/super.c 	opts.s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
es                940 fs/ext2/super.c 	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
es                994 fs/ext2/super.c 		es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
es                995 fs/ext2/super.c 		sbi->s_es = es;
es                996 fs/ext2/super.c 		if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
es               1007 fs/ext2/super.c 	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
es               1011 fs/ext2/super.c 		sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
es               1012 fs/ext2/super.c 		sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
es               1024 fs/ext2/super.c 				   le32_to_cpu(es->s_log_frag_size);
es               1029 fs/ext2/super.c 	sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
es               1030 fs/ext2/super.c 	sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
es               1031 fs/ext2/super.c 	sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
es               1041 fs/ext2/super.c 	sbi->s_mount_state = le16_to_cpu(es->s_state);
es               1085 fs/ext2/super.c 	sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
es               1086 fs/ext2/super.c 				le32_to_cpu(es->s_first_data_block) - 1)
es               1195 fs/ext2/super.c 	if (ext2_setup_super (sb, es, sb_rdonly(sb)))
es               1248 fs/ext2/super.c void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
es               1253 fs/ext2/super.c 	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
es               1254 fs/ext2/super.c 	es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
es               1255 fs/ext2/super.c 	es->s_wtime = cpu_to_le32(ktime_get_real_seconds());
es               1276 fs/ext2/super.c 	struct ext2_super_block *es = EXT2_SB(sb)->s_es;
es               1285 fs/ext2/super.c 	if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {
es               1287 fs/ext2/super.c 		es->s_state &= cpu_to_le16(~EXT2_VALID_FS);
es               1290 fs/ext2/super.c 	ext2_sync_super(sb, es, wait);
es               1333 fs/ext2/super.c 	struct ext2_super_block * es;
es               1349 fs/ext2/super.c 	es = sbi->s_es;
es               1358 fs/ext2/super.c 		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
es               1366 fs/ext2/super.c 		es->s_state = cpu_to_le16(sbi->s_mount_state);
es               1367 fs/ext2/super.c 		es->s_mtime = cpu_to_le32(ktime_get_real_seconds());
es               1374 fs/ext2/super.c 		ext2_sync_super(sb, es, 1);
es               1391 fs/ext2/super.c 		sbi->s_mount_state = le16_to_cpu(es->s_state);
es               1392 fs/ext2/super.c 		if (!ext2_setup_super (sb, es, 0))
es               1417 fs/ext2/super.c 	struct ext2_super_block *es = sbi->s_es;
es               1424 fs/ext2/super.c 	else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
es               1438 fs/ext2/super.c 		overhead = le32_to_cpu(es->s_first_data_block);
es               1457 fs/ext2/super.c 		sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
es               1462 fs/ext2/super.c 	buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
es               1464 fs/ext2/super.c 	es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
es               1465 fs/ext2/super.c 	buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
es               1466 fs/ext2/super.c 	if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
es               1468 fs/ext2/super.c 	buf->f_files = le32_to_cpu(es->s_inodes_count);
es               1470 fs/ext2/super.c 	es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
es               1472 fs/ext2/super.c 	fsid = le64_to_cpup((void *)es->s_uuid) ^
es               1473 fs/ext2/super.c 	       le64_to_cpup((void *)es->s_uuid + sizeof(u64));
es                 56 fs/ext4/balloc.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                 59 fs/ext4/balloc.c 	blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
es                693 fs/ext4/balloc.c 	struct ext4_super_block *es;
es                698 fs/ext4/balloc.c 	es = EXT4_SB(sb)->s_es;
es                728 fs/ext4/balloc.c 	       EXT4_NUM_B2C(EXT4_SB(sb), ext4_free_blocks_count(es)),
es                771 fs/ext4/balloc.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                776 fs/ext4/balloc.c 		if (group == le32_to_cpu(es->s_backup_bgs[0]) ||
es                777 fs/ext4/balloc.c 		    group == le32_to_cpu(es->s_backup_bgs[1]))
es                364 fs/ext4/block_validity.c 	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
es                378 fs/ext4/block_validity.c 			es->s_last_error_block = cpu_to_le64(blk);
es               2693 fs/ext4/ext4.h 				struct ext4_super_block *es,
es               2877 fs/ext4/ext4.h static inline ext4_fsblk_t ext4_blocks_count(struct ext4_super_block *es)
es               2879 fs/ext4/ext4.h 	return ((ext4_fsblk_t)le32_to_cpu(es->s_blocks_count_hi) << 32) |
es               2880 fs/ext4/ext4.h 		le32_to_cpu(es->s_blocks_count_lo);
es               2883 fs/ext4/ext4.h static inline ext4_fsblk_t ext4_r_blocks_count(struct ext4_super_block *es)
es               2885 fs/ext4/ext4.h 	return ((ext4_fsblk_t)le32_to_cpu(es->s_r_blocks_count_hi) << 32) |
es               2886 fs/ext4/ext4.h 		le32_to_cpu(es->s_r_blocks_count_lo);
es               2889 fs/ext4/ext4.h static inline ext4_fsblk_t ext4_free_blocks_count(struct ext4_super_block *es)
es               2891 fs/ext4/ext4.h 	return ((ext4_fsblk_t)le32_to_cpu(es->s_free_blocks_count_hi) << 32) |
es               2892 fs/ext4/ext4.h 		le32_to_cpu(es->s_free_blocks_count_lo);
es               2895 fs/ext4/ext4.h static inline void ext4_blocks_count_set(struct ext4_super_block *es,
es               2898 fs/ext4/ext4.h 	es->s_blocks_count_lo = cpu_to_le32((u32)blk);
es               2899 fs/ext4/ext4.h 	es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
es               2902 fs/ext4/ext4.h static inline void ext4_free_blocks_count_set(struct ext4_super_block *es,
es               2905 fs/ext4/ext4.h 	es->s_free_blocks_count_lo = cpu_to_le32((u32)blk);
es               2906 fs/ext4/ext4.h 	es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
es               2909 fs/ext4/ext4.h static inline void ext4_r_blocks_count_set(struct ext4_super_block *es,
es               2912 fs/ext4/ext4.h 	es->s_r_blocks_count_lo = cpu_to_le32((u32)blk);
es               2913 fs/ext4/ext4.h 	es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
es                302 fs/ext4/ext4_jbd2.c 				struct ext4_super_block *es;
es                304 fs/ext4/ext4_jbd2.c 				es = EXT4_SB(inode->i_sb)->s_es;
es                305 fs/ext4/ext4_jbd2.c 				es->s_last_error_block =
es                404 fs/ext4/extents.c 		struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
es                418 fs/ext4/extents.c 				es->s_last_error_block = cpu_to_le64(pblock);
es               1292 fs/ext4/extents.c 	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
es               1299 fs/ext4/extents.c 	if (goal > le32_to_cpu(es->s_first_data_block)) {
es               2182 fs/ext4/extents.c 	struct extent_status es;
es               2249 fs/ext4/extents.c 			es.es_lblk = start;
es               2250 fs/ext4/extents.c 			es.es_len = end - start;
es               2251 fs/ext4/extents.c 			es.es_pblk = 0;
es               2253 fs/ext4/extents.c 			es.es_lblk = le32_to_cpu(ex->ee_block);
es               2254 fs/ext4/extents.c 			es.es_len = ext4_ext_get_actual_len(ex);
es               2255 fs/ext4/extents.c 			es.es_pblk = ext4_ext_pblock(ex);
es               2265 fs/ext4/extents.c 		next_del = ext4_find_delayed_extent(inode, &es);
es               2273 fs/ext4/extents.c 		if (unlikely(es.es_len == 0)) {
es               2305 fs/ext4/extents.c 				(__u64)es.es_lblk << blksize_bits,
es               2306 fs/ext4/extents.c 				(__u64)es.es_pblk << blksize_bits,
es               2307 fs/ext4/extents.c 				(__u64)es.es_len << blksize_bits,
es               2317 fs/ext4/extents.c 		block = es.es_lblk + es.es_len;
es               2330 fs/ext4/extents.c 	struct extent_status es;
es               2338 fs/ext4/extents.c 		if (!ext4_es_lookup_extent(inode, block, &next, &es))
es               2340 fs/ext4/extents.c 		if (ext4_es_is_unwritten(&es))
es               2342 fs/ext4/extents.c 		if (ext4_es_is_delayed(&es))
es               2345 fs/ext4/extents.c 		if (ext4_es_is_hole(&es))
es               2351 fs/ext4/extents.c 			es.es_pblk = 0;
es               2353 fs/ext4/extents.c 			es.es_pblk = ext4_es_pblock(&es);
es               2355 fs/ext4/extents.c 				(__u64)es.es_lblk << blksize_bits,
es               2356 fs/ext4/extents.c 				(__u64)es.es_pblk << blksize_bits,
es               2357 fs/ext4/extents.c 				(__u64)es.es_len << blksize_bits,
es               2422 fs/ext4/extents.c 	struct extent_status es;
es               2425 fs/ext4/extents.c 				  hole_start + hole_len - 1, &es);
es               2426 fs/ext4/extents.c 	if (es.es_len) {
es               2428 fs/ext4/extents.c 		if (es.es_lblk <= hole_start)
es               2430 fs/ext4/extents.c 		hole_len = min(es.es_lblk - hole_start, hole_len);
es               5036 fs/ext4/extents.c 	struct extent_status es;
es               5043 fs/ext4/extents.c 					  &es);
es               5049 fs/ext4/extents.c 		if (es.es_len == 0)
es               5053 fs/ext4/extents.c 		if (es.es_lblk > newes->es_lblk) {
es               5055 fs/ext4/extents.c 			newes->es_len = min(es.es_lblk - newes->es_lblk,
es               5060 fs/ext4/extents.c 		newes->es_len = es.es_lblk + es.es_len - newes->es_lblk;
es               5065 fs/ext4/extents.c 				  EXT_MAX_BLOCKS, &es);
es               5066 fs/ext4/extents.c 	if (es.es_len == 0)
es               5069 fs/ext4/extents.c 		next_del = es.es_lblk;
es                187 fs/ext4/extents_status.c 		struct extent_status *es;
es                188 fs/ext4/extents_status.c 		es = rb_entry(node, struct extent_status, rb_node);
es                190 fs/ext4/extents_status.c 		       es->es_lblk, es->es_len,
es                191 fs/ext4/extents_status.c 		       ext4_es_pblock(es), ext4_es_status(es));
es                200 fs/ext4/extents_status.c static inline ext4_lblk_t ext4_es_end(struct extent_status *es)
es                202 fs/ext4/extents_status.c 	BUG_ON(es->es_lblk + es->es_len < es->es_lblk);
es                203 fs/ext4/extents_status.c 	return es->es_lblk + es->es_len - 1;
es                214 fs/ext4/extents_status.c 	struct extent_status *es = NULL;
es                217 fs/ext4/extents_status.c 		es = rb_entry(node, struct extent_status, rb_node);
es                218 fs/ext4/extents_status.c 		if (lblk < es->es_lblk)
es                220 fs/ext4/extents_status.c 		else if (lblk > ext4_es_end(es))
es                223 fs/ext4/extents_status.c 			return es;
es                226 fs/ext4/extents_status.c 	if (es && lblk < es->es_lblk)
es                227 fs/ext4/extents_status.c 		return es;
es                229 fs/ext4/extents_status.c 	if (es && lblk > ext4_es_end(es)) {
es                230 fs/ext4/extents_status.c 		node = rb_next(&es->rb_node);
es                257 fs/ext4/extents_status.c 				   int (*matching_fn)(struct extent_status *es),
es                259 fs/ext4/extents_status.c 				   struct extent_status *es)
es                265 fs/ext4/extents_status.c 	WARN_ON(es == NULL);
es                271 fs/ext4/extents_status.c 	es->es_lblk = es->es_len = es->es_pblk = 0;
es                299 fs/ext4/extents_status.c 		es->es_lblk = es1->es_lblk;
es                300 fs/ext4/extents_status.c 		es->es_len = es1->es_len;
es                301 fs/ext4/extents_status.c 		es->es_pblk = es1->es_pblk;
es                310 fs/ext4/extents_status.c 			       int (*matching_fn)(struct extent_status *es),
es                312 fs/ext4/extents_status.c 			       struct extent_status *es)
es                317 fs/ext4/extents_status.c 	__es_find_extent_range(inode, matching_fn, lblk, end, es);
es                320 fs/ext4/extents_status.c 	trace_ext4_es_find_extent_range_exit(inode, es);
es                339 fs/ext4/extents_status.c 			    int (*matching_fn)(struct extent_status *es),
es                342 fs/ext4/extents_status.c 	struct extent_status es;
es                344 fs/ext4/extents_status.c 	__es_find_extent_range(inode, matching_fn, start, end, &es);
es                345 fs/ext4/extents_status.c 	if (es.es_len == 0)
es                347 fs/ext4/extents_status.c 	else if (es.es_lblk <= start &&
es                348 fs/ext4/extents_status.c 		 start < es.es_lblk + es.es_len)
es                350 fs/ext4/extents_status.c 	else if (start <= es.es_lblk && es.es_lblk <= end)
es                359 fs/ext4/extents_status.c 			int (*matching_fn)(struct extent_status *es),
es                386 fs/ext4/extents_status.c 			  int (*matching_fn)(struct extent_status *es),
es                402 fs/ext4/extents_status.c 		      int (*matching_fn)(struct extent_status *es),
es                448 fs/ext4/extents_status.c 	struct extent_status *es;
es                449 fs/ext4/extents_status.c 	es = kmem_cache_alloc(ext4_es_cachep, GFP_ATOMIC);
es                450 fs/ext4/extents_status.c 	if (es == NULL)
es                452 fs/ext4/extents_status.c 	es->es_lblk = lblk;
es                453 fs/ext4/extents_status.c 	es->es_len = len;
es                454 fs/ext4/extents_status.c 	es->es_pblk = pblk;
es                459 fs/ext4/extents_status.c 	if (!ext4_es_is_delayed(es)) {
es                469 fs/ext4/extents_status.c 	return es;
es                472 fs/ext4/extents_status.c static void ext4_es_free_extent(struct inode *inode, struct extent_status *es)
es                478 fs/ext4/extents_status.c 	if (!ext4_es_is_delayed(es)) {
es                486 fs/ext4/extents_status.c 	kmem_cache_free(ext4_es_cachep, es);
es                529 fs/ext4/extents_status.c ext4_es_try_to_merge_left(struct inode *inode, struct extent_status *es)
es                535 fs/ext4/extents_status.c 	node = rb_prev(&es->rb_node);
es                537 fs/ext4/extents_status.c 		return es;
es                540 fs/ext4/extents_status.c 	if (ext4_es_can_be_merged(es1, es)) {
es                541 fs/ext4/extents_status.c 		es1->es_len += es->es_len;
es                542 fs/ext4/extents_status.c 		if (ext4_es_is_referenced(es))
es                544 fs/ext4/extents_status.c 		rb_erase(&es->rb_node, &tree->root);
es                545 fs/ext4/extents_status.c 		ext4_es_free_extent(inode, es);
es                546 fs/ext4/extents_status.c 		es = es1;
es                549 fs/ext4/extents_status.c 	return es;
es                553 fs/ext4/extents_status.c ext4_es_try_to_merge_right(struct inode *inode, struct extent_status *es)
es                559 fs/ext4/extents_status.c 	node = rb_next(&es->rb_node);
es                561 fs/ext4/extents_status.c 		return es;
es                564 fs/ext4/extents_status.c 	if (ext4_es_can_be_merged(es, es1)) {
es                565 fs/ext4/extents_status.c 		es->es_len += es1->es_len;
es                567 fs/ext4/extents_status.c 			ext4_es_set_referenced(es);
es                572 fs/ext4/extents_status.c 	return es;
es                579 fs/ext4/extents_status.c 					    struct extent_status *es)
es                588 fs/ext4/extents_status.c 	path = ext4_find_extent(inode, es->es_lblk, NULL, EXT4_EX_NOCACHE);
es                602 fs/ext4/extents_status.c 		es_status = ext4_es_is_unwritten(es) ? 1 : 0;
es                608 fs/ext4/extents_status.c 		if (!ext4_es_is_written(es) && !ext4_es_is_unwritten(es)) {
es                609 fs/ext4/extents_status.c 			if (in_range(es->es_lblk, ee_block, ee_len)) {
es                617 fs/ext4/extents_status.c 					es->es_lblk, es->es_len,
es                618 fs/ext4/extents_status.c 					ext4_es_pblock(es), ext4_es_status(es));
es                627 fs/ext4/extents_status.c 		if (es->es_lblk < ee_block ||
es                628 fs/ext4/extents_status.c 		    ext4_es_pblock(es) != ee_start + es->es_lblk - ee_block) {
es                633 fs/ext4/extents_status.c 				ee_status ? 'u' : 'w', es->es_lblk, es->es_len,
es                634 fs/ext4/extents_status.c 				ext4_es_pblock(es), es_status ? 'u' : 'w');
es                643 fs/ext4/extents_status.c 				ee_status ? 'u' : 'w', es->es_lblk, es->es_len,
es                644 fs/ext4/extents_status.c 				ext4_es_pblock(es), es_status ? 'u' : 'w');
es                651 fs/ext4/extents_status.c 		if (!ext4_es_is_delayed(es) && !ext4_es_is_hole(es)) {
es                656 fs/ext4/extents_status.c 				es->es_lblk, es->es_lblk, es->es_len,
es                657 fs/ext4/extents_status.c 				ext4_es_pblock(es), ext4_es_status(es));
es                666 fs/ext4/extents_status.c 					    struct extent_status *es)
es                678 fs/ext4/extents_status.c 	map.m_lblk = es->es_lblk;
es                679 fs/ext4/extents_status.c 	map.m_len = es->es_len;
es                683 fs/ext4/extents_status.c 		if (ext4_es_is_delayed(es) || ext4_es_is_hole(es)) {
es                691 fs/ext4/extents_status.c 				inode->i_ino, es->es_lblk, es->es_len,
es                692 fs/ext4/extents_status.c 				ext4_es_pblock(es), ext4_es_status(es));
es                694 fs/ext4/extents_status.c 		} else if (ext4_es_is_written(es)) {
es                695 fs/ext4/extents_status.c 			if (retval != es->es_len) {
es                698 fs/ext4/extents_status.c 					inode->i_ino, retval, es->es_len);
es                701 fs/ext4/extents_status.c 			if (map.m_pblk != ext4_es_pblock(es)) {
es                706 fs/ext4/extents_status.c 					ext4_es_pblock(es));
es                717 fs/ext4/extents_status.c 		if (ext4_es_is_written(es)) {
es                721 fs/ext4/extents_status.c 				inode->i_ino, es->es_lblk, es->es_len,
es                722 fs/ext4/extents_status.c 				ext4_es_pblock(es), ext4_es_status(es));
es                729 fs/ext4/extents_status.c 					       struct extent_status *es)
es                737 fs/ext4/extents_status.c 		ext4_es_insert_extent_ext_check(inode, es);
es                739 fs/ext4/extents_status.c 		ext4_es_insert_extent_ind_check(inode, es);
es                743 fs/ext4/extents_status.c 					       struct extent_status *es)
es                753 fs/ext4/extents_status.c 	struct extent_status *es;
es                757 fs/ext4/extents_status.c 		es = rb_entry(parent, struct extent_status, rb_node);
es                759 fs/ext4/extents_status.c 		if (newes->es_lblk < es->es_lblk) {
es                760 fs/ext4/extents_status.c 			if (ext4_es_can_be_merged(newes, es)) {
es                765 fs/ext4/extents_status.c 				es->es_lblk = newes->es_lblk;
es                766 fs/ext4/extents_status.c 				es->es_len += newes->es_len;
es                767 fs/ext4/extents_status.c 				if (ext4_es_is_written(es) ||
es                768 fs/ext4/extents_status.c 				    ext4_es_is_unwritten(es))
es                769 fs/ext4/extents_status.c 					ext4_es_store_pblock(es,
es                771 fs/ext4/extents_status.c 				es = ext4_es_try_to_merge_left(inode, es);
es                775 fs/ext4/extents_status.c 		} else if (newes->es_lblk > ext4_es_end(es)) {
es                776 fs/ext4/extents_status.c 			if (ext4_es_can_be_merged(es, newes)) {
es                777 fs/ext4/extents_status.c 				es->es_len += newes->es_len;
es                778 fs/ext4/extents_status.c 				es = ext4_es_try_to_merge_right(inode, es);
es                788 fs/ext4/extents_status.c 	es = ext4_es_alloc_extent(inode, newes->es_lblk, newes->es_len,
es                790 fs/ext4/extents_status.c 	if (!es)
es                792 fs/ext4/extents_status.c 	rb_link_node(&es->rb_node, parent, p);
es                793 fs/ext4/extents_status.c 	rb_insert_color(&es->rb_node, &tree->root);
es                796 fs/ext4/extents_status.c 	tree->cache_es = es;
es                872 fs/ext4/extents_status.c 	struct extent_status *es;
es                888 fs/ext4/extents_status.c 	es = __es_tree_search(&EXT4_I(inode)->i_es_tree.root, lblk);
es                889 fs/ext4/extents_status.c 	if (!es || es->es_lblk > end)
es                903 fs/ext4/extents_status.c 			  struct extent_status *es)
es                918 fs/ext4/extents_status.c 	es->es_lblk = es->es_len = es->es_pblk = 0;
es                946 fs/ext4/extents_status.c 		es->es_lblk = es1->es_lblk;
es                947 fs/ext4/extents_status.c 		es->es_len = es1->es_len;
es                948 fs/ext4/extents_status.c 		es->es_pblk = es1->es_pblk;
es                967 fs/ext4/extents_status.c 	trace_ext4_es_lookup_extent_exit(inode, es, found);
es                993 fs/ext4/extents_status.c 		      struct extent_status *es, struct rsvd_count *rc)
es               1008 fs/ext4/extents_status.c 		if (lblk > es->es_lblk) {
es               1009 fs/ext4/extents_status.c 			rc->left_es = es;
es               1011 fs/ext4/extents_status.c 			node = rb_prev(&es->rb_node);
es               1035 fs/ext4/extents_status.c 		       struct extent_status *es, struct rsvd_count *rc)
es               1040 fs/ext4/extents_status.c 	if (!ext4_es_is_delonly(es))
es               1052 fs/ext4/extents_status.c 	i = (lblk < es->es_lblk) ? es->es_lblk : lblk;
es               1054 fs/ext4/extents_status.c 	end = (end > ext4_es_end(es)) ? ext4_es_end(es) : end;
es               1167 fs/ext4/extents_status.c 	struct extent_status *es;
es               1187 fs/ext4/extents_status.c 		es = rc->left_es;
es               1188 fs/ext4/extents_status.c 		while (es && ext4_es_end(es) >=
es               1190 fs/ext4/extents_status.c 			if (ext4_es_is_delonly(es)) {
es               1195 fs/ext4/extents_status.c 			node = rb_prev(&es->rb_node);
es               1198 fs/ext4/extents_status.c 			es = rb_entry(node, struct extent_status, rb_node);
es               1202 fs/ext4/extents_status.c 				es = right_es;
es               1205 fs/ext4/extents_status.c 				es = node ? rb_entry(node, struct extent_status,
es               1208 fs/ext4/extents_status.c 			while (es && es->es_lblk <=
es               1210 fs/ext4/extents_status.c 				if (ext4_es_is_delonly(es)) {
es               1215 fs/ext4/extents_status.c 				node = rb_next(&es->rb_node);
es               1218 fs/ext4/extents_status.c 				es = rb_entry(node, struct extent_status,
es               1290 fs/ext4/extents_status.c 	struct extent_status *es;
es               1303 fs/ext4/extents_status.c 	es = __es_tree_search(&tree->root, lblk);
es               1304 fs/ext4/extents_status.c 	if (!es)
es               1306 fs/ext4/extents_status.c 	if (es->es_lblk > end)
es               1312 fs/ext4/extents_status.c 		init_rsvd(inode, lblk, es, &rc);
es               1314 fs/ext4/extents_status.c 	orig_es.es_lblk = es->es_lblk;
es               1315 fs/ext4/extents_status.c 	orig_es.es_len = es->es_len;
es               1316 fs/ext4/extents_status.c 	orig_es.es_pblk = es->es_pblk;
es               1318 fs/ext4/extents_status.c 	len1 = lblk > es->es_lblk ? lblk - es->es_lblk : 0;
es               1319 fs/ext4/extents_status.c 	len2 = ext4_es_end(es) > end ? ext4_es_end(es) - end : 0;
es               1321 fs/ext4/extents_status.c 		es->es_len = len1;
es               1337 fs/ext4/extents_status.c 				es->es_lblk = orig_es.es_lblk;
es               1338 fs/ext4/extents_status.c 				es->es_len = orig_es.es_len;
es               1346 fs/ext4/extents_status.c 			es->es_lblk = end + 1;
es               1347 fs/ext4/extents_status.c 			es->es_len = len2;
es               1348 fs/ext4/extents_status.c 			if (ext4_es_is_written(es) ||
es               1349 fs/ext4/extents_status.c 			    ext4_es_is_unwritten(es)) {
es               1351 fs/ext4/extents_status.c 				ext4_es_store_pblock(es, block);
es               1364 fs/ext4/extents_status.c 		node = rb_next(&es->rb_node);
es               1366 fs/ext4/extents_status.c 			es = rb_entry(node, struct extent_status, rb_node);
es               1368 fs/ext4/extents_status.c 			es = NULL;
es               1371 fs/ext4/extents_status.c 	while (es && ext4_es_end(es) <= end) {
es               1373 fs/ext4/extents_status.c 			count_rsvd(inode, es->es_lblk, es->es_len, es, &rc);
es               1374 fs/ext4/extents_status.c 		node = rb_next(&es->rb_node);
es               1375 fs/ext4/extents_status.c 		rb_erase(&es->rb_node, &tree->root);
es               1376 fs/ext4/extents_status.c 		ext4_es_free_extent(inode, es);
es               1378 fs/ext4/extents_status.c 			es = NULL;
es               1381 fs/ext4/extents_status.c 		es = rb_entry(node, struct extent_status, rb_node);
es               1384 fs/ext4/extents_status.c 	if (es && es->es_lblk < end + 1) {
es               1385 fs/ext4/extents_status.c 		ext4_lblk_t orig_len = es->es_len;
es               1387 fs/ext4/extents_status.c 		len1 = ext4_es_end(es) - end;
es               1389 fs/ext4/extents_status.c 			count_rsvd(inode, es->es_lblk, orig_len - len1,
es               1390 fs/ext4/extents_status.c 				   es, &rc);
es               1391 fs/ext4/extents_status.c 		es->es_lblk = end + 1;
es               1392 fs/ext4/extents_status.c 		es->es_len = len1;
es               1393 fs/ext4/extents_status.c 		if (ext4_es_is_written(es) || ext4_es_is_unwritten(es)) {
es               1394 fs/ext4/extents_status.c 			block = es->es_pblk + orig_len - len1;
es               1395 fs/ext4/extents_status.c 			ext4_es_store_pblock(es, block);
es               1400 fs/ext4/extents_status.c 		*reserved = get_rsvd(inode, end, es, &rc);
es               1676 fs/ext4/extents_status.c 	struct extent_status *es;
es               1679 fs/ext4/extents_status.c 	es = __es_tree_search(&tree->root, ei->i_es_shrink_lblk);
es               1680 fs/ext4/extents_status.c 	if (!es)
es               1684 fs/ext4/extents_status.c 		if (es->es_lblk > end) {
es               1690 fs/ext4/extents_status.c 		node = rb_next(&es->rb_node);
es               1695 fs/ext4/extents_status.c 		if (ext4_es_is_delayed(es))
es               1697 fs/ext4/extents_status.c 		if (ext4_es_is_referenced(es)) {
es               1698 fs/ext4/extents_status.c 			ext4_es_clear_referenced(es);
es               1702 fs/ext4/extents_status.c 		rb_erase(&es->rb_node, &tree->root);
es               1703 fs/ext4/extents_status.c 		ext4_es_free_extent(inode, es);
es               1708 fs/ext4/extents_status.c 		es = rb_entry(node, struct extent_status, rb_node);
es               1710 fs/ext4/extents_status.c 	ei->i_es_shrink_lblk = es->es_lblk;
es               1748 fs/ext4/extents_status.c 	struct extent_status *es;
es               1757 fs/ext4/extents_status.c 		es = rb_entry(node, struct extent_status, rb_node);
es               1759 fs/ext4/extents_status.c 		if (!ext4_es_is_delayed(es)) {
es               1760 fs/ext4/extents_status.c 			rb_erase(&es->rb_node, &tree->root);
es               1761 fs/ext4/extents_status.c 			ext4_es_free_extent(inode, es);
es               2024 fs/ext4/extents_status.c 	struct extent_status *es;
es               2034 fs/ext4/extents_status.c 	es = __es_tree_search(&tree->root, start);
es               2036 fs/ext4/extents_status.c 	while (es && (es->es_lblk <= end)) {
es               2037 fs/ext4/extents_status.c 		if (ext4_es_is_delonly(es)) {
es               2038 fs/ext4/extents_status.c 			if (es->es_lblk <= start)
es               2041 fs/ext4/extents_status.c 				first_lclu = EXT4_B2C(sbi, es->es_lblk);
es               2043 fs/ext4/extents_status.c 			if (ext4_es_end(es) >= end)
es               2046 fs/ext4/extents_status.c 				last_lclu = EXT4_B2C(sbi, ext4_es_end(es));
es               2054 fs/ext4/extents_status.c 		node = rb_next(&es->rb_node);
es               2057 fs/ext4/extents_status.c 		es = rb_entry(node, struct extent_status, rb_node);
es                139 fs/ext4/extents_status.h 				      int (*match_fn)(struct extent_status *es),
es                141 fs/ext4/extents_status.h 				      struct extent_status *es);
es                144 fs/ext4/extents_status.h 				 struct extent_status *es);
es                146 fs/ext4/extents_status.h 			       int (*matching_fn)(struct extent_status *es),
es                149 fs/ext4/extents_status.h 			     int (*matching_fn)(struct extent_status *es),
es                152 fs/ext4/extents_status.h static inline unsigned int ext4_es_status(struct extent_status *es)
es                154 fs/ext4/extents_status.h 	return es->es_pblk >> ES_SHIFT;
es                157 fs/ext4/extents_status.h static inline unsigned int ext4_es_type(struct extent_status *es)
es                159 fs/ext4/extents_status.h 	return (es->es_pblk & ES_TYPE_MASK) >> ES_SHIFT;
es                162 fs/ext4/extents_status.h static inline int ext4_es_is_written(struct extent_status *es)
es                164 fs/ext4/extents_status.h 	return (ext4_es_type(es) & EXTENT_STATUS_WRITTEN) != 0;
es                167 fs/ext4/extents_status.h static inline int ext4_es_is_unwritten(struct extent_status *es)
es                169 fs/ext4/extents_status.h 	return (ext4_es_type(es) & EXTENT_STATUS_UNWRITTEN) != 0;
es                172 fs/ext4/extents_status.h static inline int ext4_es_is_delayed(struct extent_status *es)
es                174 fs/ext4/extents_status.h 	return (ext4_es_type(es) & EXTENT_STATUS_DELAYED) != 0;
es                177 fs/ext4/extents_status.h static inline int ext4_es_is_hole(struct extent_status *es)
es                179 fs/ext4/extents_status.h 	return (ext4_es_type(es) & EXTENT_STATUS_HOLE) != 0;
es                182 fs/ext4/extents_status.h static inline int ext4_es_is_mapped(struct extent_status *es)
es                184 fs/ext4/extents_status.h 	return (ext4_es_is_written(es) || ext4_es_is_unwritten(es));
es                187 fs/ext4/extents_status.h static inline int ext4_es_is_delonly(struct extent_status *es)
es                189 fs/ext4/extents_status.h 	return (ext4_es_is_delayed(es) && !ext4_es_is_unwritten(es));
es                192 fs/ext4/extents_status.h static inline void ext4_es_set_referenced(struct extent_status *es)
es                194 fs/ext4/extents_status.h 	es->es_pblk |= ((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT;
es                197 fs/ext4/extents_status.h static inline void ext4_es_clear_referenced(struct extent_status *es)
es                199 fs/ext4/extents_status.h 	es->es_pblk &= ~(((ext4_fsblk_t)EXTENT_STATUS_REFERENCED) << ES_SHIFT);
es                202 fs/ext4/extents_status.h static inline int ext4_es_is_referenced(struct extent_status *es)
es                204 fs/ext4/extents_status.h 	return (ext4_es_status(es) & EXTENT_STATUS_REFERENCED) != 0;
es                207 fs/ext4/extents_status.h static inline ext4_fsblk_t ext4_es_pblock(struct extent_status *es)
es                209 fs/ext4/extents_status.h 	return es->es_pblk & ~ES_MASK;
es                212 fs/ext4/extents_status.h static inline void ext4_es_store_pblock(struct extent_status *es,
es                217 fs/ext4/extents_status.h 	block = (pb & ~ES_MASK) | (es->es_pblk & ES_MASK);
es                218 fs/ext4/extents_status.h 	es->es_pblk = block;
es                221 fs/ext4/extents_status.h static inline void ext4_es_store_status(struct extent_status *es,
es                224 fs/ext4/extents_status.h 	es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
es                225 fs/ext4/extents_status.h 		      (es->es_pblk & ~ES_MASK);
es                228 fs/ext4/extents_status.h static inline void ext4_es_store_pblock_status(struct extent_status *es,
es                232 fs/ext4/extents_status.h 	es->es_pblk = (((ext4_fsblk_t)status << ES_SHIFT) & ES_MASK) |
es                241 fs/ext4/ialloc.c 	struct ext4_super_block *es;
es                276 fs/ext4/ialloc.c 	es = sbi->s_es;
es                277 fs/ext4/ialloc.c 	if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
es               1279 fs/ext4/ialloc.c 	struct ext4_super_block *es;
es               1283 fs/ext4/ialloc.c 	es = EXT4_SB(sb)->s_es;
es               1308 fs/ext4/ialloc.c 	       le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
es                514 fs/ext4/inode.c 	struct extent_status es;
es                539 fs/ext4/inode.c 	if (ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
es                540 fs/ext4/inode.c 		if (ext4_es_is_written(&es) || ext4_es_is_unwritten(&es)) {
es                541 fs/ext4/inode.c 			map->m_pblk = ext4_es_pblock(&es) +
es                542 fs/ext4/inode.c 					map->m_lblk - es.es_lblk;
es                543 fs/ext4/inode.c 			map->m_flags |= ext4_es_is_written(&es) ?
es                545 fs/ext4/inode.c 			retval = es.es_len - (map->m_lblk - es.es_lblk);
es                549 fs/ext4/inode.c 		} else if (ext4_es_is_delayed(&es) || ext4_es_is_hole(&es)) {
es                551 fs/ext4/inode.c 			retval = es.es_len - (map->m_lblk - es.es_lblk);
es                707 fs/ext4/inode.c 		    ext4_es_lookup_extent(inode, map->m_lblk, NULL, &es)) {
es                708 fs/ext4/inode.c 			if (ext4_es_is_written(&es))
es               1829 fs/ext4/inode.c 	struct extent_status es;
es               1847 fs/ext4/inode.c 	if (ext4_es_lookup_extent(inode, iblock, NULL, &es)) {
es               1848 fs/ext4/inode.c 		if (ext4_es_is_hole(&es)) {
es               1858 fs/ext4/inode.c 		if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) {
es               1865 fs/ext4/inode.c 		map->m_pblk = ext4_es_pblock(&es) + iblock - es.es_lblk;
es               1866 fs/ext4/inode.c 		retval = es.es_len - (iblock - es.es_lblk);
es               1870 fs/ext4/inode.c 		if (ext4_es_is_written(&es))
es               1872 fs/ext4/inode.c 		else if (ext4_es_is_unwritten(&es))
es               3458 fs/ext4/inode.c 			struct extent_status es;
es               3461 fs/ext4/inode.c 						  map.m_lblk, end, &es);
es               3463 fs/ext4/inode.c 			if (!es.es_len || es.es_lblk > end) {
es               3465 fs/ext4/inode.c 			} else if (es.es_lblk > map.m_lblk) {
es               3467 fs/ext4/inode.c 				map.m_len = es.es_lblk - map.m_lblk;
es               3471 fs/ext4/inode.c 				if (es.es_lblk < map.m_lblk)
es               3472 fs/ext4/inode.c 					offs = map.m_lblk - es.es_lblk;
es               3473 fs/ext4/inode.c 				map.m_lblk = es.es_lblk + offs;
es               3474 fs/ext4/inode.c 				map.m_len = es.es_len - offs;
es               4241 fs/ext4/mballoc.c 	struct ext4_super_block *es = sbi->s_es;
es               4256 fs/ext4/mballoc.c 	if (goal < le32_to_cpu(es->s_first_data_block) ||
es               4257 fs/ext4/mballoc.c 			goal >= ext4_blocks_count(es))
es               4258 fs/ext4/mballoc.c 		goal = le32_to_cpu(es->s_first_data_block);
es                616 fs/ext4/migrate.c 	struct ext4_super_block		*es = sbi->s_es;
es                655 fs/ext4/migrate.c 	if (ext4_blocks_count(es) > EXT4_MAX_BLOCK_FILE_PHYS ||
es                136 fs/ext4/mmp.c  	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                141 fs/ext4/mmp.c  	int mmp_update_interval = le16_to_cpu(es->s_mmp_update_interval);
es                147 fs/ext4/mmp.c  	mmp_block = le64_to_cpu(es->s_mmp_block);
es                182 fs/ext4/mmp.c  		if (!(le32_to_cpu(es->s_feature_incompat) &
es                276 fs/ext4/mmp.c  	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                281 fs/ext4/mmp.c  	unsigned int mmp_check_interval = le16_to_cpu(es->s_mmp_update_interval);
es                285 fs/ext4/mmp.c  	if (mmp_block < le32_to_cpu(es->s_first_data_block) ||
es                286 fs/ext4/mmp.c  	    mmp_block >= ext4_blocks_count(es)) {
es                119 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es                120 fs/ext4/resize.c 	ext4_fsblk_t start = ext4_blocks_count(es);
es                529 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es                541 fs/ext4/resize.c 	reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
es                810 fs/ext4/resize.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                919 fs/ext4/resize.c 	le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
es               1224 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1232 fs/ext4/resize.c 			le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
es               1383 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1402 fs/ext4/resize.c 	reserved_blocks = ext4_r_blocks_count(es) * 100;
es               1403 fs/ext4/resize.c 	reserved_blocks = div64_u64(reserved_blocks, ext4_blocks_count(es));
es               1407 fs/ext4/resize.c 	ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count);
es               1408 fs/ext4/resize.c 	ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + free_blocks);
es               1409 fs/ext4/resize.c 	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) *
es               1411 fs/ext4/resize.c 	le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) *
es               1414 fs/ext4/resize.c 	ext4_debug("free blocks count %llu", ext4_free_blocks_count(es));
es               1442 fs/ext4/resize.c 	ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
es               1485 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1495 fs/ext4/resize.c 	reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks);
es               1496 fs/ext4/resize.c 	o_blocks_count = ext4_blocks_count(es);
es               1552 fs/ext4/resize.c 		update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
es               1576 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1588 fs/ext4/resize.c 	o_blocks_count = ext4_blocks_count(es);
es               1650 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1652 fs/ext4/resize.c 		le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
es               1665 fs/ext4/resize.c 	if (ext4_blocks_count(es) + input->blocks_count <
es               1666 fs/ext4/resize.c 	    ext4_blocks_count(es)) {
es               1671 fs/ext4/resize.c 	if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
es               1672 fs/ext4/resize.c 	    le32_to_cpu(es->s_inodes_count)) {
es               1679 fs/ext4/resize.c 		    !le16_to_cpu(es->s_reserved_gdt_blocks)) {
es               1719 fs/ext4/resize.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es               1740 fs/ext4/resize.c 	ext4_blocks_count_set(es, o_blocks_count + add);
es               1741 fs/ext4/resize.c 	ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + add);
es               1759 fs/ext4/resize.c 			       "blocks\n", ext4_blocks_count(es));
es               1761 fs/ext4/resize.c 			       (char *)es, sizeof(struct ext4_super_block), 0);
es               1776 fs/ext4/resize.c int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
es               1786 fs/ext4/resize.c 	o_blocks_count = ext4_blocks_count(es);
es               1857 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1865 fs/ext4/resize.c 		if (es->s_reserved_gdt_blocks) {
es               1942 fs/ext4/resize.c 	struct ext4_super_block *es = sbi->s_es;
es               1965 fs/ext4/resize.c 	o_blocks_count = ext4_blocks_count(es);
es               1999 fs/ext4/resize.c 		    le16_to_cpu(es->s_reserved_gdt_blocks)) {
es               2002 fs/ext4/resize.c 				le16_to_cpu(es->s_reserved_gdt_blocks);
es               2006 fs/ext4/resize.c 				le32_to_cpu(es->s_first_data_block);
es               2065 fs/ext4/resize.c 	if (ext4_blocks_count(es) == n_blocks_count)
es               2091 fs/ext4/resize.c 					 ext4_blocks_count(es));
es               2122 fs/ext4/resize.c 		 ext4_blocks_count(es));
es                 70 fs/ext4/super.c 					struct ext4_super_block *es);
es                 72 fs/ext4/super.c 				   struct ext4_super_block *es);
es                168 fs/ext4/super.c 				 struct ext4_super_block *es)
es                173 fs/ext4/super.c 	return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
es                177 fs/ext4/super.c 				   struct ext4_super_block *es)
es                183 fs/ext4/super.c 	csum = ext4_chksum(sbi, ~0, (char *)es, offset);
es                189 fs/ext4/super.c 				       struct ext4_super_block *es)
es                194 fs/ext4/super.c 	return es->s_checksum == ext4_superblock_csum(sb, es);
es                199 fs/ext4/super.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                204 fs/ext4/super.c 	es->s_checksum = ext4_superblock_csum(sb, es);
es                353 fs/ext4/super.c #define ext4_update_tstamp(es, tstamp) \
es                354 fs/ext4/super.c 	__ext4_update_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
es                355 fs/ext4/super.c #define ext4_get_tstamp(es, tstamp) \
es                356 fs/ext4/super.c 	__ext4_get_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
es                361 fs/ext4/super.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                366 fs/ext4/super.c 	es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
es                367 fs/ext4/super.c 	ext4_update_tstamp(es, s_last_error_time);
es                368 fs/ext4/super.c 	strncpy(es->s_last_error_func, func, sizeof(es->s_last_error_func));
es                369 fs/ext4/super.c 	es->s_last_error_line = cpu_to_le32(line);
es                370 fs/ext4/super.c 	if (!es->s_first_error_time) {
es                371 fs/ext4/super.c 		es->s_first_error_time = es->s_last_error_time;
es                372 fs/ext4/super.c 		es->s_first_error_time_hi = es->s_last_error_time_hi;
es                373 fs/ext4/super.c 		strncpy(es->s_first_error_func, func,
es                374 fs/ext4/super.c 			sizeof(es->s_first_error_func));
es                375 fs/ext4/super.c 		es->s_first_error_line = cpu_to_le32(line);
es                376 fs/ext4/super.c 		es->s_first_error_ino = es->s_last_error_ino;
es                377 fs/ext4/super.c 		es->s_first_error_block = es->s_last_error_block;
es                383 fs/ext4/super.c 	if (!es->s_error_count)
es                385 fs/ext4/super.c 	le32_add_cpu(&es->s_error_count, 1);
es                526 fs/ext4/super.c 	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
es                532 fs/ext4/super.c 	es->s_last_error_ino = cpu_to_le32(inode->i_ino);
es                533 fs/ext4/super.c 	es->s_last_error_block = cpu_to_le64(block);
es                560 fs/ext4/super.c 	struct ext4_super_block *es;
es                568 fs/ext4/super.c 	es = EXT4_SB(inode->i_sb)->s_es;
es                569 fs/ext4/super.c 	es->s_last_error_ino = cpu_to_le32(inode->i_ino);
es                775 fs/ext4/super.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                781 fs/ext4/super.c 	es->s_last_error_ino = cpu_to_le32(ino);
es                782 fs/ext4/super.c 	es->s_last_error_block = cpu_to_le64(block);
es                858 fs/ext4/super.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es                860 fs/ext4/super.c 	if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
es                868 fs/ext4/super.c 	es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
es                869 fs/ext4/super.c 	es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
es                870 fs/ext4/super.c 	es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
es                973 fs/ext4/super.c 	struct ext4_super_block *es = sbi->s_es;
es               1001 fs/ext4/super.c 		es->s_state = cpu_to_le16(sbi->s_mount_state);
es               1781 fs/ext4/super.c static int ext4_sb_read_encoding(const struct ext4_super_block *es,
es               1785 fs/ext4/super.c 	__u16 magic = le16_to_cpu(es->s_encoding);
es               1796 fs/ext4/super.c 	*flags = le16_to_cpu(es->s_encoding_flags);
es               2193 fs/ext4/super.c 	struct ext4_super_block *es = sbi->s_es;
es               2219 fs/ext4/super.c 	    le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID)
es               2223 fs/ext4/super.c 	    le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID)
es               2226 fs/ext4/super.c 	def_errors = nodefs ? -1 : le16_to_cpu(es->s_errors);
es               2287 fs/ext4/super.c static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
es               2293 fs/ext4/super.c 	if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
es               2307 fs/ext4/super.c 	else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
es               2308 fs/ext4/super.c 		 le16_to_cpu(es->s_mnt_count) >=
es               2309 fs/ext4/super.c 		 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
es               2313 fs/ext4/super.c 	else if (le32_to_cpu(es->s_checkinterval) &&
es               2314 fs/ext4/super.c 		 (ext4_get_tstamp(es, s_lastcheck) +
es               2315 fs/ext4/super.c 		  le32_to_cpu(es->s_checkinterval) <= ktime_get_real_seconds()))
es               2320 fs/ext4/super.c 		es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
es               2321 fs/ext4/super.c 	if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
es               2322 fs/ext4/super.c 		es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
es               2323 fs/ext4/super.c 	le16_add_cpu(&es->s_mnt_count, 1);
es               2324 fs/ext4/super.c 	ext4_update_tstamp(es, s_mtime);
es               2626 fs/ext4/super.c 				struct ext4_super_block *es)
es               2634 fs/ext4/super.c 	if (!es->s_last_orphan) {
es               2654 fs/ext4/super.c 		if (es->s_last_orphan && !(s_flags & SB_RDONLY)) {
es               2657 fs/ext4/super.c 			es->s_last_orphan = 0;
es               2700 fs/ext4/super.c 	while (es->s_last_orphan) {
es               2709 fs/ext4/super.c 			es->s_last_orphan = 0;
es               2713 fs/ext4/super.c 		inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
es               2715 fs/ext4/super.c 			es->s_last_orphan = 0;
es               3009 fs/ext4/super.c 	struct ext4_super_block *es = sbi->s_es;
es               3011 fs/ext4/super.c 	if (es->s_error_count)
es               3014 fs/ext4/super.c 			 le32_to_cpu(es->s_error_count));
es               3015 fs/ext4/super.c 	if (es->s_first_error_time) {
es               3018 fs/ext4/super.c 		       ext4_get_tstamp(es, s_first_error_time),
es               3019 fs/ext4/super.c 		       (int) sizeof(es->s_first_error_func),
es               3020 fs/ext4/super.c 		       es->s_first_error_func,
es               3021 fs/ext4/super.c 		       le32_to_cpu(es->s_first_error_line));
es               3022 fs/ext4/super.c 		if (es->s_first_error_ino)
es               3024 fs/ext4/super.c 			       le32_to_cpu(es->s_first_error_ino));
es               3025 fs/ext4/super.c 		if (es->s_first_error_block)
es               3027 fs/ext4/super.c 			       le64_to_cpu(es->s_first_error_block));
es               3030 fs/ext4/super.c 	if (es->s_last_error_time) {
es               3033 fs/ext4/super.c 		       ext4_get_tstamp(es, s_last_error_time),
es               3034 fs/ext4/super.c 		       (int) sizeof(es->s_last_error_func),
es               3035 fs/ext4/super.c 		       es->s_last_error_func,
es               3036 fs/ext4/super.c 		       le32_to_cpu(es->s_last_error_line));
es               3037 fs/ext4/super.c 		if (es->s_last_error_ino)
es               3039 fs/ext4/super.c 			       le32_to_cpu(es->s_last_error_ino));
es               3040 fs/ext4/super.c 		if (es->s_last_error_block)
es               3042 fs/ext4/super.c 			       le64_to_cpu(es->s_last_error_block));
es               3525 fs/ext4/super.c 	struct ext4_super_block *es = sbi->s_es;
es               3527 fs/ext4/super.c 	unsigned int j_blocks, j_inum = le32_to_cpu(es->s_journal_inum);
es               3544 fs/ext4/super.c 	overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
es               3617 fs/ext4/super.c 	struct ext4_super_block *es = NULL;
es               3685 fs/ext4/super.c 	es = (struct ext4_super_block *) (bh->b_data + offset);
es               3686 fs/ext4/super.c 	sbi->s_es = es;
es               3687 fs/ext4/super.c 	sb->s_magic = le16_to_cpu(es->s_magic);
es               3690 fs/ext4/super.c 	sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
es               3699 fs/ext4/super.c 	if (!ext4_verify_csum_type(sb, es)) {
es               3716 fs/ext4/super.c 	if (!ext4_superblock_csum_verify(sb, es)) {
es               3726 fs/ext4/super.c 		sbi->s_csum_seed = le32_to_cpu(es->s_checksum_seed);
es               3728 fs/ext4/super.c 		sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid,
es               3729 fs/ext4/super.c 					       sizeof(es->s_uuid));
es               3732 fs/ext4/super.c 	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
es               3767 fs/ext4/super.c 	sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
es               3768 fs/ext4/super.c 	sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
es               3790 fs/ext4/super.c 	blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
es               3795 fs/ext4/super.c 			 blocksize, le32_to_cpu(es->s_log_block_size));
es               3799 fs/ext4/super.c 	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
es               3803 fs/ext4/super.c 		sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
es               3804 fs/ext4/super.c 		sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
es               3842 fs/ext4/super.c 			v = le16_to_cpu(es->s_want_extra_isize);
es               3851 fs/ext4/super.c 			v = le16_to_cpu(es->s_min_extra_isize);
es               3893 fs/ext4/super.c 		if (ext4_sb_read_encoding(es, &encoding_info,
es               3951 fs/ext4/super.c 	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
es               3959 fs/ext4/super.c 	if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
es               4020 fs/ext4/super.c 	if (le32_to_cpu(es->s_log_block_size) >
es               4024 fs/ext4/super.c 			 le32_to_cpu(es->s_log_block_size));
es               4027 fs/ext4/super.c 	if (le32_to_cpu(es->s_log_cluster_size) >
es               4031 fs/ext4/super.c 			 le32_to_cpu(es->s_log_cluster_size));
es               4055 fs/ext4/super.c 	if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
es               4057 fs/ext4/super.c 			 es->s_encryption_level);
es               4078 fs/ext4/super.c 		es = (struct ext4_super_block *)(bh->b_data + offset);
es               4079 fs/ext4/super.c 		sbi->s_es = es;
es               4080 fs/ext4/super.c 		if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
es               4092 fs/ext4/super.c 	sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
es               4105 fs/ext4/super.c 	sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
es               4106 fs/ext4/super.c 	sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
es               4121 fs/ext4/super.c 	sbi->s_mount_state = le16_to_cpu(es->s_state);
es               4126 fs/ext4/super.c 		sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
es               4127 fs/ext4/super.c 	sbi->s_def_hash_version = es->s_def_hash_version;
es               4129 fs/ext4/super.c 		i = le32_to_cpu(es->s_flags);
es               4135 fs/ext4/super.c 				es->s_flags |=
es               4140 fs/ext4/super.c 				es->s_flags |=
es               4147 fs/ext4/super.c 	clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
es               4156 fs/ext4/super.c 		sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) -
es               4157 fs/ext4/super.c 			le32_to_cpu(es->s_log_block_size);
es               4159 fs/ext4/super.c 			le32_to_cpu(es->s_clusters_per_group);
es               4201 fs/ext4/super.c 					ext4_blocks_count(es));
es               4213 fs/ext4/super.c 	if (blocks_count && ext4_blocks_count(es) > blocks_count) {
es               4216 fs/ext4/super.c 		       ext4_blocks_count(es), blocks_count);
es               4224 fs/ext4/super.c 	if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
es               4227 fs/ext4/super.c 			 le32_to_cpu(es->s_first_data_block),
es               4228 fs/ext4/super.c 			 ext4_blocks_count(es));
es               4231 fs/ext4/super.c 	if ((es->s_first_data_block == 0) && (es->s_log_block_size == 0) &&
es               4238 fs/ext4/super.c 	blocks_count = (ext4_blocks_count(es) -
es               4239 fs/ext4/super.c 			le32_to_cpu(es->s_first_data_block) +
es               4246 fs/ext4/super.c 		       ext4_blocks_count(es),
es               4247 fs/ext4/super.c 		       le32_to_cpu(es->s_first_data_block),
es               4255 fs/ext4/super.c 	    le32_to_cpu(es->s_inodes_count)) {
es               4257 fs/ext4/super.c 			 le32_to_cpu(es->s_inodes_count),
es               4265 fs/ext4/super.c 		if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
es               4269 fs/ext4/super.c 				 le32_to_cpu(es->s_first_meta_bg), db_count);
es               4342 fs/ext4/super.c 	memcpy(&sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
es               4349 fs/ext4/super.c 	needs_recovery = (es->s_last_orphan != 0 ||
es               4353 fs/ext4/super.c 		if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
es               4361 fs/ext4/super.c 		err = ext4_load_journal(sb, es, journal_devnum);
es               4496 fs/ext4/super.c 	if (es->s_overhead_clusters)
es               4497 fs/ext4/super.c 		sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
es               4546 fs/ext4/super.c 	ret = ext4_setup_super(sb, es, sb_rdonly(sb));
es               4623 fs/ext4/super.c 	ext4_orphan_cleanup(sb, es);
es               4627 fs/ext4/super.c 		ext4_mark_recovery_complete(sb, es);
es               4654 fs/ext4/super.c 	if (es->s_error_count)
es               4839 fs/ext4/super.c 	struct ext4_super_block *es;
es               4865 fs/ext4/super.c 	es = (struct ext4_super_block *) (bh->b_data + offset);
es               4866 fs/ext4/super.c 	if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
es               4867 fs/ext4/super.c 	    !(le32_to_cpu(es->s_feature_incompat) &
es               4875 fs/ext4/super.c 	if ((le32_to_cpu(es->s_feature_ro_compat) &
es               4877 fs/ext4/super.c 	    es->s_checksum != ext4_superblock_csum(sb, es)) {
es               4884 fs/ext4/super.c 	if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
es               4890 fs/ext4/super.c 	len = ext4_blocks_count(es);
es               4925 fs/ext4/super.c 			     struct ext4_super_block *es,
es               4929 fs/ext4/super.c 	unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
es               4937 fs/ext4/super.c 	    journal_devnum != le32_to_cpu(es->s_journal_dev)) {
es               4942 fs/ext4/super.c 		journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
es               4988 fs/ext4/super.c 			memcpy(save, ((char *) es) +
es               4992 fs/ext4/super.c 			memcpy(((char *) es) + EXT4_S_ERR_START,
es               5004 fs/ext4/super.c 	ext4_clear_journal_err(sb, es);
es               5007 fs/ext4/super.c 	    journal_devnum != le32_to_cpu(es->s_journal_dev)) {
es               5008 fs/ext4/super.c 		es->s_journal_dev = cpu_to_le32(journal_devnum);
es               5019 fs/ext4/super.c 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
es               5044 fs/ext4/super.c 		ext4_update_tstamp(es, s_wtime);
es               5046 fs/ext4/super.c 		es->s_kbytes_written =
es               5052 fs/ext4/super.c 		es->s_kbytes_written =
es               5055 fs/ext4/super.c 		ext4_free_blocks_count_set(es,
es               5059 fs/ext4/super.c 		es->s_free_inodes_count =
es               5101 fs/ext4/super.c 					struct ext4_super_block *es)
es               5128 fs/ext4/super.c 				   struct ext4_super_block *es)
es               5153 fs/ext4/super.c 		es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
es               5299 fs/ext4/super.c 	struct ext4_super_block *es;
es               5402 fs/ext4/super.c 	es = sbi->s_es;
es               5437 fs/ext4/super.c 			if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
es               5439 fs/ext4/super.c 				es->s_state = cpu_to_le16(sbi->s_mount_state);
es               5442 fs/ext4/super.c 				ext4_mark_recovery_complete(sb, es);
es               5475 fs/ext4/super.c 			if (es->s_last_orphan) {
es               5491 fs/ext4/super.c 				ext4_clear_journal_err(sb, es);
es               5492 fs/ext4/super.c 			sbi->s_mount_state = le16_to_cpu(es->s_state);
es               5494 fs/ext4/super.c 			err = ext4_setup_super(sb, es, 0);
es               5501 fs/ext4/super.c 						le64_to_cpu(es->s_mmp_block))) {
es               5629 fs/ext4/super.c 	struct ext4_super_block *es = sbi->s_es;
es               5640 fs/ext4/super.c 	buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, overhead);
es               5646 fs/ext4/super.c 			(ext4_r_blocks_count(es) + resv_blocks);
es               5647 fs/ext4/super.c 	if (buf->f_bfree < (ext4_r_blocks_count(es) + resv_blocks))
es               5649 fs/ext4/super.c 	buf->f_files = le32_to_cpu(es->s_inodes_count);
es               5652 fs/ext4/super.c 	fsid = le64_to_cpup((void *)es->s_uuid) ^
es               5653 fs/ext4/super.c 	       le64_to_cpup((void *)es->s_uuid + sizeof(u64));
es                287 fs/ext4/sysfs.c #define print_tstamp(buf, es, tstamp) \
es                288 fs/ext4/sysfs.c 	__print_tstamp(buf, (es)->tstamp, (es)->tstamp ## _hi)
es                861 fs/gfs2/xattr.c 				 struct gfs2_ea_header *ea, struct ea_set *es)
es                863 fs/gfs2/xattr.c 	struct gfs2_ea_request *er = es->es_er;
es                872 fs/gfs2/xattr.c 	if (es->ea_split)
es                877 fs/gfs2/xattr.c 	if (es->es_el)
es                878 fs/gfs2/xattr.c 		ea_set_remove_stuffed(ip, es->es_el);
es                890 fs/gfs2/xattr.c 	struct ea_set *es = private;
es                891 fs/gfs2/xattr.c 	struct gfs2_ea_header *ea = es->es_ea;
es                894 fs/gfs2/xattr.c 	gfs2_trans_add_meta(ip->i_gl, es->es_bh);
es                896 fs/gfs2/xattr.c 	if (es->ea_split)
es                903 fs/gfs2/xattr.c 	if (es->es_el)
es                904 fs/gfs2/xattr.c 		ea_set_remove_stuffed(ip, es->es_el);
es                913 fs/gfs2/xattr.c 	struct ea_set *es = private;
es                918 fs/gfs2/xattr.c 	stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len,
es                919 fs/gfs2/xattr.c 			       es->es_er->er_data_len, &size);
es                929 fs/gfs2/xattr.c 		es->ea_split = 0;
es                931 fs/gfs2/xattr.c 		es->ea_split = 1;
es                936 fs/gfs2/xattr.c 		error = ea_set_simple_noalloc(ip, bh, ea, es);
es                942 fs/gfs2/xattr.c 		es->es_bh = bh;
es                943 fs/gfs2/xattr.c 		es->es_ea = ea;
es                944 fs/gfs2/xattr.c 		blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
es                947 fs/gfs2/xattr.c 		error = ea_alloc_skeleton(ip, es->es_er, blks,
es                948 fs/gfs2/xattr.c 					  ea_set_simple_alloc, es);
es               1034 fs/gfs2/xattr.c 	struct ea_set es;
es               1044 fs/gfs2/xattr.c 	memset(&es, 0, sizeof(struct ea_set));
es               1045 fs/gfs2/xattr.c 	es.es_er = &er;
es               1046 fs/gfs2/xattr.c 	es.es_el = el;
es               1048 fs/gfs2/xattr.c 	error = ea_foreach(ip, ea_set_simple, &es);
es                 67 fs/nfsd/blocklayout.c 			bex->es = PNFS_BLOCK_READ_DATA;
es                 69 fs/nfsd/blocklayout.c 			bex->es = PNFS_BLOCK_READWRITE_DATA;
es                 82 fs/nfsd/blocklayout.c 			bex->es = PNFS_BLOCK_INVALID_DATA;
es                 89 fs/nfsd/blocklayout.c 			bex->es = PNFS_BLOCK_NONE_DATA;
es                108 fs/nfsd/blocklayout.c 	dprintk("GET: 0x%llx:0x%llx %d\n", bex->foff, bex->len, bex->es);
es                 36 fs/nfsd/blocklayoutxdr.c 	*p++ = cpu_to_be32(b->es);
es                159 fs/nfsd/blocklayoutxdr.c 		bex.es = be32_to_cpup(p++);
es                160 fs/nfsd/blocklayoutxdr.c 		if (bex.es != PNFS_BLOCK_READWRITE_DATA) {
es                162 fs/nfsd/blocklayoutxdr.c 				__func__, bex.es);
es                 16 fs/nfsd/blocklayoutxdr.h 	enum pnfs_block_extent_state	es;
es                856 fs/ntfs/attrib.c 	static const char *es = " Unmount and run chkdsk.";
es                972 fs/ntfs/attrib.c 						base_ni->mft_no, es);
es                997 fs/ntfs/attrib.c 							base_ni->mft_no, es);
es               1073 fs/ntfs/attrib.c 				es);
es               1842 fs/ntfs/inode.c 		static const char *es = "  Not allowed.  $MFT is corrupt.  "
es               1850 fs/ntfs/inode.c 					"compressed.%s", es);
es               1858 fs/ntfs/inode.c 						"sparse.%s", es);
es               2310 fs/ntfs/inode.c static const char *es = "  Leaving inconsistent metadata.  Unmount and run "
es               2697 fs/ntfs/inode.c 				IS_ERR(m) ? PTR_ERR(m) : err, es);
es               2708 fs/ntfs/inode.c 				(unsigned)le32_to_cpu(ni->type), mp_size, es);
es               2732 fs/ntfs/inode.c 				err, es);
es               1104 fs/ntfs/mft.c  static const char *es = "  Leaving inconsistent metadata.  Unmount and run "
es               1366 fs/ntfs/mft.c  						"allocated cluster.%s", es);
es               1498 fs/ntfs/mft.c  				"mft bitmap attribute.%s", es);
es               1528 fs/ntfs/mft.c  		ntfs_error(vol->sb, "Failed to free allocated cluster.%s", es);
es               1539 fs/ntfs/mft.c  					"array.%s", es);
es               1544 fs/ntfs/mft.c  					"record.%s", es);
es               1642 fs/ntfs/mft.c  		ntfs_error(vol->sb, "Failed to map mft record.%s", es);
es               1648 fs/ntfs/mft.c  		ntfs_error(vol->sb, "Failed to get search context.%s", es);
es               1655 fs/ntfs/mft.c  				"mft bitmap attribute.%s", es);
es               1804 fs/ntfs/mft.c  					"from the mft data attribute.%s", es);
es               1936 fs/ntfs/mft.c  				"mft data attribute.%s", es);
es               1955 fs/ntfs/mft.c  				"attribute.%s", es);
es               1961 fs/ntfs/mft.c  				"runlist.%s", es);
es               1971 fs/ntfs/mft.c  					"array.%s", es);
es               1976 fs/ntfs/mft.c  					"record.%s", es);
es               1983 fs/ntfs/mft.c  				"context.%s", es);
es               2739 fs/ntfs/mft.c  		ntfs_error(vol->sb, "Failed to clear bit in mft bitmap.%s", es);
es               2872 fs/ntfs/mft.c  		ntfs_error(vol->sb, "Failed to clear bit in mft bitmap.%s", es);
es               2886 fs/ntfs/mft.c  					"buffer during rollback.%s", es);
es                477 fs/ntfs/super.c 		static const char *es = ".  Cannot remount read-write.";
es                482 fs/ntfs/super.c 					es);
es                486 fs/ntfs/super.c 			ntfs_error(sb, "Volume is dirty and read-only%s", es);
es                491 fs/ntfs/super.c 					"and is read-only%s", es);
es                498 fs/ntfs/super.c 					es);
es                503 fs/ntfs/super.c 					"information flags%s", es);
es                513 fs/ntfs/super.c 						"compatibility flag%s", es);
es                521 fs/ntfs/super.c 					es);
es                527 fs/ntfs/super.c 					es);
es                533 fs/ntfs/super.c 					"($UsnJrnl)%s", es);
es                 89 include/linux/fsl_devices.h 	unsigned	es:1;		/* need USBMODE:ES */
es               2247 include/trace/events/ext4.h 	TP_PROTO(struct inode *inode, struct extent_status *es),
es               2249 include/trace/events/ext4.h 	TP_ARGS(inode, es),
es               2263 include/trace/events/ext4.h 		__entry->lblk	= es->es_lblk;
es               2264 include/trace/events/ext4.h 		__entry->len	= es->es_len;
es               2265 include/trace/events/ext4.h 		__entry->pblk	= ext4_es_pblock(es);
es               2266 include/trace/events/ext4.h 		__entry->status	= ext4_es_status(es);
es               2277 include/trace/events/ext4.h 	TP_PROTO(struct inode *inode, struct extent_status *es),
es               2279 include/trace/events/ext4.h 	TP_ARGS(inode, es)
es               2283 include/trace/events/ext4.h 	TP_PROTO(struct inode *inode, struct extent_status *es),
es               2285 include/trace/events/ext4.h 	TP_ARGS(inode, es)
es               2336 include/trace/events/ext4.h 	TP_PROTO(struct inode *inode, struct extent_status *es),
es               2338 include/trace/events/ext4.h 	TP_ARGS(inode, es),
es               2352 include/trace/events/ext4.h 		__entry->lblk	= es->es_lblk;
es               2353 include/trace/events/ext4.h 		__entry->len	= es->es_len;
es               2354 include/trace/events/ext4.h 		__entry->pblk	= ext4_es_pblock(es);
es               2355 include/trace/events/ext4.h 		__entry->status	= ext4_es_status(es);
es               2388 include/trace/events/ext4.h 	TP_PROTO(struct inode *inode, struct extent_status *es,
es               2391 include/trace/events/ext4.h 	TP_ARGS(inode, es, found),
es               2406 include/trace/events/ext4.h 		__entry->lblk	= es->es_lblk;
es               2407 include/trace/events/ext4.h 		__entry->len	= es->es_len;
es               2408 include/trace/events/ext4.h 		__entry->pblk	= ext4_es_pblock(es);
es               2409 include/trace/events/ext4.h 		__entry->status	= ext4_es_status(es);
es               2556 include/trace/events/ext4.h 	TP_PROTO(struct inode *inode, struct extent_status *es,
es               2559 include/trace/events/ext4.h 	TP_ARGS(inode, es, allocated),
es               2574 include/trace/events/ext4.h 		__entry->lblk		= es->es_lblk;
es               2575 include/trace/events/ext4.h 		__entry->len		= es->es_len;
es               2576 include/trace/events/ext4.h 		__entry->pblk		= ext4_es_pblock(es);
es               2577 include/trace/events/ext4.h 		__entry->status		= ext4_es_status(es);
es                 20 include/uapi/video/uvesafb.h 	__u16 es;
es                399 scripts/kconfig/menu.c 					struct symbol *es = prop_get_symbol(prop);
es                400 scripts/kconfig/menu.c 					es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr,
es                403 scripts/kconfig/menu.c 					struct symbol *es = prop_get_symbol(prop);
es                404 scripts/kconfig/menu.c 					es->implied.expr = expr_alloc_or(es->implied.expr,
es                315 sound/pci/ac97/ac97_pcm.c 			u16 es;
es                316 sound/pci/ac97/ac97_pcm.c 			es = ac97->regs[AC97_EXTENDED_ID] &= ~AC97_EI_DACS_SLOT_MASK;
es                319 sound/pci/ac97/ac97_pcm.c 			case 2: es |= (1<<AC97_EI_DACS_SLOT_SHIFT); break;
es                320 sound/pci/ac97/ac97_pcm.c 			case 3: es |= (2<<AC97_EI_DACS_SLOT_SHIFT); break;
es                322 sound/pci/ac97/ac97_pcm.c 			snd_ac97_write_cache(ac97, AC97_EXTENDED_ID, es);
es                859 sound/pci/es1968.c 		struct esschan *es;
es                860 sound/pci/es1968.c 		list_for_each_entry(es, &chip->substream_list, list) {
es                861 sound/pci/es1968.c 			if (max_freq < es->bob_freq)
es                862 sound/pci/es1968.c 				max_freq = es->bob_freq;
es                873 sound/pci/es1968.c snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,
es                878 sound/pci/es1968.c 	if (es->fmt & ESS_FMT_STEREO)
es                880 sound/pci/es1968.c 	if (es->fmt & ESS_FMT_16BIT)
es                882 sound/pci/es1968.c 	freq /= es->frag_size;
es                907 sound/pci/es1968.c snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)
es                911 sound/pci/es1968.c 	offset = apu_get_register(chip, es->apu[0], 5);
es                913 sound/pci/es1968.c 	offset -= es->base[0];
es                935 sound/pci/es1968.c static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)
es                938 sound/pci/es1968.c 	__apu_set_register(chip, es->apu[0], 5, es->base[0]);
es                939 sound/pci/es1968.c 	snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]);
es                940 sound/pci/es1968.c 	if (es->mode == ESM_MODE_CAPTURE) {
es                941 sound/pci/es1968.c 		__apu_set_register(chip, es->apu[2], 5, es->base[2]);
es                942 sound/pci/es1968.c 		snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]);
es                944 sound/pci/es1968.c 	if (es->fmt & ESS_FMT_STEREO) {
es                945 sound/pci/es1968.c 		__apu_set_register(chip, es->apu[1], 5, es->base[1]);
es                946 sound/pci/es1968.c 		snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]);
es                947 sound/pci/es1968.c 		if (es->mode == ESM_MODE_CAPTURE) {
es                948 sound/pci/es1968.c 			__apu_set_register(chip, es->apu[3], 5, es->base[3]);
es                949 sound/pci/es1968.c 			snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]);
es                955 sound/pci/es1968.c static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)
es                958 sound/pci/es1968.c 	snd_es1968_trigger_apu(chip, es->apu[0], 0);
es                959 sound/pci/es1968.c 	snd_es1968_trigger_apu(chip, es->apu[1], 0);
es                960 sound/pci/es1968.c 	if (es->mode == ESM_MODE_CAPTURE) {
es                961 sound/pci/es1968.c 		snd_es1968_trigger_apu(chip, es->apu[2], 0);
es                962 sound/pci/es1968.c 		snd_es1968_trigger_apu(chip, es->apu[3], 0);
es                968 sound/pci/es1968.c static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,
es                974 sound/pci/es1968.c 		if (!(es->fmt & ESS_FMT_16BIT))
es                976 sound/pci/es1968.c 		if (es->fmt & ESS_FMT_STEREO)
es                981 sound/pci/es1968.c 	wave_set_register(chip, es->apu[channel] << 3, tmpval);
es                984 sound/pci/es1968.c 	es->wc_map[channel] = tmpval;
es                989 sound/pci/es1968.c static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,
es                999 sound/pci/es1968.c 	size = es->dma_size >> es->wav_shift;
es               1001 sound/pci/es1968.c 	if (es->fmt & ESS_FMT_STEREO)
es               1005 sound/pci/es1968.c 		apu = es->apu[channel];
es               1007 sound/pci/es1968.c 		snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0);
es               1010 sound/pci/es1968.c 		pa = es->memory->buf.addr;
es               1016 sound/pci/es1968.c 		if (es->fmt & ESS_FMT_STEREO) {
es               1020 sound/pci/es1968.c 			if (es->fmt & ESS_FMT_16BIT)
es               1026 sound/pci/es1968.c 		es->base[channel] = pa & 0xFFFF;
es               1048 sound/pci/es1968.c 		if (es->fmt & ESS_FMT_16BIT)
es               1049 sound/pci/es1968.c 			es->apu_mode[channel] = ESM_APU_16BITLINEAR;
es               1051 sound/pci/es1968.c 			es->apu_mode[channel] = ESM_APU_8BITLINEAR;
es               1053 sound/pci/es1968.c 		if (es->fmt & ESS_FMT_STEREO) {
es               1061 sound/pci/es1968.c 			es->apu_mode[channel] += 1;	/* stereo */
es               1081 sound/pci/es1968.c 	if (!(es->fmt & ESS_FMT_16BIT) && !(es->fmt & ESS_FMT_STEREO))
es               1087 sound/pci/es1968.c 	snd_es1968_apu_set_freq(chip, es->apu[0], freq);
es               1088 sound/pci/es1968.c 	snd_es1968_apu_set_freq(chip, es->apu[1], freq);
es               1092 sound/pci/es1968.c static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,
es               1096 sound/pci/es1968.c 	int i, apu = es->apu[channel];
es               1098 sound/pci/es1968.c 	es->apu_mode[channel] = mode;
es               1101 sound/pci/es1968.c 	snd_es1968_program_wavecache(chip, es, channel, pa, 1);
es               1109 sound/pci/es1968.c 	es->base[channel] = pa & 0xFFFF;
es               1137 sound/pci/es1968.c static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,
es               1144 sound/pci/es1968.c 	size = es->dma_size >> es->wav_shift;
es               1158 sound/pci/es1968.c 	init_capture_apu(chip, es, 2,
es               1159 sound/pci/es1968.c 			 es->mixbuf->buf.addr, ESM_MIXBUF_SIZE/4, /* in words */
es               1162 sound/pci/es1968.c 	init_capture_apu(chip, es, 0, es->memory->buf.addr, size,
es               1163 sound/pci/es1968.c 			 ESM_APU_SRCONVERTOR, es->apu[2]);
es               1164 sound/pci/es1968.c 	if (es->fmt & ESS_FMT_STEREO) {
es               1166 sound/pci/es1968.c 		init_capture_apu(chip, es, 3,
es               1167 sound/pci/es1968.c 				 es->mixbuf->buf.addr + ESM_MIXBUF_SIZE/2,
es               1171 sound/pci/es1968.c 		init_capture_apu(chip, es, 1,
es               1172 sound/pci/es1968.c 				 es->memory->buf.addr + size*2, size,
es               1173 sound/pci/es1968.c 				 ESM_APU_SRCONVERTOR, es->apu[3]);
es               1186 sound/pci/es1968.c 	snd_es1968_apu_set_freq(chip, es->apu[0], freq);
es               1187 sound/pci/es1968.c 	snd_es1968_apu_set_freq(chip, es->apu[1], freq);
es               1191 sound/pci/es1968.c 	snd_es1968_apu_set_freq(chip, es->apu[2], freq);
es               1192 sound/pci/es1968.c 	snd_es1968_apu_set_freq(chip, es->apu[3], freq);
es               1210 sound/pci/es1968.c 	struct esschan *es = runtime->private_data;
es               1212 sound/pci/es1968.c 	es->dma_size = snd_pcm_lib_buffer_bytes(substream);
es               1213 sound/pci/es1968.c 	es->frag_size = snd_pcm_lib_period_bytes(substream);
es               1215 sound/pci/es1968.c 	es->wav_shift = 1; /* maestro handles always 16bit */
es               1216 sound/pci/es1968.c 	es->fmt = 0;
es               1218 sound/pci/es1968.c 		es->fmt |= ESS_FMT_16BIT;
es               1220 sound/pci/es1968.c 		es->fmt |= ESS_FMT_STEREO;
es               1221 sound/pci/es1968.c 		if (es->fmt & ESS_FMT_16BIT) /* 8bit is already word shifted */
es               1222 sound/pci/es1968.c 			es->wav_shift++;
es               1224 sound/pci/es1968.c 	es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime);
es               1226 sound/pci/es1968.c 	switch (es->mode) {
es               1228 sound/pci/es1968.c 		snd_es1968_playback_setup(chip, es, runtime);
es               1231 sound/pci/es1968.c 		snd_es1968_capture_setup(chip, es, runtime);
es               1241 sound/pci/es1968.c 	struct esschan *es = substream->runtime->private_data;
es               1247 sound/pci/es1968.c 		if (es->running)
es               1249 sound/pci/es1968.c 		snd_es1968_bob_inc(chip, es->bob_freq);
es               1250 sound/pci/es1968.c 		es->count = 0;
es               1251 sound/pci/es1968.c 		es->hwptr = 0;
es               1252 sound/pci/es1968.c 		snd_es1968_pcm_start(chip, es);
es               1253 sound/pci/es1968.c 		es->running = 1;
es               1257 sound/pci/es1968.c 		if (! es->running)
es               1259 sound/pci/es1968.c 		snd_es1968_pcm_stop(chip, es);
es               1260 sound/pci/es1968.c 		es->running = 0;
es               1271 sound/pci/es1968.c 	struct esschan *es = substream->runtime->private_data;
es               1274 sound/pci/es1968.c 	ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
es               1276 sound/pci/es1968.c 	return bytes_to_frames(substream->runtime, ptr % es->dma_size);
es               1539 sound/pci/es1968.c 	struct esschan *es;
es               1547 sound/pci/es1968.c 	es = kzalloc(sizeof(*es), GFP_KERNEL);
es               1548 sound/pci/es1968.c 	if (!es) {
es               1553 sound/pci/es1968.c 	es->apu[0] = apu1;
es               1554 sound/pci/es1968.c 	es->apu[1] = apu1 + 1;
es               1555 sound/pci/es1968.c 	es->apu_mode[0] = 0;
es               1556 sound/pci/es1968.c 	es->apu_mode[1] = 0;
es               1557 sound/pci/es1968.c 	es->running = 0;
es               1558 sound/pci/es1968.c 	es->substream = substream;
es               1559 sound/pci/es1968.c 	es->mode = ESM_MODE_PLAY;
es               1561 sound/pci/es1968.c 	runtime->private_data = es;
es               1567 sound/pci/es1968.c 	list_add(&es->list, &chip->substream_list);
es               1577 sound/pci/es1968.c 	struct esschan *es;
es               1589 sound/pci/es1968.c 	es = kzalloc(sizeof(*es), GFP_KERNEL);
es               1590 sound/pci/es1968.c 	if (!es) {
es               1596 sound/pci/es1968.c 	es->apu[0] = apu1;
es               1597 sound/pci/es1968.c 	es->apu[1] = apu1 + 1;
es               1598 sound/pci/es1968.c 	es->apu[2] = apu2;
es               1599 sound/pci/es1968.c 	es->apu[3] = apu2 + 1;
es               1600 sound/pci/es1968.c 	es->apu_mode[0] = 0;
es               1601 sound/pci/es1968.c 	es->apu_mode[1] = 0;
es               1602 sound/pci/es1968.c 	es->apu_mode[2] = 0;
es               1603 sound/pci/es1968.c 	es->apu_mode[3] = 0;
es               1604 sound/pci/es1968.c 	es->running = 0;
es               1605 sound/pci/es1968.c 	es->substream = substream;
es               1606 sound/pci/es1968.c 	es->mode = ESM_MODE_CAPTURE;
es               1609 sound/pci/es1968.c 	if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) {
es               1612 sound/pci/es1968.c 		kfree(es);
es               1615 sound/pci/es1968.c 	memset(es->mixbuf->buf.area, 0, ESM_MIXBUF_SIZE);
es               1617 sound/pci/es1968.c 	runtime->private_data = es;
es               1624 sound/pci/es1968.c 	list_add(&es->list, &chip->substream_list);
es               1633 sound/pci/es1968.c 	struct esschan *es;
es               1637 sound/pci/es1968.c 	es = substream->runtime->private_data;
es               1639 sound/pci/es1968.c 	list_del(&es->list);
es               1641 sound/pci/es1968.c 	snd_es1968_free_apu_pair(chip, es->apu[0]);
es               1642 sound/pci/es1968.c 	kfree(es);
es               1650 sound/pci/es1968.c 	struct esschan *es;
es               1654 sound/pci/es1968.c 	es = substream->runtime->private_data;
es               1656 sound/pci/es1968.c 	list_del(&es->list);
es               1658 sound/pci/es1968.c 	snd_es1968_free_memory(chip, es->mixbuf);
es               1659 sound/pci/es1968.c 	snd_es1968_free_apu_pair(chip, es->apu[0]);
es               1660 sound/pci/es1968.c 	snd_es1968_free_apu_pair(chip, es->apu[2]);
es               1661 sound/pci/es1968.c 	kfree(es);
es               1833 sound/pci/es1968.c static void snd_es1968_suppress_jitter(struct es1968 *chip, struct esschan *es)
es               1850 sound/pci/es1968.c static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
es               1854 sound/pci/es1968.c 	struct snd_pcm_substream *subs = es->substream;
es               1856 sound/pci/es1968.c 	if (subs == NULL || !es->running)
es               1859 sound/pci/es1968.c 	hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
es               1860 sound/pci/es1968.c 	hwptr %= es->dma_size;
es               1862 sound/pci/es1968.c 	diff = (es->dma_size + hwptr - es->hwptr) % es->dma_size;
es               1864 sound/pci/es1968.c 	es->hwptr = hwptr;
es               1865 sound/pci/es1968.c 	es->count += diff;
es               1867 sound/pci/es1968.c 	if (es->count > es->frag_size) {
es               1871 sound/pci/es1968.c 		es->count %= es->frag_size;
es               1980 sound/pci/es1968.c 		struct esschan *es;
es               1982 sound/pci/es1968.c 		list_for_each_entry(es, &chip->substream_list, list) {
es               1983 sound/pci/es1968.c 			if (es->running) {
es               1984 sound/pci/es1968.c 				snd_es1968_update_pcm(chip, es);
es               1985 sound/pci/es1968.c 				if (es->fmt & ESS_FMT_STEREO)
es               1986 sound/pci/es1968.c 					snd_es1968_suppress_jitter(chip, es);
es               2390 sound/pci/es1968.c 	struct esschan *es;
es               2408 sound/pci/es1968.c 	list_for_each_entry(es, &chip->substream_list, list) {
es               2409 sound/pci/es1968.c 		switch (es->mode) {
es               2411 sound/pci/es1968.c 			snd_es1968_playback_setup(chip, es, es->substream->runtime);
es               2414 sound/pci/es1968.c 			snd_es1968_capture_setup(chip, es, es->substream->runtime);
es                151 tools/arch/x86/include/uapi/asm/kvm.h 	struct kvm_segment cs, ds, es, fs, gs, ss;
es                271 tools/perf/builtin-script.c 	struct evsel_script *es = zalloc(sizeof(*es));
es                273 tools/perf/builtin-script.c 	if (es != NULL) {
es                274 tools/perf/builtin-script.c 		if (asprintf(&es->filename, "%s.%s.dump", data->file.path, perf_evsel__name(evsel)) < 0)
es                276 tools/perf/builtin-script.c 		es->fp = fopen(es->filename, "w");
es                277 tools/perf/builtin-script.c 		if (es->fp == NULL)
es                281 tools/perf/builtin-script.c 	return es;
es                283 tools/perf/builtin-script.c 	zfree(&es->filename);
es                285 tools/perf/builtin-script.c 	free(es);
es                289 tools/perf/builtin-script.c static void perf_evsel_script__delete(struct evsel_script *es)
es                291 tools/perf/builtin-script.c 	zfree(&es->filename);
es                292 tools/perf/builtin-script.c 	fclose(es->fp);
es                293 tools/perf/builtin-script.c 	es->fp = NULL;
es                294 tools/perf/builtin-script.c 	free(es);
es                297 tools/perf/builtin-script.c static int perf_evsel_script__fprintf(struct evsel_script *es, FILE *fp)
es                301 tools/perf/builtin-script.c 	fstat(fileno(es->fp), &st);
es                303 tools/perf/builtin-script.c 		       st.st_size / 1024.0 / 1024.0, es->filename, es->samples);
es               1813 tools/perf/builtin-script.c 	struct evsel_script *es = evsel->priv;
es               1814 tools/perf/builtin-script.c 	FILE *fp = es->fp;
es               1825 tools/perf/builtin-script.c 	++es->samples;
es               2046 tools/perf/builtin-script.c 	static struct evsel_script *es;
es               2060 tools/perf/builtin-script.c 			es = zalloc(sizeof(*es));
es               2061 tools/perf/builtin-script.c 			if (!es)
es               2063 tools/perf/builtin-script.c 			es->fp = stdout;
es               2064 tools/perf/builtin-script.c 			evsel->priv = es;
es               2469 tools/perf/builtin-script.c 		struct evsel_script *es = evsel->priv;
es               2471 tools/perf/builtin-script.c 		perf_evsel_script__fprintf(es, stdout);
es               2472 tools/perf/builtin-script.c 		perf_evsel_script__delete(es);
es                377 tools/perf/pmu-events/jevents.c 	es->field = strdup(field);				\
es                378 tools/perf/pmu-events/jevents.c 	if (!es->field)						\
es                382 tools/perf/pmu-events/jevents.c #define FREE_EVENT_FIELD(field) free(es->field)
es                384 tools/perf/pmu-events/jevents.c #define TRY_FIXUP_FIELD(field) do { if (es->field && !*field) {\
es                385 tools/perf/pmu-events/jevents.c 	*field = strdup(es->field);				\
es                407 tools/perf/pmu-events/jevents.c 	struct event_struct *es, *next;
es                409 tools/perf/pmu-events/jevents.c 	list_for_each_entry_safe(es, next, &arch_std_events, list) {
es                411 tools/perf/pmu-events/jevents.c 		list_del_init(&es->list);
es                412 tools/perf/pmu-events/jevents.c 		free(es);
es                421 tools/perf/pmu-events/jevents.c 	struct event_struct *es;
es                423 tools/perf/pmu-events/jevents.c 	es = malloc(sizeof(*es));
es                424 tools/perf/pmu-events/jevents.c 	if (!es)
es                426 tools/perf/pmu-events/jevents.c 	memset(es, 0, sizeof(*es));
es                428 tools/perf/pmu-events/jevents.c 	list_add_tail(&es->list, &arch_std_events);
es                432 tools/perf/pmu-events/jevents.c 	free(es);
es                485 tools/perf/pmu-events/jevents.c 	struct event_struct *es;
es                487 tools/perf/pmu-events/jevents.c 	list_for_each_entry(es, &arch_std_events, list) {
es                488 tools/perf/pmu-events/jevents.c 		if (!strcmp(arch_std, es->name)) {
es                489 tools/perf/pmu-events/jevents.c 			if (!eventcode && es->event) {
es                349 tools/perf/util/db-export.c 	struct export_sample es = {
es                374 tools/perf/util/db-export.c 		es.comm_db_id = comm->db_id;
es                376 tools/perf/util/db-export.c 	es.db_id = ++dbe->sample_last_db_id;
es                378 tools/perf/util/db-export.c 	err = db_ids_from_al(dbe, al, &es.dso_db_id, &es.sym_db_id, &es.offset);
es                388 tools/perf/util/db-export.c 			es.call_path_id = cp->db_id;
es                397 tools/perf/util/db-export.c 		err = db_ids_from_al(dbe, &addr_al, &es.addr_dso_db_id,
es                398 tools/perf/util/db-export.c 				     &es.addr_sym_db_id, &es.addr_offset);
es                403 tools/perf/util/db-export.c 						    &addr_al, es.db_id,
es                411 tools/perf/util/db-export.c 		err = dbe->export_sample(dbe, &es);
es                 56 tools/perf/util/db-export.h 	int (*export_sample)(struct db_export *dbe, struct export_sample *es);
es               1121 tools/perf/util/scripting-engines/trace-event-python.c 				       struct export_sample *es)
es               1128 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 0, es->db_id);
es               1129 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 1, es->evsel->db_id);
es               1130 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 2, es->al->machine->db_id);
es               1131 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 3, es->al->thread->db_id);
es               1132 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 4, es->comm_db_id);
es               1133 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 5, es->dso_db_id);
es               1134 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 6, es->sym_db_id);
es               1135 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 7, es->offset);
es               1136 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 8, es->sample->ip);
es               1137 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 9, es->sample->time);
es               1138 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_s32(t, 10, es->sample->cpu);
es               1139 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 11, es->addr_dso_db_id);
es               1140 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 12, es->addr_sym_db_id);
es               1141 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 13, es->addr_offset);
es               1142 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 14, es->sample->addr);
es               1143 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 15, es->sample->period);
es               1144 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 16, es->sample->weight);
es               1145 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 17, es->sample->transaction);
es               1146 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 18, es->sample->data_src);
es               1147 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_s32(t, 19, es->sample->flags & PERF_BRANCH_MASK);
es               1148 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_s32(t, 20, !!(es->sample->flags & PERF_IP_FLAG_IN_TX));
es               1149 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 21, es->call_path_id);
es               1150 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 22, es->sample->insn_cnt);
es               1151 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 23, es->sample->cyc_cnt);
es               1158 tools/perf/util/scripting-engines/trace-event-python.c static void python_export_synth(struct db_export *dbe, struct export_sample *es)
es               1165 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 0, es->db_id);
es               1166 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_u64(t, 1, es->evsel->core.attr.config);
es               1167 tools/perf/util/scripting-engines/trace-event-python.c 	tuple_set_bytes(t, 2, es->sample->raw_data, es->sample->raw_size);
es               1175 tools/perf/util/scripting-engines/trace-event-python.c 				struct export_sample *es)
es               1179 tools/perf/util/scripting-engines/trace-event-python.c 	python_export_sample_table(dbe, es);
es               1181 tools/perf/util/scripting-engines/trace-event-python.c 	if (es->evsel->core.attr.type == PERF_TYPE_SYNTH && tables->synth_handler)
es               1182 tools/perf/util/scripting-engines/trace-event-python.c 		python_export_synth(dbe, es);
es                128 tools/testing/selftests/kvm/include/x86_64/processor.h 	uint16_t es;
es                131 tools/testing/selftests/kvm/include/x86_64/processor.h 			     : /* output */ [es]"=rm"(es));
es                132 tools/testing/selftests/kvm/include/x86_64/processor.h 	return es;
es                196 tools/testing/selftests/kvm/lib/x86_64/processor.c 	segment_dump(stream, &sregs->es, indent + 2);
es                632 tools/testing/selftests/kvm/lib/x86_64/processor.c 		kvm_seg_set_kernel_data_64bit(vm, 0x10, &sregs.es);
es                268 tools/testing/selftests/x86/entry_from_vm86.c 	v86.regs.es = load_addr / 16;