diff --git a/ChangeLog b/ChangeLog index d2cbe27..1a08d9e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,77 @@ +2007-07-19 Jason Fleischli + * Integrated x86_64 support patches from Chandramouli Narayanan + changes summarized in following bullets. + * alloc.c -- adds patch contributors credit to copyright + * alloc.c -- adds uefi_call_wrapper around BS->function calls + * alloc.c -- adds call to Print on VERB_PRT + * alternate.c -- adds patch contributors credit around copyright + * alternate.c -- adds uefi_call_wrapper around RT->function calls + * simple.c -- adds patch contributors credit to copyright + * simple.c -- adds uefi_call_wrapper around ip->ReadKeyStroke + * textmenu.c -- adds patch contributors credit to copyright + * textmenu.c -- adds uefi_call_wrapper around ClearScreen & + SetTextAttr + * textmenu.c -- adds uefi_call_wrapper around ip->ReadKeyStroke + * elilo.c -- adds patch contributors credit to copyright + * elilo.c -- fixes version number for ELILO_VERSION macro to current + * elilo.c -- adds uefi_call_wrapper around BS->function calls + * elilo.c -- adds uefi_call_wrapper around RT->function calls + * fileops.c -- adds patch contributors credit to copyright + * fileops.c -- adds uefi_call_wrapper around BS->function calls + * fileops.c -- adds uefi_call_wrapper around RT->function calls + * fileops.c -- adds uefi_call_wrapper around blkio->function calls + * localfs.c -- adds patch contributors credit to copyright + * localfs.c -- changed EFI_HANDLE *dev declaration to non-pointer type + * localfs.c -- adds uefi_call_wrapper around lfs->volume->functions + * localfs.c -- adds uefi_call_wrapper around BS->function calls + * netfs.c -- adds patch contributors credit to copyright + * netfs.c -- adds uefi_call_wrapper around nfs->pxe->function calls + * netfs.c -- adds uefi_call_wrapper around BS->function calls + * getopt.c -- changed int to char in StrChr() function + * Make.defaults -- adds patch contributors credit to copyright + * Make.defaults -- adds cflag for efi function wrapper + * Makefile -- adds patch contributors credit to copyright + * Makefile -- x86_64 subdir and a new rule for .S + * util.c -- adds patch contributors credit to copyright + * util.c -- adds uefi_call_wrapper to systab->functions + * util.c -- adds uefi_call_wrapper to conin->functions + * util.c -- adds uefi_call_wrapper to BS->functions + * util.c -- doubles ELILO_MEMMAP_SIZE_DEFAULT in get_memmap() function + * bootparams.c -- uses ia32 params for x86_64 addition.. hmmmm? + * config.c -- adds patch contributors credit to copyright + * config.c -- adds define reference for x86_64.conf + * config.c -- in config_error() removes use of va_list which maps to + the gnu C-lib iface __gnuc_va_list. Replaces the use of _IPrint on + the va_list with direct use of IPrint(systab->ConOut, msg); + *maintainer note, this probably introduces a bug, in light of this + note from the patch submitter --> "On some x86_64 systems with + EFI1.10 firmware I tested, early boot messages did not appear on console. + However, I didn't encounter this behavior on x86_64 systems with UEFI2.0 + firmware" + * elf.h -- adds #def for x86_64 + * glue_netfs.c -- adds patch contributors credit to copyright + * glue_netfs.c -- adds define for x86_64.conf + * sysdeps.h -- adds patch contributors credit to copyright + * sysdeps.h -- add include reference for new x86_64 subdir + * x86_64/ -- new subdir - all based on elilo/ia32 subdir + * x86_64/bin_to_h.c -- new file, stream fed binary to hex converter + * x86_64/bzimage.c -- new file, binary compressed kernel support + * x86_64/gzip.c -- new file, embedded gzip + * x86_64/gzip_loader.c -- new file, embedded gzip + * x86_64/gzip.h -- new file, embedded gzip + * x86_64/inflate.c -- new file, a pkzip method 8 embedded decompressor + * x86_64/Makefile -- new file + * x86_64/plain_loader.c -- new file, for loading non-compressed kernels + * x86_64/private.h -- new file + * x86_64/rmswitch.S -- new file, RealMode assembly module + * x86_64/sysdeps.h -- new file, system stuff for x86_64, e820 mapping + added. + * x86_64/sysdeps.c -- new file, system stuff for x86_64 + * elilo.txt -- documentation update, add Intel to copyright + * README.gnu-efi -- documentation update for x86_64 +2006-01-27 Alex Williamson + * Found a couple more places where vmcode isn't zeroed, causing the + option to get carried over to labels it shouldn't. 2006-01-09 Brett Johnson * Released 3.6 2005-12-22 Alex Williamson diff --git a/Make.defaults b/Make.defaults index 0a90776..0558a58 100644 --- a/Make.defaults +++ b/Make.defaults @@ -1,6 +1,7 @@ # # Copyright (C) 2001-2003 Hewlett-Packard Co. # Contributed by Stephane Eranian +# Contributed by Chandramouli Narayanan # # This file is part of ELILO, the LINUX EFI boot loader. # @@ -54,7 +55,7 @@ CONFIG_machspec_netconfig=y # They are installed as part of the GNU-EFI package installation # EFIINC = /usr/include/efi -GNUEFILIB = /usr/lib +GNUEFILIB = /usr/lib EFILIB = /usr/lib EFICRT0 = /usr/lib @@ -67,7 +68,7 @@ CPPFLAGS = -DCONFIG_$(ARCH) OPTIMFLAGS = -O2 DEBUGFLAGS = -Wall -CFLAGS = $(OPTIMFLAGS) -fpic -fshort-wchar $(DEBUGFLAGS) +CFLAGS = $(OPTIMFLAGS) -fpic -fshort-wchar $(DEBUGFLAGS) LDFLAGS = -nostdlib -znocombreloc INSTALL = install @@ -105,6 +106,12 @@ AR = $(prefix)ar RANLIB = $(prefix)ranlib OBJCOPY = $(prefix)objcopy +# Use Modified binutils that supports x86_64 using UEFI ABI +ifeq ($(ARCH), x86_64) + CFLAGS += -DEFI_FUNCTION_WRAPPER + OBJCOPY = /usr/bin/objcopy +endif + ifeq ($(ARCH),ia64) GCC_VERSION=$(shell $(CROSS_COMPILE)$(CC) -v 2>&1 | fgrep 'gcc version' | cut -f3 -d' ' | cut -f1 -d'.') diff --git a/Make.rules b/Make.rules index 2f4ade2..c9c87c8 100644 --- a/Make.rules +++ b/Make.rules @@ -32,4 +32,7 @@ %.o: %.c $(CC) $(INCDIR) $(CFLAGS) $(CPPFLAGS) -c $< -o $@ +# a rule for .S +%.o: %.S + $(CC) $(INCDIR) $(CFLAGS) $(CPPFLAGS) -c $< -o $@ diff --git a/Makefile b/Makefile index 5015faf..73dc4d4 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,8 @@ # # Copyright (C) 2001-2003 Hewlett-Packard Co. # Contributed by Stephane Eranian +# Contributed by Fenghua Yu +# Contributed by Chandramouli Narayanan # # This file is part of ELILO, the LINUX EFI boot loader. # @@ -58,6 +60,10 @@ ifeq ($(ARCH),ia32) SUBDIRS += ia32 endif +ifeq ($(ARCH),x86_64) +SUBDIRS += x86_64 +endif + FILES = elilo.o getopt.o strops.o loader.o \ fileops.o util.o vars.o alloc.o chooser.o \ config.o initrd.o alternate.o bootparams.o \ diff --git a/README b/README index 29724e7..92d29ef 100644 --- a/README +++ b/README @@ -1,14 +1,15 @@ - ELILO: the IA-32 and IA-64 Linux Loader - --------------------------------------- + ELILO: the IA-32,IA-64 and x86_64 Linux Loader + ---------------------------------------------- Stephane Eranian August 2003 Copyright (C) 2000-2003 Hewlett-Packard Co. + Copyright (C) 2006-2010 Intel Co. -This package contains version 3.4 of elilo, the EFI boot loader -for IA-64(IPF) and IA-32(x86) EFI-based platforms. +This package contains version 3.7 of elilo, the EFI boot loader +for IA-64(IPF),IA-32(x86) and x86_64 EFI-based platforms. RELEASE NOTES: @@ -65,6 +66,12 @@ RELEASE NOTES: The Redhat 9.0 toolchain does not work at the moment. + For x86_64, a toolchain known to produce working binaries is: + gcc-4.1.1 or above + binutils-2.17.50.0.14 with Intel64 EFI support + For x86_64, the following libraries are required for the elilo build + gnu-efi library with x86_64 + DOCUMENTATION: -------------- PLEASE READ THE docs/elilo.txt file for some documentation on how diff --git a/README.gnu-efi b/README.gnu-efi index 1653032..7007f09 100644 --- a/README.gnu-efi +++ b/README.gnu-efi @@ -1,5 +1,6 @@ IMPORTANT Information related to the gnu-efi package + and x86_64 efi support ---------------------------------------------------- August 2003 @@ -12,6 +13,10 @@ As of version elilo-3.0, the gnu-efi package is now split in two different packa Note that X.y don't need to match for both packages. However elilo-3.x requires at least gnu-efi >= 3.0. When using a version of gcc >3.0 you MUST use at least gnu-efi-3.0a. +Note that EFI support for x86_64 has been added as a patch to gnu-efi-3.0c. + +For x86_64, see the important notes under x86_64. + IMPORTANT NOTE FOR IA-32: ------------------------- For IA-32, the Redhat 8.0 toolchain is known to produce @@ -29,3 +34,32 @@ IMPORTANT NOTE FOR IA-32: The gnu-efi package can be downloaded from: ftp://ftp.hpl.hp.com/pub/linux-ia64/gnu-efi-X.y.tar.gz + +IMPORTANT NOTE FOR x86_64: +------------------------- + + EFI x86_64 elilo support requires the following libraries: + + 1. gnu-efi-3.0c library with x86_64 support. + + 2. The toolchain known to produce working x86_64 efi binary are: + + gcc-4.1.1 or above + binutils-2.17.50.0.14 with Intel64 EFI support + + Implementation: + -------------- + Calls to EFI services in x86_64 require a wrapper to pass the arguments + in the appropriate manner. This is implemented with efi wrapper. + For IA32 and IA64, the wrapper is a macro that merely calls the + EFI services directly. The elilo source has been modified to use the + efi wrapper implemented in gnu-efi-3.0c library. + elilo for x86_64 and its dependent libraries are built and the final + ELF image is converted into PE-COFF image using the objcopy supported + by binutils-2.17.50.0.14 or above with Intel64 EFI support. + + On UEFI 2.0 firmware, only Graphics Output Protocol (GOP) is supported. + The x86_64 elilo first queries video information from GOP failing which + it queries for text mode support. The video information is passed to + Linux kernel via boot parameter. The GOP support requires + Linux kernel EFI framebuffer driver (kernel configuration option). diff --git a/alloc.c b/alloc.c index 349da9f..358939a 100644 --- a/alloc.c +++ b/alloc.c @@ -1,6 +1,9 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -100,7 +103,7 @@ alloc(UINTN size, EFI_MEMORY_TYPE type) if (type == 0) type = EfiLoaderData; - status = BS->AllocatePool (type, size, &tmp); + status = uefi_call_wrapper(BS->AllocatePool, 3, type, size, &tmp); if (EFI_ERROR(status)) { ERR_PRT((L"allocator: AllocatePool(%d, %d, 0x%x) failed (%r)\n", type, size, status)); return NULL; @@ -127,9 +130,9 @@ alloc_pages(UINTN pgcnt, EFI_MEMORY_TYPE type, EFI_ALLOCATE_TYPE where, VOID *ad return NULL; } - status = BS->AllocatePages(where, type , pgcnt, &tmp); + status = uefi_call_wrapper(BS->AllocatePages, 4, where, type , pgcnt, &tmp); if (EFI_ERROR(status)) { - VERB_PRT(1, (L"allocator: AllocatePages(%d, %d, %d, 0x%lx) failed (%r)\n", where, type, pgcnt, tmp, status)); + VERB_PRT(1, Print(L"allocator: AllocatePages(%d, %d, %d, 0x%lx) failed (%r)\n", where, type, pgcnt, tmp, status)); return NULL; } /* XXX: will cause warning on IA-32 */ @@ -155,7 +158,7 @@ free(VOID *addr) if (p->addr == addr) goto found; } /* not found */ - VERB_PRT(1, (L"allocator: invalid free @ 0x%lx\n", addr)); + VERB_PRT(1, Print(L"allocator: invalid free @ 0x%lx\n", addr)); return; found: DBG_PRT((L"free: %s @0x%lx size=%ld\n", @@ -163,9 +166,9 @@ found: addr, p->size)); if (p->type == ALLOC_POOL) - BS->FreePool(addr); + uefi_call_wrapper(BS->FreePool, 1, addr); else - BS->FreePages((EFI_PHYSICAL_ADDRESS)addr, p->size); + uefi_call_wrapper(BS->FreePages, 2, (EFI_PHYSICAL_ADDRESS)addr, p->size); /* remove from used list */ if (p->next) @@ -195,9 +198,9 @@ free_all(VOID) DBG_PRT((L"free_all %a @ 0x%lx\n", used_allocs->type == ALLOC_POOL ? "pool" : "pages", used_allocs->addr)); if (used_allocs->type == ALLOC_POOL) - BS->FreePool(used_allocs->addr); + uefi_call_wrapper(BS->FreePool, 1, used_allocs->addr); else - BS->FreePages((EFI_PHYSICAL_ADDRESS)used_allocs->addr, used_allocs->size); + uefi_call_wrapper(BS->FreePages, 2, (EFI_PHYSICAL_ADDRESS)used_allocs->addr, used_allocs->size); tmp = used_allocs->next; diff --git a/alternate.c b/alternate.c index df138ad..992e9bd 100644 --- a/alternate.c +++ b/alternate.c @@ -1,6 +1,9 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -77,7 +80,7 @@ alternate_kernel(CHAR16 *buffer, INTN size) * - the variable does not exist * - our buffer size is too small. */ - status = RT->GetVariable(ELILO_ALTK_VAR, &altk_guid, NULL, &size, buffer); + status = uefi_call_wrapper(RT->GetVariable, 5, ELILO_ALTK_VAR, &altk_guid, NULL, &size, buffer); if (EFI_ERROR(status)) { DBG_PRT((L"cannot access variable %s: %r", ELILO_ALTK_VAR, status)); @@ -110,7 +113,7 @@ alternate_kernel(CHAR16 *buffer, INTN size) ret = 0; delete_var: - status = RT->SetVariable(ELILO_ALTK_VAR, &altk_guid, 0, 0, NULL); + status = uefi_call_wrapper(RT->SetVariable, 5, ELILO_ALTK_VAR, &altk_guid, 0, 0, NULL); if (EFI_ERROR(status)) { ERR_PRT((L"cannot erase variable %s", ELILO_ALTK_VAR)); } diff --git a/bootparams.c b/bootparams.c index 8859fcc..1a2c54b 100644 --- a/bootparams.c +++ b/bootparams.c @@ -83,7 +83,7 @@ create_boot_params(CHAR16 *args, memdesc_t *initrd, memdesc_t *vmcode, UINTN *co /* XXX: need to fix this for 3.5 */ #ifdef CONFIG_ia64 cp = ((CHAR8 *)bp) + BOOT_PARAM_MEMSIZE - cmdline_size; -#elif defined CONFIG_ia32 +#elif defined CONFIG_ia32 || CONFIG_x86_64 cp = ((CHAR8 *)bp) + BOOT_PARAM_MEMSIZE - 2048; #endif diff --git a/choosers/simple.c b/choosers/simple.c index b246a91..5525086 100644 --- a/choosers/simple.c +++ b/choosers/simple.c @@ -1,6 +1,10 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -136,7 +140,8 @@ reprint: first_time = 0; for (;;) { - while ((status=ip->ReadKeyStroke(ip, &key)) == EFI_NOT_READY); + while ((status = uefi_call_wrapper(ip->ReadKeyStroke, 2, ip, &key)) + == EFI_NOT_READY); if (EFI_ERROR(status)) { ERR_PRT((L"select_kernel readkey: %r", status)); return -1; @@ -274,7 +279,7 @@ restart: argc = argify(alt_buffer,sizeof(alt_buffer), argv); alt_argv = argv; index = 0; - args[0] = initrd_name[0] = 0; + args[0] = initrd_name[0] = vmcode_name[0] = 0; /* * don't check twice because the variable is deleted after * first access @@ -354,7 +359,7 @@ restart: ret = wait_timeout(elilo_opt.delay); if (ret != 0) { elilo_opt.prompt = 1; - elilo_opt.initrd[0] = CHAR_NULL; + elilo_opt.initrd[0] = elilo_opt.vmcode[0] = CHAR_NULL; elilo_opt.timeout = ELILO_TIMEOUT_INFINITY; goto restart; } diff --git a/choosers/textmenu.c b/choosers/textmenu.c index 3210dda..400d4f6 100644 --- a/choosers/textmenu.c +++ b/choosers/textmenu.c @@ -1,6 +1,10 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Richard Hirst + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -45,8 +49,8 @@ static CHAR16 PromptBuf[CMDLINE_MAXLEN]; #define DEF_ATTR EFI_TEXT_ATTR(EFI_LIGHTGRAY,EFI_BLACK) -#define ClearScreen() ST->ConOut->ClearScreen(ST->ConOut) -#define SetTextAttr(a) ST->ConOut->SetAttribute(ST->ConOut, a) +#define ClearScreen() uefi_call_wrapper(ST->ConOut->ClearScreen, 1, ST->ConOut) +#define SetTextAttr(a) uefi_call_wrapper(ST->ConOut->SetAttribute, 2, ST->ConOut, a) static INTN tohex(INTN c) @@ -249,7 +253,8 @@ reprint: SetTextAttr(CurrentAttr); for (;;) { - while ((status=ip->ReadKeyStroke(ip, &key)) == EFI_NOT_READY); + while ((status = uefi_call_wrapper(ip->ReadKeyStroke, 2, ip, &key)) + == EFI_NOT_READY); if (EFI_ERROR(status)) { SetTextAttr(EFI_TEXT_ATTR(EFI_LIGHTGRAY,EFI_BLACK)); ClearScreen(); @@ -295,7 +300,7 @@ reprint: if (i) { msgbuf[i] = 0; paint_msg(msgbuf); - while ((status=ip->ReadKeyStroke(ip, &key)) == EFI_NOT_READY); + while ((status= uefi_call_wrapper(ip->ReadKeyStroke, 2, ip, &key)) == EFI_NOT_READY); goto reprint; } } @@ -465,7 +470,7 @@ restart: ret = wait_timeout(elilo_opt.delay); if (ret != 0) { elilo_opt.prompt = 1; - elilo_opt.initrd[0] = CHAR_NULL; + elilo_opt.initrd[0] = elilo_opt.vmcode[0] = CHAR_NULL; elilo_opt.timeout = ELILO_TIMEOUT_INFINITY; goto restart; } diff --git a/config.c b/config.c index e24c0c0..026e098 100644 --- a/config.c +++ b/config.c @@ -1,6 +1,9 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -42,6 +45,8 @@ #define ELILO_ARCH_DEFAULT_CONFIG L"elilo-ia64.conf" #elif defined (CONFIG_ia32) #define ELILO_ARCH_DEFAULT_CONFIG L"elilo-ia32.conf" +#elif defined (CONFIG_x86_64) +#define ELILO_ARCH_DEFAULT_CONFIG L"elilo-x86_64.conf" #else #error "You need to specfy your default arch config file" #endif @@ -204,14 +209,8 @@ static fops_fd_t config_fd; static VOID config_error(CHAR16 *msg,...) { - va_list ap; - extern UINTN _IPrint (UINTN, UINTN, SIMPLE_TEXT_OUTPUT_INTERFACE *, CHAR16 *, CHAR8 *, va_list); - Print(L"near line %d: ",line_num); - - va_start(ap,msg); - _IPrint((UINTN)-1, (UINTN)-1, systab->ConOut, msg, NULL, ap); - va_end(ap); + IPrint(systab->ConOut, msg); Print(L"\n"); } diff --git a/cscope.out b/cscope.out new file mode 100644 index 0000000..9750688 --- /dev/null +++ b/cscope.out @@ -0,0 +1,135421 @@ +cscope 16 $HOME/dev/elilo 0000729622 + @alloc.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +31  + #NALLOC + 512 + + ) + +33 um { + mALLOC_POOL +, + mALLOC_PAGES + } + tloc_tys_t +; + +35  + s_loc_y + { + +36  +_loc_y + * + mxt +; + +37  +_loc_y + * + mev +; + +38 +VOID + * + maddr +; + +39 +UINTN + + msize +; + +40 +loc_tys_t + + mty +; + +41 } + tloc_y_t +; + +43  +loc_y_t + + glocs +[ +NALLOC +]; + +44  +loc_y_t + * + g_locs +, * + gud_locs +; + +46  +VOID + * + gkmem_addr +; + +47  +UINTN + + gkmem_pgt +; + +52 +INTN + + +53 + $loc_ +( +VOID +) + +55 +UINTN + +i +; + +57  +i +=0; i < +NALLOC +-1; i++) { + +58 +locs +[ +i +]. +xt + =llocs+i+1; + +60 +locs +[ +i +]. +xt + = +NULL +; + +62 +_locs + = +locs +; + +63 +ud_locs + = +NULL +; + +66 + } +} + +68  +VOID + + +69 + $loc_add +( +VOID + * +addr +, +UINTN + +size +, +loc_tys_t + +ty +) + +71 +loc_y_t + * +loc +; + +74 +loc + = +_locs +; + +75 +_locs + = fe_locs-> +xt +; + +77 +loc +-> +ev + = +NULL +; + +78 +loc +-> +xt + = +ud_locs +; + +79 +loc +-> +addr + =ddr; + +80 +loc +-> +ty + =ype; + +81 +loc +-> +size + = size; + +84 i( +ud_locs +ud_locs-> +ev + = +loc +; + +86 +ud_locs + = +loc +; + +87 + } +} + +89 +VOID + * + +90 + $loc +( +UINTN + +size +, +EFI_MEMORY_TYPE + +ty +) + +92 +EFI_STATUS + +us +; + +93 +VOID + * +tmp + = 0; + +96 i( +_locs + = +NULL +) { + +97 + `ERR_PRT +(( +L +"allocator:o more slots\n")); + +98  +NULL +; + +101 i( +ty + =0ty = +EfiLdDa +; + +103 +us + = +BS +-> + `AoPo + ( +ty +, +size +, & +tmp +); + +104 i( + `EFI_ERROR +( +us +)) { + +105 + `ERR_PRT +(( +L +"lot: AoPo(%d, %d, 0x%xed (%r)\n", +ty +, +size +, +us +)); + +106  +NULL +; + +108 + `loc_add +( +tmp +, +size +, +ALLOC_POOL +); + +110 + `DBG_PRT +(( +L +"loc:od %d by@[0x%lx-0x%lx]\n", +size +, +tmp +,mp+size)); + +112  +tmp +; + +113 + } +} + +118 +VOID + * + +119 + $loc_ges +( +UINTN + +pgt +, +EFI_MEMORY_TYPE + +ty +, +EFI_ALLOCATE_TYPE + +whe +, +VOID + * +addr +) + +121 +EFI_STATUS + +us +; + +122 +EFI_PHYSICAL_ADDRESS + +tmp + = (EFI_PHYSICAL_ADDRESS) +addr +; + +125 i( +_locs + = +NULL +) { + +126 + `ERR_PRT +(( +L +"allocator:o more slots\n")); + +127  +NULL +; + +130 +us + = +BS +-> + `AoPages +( +whe +, +ty + , +pgt +, & +tmp +); + +131 i( + `EFI_ERROR +( +us +)) { + +132 + `VERB_PRT +(1, ( +L +"lot: AoPages(%d, %d, %d, 0x%lxed (%r)\n", +whe +, +ty +, +pgt +, +tmp +, +us +)); + +133  +NULL +; + +136 +addr + = ( +VOID + *) +tmp +; + +138 + `loc_add +( +addr +, +pgt +, +ALLOC_PAGES +); + +140 + `DBG_PRT +(( +L +"lot:od %dage@0x%lx\n", +pgt +, +tmp +)); + +142  +addr +; + +143 + } +} + +148 +VOID + + +149 + $ +( +VOID + * +addr +) + +151 +loc_y_t + * +p +; + +154  +p += +ud_locs +; ; =-> +xt +) { + +155 i( +p +-> +addr + =addr +found +; + +158 + `VERB_PRT +(1, ( +L +"lot: invid f@ 0x%lx\n", +addr +)); + +160 +found +: + +161 + `DBG_PRT +(( +L +"free: %s @0x%lx size=%ld\n", + +162 +p +-> +ty + = +ALLOC_POOL + ? +L +"Pool": L"Page", + +163 +addr +, +p +-> +size +)); + +165 i( +p +-> +ty + = +ALLOC_POOL +) + +166 +BS +-> + `FePo +( +addr +); + +168 +BS +-> + `FePages +(( +EFI_PHYSICAL_ADDRESS +) +addr +, +p +-> +size +); + +171 i( +p +-> +xt +) + +172 +p +-> +xt +-> +ev + =->prev; + +174 i( +p +-> +ev +) + +175 +p +-> +ev +-> +xt + =->next; + +177 +ud_locs + = +p +-> +xt +; + +180 +p +-> +xt + = +_locs +; + +181 +_locs + = +p +; + +182 + } +} + +188 +VOID + + +189 + $_l +( +VOID +) + +191 +loc_y_t + * +tmp +; + +193  +ud_locs +) { + +195 + `DBG_PRT +(( +L +"_%@ 0x%lx\n", +ud_locs +-> +ty + = +ALLOC_POOL + ? "po" : "ges", ud_locs-> +addr +)); + +197 i( +ud_locs +-> +ty + = +ALLOC_POOL +) + +198 +BS +-> + `FePo +( +ud_locs +-> +addr +); + +200 +BS +-> + `FePages +(( +EFI_PHYSICAL_ADDRESS +) +ud_locs +-> +addr +, ud_locs-> +size +); + +202 +tmp + = +ud_locs +-> +xt +; + +205 +ud_locs +-> +xt + = +_locs +; + +206 +_locs + = +ud_locs +; + +208 +ud_locs + = +tmp +; + +210 + } +} + +212 +INTN + + +213 + $loc_kmem +( +VOID + * +t_addr +, +UINTN + +pgt +) + +215 i( + `loc_ges +( +pgt +, +EfiLdDa +, +AoAddss +, +t_addr +) == 0)  -1; + +217 +kmem_addr + = +t_addr +; + +218 +kmem_pgt + = +pgt +; + +221 + } +} + +223 +VOID + + +224 + $_kmem +( +VOID +) + +226 + `DBG_PRT +(( +L +"_kmem befܐ(%lx, %ld)\n", +kmem_addr +, +kmem_pgt +)); + +227 i( +kmem_addr + && +kmem_pgt + != 0) { + +228 + ` +( +kmem_addr +); + +229 +kmem_addr + = +NULL +; + +230 +kmem_pgt + = 0; + +232 + `DBG_PRT +(( +L +"_kmem (%lx, %ld)\n", +kmem_addr +, +kmem_pgt +)); + +233 + } +} + +235 +VOID + + +236 + $_l_memy +( +VOID +) + +238 + `_l +(); + +239 + `_kmem +(); + +240 + } +} + + @alternate.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +31  + #ELILO_ALTK_VAR + +L +"EloA" + + ) + +36  +EFI_GUID + + gtk_guid +={0,}; + +55 +INTN + + +56 + $e_kl +( +CHAR16 + * +bufr +, +INTN + +size +) + +58 +EFI_STATUS + +us +; + +59 +INTN + +t + = -1; + +67 i( +size + < 4)  -1; + +72 +size +-=2; + +80 +us + = +RT +-> + `GVb +( +ELILO_ALTK_VAR +, & +tk_guid +, +NULL +, & +size +, +bufr +); + +81 i( + `EFI_ERROR +( +us +)) { + +82 + `DBG_PRT +(( +L +"هcsvb %s: %r", +ELILO_ALTK_VAR +, +us +)); + +85 i( +us + = +EFI_BUFFER_TOO_SMALL + +de_v +; + +99 i( +size + & 0x1) { + +100 + `Prt +( +L +"vid cڋ f %vb,sg vb\n", +ELILO_ALTK_VAR +); + +101  +de_v +; + +105 i( +size + =2 +de_v +; + +107 +bufr +[ +size +] = +CHAR_NULL +; + +109 + `VERB_PRT +(2, + `Prt +( +L +"foundɔNj vb %: %s\n", +ELILO_ALTK_VAR +, +bufr +)); + +111 +t + = 0; + +112 +de_v +: + +113 +us + = +RT +-> + `SVb +( +ELILO_ALTK_VAR +, & +tk_guid +, 0, 0, +NULL +); + +114 i( + `EFI_ERROR +( +us +)) { + +115 + `ERR_PRT +(( +L +"ك vb %s", +ELILO_ALTK_VAR +)); + +117  +t +; + +118 + } +} + + @bootparams.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +40 +VOID + * + +41 + $_bo_ms +( +CHAR16 + * +gs +, +memdesc_t + * +rd +, memdesc_* +vmcode +, +UINTN + * +cook +) + +47  + #BOOT_PARAM_MEMSIZE + 16384 + + ) + +48 +UINTN + +bpsize +, +cmdle_size +; + +49 +bo_ms_t + * +bp +; + +50 +CHAR8 + * + +; + +51 +CHAR16 + +ch +; + +59 +cmdle_size + = + `SL +( +gs +) + 1; + +60 +bpsize + = ( +bo_ms_t ++ +cmdle_size +; + +62 i( +bpsize + > +BOOT_PARAM_MEMSIZE +) { + +63 + `ERR_PRT +(( +L +"BOOT_PARAM_MEMSIZEosml,da %d bys", +bpsize +)); + +64  +NULL +; + +75 +bp + = ( +bo_ms_t + *) + `loc +( +BOOT_PARAM_MEMSIZE +, +EfiLdDa +); + +76 i( +bp + = +NULL +) { + +77 + `ERR_PRT +(( +L +"can'tllocate bootarams")); + +81 + `VERB_PRT +(3, + `Prt +( +L +"boمam@ 0x%lx\n", +bp +)); + +84 #ifde +CONFIG_64 + + +85 + + = (( +CHAR8 + *) +bp ++ +BOOT_PARAM_MEMSIZE + - +cmdle_size +; + +86 #i +defed + +CONFIG_32 + + +87 + + = (( +CHAR8 + *) +bp ++ +BOOT_PARAM_MEMSIZE + - 2048; + +97 + `Memt +( +bp +, 0, +BOOT_PARAM_MEMSIZE +); + +99 i( + `sysds__bo_ms +( +bp +, + +, +rd +, +vmcode +, +cook +) == -1)  0; + +106 +ch + = * +gs +++; + +107 i(! +ch +) ; + +108 * + +++ = +ch +; + +110 * + +++ = '\0'; + +112  +bp +; + +113 + } +} + +115 +VOID + + +116 + $_bo_ms +( +VOID + * +bp +) + +118 +bo_ms_t + * +_bp + = (bo_ms_*) +bp +; + +120 + `sysds__bo_ms +( +_bp +); + +122 + ` +( +_bp +); + +123 + } +} + + @chooser.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +31 #ifde +CONFIG_CHOOSER_SIMPLE + + +32  + ~"choors/sime.h +" + +35 #ifde +CONFIG_CHOOSER_TEXTMENU + + +36  + ~"choors/xtmu.h +" + +39  +choor_t + * + gchoors_b +[]={ + +40 #ifde +CONFIG_CHOOSER_SIMPLE + + +41 & +sime_choor +, + +43 #ifde +CONFIG_CHOOSER_TEXTMENU + + +44 & +xtmu_choor +, + +46 +NULL + + +64 +choor_func_t + * + gkl_choor +; + +66 +INTN + + +67 + $_choor +( +EFI_HANDLE + +dev +) + +69 +choor_t + ** +p +; + +70 +CHAR16 + * +choor_me + = +L +"none"; + +72 +kl_choor + = +NULL +; + +74  +p += +choors_b +; *p;++) { + +76 + `VERB_PRT +(4, + `Prt +( +L +"yg choo%s\n", (* +p +)-> +choor_me +)); + +78 i((* +p +)-> + `choor_obe +( +dev +) == 0) { + +82 i(! + `SCmp +( +o_t +. +choor +, (* +p +)-> +choor_me +)) { + +83 +kl_choor + = (* +p +)-> +choor_func +; + +84 +choor_me + = (* +p +)->chooser_name; + +88 i( +kl_choor + = +NULL +) { + +89 +kl_choor + = (* +p +)-> +choor_func +; + +90 +choor_me + = (* +p +)->chooser_name; + +95 i( +kl_choor +) { + +96 + `VERB_PRT +(2, + `Prt +( +L +"ed choo%s\n", +choor_me +)); + +100 + `ERR_PRT +(( +L +"No chooser selected. Impossibleoroceed")); + +102 + } +} + +104 +INTN + + +105 + $exi_choor +( +CHAR16 + * +me +) + +107 +choor_t + ** +p +; + +109  +p += +choors_b +; *p;++) { + +110 i(! + `SCmp +( +me +, (* +p +)-> +choor_me +))  0; + +113 + } +} + + @chooser.h + +26 #ide +__ELILO_CHOOSER_H__ + + +27  + #__ELILO_CHOOSER_H__ + + + ) + +29  +INTN + + tchoor_func_t +( + tCHAR16 + ** + tgv +, + tINTN + + tc +, INTN + tdex +, CHAR16 * + tkme +, CHAR16 * + tcmdle +); + +50 +CHAR16 + * + mchoor_me +; + +51 +INTN + (* +choor_obe +)( +EFI_HANDLE + + mdev +); + +52 +choor_func_t + * + mchoor_func +; + +53 } + tchoor_t +; + +55 +INTN + +_choor +( +EFI_HANDLE +); + +56 +INTN + +exi_choor +( +CHAR16 + * +me +); + +58 +choor_func_t + * +kl_choor +; + + @choosers/simple.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"vs.h +" + +33  +CHAR16 + ** + gt_gv +; + +35  +VOID + + +36 + $diy_b_fo +( +CHAR16 + * +me +) + +38 +CHAR16 + * +desc +; + +39 +CHAR16 + +rd_me +[ +CMDLINE_MAXLEN +]; + +40 +CHAR16 + +vmcode_me +[ +CMDLINE_MAXLEN +]; + +41 +CHAR16 + +tis_tmp +[ +CMDLINE_MAXLEN +]; + +42 +CHAR16 + +tis +[ +CMDLINE_MAXLEN +]; + +43 +CHAR16 + +kme +[ +FILENAME_MAXLEN +]; + +45 +desc + = + `fd_desti +( +me +); + +46 i( +desc +) { + +47 + `Prt +( +L +"des : %s\n", +desc +); + +50 +rd_me +[0] = +vmcode_me +[0] = +tis_tmp +[0] = +kme +[0] = +CHAR_NULL +; + +52 i( + `fd_b +( +me +, +kme +, +tis_tmp +, +rd_me +, +vmcode_me +) == -1) { + +53 + `SCpy +( +kme +, +me +); + +54 + `Prt +( +L +"\n"); + +56 + `sub_vs +( +tis_tmp +, +tis +, +CMDLINE_MAXLEN +); + +58 + `Prt +( +L +"cmdle: %%s\n", +kme +, +tis +); + +59 i( +rd_me +[0] + `Prt +( +L +"initrd : %s\n", initrd_name); + +60 i( +vmcode_me +[0] + `Prt +( +L +"vmcode : %s\n", vmcode_name); + +61 + } +} + +63  +VOID + + +64 + $t_fos +( +f +) + +66 +CHAR16 + * +cfig_fe +; + +67 +CHAR16 + +dth +[ +FILENAME_MAXLEN +]; + +68 +CHAR16 + * +bo_dev_me +; + +69 +UINT8 + +is_abs +; + +71 +bo_dev_me + = + `fs_bodev_me +(); + +72 +cfig_fe + = + `g_cfig_fe +(); + +74 + `fs_gdeu_th +( +dth +, +FILENAME_MAXLEN +); + +76 i( +f + || +o_t +. +vbo + > 0) + +77 + `Prt +( +L +"deu fth: %s:%s\n", +bo_dev_me +, +dth +); + +79 +is_abs + = +cfig_fe + && (cfig_fe[0] = +CHAR_BACKSLASH + || cfig_fe[0] = +CHAR_SLASH +) ? 1 : 0; + +81 i( +f + || +o_t +. +vbo + > 0) + +82 + `Prt +( +L +"cfig f : %s%s\n", +cfig_fe + && +is_abs + =0 ? +dth + : L"", config_file ? config_file : L"none used"); + +84 i( +t_gv +) { + +85 +CHAR16 + ** +p + = +t_gv +; + +86 + `Prt +( +L +"foundlternate default choice :"); + +87 * +p + + `Prt +( +L +" %s", *p++); + +88 + `Prt +( +L +"\n"); + +90 + } +} + +92  +VOID + + +93 + $t_hp +( +f +) + +95 i( +f + || +o_t +. +vbo + > 0) + +96 + `Prt +( +L +"commandist (must be first character):\n=:print deviceist, %%:print variableist, &:printaths, ?:help\nTAB:printabel information\n"); + +97 + } +} + +106  +INTN + + +107 + $_kl +( +CHAR16 + * +bufr +, +INTN + +size +) + +109  + #CHAR_CTRL_C + +L +'\003' + + ) + +110  + #CHAR_CTRL_D + +L +'\004' + + ) + +111  + #CHAR_CTRL_U + +L +'\025' + + ) + +113 +SIMPLE_INPUT_INTERFACE + * + + = +syab +-> +CIn +; + +114 +EFI_INPUT_KEY + +key +; + +115 +EFI_STATUS + +us +; + +116 +INTN + +pos + = 0, +t +; + +117 +INT8 + +f_time + = 1; + +122 + `t_hp +(0); + +124 + `t_fos +(0); + +126 +t +: + +127 +bufr +[ +pos +] = +CHAR_NULL +; + +129 + `Prt +( +L +"\nELILO bo: %s", +bufr +); + +133 i( +f_time + && ( +t += + `wa_timeout +( +o_t +. +timeout +)) != 1) { + +134  +t + == -1 ? -1: 0; + +136 +f_time + = 0; + +139 ( +us += + +-> + `RdKeySoke +(, & +key +)= +EFI_NOT_READY +); + +140 i( + `EFI_ERROR +( +us +)) { + +141 + `ERR_PRT +(( +L +"_kȻadkey: %r", +us +)); + +144  +key +. +UnicodeCh +) { + +145  +CHAR_TAB +: + +146 + `Prt +( +L +"\n"); + +147 i( +pos + == 0) { + +148 + `t_b_li +(); + +149 + `Prt +( +L +"(or kernel fileame: [[dev_name:/]path/]kernel_image cmdline options)\n"); + +151 +bufr +[ +pos +] = +CHAR_NULL +; + +152 + `diy_b_fo +( +bufr +); + +154  +t +; + +155  +L +'%': + +156 i( +pos +>0 +nm_ch +; + +157 + `Prt +( +L +"\n"); + +158 + `t_vs +(); + +159  +t +; + +160  +L +'?': + +161 i( +pos +>0 +nm_ch +; + +162 + `Prt +( +L +"\n"); + +163 + `t_hp +(1); + +164  +t +; + +165  +L +'&': + +166 i( +pos +>0 +nm_ch +; + +167 + `Prt +( +L +"\n"); + +168 + `t_fos +(1); + +169  +t +; + +170  +L +'=': + +171 i( +pos +>0 +nm_ch +; + +172 + `Prt +( +L +"\n"); + +173 + `t_devis +(); + +174  +t +; + +175  +CHAR_BACKSPACE +: + +176 i( +pos + == 0) ; + +177 +pos +--; + +178 + `Prt +( +L +"\b \b"); + +180  +CHAR_CTRL_U +: + +181  +pos +) { + +182 + `Prt +( +L +"\b \b"); + +183 +pos +--; + +186  +CHAR_CTRL_C +: + +187 +pos + = 0; + +188  +t +; + +189  +CHAR_LINEFEED +: + +190  +CHAR_CARRIAGE_RETURN +: + +191 +bufr +[ +pos +] = +CHAR_NULL +; + +192 + `Prt +( +L +"\n"); + +195 +nm_ch +: + +196 i( +key +. +UnicodeCh + = +CHAR_CTRL_D + || key. +SnCode + == 0x17 ) { + +197 + `Prt +( +L +"\nGiving uphen...\n"); + +200 i( +key +. +UnicodeCh + = +CHAR_NULL +) ; + +202 i( +pos + > +size +-1) ; + +204 +bufr +[ +pos +++] = +key +. +UnicodeCh +; + +207 + `Prt +( +L +"%c", +key +. +UnicodeCh +); + +211 + } +} + +213  +VOID + + +214 + $diy_mesge +( +VOID +) + +216 +fs_fd_t + +fd +; + +217 +EFI_STATUS + +us +; + +218 +INTN + +n +, +i +; + +219 +CHAR16 + * +fame +; + +220 +CHAR8 + +buf +[256]; + +222 i(( +fame + = + `g_mesge_fame +(0)= +NULL +) ; + +224 i(* +fame + = +CHAR_NULL +) ; + +226 + `VERB_PRT +(3, + `Prt +( +L +"ݒg mesgf%s\n", +fame +)); + +228 +us + = + `fs_ݒ +( +fame +, & +fd +); + +229 i( + `EFI_ERROR +( +us +)) { + +230 + `VERB_PRT +(3, + `Prt +( +L +"mesgf%n found\n", +fame +)); + +233 +n + = 256; + +234 + `Prt +( +L +"\n"); + +235 ( +us + = + `fs_ad +( +fd +, +buf +, & +n +)= +EFI_SUCCESS +) { + +237  +i +=0; i < +n +; i++) { + +238 + `Prt +( +L +"%c", ( +CHAR16 +) +buf +[ +i +]); + +240 i( +n + < 256) ; + +242 + `fs_o +( +fd +); + +243 + } +} + +245  +INTN + + +246 + $sime_choo +( +CHAR16 + ** +gv +, +INTN + +gc +, INTN +dex +, CHAR16 * +kme +, CHAR16 * +cmdle +) + +248  + #BOOT_IMG_STR + +L +"BOOT_IMAGE=" + + ) + +249 +CHAR16 + +bufr +[ +CMDLINE_MAXLEN +]; + +250 +CHAR16 + +t_bufr +[ +CMDLINE_MAXLEN +]; + +251 +CHAR16 + +rd_me +[ +CMDLINE_MAXLEN +]; + +252 +CHAR16 + +vmcode_me +[ +CMDLINE_MAXLEN +]; + +253 +CHAR16 + +gs +[ +CMDLINE_MAXLEN +]; + +254 +CHAR16 + +devme +[ +CMDLINE_MAXLEN +]; + +255 +CHAR16 + +dth +[ +FILENAME_MAXLEN +]; + +256 +CHAR16 + * +ash_pos +, * +c_pos +, * +backash_pos +; + +257 +UINTN + +n +; + +258 +INTN + +t +; + +260 +bufr +[0] = +t_bufr +[0] = +CHAR_NULL +; + +262 + `diy_mesge +(); + +264 +t +: + +265 +rd_me +[0] = +vmcode_me +[0] = +kme +[0] = +cmdle +[0] = +gs +[0] = +CHAR_NULL +; + +268 + `Memt +(& +o_t +. +img_t +, 0, (elilo_opt.img_opt)); + +273 i( +o_t +. +t_check + && + `e_kl +( +t_bufr +, (alt_buffer)) == 0) { + +274 +gc + = + `gify +( +t_bufr +,_bufr), +gv +); + +275 +t_gv + = +gv +; + +276 +dex + = 0; + +277 +gs +[0] = +rd_me +[0] = +vmcode_me +[0] = 0; + +282 +o_t +. +t_check + = 0; + +285 i( +o_t +. +om +) { + +286 +t + = + `_kl +( +bufr +, (buffer)); + +287 i( +t + == -1)  -1; + +288 +gc + = + `gify +( +bufr +,(bufr), +gv +); + +289 +dex + = 0; + +297 i( +t_bufr +[0] && +bufr +[0] = +CHAR_NULL +) { + +298 + `SCpy +( +bufr +, +t_bufr +); + +309 +t + = + `fd_b +(( +dex + < +gc +? +gv +[dex] : +NULL +, +kme +, +gs +, +rd_me +, +vmcode_me +); + +315 i( +t + == -1) { + +316 i(( +dex + < +gc +&& +gv +[index]) + +317 + `SCpy +( +kme +, +gv +[ +dex +]); + +319 + `SCpy +( +kme +, +o_t +. +deu_kl +); + +326 i( +gc + > 1+ +dex +) { + +328 ++ +dex + < +gc +) { + +329 + `SC +( +gs +, +L +" "); + +330 + `SC +( +gs +, +gv +[ +dex +]); + +337 i( +o_t +. +rd +[0] = +CHAR_NULL + && +rd_me +[0] != CHAR_NULL) { + +338 + `SCpy +( +o_t +. +rd +, +rd_me +); + +341 i( +o_t +. +vmcode +[0] = +CHAR_NULL + && +vmcode_me +[0] != CHAR_NULL) { + +342 + `SCpy +( +o_t +. +vmcode +, +vmcode_me +); + +345 + `VERB_PRT +(1, { + `Prt +( +L +"k i '%s'\n", +kme +); + +346 + `Prt +( +L +"gumt '%s'\n", +gs +); + +347 i( +o_t +. +rd +[0] + `Prt +( +L +"initrd is '%s'\n",lilo_opt.initrd); + +348 i( +o_t +. +vmcode +[0] + `Prt +( +L +"vmm is '%s'\n",lilo_opt.vmcode); + +351 i( +o_t +. +om + == 0) { + +353 + `Prt +( +L +"ELILO\n"); + +354 +t + = + `wa_timeout +( +o_t +. +day +); + +355 i( +t + != 0) { + +356 +o_t +. +om + = 1; + +357 +o_t +. +rd +[0] =lo_t. +vmcode +[0] = +CHAR_NULL +; + +358 +o_t +. +timeout + = +ELILO_TIMEOUT_INFINITY +; + +359  +t +; + +366 +ash_pos + = + `SChr +( +kme +, +L +'/'); + +367 +backash_pos + = + `SChr +( +kme +, +L +'\\'); + +368 +c_pos + = + `SChr +( +kme +, +L +':'); + +370 i( +backash_pos + && backash_po< +ash_pos +) slash_pos = backslash_pos; + +372 i( +c_pos + = +NULL + || ( +ash_pos + && (slash_pos < colon_pos))) { + +373 + `SCpy +( +devme +, + `fs_bodev_me +()); + +374 + `SC +( +devme +, +L +":"); + +377 i( +kme +[0] ! +L +'/' && kname[0] != L'\\') { + +378 + `fs_gdeu_th +( +dth +, +FILENAME_MAXLEN +); + +379 + `SC +( +devme +, +dth +); + +382 +devme +[0] = +CHAR_NULL +; + +388 +n + = + `SL +( +BOOT_IMG_STR +) + +389 + + `SL +( +devme +) + +391 + +o_t +. +vmcode +[0] ? + `SL +lo_t.vmcode: SL( +kme +) + +393 + + `SL +( +gs +); + +395 i( +n + > +CMDLINE_MAXLEN +-1) { + +396 + `ERR_PRT +(( +L +"rgumentsistooong cannot fit BOOT_IMAGE\n")); + +399 + `SCpy +( +cmdle +, +L +"BOOT_IMAGE="); + +400 + `SC +( +cmdle +, +devme +); + +401 i( +o_t +. +vmcode +[0]) + +402 + `SC +( +cmdle +, +o_t +. +vmcode +); + +404 + `SC +( +cmdle +, +kme +); + +405 + `SC +( +cmdle +, +L +" "); + +406 + `SC +( +cmdle +, +gs +); + +409 + } +} + +411  +INTN + + +412 + $sime_obe +( +EFI_HANDLE + +dev +) + +416 + } +} + +418 +choor_t + + gsime_choor +={ + +419 +L +"simple", + +420 +sime_obe +, + +421 +sime_choo + + + @choosers/simple.h + +26 #ide +__ELILO_CHOOSER_SIMPLE_H__ + + +27  + #__ELILO_CHOOSER_SIMPLE_H__ + + + ) + +29  + ~"fes.h +" + +31 +choor_t + +sime_choor +; + + @choosers/textmenu.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +31  + #MAX_LABELS + 64 + + ) + +32  + #MSGBUFLEN + 4096 + + ) + +34  +UINT8 + + gmsgbuf +[ +MSGBUFLEN +]; + +35  +CHAR16 + * + gbs +[ +MAX_LABELS +]; + +36  +CHAR16 + * + gdestis +[ +MAX_LABELS +]; + +37  +INTN + + gabs +; + +38  +INTN + + gCursRow +, + gCursC +, + gPromRow +, + gPromC +; + +39  +INTN + + gMuRow +, + gMuC +, + gMuWidth +, + gMuHeight +; + +40  +INTN + + gDiyPd +, + gCutAr +, + gPromAr +; + +41  +INTN + + gPromWidth +, + gMuHiAr +, + gMuLoAr +; + +42  +INTN + + gPromL +, + gMuAive +, + gMuF +; + +43  +CHAR16 + + gPromBuf +[ +CMDLINE_MAXLEN +]; + +45  + #DEF_ATTR + + `EFI_TEXT_ATTR +( +EFI_LIGHTGRAY +, +EFI_BLACK +) + + ) + +48  + #CˬSn +( +ST +-> +COut +-> + `CˬSn +(ST->COut) + + ) + +49  + #STextAr +( +a + +ST +-> +COut +-> + `SAribu +(ST->COut,) + + ) + +51  +INTN + + +52 + $tohex +( +INTN + +c +) + +54 i( +c + >= '0' && c <= '9') + +55  +c + - '0'; + +56 i( +c + >= 'A' && c <= 'F') + +57  +c + = c - 'A' + 10; + +58 i( +c + >= 'a' && c <= 'f') + +59  +c + = c - 'a' + 10; + +62 + } +} + +64  +VOID + + +65 + $t_msg +( +UINT8 + * +msg +) + +67 +INTN + +c +; + +69 +CursC + = +CursRow + = 0; + +70 +CutAr + = +DEF_ATTR +; + +71 + `STextAr +( +CutAr +); + +72 + `CˬSn +(); + +73 ( +c + = * +msg +++)) { + +75 i( +c + =0xda +BOXDRAW_DOWN_RIGHT +; + +76 i( +c + =0xc4 +BOXDRAW_HORIZONTAL +; + +77 i( +c + =0xbf +BOXDRAW_DOWN_LEFT +; + +78 i( +c + =0xb3 +BOXDRAW_VERTICAL +; + +79 i( +c + =0xd9 +BOXDRAW_UP_LEFT +; + +80 i( +c + =0xc0 +BOXDRAW_UP_RIGHT +; + +81 i( +c + =0xb4 +BOXDRAW_VERTICAL_LEFT +; + +82 i( +c + =0xc3 +BOXDRAW_VERTICAL_RIGHT +; + +83 i( +c + =0x1e +GEOMETRICSHAPE_UP_TRIANGLE +; + +84 i( +c + =0x1f +GEOMETRICSHAPE_DOWN_TRIANGLE +; + +85 i( +c + > 0x7f) c = '?'; + +88 i( +c + >= ' ') { + +89 + `Prt +( +L +"%c", +c +); + +90 +CursC +++; + +93  +c +) { + +97 +CursRow +++; + +98 +CursC + = 0; + +99 + `Prt +( +L +"\n"); + +102 +CursC + = +CursRow + = 0; + +103 + `CˬSn +(); + +106 i( +msg +[0] && msg[1]) { + +107 +INTN + +bg + = + `tohex +(* +msg +++); + +108 +INTN + +fg + = + `tohex +(* +msg +++); + +110 i( +bg + < 16 || +fg + < 16) { + +111 +CutAr + = + `EFI_TEXT_ATTR +( +fg +, +bg +); + +112 + `STextAr +( +CutAr +); + +117 i(! +DiyPd +) { + +118 i(! +PromRow +) { + +119 +PromRow + = +CursRow +; + +120 +PromC + = +CursC +; + +121 +PromAr + = +CutAr +; + +123 i(! +PromWidth +) + +124 +PromWidth + = +CursC + - +PromC +; + +129 i(! +DiyPd +) { + +130 i(! +MuRow +) { + +131 +MuRow + = +CursRow +; + +132 +MuC + = +CursC +; + +133 +MuLoAr + = +CutAr +; + +135 i(! +MuWidth +) { + +136 +MuWidth + = +CursC + - +MuC +; + +137 +MuHeight + = +CursRow + - +MuRow + + 1; + +138 +MuHiAr + = +CutAr +; + +144 + `Prt +( +L +"?"); + +145 +CursC +++; + +149 + } +} + +152  +VOID + + +153 + $t_om +( +VOID +) + +155 +INTN + +offt + = +PromL + > +PromWidth + - 1 ? PromptLen - PromptWidth + 1: 0; + +156 + `STextAr +( +PromAr +); + +157 + `PrtAt +( +PromC +, +PromRow +, +L +"%s%s", +PromBuf + + +offt +, L" \b"); + +158 + `STextAr +( +CutAr +); + +159 + } +} + +161  +VOID + + +162 + $t_mu +( +VOID +) + +164 +INTN + +i +, +j +; + +166  +i + = 0; i < +MuHeight +; i++) { + +167 +INTN + + + = ( +i + + +MuF + = +MuAive +? +MuHiAr +: +MuLoAr +; + +168 +CHAR16 + +desti +[80]; + +170  +j + = 0; j < +MuWidth +; j++) + +171 +desti +[ +j +] = ' '; + +172 +desti +[ +MuWidth +] = '\0'; + +173 i( +i + + +MuF + < +abs +) { + +174  +j + = 0; +destis +[ +i + + +MuF +][j] && j < +MuWidth +; j++) + +175 +desti +[ +j ++1] = +destis +[ +i + + +MuF +][j]; + +177 + `STextAr +( + +); + +178 + `PrtAt +( +MuC +, +MuRow + + +i +, +L +"%-.*s", +MuWidth +, +desti +); + +179 + `STextAr +( +CutAr +); + +181 + `t_om +(); + +182 + } +} + +184  +INTN + + +185 + $ad_mesge_fe +( +INTN + +msg +, +INT8 + * +buf +, INTN +max +) + +187 +CHAR16 + * +fame +; + +188 +fs_fd_t + +mesge_fd +; + +189 +EFI_STATUS + +us +; + +190 +INTN + +n + = +max +; + +192 i( +msg + > 10)  0; + +194 i(( +fame + = + `g_mesge_fame +( +msg +)= +NULL +) { + +195 + `VERB_PRT +(3, + `Prt +( +L +"no message file specified\n")); + +199 + `VERB_PRT +(3, + `Prt +( +L +"ݒg mesgf%s\n", +fame +)); + +201 +us + = + `fs_ݒ +( +fame +, & +mesge_fd +); + +202 i( + `EFI_ERROR +( +us +)) { + +203 + `VERB_PRT +(3, + `Prt +( +L +"mesgf%n found\n", +fame +)); + +207 +us + = + `fs_ad +( +mesge_fd +, +buf +, & +n +); + +208 i( + `EFI_ERROR +( +us +)) { + +209 + `VERB_PRT +(3, + `Prt +( +L +"Erroreading message file\n")); + +210 +n + = 0; + +213 + `fs_o +( +mesge_fd +); + +215 + `VERB_PRT +(3, + `Prt +( +L +"dڐadg mesgf%s\n", +fame +)); + +217  +n +; + +218 + } +} + +228  +INTN + + +229 + $_kl +( +CHAR16 + * +b +, +INTN + +lsize +) + +231  + #CHAR_CTRL_C + ( +L +'\003' + + ) + +232  + #CHAR_CTRL_D + ( +L +'\004' + + ) + +233  + #CHAR_CTRL_F + ( +L +'\006' + + ) + +234  + #CHAR_DEL + ( +L +'\177' + + ) + +235 +SIMPLE_INPUT_INTERFACE + * + + = +syab +-> +CIn +; + +236 +EFI_INPUT_KEY + +key +; + +237 +EFI_STATUS + +us +; + +238 +INT8 + +f_time + = 1; + +239 +INTN + +i +; + +240 +INT8 + + + = 0; + +242 +t +: + +243 +i + = + `ad_mesge_fe +(0, +msgbuf +, +MSGBUFLEN +-1); + +244 +msgbuf +[ +i +] = 0; + +245 + `t_msg +( +msgbuf +); + +246 +DiyPd + = 1; + +247 + `t_mu +(); + +248 +CutAr + = +PromAr +; + +249 + `STextAr +( +CutAr +); + +252 ( +us += + +-> + `RdKeySoke +(, & +key +)= +EFI_NOT_READY +); + +253 i( + `EFI_ERROR +( +us +)) { + +254 + `STextAr +( + `EFI_TEXT_ATTR +( +EFI_LIGHTGRAY +, +EFI_BLACK +)); + +255 + `CˬSn +(); + +256 + `ERR_PRT +(( +L +"_kȻadkey: %r", +us +)); + +259 i( +key +. +UnicodeCh + = +CHAR_CTRL_F +) { + +260 + + = 1; + +263 i( + +) { + +264 i( +key +. +UnicodeCh + >= '0' && key.UnicodeChar <= '9') { + +265 i( +key +. +UnicodeCh + == '0') + +266 +key +. +SnCode + = +SCAN_F10 +; + +268 +key +. +SnCode + = +SCAN_F1 + + key. +UnicodeCh + - '1'; + +269 +key +. +UnicodeCh + = 0; + +271 + + = 0; + +273 i( +key +. +SnCode + = +SCAN_UP +) { + +274 i( +MuAive +) + +275 +MuAive +--; + +278 i( +MuAive + < +MuF +) + +279 +MuF + = +MuAive +; + +280 + `t_mu +(); + +283 i( +key +. +SnCode + = +SCAN_DOWN +) { + +284 i( +MuAive + < +abs + - 1) + +285 +MuAive +++; + +288 i( +MuAive + > +MuF + + +MuHeight +) + +289 +MuF + = +MuAive + - +MuHeight + + 1; + +290 + `t_mu +(); + +293 i( +key +. +SnCode + > +SCAN_F1 + && key.SnCod< +SCAN_F10 +) { + +294 +i + = + `ad_mesge_fe +( +key +. +SnCode + - +SCAN_F1 + + 1, +msgbuf +, +MSGBUFLEN +-1); + +295 i( +i +) { + +296 +msgbuf +[ +i +] = 0; + +297 + `t_msg +( +msgbuf +); + +298 ( +us += + +-> + `RdKeySoke +(, & +key +)= +EFI_NOT_READY +); + +299  +t +; + +303  +key +. +UnicodeCh +) { + +305  +L +'?': + +306 + `Prt +( +L +"\n"); + +307 + `t_devis +(); + +308 +f_time + = 0; + +309  +t +; + +310  +CHAR_BACKSPACE +: + +311  +CHAR_DEL +: + +312 i( +PromL + == 0) ; + +313 +PromL +--; + +314 +PromBuf +[ +PromL +] = 0; + +315 i( +PromL + > +PromWidth +-2) + +316 + `t_om +(); + +318 + `Prt +( +L +"\b \b"); + +321  +CHAR_LINEFEED +: + +322  +CHAR_CARRIAGE_RETURN +: + +323 + `SCpy +( +b +, +bs +[ +MuAive +]); + +324 + `STextAr +( + `EFI_TEXT_ATTR +( +EFI_LIGHTGRAY +, +EFI_BLACK +)); + +325 + `CˬSn +(); + +329 i +key +. +UnicodeCh + = +CHAR_CTRL_D + + +330 || +key +. +UnicodeCh + = +CHAR_CTRL_C +) { + +331 + `STextAr +( + `EFI_TEXT_ATTR +( +EFI_LIGHTGRAY +, +EFI_BLACK +)); + +332 + `CˬSn +(); + +333 + `Prt +( +L +"\nGiving uphen...\n"); + +336 i( +key +. +UnicodeCh + = +CHAR_NULL +) ; + +338 i( +PromL + > +CMDLINE_MAXLEN +-1) ; + +340 i( +key +. +UnicodeCh + < ' ' || key.UnicodeChar > 0x7e) + +341 +key +. +UnicodeCh + = '?'; + +342 +PromBuf +[ +PromL +++] = +key +. +UnicodeCh +; + +343 +PromBuf +[ +PromL +] = 0; + +346 i( +PromL + > +PromWidth +-1) + +347 + `t_om +(); + +349 + `Prt +( +L +"%c", +key +. +UnicodeCh +); + +353 + } +} + +355 +INTN + + +356 + $xtmu_choo +( +CHAR16 + ** +gv +, +INTN + +gc +, INTN +dex +, CHAR16 * +kme +, CHAR16 * +cmdle +) + +358  + #BOOT_IMG_STR + +L +"BOOT_IMAGE=" + + ) + +359 +CHAR16 + +b +[ +CMDLINE_MAXLEN +]; + +360 +CHAR16 + +rd_me +[ +CMDLINE_MAXLEN +]; + +361 +CHAR16 + +vmcode_me +[ +CMDLINE_MAXLEN +]; + +362 +CHAR16 + +gs +[ +CMDLINE_MAXLEN +]; + +363 +CHAR16 + +devme +[ +CMDLINE_MAXLEN +]; + +364 +CHAR16 + +dth +[ +FILENAME_MAXLEN +]; + +365 +CHAR16 + * +ash_pos +, * +c_pos +, * +backash_pos +; + +366 +UINTN + +n +; + +367 +INTN + +t +; + +368 +VOID + * +hd + = +NULL +; + +372 +CursRow + = +CursC + = +PromRow + = +PromC + = 0; + +373 +MuRow + = +MuC + = +MuWidth + = +MuHeight + = 0; + +374 +DiyPd + = +CutAr + = +PromAr + = 0; + +375 +PromWidth + = +MuHiAr + = +MuLoAr + = 0; + +376 +PromL + = +MuAive + = +MuF + = 0; + +377 +PromBuf +[0] = +CHAR_NULL +; + +379 +abs + = 0; + +380  +abs + < +MAX_LABELS + && ( +hd + = + `g_xt_desti +(hd, +bs + +bs, +destis + +labels))) { + +381 i( +destis +[ +abs +][0] == 0) + +382 +destis +[ +abs +] = +bs +[nlabels]; + +383 +abs +++; + +385 +t +: + +386 +vmcode_me +[0] = +rd_me +[0] = +kme +[0] = +cmdle +[0] = +gs +[0] = +CHAR_NULL +; + +389 + `Memt +(& +o_t +. +img_t +, 0, (elilo_opt.img_opt)); + +391 i( +o_t +. +om +) { + +392 +t + = + `_kl +( +b +, (label)); + +393 i( +t + == -1)  -1; + +394 +gc + = + `gify +( +PromBuf +,(PromBuf), +gv +); + +395 +dex + = 0; + +401 i( +o_t +. +t_check + && + `e_kl +( +PromBuf +, (PromptBuf)) == 0) { + +402 +gc + = + `gify +( +PromBuf +,(PromBuf), +gv +); + +403 +dex + = 0; + +404 +b +[0] = +gs +[0] = +rd_me +[0] = +vmcode_me +[0] = 0; + +415 i( +b +[0]) + +416 +t + = + `fd_b +( +b +, +kme +, +gs +, +rd_me +, +vmcode_me +); + +418 +t + = + `fd_b +(( +dex + < +gc +? +gv +[dex] : +NULL +, +kme +, +gs +, +rd_me +, +vmcode_me +); + +424 i( +t + == -1) { + +425 i(( +dex + < +gc +&& +gv +[index]) + +426 + `SCpy +( +kme +, +gv +[ +dex +]); + +428 + `SCpy +( +kme +, +o_t +. +deu_kl +); + +435 i( +b +[0]) + +436 +dex +--; + +437 i( +gc + > 1+ +dex +) { + +439 ++ +dex + < +gc +) { + +440 + `SC +( +gs +, +L +" "); + +441 + `SC +( +gs +, +gv +[ +dex +]); + +448 i( +o_t +. +rd +[0] = +CHAR_NULL + && +rd_me +[0] != CHAR_NULL) { + +449 + `SCpy +( +o_t +. +rd +, +rd_me +); + +452 i( +o_t +. +vmcode +[0] = +CHAR_NULL + && +vmcode_me +[0] != CHAR_NULL) { + +453 + `SCpy +( +o_t +. +vmcode +, +vmcode_me +); + +456 + `VERB_PRT +(1, { + `Prt +( +L +"k i '%s'\n", +kme +); + +457 + `Prt +( +L +"gumt '%s'\n", +gs +); + +458 i( +o_t +. +rd +[0] + `Prt +( +L +"initrd is '%s'\n",lilo_opt.initrd); + +459 i( +o_t +. +vmcode +[0] + `Prt +( +L +"vmm is '%s'\n",lilo_opt.vmcode); + +462 i( +o_t +. +om + == 0) { + +464 + `Prt +( +L +"ELILO\n"); + +465 +t + = + `wa_timeout +( +o_t +. +day +); + +466 i( +t + != 0) { + +467 +o_t +. +om + = 1; + +468 +o_t +. +rd +[0] =lo_t. +vmcode +[0] = +CHAR_NULL +; + +469 +o_t +. +timeout + = +ELILO_TIMEOUT_INFINITY +; + +470  +t +; + +478 +ash_pos + = + `SChr +( +kme +, +L +'/'); + +479 +backash_pos + = + `SChr +( +kme +, +L +'\\'); + +480 +c_pos + = + `SChr +( +kme +, +L +':'); + +482 i( +backash_pos + && backash_po< +ash_pos +) slash_pos = backslash_pos; + +484 i( +c_pos + = +NULL + || ( +ash_pos + && (slash_pos < colon_pos))) { + +485 + `SCpy +( +devme +, + `fs_bodev_me +()); + +486 + `SC +( +devme +, +L +":"); + +489 i( +kme +[0] ! +L +'/' && kname[0] != L'\\') { + +490 + `fs_gdeu_th +( +dth +, +FILENAME_MAXLEN +); + +491 + `SC +( +devme +, +dth +); + +494 +devme +[0] = +CHAR_NULL +; + +500 +n + = + `SL +( +BOOT_IMG_STR +) + +501 + + `SL +( +devme +) + +502 + + `SL +( +kme +) + +503 + +o_t +. +vmcode +[0] ? + `SL +lo_t.vmcode: SL( +kme +) + +505 + + `SL +( +gs +); + +507 i( +n + > +CMDLINE_MAXLEN +-1) { + +508 + `STextAr +( + `EFI_TEXT_ATTR +( +EFI_LIGHTGRAY +, +EFI_BLACK +)); + +509 + `CˬSn +(); + +510 + `ERR_PRT +(( +L +"rgumentsistooong cannot fit BOOT_IMAGE\n")); + +513 + `SCpy +( +cmdle +, +L +"BOOT_IMAGE="); + +514 + `SC +( +cmdle +, +devme +); + +515 i( +o_t +. +vmcode +[0]) + +516 + `SC +( +cmdle +, +o_t +. +vmcode +); + +518 + `SC +( +cmdle +, +kme +); + +519 + `SC +( +cmdle +, +L +" "); + +520 + `SC +( +cmdle +, +gs +); + +522 + `VERB_PRT +(3, + `Prt +( +L +"f commdi'%s'\n", +cmdle +)); + +525 + } +} + +527  +INTN + + +528 + $xtmu_obe +( +EFI_HANDLE + +dev +) + +532 + } +} + +534 +choor_t + + gxtmu_choor +={ + +535 +L +"textmenu", + +536 +xtmu_obe +, + +537 +xtmu_choo + + + @choosers/textmenu.h + +26 #ide +__ELILO_CHOOSER_TEXTMENU_H__ + + +27  + #__ELILO_CHOOSER_TEXTMENU_H__ + + + ) + +29  + ~"fes.h +" + +31 +choor_t + +xtmu_choor +; + + @config.c + +29  + ~ + +30  + ~ + +31  + ~ + +33  + ~"o.h +" + +34  + ~"cfig.h +" + +41 #i +defed +( +CONFIG_64 +) + +42  + #ELILO_ARCH_DEFAULT_CONFIG + +L +"o-64.cf" + + ) + +43 #i +defed + ( +CONFIG_32 +) + +44  + #ELILO_ARCH_DEFAULT_CONFIG + +L +"o-32.cf" + + ) + +52  + #ELILO_DEFAULT_CONFIG + +L +"o.cf" + + ) + +54  + #MAX_STRING + +CMDLINE_MAXLEN + + + ) + +55  + #CONFIG_BUFSIZE + 512 + + ) + +63  + #MAX_MESSAGES + 13 + + ) + +65  + sbo_image + { + +66  +bo_image + * + mxt +; + +67 +CHAR16 + + mb +[ +MAX_STRING +]; + +68 +CHAR16 + + mkme +[ +FILENAME_MAXLEN +]; + +69 +CHAR16 + + mtis +[ +MAX_STRING +]; + +70 +CHAR16 + + mrd +[ +FILENAME_MAXLEN +]; + +71 +CHAR16 + + mvmcode +[ +FILENAME_MAXLEN +]; + +72 +CHAR16 + + mro +[ +FILENAME_MAXLEN +]; + +73 +CHAR16 + + mback +[ +MAX_STRING +]; + +74 +CHAR16 + + mdesti +[ +MAX_STRING +]; + +76 +UINTN + + mmdisk +; + +77 +UINTN + + madly +; + +78 +UINTN + + ml +; + +80 +sys_img_tis_t + + msys_img_ts +; + +81 } + tbo_image_t +; + +84 + mTOK_ERR +, + +85 + mTOK_EQUAL +, + +86 + mTOK_STR +, + +87 + mTOK_EOF + + +88 } + ttok_t +; + +95 +CHAR16 + + mro +[ +FILENAME_MAXLEN +]; + +96 +CHAR16 + + mrd +[ +FILENAME_MAXLEN +]; + +97 +CHAR16 + + mvmcode +[ +FILENAME_MAXLEN +]; + +98 +CHAR16 + + mtis +[ +MAX_STRING +]; + +99 +CHAR16 + + mdeu_image_me +[ +MAX_STRING +]; + +100 +CHAR16 + + mmesge_fe +[ +MAX_MESSAGES +][ +FILENAME_MAXLEN +]; + +101 +CHAR16 + + mchoor +[ +FILENAME_MAXLEN +]; + +102 +CHAR16 + + mcfig_fe +[ +FILENAME_MAXLEN +]; + +103 +bo_image_t + * + mdeu_image +; + +105 +UINTN + + madly +; + +110 +UINTN + + mt_check +; + +111 +UINTN + + mdebug +; + +112 +UINTN + + mday +; + +113 +UINTN + + mom +; + +114 +UINTN + + mtimeout +; + +115 +UINTN + + mvbo +; + +116 +UINTN + + medd30_no_f +; + +117 } + tglob_cfig_t +; + +123  + s_cfig_ti_group + { + +124  +_cfig_ti_group + * + mxt +; + +125 +cfig_ti_t + * + mtis +; + +126 +UINTN + + mrs +; + +127 } + tcfig_ti_group_t +; + +129  +ti_ai_t + + gdo_image +, + gdo_l +, + gdo_tis +; + +130  +INTN + +check_vbosy +( +VOID + *), +check_choor +(VOID *); + +132  +glob_cfig_t + + gglob_cfig +; + +137  +cfig_ti_t + + gglob_comm_tis +[]={ + +138 { +OPT_STR +, +OPT_GLOBAL +, +L +"deu", +NULL +, NULL, +glob_cfig +. +deu_image_me +}, + +139 { +OPT_NUM +, +OPT_GLOBAL +, +L +"timeout", +NULL +, NULL, & +glob_cfig +. +timeout +}, + +140 { +OPT_NUM +, +OPT_GLOBAL +, +L +"day", +NULL +, NULL, & +glob_cfig +. +day +}, + +141 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"debug", +NULL +, NULL, & +glob_cfig +. +debug +}, + +142 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"om", +NULL +, NULL, & +glob_cfig +. +om +}, + +143 { +OPT_NUM +, +OPT_GLOBAL +, +L +"vbo", +NULL +, +check_vbosy +, & +glob_cfig +. +vbo +}, + +144 { +OPT_FILE +, +OPT_GLOBAL +, +L +"ro", +NULL +, NULL, +glob_cfig +. +ro +}, + +145 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"ad-ly", +NULL +, NULL, & +glob_cfig +. +adly +}, + +146 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"ndd30", +NULL +, NULL, & +glob_cfig +. +edd30_no_f +}, + +147 { +OPT_CMD +, +OPT_GLOBAL +, +L +"nd", +NULL +, NULL, +glob_cfig +. +tis +}, + +148 { +OPT_FILE +, +OPT_GLOBAL +, +L +"rd", +NULL +, NULL, +glob_cfig +. +rd +}, + +149 { +OPT_FILE +, +OPT_GLOBAL +, +L +"vmm", +NULL +, NULL, +glob_cfig +. +vmcode +}, + +150 { +OPT_FILE +, +OPT_GLOBAL +, +L +"image", +do_image +, +NULL +, +t_offtof +( +kme +)}, + +151 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"checkt", +NULL +, NULL, & +glob_cfig +. +t_check +}, + +152 { +OPT_STR +, +OPT_GLOBAL +, +L +"choor", +NULL +, +check_choor +, +glob_cfig +. +choor +}, + +153 { +OPT_FILE +, +OPT_GLOBAL +, +L +"mesge", +NULL +, NULL, +glob_cfig +. +mesge_fe +[0]}, + +154 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f1", +NULL +, NULL, +glob_cfig +. +mesge_fe +[1]}, + +155 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f2", +NULL +, NULL, +glob_cfig +. +mesge_fe +[2]}, + +156 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f3", +NULL +, NULL, +glob_cfig +. +mesge_fe +[3]}, + +157 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f4", +NULL +, NULL, +glob_cfig +. +mesge_fe +[4]}, + +158 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f5", +NULL +, NULL, +glob_cfig +. +mesge_fe +[5]}, + +159 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f6", +NULL +, NULL, +glob_cfig +. +mesge_fe +[6]}, + +160 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f7", +NULL +, NULL, +glob_cfig +. +mesge_fe +[7]}, + +161 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f8", +NULL +, NULL, +glob_cfig +. +mesge_fe +[8]}, + +162 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f9", +NULL +, NULL, +glob_cfig +. +mesge_fe +[9]}, + +163 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f10", +NULL +, NULL, +glob_cfig +. +mesge_fe +[10]}, + +164 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f11", +NULL +, NULL, +glob_cfig +. +mesge_fe +[11]}, + +165 { +OPT_FILE +, +OPT_GLOBAL +, +L +"f12", +NULL +, NULL, +glob_cfig +. +mesge_fe +[12]} + +168  +cfig_ti_t + + gimage_comm_tis +[]={ + +169 { +OPT_FILE +, +OPT_IMAGE +, +L +"ro", +NULL +, NULL, +t_offtof +( +ro +)}, + +170 { +OPT_BOOL +, +OPT_IMAGE +, +L +"ad-ly", +NULL +, NULL, +t_offtof +( +adly +)}, + +171 { +OPT_CMD +, +OPT_IMAGE +, +L +"nd", +do_tis +, +NULL +, +t_offtof +( +tis +)}, + +172 { +OPT_CMD +, +OPT_IMAGE +, +L +"l", +do_l +, +NULL +, NULL}, + +173 { +OPT_FILE +, +OPT_IMAGE +, +L +"rd", +NULL +, NULL, +t_offtof +( +rd +)}, + +174 { +OPT_FILE +, +OPT_IMAGE +, +L +"vmm", +NULL +, NULL, +t_offtof +( +vmcode +)}, + +175 { +OPT_STR +, +OPT_IMAGE +, +L +"b", +NULL +, NULL, +t_offtof +( +b +)}, + +176 { +OPT_FILE +, +OPT_IMAGE +, +L +"image", +do_image +, +NULL +, +t_offtof +( +kme +)}, + +177 { +OPT_STR +, +OPT_IMAGE +, +L +"desti", +NULL +, NULL, +t_offtof +( +desti +)}, + +180  + #OPTION_IS_GLOBAL +( +p +()-> +sce + = +OPT_GLOBAL +) + + ) + +181  + #OPTION_IS_IMG_SYS +( +p +()-> +sce + = +OPT_IMAGE_SYS +) + + ) + +183  + #CHAR_EOF + ( +CHAR16 +)-1 + + ) + +184  + #CHAR_NUM0 + +L +'0' + + ) + +185  + #CHAR_NUM9 + +L +'9' + + ) + +187  +UINTN + + gle_num +; + +188  +INTN + + gback +; + +190  +cfig_ti_group_t + * + gglob_ti_li +; + +191  +cfig_ti_group_t + * + gimage_ti_li +; + +194  +cfig_ti_group_t + * + gcut_tis +; + +196  +bo_image_t + * + gimage_li +, * + gf_image +; + +197  +bo_image_t + * + gcut_img +; + +199  +INT8 + + gcfig_buf +[ +CONFIG_BUFSIZE +]; + +200  +UINTN + + gbuf_max +, + gbuf_pos +; + +202  +fs_fd_t + + gcfig_fd +; + +204  +VOID + + +205 + $cfig_r +( +CHAR16 + * +msg +,...) + +207 +va_li + + +; + +208 +UINTN + + `_IPrt + (UINTN, UINTN, +SIMPLE_TEXT_OUTPUT_INTERFACE + *, +CHAR16 + *, +CHAR8 + *, +va_li +); + +210 + `Prt +( +L +"ì%d: ", +le_num +); + +212 + `va_t +( + +, +msg +); + +213 + `_IPrt +(( +UINTN +)-1, (UINTN)-1, +syab +-> +COut +, +msg +, +NULL +, + +); + +214 + `va_d +( + +); + +215 + `Prt +( +L +"\n"); + +216 + } +} + +229  +CHAR16 + + +230 + $gc +( +VOID +) + +232 +EFI_STATUS + +us +; + +234 i( +buf_pos + =0 || buf_po= +buf_max +) { + +235 +buf_max + = +CONFIG_BUFSIZE +; + +236 +us + = + `fs_ad +( +cfig_fd +, +cfig_buf +, & +buf_max +); + +237 i( + `EFI_ERROR +( +us +|| +buf_max + =0 +CHAR_EOF +; + +239 +buf_pos + = 0; + +241  ( +CHAR16 +) +cfig_buf +[ +buf_pos +++]; + +242 + } +} + +249  +CHAR16 + + +250 + $xt +( +VOID +) + +252 +CHAR16 + +ch +; + +254 i( +back +) { + +255 +ch + = +back +; + +256 +back + = 0; + +257  +ch +; + +259  + `gc +(); + +260 + } +} + +265  +VOID + + +266 + $aga +( +CHAR16 + +ch +) + +268 i( +back +{ + `cfig_r +( +L +"config:gain invokedwice"); } + +269 +back + = +ch +; + +270 + } +} + +279  +cfig_ti_t + * + +280 + $fd_ti +( +cfig_ti_group_t + * +g +, +CHAR16 + * +r +) + +282 +cfig_ti_t + * +p + = +NULL +; + +283 +cfig_ti_t + * +d +; + +285  +g +) { + +286 +p + = +g +-> +tis +; + +287 +d + = +g +-> +tis ++g-> +rs +; + +289  +p + ! +d +) { + +290 i(! + `SCmp +( +r +, +p +-> +me +)) ; + +291 +p +++; + +293 +g + = g-> +xt +; + +295  +NULL +; + +296 + } +} + +307  +tok_t + + +308 + $g_tok +( +CHAR16 + * +r +, +UINTN + +maxn +) + +310 +INTN + +ch +, +esd +; + +311 +CHAR16 + * +he +; + +314 ( +ch + = + `xt +()), ch =' ' || ch ='\t' || ch ='\n'i(ch ='\n' +le_num +++; + +316 i( +ch + = +CHAR_EOF + +TOK_EOF +; + +318 i( +ch + != '#') ; + +321 ( +ch + = + `xt +()), ch !'\n'i(ch = +CHAR_EOF + +TOK_EOF +; + +322 +le_num +++; + +324 i( +ch + ='=' +TOK_EQUAL +; + +326 i( +ch + == '"') { + +327 +he + = +r +; + +328  +he +- +r + < +maxn +) { + +329 i(( +ch + = + `xt +()= +CHAR_EOF +) { + +330 + `cfig_r +( +L +"EOF in quoted string"); + +331  +TOK_ERR +; + +333 i( +ch + == '"') { + +334 * +he + = 0; + +335  +TOK_STR +; + +337 i( +ch + == '\\') { + +338 +ch + = + `xt +(); + +339 i( +ch + != '"' && ch != '\\' && ch != '\n') { + +340 + `cfig_r +( +L +"Bad use of \\ in quoted string"); + +341  +TOK_ERR +; + +343 i( +ch + == '\n') ; + +345 ( +ch + = + `xt +()), ch == ' ' || ch == '\t'); + +346 i(! +ch +) ; + +347 + `aga +( +ch +); + +348 +ch + = ' '; + +352 i( +ch + == '\n' || ch == '\t') { + +353 + `cfig_r +( +L +"\\nnd \\treotllowed in quoted strings"); + +354  +TOK_ERR +; + +356 * +he +++ = +ch +; + +358 + `cfig_r +( +L +"Quoted string isooong"); + +359  +TOK_ERR +; + +360 + } +} + +362 + ghe + = +r +; + +363 + gesd + = 0; + +365  + ghe +- + gr + < + gmaxn +) { + +366 i( + gesd +) { + +367 i( + gch + = +CHAR_EOF +) { + +368 +cfig_r +( +L +"\\recedes EOF"); + +369  + gTOK_ERR +; + +371 i( + gch + ='\n' +le_num +++; + +372 * + ghe +++ = +ch + == '\t' ? ' ' : ch; + +373 + gesd + = 0; + +376 i( + gch + =' ' || +ch + == '\t' || ch == '\n' || ch == '#' || + +377 +ch + ='=' || ch = +CHAR_EOF +) { + +378 +aga +( +ch +); + +379 * + ghe + = 0; + +380  + gTOK_STR +; + +382 i(!( + gesd + = ( +ch + ='\\'))* +he +++ = ch; + +384 + gch + = +xt +(); + +386 +cfig_r +( +L +"Token isooong"); + +387  + gTOK_ERR +; + +390  +INTN + + +391 + $image_check +( +bo_image_t + * +img +) + +393 +bo_image_t + * +b +; + +395 i( +img + = +NULL +)  -1; + +398 i( +img +-> +b +[0] == '\0') { + +399 + `cfig_r +( +L +"image hasoabel"); + +404  +b += +image_li +; b; b = b-> +xt +) { + +405 i( +img + = +b +) ; + +406 i(! + `SCmp +( +img +-> +b +, +b +->label)) { + +407 + `cfig_r +( +L +"imagwhab %ady defed", +img +-> +b +); + +412 + } +} + +414  +INTN + + +415 + $glob_check +( +VOID +) + +418 + } +} + +420  +INTN + + +421 + $f_check +( +VOID +) + +423 +bo_image_t + * +b +; + +425 i( +glob_cfig +. +deu_image_me +[0]) { + +426  +b += +image_li +; b; b = b-> +xt +) { + +427 i(! + `SCmp +( +b +-> +b +, +glob_cfig +. +deu_image_me +) +found +; + +429 + `cfig_r +( +L +"deu imag'%s' defed ", +glob_cfig +. +deu_image_me +); + +432 +glob_cfig +. +deu_image + = +f_image +; + +434 +found +: + +435 +glob_cfig +. +deu_image + = +b +; + +437 + } +} + +449  +le + +VOID + * + +450 + $adju_por +( +cfig_ti_t + * +p +) + +455 i( + `OPTION_IS_GLOBAL +( +p +)-> +da +; + +457 i( + `OPTION_IS_IMG_SYS +( +p +) ( +VOID + *)(( +UINTN +)& +cut_img +-> +sys_img_ts + +-> +da +); + +459  ( +VOID + *)(( +UINTN +) +cut_img + + +p +-> +da +); + +460 + } +} + +465  +INTN + + +466 + $do_image +( +cfig_ti_t + * +p +, +VOID + * +r +) + +468 +bo_image_t + * +img +; + +477 i( +cut_img +) { + +478 i( + `image_check +( +cut_img +) == -1)  -1; + +479 } i( + `glob_check +() == -1)  -1; + +481 +img + = ( +bo_image_t + *) + `loc +((bo_image_t), +EfiLdDa +); + +482 i( +img + = +NULL +)  -1; + +484 + `Memt +( +img +, 0, ( +bo_image_t +)); + +486 + `DBG_PRT +(( +L +"mu dimag %s", ( +CHAR16 + *) +r +)); + +489 + `SCpy +( +img +-> +kme +, +r +); + +492 +cut_tis + = +image_ti_li +; + +495 i( +image_li + = +NULL + +f_image + = +img +; + +500 i( +image_li + = +NULL +) + +501 +image_li + = +img +; + +503 +bo_image_t + * +p + = +image_li +; + +505  +p +-> +xt +) + +506 +p + =-> +xt +; + +507 +p +-> +xt + = +img +; + +511 +cut_img + = +img +; + +514 + } +} + +521  +INTN + + +522 + $do_boޗn +( +cfig_ti_t + * +p +) + +524 +INT8 + * +buf +; + +526 +buf + = + `adju_por +( +p +); + +528 i( +p +-> +ai +-> + `ai +, +NULL +); + +531 * +buf + = 1; + +534 + } +} + +542  +INTN + + +543 + $do_l +( +cfig_ti_t + * +p +, +VOID + * +r +) + +548 + `SCpy +( +cut_img +-> +tis +, +r +); + +550 +cut_img +-> +l + = 1; + +553 + } +} + +555  +INTN + + +556 + $do_tis +( +cfig_ti_t + * +p +, +VOID + * +r +) + +559 i( +cut_img +-> +l +)  0; + +564 + `SCpy +( +cut_img +-> +tis +, +r +); + +567 + } +} + +569  +INTN + + +570 + $do_numic +( +cfig_ti_t + * +p +) + +572 +CHAR16 + +numr +[ +MAX_STRING +]; + +573 +CHAR16 + * +r +; + +574 +tok_t + +tok +; + +575 +UINTN + * +buf +; + +576 +UINTN + +tmp +; + +581 +tok + = + `g_tok +( +numr +, +MAX_STRING +); + +582 i( +tok + ! +TOK_EQUAL +) { + +583 + `cfig_r +( +L +"Oi %exqu sig+ vue", +p +-> +me +); + +591 +tok + = + `g_tok +( +numr +, +MAX_STRING +); + +592 i( +tok + ! +TOK_STR +) { + +593 + `cfig_r +( +L +"Oi %exvue", +p +-> +me +); + +596 +r + = +numr +; + +601 i( +p +-> +ai +-> + `ai +, +r +); + +606 i( +p +-> +da + = +NULL +)  0; + +608 +buf + = ( +UINTN + *) + `adju_por +( +p +); + +610 * +r + && *> +CHAR_NUM0 + && *< +CHAR_NUM9 +) str++; + +611 i(* +r +) { + +612 + `cfig_r +( +L +"%iexgumidecim vue", +p +-> +me +); + +616 +tmp + = + `Atoi +( +numr +); + +618 i( +p +-> +check + &&-> + `check +(& +tmp +) == -1)  -1; + +624 i(* +buf +) { + +625 + `cfig_r +( +L +"ti %iady defed ithicڋxt", +p +-> +me +); + +629 * +buf + = +tmp +; + +632 + } +} + +634  +INTN + + +635 + $check_vbosy +( +VOID + * +da +) + +637 +UINTN + * +v + = (UINTN *) +da +; + +639 i(* +v + > 5) { + +640 + `cfig_r +( +L +"Vbosyev mu b [0-5]nd %d", * +v +); + +645 + } +} + +652  +INTN + + +653 + $check_choor +( +VOID + * +da +) + +655 +CHAR16 + * +choor + = (CHAR16 *) +da +; + +657 i( + `exi_choor +( +choor +) == -1) { + +658 + `cfig_r +( +L +"choo%iunknown\n", +choor +); + +662 + } +} + +665  +INTN + + +666 + $do_rg_ce +( +cfig_ti_t + * +p +, +CHAR16 + * +r +, +UINTN + +maxn +, CHAR16 * +msg +) + +668 +tok_t + +tok +; + +669 +CHAR16 + * +buf +; + +674 +tok + = + `g_tok +( +r +, +maxn +); + +675 i( +tok + ! +TOK_EQUAL +) { + +676 + `cfig_r +( +L +"Oi %exqu sig+ %s", +p +-> +me +, +msg +); + +683 +tok + = + `g_tok +( +r +, +maxn +); + +684 i( +tok + ! +TOK_STR +) { + +685 + `cfig_r +( +L +"Oi %ex%s", +p +-> +me +, +msg +); + +693 i( +p +-> +ai +-> + `ai +, +r +); + +698 i( +p +-> +da + = +NULL +)  0; + +700 +buf + = + `adju_por +( +p +); + +702 i(* +buf + ! +CHAR_NULL +) { + +703 + `cfig_r +( +L +"'%s'̗dy defed", +p +-> +me +); + +706 i( +p +-> +check + &&-> + `check +( +r +) == -1)  -1; + +711 + `SCpy +( +buf +, +r +); + +714 + } +} + +716  +INTN + + +717 + $do_rg +( +cfig_ti_t + * +p +) + +719 +CHAR16 + +r +[ +MAX_STRING +]; + +721  + `do_rg_ce +( +p +, +r +, +MAX_STRING +, +L +"string"); + +722 + } +} + +724  +INTN + + +725 + $do_fe +( +cfig_ti_t + * +p +) + +727 +CHAR16 + +r +[ +FILENAME_MAXLEN +]; + +729  + `do_rg_ce +( +p +, +r +, +FILENAME_MAXLEN +, +L +"filename"); + +730 + } +} + +733  +INTN + + +734 + $do_cmd +( +cfig_ti_t + * +p +) + +736 +CHAR16 + +r +[ +CMDLINE_MAXLEN +]; + +737  + `do_rg_ce +( +p +, +r +, +CMDLINE_MAXLEN +, +L +"kernel options"); + +738 + } +} + +741 +INTN + + +742 + $cfig_r +( +VOID +) + +744 +CHAR16 + +r +[ +MAX_STRING +]; + +745 +INTN + +t + = -1; + +746 +tok_t + +tok +; + +747 +cfig_ti_t + * +p +; + +750 +tok + = + `g_tok +( +r +, +MAX_STRING +); + +752 i( +tok + = +TOK_EOF +) ; + +754 i( +tok + = +TOK_ERR +)  -1; + +756 i( +p + = + `fd_ti +( +cut_tis +, +r +)= +NULL +) { + +757 + `cfig_r +( +L +"Unkowti %s", +r +); + +762 +t + = -1; + +764  +p +-> +ty +) { + +765  +OPT_BOOL +: + +766 +t + = + `do_boޗn +( +p +); + +768  +OPT_STR +: + +769 +t + = + `do_rg +( +p +); + +771  +OPT_NUM +: + +772 +t + = + `do_numic +( +p +); + +774  +OPT_FILE +: + +775 +t + = + `do_fe +( +p +); + +777  +OPT_CMD +: + +778 +t + = + `do_cmd +( +p +); + +781 + `cfig_r +( +L +"Unkowtiځy %d", +p +-> +ty +); + +783 i( +t + =-1 +r +; + +785 i( +cut_img +) { + +786 +t + = + `image_check +( +cut_img +); + +788 + `cfig_r +( +L +"No image defined !"); + +790 i( +t + =0軈 + `f_check +(); + +791 +r +: + +792  +t +; + +793 + } +} + +795  +VOID + + +796 + $upde_o_t +( +VOID +) + +803 i( +glob_cfig +. +t_check + +o_t +.alt_check = 1; + +805 i( +glob_cfig +. +debug + +o_t +.debug = 1; + +806 i( +glob_cfig +. +om + +o_t +.prompt = 1; + +813 i( +glob_cfig +. +vbo + && +o_t +.verbose == 0) + +814 +o_t +. +vbo + = +glob_cfig +.verbose; + +816 i( +glob_cfig +. +choor +[0] && +o_t +.chooser[0] == 0) + +817 + `SCpy +( +o_t +. +choor +, +glob_cfig +.chooser); + +823 i( +glob_cfig +. +edd30_no_f + && +o_t +.edd30_no_force == 0) + +824 +o_t +. +edd30_no_f + = 1; + +830 i( +glob_cfig +. +day + && +o_t +. +day_t + == 0) + +831 +o_t +. +day + = +glob_cfig +.delay; + +834 +o_t +. +timeout + = +glob_cfig +.timeout; + +837 + } +} + +843 +CHAR16 + * + +844 + $g_cfig_fe +( +VOID +) + +846  +glob_cfig +. +cfig_fe +[0] ? glob_cfig.cfig_f: +NULL +; + +847 + } +} + +849 +EFI_STATUS + + +850 + $ad_cfig +( +CHAR16 + * +fame +) + +852 +EFI_STATUS + +us +; + +853 +INTN + +t +; + +855 i( +fame + = +NULL + +EFI_INVALID_PARAMETER +; + +857 + `VERB_PRT +(3, + `Prt +( +L +"yg cfig f%s\n", +fame +)); + +859 + `SCpy +( +glob_cfig +. +cfig_fe +, +fame +); + +861 +us + = + `fs_ݒ +( +fame +, & +cfig_fd +); + +862 i( + `EFI_ERROR +( +us +)) { + +863 + `VERB_PRT +(3, + `Prt +( +L +" ocfig f%s\n", +fame +)); + +864  +us +; + +869 +le_num + = 1; + +871 +t + = + `cfig_r +(); + +873 + `fs_o +( +cfig_fd +); + +875 + `DBG_PRT +(( +L +"donearsing config file\n")); + +877 i( +t + !0 +EFI_INVALID_PARAMETER +; + +879 + `upde_o_t +(); + +881  +EFI_SUCCESS +; + +882 + } +} + +884 +VOID + + +885 + $t_b_li +( +VOID +) + +887 +bo_image_t + * +img +, * +d + = +glob_cfig +. +deu_image +; + +889 i( +d + + `Prt +( +L +"\t%s\n", d-> +b +); + +891  +img + = +image_li +; img; img = img-> +xt +) { + +892 i( +img + ! +d + + `Prt +( +L +"\t%s\n", img-> +b +); + +894 + } +} + +902 +VOID + * + +903 + $g_xt_desti +( +VOID + * +ev +, +CHAR16 + ** +b +, CHAR16 ** +desti +) + +905 +bo_image_t + * +img + = (bo_image_*) +ev +; + +907 i( +img + = +NULL +) + +908 +img + = +image_li +; + +910 +img + = img-> +xt +; + +912 i( +img +) { + +913 * +b + = +img +->label; + +914 * +desti + = +img +->description; + +915  (*) +img +; + +918  +NULL +; + +919 + } +} + +925 +CHAR16 + * + +926 + $fd_desti +( +CHAR16 + * +b +) + +928 +bo_image_t + * +img +; + +931  +img + = +image_li +; img; img = img-> +xt +) { + +932 i( + `SiCmp +( +img +-> +b +,abel) == 0) { + +933  +img +-> +desti +; + +936  +NULL +; + +937 + } +} + +939 +INTN + + +940 + $fd_b +( +CHAR16 + * +b +, CHAR16 * +kme +, CHAR16 * +tis +, CHAR16 * +rd +, CHAR16 * +vmcode +) + +942 +bo_image_t + * +img +; + +944 i( +b + = +NULL +) { + +945 i( +glob_cfig +. +deu_image + = +NULL +)  -1; + +946 +img + = +glob_cfig +. +deu_image +; + +947  +found +; + +950 +tis +[0] = 0; + +953  +img + = +image_li +; img; img = img-> +xt +) { + +954 i( + `SiCmp +( +img +-> +b +,abel) == 0) { + +955  +found +; + +961 i( +glob_cfig +. +ro +[0]) { + +962 + `SCpy +( +tis +, +L +"oot="); + +963 + `SC +( +tis +, +glob_cfig +. +ro +); + +966 i( +glob_cfig +. +tis +[0]) { + +967 + `SC +( +tis +, +L +" "); + +968 + `SC +( +tis +, +glob_cfig +.options); + +970 i( +glob_cfig +. +adly + + `SC +( +tis +, +L +"o"); + +972 i( +glob_cfig +. +rd +[0] + `SCpy +(initrd, global_config.initrd); + +973 i( +glob_cfig +. +vmcode +[0] + `SCpy +(vmcode, global_config.vmcode); + +976 +o_t +. +sys_img_ts + = +NULL +; + +979 +found +: + +980 + `SCpy +( +kme +, +img +->kname); + +987 i( +img +-> +l + == 0) { + +988 i( +img +-> +ro +[0] || +glob_cfig +.root[0]) { + +989 + `SC +( +tis +, +L +"root="); + +990 + `SC +( +tis +, +img +-> +ro +[0] ? img->ro : +glob_cfig +.root); + +993 i( +img +-> +tis +[0] || +glob_cfig +.options[0]) { + +994 + `SC +( +tis +, +L +" "); + +995 + `SC +( +tis +, +img +->tis[0] ? img->tis: +glob_cfig +.options); + +997 i( +img +-> +adly + || +glob_cfig +.readonly) { + +998 + `SC +( +tis +, +L +"o"); + +1002 + `SCpy +( +tis +, +img +->options); + +1006 i( +img +-> +rd +[0]) + +1007 + `SCpy +( +rd +, +img +->initrd); + +1008 i( +glob_cfig +. +rd +[0]) + +1009 + `SCpy +( +rd +, +glob_cfig +.initrd); + +1011 i( +img +-> +vmcode +[0]) + +1012 + `SCpy +( +vmcode +, +img +->vmcode); + +1013 i( +glob_cfig +. +vmcode +[0]) + +1014 + `SCpy +( +vmcode +, +glob_cfig +.vmcode); + +1019 +o_t +. +sys_img_ts + = & +img +->sys_img_opts; + +1021 + `DBG_PRT +(( +L +"b %s: kme=%tis=%rd=%vmcode=%s", +img +-> +b +, +kme +, +tis +, +rd +, +vmcode +)); + +1024 + } +} + +1026  +VOID + + +1027 + $t_tis +( +cfig_ti_group_t + * +g +, +BOOLEAN + +f +) + +1029 +cfig_ti_t + * +d +, * +p +; + +1030 +CHAR16 + * +r +; + +1032  +g +) { + +1033 +p + = +g +-> +tis +; + +1034 +d + = +g +-> +tis ++g-> +rs +; + +1035  +p + ! +d +) { + +1036 +r + = +NULL +; + +1037  +p +-> +ty +) { + +1038  +OPT_BOOL +: + +1039 +r + = +L +"%s"; + +1041  +OPT_STR + : + +1042 +r + = +L +"%s=string"; + +1044  +OPT_FILE + : + +1045 +r + = +L +"%s=filename"; + +1047  +OPT_CMD + : + +1048 +r + = +L +"%s=kernel_options"; + +1050  +OPT_NUM + : + +1051 +r + = +L +"%s=number"; + +1056 i( +r + && +f + = +FALSE + + `Prt +( +L +", "); + +1057 i( +r + + `Prt +(r, +p +-> +me +); + +1058 +f + = +FALSE +; + +1059 +p +++; + +1061 +g + = g-> +xt +; + +1063 + } +} + +1066 +VOID + + +1067 + $t_cfig_tis +( +VOID +) + +1069 + `Prt +( +L +"Global options supported:\n"); + +1071 + `t_tis +( +glob_ti_li +, +TRUE +); + +1072 + `Prt +( +L +"\n\n"); + +1074 + `Prt +( +L +"Image options supported:\n"); + +1075 + `t_tis +( +image_ti_li +, +TRUE +); + +1076 + `Prt +( +L +"\n"); + +1077 + } +} + +1084 +CHAR16 + * + +1085 + $g_mesge_fame +( +INTN + +which +) + +1087 i( +which + < 0 || which > +MAX_MESSAGES + +NULL +; + +1088  +glob_cfig +. +mesge_fe +[ +which +]; + +1089 + } +} + +1091 +INTN + + +1092 + $gi_cfig_tis +( +cfig_ti_t + * +t +, +UINTN + +n +, +cfig_ti_group_sce_t + +group +) + +1094 +cfig_ti_group_t + * +wg +, ** +g +; + +1096 i( +t + = +NULL + || +n + =0 || ( +group + ! +OPTIONS_GROUP_GLOBAL + && grou! +OPTIONS_GROUP_IMAGE +))  -1; + +1098 + `VERB_PRT +(3, + `Prt +( +L +"gig %d oiڠf grou%s\n", +n +, +group + = +OPTIONS_GROUP_GLOBAL + ? L"global" : L"image")); + +1100 +wg + = + `loc +(( +cfig_ti_group_t +), +EfiLdDa +); + +1101 i( +wg + = +NULL +)  -1; + +1103 +g + = +group + = +OPTIONS_GROUP_GLOBAL + ? & +glob_ti_li + : & +image_ti_li +; + +1105 i(* +g +(*g)-> +xt +) grp = &(*grp)->next; + +1107 +wg +-> +tis + = +t +; + +1108 +wg +-> +xt + = +NULL +; + +1109 +wg +-> +rs + = +n +; + +1111 i(* +g +) { + +1112 (* +g +)-> +xt + = +wg +; + +1114 * +g + = +wg +; + +1117 + } +} + +1122 +INTN + + +1123 + $cfig_ +( +VOID +) + +1125 +INTN + +t +; + +1127 +t + = + `gi_cfig_tis +( +glob_comm_tis +, + +1128 ( +glob_comm_tis +)/( +cfig_ti_t +), + +1129 +OPTIONS_GROUP_GLOBAL +); + +1130 i( +t + == -1)  -1; + +1132 +t + = + `gi_cfig_tis +( +image_comm_tis +, + +1133 ( +image_comm_tis +)/( +cfig_ti_t +), + +1134 +OPTIONS_GROUP_IMAGE +); + +1136 +cut_tis + = +glob_ti_li +; + +1138  +t +; + +1139 + } +} + + @config.h + +26 #ide +__ELILO_CONFIG_H__ + + +27  + #__ELILO_CONFIG_H__ + + + ) + +29  + #t_offtof +( +t +(&(( +bo_image_t + *)(0x0))->t) + + ) + +31 um { + mOPT_NOTUSED +, + mOPT_STR +, + mOPT_CMD +, + mOPT_BOOL +, + mOPT_NUM +, + mOPT_FILE + } + tcfig_ti_ty_t +; + +33 um { + mOPT_GLOBAL +, + +34 + mOPT_IMAGE +, + +35 + mOPT_IMAGE_SYS + + +36 } + tcfig_ti_sce_t +; + +38 um { + mOPTIONS_GROUP_GLOBAL +, + +39 + mOPTIONS_GROUP_IMAGE +, + +40 } + tcfig_ti_group_sce_t +; + +42  + g_cfig_ti_t +; + +43  +INTN + + tti_ai_t +( + t_cfig_ti_t + *, + tVOID + *); + +45  + s_cfig_ti_t + { + +46 +cfig_ti_ty_t + + mty +; + +47 +cfig_ti_sce_t + + msce +; + +48 +CHAR16 + * + mme +; + +49 +ti_ai_t + * + mai +; + +50 +INTN + (* +check +)(*); + +51 +VOID + * + mda +; + +52 } + tcfig_ti_t +; + +54 +INTN + +gi_cfig_tis +( +cfig_ti_t + * +t +, +UINTN + +rs +, +cfig_ti_group_sce_t +); + + @devschemes/simple.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"fes.h +" + +32  + #NAMING_SCHEME + +L +"sime" + + ) + +35 +INT8 + + mty +; + +36 +INT8 + + msubty +; + +37 +INTN + (* +devi_func +)( +devi_t + * + mdev +, +EFI_DEVICE_PATH + * + mdp +); + +38 } + tdevis_tys_t +; + +41  +UINT32 + + gi_cou +, + gscsi_cou +, + gt_cou +; + +43  +INTN + + +44 + $i_devi +( +devi_t + * +dev +, +EFI_DEVICE_PATH + * +dp +) + +48 +dev +-> +me +[0] = +L +'a'; + +49 +dev +-> +me +[1] = +L +'t'; + +50 +dev +-> +me +[2] = +L +'a'; + +51 +dev +-> +me +[3] = +L +'p'; + +52 +dev +-> +me +[4] = +L +'i'; + +54 + `SPrt +( +dev +-> +me ++5, +FILEOPS_DEVNAME_MAXLEN +-5-1, +L +"%d", +i_cou +); + +55 +i_cou +++; + +58 + } +} + +60  +INTN + + +61 + $scsi_devi +( +devi_t + * +dev +, +EFI_DEVICE_PATH + * +dp +) + +65 +dev +-> +me +[0] = +L +'s'; + +66 +dev +-> +me +[1] = +L +'c'; + +67 +dev +-> +me +[2] = +L +'s'; + +68 +dev +-> +me +[3] = +L +'i'; + +70 + `SPrt +( +dev +-> +me ++4, +FILEOPS_DEVNAME_MAXLEN +-4-1, +L +"%d", +scsi_cou +); + +71 +scsi_cou +++; + +74 + } +} + +76  +INTN + + +77 + $twk_devi +( +devi_t + * +dev +, +EFI_DEVICE_PATH + * +dp +) + +81 +dev +-> +me +[0] = +L +'n'; + +82 +dev +-> +me +[1] = +L +'e'; + +83 +dev +-> +me +[2] = +L +'t'; + +85 + `SPrt +( +dev +-> +me ++3, +FILEOPS_DEVNAME_MAXLEN +-3-1, +L +"%d", +t_cou +); + +86 +t_cou +++; + +89 + } +} + +94  +devis_tys_t + + gdev_tys +[]={ + +95 { +MESSAGING_DEVICE_PATH +, +MSG_ATAPI_DP +, +i_devi +}, + +96 { +MESSAGING_DEVICE_PATH +, +MSG_SCSI_DP +, +scsi_devi +}, + +97 { +MESSAGING_DEVICE_PATH +, +MSG_MAC_ADDR_DP +, +twk_devi +}, + +98 { 0, 0 , +NULL +} + +101  +INTN + + +102 + $sime_scheme +( +devi_t + * +b +, +UINTN + +n +) + +104 +EFI_DEVICE_PATH + * +dp1 +, * +dp +; + +105 +devis_tys_t + * +p +; + +106 +UINTN + +i +; + +117 i( +o_t +. +edd30_ + == 0) { + +118 + `VERB_PRT +(4, + `Prt +( +L +"%deviamg schemly wkwh EDD3.0bd\n", +NAMING_SCHEME +)); + +122  +i +=0; i < +n +; i++) { + +123 +dp + = + `DeviPhFromHd +( +b +[ +i +]. +dev +); + +124 i( +dp + = +NULL +) { + +125 + `ERR_PRT +(( +L +" g devih f devi %d", +i +)); + +128 +dp1 + = +dp + = + `UackDeviPh +(dp); + +130 ! + `IsDeviPhEnd +( +dp +)) { + +131 +p + = +dev_tys +; + +132  +p +-> +ty +) { + +133 i +p +-> +ty + = + `DeviPhTy +( +dp +) + +134 && +p +-> +subty + = + `DeviPhSubTy +( +dp +)) { + +135 (* +p +-> +devi_func +)( +b ++ +i +, +dp +); + +136  +de +; + +139 +p +++; + +141 +dp + = + `NextDeviPhNode +(dp); + +143 +de +: + +144 + `FePo +( +dp1 +); + +147 + } +} + +149 +devme_scheme_t + + gsime_devme_scheme +={ + +150 +NAMING_SCHEME +, + +151 +sime_scheme + + + @elf.h + +29 #ide +__LINUX_ELF_H__ + + +30  + #__LINUX_ELF_H__ + + + ) + +36  + ~ + +39  +UINT32 + + tElf32_Addr +; + +40  +UINT16 + + tElf32_Hf +; + +41  +UINT32 + + tElf32_Off +; + +42  +INT32 + + tElf32_Swd +; + +43  +UINT32 + + tElf32_Wd +; + +46  +UINT64 + + tElf64_Addr +; + +47  +UINT16 + + tElf64_Hf +; + +48  +INT16 + + tElf64_SHf +; + +49  +UINT64 + + tElf64_Off +; + +50  +INT64 + + tElf64_Swd +; + +51  +UINT64 + + tElf64_Wd +; + +54  + #PT_NULL + 0 + + ) + +55  + #PT_LOAD + 1 + + ) + +56  + #PT_DYNAMIC + 2 + + ) + +57  + #PT_INTERP + 3 + + ) + +58  + #PT_NOTE + 4 + + ) + +59  + #PT_SHLIB + 5 + + ) + +60  + #PT_PHDR + 6 + + ) + +61  + #PT_LOPROC + 0x70000000 + + ) + +62  + #PT_HIPROC + 0x7fffffff + + ) + +63  + #PT_MIPS_REGINFO + 0x70000000 + + ) + +66  + #EF_MIPS_NOREORDER + 0x00000001 + + ) + +67  + #EF_MIPS_PIC + 0x00000002 + + ) + +68  + #EF_MIPS_CPIC + 0x00000004 + + ) + +69  + #EF_MIPS_ARCH + 0xf0000000 + + ) + +72  + #ET_NONE + 0 + + ) + +73  + #ET_REL + 1 + + ) + +74  + #ET_EXEC + 2 + + ) + +75  + #ET_DYN + 3 + + ) + +76  + #ET_CORE + 4 + + ) + +77  + #ET_LOPROC + 0xff00 + + ) + +78  + #ET_HIPROC + 0xffff + + ) + +81  + #EM_NONE + 0 + + ) + +82  + #EM_M32 + 1 + + ) + +83  + #EM_SPARC + 2 + + ) + +84  + #EM_386 + 3 + + ) + +85  + #EM_68K + 4 + + ) + +86  + #EM_88K + 5 + + ) + +87  + #EM_486 + 6 + + ) + +88  + #EM_860 + 7 + + ) + +90  + #EM_MIPS + 8 + + ) + +92  + #EM_MIPS_RS4_BE + 10 + + ) + +94  + #EM_PARISC + 15 + + ) + +96  + #EM_SPARC32PLUS + 18 + + ) + +98  + #EM_PPC + 20 + + ) + +100  + #EM_SH + 42 + + ) + +102  + #EM_SPARCV9 + 43 + + ) + +104  + #EM_IA_64 + 50 + + ) + +110  + #EM_ALPHA + 0x9026 + + ) + +114  + #DT_NULL + 0 + + ) + +115  + #DT_NEEDED + 1 + + ) + +116  + #DT_PLTRELSZ + 2 + + ) + +117  + #DT_PLTGOT + 3 + + ) + +118  + #DT_HASH + 4 + + ) + +119  + #DT_STRTAB + 5 + + ) + +120  + #DT_SYMTAB + 6 + + ) + +121  + #DT_RELA + 7 + + ) + +122  + #DT_RELASZ + 8 + + ) + +123  + #DT_RELAENT + 9 + + ) + +124  + #DT_STRSZ + 10 + + ) + +125  + #DT_SYMENT + 11 + + ) + +126  + #DT_INIT + 12 + + ) + +127  + #DT_FINI + 13 + + ) + +128  + #DT_SONAME + 14 + + ) + +129  + #DT_RPATH + 15 + + ) + +130  + #DT_SYMBOLIC + 16 + + ) + +131  + #DT_REL + 17 + + ) + +132  + #DT_RELSZ + 18 + + ) + +133  + #DT_RELENT + 19 + + ) + +134  + #DT_PLTREL + 20 + + ) + +135  + #DT_DEBUG + 21 + + ) + +136  + #DT_TEXTREL + 22 + + ) + +137  + #DT_JMPREL + 23 + + ) + +138  + #DT_LOPROC + 0x70000000 + + ) + +139  + #DT_HIPROC + 0x7fffffff + + ) + +140  + #DT_MIPS_RLD_VERSION + 0x70000001 + + ) + +141  + #DT_MIPS_TIME_STAMP + 0x70000002 + + ) + +142  + #DT_MIPS_ICHECKSUM + 0x70000003 + + ) + +143  + #DT_MIPS_IVERSION + 0x70000004 + + ) + +144  + #DT_MIPS_FLAGS + 0x70000005 + + ) + +145  + #RHF_NONE + 0 + + ) + +146  + #RHF_HARDWAY + 1 + + ) + +147  + #RHF_NOTPOT + 2 + + ) + +148  + #DT_MIPS_BASE_ADDRESS + 0x70000006 + + ) + +149  + #DT_MIPS_CONFLICT + 0x70000008 + + ) + +150  + #DT_MIPS_LIBLIST + 0x70000009 + + ) + +151  + #DT_MIPS_LOCAL_GOTNO + 0x7000000a + + ) + +152  + #DT_MIPS_CONFLICTNO + 0x7000000b + + ) + +153  + #DT_MIPS_LIBLISTNO + 0x70000010 + + ) + +154  + #DT_MIPS_SYMTABNO + 0x70000011 + + ) + +155  + #DT_MIPS_UNREFEXTNO + 0x70000012 + + ) + +156  + #DT_MIPS_GOTSYM + 0x70000013 + + ) + +157  + #DT_MIPS_HIPAGENO + 0x70000014 + + ) + +158  + #DT_MIPS_RLD_MAP + 0x70000016 + + ) + +161  + #STB_LOCAL + 0 + + ) + +162  + #STB_GLOBAL + 1 + + ) + +163  + #STB_WEAK + 2 + + ) + +165  + #STT_NOTYPE + 0 + + ) + +166  + #STT_OBJECT + 1 + + ) + +167  + #STT_FUNC + 2 + + ) + +168  + #STT_SECTION + 3 + + ) + +169  + #STT_FILE + 4 + + ) + +171  + #ELF32_ST_BIND +( +x +((x>> 4) + + ) + +172  + #ELF32_ST_TYPE +( +x +(((x& 0xf) + + ) + +176  + #AT_NULL + 0 + + ) + +177  + #AT_IGNORE + 1 + + ) + +178  + #AT_EXECFD + 2 + + ) + +179  + #AT_PHDR + 3 + + ) + +180  + #AT_PHENT + 4 + + ) + +181  + #AT_PHNUM + 5 + + ) + +182  + #AT_PAGESZ + 6 + + ) + +183  + #AT_BASE + 7 + + ) + +184  + #AT_FLAGS + 8 + + ) + +185  + #AT_ENTRY + 9 + + ) + +186  + #AT_NOTELF + 10 + + ) + +187  + #AT_UID + 11 + + ) + +188  + #AT_EUID + 12 + + ) + +189  + #AT_GID + 13 + + ) + +190  + #AT_EGID + 14 + + ) + +191  + #AT_PLATFORM + 15 + + ) + +192  + #AT_HWCAP + 16 + + ) + +194  + sdymic +{ + +195 +Elf32_Swd + + md_g +; + +197 +Elf32_Swd + + md_v +; + +198 +Elf32_Addr + + md_r +; + +199 } + md_un +; + +200 } + tElf32_Dyn +; + +203 +Elf64_Wd + + md_g +; + +205 +Elf64_Wd + + md_v +; + +206 +Elf64_Wd + + md_r +; + +207 } + md_un +; + +208 } + tElf64_Dyn +; + +211  + #ELF32_R_SYM +( +x +((x>> 8) + + ) + +212  + #ELF32_R_TYPE +( +x +((x& 0xff) + + ) + +214  + #R_386_NONE + 0 + + ) + +215  + #R_386_32 + 1 + + ) + +216  + #R_386_PC32 + 2 + + ) + +217  + #R_386_GOT32 + 3 + + ) + +218  + #R_386_PLT32 + 4 + + ) + +219  + #R_386_COPY + 5 + + ) + +220  + #R_386_GLOB_DAT + 6 + + ) + +221  + #R_386_JMP_SLOT + 7 + + ) + +222  + #R_386_RELATIVE + 8 + + ) + +223  + #R_386_GOTOFF + 9 + + ) + +224  + #R_386_GOTPC + 10 + + ) + +225  + #R_386_NUM + 11 + + ) + +227  + #R_MIPS_NONE + 0 + + ) + +228  + #R_MIPS_16 + 1 + + ) + +229  + #R_MIPS_32 + 2 + + ) + +230  + #R_MIPS_REL32 + 3 + + ) + +231  + #R_MIPS_26 + 4 + + ) + +232  + #R_MIPS_HI16 + 5 + + ) + +233  + #R_MIPS_LO16 + 6 + + ) + +234  + #R_MIPS_GPREL16 + 7 + + ) + +235  + #R_MIPS_LITERAL + 8 + + ) + +236  + #R_MIPS_GOT16 + 9 + + ) + +237  + #R_MIPS_PC16 + 10 + + ) + +238  + #R_MIPS_CALL16 + 11 + + ) + +239  + #R_MIPS_GPREL32 + 12 + + ) + +242  + #R_MIPS_UNUSED1 + 13 + + ) + +243  + #R_MIPS_UNUSED2 + 14 + + ) + +244  + #R_MIPS_UNUSED3 + 15 + + ) + +245  + #R_MIPS_SHIFT5 + 16 + + ) + +246  + #R_MIPS_SHIFT6 + 17 + + ) + +247  + #R_MIPS_64 + 18 + + ) + +248  + #R_MIPS_GOT_DISP + 19 + + ) + +249  + #R_MIPS_GOT_PAGE + 20 + + ) + +250  + #R_MIPS_GOT_OFST + 21 + + ) + +255  + #R_MIPS_GOTHI16 + 22 + + ) + +256  + #R_MIPS_GOTLO16 + 23 + + ) + +257  + #R_MIPS_SUB + 24 + + ) + +258  + #R_MIPS_INSERT_A + 25 + + ) + +259  + #R_MIPS_INSERT_B + 26 + + ) + +260  + #R_MIPS_DELETE + 27 + + ) + +261  + #R_MIPS_HIGHER + 28 + + ) + +262  + #R_MIPS_HIGHEST + 29 + + ) + +267  + #R_MIPS_CALLHI16 + 30 + + ) + +268  + #R_MIPS_CALLLO16 + 31 + + ) + +272  + #R_MIPS_LOVENDOR + 100 + + ) + +273  + #R_MIPS_HIVENDOR + 127 + + ) + +279  + #R_SPARC_NONE + 0 + + ) + +280  + #R_SPARC_8 + 1 + + ) + +281  + #R_SPARC_16 + 2 + + ) + +282  + #R_SPARC_32 + 3 + + ) + +283  + #R_SPARC_DISP8 + 4 + + ) + +284  + #R_SPARC_DISP16 + 5 + + ) + +285  + #R_SPARC_DISP32 + 6 + + ) + +286  + #R_SPARC_WDISP30 + 7 + + ) + +287  + #R_SPARC_WDISP22 + 8 + + ) + +288  + #R_SPARC_HI22 + 9 + + ) + +289  + #R_SPARC_22 + 10 + + ) + +290  + #R_SPARC_13 + 11 + + ) + +291  + #R_SPARC_LO10 + 12 + + ) + +292  + #R_SPARC_GOT10 + 13 + + ) + +293  + #R_SPARC_GOT13 + 14 + + ) + +294  + #R_SPARC_GOT22 + 15 + + ) + +295  + #R_SPARC_PC10 + 16 + + ) + +296  + #R_SPARC_PC22 + 17 + + ) + +297  + #R_SPARC_WPLT30 + 18 + + ) + +298  + #R_SPARC_COPY + 19 + + ) + +299  + #R_SPARC_GLOB_DAT + 20 + + ) + +300  + #R_SPARC_JMP_SLOT + 21 + + ) + +301  + #R_SPARC_RELATIVE + 22 + + ) + +302  + #R_SPARC_UA32 + 23 + + ) + +303  + #R_SPARC_PLT32 + 24 + + ) + +304  + #R_SPARC_HIPLT22 + 25 + + ) + +305  + #R_SPARC_LOPLT10 + 26 + + ) + +306  + #R_SPARC_PCPLT32 + 27 + + ) + +307  + #R_SPARC_PCPLT22 + 28 + + ) + +308  + #R_SPARC_PCPLT10 + 29 + + ) + +309  + #R_SPARC_10 + 30 + + ) + +310  + #R_SPARC_11 + 31 + + ) + +311  + #R_SPARC_WDISP16 + 40 + + ) + +312  + #R_SPARC_WDISP19 + 41 + + ) + +313  + #R_SPARC_7 + 43 + + ) + +314  + #R_SPARC_5 + 44 + + ) + +315  + #R_SPARC_6 + 45 + + ) + +319  + #HWCAP_SPARC_FLUSH + 1 + + ) + +320  + #HWCAP_SPARC_STBAR + 2 + + ) + +321  + #HWCAP_SPARC_SWAP + 4 + + ) + +322  + #HWCAP_SPARC_MULDIV + 8 + + ) + +323  + #HWCAP_SPARC_V9 + 16 + + ) + +329  + #R_68K_NONE + 0 + + ) + +330  + #R_68K_32 + 1 + + ) + +331  + #R_68K_16 + 2 + + ) + +332  + #R_68K_8 + 3 + + ) + +333  + #R_68K_PC32 + 4 + + ) + +334  + #R_68K_PC16 + 5 + + ) + +335  + #R_68K_PC8 + 6 + + ) + +336  + #R_68K_GOT32 + 7 + + ) + +337  + #R_68K_GOT16 + 8 + + ) + +338  + #R_68K_GOT8 + 9 + + ) + +339  + #R_68K_GOT32O + 10 + + ) + +340  + #R_68K_GOT16O + 11 + + ) + +341  + #R_68K_GOT8O + 12 + + ) + +342  + #R_68K_PLT32 + 13 + + ) + +343  + #R_68K_PLT16 + 14 + + ) + +344  + #R_68K_PLT8 + 15 + + ) + +345  + #R_68K_PLT32O + 16 + + ) + +346  + #R_68K_PLT16O + 17 + + ) + +347  + #R_68K_PLT8O + 18 + + ) + +348  + #R_68K_COPY + 19 + + ) + +349  + #R_68K_GLOB_DAT + 20 + + ) + +350  + #R_68K_JMP_SLOT + 21 + + ) + +351  + #R_68K_RELATIVE + 22 + + ) + +356  + #R_ALPHA_NONE + 0 + + ) + +357  + #R_ALPHA_REFLONG + 1 + + ) + +358  + #R_ALPHA_REFQUAD + 2 + + ) + +359  + #R_ALPHA_GPREL32 + 3 + + ) + +360  + #R_ALPHA_LITERAL + 4 + + ) + +361  + #R_ALPHA_LITUSE + 5 + + ) + +362  + #R_ALPHA_GPDISP + 6 + + ) + +363  + #R_ALPHA_BRADDR + 7 + + ) + +364  + #R_ALPHA_HINT + 8 + + ) + +365  + #R_ALPHA_SREL16 + 9 + + ) + +366  + #R_ALPHA_SREL32 + 10 + + ) + +367  + #R_ALPHA_SREL64 + 11 + + ) + +368  + #R_ALPHA_OP_PUSH + 12 + + ) + +369  + #R_ALPHA_OP_STORE + 13 + + ) + +370  + #R_ALPHA_OP_PSUB + 14 + + ) + +371  + #R_ALPHA_OP_PRSHIFT + 15 + + ) + +372  + #R_ALPHA_GPVALUE + 16 + + ) + +373  + #R_ALPHA_GPRELHIGH + 17 + + ) + +374  + #R_ALPHA_GPRELLOW + 18 + + ) + +375  + #R_ALPHA_IMMED_GP_16 + 19 + + ) + +376  + #R_ALPHA_IMMED_GP_HI32 + 20 + + ) + +377  + #R_ALPHA_IMMED_SCN_HI32 + 21 + + ) + +378  + #R_ALPHA_IMMED_BR_HI32 + 22 + + ) + +379  + #R_ALPHA_IMMED_LO32 + 23 + + ) + +380  + #R_ALPHA_COPY + 24 + + ) + +381  + #R_ALPHA_GLOB_DAT + 25 + + ) + +382  + #R_ALPHA_JMP_SLOT + 26 + + ) + +383  + #R_ALPHA_RELATIVE + 27 + + ) + +387  + #EF_ALPHA_32BIT + 1 + + ) + +390  + sf32_l + { + +391 +Elf32_Addr + + mr_offt +; + +392 +Elf32_Wd + + mr_fo +; + +393 } + tElf32_R +; + +395  + sf64_l + { + +396 +Elf64_Addr + + mr_offt +; + +397 +Elf64_Wd + + mr_fo +; + +398 } + tElf64_R +; + +400  + sf32_ +{ + +401 +Elf32_Addr + + mr_offt +; + +402 +Elf32_Wd + + mr_fo +; + +403 +Elf32_Swd + + mr_addd +; + +404 } + tElf32_Ra +; + +406  + sf64_ + { + +407 +Elf64_Addr + + mr_offt +; + +408 +Elf64_Wd + + mr_fo +; + +409 +Elf64_Wd + + mr_addd +; + +410 } + tElf64_Ra +; + +412  + sf32_sym +{ + +413 +Elf32_Wd + + m_me +; + +414 +Elf32_Addr + + m_vue +; + +415 +Elf32_Wd + + m_size +; + +416  + m_fo +; + +417  + m_h +; + +418 +Elf32_Hf + + m_shndx +; + +419 } + tElf32_Sym +; + +421  + sf64_sym + { + +422 +Elf32_Wd + + m_me +; + +423  + m_fo +; + +424  + m_h +; + +425 +Elf64_Hf + + m_shndx +; + +426 +Elf64_Addr + + m_vue +; + +427 +Elf64_Wd + + m_size +; + +428 } + tElf64_Sym +; + +431  + #EI_NIDENT + 16 + + ) + +433  + sf32_hdr +{ + +434  + me_idt +[ +EI_NIDENT +]; + +435 +Elf32_Hf + + me_ty +; + +436 +Elf32_Hf + + me_mache +; + +437 +Elf32_Wd + + me_vsi +; + +438 +Elf32_Addr + + me_y +; + +439 +Elf32_Off + + me_phoff +; + +440 +Elf32_Off + + me_shoff +; + +441 +Elf32_Wd + + me_ags +; + +442 +Elf32_Hf + + me_ehsize +; + +443 +Elf32_Hf + + me_phtsize +; + +444 +Elf32_Hf + + me_phnum +; + +445 +Elf32_Hf + + me_shtsize +; + +446 +Elf32_Hf + + me_shnum +; + +447 +Elf32_Hf + + me_shdx +; + +448 } + tElf32_Ehdr +; + +450  + sf64_hdr + { + +451  + me_idt +[16]; + +452 +Elf64_SHf + + me_ty +; + +453 +Elf64_Hf + + me_mache +; + +454 +INT32 + + me_vsi +; + +455 +Elf64_Addr + + me_y +; + +456 +Elf64_Off + + me_phoff +; + +457 +Elf64_Off + + me_shoff +; + +458 +INT32 + + me_ags +; + +459 +Elf64_SHf + + me_ehsize +; + +460 +Elf64_SHf + + me_phtsize +; + +461 +Elf64_SHf + + me_phnum +; + +462 +Elf64_SHf + + me_shtsize +; + +463 +Elf64_SHf + + me_shnum +; + +464 +Elf64_SHf + + me_shdx +; + +465 } + tElf64_Ehdr +; + +469  + #PF_R + 0x4 + + ) + +470  + #PF_W + 0x2 + + ) + +471  + #PF_X + 0x1 + + ) + +473  + sf32_phdr +{ + +474 +Elf32_Wd + + mp_ty +; + +475 +Elf32_Off + + mp_offt +; + +476 +Elf32_Addr + + mp_vaddr +; + +477 +Elf32_Addr + + mp_ddr +; + +478 +Elf32_Wd + + mp_fesz +; + +479 +Elf32_Wd + + mp_memsz +; + +480 +Elf32_Wd + + mp_ags +; + +481 +Elf32_Wd + + mp_ign +; + +482 } + tElf32_Phdr +; + +484  + sf64_phdr + { + +485 +INT32 + + mp_ty +; + +486 +INT32 + + mp_ags +; + +487 +Elf64_Off + + mp_offt +; + +488 +Elf64_Addr + + mp_vaddr +; + +489 +Elf64_Addr + + mp_ddr +; + +490 +Elf64_Wd + + mp_fesz +; + +491 +Elf64_Wd + + mp_memsz +; + +492 +Elf64_Wd + + mp_ign +; + +493 } + tElf64_Phdr +; + +496  + #SHT_NULL + 0 + + ) + +497  + #SHT_PROGBITS + 1 + + ) + +498  + #SHT_SYMTAB + 2 + + ) + +499  + #SHT_STRTAB + 3 + + ) + +500  + #SHT_RELA + 4 + + ) + +501  + #SHT_HASH + 5 + + ) + +502  + #SHT_DYNAMIC + 6 + + ) + +503  + #SHT_NOTE + 7 + + ) + +504  + #SHT_NOBITS + 8 + + ) + +505  + #SHT_REL + 9 + + ) + +506  + #SHT_SHLIB + 10 + + ) + +507  + #SHT_DYNSYM + 11 + + ) + +508  + #SHT_NUM + 12 + + ) + +509  + #SHT_LOPROC + 0x70000000 + + ) + +510  + #SHT_HIPROC + 0x7fffffff + + ) + +511  + #SHT_LOUSER + 0x80000000 + + ) + +512  + #SHT_HIUSER + 0xffffffff + + ) + +513  + #SHT_MIPS_LIST + 0x70000000 + + ) + +514  + #SHT_MIPS_CONFLICT + 0x70000002 + + ) + +515  + #SHT_MIPS_GPTAB + 0x70000003 + + ) + +516  + #SHT_MIPS_UCODE + 0x70000004 + + ) + +519  + #SHF_WRITE + 0x1 + + ) + +520  + #SHF_ALLOC + 0x2 + + ) + +521  + #SHF_EXECINSTR + 0x4 + + ) + +522  + #SHF_MASKPROC + 0xf0000000 + + ) + +523  + #SHF_MIPS_GPREL + 0x10000000 + + ) + +526  + #SHN_UNDEF + 0 + + ) + +527  + #SHN_LORESERVE + 0xff00 + + ) + +528  + #SHN_LOPROC + 0xff00 + + ) + +529  + #SHN_HIPROC + 0xff1f + + ) + +530  + #SHN_ABS + 0xfff1 + + ) + +531  + #SHN_COMMON + 0xfff2 + + ) + +532  + #SHN_HIRESERVE + 0xffff + + ) + +533  + #SHN_MIPS_ACCOMON + 0xff00 + + ) + +536 +Elf32_Wd + + msh_me +; + +537 +Elf32_Wd + + msh_ty +; + +538 +Elf32_Wd + + msh_ags +; + +539 +Elf32_Addr + + msh_addr +; + +540 +Elf32_Off + + msh_offt +; + +541 +Elf32_Wd + + msh_size +; + +542 +Elf32_Wd + + msh_lk +; + +543 +Elf32_Wd + + msh_fo +; + +544 +Elf32_Wd + + msh_addlign +; + +545 +Elf32_Wd + + msh_tsize +; + +546 } + tElf32_Shdr +; + +548  + sf64_shdr + { + +549 +Elf32_Wd + + msh_me +; + +550 +Elf32_Wd + + msh_ty +; + +551 +Elf64_Wd + + msh_ags +; + +552 +Elf64_Addr + + msh_addr +; + +553 +Elf64_Off + + msh_offt +; + +554 +Elf64_Wd + + msh_size +; + +555 +Elf32_Wd + + msh_lk +; + +556 +Elf32_Wd + + msh_fo +; + +557 +Elf64_Wd + + msh_addlign +; + +558 +Elf64_Wd + + msh_tsize +; + +559 } + tElf64_Shdr +; + +561  + #EI_MAG0 + 0 + + ) + +562  + #EI_MAG1 + 1 + + ) + +563  + #EI_MAG2 + 2 + + ) + +564  + #EI_MAG3 + 3 + + ) + +565  + #EI_CLASS + 4 + + ) + +566  + #EI_DATA + 5 + + ) + +567  + #EI_VERSION + 6 + + ) + +568  + #EI_PAD + 7 + + ) + +570  + #ELFMAG0 + 0x7 + + ) + +571  + #ELFMAG1 + 'E' + + ) + +572  + #ELFMAG2 + 'L' + + ) + +573  + #ELFMAG3 + 'F' + + ) + +574  + #ELFMAG + "\177ELF" + + ) + +575  + #SELFMAG + 4 + + ) + +577  + #ELFCLASSNONE + 0 + + ) + +578  + #ELFCLASS32 + 1 + + ) + +579  + #ELFCLASS64 + 2 + + ) + +580  + #ELFCLASSNUM + 3 + + ) + +582  + #ELFDATANONE + 0 + + ) + +583  + #ELFDATA2LSB + 1 + + ) + +584  + #ELFDATA2MSB + 2 + + ) + +586  + #EV_NONE + 0 + + ) + +587  + #EV_CURRENT + 1 + + ) + +588  + #EV_NUM + 2 + + ) + +591  + #NT_PRSTATUS + 1 + + ) + +592  + #NT_PRFPREG + 2 + + ) + +593  + #NT_PRPSINFO + 3 + + ) + +594  + #NT_TASKSTRUCT + 4 + + ) + +597  + sf32_ne + { + +598 +Elf32_Wd + + mn_mesz +; + +599 +Elf32_Wd + + mn_descsz +; + +600 +Elf32_Wd + + mn_ty +; + +601 } + tElf32_Nhdr +; + +609  + sf64_ne + { + +610 +Elf32_Wd + + mn_mesz +; + +611 +Elf32_Wd + + mn_descsz +; + +612 +Elf32_Wd + + mn_ty +; + +613 } + tElf64_Nhdr +; + +615 #i +ELF_CLASS + = +ELFCLASS32 + + +617 +Elf32_Dyn + +_DYNAMIC + []; + +618  + #fhdr + +f32_hdr + + + ) + +619  + #f_phdr + +f32_phdr + + + ) + +620  + #f_ne + +f32_ne + + + ) + +624 +Elf64_Dyn + +_DYNAMIC + []; + +625  + #fhdr + +f64_hdr + + + ) + +626  + #f_phdr + +f64_phdr + + + ) + +627  + #f_ne + +f64_ne + + + ) + + @elilo.c + +32  + ~ + +33  + ~ + +35  + ~"o.h +" + +36  + ~"vs.h +" + +37  + ~"gz.h +" + +39  + ~"gt.h +" + +40  + ~"fes.h +" + +41  + ~"ld.h +" + +42  + ~"cfig.h +" + +44  + #ELILO_VERSION + +L +"3.4" + + ) + +45  + #ELILO_SHARED_CMDLINE_OPTS + +L +"pPMC:aDhd:i:vVc:E" + + ) + +47 +o_cfig_t + + go_t +; + +49 +EFI_SYSTEM_TABLE + * + gsyab +; + +62  +INTN + + +63 + $do_kl_ld +( +CHAR16 + * +kme +, +kdesc_t + * +kd +) + +65 +ld_s_t + * +lds +; + +66 +EFI_STATUS + +us +; + +67 +fs_fd_t + +fd +; + +69 +us + = + `fs_ݒ +( +kme +, & +fd +); + +70 i( + `EFI_ERROR +( +us +)) { + +71 + `ERR_PRT +(( +L +"Kf found %s", +kme +)); + +72  +ELILO_LOAD_ERROR +; + +74 + `fs_o +( +fd +); + +76 +lds + = + `ld_obe +( +kme +); + +77 i( +lds + = +NULL +) { + +78 + `ERR_PRT +(( +L +"Cn fdd f %s", +kme +)); + +79  +ELILO_LOAD_ERROR +; + +82 + `VERB_PRT +(1, + `Prt +( +L +"Usg %ld\n", +lds +-> +ld_me +)); + +84  +lds +-> + `ld_ld_kl +( +kme +, +kd +); + +85 + } +} + +87 +INTN + + +88 + $kl_ld +( +EFI_HANDLE + +image +, +CHAR16 + * +kme +, +kdesc_t + * +kd +, +memdesc_t + * +imem +, memdesc_* +mmem +) + +90 +CHAR16 + +kl +[ +CMDLINE_MAXLEN +]; + +97 i( +o_t +. +vmcode +[0]) + +98 + `SCpy +( +kl +, +o_t +. +vmcode +); + +100 + `SCpy +( +kl +, +kme +); + +104  + `do_kl_ld +( +kl +, +kd +)) { + +105  +ELILO_LOAD_SUCCESS +: + +108  +ELILO_LOAD_ERROR +: + +110  +ELILO_LOAD_ERROR +; + +112  +ELILO_LOAD_ABORTED +: + +114 +o_t +. +rd +[0] = +CHAR_NULL +; + +115 +o_t +. +vmcode +[0] = +CHAR_NULL +; + +118 +o_t +. +om + = 1; + +119 +o_t +. +timeout + = +ELILO_DEFAULT_TIMEOUT +; + +120 +o_t +. +day + = 0; + +122  +ELILO_LOAD_RETRY +; + +125 + `VERB_PRT +(3, + `Prt +( +L +"kerneloaded in [0x%lx-0x%lx]ntry=0x%lx\n", + +126 () +kd +-> +kt +, ()kd-> +kd +, ()kd-> +ky +)); + +128 i( +o_t +. +rd +[0]) { + +130 i( + `sysds_rd_g_addr +( +kd +, +imem +=-1 +ex_r +; + +132  + `ld_fe +( +o_t +. +rd +, +imem +)) { + +133  +ELILO_LOAD_SUCCESS +: + +135  +ELILO_LOAD_ERROR +: + +136  +ex_r +; + +137  +ELILO_LOAD_ABORTED +: + +138 + `_kmem +(); + +140 +o_t +. +rd +[0] = +CHAR_NULL +; + +141 +o_t +. +vmcode +[0] = +CHAR_NULL +; + +142 +o_t +. +om + = 1; + +143 +o_t +. +timeout + = +ELILO_DEFAULT_TIMEOUT +; + +144 +o_t +. +day + = 0; + +146  +ELILO_LOAD_RETRY +; + +150 i( +o_t +. +vmcode +[0]) { + +152 +mmem +-> +t_addr + = 0; + +154  + `ld_fe +( +kme +, +mmem +)) { + +155  +ELILO_LOAD_SUCCESS +: + +157  +ELILO_LOAD_ERROR +: + +158  +ex_r +; + +159  +ELILO_LOAD_ABORTED +: + +160 i( +imem +-> +t_addr +) + +161 + ` +( +imem +-> +t_addr +); + +162 + `_kmem +(); + +164 +o_t +. +rd +[0] = +CHAR_NULL +; + +165 +o_t +. +vmcode +[0] = +CHAR_NULL +; + +166 +o_t +. +om + = 1; + +167 +o_t +. +timeout + = +ELILO_DEFAULT_TIMEOUT +; + +168 +o_t +. +day + = 0; + +170  +ELILO_LOAD_RETRY +; + +174 i( + `gz_obe +( +mmem +-> +t_addr +, mmem-> +size +) == 0 && + +175 + `gunz_image +( +mmem +! +ELILO_LOAD_SUCCESS +) { + +176 i( +imem +-> +t_addr +) + +177 + ` +( +imem +-> +t_addr +); + +178 + ` +( +mmem +-> +t_addr +); + +179 + `_kmem +(); + +181 +o_t +. +rd +[0] = +CHAR_NULL +; + +182 +o_t +. +vmcode +[0] = +CHAR_NULL +; + +183 +o_t +. +om + = 1; + +184 +o_t +. +timeout + = +ELILO_DEFAULT_TIMEOUT +; + +185 +o_t +. +day + = 0; + +187  +ELILO_LOAD_RETRY +; + +190  +ELILO_LOAD_SUCCESS +; + +191 +ex_r +: + +192 + `_kmem +(); + +193 i( +imem +-> +t_addr + + ` +(imem->start_addr); + +194 i( +mmem +-> +t_addr + + ` +(mmem->start_addr); + +196  +ELILO_LOAD_ERROR +; + +197 + } +} + +199  +INTN + + +200 + $ma_lo +( +EFI_HANDLE + +dev +, +CHAR16 + ** +gv +, +INTN + +gc +, INTN +dex +, EFI_HANDLE +image +) + +202 +CHAR16 + +kme +[ +FILENAME_MAXLEN +]; + +203 +CHAR16 + +cmdle_tmp +[ +CMDLINE_MAXLEN +]; + +204 +CHAR16 + +cmdle +[ +CMDLINE_MAXLEN +]; + +205 +VOID + * +bp +; + +206 +UINTN + +cook +; + +207 +EFI_STATUS + +us + = +EFI_SUCCESS +; + +208 +kdesc_t + +kd +; + +209 +memdesc_t + +imem +, +mmem +; + +210 +INTN + +r +; + +217 i( + `sysds_o_ais +( +dev +, +gv +, +gc +, +dex +, +image +) == -1)  -1; + +220 +kme +[0] = +cmdle_tmp +[0] = +cmdle +[0] = +CHAR_NULL +; + +221 +imem +. +t_addr + = 0; imem. +pgt + = 0; imem. +size + = 0; + +222 +o_t +. +sys_img_ts + = +NULL +; + +224 i( + `kl_choor +( +gv +, +gc +, +dex +, +kme +, +cmdle_tmp +=-1 +ex_r +; + +226  + `kl_ld +( +image +, +kme +, & +kd +, & +imem +, & +mmem +)) { + +227  +ELILO_LOAD_SUCCESS +: + +228  +do_unch +; + +229  +ELILO_LOAD_ERROR +: + +230  +ex_r +; + +235 +do_unch +: + +236 +r + = + `sub_vs +( +cmdle_tmp +, +cmdle +, +CMDLINE_MAXLEN +); + +238 + `VERB_PRT +(3, + `Prt +( +L +"f cmdle(%d): %s\n", +r +, +cmdle +)); + +241 + `o_devis +(); + +244 i(( +bp += + `_bo_ms +( +cmdle +, & +imem +, & +mmem +, & +cook +)=0 +r +; + +247 +us + = +BS +-> + `ExBoSvis +( +image +, +cook +); + +248 i( + `EFI_ERROR +( +us +) +bad_ex +; + +250 + `t_kl +( +kd +. +ky +, +bp +); + +253 + `ERR_PRT +(( +L +"start_kernel()eturn !")); + +254 +bad_ex +: + +258 + `ERR_PRT +(( +L +"ExBoSvied %r", +us +)); + +259 +r +: + +260 + `_kmem +(); + +261 i( +imem +. +t_addr + + ` +(imem.start_addr); + +262 i( +bp + + `_bo_ms +(bp); + +263 +ex_r +: + +264  +ELILO_LOAD_ERROR +; + +266 + } +} + +268  +VOID + + +269 + $o_hp +( +VOID +) + +272 + `Prt +( +L +"-d secsimeout in 10th of second before booting\n"); + +273 + `Prt +( +L +"-hhis helpext\n"); + +274 + `Prt +( +L +"-Vrint version\n"); + +275 + `Prt +( +L +"-v verboseevel(canppear multipleimes)\n"); + +276 + `Prt +( +L +"-always check forlternate kernel image\n"); + +277 + `Prt +( +L +"-i fileoad fileshe initialamdisk\n"); + +278 + `Prt +( +L +"-m fileoad filesdditional bootime vmm module\n"); + +279 + `Prt +( +L +"-C file indicatehe config fileo use\n"); + +280 + `Prt +( +L +"-Parse config file only (verify syntax)\n"); + +281 + `Prt +( +L +"-Dnable debugrints\n"); + +282 + `Prt +( +L +"-p force interactive mode\n"); + +283 + `Prt +( +L +"-came image choosero use\n"); + +284 + `Prt +( +L +"-E doot force EDD30 variable\n"); + +286 + `sysds_t_cmdle_ts +(); + +288 + `Prt +( +L +"\n"); + +290 + `t_cfig_tis +(); + +291 + } +} + +298  +CHAR16 + * + gdeu_ld_tis +; + +299  +UINTN + + gdeu_ld_tis_size +; + +300  +INTN + + gde_fixups +; + +302  +VOID + + +303 + $fixurgs +( +EFI_LOADED_IMAGE + * +fo +) + +305 +EFI_STATUS + +us +; + +306 +EFI_PXE_BASE_CODE + * +pxe +; + +308  + #FAKE_ELILONAME + +L +"o-fd" + + ) + +310 +us + = +BS +-> + `HdProc + ( +fo +-> +DeviHd +, & +PxeBaCodeProc +, ( +VOID + **)& +pxe +); + +311 i( + `EFI_ERROR +( +us +)) ; + +313 +deu_ld_tis + = +fo +-> +LdOis +; + +314 +deu_ld_tis_size + = +fo +-> +LdOisSize +; + +316 +fo +-> +LdOis + = +FAKE_ELILONAME +; + +317 +fo +-> +LdOisSize + = + `SL +(fo-> +LdOis +)*( +CHAR16 +); + +319 +de_fixups + = 1; + +320 + } +} + +326  +VOID + + +327 + $unfixurgs +( +EFI_LOADED_IMAGE + * +fo +) + +329 i( +de_fixups + == 0) ; + +331 +fo +-> +LdOis + = +deu_ld_tis +; + +332 +fo +-> +LdOisSize + = +deu_ld_tis_size +; + +333 + } +} + +353  + #EDD30_GUID + \ + +354 {0x964e5b21, 0x6459, 0x11d2, { 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}} + + ) + +356  + #EDD30_ATTR + ( +EFI_VARIABLE_RUNTIME_ACCESS +| +EFI_VARIABLE_BOOTSERVICE_ACCESS +| +EFI_VARIABLE_NON_VOLATILE +) + + ) + +358  +EFI_GUID + + gedd30_guid + = +EDD30_GUID +; + +360  +INTN + + +361 + $check_edd30 +( +VOID +) + +363 +EFI_STATUS + +us +; + +364 +UINTN + +l + = ( +BOOLEAN +); + +365 +UINT8 + +bo + = +FALSE +; + +366 +INTN + +t + = -1; + +368 +us + = +RT +-> + `GVb +( +L +"EDD30", & +edd30_guid +, +NULL +, & +l +, & +bo +); + +369 i( +us + = +EFI_BUFFER_TOO_SMALL + || ( +bo + ! +TRUE + && bo ! +FALSE +)) { + +370 + `ERR_PRT +(( +L +"Warning: EDD30 EFI variable isot boolean value: forcing ito TRUE")); + +373 i( +us + = +EFI_SUCCESS + && +bo + = +TRUE +) { + +374 + `VERB_PRT +(3, + `Prt +( +L +"EDD30 is TRUE\n")); + +375 +o_t +. +edd30_ + = +TRUE +; + +376 +t + = 0; + +378 + `VERB_PRT +(4, + +379 i( +us + ! +EFI_SUCCESS +) { + +380 + `Prt +( +L +"EDD30 EFI variableot defined\n"); + +382 + `Prt +( +L +"EDD30 EFI variable is false\n"); + +387  +t +; + +388 + } +} + +390  +INTN + + +391 + $f_edd30 +( +VOID +) + +393 +EFI_STATUS + +us +; + +394 +UINTN + +l + = ( +BOOLEAN +); + +395 +UINT8 + +bo +; + +397 +bo + = +TRUE +; + +398 +us + = +RT +-> + `SVb +( +L +"EDD30", & +edd30_guid +, +EDD30_ATTR +, +l +, & +bo +); + +399 i( + `EFI_ERROR +( +us +)) { + +400 + `ERR_PRT +(( +L +"can't set EDD30 variable: ignoring it")); + +404 + `VERB_PRT +(3, + `Prt +( +L +"EDD30 variable forcedo TRUE. You shouldebootoakedvantage of EDD3.0.\n")); + +407 + } +} + +412 +EFI_STATUS + + +413 + $efi_ma + ( +EFI_HANDLE + +image +, +EFI_SYSTEM_TABLE + * +syem_b +) + +415 +CHAR16 + * +gv +[ +MAX_ARGS +]; + +416 +CHAR16 + +trg +[ +MAX_ARGS +]; + +417 +EFI_LOADED_IMAGE + * +fo +; + +418 +EFI_STATUS + +us +, +t + = +EFI_LOAD_ERROR +; + +419 +INTN + +gc + = 0, +c +; + +420 +INTN + +edd30_us +, +y +; + +421 +CHAR16 + * +r +, * +gli + = +NULL +; + +422 +BOOLEAN + +devis_lized + = +FALSE +; + +423 +CHAR16 + +dth +[ +FILENAME_MAXLEN +]; + +424 +CHAR16 + * +devth +; + +426 +o_t +. +vbo +=0; + +427 +o_t +. +debug +=0; + +430 +syab + = +syem_b +; + +433 + `InlizeLib +( +image +, +syab +); + +442 +BS +-> + `SWchdogTim +(0, 0x0, 0, +NULL +); + +445 i( + `loc_ +(=-1 +EFI_LOAD_ERROR +; + +447 +us + = +BS +-> + `HdProc +( +image +, & +LdedImageProc +, ( +VOID + **& +fo +); + +448 i( + `EFI_ERROR +( +us +)) { + +449 + `ERR_PRT +(( +L +"image handle doesot support LOADED_IMAGErotocol")); + +450  +EFI_LOAD_ERROR +; + +453 + `VERB_PRT +(5, + `Prt +( +L +"Lded0x%lx size=%d bycode=%d da=%d\n", +fo +-> +ImageBa +, info-> +ImageSize +, info-> +ImageCodeTy +, info-> +ImageDaTy +)); + +458 +edd30_us + = + `check_edd30 +(); + +463 i( + `cfig_ +(=-1 +do_ex +; + +468 i( + `sysds_ +( +fo +-> +DeviHd +=-1 +do_ex +; + +469 i( + `sysds_gi_tis +(=-1 +do_ex +; + +484 + `fixurgs +( +fo +); + +487 + `Prt +( +L +"LdOis=%x OnSize=%d\n", +fo +-> +LdOis +, info-> +LdOisSize +); + +488 { +INTN + +i +; i=0; i< +fo +-> +LdOisSize +>>1; i++ + `Prt +( +L +"tis[%d]=%d (%c)\n", i, (( +CHAR16 + *)fo-> +LdOis +)[i], ((CHAR16 *)info->LoadOptions)[i]); } + +499 +gli + = + `loc +( +fo +-> +LdOisSize ++( +CHAR16 +), +EfiLdDa +); + +500 i( +gli + = +NULL +) { + +501 + `ERR_PRT +(( +L +"cannot copyrgumentist")); + +502  +EFI_OUT_OF_RESOURCES +; + +504 + `Memy +( +gli +, +fo +-> +LdOis +, info-> +LdOisSize +); + +506 +gc + = + `gify +( +gli +, +fo +-> +LdOisSize +, +gv +); + +508 + `SCpy +( +trg +, +ELILO_SHARED_CMDLINE_OPTS +); + +509 + `SC +( +trg +, + `sysds_g_cmdle_ts +()); + +511 ( +c += + `Gt +( +gc +, +gv +, +trg +)) != -1 ) { + +512  +c +) { + +514 +o_t +. +t_check + = 1; + +517 +o_t +. +debug + = 1; + +520 +o_t +. +om + = 1; + +523 +o_t +. +vbo +++; + +524 i( +o_t +. +vbo + > 5)lilo_opt.verbose = 5; + +527 + `o_hp +(); + +528 +t + = +EFI_SUCCESS +; + +529  +do_ex +; + +535 +o_t +. +day + = + `Atoi +( +Og +); + +536 +o_t +. +day_t + = 1; + +540 +o_t +. +edd30_no_f + = 1; + +543 i( + `SL +( +Og +> +FILENAME_MAXLEN +-1) { + +544 + `Prt +( +L +"rd familimed%d chas\n", +FILENAME_MAXLEN +); + +545  +do_ex +; + +547 + `SCpy +( +o_t +. +rd +, +Og +); + +550 i( + `SL +( +Og +> +FILENAME_MAXLEN +-1) { + +551 + `Prt +( +L +"vmm modu familimed%d chas\n", +FILENAME_MAXLEN +); + +552  +do_ex +; + +554 + `SCpy +( +o_t +. +vmcode +, +Og +); + +557 i( + `SL +( +Og +> +FILENAME_MAXLEN +-1) { + +558 + `Prt +( +L +"cfig familimed%d chas\n", +FILENAME_MAXLEN +); + +559  +do_ex +; + +561 + `SCpy +( +o_t +. +cfig +, +Og +); + +564 { +mm_desc_t + +mdesc +; + +565 i( + `g_memm +(& +mdesc +) == -1) { + +566 + `Prt +( +L +"Cannot get memory map\n"); + +567  +EFI_LOAD_ERROR +; + +569 + `t_memm +(& +mdesc +); + +570 +t + = +EFI_SUCCESS +; + +571  +do_ex +; + +574 + `Prt +( +L +"ELILO v%f EFI/%a\n", +ELILO_VERSION +, +ELILO_ARCH +); + +575 +t + = +EFI_SUCCESS +; + +576  +do_ex +; + +579 +o_t +. +r_ly + = 1; + +582 i( + `SL +( +Og +> +FILENAME_MAXLEN +-1) { + +583 + `Prt +( +L +"choomilimed%d chas\n", +FILENAME_MAXLEN +); + +584  +do_ex +; + +586 + `SCpy +( +o_t +. +choor +, +Og +); + +592 i( + `sysds_gt +( +c +, +Od +, +Og +) == 0) ; + +594 + `Prt +( +L +"Unknowti -%c\n", ( +CHAR16 +) +c +); + +595  +do_ex +; + +598 + `DBG_PRT +(( +L +"Od=%d og=%xrgc=%d", +Od +, +Og +, +gc +)); + +604 i( + `_devis +( +fo +-> +DeviHd +=-1 +do_ex +; + +606 +devis_lized + = +TRUE +; + +608 +devth + = + `DeviPhToS +( +fo +-> +FePh +); + +613 + `fs_tdeus +( +o_t +. +deu_cfigs +,lo_t. +deu_kl +, +FILENAME_MAXLEN +, +devth +); + +618 + `VERB_PRT +(2, + `Prt +( +L +"Default config: %s\nDefault_kernel: %s\n", + +619 +o_t +. +deu_cfigs +[0]. +ame +,lo_t. +deu_kl +)); + +623 +r + = +o_t +. +cfig +[0] = +CHAR_NULL + ? ( +y +=1,o_t. +deu_cfigs +[0]. +ame +) : (retry=0,elilo_opt.config); + +628 +t + = + `ad_cfig +( +r +); + +629 + `VERB_PRT +(1, + `Prt +( +L +"ad_cfig=%r\n", +t +)); + +633 i( +o_t +. +cfig +[0] = +CHAR_NULL +) { + +634 ( +t + ! +EFI_SUCCESS +) && + +635 ( +y + < +MAX_DEFAULT_CONFIGS +) && + +636 ( +o_t +. +deu_cfigs +[ +y +]. +ame +[0] ! +CHAR_NULL +)) { + +638 +r + = +o_t +. +deu_cfigs +[ +y +]. +ame +; + +639 +t + = + `ad_cfig +( +r +); + +640 + `VERB_PRT +(1, + `Prt +( +L +"ad_cfig=%r\n", +t +)); + +641 +y + += 1; + +649 i( +t + = +EFI_NOT_FOUND + || = +EFI_TFTP_ERROR +) { + +650 i( +o_t +. +om + =0 &&lo_t. +cfig +[0] ! +CHAR_NULL +) { + +651 + `Prt +( +L +"cfig f%n found\n", +r +); + +652  +do_ex +; + +654 + `fs_gdeu_th +( +dth +, +FILENAME_MAXLEN +); + +655 i( +t + = +EFI_TFTP_ERROR +) + +656 + `Prt +( +L +"ncfig ffound oTFTP sv i%s\n", +dth +); + +658 + `Prt +( +L +"ncfig ffound i%s\n", +dth +); + +663 i( +o_t +. +r_ly +) { + +664 i( +t + = +EFI_SUCCESS +) + +665 + `Prt +( +L +"Cfig f%rd sucssfuy\n", +r +); + +666  +do_ex +; + +673 i( +t + ! +EFI_SUCCESS +) { + +674 + `Prt +( +L +"forcing interactive mode dueo config filerror(s)\n"); + +675 +o_t +. +om + = 1; + +682 i( +gc + > +Od +) { + +683 +o_t +. +om + = 0; + +694 i( +edd30_us + =-1 && +o_t +. +edd30_no_f + == 0) { + +695 + `f_edd30 +(); + +698 +t + = +EFI_LOAD_ERROR +; + +703 i(( +o_t +. +om + &&lo_t. +timeout + == 0)) { + +704 +o_t +. +timeout + = +ELILO_DEFAULT_TIMEOUT +; + +710 i( + `_choor +( +fo +-> +DeviHd +) == -1) { + +711 + `ERR_PRT +(( +L +"Cannot find decent chooser\n")); + +712  +do_ex +; + +717 + `ma_lo +( +fo +-> +DeviHd +, +gv +, +gc +, +Od +, +image +); + +719 +do_ex +: + +720 + `unfixurgs +( +fo +); + +725 i( +devis_lized + + `o_devis +(); + +728 + `_l_memy +(); + +730  +t +; + +731 + } +} + + @elilo.h + +29 #ide +__ELILO_H__ + + +30  + #__ELILO_H__ + + + ) + +32  + ~ + +34  + ~"o_debug.h +" + +36  + ~"fes.h +" + +37  + ~"choor.h +" + +39  + ~"rs.h +" + +41  + ~"sysds.h +" + +43  + #MB + (1024*1024 + + ) + +46  + #ROUNDUP +( +x +, +a +(((x+ (a- 1& ~(- 1)) + + ) + +47  + #ROUNDDOWN +( +x +, +a +((x& ~(- 1)) + + ) + +52  + #ELILO_LOAD_SUCCESS + 0 + + ) + +53  + #ELILO_LOAD_ABORTED + 1 + + ) + +54  + #ELILO_LOAD_ERROR + 2 + + ) + +55  + #ELILO_LOAD_RETRY + 3 + + ) + +57  + #ELILO_DEFAULT_TIMEOUT + +ELILO_TIMEOUT_INFINITY + + + ) + +58  + #ELILO_TIMEOUT_INFINITY + (~0UL) + + ) + +60  + #CMDLINE_MAXLEN + 512 + + ) + +61  + #FILENAME_MAXLEN + 256 + + ) + +62  + #MAX_ARGS + 256 + + ) + +64  + #MAX_DEFAULT_CONFIGS + 16 + + ) + +67 +UINT8 + + mnhg_y +; + +68 } + timage_t_t +; + +70  + scfig_fe + { + +71 +CHAR16 + + mame +[ +FILENAME_MAXLEN +]; + +72 } + tcfig_fe_t +; + +79 +UINTN + + mt_check +; + +80 +UINTN + + mdebug +; + +81 +UINTN + + mday +; + +82 +UINTN + + mvbo +; + +83 +CHAR16 + + mrd +[ +FILENAME_MAXLEN +]; + +84 +CHAR16 + + mvmcode +[ +FILENAME_MAXLEN +]; + +85 +UINT8 + + mday_t +; + +86 +UINT8 + + medd30_ +; + +87 +UINT8 + + medd30_no_f +; + +92 +UINTN + + mom +; + +93 +UINTN + + mr_ly +; + +94 +UINTN + + mtimeout +; + +96 +image_t_t + + mimg_t +; + +98 +sys_img_tis_t + * + msys_img_ts +; + +100 +CHAR16 + + mdeu_kl +[ +FILENAME_MAXLEN +]; + +102 +cfig_fe_t + + mdeu_cfigs +[ +MAX_DEFAULT_CONFIGS +]; + +104 +CHAR16 + + mcfig +[ +FILENAME_MAXLEN +]; + +105 +CHAR16 + + mchoor +[ +FILENAME_MAXLEN +]; + +106 } + to_cfig_t +; + +109 +o_cfig_t + +o_t +; + +111 +EFI_SYSTEM_TABLE + * +syab +; + +114 +VOID + * + mt_addr +; + +115 +UINTN + + mpgt +; + +116 +UINTN + + msize +; + +117 } + tmemdesc_t +; + +120 +VOID + * + mkt +; + +121 +VOID + * + mkd +; + +122 +VOID + * + mky +; + +123 } + tkdesc_t +; + +126 +EFI_MEMORY_DESCRIPTOR + * + mmd +; + +127 +UINTN + + mm_size +; + +128 +UINTN + + mdesc_size +; + +129 +UINTN + + mcook +; + +130 +UINT32 + + mdesc_vsi +; + +131 } + tmm_desc_t +; + +133 #ide +MAX + + +134  + #MAX +( +a +, +b +()>(b? (a: (b)) + + ) + +137 #ide +MIN + + +138  + #MIN +( +a +, +b +()>(b? (b: (a)) + + ) + +141  + #VERB_PRT +( +n +, +cmd +) \ + +142 { i( +o_t +. +vbo + >( +n +){ +cmd +; } } + + ) + +146 +INTN + +loc_ +( +VOID +); + +147 +VOID + * +loc +( +UINTN +, +EFI_MEMORY_TYPE +); + +148 +VOID + + +(VOID *); + +149 +VOID + * +loc_ges +( +UINTN +, +EFI_MEMORY_TYPE +, +EFI_ALLOCATE_TYPE +, VOID *); + +150 +VOID + +_ges +(VOID *); + +151 +VOID + +_l +(VOID); + +152 +INTN + +loc_kmem +( +VOID + *, +UINTN +); + +153 +VOID + +_kmem +(VOID); + +154 +VOID + +_l_memy +(VOID); + +157 +INTN + +ad_fe +( +UINTN + +fd +, UINTN, +CHAR8 + *); + +158 +EFI_STATUS + +check_abt +( +VOID +); + +159 +VOID + +t_put +(VOID); + +160 +INTN + +wa_timeout +( +UINTN +); + +161 +INTN + +gify +( +CHAR16 + *, +UINTN +, CHAR16 **); + +162 +VOID + +urgify +( +CHAR16 + **, CHAR16 **); + +163  +l_gs +( +CHAR16 + *, CHAR16 *, CHAR16 *); + +164 +INTN + +g_memm +( +mm_desc_t + *); + +165 +VOID + +_memm +( +mm_desc_t + *); + +166 +INTN + +fd_kl_memy +( +VOID + * +low_addr +, VOID * +max_addr +, +UINTN + +ignmt +, VOID ** +t +); + +167 +VOID + +t_memm +( +mm_desc_t + *); + +168 +VOID + +ascii2U +( +CHAR8 + *, +CHAR16 + *, +UINTN +); + +169 +VOID + +U2ascii +( +CHAR16 + *, +CHAR8 + *, +UINTN +); + +172 +EFI_STATUS + +ad_cfig +( +CHAR16 + *); + +173 +VOID + +t_cfig_tis +(VOID); + +174 +INTN + +fd_b +( +CHAR16 + *, CHAR16 *, CHAR16 *, CHAR16 *, CHAR16 *); + +175 +VOID + +t_b_li +(VOID); + +176 +INTN + +cfig_ +( +VOID +); + +177 +CHAR16 + * +g_mesge_fame +( +INTN + +which +); + +178 +CHAR16 + * +fd_desti +(CHAR16 * +b +); + +179 +VOID + * +g_xt_desti +(VOID * +ev +, +CHAR16 + ** +b +, CHAR16 ** +desti +); + +180 +CHAR16 + * +g_cfig_fe +( +VOID +); + +183 +INTN + +ld_fe +( +CHAR16 + *, +memdesc_t + *); + +186 +INTN + +e_kl +( +CHAR16 + *, INTN); + +189 +VOID + * +_bo_ms + ( +CHAR16 + *, +memdesc_t + *, memdesc_*, +UINTN + *); + +190 +VOID + +_bo_ms +(VOID * +bp +); + +197 +INTN + +sysds__bo_ms +( +bo_ms_t + *, +CHAR8 + *, +memdesc_t + *, memdesc_*, +UINTN + *); + +198 +VOID + +sysds__bo_ms +( +bo_ms_t + *); + +199 +INTN + +sysds_ +( +EFI_HANDLE + +dev +); + +200 +INTN + +sysds_rd_g_addr +( +kdesc_t + *, +memdesc_t + *); + +201 +INTN + +sysds_o_ais +( +EFI_HANDLE +, +CHAR16 + **, INTN, INTN, EFI_HANDLE); + +202 +CHAR16 + * +sysds_g_cmdle_ts +( +VOID +); + +203 +INTN + +sysds_gt +(INTN, INTN, +CHAR16 + *); + +204 +VOID + +sysds_t_cmdle_ts +(VOID); + +205 +INTN + +sysds_gi_tis +( +VOID +); + +207  + #CHAR_SLASH + +L +'/' + + ) + +208  + #CHAR_BACKSLASH + +L +'\\' + + ) + + @elilo_debug.h + +26 #ide +__ELILO_DEBUG__ + + +27  + #__ELILO_DEBUG__ + + + ) + +29  + #ELILO_DEBUG + 1 + + ) + +31  + #ERR_PRT +( +a +d{ + `Prt +( +L +"%a֚%d):", +__FILE__ +, +__LINE__ +); +Prt +; Prt(L"\n"); } 0); + + ) + +33 #ifde +ELILO_DEBUG + + +34  + #DBG_PRT +( +a +) do { \ + +35 i( +o_t +. +debug +) { \ + +36 + `Prt +( +L +"%a֚%d):", +__FILE__ +, +__LINE__ +); \ + +37 +Prt + +a +; \ + +38 + `Prt +( +L +"\n"); \ + +39 } } 0); + + ) + +41  + #DBG_PRT +( +a +) + + ) + + @fileops.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"fes.h +" + +35 #ifde +CONFIG_LOCALFS + + +36  + ~"glue_lolfs.h +" + +38 #ifde +CONFIG_NETFS + + +39  + ~"glue_tfs.h +" + +42 #ifde +CONFIG_EXT2FS + + +43  + ~"glue_ext2fs.h +" + +50 +devme_scheme_t + +sime_devme_scheme +; + +52  +devme_scheme_t + * + gdevme_scheme_b +[]={ + +53 & +sime_devme_scheme +, + +54 +NULL + + +65  + $EFI_STATUS + ( + tfs_fixups_t +)( + tEFI_HANDLE + + tdev +, + tdevi_t + * + td +); + +72  +fes_fs_t + * +fs_b +[]={ + +73 #ifde +CONFIG_LOCALFS + + +74 & +lolfs_glue +, + +76 #ifde +CONFIG_EXT2FS + + +77 & +ext2fs_glue +, + +79 #ifde +CONFIG_NETFS + + +80 & +tfs_glue +, + +82 +NULL + + +83 + } +}; + +85  +devi_t + * + gdev_b +; + +86  +UINTN + + gndev +, + gndev_bo +; + +87  +devi_t + * + gbo_dev +; + +89  + s_fdesc_t + { + +90  +_fdesc_t + * + mxt +; + +91 +fes_t + * + mfs +; + +92 +UINTN + + mfh +; + +93 } + tfdesc_t +; + +95  + #FILEOPS_FD_MAX + 16 + + ) + +97  +fdesc_t + + gfd_b +[ +FILEOPS_FD_MAX +]; + +98  +fdesc_t + * + g_fd +; + +100  +devme_scheme_t + * + gcut_devme_scheme +; + +102  + #FDESC_IDX +( +f +( +fs_fd_t +)(f- +fd_b +) + + ) + +103  + #FDESC_INVALID_FD +( +fd +(fd > +FILEOPS_FD_MAX + || +fd_b +[(fd)]. +fs + = +NULL +) + + ) + +104  + #FDESC_F +( +fd +( +fd_b ++(fd)) + + ) + +106  +fdesc_t + * + +107 + $fd_loc +( +VOID +) + +109 +fdesc_t + * +tmp + = +NULL +; + +111 i( +_fd + = +NULL +) { + +112 + `ERR_PRT +(( +L +"out of file descriptor")); + +114 +tmp + = +_fd +; + +115 +_fd + = fe_fd-> +xt +; + +117  +tmp +; + +118 + } +} + +120  +VOID + + +121 + $fd_ +( +fdesc_t + * +fd +) + +123 i( +fd + = +NULL +) { + +124 + `ERR_PRT +(( +L +"invalid fd")); + +126 +fd +-> +fs + = +NULL +; + +127 +fd +-> +xt + = +_fd +; + +128 +_fd + = +fd +; + +129 + } +} + +131  +fes_t + * + +132 + $glue_fesyem +( +EFI_GUID + * +o +, +EFI_HANDLE + +dev +, +fs_fs_glue_t + +glue +) + +134 +fes_t + * +fs +; + +135 +VOID + * +tf + = +NULL +; + +136 +EFI_STATUS + +us +; + +138 +us + = +BS +-> + `HdProc +( +dev +, +o +, & +tf +); + +139 i( + `EFI_ERROR +( +us +)) { + +140 + `ERR_PRT +(( +L +"ubˁlo %g: should hn", +o +)); + +141  +NULL +; + +143 +fs + = ( +fes_t + *) + `loc +((*fs), +EfiLdDa +); + +144 i( +fs + = +NULL +) { + +145 + `ERR_PRT +(( +L +"failedollocate fileops")); + +146  +NULL +; + +148 + `Memt +( +fs +, 0, (*fops)); + +150 +fs +-> +dev + = dev; + +153 + `glue +( +fs +, +tf +); + +155  +fs +; + +156 + } +} + +158 +INTN + + +159 + $fs_l_th +( +CHAR16 + * +th +, CHAR16 * +dev +) + +161 +CHAR16 + * +p +, * +d + = +dev +; + +162 +UINTN + +n + = +FILEOPS_DEVNAME_MAXLEN +; + +163  + #CHAR_COLON + +L +':' + + ) + +165 +p + = + `SChr +( +th +, +CHAR_COLON +); + +166 i( +p + = +NULL +) { + +167 * +dev + = +CHAR_NULL +; + +171  +d + = +dev + ; +th + ! +p + ;) { + +172 i(-- +n + == 0)  -1; + +173 * +d +++ = * +th +++; + +175 * +d + = +CHAR_NULL +; + +177 + } +} + +179  +devi_t + * + +180 + $fd_devi_byme +( +CHAR16 + * +dev +) + +182 +UINTN + +i +; + +183  +i +=0; i < +ndev +; i++) { + +184 i(! + `SCmp +( +dev +, +dev_b +[ +i +]. +me +))  dev_tab+i; + +186  +NULL +; + +187 + } +} + +206 +EFI_STATUS + + +207 + $fs_g_xt_devi +( +UINTN + +pidx +, +CHAR16 + * +ty +, UINTN +maxn +, UINTN * +idx +, CHAR16 * +me +, +EFI_HANDLE + * +dev +) + +209 +UINTN + +i +; + +211 i( +me + = +NULL + || +idx + =NULL +EFI_INVALID_PARAMETER +; + +213  +i += +pidx +; i < +ndev +; i++) { + +214 i( +ty + = +NULL + || ! + `SCmp +( +dev_b +[ +i +]. +fs +-> +me +,y) +found +; + +216  +EFI_NOT_FOUND +; + +217 +found +: + +218 i( + `SL +( +dev_b +[ +i +]. +me +> +maxn +) { + +219 * +idx + = +pidx +; + +220  +EFI_BUFFER_TOO_SMALL +; + +222 + `SCpy +( +me +, +dev_b +[ +i +].name); + +223 * +idx + = +i ++1; + +224 i( +dev +*dev = +dev_b +[ +i +].dev; + +226  +EFI_SUCCESS +; + +227 + } +} + +229 +EFI_STATUS + + +230 + $fs_g_devi_hd +( +CHAR16 + * +me +, +EFI_HANDLE + * +dev +) + +232 +UINTN + +i +; + +234 i( +me + = +NULL + || +dev + =NULL +EFI_INVALID_PARAMETER +; + +236  +i +=0; i < +ndev +; i++) { + +237 i(! + `SCmp +( +dev_b +[ +i +]. +me +,ame) +found +; + +239  +EFI_NOT_FOUND +; + +240 +found +: + +241 * +dev + = +dev_b +[ +i +].dev; + +243  +EFI_SUCCESS +; + +244 + } +} + +247 +EFI_STATUS + + +248 + $fs_ݒ +( +CHAR16 + * +fume +, +fs_fd_t + * +fd +) + +250 +fdesc_t + * +f +; + +251 +EFI_STATUS + +us +; + +252 +fes_t + * +fs +; + +253 +devi_t + * +dev +; + +254 +CHAR16 + +dev_me +[ +FILEOPS_DEVNAME_MAXLEN +]; + +255 +CHAR16 + * +me +; + +258 i( +fd + = +NULL + || +fume + =NULL || *fum= +CHAR_NULL + || + `fs_l_th +(fume, +dev_me +) == -1) + +259  +EFI_INVALID_PARAMETER +; + +261 + `DBG_PRT +(( +L +"fs_ݒ(%s), dev:%s:", +fume + ? fum: L"(NULL)", +dev_me +)); + +263 +me + = +fume +; + +264 i( +dev_me +[0] = +CHAR_NULL +) { + +265 i( +bo_dev + = +NULL + +EFI_INVALID_PARAMETER +; + +266 +fs + = +bo_dev +->fops; + +268 i(( +dev += + `fd_devi_byme +( +dev_me +)= +NULL + +EFI_INVALID_PARAMETER +; + +270 +me + + + `SL +( +dev_me +)+1; + +272 +fs + = +dev +->fops; + +275 i( +fs + = +NULL + +EFI_INVALID_PARAMETER +; + +277 i(( +f += + `fd_loc +()= +NULL + +EFI_OUT_OF_RESOURCES +; + +279 + `DBG_PRT +(( +L +"dev:%s: fume:%s:ame:%s: f=%d", +dev_me +, +fume +, +me +, +f + - +fd_b +)); + +281 +us + = +fs +-> + `ݒ +(fs-> +tf +, +me +, & +f +-> +fh +); + +282 i( + `EFI_ERROR +( +us +) +r +; + +284 +f +-> +fs + = fops; + +286 * +fd + = + `FDESC_IDX +( +f +); + +288  +EFI_SUCCESS +; + +289 +r +: + +290 + `fd_ +( +f +); + +291  +us +; + +292 + } +} + +294 +EFI_STATUS + + +295 + $fs_ad +( +fs_fd_t + +fd +, +VOID + * +buf +, +UINTN + * +size +) + +297 +fdesc_t + * +f +; + +299 i( +buf + = +NULL + || + `FDESC_INVALID_FD +( +fd +|| +size + =NULL +EFI_INVALID_PARAMETER +; + +301 +f + = + `FDESC_F +( +fd +); + +303  +f +-> +fs +-> + `ad +(f->fs-> +tf +, f-> +fh +, +buf +, +size +); + +304 + } +} + +306 +EFI_STATUS + + +307 + $fs_o +( +fs_fd_t + +fd +) + +309 +fdesc_t + * +f +; + +310 +EFI_STATUS + +us +; + +312 i( + `FDESC_INVALID_FD +( +fd +) +EFI_INVALID_PARAMETER +; + +314 +f + = + `FDESC_F +( +fd +); + +316 +us + = +f +-> +fs +-> + `o +(f->fs-> +tf +, f-> +fh +); + +318 + `fd_ +( +f +); + +320  +us +; + +321 + } +} + +323 +EFI_STATUS + + +324 + $fs_fosize +( +fs_fd_t + +fd +, +UINT64 + * +size +) + +326 +fdesc_t + * +f +; + +328 i( + `FDESC_INVALID_FD +( +fd +|| +size + = +NULL + +EFI_INVALID_PARAMETER +; + +330 +f + = + `FDESC_F +( +fd +); + +332  +f +-> +fs +-> + `fosize +(f->fs-> +tf +, f-> +fh +, +size +); + +333 + } +} + +335 +EFI_STATUS + + +336 + $fs_ek +( +fs_fd_t + +fd +, +UINT64 + +wpos +) + +338 +fdesc_t + * +f +; + +340 i( + `FDESC_INVALID_FD +( +fd +) +EFI_INVALID_PARAMETER +; + +342 +f + = + `FDESC_F +( +fd +); + +344  +f +-> +fs +-> + `ek +(f->fs-> +tf +, f-> +fh +, +wpos +); + +345 + } +} + +347 +EFI_STATUS + + +348 + $fs_tdeus +( +cfig_fe + * +defcf +, +CHAR16 + * +kme +, +UINTN + +maxn +, CHAR16 * +devth +) + +350 +INTN + +i +; + +357 #i + `defed +( +CONFIG_64 +) + +358  + #FILEOPS_ARCH_DEFAULT_CONFIG + +L +"o-64.cf" + + ) + +359 #i + `defed + ( +CONFIG_32 +) + +360  + #FILEOPS_ARCH_DEFAULT_CONFIG + +L +"o-32.cf" + + ) + +368  + #FILEOPS_DEFAULT_CONFIG + +L +"o.cf" + + ) + +370  + #FILEOPS_DEFAULT_KERNEL + +L +"vmlux" + + ) + +372 #ifde +ELILO_DEBUG + + +373 i( +defcf + = +NULL + || +kme + =NULL +EFI_INVALID_PARAMETER +; + +376  +i +=0; i< +MAX_DEFAULT_CONFIGS +; i++) { + +377 +defcf +[ +i +]. +ame +[0] = +CHAR_NULL +; + +380 i( +bo_dev + = +NULL + || bo_dev-> +fs + == NULL) { + +381 i( +bo_dev + = +NULL +) + +382 + `Prt +( +L +"Warning boot deviceotecognized\n"); + +384 + `Prt +( +L +"Unknown filesystem on boot device\n"); + +386 + `Prt +( +L +"Using builtin defaults for kernelnd config file\n"); + +388 + `SnCpy +( +kme +, +FILEOPS_DEFAULT_KERNEL +, +maxn +-1); + +391 +bo_dev +-> +fs +-> + `tdeus +(bo_dev->fs-> +tf +, +defcf +, +kme +, +maxn +, +devth +); + +393 +i +=0; i< +MAX_DEFAULT_CONFIGS + && +defcf +[i]. +ame +[0] ! +CHAR_NULL +) i += 1; + +394 #ifde +ELILO_DEBUG + + +395 i(( +i ++3> +MAX_DEFAULT_CONFIGS +) { + +396 + `Prt +( +L +"ERROR: i = %d, MAX_DEFAULT_CONFIGS inنgough\n", +i +); + +397  +EFI_INVALID_PARAMETER +; + +400 + `SnCpy +( +defcf +[ +i +]. +ame +, +FILEOPS_ARCH_DEFAULT_CONFIG +, +maxn +-1); + +401 + `SnCpy +( +defcf +[ +i ++1]. +ame +, +FILEOPS_DEFAULT_CONFIG +, +maxn +-1); + +403 #ifde +ELILO_DEBUG + + +404 + `VERB_PRT +(3, + `Prt +( +L +"Default config filenameist:\n")); + +405  +i +=0; i< +MAX_DEFAULT_CONFIGS +; i++) { + +406 i( +defcf +[ +i +]. +ame +[0] = +CHAR_NULL +) { ; } + +407 + `VERB_PRT +(3, + `Prt +( +L +"\t%s\n", +defcf +[ +i +]. +ame +)); + +411  +EFI_SUCCESS +; + +412 + } +} + +414 +EFI_STATUS + + +415 + $fs_gdeu_th +( +CHAR16 + * +th +, +UINTN + +maxn +) + +417 i( +th + = +NULL + || +maxn + =0 +EFI_INVALID_PARAMETER +; + +423 i( +bo_dev +-> +fs +-> +gdeu_th +) + +424  +bo_dev +-> +fs +-> + `gdeu_th +( +th +, +maxn +); + +426 +th +[0] = +CHAR_NULL +; + +428  +EFI_SUCCESS +; + +429 + } +} + +431 +CHAR16 + * + +432 + $fs_bodev_me +( +VOID +) + +434  +bo_dev + ? bo_dev-> +me + : +L +"not supported"; + +435 + } +} + +437  +INTN + + +438 + $add_dev_b +( +EFI_GUID + * +o +, +EFI_HANDLE + +bo_hd +, +UINTN + +size +, +fs_fs_glue_t + +glue +) + +440 +EFI_STATUS + +us +; + +441 +EFI_HANDLE + * +b +; + +442 +UINTN + +i +; + +443  +UINTN + +idx +; + +445 i( +size + == 0)  0; + +447 +b + = ( +EFI_HANDLE + *) + `loc +( +size +, +EfiLdDa +); + +448 i( +b + = +NULL +) { + +449 + `ERR_PRT +(( +L +"failedollocate handleable")); + +453 + `Memt +( +b +, 0, +size +); + +458 +us + = +BS +-> + `LoHd +( +ByProc +, +o +, +NULL +, & +size +, +b +); + +459 i( +us + ! +EFI_SUCCESS +) { + +460 + `ERR_PRT +(( +L +"edg hdˠf܅r%g size=%d: %r", +o +, +size +, +us +)); + +461 + ` +( +b +); + +464 +size + /( +EFI_HANDLE +); + +466  +i +=0; i < +size +; i++) { + +467 +dev_b +[ +idx +]. +dev + = +b +[ +i +]; + +468 +dev_b +[ +idx +]. +fs + = + `glue_fesyem +( +o +, +b +[ +i +], +glue +); + +470 i( +b +[ +i +] = +bo_hd + +bo_dev + = +dev_b ++ +idx +; + +473 i( +dev_b +[ +idx +]. +fs + +ndev_bo +++; + +476 +dev_b +[ +idx +]. +me +[0] = +L +'d'; + +477 +dev_b +[ +idx +]. +me +[1] = +L +'e'; + +478 +dev_b +[ +idx +]. +me +[2] = +L +'v'; + +479 +dev_b +[ +idx +]. +me +[3] = +L +'0' + idx/100; + +480 +dev_b +[ +idx +]. +me +[4] = +L +'0' + (idx%100)/10; + +481 +dev_b +[ +idx +]. +me +[5] = +L +'0' + (idx%100) % 10; + +482 +dev_b +[ +idx +]. +me +[6] = +CHAR_NULL +; + +484 #ifde +ELILO_DEBUG + + +485 i( +o_t +. +debug +) { + +486 +EFI_DEVICE_PATH + * +dp +; + +487 +CHAR16 + * +r +, * +r2 +; + +489 +r + = +NULL +; + +490 +dp + = + `DeviPhFromHd +( +dev_b +[ +idx +]. +dev +); + +491 i( +dp + +r + = + `DeviPhToS +(dp); + +493 +r2 + = +r + = +NULL + ? +L +"Unknown" : str; + +495 + `DBG_PRT +(( +L +"%: %-8: %s\n", +dev_b +[ +idx +]. +me +, + +496 ( +dev_b +[ +idx +]. +fs + ? dev_b[idx].fs-> +me +: +L +"N/A"), +r2 +)); + +498 i( +r + + `FePo +(str); + +502 +idx +++; + +504 + ` +( +b +); + +507 +ndev + = +idx +; + +510 + } +} + +512  +INTN + + +513 + $obe_devme_schemes +( +devi_t + * +dev_b +, +INTN + +ndev +) + +515 +devme_scheme_t + ** +p +; + +517  +p + = +devme_scheme_b +; *p ;++) { + +518 i((* +p +)-> + `l_scheme +( +dev_b +, +ndev +=0 +found +; + +520 + `ERR_PRT +(( +L +"No devname schemes worked, using builtin\n")); + +522 +found +: + +523 + `VERB_PRT +(3, + `Prt +( +L +"devmscheme: %s\n", (* +p +)-> +me +)); + +524 +cut_devme_scheme + = * +p +; + +526 + } +} + +528  +INTN + + +529 + $fd_fesyems +( +EFI_HANDLE + +bo_hd +) + +531 +UINTN + +size +, +tٮ + = 0; + +532 +fes_fs_t + ** +fs +; + +537  +fs + = +fs_b +; *fs; fs++) { + +538 +size + = 0; + +539 +BS +-> + `LoHd +( +ByProc +, &(* +fs +)-> +o +, +NULL +, & +size +, NULL); + +540 +tٮ + + +size +; + +542 i( +tٮ + == 0) { + +543 + `ERR_PRT +(( +L +"No useable filesystem found")); + +546 +tٮ + /( +EFI_HANDLE +); + +547 + `DBG_PRT +(( +L +"found %d fesyems", +tٮ +)); + +549 +dev_b + = ( +devi_t + *) + `loc +( +tٮ +*(devi_t), +EfiLdDa +); + +550 i( +dev_b + = +NULL +) { + +551 + `ERR_PRT +(( +L +"failedollocate handleable")); + +555 + `Memt +( +dev_b +, 0, +tٮ +*( +devi_t +)); + +560  +fs + = +fs_b +; *fs; fs++) { + +561 +size + = 0; + +563 +BS +-> + `LoHd +( +ByProc +, &(* +fs +)-> +o +, +NULL +, & +size +, NULL); + +564 i( +size + == 0) ; + +566 + `add_dev_b +(&(* +fs +)-> +o +, +bo_hd +, +size +, (*fs)-> +glue +); + +568 + `obe_devme_schemes +( +dev_b +, +ndev +); + +571 + } +} + +573  +INTN + + +574 + $fes_ +( +VOID +) + +576 +UINTN + +i +; + +578  +i +=0; i < +FILEOPS_FD_MAX +-1; i++) { + +579 +fd_b +[ +i +]. +xt + = &fd_tab[i+1]; + +581 +fd_b +[ +i +]. +xt + = +NULL +; + +582 +_fd + = +fd_b +; + +585 + } +} + +590  +INTN + + +591 + $l_fesyems +( +VOID +) + +593 +fes_fs_t + ** +fs +; + +595  +fs + = +fs_b +; *fs; fs++(*fs)-> + `l +(); + +598 + } +} + +600  +INTN + + +601 + $unl_fesyems +( +VOID +) + +603 +fes_fs_t + ** +fs +; + +605  +fs + = +fs_b +; *fs; fs++(*fs)-> + `unl +(); + +608 + } +} + +610 +INTN + + +611 + $_devis +( +EFI_HANDLE + +bo_hd +) + +614 + `l_fesyems +(); + +619 + `fes_ +(); + +621  + `fd_fesyems +( +bo_hd +); + +622 + } +} + +624 +INTN + + +625 + $o_devis +( +VOID +) + +627 +INTN + +i +; + +629  +i +=0; i < +FILEOPS_FD_MAX +; i++) { + +630 + `fs_o +( +i +); + +632 + ` +( +dev_b +); + +637 + `unl_fesyems +(); + +640 + } +} + +642 +VOID + + +643 + $t_devis +( +VOID +) + +645 +UINTN + +idx +; + +646 +EFI_DEVICE_PATH + * +dp +; + +647 +CHAR16 + * +r +, * +r2 +; + +649  +idx +=0; idx< +ndev +; idx++) { + +650 +r + = +NULL +; + +652 +dp + = + `DeviPhFromHd +( +dev_b +[ +idx +]. +dev +); + +653 i( +dp + +r + = + `DeviPhToS +(dp); + +655 +r2 + = +r + = +NULL + ? +L +"Unknown" : str; + +657 + `Prt +( +L +"%8: %-6: %s\n", +dev_b +[ +idx +]. +me +, + +658 ( +dev_b +[ +idx +]. +fs + ? dev_b[idx].fs-> +me +: +L +"N/A"), +r2 +); + +660 i( +r + + `FePo +(str); + +662 + `Prt +( +L +"%d deviavaab f boٚg\n", +ndev_bo +); + +664 i( +bo_dev + = +NULL +) { + +665 + `Prt +( +L +"boot deviceot detected\n"); + +667 + `Prt +( +L +"bo devi %s: %s\n", +bo_dev +-> +me +, + +668 ( +bo_dev +-> +fs + ? bo_dev->fs-> +me + : +L +"No fileccess")); + +670 + } +} + + @fileops.h + +26 #ide +__FILEOPS_H__ + + +27  + #__FILEOPS_H__ + + + ) + +29  + #FILEOPS_NAME_MAXLEN + 32 + + ) + +34  +UINTN + + tfs_fd_t +; + +37  + gcfig_fe +; + +39 +EFI_STATUS + +fs_ݒ +( +CHAR16 + * +me +, +fs_fd_t + * +fd +); + +40 +EFI_STATUS + +fs_ad +( +fs_fd_t + +fd +, +VOID + * +buf +, +UINTN + * +size +); + +41 +EFI_STATUS + +fs_o +( +fs_fd_t + +fd +); + +42 +EFI_STATUS + +fs_fosize +( +fs_fd_t + +fd +, +UINT64 + * +size +); + +43 +EFI_STATUS + +fs_ek +( +fs_fd_t + +fd +, +UINT64 + +wpos +); + +44 +EFI_STATUS + +fs_tdeus +( +cfig_fe + * +defcf +, +CHAR16 + * +kme +, +UINTN + +maxn +, CHAR16 * +devth +); + +45 +EFI_STATUS + +fs_gdeu_th +( +CHAR16 + * +th +, +UINTN + +maxn +); + +46 +CHAR16 + * +fs_bodev_me +( +VOID +); + +53  + $EFI_STATUS + (* + tfs_ݒ_t +)( + tVOID + * + ttf +, + tCHAR16 + * + tme +, + tfs_fd_t + * + tfd +); + +54  + $EFI_STATUS + (* + tfs_ad_t +)( + tVOID + * + ttf +, + tfs_fd_t + + tfd +, VOID * + tbuf +, + tUINTN + * + tsize +); + +55  + $EFI_STATUS + (* + tfs_o_t +)( + tVOID + * + ttf +, + tfs_fd_t + + tfd +); + +56  + $EFI_STATUS + (* + tfs_fosize_t +)( + tVOID + * + ttf +, + tfs_fd_t + + tfd +, + tUINT64 + * + tsize +); + +57  + $EFI_STATUS + (* + tfs_ek_t +)( + tVOID + * + ttf +, + tfs_fd_t + + tfd +, + tUINT64 + + twpos +); + +58  + $EFI_STATUS + (* + tfs_tdeus_t +)( + tVOID + * + ttf +,  + tcfig_fe + * + tdefcfs +, + tCHAR16 + * + tkme +, + tUINTN + + tmaxn +, CHAR16 * + tdevth +); + +59  + $EFI_STATUS + (* + tfs_gdeu_th_t +)( + tCHAR16 + * + tth +, + tUINTN + + tmaxn +); + +62 +VOID + * +tf +; + +64 +fs_ݒ_t + +ݒ +; + +65 +fs_ad_t + +ad +; + +66 +fs_o_t + +o +; + +67 +fs_fosize_t + +fosize +; + +68 +fs_ek_t + +ek +; + +69 +fs_tdeus_t + +tdeus +; + +70 +fs_gdeu_th_t + +gdeu_th +; + +72 +EFI_HANDLE + +dev +; + +73 +CHAR16 + +me +[ +FILEOPS_NAME_MAXLEN +]; + +74 } + tfes_t +; + +79  + $INTN + (* + tfs_fs_glue_t +)( + tfes_t + * + tthis +, + tVOID + * + ttf +); + +80  + $EFI_STATUS + (* + tfs_fs_l_t +)( + tVOID +); + +81  + $EFI_STATUS + (* + tfs_fs_unl_t +)( + tVOID +); + +84 +EFI_GUID + +o +; + +85 +fs_fs_glue_t + +glue +; + +86 +fs_fs_l_t + +l +; + +87 +fs_fs_unl_t + +unl +; + +88 } + tfes_fs_t +; + +94  + #FILEOPS_DEVNAME_MAXLEN + 16 + + ) + +97 +EFI_HANDLE + +dev +; + +98 +fes_t + * +fs +; + +99 +CHAR16 + +me +[ +FILEOPS_DEVNAME_MAXLEN +]; + +100 } + tdevi_t +; + +102 +INTN + + `_devis +( +EFI_HANDLE + +bo_hd +); + +103 +INTN + + `o_devis +( +VOID +); + +104 +VOID + + `t_devis +(VOID); + +105 +EFI_STATUS + + `fs_g_xt_devi +( +UINTN + +pidx +, +CHAR16 + * +ty +, UINTN +maxn +, UINTN * +idx +, CHAR16 * +me +, +EFI_HANDLE + * +dev +); + +106 +INTN + + `fs_l_th +( +CHAR16 + * +th +, CHAR16 * +dev +); + +107 +EFI_STATUS + + `fs_g_devi_hd +( +CHAR16 + * +me +, +EFI_HANDLE + * +dev +); + +123 +CHAR16 + * +me +; + +124 + `INTN + (* +l_scheme +)( +devi_t + * +b +, +UINTN + +ndev +); + +125 } + tdevme_scheme_t +; + + @fs/ext2_fs.h + +16 #ide +_LINUX_EXT2_FS_H + + +17  + #_LINUX_EXT2_FS_H + + + ) + +26 #unde +EXT2FS_DEBUG + + +31  + #EXT2_PREALLOCATE + + + ) + +32  + #EXT2_DEFAULT_PREALLOC_BLOCKS + 8 + + ) + +37  + #EXT2FS_DATE + "95/08/09" + + ) + +38  + #EXT2FS_VERSION + "0.5b" + + ) + +43 #ifde +EXT2FS_DEBUG + + +44  + #ext2_debug +( +f +, +a +...) { \ + +45 + `tk + ("EXT2-fs DEBUG (%s, %d): %s:", \ + +46 +__FILE__ +, +__LINE__ +, +__FUNCTION__ +); \ + +47 + `tk + ( +f +, ## +a +); \ + +48 } + + ) + +50  + #ext2_debug +( +f +, +a +... + + ) + +56  + #EXT2_BAD_INO + 1 + + ) + +57  + #EXT2_ROOT_INO + 2 + + ) + +58  + #EXT2_ACL_IDX_INO + 3 + + ) + +59  + #EXT2_ACL_DATA_INO + 4 + + ) + +60  + #EXT2_BOOT_LOADER_INO + 5 + + ) + +61  + #EXT2_UNDEL_DIR_INO + 6 + + ) + +64  + #EXT2_GOOD_OLD_FIRST_INO + 11 + + ) + +69  + #EXT2_SUPER_MAGIC + 0xEF53 + + ) + +74  + #EXT2_LINK_MAX + 32000 + + ) + +79  + #EXT2_MIN_BLOCK_SIZE + 1024 + + ) + +80  + #EXT2_MAX_BLOCK_SIZE + 4096 + + ) + +81  + #EXT2_MIN_BLOCK_LOG_SIZE + 10 + + ) + +82 #ifde +__KERNEL__ + + +83  + #EXT2_BLOCK_SIZE +( +s +((s)-> +s_blocksize +) + + ) + +85  + #EXT2_BLOCK_SIZE +( +s +( +EXT2_MIN_BLOCK_SIZE + << (s)-> +s_log_block_size +) + + ) + +87  + #EXT2_ACLE_PER_BLOCK +( +s +( + `EXT2_BLOCK_SIZE +(s/  ( +ext2_a_y +)) + + ) + +88  + #EXT2_ADDR_PER_BLOCK +( +s +( + `EXT2_BLOCK_SIZE +(s/  ( +__u32 +)) + + ) + +89 #ifde +__KERNEL__ + + +90  + #EXT2_BLOCK_SIZE_BITS +( +s +((s)-> +s_blocksize_bs +) + + ) + +92  + #EXT2_BLOCK_SIZE_BITS +( +s +((s)-> +s_log_block_size + + 10) + + ) + +94 #ifde +__KERNEL__ + + +95  + #EXT2_ADDR_PER_BLOCK_BITS +( +s +((s)-> +u +. +ext2_sb +. +s_addr_r_block_bs +) + + ) + +96  + #EXT2_INODE_SIZE +( +s +((s)-> +u +. +ext2_sb +. +s_ode_size +) + + ) + +97  + #EXT2_FIRST_INO +( +s +((s)-> +u +. +ext2_sb +. +s_f_o +) + + ) + +99  + #EXT2_INODE_SIZE +( +s +(((s)-> +s_v_v + = +EXT2_GOOD_OLD_REV +) ? \ + +100 +EXT2_GOOD_OLD_INODE_SIZE + : \ + +101 ( +s +)-> +s_ode_size +) + + ) + +102  + #EXT2_FIRST_INO +( +s +(((s)-> +s_v_v + = +EXT2_GOOD_OLD_REV +) ? \ + +103 +EXT2_GOOD_OLD_FIRST_INO + : \ + +104 ( +s +)-> +s_f_o +) + + ) + +110  + #EXT2_MIN_FRAG_SIZE + 1024 + + ) + +111  + #EXT2_MAX_FRAG_SIZE + 4096 + + ) + +112  + #EXT2_MIN_FRAG_LOG_SIZE + 10 + + ) + +113 #ifde +__KERNEL__ + + +114  + #EXT2_FRAG_SIZE +( +s +((s)-> +u +. +ext2_sb +. +s_ag_size +) + + ) + +115  + #EXT2_FRAGS_PER_BLOCK +( +s +((s)-> +u +. +ext2_sb +. +s_ags_r_block +) + + ) + +117  + #EXT2_FRAG_SIZE +( +s +( +EXT2_MIN_FRAG_SIZE + << (s)-> +s_log_ag_size +) + + ) + +118  + #EXT2_FRAGS_PER_BLOCK +( +s +( + `EXT2_BLOCK_SIZE +(s/ + `EXT2_FRAG_SIZE +(s)) + + ) + +124  + sext2_a_hd + + +126 +__u32 + + mah_size +; + +127 +__u32 + + mah_fe_cou +; + +128 +__u32 + + mah_ae_cou +; + +129 +__u32 + + mah_f_ae +; + +132  + sext2_a_y + + +134 +__u32 + + mae_size +; + +135 +__u16 + + mae_rms +; + +136 +__u16 + + mae_ty +; + +137 +__u16 + + mae_g +; + +138 +__u16 + + mae_d1 +; + +139 +__u32 + + mae_xt +; + +146  + sext2_group_desc + + +148 +__u32 + + mbg_block_bm +; + +149 +__u32 + + mbg_ode_bm +; + +150 +__u32 + + mbg_ode_b +; + +151 +__u16 + + mbg__blocks_cou +; + +152 +__u16 + + mbg__odes_cou +; + +153 +__u16 + + mbg_ud_ds_cou +; + +154 +__u16 + + mbg_d +; + +155 +__u32 + + mbg_rved +[3]; + +161 #ifde +__KERNEL__ + + +162  + #EXT2_BLOCKS_PER_GROUP +( +s +((s)-> +u +. +ext2_sb +. +s_blocks_r_group +) + + ) + +163  + #EXT2_DESC_PER_BLOCK +( +s +((s)-> +u +. +ext2_sb +. +s_desc_r_block +) + + ) + +164  + #EXT2_INODES_PER_GROUP +( +s +((s)-> +u +. +ext2_sb +. +s_odes_r_group +) + + ) + +165  + #EXT2_DESC_PER_BLOCK_BITS +( +s +((s)-> +u +. +ext2_sb +. +s_desc_r_block_bs +) + + ) + +167  + #EXT2_BLOCKS_PER_GROUP +( +s +((s)-> +s_blocks_r_group +) + + ) + +168  + #EXT2_DESC_PER_BLOCK +( +s +( + `EXT2_BLOCK_SIZE +(s/  ( +ext2_group_desc +)) + + ) + +169  + #EXT2_INODES_PER_GROUP +( +s +((s)-> +s_odes_r_group +) + + ) + +175  + #EXT2_NDIR_BLOCKS + 12 + + ) + +176  + #EXT2_IND_BLOCK + +EXT2_NDIR_BLOCKS + + + ) + +177  + #EXT2_DIND_BLOCK + ( +EXT2_IND_BLOCK + + 1) + + ) + +178  + #EXT2_TIND_BLOCK + ( +EXT2_DIND_BLOCK + + 1) + + ) + +179  + #EXT2_N_BLOCKS + ( +EXT2_TIND_BLOCK + + 1) + + ) + +184  + #EXT2_SECRM_FL + 0x00000001 + + ) + +185  + #EXT2_UNRM_FL + 0x00000002 + + ) + +186  + #EXT2_COMPR_FL + 0x00000004 + + ) + +187  + #EXT2_SYNC_FL + 0x00000008 + + ) + +188  + #EXT2_IMMUTABLE_FL + 0x00000010 + + ) + +189  + #EXT2_APPEND_FL + 0x00000020 + + ) + +190  + #EXT2_NODUMP_FL + 0x00000040 + + ) + +191  + #EXT2_NOATIME_FL + 0x00000080 + + ) + +193  + #EXT2_DIRTY_FL + 0x00000100 + + ) + +194  + #EXT2_COMPRBLK_FL + 0x00000200 + + ) + +195  + #EXT2_NOCOMP_FL + 0x00000400 + + ) + +196  + #EXT2_ECOMPR_FL + 0x00000800 + + ) + +198  + #EXT2_BTREE_FL + 0x00001000 + + ) + +199  + #EXT2_RESERVED_FL + 0x80000000 + + ) + +201  + #EXT2_FL_USER_VISIBLE + 0x00001FFF + + ) + +202  + #EXT2_FL_USER_MODIFIABLE + 0x000000FF + + ) + +207  + #EXT2_IOC_GETFLAGS + + `_IOR +('f', 1, ) + + ) + +208  + #EXT2_IOC_SETFLAGS + + `_IOW +('f', 2, ) + + ) + +209  + #EXT2_IOC_GETVERSION + + `_IOR +('v', 1, ) + + ) + +210  + #EXT2_IOC_SETVERSION + + `_IOW +('v', 2, ) + + ) + +215  + sext2_ode + { + +216 +__u16 + + mi_mode +; + +217 +__u16 + + mi_uid +; + +218 +__u32 + + mi_size +; + +219 +__u32 + + mi_ime +; + +220 +__u32 + + mi_ime +; + +221 +__u32 + + mi_mtime +; + +222 +__u32 + + mi_dtime +; + +223 +__u16 + + mi_gid +; + +224 +__u16 + + mi_lks_cou +; + +225 +__u32 + + mi_blocks +; + +226 +__u32 + + mi_ags +; + +229 +__u32 + + ml_i_rved1 +; + +230 } + mlux1 +; + +232 +__u32 + + mh_i_ +; + +233 } + mhurd1 +; + +235 +__u32 + + mm_i_rved1 +; + +236 } + mmasix1 +; + +237 } + mosd1 +; + +238 +__u32 + + mi_block +[ +EXT2_N_BLOCKS +]; + +239 +__u32 + + mi_gi +; + +240 +__u32 + + mi_fe_a +; + +241 +__u32 + + mi_d_a +; + +242 +__u32 + + mi_ddr +; + +245 +__u8 + + ml_i_ag +; + +246 +__u8 + + ml_i_fsize +; + +247 +__u16 + + mi_d1 +; + +248 +__u16 + + ml_i_uid_high +; + +249 +__u16 + + ml_i_gid_high +; + +250 +__u32 + + ml_i_rved2 +; + +251 } + mlux2 +; + +253 +__u8 + + mh_i_ag +; + +254 +__u8 + + mh_i_fsize +; + +255 +__u16 + + mh_i_mode_high +; + +256 +__u16 + + mh_i_uid_high +; + +257 +__u16 + + mh_i_gid_high +; + +258 +__u32 + + mh_i_auth +; + +259 } + mhurd2 +; + +261 +__u8 + + mm_i_ag +; + +262 +__u8 + + mm_i_fsize +; + +263 +__u16 + + mm_d1 +; + +264 +__u32 + + mm_i_rved2 +[2]; + +265 } + mmasix2 +; + +266 } + mosd2 +; + +269  + #i_size_high + +i_d_a + + + ) + +271 #i +defed +( +__KERNEL__ +|| defed( +__lux__ +) + +272  + #i_rved1 + +osd1 +. +lux1 +. +l_i_rved1 + + + ) + +273  + #i_ag + +osd2 +. +lux2 +. +l_i_ag + + + ) + +274  + #i_fsize + +osd2 +. +lux2 +. +l_i_fsize + + + ) + +275  + #i_uid_low + +i_uid + + + ) + +276  + #i_gid_low + +i_gid + + + ) + +277  + #i_uid_high + +osd2 +. +lux2 +. +l_i_uid_high + + + ) + +278  + #i_gid_high + +osd2 +. +lux2 +. +l_i_gid_high + + + ) + +279  + #i_rved2 + +osd2 +. +lux2 +. +l_i_rved2 + + + ) + +282 #ifdef +__hurd__ + + +283  + #i_ + +osd1 +. +hurd1 +. +h_i_ + + + ) + +284  + #i_ag + +osd2 +. +hurd2 +. +h_i_ag +; + + ) + +285  + #i_fsize + +osd2 +. +hurd2 +. +h_i_fsize +; + + ) + +286  + #i_uid_high + +osd2 +. +hurd2 +. +h_i_uid_high + + + ) + +287  + #i_gid_high + +osd2 +. +hurd2 +. +h_i_gid_high + + + ) + +288  + #i_auth + +osd2 +. +hurd2 +. +h_i_auth + + + ) + +291 #ifdef +__masix__ + + +292  + #i_rved1 + +osd1 +. +masix1 +. +m_i_rved1 + + + ) + +293  + #i_ag + +osd2 +. +masix2 +. +m_i_ag + + + ) + +294  + #i_fsize + +osd2 +. +masix2 +. +m_i_fsize + + + ) + +295  + #i_rved2 + +osd2 +. +masix2 +. +m_i_rved2 + + + ) + +301  + #EXT2_VALID_FS + 0x0001 + + ) + +302  + #EXT2_ERROR_FS + 0x0002 + + ) + +307  + #EXT2_MOUNT_CHECK + 0x0001 + + ) + +308  + #EXT2_MOUNT_GRPID + 0x0004 + + ) + +309  + #EXT2_MOUNT_DEBUG + 0x0008 + + ) + +310  + #EXT2_MOUNT_ERRORS_CONT + 0x0010 + + ) + +311  + #EXT2_MOUNT_ERRORS_RO + 0x0020 + + ) + +312  + #EXT2_MOUNT_ERRORS_PANIC + 0x0040 + + ) + +313  + #EXT2_MOUNT_MINIX_DF + 0x0080 + + ) + +314  + #EXT2_MOUNT_NO_UID32 + 0x0200 + + ) + +316  + #r_t +( +o +, +t +&~ +EXT2_MOUNT_ +## + ) +opt + +317  + #t_t +( +o +, +t +| +EXT2_MOUNT_ +## + ) +opt + +318  + #_t +( +sb +, +t +((sb)-> +u +. +ext2_sb +. +s_mou_t + & \ + +319 +EXT2_MOUNT_ +## +t +) + + ) + +323  + #EXT2_DFL_MAX_MNT_COUNT + 20 + + ) + +324  + #EXT2_DFL_CHECKINTERVAL + 0 + + ) + +329  + #EXT2_ERRORS_CONTINUE + 1 + + ) + +330  + #EXT2_ERRORS_RO + 2 + + ) + +331  + #EXT2_ERRORS_PANIC + 3 + + ) + +332  + #EXT2_ERRORS_DEFAULT + +EXT2_ERRORS_CONTINUE + + + ) + +337  + sext2_sur_block + { + +338 +__u32 + + ms_odes_cou +; + +339 +__u32 + + ms_blocks_cou +; + +340 +__u32 + + ms_r_blocks_cou +; + +341 +__u32 + + ms__blocks_cou +; + +342 +__u32 + + ms__odes_cou +; + +343 +__u32 + + ms_f_da_block +; + +344 +__u32 + + ms_log_block_size +; + +345 +__s32 + + ms_log_ag_size +; + +346 +__u32 + + ms_blocks_r_group +; + +347 +__u32 + + ms_ags_r_group +; + +348 +__u32 + + ms_odes_r_group +; + +349 +__u32 + + ms_mtime +; + +350 +__u32 + + ms_wtime +; + +351 +__u16 + + ms_m_cou +; + +352 +__s16 + + ms_max_m_cou +; + +353 +__u16 + + ms_magic +; + +354 +__u16 + + ms_e +; + +355 +__u16 + + ms_rs +; + +356 +__u16 + + ms_m_v_v +; + +357 +__u32 + + ms_ϡcheck +; + +358 +__u32 + + ms_checkrv +; + +359 +__u32 + + ms_t_os +; + +360 +__u32 + + ms_v_v +; + +361 +__u16 + + ms_def_suid +; + +362 +__u16 + + ms_def_sgid +; + +376 +__u32 + + ms_f_o +; + +377 +__u16 + + ms_ode_size +; + +378 +__u16 + + ms_block_group_ +; + +379 +__u32 + + ms_u_comt +; + +380 +__u32 + + ms_u_comt +; + +381 +__u32 + + ms_u_ro_comt +; + +382 +__u8 + + ms_uuid +[16]; + +383  + ms_vume_me +[16]; + +384  + ms_ϡ_moued +[64]; + +385 +__u32 + + ms_gܙhm_uge_bm +; + +390 +__u8 + + ms_oc_blocks +; + +391 +__u8 + + ms_oc_d_blocks +; + +392 +__u16 + + ms_ddg1 +; + +393 +__u32 + + ms_rved +[204]; + +396 #ifde +__KERNEL__ + + +397  + #EXT2_SB +( +sb +(&((sb)-> +u +. +ext2_sb +)) + + ) + +402  + #EXT2_SB +( +sb +(sb) + + ) + +408  + #EXT2_OS_LINUX + 0 + + ) + +409  + #EXT2_OS_HURD + 1 + + ) + +410  + #EXT2_OS_MASIX + 2 + + ) + +411  + #EXT2_OS_FREEBSD + 3 + + ) + +412  + #EXT2_OS_LITES + 4 + + ) + +417  + #EXT2_GOOD_OLD_REV + 0 + + ) + +418  + #EXT2_DYNAMIC_REV + 1 + + ) + +420  + #EXT2_CURRENT_REV + +EXT2_GOOD_OLD_REV + + + ) + +421  + #EXT2_MAX_SUPP_REV + +EXT2_DYNAMIC_REV + + + ) + +423  + #EXT2_GOOD_OLD_INODE_SIZE + 128 + + ) + +429  + #EXT2_HAS_COMPAT_FEATURE +( +sb +, +mask +) \ + +430 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_comt + & + `u_to_32 +( +mask +) + + ) + +431  + #EXT2_HAS_RO_COMPAT_FEATURE +( +sb +, +mask +) \ + +432 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_ro_comt + & + `u_to_32 +( +mask +) + + ) + +433  + #EXT2_HAS_INCOMPAT_FEATURE +( +sb +, +mask +) \ + +434 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_comt + & + `u_to_32 +( +mask +) + + ) + +435  + #EXT2_SET_COMPAT_FEATURE +( +sb +, +mask +) \ + +436 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_comt + | + `u_to_32 +( +mask +) + + ) + +437  + #EXT2_SET_RO_COMPAT_FEATURE +( +sb +, +mask +) \ + +438 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_ro_comt + | + `u_to_32 +( +mask +) + + ) + +439  + #EXT2_SET_INCOMPAT_FEATURE +( +sb +, +mask +) \ + +440 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_comt + | + `u_to_32 +( +mask +) + + ) + +441  + #EXT2_CLEAR_COMPAT_FEATURE +( +sb +, +mask +) \ + +442 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_comt + &~ + `u_to_32 +( +mask +) + + ) + +443  + #EXT2_CLEAR_RO_COMPAT_FEATURE +( +sb +, +mask +) \ + +444 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_ro_comt + &~ + `u_to_32 +( +mask +) + + ) + +445  + #EXT2_CLEAR_INCOMPAT_FEATURE +( +sb +, +mask +) \ + +446 + `EXT2_SB +( +sb +)-> +s_es +-> +s_u_comt + &~ + `u_to_32 +( +mask +) + + ) + +448  + #EXT2_FEATURE_COMPAT_DIR_PREALLOC + 0x0001 + + ) + +450  + #EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER + 0x0001 + + ) + +451  + #EXT2_FEATURE_RO_COMPAT_LARGE_FILE + 0x0002 + + ) + +452  + #EXT2_FEATURE_RO_COMPAT_BTREE_DIR + 0x0004 + + ) + +454  + #EXT2_FEATURE_INCOMPAT_COMPRESSION + 0x0001 + + ) + +455  + #EXT2_FEATURE_INCOMPAT_FILETYPE + 0x0002 + + ) + +457  + #EXT2_FEATURE_COMPAT_SUPP + 0 + + ) + +458  + #EXT2_FEATURE_INCOMPAT_SUPP + +EXT2_FEATURE_INCOMPAT_FILETYPE + + + ) + +459  + #EXT2_FEATURE_RO_COMPAT_SUPP + ( +EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER +| \ + +460 +EXT2_FEATURE_RO_COMPAT_LARGE_FILE +| \ + +461 +EXT2_FEATURE_RO_COMPAT_BTREE_DIR +) + + ) + +466  + #EXT2_DEF_RESUID + 0 + + ) + +467  + #EXT2_DEF_RESGID + 0 + + ) + +472  + #EXT2_NAME_LEN + 255 + + ) + +474  + sext2_d_y + { + +475 +__u32 + + mode +; + +476 +__u16 + + mc_n +; + +477 +__u16 + + mme_n +; + +478  + mme +[ +EXT2_NAME_LEN +]; + +487  + sext2_d_y_2 + { + +488 +__u32 + + mode +; + +489 +__u16 + + mc_n +; + +490 +__u8 + + mme_n +; + +491 +__u8 + + mfe_ty +; + +492  + mme +[ +EXT2_NAME_LEN +]; + +499  + #EXT2_FT_UNKNOWN + 0 + + ) + +500  + #EXT2_FT_REG_FILE + 1 + + ) + +501  + #EXT2_FT_DIR + 2 + + ) + +502  + #EXT2_FT_CHRDEV + 3 + + ) + +503  + #EXT2_FT_BLKDEV + 4 + + ) + +504  + #EXT2_FT_FIFO + 5 + + ) + +505  + #EXT2_FT_SOCK + 6 + + ) + +506  + #EXT2_FT_SYMLINK + 7 + + ) + +508  + #EXT2_FT_MAX + 8 + + ) + +515  + #EXT2_DIR_PAD + 4 + + ) + +516  + #EXT2_DIR_ROUND + ( +EXT2_DIR_PAD + - 1) + + ) + +517  + #EXT2_DIR_REC_LEN +( +me_n +((ame_n+ 8 + +EXT2_DIR_ROUND +) & \ + +518 ~ +EXT2_DIR_ROUND +) + + ) + +520 #ifde +__KERNEL__ + + +529  + #NORET_TYPE + + + ) + +530  + #ATTRIB_NORET + + `__ibu__ +(( +nܑu +)) + + ) + +531  + #NORET_AND + +nܑu +, + + ) + +534  +ext2_rmissi + ( +ode + *, ); + +537  +ext2_bg_has_sur +( +sur_block + * +sb +,  +group +); + +538  +ext2_bg_num_gdb +( +sur_block + * +sb +,  +group +); + +539  +ext2_w_block + (cڡ  +ode + *, , + +540 +__u32 + *, __u32 *, *); + +541  +ext2__blocks + (cڡ  +ode + *, , + +543  +ext2_cou__blocks + ( +sur_block + *); + +544  +ext2_check_blocks_bm + ( +sur_block + *); + +545  +ext2_group_desc + * +ext2_g_group_desc +( +sur_block + * +sb +, + +546  +block_group +, + +547  +bufr_hd + ** +bh +); + +550  +ext2_cou_ + ( +bufr_hd + *, ); + +553  +ext2_check_d_y + (cڡ *,  +ode + *, + +554  +ext2_d_y_2 + *,  +bufr_hd + *, + +558  +ext2_ad + ( +ode + *,  +fe + *, *, ); + +559  +ext2_wre + ( +ode + *,  +fe + *, *, ); + +562  +ext2_sync_fe + ( +fe + *,  +dy + *, ); + +563  +ext2_fsync_ode + ( +ode + *, ); + +566  +ode + * +ext2_w_ode + (const inode *, ); + +567  +ext2__ode + ( +ode + *); + +568  +ext2_cou__odes + ( +sur_block + *); + +569  +ext2_check_odes_bm + ( +sur_block + *); + +573  +bufr_hd + * +ext2_gblk + ( +ode + *, , , *); + +574  +bufr_hd + * +ext2_bad + ( +ode + *, , , *); + +576  +ext2_ad_ode + ( +ode + *); + +577  +ext2_wre_ode + ( +ode + *, ); + +578  +ext2_put_ode + ( +ode + *); + +579  +ext2_de_ode + ( +ode + *); + +580  +ext2_sync_ode + ( +ode + *); + +581  +ext2_disrd_oc + ( +ode + *); + +584  +ext2_iol + ( +ode + *,  +fe + *, , + +588  +ode_ݔis + +ext2_d_ode_ݔis +; + +591  + $ext2_r + ( +sur_block + *, const *, const *, ...) + +592 + `__ibu__ + (( + `fm + ( +tf +, 3, 4))); + +593 +NORET_TYPE +  + $ext2_nic + ( +sur_block + *, const *, + +595 + `__ibu__ + (( +NORET_AND + + `fm + ( +tf +, 3, 4))); + +596  + $ext2_wng + ( +sur_block + *, const *, const *, ...) + +597 + `__ibu__ + (( + `fm + ( +tf +, 3, 4))); + +598  + `ext2_upde_dymic_v + ( +sur_block + * +sb +); + +599  + `ext2_put_sur + ( +sur_block + *); + +600  + `ext2_wre_sur + ( +sur_block + *); + +601  + `ext2_mou + ( +sur_block + *, *, *); + +602  +sur_block + * + `ext2_ad_sur + (super_block *,*,); + +603  + `ext2_fs + ( +sur_block + *,  +fs + *); + +606  + `ext2_un + ( +ode + *); + +613  +fe_ݔis + +ext2_d_ݔis +; + +616  +ode_ݔis + +ext2_fe_ode_ݔis +; + +617  +fe_ݔis + +ext2_fe_ݔis +; + +620  +ode_ݔis + +ext2__symlk_ode_ݔis +; + +622  +addss_a_ݔis + +ext2_as +; + + @fs/ext2_fs_i.h + +16 #ide +_LINUX_EXT2_FS_I + + +17  + #_LINUX_EXT2_FS_I + + + ) + +22  + sext2_ode_fo + { + +23 +__u32 + + mi_da +[15]; + +24 +__u32 + + mi_ags +; + +25 +__u32 + + mi_ddr +; + +26 +__u8 + + mi_ag_no +; + +27 +__u8 + + mi_ag_size +; + +28 +__u16 + + mi_osync +; + +29 +__u32 + + mi_fe_a +; + +30 +__u32 + + mi_d_a +; + +31 +__u32 + + mi_dtime +; + +32 +__u32 + + mn_ud_1 +; + +33 +__u32 + + mi_block_group +; + +34 +__u32 + + mi_xt_loc_block +; + +35 +__u32 + + mi_xt_loc_gl +; + +36 +__u32 + + mi_oc_block +; + +37 +__u32 + + mi_oc_cou +; + +38 +__u32 + + mi_high_size +; + +39  + mi_w_ode +:1; + + @fs/ext2_fs_sb.h + +16 #ide +_LINUX_EXT2_FS_SB + + +17  + #_LINUX_EXT2_FS_SB + + + ) + +25  + #EXT2_MAX_GROUP_LOADED + 8 + + ) + +30  + sext2_sb_fo + { + +31  + ms_ag_size +; + +32  + ms_ags_r_block +; + +33  + ms_odes_r_block +; + +34  + ms_ags_r_group +; + +35  + ms_blocks_r_group +; + +36  + ms_odes_r_group +; + +37  + ms_b_r_group +; + +38  + ms_gdb_cou +; + +39  + ms_desc_r_block +; + +40  + ms_groups_cou +; + +41  +bufr_hd + * + ms_sbh +; + +42  +ext2_sur_block + * + ms_es +; + +43  +bufr_hd + ** + ms_group_desc +; + +44  + ms_lded_ode_bms +; + +45  + ms_lded_block_bms +; + +46  + ms_ode_bm_numb +[ +EXT2_MAX_GROUP_LOADED +]; + +47  +bufr_hd + * + ms_ode_bm +[ +EXT2_MAX_GROUP_LOADED +]; + +48  + ms_block_bm_numb +[ +EXT2_MAX_GROUP_LOADED +]; + +49  +bufr_hd + * + ms_block_bm +[ +EXT2_MAX_GROUP_LOADED +]; + +50  + ms_mou_t +; + +51 +uid_t + + ms_suid +; + +52 +gid_t + + ms_sgid +; + +53  + ms_mou_e +; + +54  + ms_d +; + +55  + ms_addr_r_block_bs +; + +56  + ms_desc_r_block_bs +; + +57  + ms_ode_size +; + +58  + ms_f_o +; + + @fs/ext2_private.h + +26 #ide +__FS_EXT2FS_PRIVATE_H__ + + +27  + #__FS_EXT2FS_PRIVATE_H__ + + + ) + +33  +UINT32 + + t__u32 +; + +34  +INT32 + + t__s32 +; + +35  +UINT16 + + t__u16 +; + +36  +INT16 + + t__s16 +; + +37  +UINT8 + + t__u8 +; + +38  +INT8 + + t__s8 +; + +39  +UINT32 + + tuid_t +; + +40  +UINT32 + + tgid_t +; + +45  + #S_IFMT + 00170000 + + ) + +46  + #S_IFSOCK + 0140000 + + ) + +47  + #S_IFLNK + 0120000 + + ) + +48  + #S_IFREG + 0100000 + + ) + +49  + #S_IFBLK + 0060000 + + ) + +50  + #S_IFDIR + 0040000 + + ) + +51  + #S_IFCHR + 0020000 + + ) + +52  + #S_IFIFO + 0010000 + + ) + +53  + #S_ISUID + 0004000 + + ) + +54  + #S_ISGID + 0002000 + + ) + +55  + #S_ISVTX + 0001000 + + ) + +57  + #S_ISLNK +( +m +(((m& +S_IFMT += +S_IFLNK +) + + ) + +58  + #S_ISREG +( +m +(((m& +S_IFMT += +S_IFREG +) + + ) + +59  + #S_ISDIR +( +m +(((m& +S_IFMT += +S_IFDIR +) + + ) + +60  + #S_ISCHR +( +m +(((m& +S_IFMT += +S_IFCHR +) + + ) + +61  + #S_ISBLK +( +m +(((m& +S_IFMT += +S_IFBLK +) + + ) + +62  + #S_ISFIFO +( +m +(((m& +S_IFMT += +S_IFIFO +) + + ) + +63  + #S_ISSOCK +( +m +(((m& +S_IFMT += +S_IFSOCK +) + + ) + +66  + ~"fs/ext2_fs.h +" + +67  + ~"fs/ext2_fs_sb.h +" + +68  + ~"fs/ext2_fs_i.h +" + + @fs/ext2fs.c + +32  + ~ + +33  + ~ + +35  + ~"o.h +" + +37  + #FS_NAME + +L +"ext2fs" + + ) + +39 #ifde +PATH_MAX + + +40 #r +You + +mu + +have + +uded + +some + +Lux + +hd + +fe + +by + +r + + +43  + #PATH_MAX + 4095 + + ) + +44  + #EXT2FS_PATH_MAXLEN + +PATH_MAX + + + ) + +46  + ~"fs/ext2fs.h +" + +47  + ~"fs/ext2_ive.h +" + +53  + #EXT2FS_MEMTYPE + +EfiLdDa + + + ) + +56  + #EXT2_FILESIZE_MAX + (0x100000000UL) + + ) + +62  + #MAX_OPEN_FILES + 32 + + ) + +64  + sode_b_y + { + +65  +ext2_ode + + mode +; + +66  + mumb +; + +67  + m +; + +68  + md_mode +; + +70 +UINT32 + + mpos +; + +71 } + tode_y_t +; + +75  +ext2_sur_block + + msb +; + +76  +ext2_group_desc + * + mgds +; + +77  +ext2_ode + * + mro_ode +; + +78  + mngroups +; + +79  + mdelim +; + +80  + md1lim +; + +81  + md2lim +; + +82  + mrs_r_blk +; + +83 +CHAR8 + + mblkbuf +[ +EXT2_MAX_BLOCK_SIZE +]; + +84  + mched_iblkno +; + +85 +CHAR8 + + miblkbuf +[ +EXT2_MAX_BLOCK_SIZE +]; + +86  + mched_diblkno +; + +87 +CHAR8 + + mdiblkbuf +[ +EXT2_MAX_BLOCK_SIZE +]; + +88  + mblocksize +; + +91 +ode_y_t + + mode_b +[ +MAX_OPEN_FILES +]; + +94 +EFI_BLOCK_IO + * + mblkio +; + +95 +UINT32 + + mmedid +; + +96 +EFI_HANDLE + + mdev +; + +97 } + text2fs_iv_e_t +; + +101 +ext2fs_r_t + + mpub_tf +; + +103 +ext2fs_r_t + + mpub_tf +; + +104 +ext2fs_iv_e_t + + miv_da +; + +105 } + mext2fs_iv +; + +106 } + text2fs_t +; + +108  + #FS_PRIVATE +( +n +(&((( +ext2fs_t + *)-> +ext2fs_iv +. +iv_da +)) + + ) + +111 +EFI_HANDLE + * + mdev +; + +112 +ext2fs_t + * + mtf +; + +113 } + tdev_b_t +; + +115  +dev_b_t + * + gdev_b +; + +116  +UINTN + + gndev +; + +119  +EFI_GUID + + gExt2FsProc + = +EXT2FS_PROTOCOL +; + +121  +INTN + + +122 + $ad_bys +( +EFI_BLOCK_IO + * +blkio +, +UINT32 + +medid +, +UINTN + +offt +, +VOID + * +addr +, UINTN +size +) + +124 +EFI_STATUS + +us +; + +125 +UINT8 + * +bufr +; + +126 +UINTN + +cou +, +bufr_size +; + +127 +EFI_LBA + +ba +; + +128 +INTN + +t + = +EFI_INVALID_PARAMETER +; + +130 +ba + = +offt + / +blkio +-> +Med +-> +BlockSize +; + +131 +cou + = ( +size + + +blkio +-> +Med +-> +BlockSize + -1) / blkio->Media->BlockSize; + +132 +bufr_size + = +cou + * +blkio +-> +Med +-> +BlockSize +; + +134 + `DBG_PRT +(( +L +"adblock(%x, %d,%dba=%d cou=%d", +blkio +, +offt +, +size +, +ba +, +cou +)); + +139 +bufr + = ( +UINT8 + *) + `loc +( +bufr_size +, +EfiLdDa +); + +140 i( +bufr + = +NULL +) { + +141 + `ERR_PRT +(( +L +"هoxt2fbufsize=%d", +bufr_size +)); + +142  +t +; + +145 + `DBG_PRT +(( +L +"adblock(%x, %d, %d, %d, %x)", +blkio +, +medid +, +ba +, +bufr_size +, +bufr +)); + +147 +us + = +blkio +-> + `RdBlocks +(blkio, +medid +, +ba +, +bufr_size +, +bufr +); + +148 i( + `EFI_ERROR +( +us +)) { + +149 + `ERR_PRT +(( +L +"adblock(%d,%d)=%r", +ba +, +bufr_size +, +us +)); + +150  +r +; + +153 + `DBG_PRT +(( +L +"adblock(%d,%d)->%r", +offt +, +bufr_size +, +us +)); + +155 + `Memy +( +addr +, +bufr ++( +offt +-( +ba +* +blkio +-> +Med +-> +BlockSize +)), +size +); + +157 +t + = 0; + +159 +r +: + +160 + ` +( +bufr +); + +162  +t +; + +163 + } +} + +169  +ext2_ode + * + +170 + $ext2_ig +( +ext2fs_iv_e_t + * +e2fs +,  +o +) + +172  +i +; + +173  +ext2_ode + * + +; + +174  +ode_b_y + * +p + = 0; + +175  +group +; + +176  +offt +; + +178 + + = 0; + +179  +i + = 0; i < +MAX_OPEN_FILES +; i++) { + +180 + `DBG_PRT +(( +L +"ext2_iget:ooping,ntry %d inode %d free %d", + +181 +i +, +e2fs +-> +ode_b +[i]. +umb +,2fs->ode_b[i]. + +)); + +182 i( +e2fs +-> +ode_b +[ +i +]. + +) { + +183 +p + = & +e2fs +-> +ode_b +[ +i +]; + +184 + + = & +p +-> +ode +; + +188 i(! + +) { + +189 + `ERR_PRT +(( +L +"ext2_iget:o free inodes")); + +190  +NULL +; + +194 +group + = ( +o +-1/ +e2fs +-> +sb +. +s_odes_r_group +; + +196 + `DBG_PRT +(( +L +" i-ode_b=%d bg_ode_b=%d group=%d ino=%d\n", ( +UINTN +)( +p +- +e2fs +-> +ode_b +), + +197 ( +UINTN +)( +e2fs +-> +gds +[ +group +]. +bg_ode_b +), (UINTN)group, (UINTN) +o +)); + +199 +offt + = (( +e2fs +-> +gds +[ +group +]. +bg_ode_b + *2fs-> +blocksize +) + +200 + ((( +o + - 1% + `EXT2_INODES_PER_GROUP +(& +e2fs +-> +sb +)* + `EXT2_INODE_SIZE +(&e2fs->sb)); + +202 + `DBG_PRT +(( +L +"ext2_iget:eading %d bytest offset %d" + +205 ( +ext2_ode +), + +206 ( +UINTN +) +offt +, + +207 ( +UINTN +) +e2fs +-> +gds +[ +group +]. +bg_ode_b +, (UINTN2fs-> +blocksize +, + +208 ( +UINTN +)( +o + - 1), (UINTN) + `EXT2_INODES_PER_GROUP +(& +e2fs +-> +sb +), + `EXT2_INODE_SIZE +(&e2fs->sb), + +209 ( +UINTN +) +o +, (UINTN( +p + - +e2fs +-> +ode_b +))); + +211 i( + `ad_bys +( +e2fs +-> +blkio +,2fs-> +medid +, +offt +, + +, ( +ext2_ode +))) { + +212 + `ERR_PRT +(( +L +"ext2_iget:eadrror")); + +213  +NULL +; + +216 + `DBG_PRT +(( +L +"mode=%x uid=%d size=%d gid=%dinks=%d flags=%d", + +217 ( +UINTN +) + +-> +i_mode +, + +218 ( +UINTN +) + +-> +i_uid +, + +219 ( +UINTN +) + +-> +i_size +, + +220 ( +UINTN +) + +-> +i_gid +, + +221 ( +UINTN +) + +-> +i_ags +)); + +223 +p +-> + + = 0; + +224 +p +-> +umb + = +o +; + +225 +p +-> +d_mode + = + +-> +i_mode +; + +227  + +; + +228 + } +} + +236 + $ext2_ut +( +ext2fs_iv_e_t + * +e2fs +,  +ext2_ode + * + +) + +238  +ode_b_y + * +p +; + +241 +p + = ( +ode_b_y + *) + +; + +243 + `DBG_PRT +(( +L +"ext2_ut: inod%dab %d", +p +-> +umb +, ((- +e2fs +-> +ode_b +))); + +245 +p +-> +umb + = 0; + +246 +p +-> + + = 1; + +247 + } +} + +260 + $ext2_blkno +( +ext2fs_iv_e_t + * +e2fs +,  +ext2_ode + * + +,  +blkoff +) + +262 * + +; + +263 * +p +; + +264 * +d +; + +265  +blkno +; + +266  +iblkno +; + +267  +diblkno +; + +268  +offt +; + +270 +p + = (*) +e2fs +-> +iblkbuf +; + +271 +d + = (*) +e2fs +-> +diblkbuf +; + +272 + + = (*) +e2fs +-> +blkbuf +; + +275 i( +blkoff + < +e2fs +-> +delim +) { + +276  + +-> +i_block +[ +blkoff +]; + +280 i( +blkoff + < +e2fs +-> +d1lim +) { + +281 +iblkno + = + +-> +i_block +[ +EXT2_IND_BLOCK +]; + +283 i( +iblkno + == 0) { + +288 i( +e2fs +-> +ched_iblkno + ! +iblkno +) { + +289 +offt + = +iblkno + * +e2fs +-> +blocksize +; + +290 i( + `ad_bys +( +e2fs +-> +blkio +,2fs-> +medid +, +offt +,2fs-> +iblkbuf +,2fs-> +blocksize +)) { + +291 + `ERR_PRT +(( +L +"ext2_blkno:rror on iblkead")); + +294 +e2fs +-> +ched_iblkno + = +iblkno +; + +297 +blkno + = +p +[ +blkoff +-( +e2fs +-> +delim ++1)]; + +298  +blkno +; + +302 i( +blkoff + < +e2fs +-> +d2lim +) { + +304 +diblkno + = + +-> +i_block +[ +EXT2_DIND_BLOCK +]; + +306 i( +diblkno + == 0) { + +311 i( +e2fs +-> +ched_diblkno + ! +diblkno +) { + +312 +offt + = +diblkno + * +e2fs +-> +blocksize +; + +313 i( + `ad_bys +( +e2fs +-> +blkio +,2fs-> +medid +, +offt +,2fs-> +diblkbuf +,2fs-> +blocksize +)) { + +314 + `ERR_PRT +(( +L +"ext2_blkno:rreading dindr blk")); + +317 +e2fs +-> +ched_diblkno + = +diblkno +; + +321 +iblkno + = +d +[( +blkoff + - ( +e2fs +-> +d1lim ++1)/2fs-> +rs_r_blk +]; + +323 i( +iblkno + == 0) { + +329 i( +e2fs +-> +ched_iblkno + ! +iblkno +) { + +330 +offt + = +iblkno + * +e2fs +-> +blocksize +; + +331 i( + `ad_bys +( +e2fs +-> +blkio +,2fs-> +medid +, +offt +,2fs-> +iblkbuf +,2fs-> +blocksize +)) { + +332 + `ERR_PRT +(( +L +"ext2_blkno:rr on iblkead")); + +335 +e2fs +-> +ched_iblkno + = +iblkno +; + +339 +blkno + = +p +[( +blkoff +-( +e2fs +-> +d1lim ++1)%2fs-> +rs_r_blk +]; + +340  +blkno +; + +343 i( +blkoff + > +e2fs +-> +d2lim +) { + +344 + `ERR_PRT +(( +L +"ext2_blkno: blockumborge: %d", +blkoff +)); + +348 + } +} + +352 + $ext2_badi +( +ext2fs_iv_e_t + * +e2fs +,  +ext2_ode + * + +,  +blkno +,  +nblks +, +CHAR8 + * +bufr +) + +354  +dev_blkno +, +nctig +, +offt +, +nbys +, +t_bys +; + +356 +t_bys + = 0; + +357 i(( +blkno ++ +nblks +)* +e2fs +-> +blocksize + > + +-> +i_size +) + +358 +nblks + = ( + +-> +i_size + + +e2fs +-> +blocksize +/2fs->blocksiz- +blkno +; + +360  +nblks +) { + +365 +nctig + = 0; +nbys + = 0; + +366 +dev_blkno + = + `ext2_blkno +( +e2fs +, + +, +blkno +); + +368 ++ +blkno +; ++ +nctig +; -- +nblks +; + +369 +nbys + + +e2fs +-> +blocksize +; + +370 }  +nblks + && + +371 + `ext2_blkno +( +e2fs +, + +, +blkno += +dev_blkno + + +nctig +); + +373 i( +dev_blkno + == 0) { + +375 + `Memt +( +bufr +, 0, +nbys +); + +378 +offt + = +dev_blkno +* +e2fs +-> +blocksize +; + +379 + `DBG_PRT +(( +L +"ext2_bad:dg %d by off%d", +nbys +, +offt +)); + +381 i( + `ad_bys +( +e2fs +-> +blkio +,2fs-> +medid +, +offt +, +bufr +, +nbys +)) { + +382 + `ERR_PRT +(( +L +"ext2_bread:eadrror")); + +386 +bufr + + +nbys +; + +387 +t_bys + + +nbys +; + +389  +t_bys +; + +390 + } +} + +392  +ext2_d_y_2 + * + +393 + $ext2_addi +( +ext2fs_iv_e_t + * +e2fs +,  +ext2_ode + * +d_ode +,  +wd +) + +395  +ext2_d_y_2 + * +dp +; + +396  +dofft + = 0, +blockofft + = 0; + +399 i( +wd +) { + +400 +dofft + = 0; + +401 +blockofft + = 0; + +403 i( + `ext2_badi +( +e2fs +, +d_ode +, 0, 1,2fs-> +blkbuf +) < 0) + +404  +NULL +; + +407 + `DBG_PRT +(( +L +"ext2_addi: blkoff%d doff%d %d", +blockofft +, +dofft +, +d_ode +-> +i_size +)); + +409 i( +blockofft + > +e2fs +-> +blocksize +) { + +410 +dofft + + +e2fs +-> +blocksize +; + +411 i( +dofft + > +d_ode +-> +i_size +) + +412  +NULL +; + +413 + `ERR_PRT +(( +L +"ext2_addi:dg block%d", +dofft +)); + +415 i( + `ext2_badi +( +e2fs +, +d_ode +, +dofft + /2fs-> +blocksize +, 1,2fs-> +blkbuf +< 0 +NULL +; + +416 +blockofft + = 0; + +419 +dp + = ( +ext2_d_y_2 + *( +e2fs +-> +blkbuf + + +blockofft +); + +420 +blockofft + + +dp +-> +c_n +; + +423 + `Prt +( +L +"ext2_readdiri:eturning %x = "); + +424 { +INTN + +i +; i=0; i < +dp +-> +me_n +; i++ + `Prt +( +L +"%c", ( +CHAR16 +)dp-> +me +[i]); Print(L"\n");} + +426  +dp +; + +427 + } +} + +433  +ext2_ode + * + +434 + $ext2_mei +( +ext2fs_iv_e_t + * +e2fs +, +CHAR8 + * +me +) + +436 +CHAR8 + * +compڒt +; + +437  +ext2_ode + * +d_ode +; + +438  +ext2_d_y_2 + * +dp +; + +439  +xt_o +; + +442 i(! +e2fs +-> +ro_ode +) + +443 +e2fs +-> +ro_ode + = + `ext2_ig +2fs, +EXT2_ROOT_INO +); + +444 +d_ode + = +e2fs +-> +ro_ode +; + +445 i(! +d_ode +) + +446  +NULL +; + +448 +compڒt + = + `ok_sime +( +me +, '/'); + +449  +compڒt +) { + +450  +compڒt_ngth +; + +451  +wd + = 0; + +456 +xt_o + = -1; + +457 +compڒt_ngth + = + `a +( +compڒt +); + +459 + `DBG_PRT +(( +L +"ext2_mei: compڒ%a", +compڒt +)); + +462 ( +dp + = + `ext2_addi +( +e2fs +, +d_ode +, ! +wd +++))) { + +463 i(( +dp +-> +me_n + = +compڒt_ngth +) && + +464 ( + `cm +( +compڒt +, +dp +-> +me +, + +465 +compڒt_ngth +) == 0)) + +468 + `DBG_PRT +(( +L +"ext2_mei: foundry %a", +compڒt +)); + +469 +xt_o + = +dp +-> +ode +; + +472 + `DBG_PRT +(( +L +"ext2_namei:ooping")); + +475 + `DBG_PRT +(( +L +"ext2_mei:ext_%d", +xt_o +)); + +481 i( +d_ode + ! +e2fs +-> +ro_ode + + `ext2_ut +(e2fs, dir_inode); + +487 i( +xt_o + < 0) { + +488  +NULL +; + +495 +d_ode + = + `ext2_ig +( +e2fs +, +xt_o +); + +496 i(! +d_ode +) + +497  +NULL +; + +499 +compڒt + = + `ok_sime +( +NULL +, '/'); + +506  +d_ode +; + +507 + } +} + +514 + $ext2_bad +( +ext2fs_iv_e_t + * +e2fs +,  +fd +,  +blkno +,  +nblks +, * +bufr +) + +516  +ext2_ode + * + +; + +517 + + = & +e2fs +-> +ode_b +[ +fd +]. +ode +; + +518  + `ext2_badi +( +e2fs +, + +, +blkno +, +nblks +, +bufr +); + +519 + } +} + +527 + $ext2_add +( +ext2fs_iv_e_t + * +e2fs +,  +fd +,  +wd +) + +529  +ext2_ode + * + + = & +e2fs +-> +ode_b +[ +fd +]. +ode +; + +530  +ext2_d_y_2 + * +t +; + +531 i(! + `S_ISDIR +( + +-> +i_mode +)) { + +532 + `ERR_PRT +(( +L +"fd %d (inode %d) isot directory (mode %x)", + +533 +fd +, +e2fs +-> +ode_b +[fd]. +umb +, + +-> +i_mode +)); + +534  +NULL +; + +536 +t + = + `ext2_addi +( +e2fs +, + +, +wd +); + +537 i( +t +) { + +538 +t +-> +me +[t-> +me_n +] = '\0'; + +539  +t +-> +me +; + +541  +NULL +; + +543 + } +} + +547 + $ext2_f +( +ext2fs_iv_e_t + * +e2fs +,  +fd +, +ext2fs__t + * +buf +) + +549  +ext2_ode + * + + = & +e2fs +-> +ode_b +[ +fd +]. +ode +; + +551 + `Memt +( +buf +, 0, (*buf)); + +554 +buf +-> +_o + = +e2fs +-> +ode_b +[ +fd +]. +umb +; + +555 +buf +-> +_mode + = + +-> +i_mode +; + +556 +buf +-> +_ƚk + = + +-> +i_lks_cou +; + +557 +buf +-> +_uid + = + +-> +i_uid +; + +558 +buf +-> +_gid + = + +-> +i_gid +; + +559 +buf +-> +_size + = + +-> +i_size +; + +560 +buf +-> +_ime + = + +-> +i_ime +; + +561 +buf +-> +_mtime + = + +-> +i_mtime +; + +562 +buf +-> +_ime + = + +-> +i_ime +; + +565 + } +} + +567  +EFI_STATUS + + +568 + $ext2fs_f +( +ext2fs_r_t + * +this +, +UINTN + +fd +, +ext2fs__t + * + +) + +570 +ext2fs_iv_e_t + * +e2fs +; + +572 i( +this + = +NULL + || +fd + > +MAX_OPEN_FILES + || + + =NULL +EFI_INVALID_PARAMETER +; + +574 +e2fs + = + `FS_PRIVATE +( +this +); + +576 + `ext2_f +( +e2fs +, +fd +, + +); + +578  +EFI_SUCCESS +; + +579 + } +} + +581  +EFI_STATUS + + +582 + $ext2fs_ek +( +ext2fs_r_t + * +this +, +UINTN + +fd +, +UINT64 + +wpos +) + +584 +ext2fs_iv_e_t + * +e2fs +; + +586 i( +this + = +NULL + || +fd + > +MAX_OPEN_FILES + || +wpos + > +EXT2_FILESIZE_MAX + +EFI_INVALID_PARAMETER +; + +588 +e2fs + = + `FS_PRIVATE +( +this +); + +589 i( +wpos + > ( +UINT64 +) +e2fs +-> +ode_b +[ +fd +]. +ode +. +i_size + +EFI_INVALID_PARAMETER +; + +591 +e2fs +-> +ode_b +[ +fd +]. +pos + = +wpos +; + +593  +EFI_SUCCESS +; + +594 + } +} + +596  +EFI_STATUS + + +597 + $ext2fs_ad +( +ext2fs_r_t + * +this +, +UINTN + +fd +, +VOID + * +buf +, UINTN * +size +) + +599 +ext2fs_iv_e_t + * +e2fs +; + +600 +UINTN + +cou +, +nc +, +bofs +, +bnum +, +pos +; + +601 +EFI_STATUS + +t + = +EFI_INVALID_PARAMETER +; + +602 +CHAR8 + * +block +; + +604 i( +this + = +NULL + || +size + =NULL || +buf + =NULL || +fd + > +MAX_OPEN_FILES + +EFI_INVALID_PARAMETER +; + +606 +e2fs + = + `FS_PRIVATE +( +this +); + +608 +cou + = + `MIN +(* +size +, +e2fs +-> +ode_b +[ +fd +]. +ode +. +i_size + -2fs->ode_b[fd]. +pos +); + +610 i( +cou + == 0) { + +611 * +size + = 0; + +612  +EFI_SUCCESS +; + +614 +block + = +e2fs +-> +blkbuf +; + +616 * +size + = 0; + +618 +pos + = +e2fs +-> +ode_b +[ +fd +].pos; + +619 + `DBG_PRT +(( +L +"size=%d i_size=%d cou=%dos=%ld", * +size +, +e2fs +-> +ode_b +[ +fd +]. +ode +. +i_size +, +cou +, +pos +)); + +620  +cou +) { + +621 +bnum + = +pos + / +e2fs +-> +blocksize +; + +622 +bofs + = +pos + % +e2fs +-> +blocksize +; + +623 +nc + = + `MIN +( +cou +, +e2fs +-> +blocksize + - +bofs +); + +625 + `DBG_PRT +(( +L +"bnum =%d bofs=%dc=%d *size=%d", +bnum +, +bofs +, +nc +, * +size +)); + +627 i( + `ext2_bad +( +e2fs +, +fd +, +bnum +, 1, +block +=-1 +r +; + +629 {  +i +; * +p + = +block ++ +bofs +; + +630  +i += + `MIN +( +nc +, 64); i>=0 ; i--, +p +++) { + +631 i( +i + % 16 =0 + `Prt +( +L +"\n"); + +632 + `Prt +( +L +"%02x ", ( +UINTN +)* +p + & 0xff); + +637 + `Memy +( +buf +, +block ++ +bofs +, +nc +); + +638 +cou + - +nc +; + +639 +pos + + +nc +; + +640 +buf + + +nc +; + +641 * +size + + +nc +; + +644 +e2fs +-> +ode_b +[ +fd +]. +pos + +* +size +; + +645 +t + = +EFI_SUCCESS +; + +646 +r +: + +647 + `DBG_PRT +(( +L +"*size=%d=%r", * +size +, +t +)); + +648  +t +; + +649 + } +} + +651  +ext2_ode + * + +652 + $ext2_flow_lk +( +ext2fs_iv_e_t + * +e2fs +,  +ext2_ode + * +om +, cڡ * +ba +) + +654 * +lkto +; + +656 i( +om +-> +i_blocks +) { + +657 +lkto + = +e2fs +-> +blkbuf +; + +658 i( + `ext2_badi +( +e2fs +, +om +, 0, 1,2fs-> +blkbuf +) == -1) + +659  +NULL +; + +660 + `DBG_PRT +(( +L +"longink!")); + +662 +lkto + = (*) +om +-> +i_block +; + +664 + `DBG_PRT +(( +L +"symlk%s", +lkto +)); + +667 i( +lkto +[0] != '/') { + +668 * +d + = + `ch +( +ba +, '/'); + +669 i( +d +) { + +671  +fume +[ +EXT2FS_PATH_MAXLEN +]; + +673 i((( +d + - +ba + + 1+ + `a +( +lkto ++ 1> +EXT2FS_PATH_MAXLEN +) { + +674 + `Prt +( +L +"%s: famtolg, c'sve\n", +__FUNCTION__ +); + +675  +NULL +; + +678 + `ya +( +fume +, +ba +, +d + - base + 1); + +679 +fume +[ +d + - +ba + + 1] = '\0'; + +680 + `r +( +fume +, +lkto +); + +681 + `DBG_PRT +(( +L +"sved%s", +fume +)); + +682  + `ext2_mei +( +e2fs +, +fume +); + +685  + `ext2_mei +( +e2fs +, +lkto +); + +688  + `ext2_mei +( +e2fs +, +lkto +); + +690 + } +} + +693 + $ext2_ݒ +( +ext2fs_iv_e_t + * +e2fs +, * +fame +) + +699  +ext2_ode + * + +; + +701 + + = + `ext2_mei +( +e2fs +, +fame +); + +702 i( + +) { + +703  +ode_b_y + * +p +; + +705  + `S_ISLNK +( + +-> +i_mode +)) { + +706 + + = + `ext2_flow_lk +( +e2fs +, ip, +fame +); + +707 i(! + +)  -1; + +709 +p + = ( +ode_b_y + *) + +; + +710  +p + - +e2fs +-> +ode_b +; + +713 + } +} + +715  + $ext2_o +( +ext2fs_iv_e_t + * +e2fs +,  +fd +) + +718 i(& +e2fs +-> +ode_b +[ +fd +]. +ode + !e2fs-> +ro_ode +) + +719 + `ext2_ut +( +e2fs +, &e2fs-> +ode_b +[ +fd +]. +ode +); + +720 + } +} + +722  +EFI_STATUS + + +723 + $ext2fs_o +( +ext2fs_r_t + * +this +, +UINTN + +fd +) + +725 +ext2fs_iv_e_t + * +e2fs +; + +727 i( +this + = +NULL + || +fd + > +MAX_OPEN_FILES + +EFI_INVALID_PARAMETER +; + +729 +e2fs + = + `FS_PRIVATE +( +this +); + +731 + `ext2_o +( +e2fs +, +fd +); + +733  +EFI_SUCCESS +; + +734 + } +} + +736  +EFI_STATUS + + +737 + $ext2fs_ݒ +( +ext2fs_r_t + * +this +, +CHAR16 + * +me +, +UINTN + * +fd +) + +739 +ext2fs_iv_e_t + * +e2fs +; + +740 +CHAR8 + +fame +[ +EXT2FS_PATH_MAXLEN +]; + +741 +INTN + +tmp +; + +743 + `DBG_PRT +(( +L +"me:%fd=%x", +me +, +fd +)); + +745 i( +this + = +NULL + || +me + =NULL || +fd + =NULL || + `SL +ame>= +EXT2FS_PATH_MAXLEN + +EFI_INVALID_PARAMETER +; + +747 +e2fs + = + `FS_PRIVATE +( +this +); + +752 + `SnXCpy +( +fame +, +me +, +EXT2FS_PATH_MAXLEN +); + +754 + `DBG_PRT +(( +L +"ASCIIame:%UTF-me:%s", +fame +, +me +)); + +756 +tmp + = + `ext2_ݒ +( +e2fs +, +fame +); + +757 i( +tmp + != -1) { + +758 * +fd + = ( +UINTN +) +tmp +; + +759 +e2fs +-> +ode_b +[ +tmp +]. +pos + = 0; + +762 + `DBG_PRT +(( +L +"me: %fd=%dmp=%d", +me +, * +fd +, +tmp +)); + +764  +tmp + =-1 ? +EFI_NOT_FOUND + : +EFI_SUCCESS +; + +765 + } +} + +767  +EFI_STATUS + + +768 + $ext2fs_me +( +ext2fs_r_t + * +this +, +CHAR16 + * +me +, +UINTN + +maxn +) + +770 i( +me + = +NULL + || +maxn + < 1 +EFI_INVALID_PARAMETER +; + +772 + `SnCpy +( +me +, +FS_NAME +, +maxn +-1); + +774 +me +[ +maxn +-1] = +CHAR_NULL +; + +776  +EFI_SUCCESS +; + +777 + } +} + +779  +INTN + + +780 + $ext2fs__e +( +ext2fs_t + * +ext2fs +, +EFI_HANDLE + +dev +, +EFI_BLOCK_IO + * +blkio +,  +ext2_sur_block + * +sb +) + +782 +ext2fs_iv_e_t + * +e2fs + = + `FS_PRIVATE +( +ext2fs +); + +783 +UINTN + +i +; + +784 +EFI_STATUS + +us +; + +786 + `Memt +( +ext2fs +, 0, (*ext2fs)); + +788 +e2fs +-> +dev + = dev; + +789 +e2fs +-> +blkio + = blkio; + +790 +e2fs +-> +medid + = +blkio +-> +Med +-> +MedId +; + +793 + `Memy +(& +e2fs +-> +sb +, sb, (*sb)); + +795 +e2fs +-> +ngroups + = ( +sb +-> +s_blocks_cou + - sb-> +s_f_da_block + + + `EXT2_BLOCKS_PER_GROUP +(sb) - 1) / EXT2_BLOCKS_PER_GROUP(sb); + +797 +e2fs +-> +gds + = ( +ext2_group_desc + *) + `loc +2fs-> +ngroups + * (ext2_group_desc), +EXT2FS_MEMTYPE +); + +798 i( +e2fs +-> +gds + = +NULL +) { + +799 + `ERR_PRT +(( +L +"failedollocate gds")); + +800  +EFI_OUT_OF_RESOURCES +; + +803 +e2fs +-> +blocksize + = + `EXT2_BLOCK_SIZE +( +sb +); + +805 + `DBG_PRT +(( +L +"gds_size=%d gds_offset=%dgroups=%d blocksize=%d", + +806 +e2fs +-> +ngroups + * ( +ext2_group_desc +), + +807 +e2fs +-> +blocksize + * ( +EXT2_MIN_BLOCK_SIZE +/e2fs->blocksize + 1), + +808 +e2fs +-> +ngroups +, ( +UINTN +2fs-> +blocksize +)); + +811 +us + = + `ad_bys +( +blkio +, +e2fs +-> +medid +,2fs-> +blocksize + * ( +EXT2_MIN_BLOCK_SIZE +/e2fs->blocksize + 1), + +812 +e2fs +-> +gds +,2fs-> +ngroups + * ( +ext2_group_desc +)); + +813 i( + `EFI_ERROR +( +us +)) { + +814 + `ERR_PRT +(( +L +"لd gds: %r", +us +)); + +815 + ` +( +e2fs +-> +gds +); + +816  +EFI_INVALID_PARAMETER +; + +819 {  +i +; * +p + = (*) +e2fs +-> +gds +; + +820  +i += +e2fs +-> +ngroups +*(*e2fs-> +gds +); i ; i--, +p +++) { + +821 i( +i + % 16 =0 + `Prt +( +L +"\n"); + +822 + `Prt +( +L +"%02x ", ( +UINTN +)* +p + & 0xff); + +828 +e2fs +-> +ched_diblkno + = -1; + +829 +e2fs +-> +ched_iblkno + = -1; + +832  +i + = 0; i < +MAX_OPEN_FILES +; i++) { + +833 +e2fs +-> +ode_b +[ +i +]. + + = 1; + +834 +e2fs +-> +ode_b +[ +i +]. +umb + = 0; + +837 +e2fs +-> +ro_ode + = +NULL +; + +844 +e2fs +-> +delim + = +EXT2_NDIR_BLOCKS + - 1; + +845 +e2fs +-> +rs_r_blk + =2fs-> +blocksize +/(); + +846 +e2fs +-> +d1lim + =2fs-> +rs_r_blk + +2fs-> +delim +; + +847 +e2fs +-> +d2lim + = (e2fs-> +rs_r_blk + *2fs->rs_r_blk+2fs-> +delim +; + +849 +ext2fs +-> +pub_tf +. +ext2fs_me + =xt2fs_name; + +850 +ext2fs +-> +pub_tf +. +ext2fs_ݒ + =xt2fs_open; + +851 +ext2fs +-> +pub_tf +. +ext2fs_ad + =xt2fs_read; + +852 +ext2fs +-> +pub_tf +. +ext2fs_o + =xt2fs_close; + +853 +ext2fs +-> +pub_tf +. +ext2fs_ek + =xt2fs_seek; + +854 +ext2fs +-> +pub_tf +. +ext2fs_f + =xt2fs_fstat; + +856  +EFI_SUCCESS +; + +857 + } +} + +860  +EFI_STATUS + + +861 + $ext2fs_l_e +( +EFI_HANDLE + +dev +, +VOID + ** +tf +) + +863  +ext2_sur_block + +sb +; + +864  +sb_block + = 1; + +865 +EFI_STATUS + +us +; + +866 +EFI_BLOCK_IO + * +blkio +; + +867 +ext2fs_t + * +ext2fs +; + +869 +us + = +BS +-> + `HdProc + ( +dev +, & +Ext2FsProc +, ( +VOID + **)& +ext2fs +); + +870 i( +us + = +EFI_SUCCESS +) { + +871 + `ERR_PRT +(( +L +"Wng: foundxig %oc odevi", +FS_NAME +)); + +872  +found +; + +875 +us + = +BS +-> + `HdProc +( +dev +, & +BlockIoProc +, ( +VOID + **)& +blkio +); + +876 i( + `EFI_ERROR +( +us +) +EFI_INVALID_PARAMETER +; + +878 + `VERB_PRT +(5, + +879 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +880 +dp + = + `DeviPhFromHd +( +dev +); + +881 +r + = + `DeviPhToS +( +dp +); + +882 + `Prt +( +L +"dev:%s\nLogiȷi: % BlockSize: %d WreCachg: %\n", +r +, + +883 +blkio +-> +Med +-> +LogilPti + ? +L +"Yes": L"No", + +884 +blkio +-> +Med +-> +BlockSize +, + +885 +blkio +-> +Med +-> +WreCachg + ? +L +"Yes":L"No"); + +886 + `FePo +( +r +); + +888 i( +blkio +-> +Med +-> +LogilPti + = +FALSE + +EFI_INVALID_PARAMETER +; + +896 +blkio +-> + `Ret +(blkio, +FALSE +); + +899 +us + = + `ad_bys +( +blkio +, blkio-> +Med +-> +MedId +, +sb_block + * +EXT2_MIN_BLOCK_SIZE +, & +sb +, (sb)); + +900 i( + `EFI_ERROR +( +us +)) { + +901 + `DBG_PRT +(( +L +"لd surblock: %r", +us +)); + +902  +EFI_INVALID_PARAMETER +; + +905 i( +sb +. +s_magic + ! +EXT2_SUPER_MAGIC +) { + +906 + `DBG_PRT +(( +L +"bad magi0x%x\n", +sb +. +s_magic +)); + +907  +EFI_INVALID_PARAMETER +; + +910 +ext2fs + = ( +ext2fs_t + *) + `loc +((*ext2fs), +EXT2FS_MEMTYPE +); + +911 i( +ext2fs + = +NULL + +EFI_OUT_OF_RESOURCES +; + +913 +us + = + `ext2fs__e +( +ext2fs +, +dev +, +blkio +, & +sb +); + +914 i( +us + ! +EFI_SUCCESS +) { + +915 + ` +( +ext2fs +); + +916  +us +; + +919 +us + = + `LibInlProcIs +(& +dev +, & +Ext2FsProc +, +ext2fs +, +NULL +); + +920 i( + `EFI_ERROR +( +us +)) { + +921 + `ERR_PRT +(( +L +"Cn in%oc: %r", +FS_NAME +, +us +)); + +922 + ` +( +ext2fs +); + +923  +us +; + +925 +found +: + +926 i( +tf +*t( +VOID + *) +ext2fs +; + +928 + `VERB_PRT +(3, + +929 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +930 +dp + = + `DeviPhFromHd +( +dev +); + +931 +r + = + `DeviPhToS +( +dp +); + +932 + `Prt +( +L +"dev:%%deed\n", +r +, +FS_NAME +); + +933 + `FePo +( +r +); + +936  +EFI_SUCCESS +; + +937 + } +} + +939 +EFI_STATUS + + +940 + $ext2fs_l +( +VOID +) + +942 +UINTN + +size + = 0; + +943 +UINTN + +i +; + +944 +EFI_STATUS + +us +; + +945 +VOID + * +tf +; + +947 +BS +-> + `LoHd +( +ByProc +, & +BlockIoProc +, +NULL +, & +size +, NULL); + +948 i( +size + =0 +EFI_UNSUPPORTED +; + +950 + `DBG_PRT +(( +L +"size=%d", +size +)); + +952 +dev_b + = ( +dev_b_t + *) + `loc +( +size +, +EfiLdDa +); + +953 i( +dev_b + = +NULL +) { + +954 + `ERR_PRT +(( +L +"failedollocate handleable")); + +955  +EFI_OUT_OF_RESOURCES +; + +958 +us + = +BS +-> + `LoHd +( +ByProc +, & +BlockIoProc +, +NULL +, & +size +, ( +VOID + **) +dev_b +); + +959 i( +us + ! +EFI_SUCCESS +) { + +960 + `ERR_PRT +(( +L +"edg hds: %r", +us +)); + +961 + ` +( +dev_b +); + +962  +us +; + +964 +ndev + = +size + / ( +EFI_HANDLE +); + +966  +i +=0; i < +ndev +; i++) { + +967 +tf + = +NULL +; + +968 + `ext2fs_l_e +( +dev_b +[ +i +]. +dev +, & +tf +); + +970 +dev_b +[ +i +]. +tf + = intf; + +973  +EFI_SUCCESS +; + +974 + } +} + +976 +EFI_STATUS + + +977 + $ext2fs_unl +( +VOID +) + +980 +ext2fs_iv_e_t + * +e2fs +; + +981 +EFI_STATUS + +us +; + +982 +UINTN + +i +; + +984  +i +=0; i < +ndev +; i++) { + +985 i( +dev_b +[ +i +]. +tf + = +NULL +) ; + +986 +e2fs + = + `FS_PRIVATE +( +dev_b +[ +i +]. +tf +); + +987 +us + = +BS +-> + `UnlProcI +( +e2fs +-> +dev +, & +Ext2FsProc +, +dev_b +[ +i +]. +tf +); + +988 i( + `EFI_ERROR +( +us +)) { + +989 + `ERR_PRT +(( +L +"Un%r: %r", +FS_NAME +, +us +)); + +992 + `VERB_PRT +(3, + +993 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +994 +dp + = + `DeviPhFromHd +( +e2fs +-> +dev +); + +995 +r + = + `DeviPhToS +( +dp +); + +996 + `Prt +( +L +"und % %s\n", +FS_NAME +, +r +); + +997 + `FePo +( +r +); + +999 + ` +( +dev_b +[ +i +]. +tf +); + +1001 i( +dev_b + + ` +(dev_tab); + +1003  +EFI_SUCCESS +; + +1004 + } +} + + @fs/ext2fs.h + +25 #ide +__EXT2FS_H__ + + +26  + #__EXT2FS_H__ + + + ) + +28 +INTERFACE_DECL +( +_ext2fs_r_t +); + +35  + m_o +; + +36  + m_ƚk +; + +37  + m_mode +; + +38  + m_uid +; + +39  + m_gid +; + +40  + m_size +; + +41  + m_ime +; + +42  + m_mtime +; + +43  + m_ime +; + +44 } + text2fs__t +; + +47  + s_ext2fs_r_t + { + +48 +EFI_STATUS + (* +ext2fs_me +)( +_ext2fs_r_t + * + mthis +, +CHAR16 + * + mme +, +UINTN + + mmaxn +); + +49 +EFI_STATUS + (* +ext2fs_ݒ +)( +_ext2fs_r_t + * + mthis +, +CHAR16 + * + mme +, +UINTN + * + mfd +); + +50 +EFI_STATUS + (* +ext2fs_ad +)( +_ext2fs_r_t + * + mthis +, +UINTN + + mfd +, +VOID + * + mbuf +, UINTN * + msize +); + +51 +EFI_STATUS + (* +ext2fs_o +)( +_ext2fs_r_t + * + mthis +, +UINTN + + mfd +); + +52 +EFI_STATUS + (* +ext2fs_f +)( +_ext2fs_r_t + * + mthis +, +UINTN + + mfd +, +ext2fs__t + * + m +); + +53 +EFI_STATUS + (* +ext2fs_ek +)( +_ext2fs_r_t + * + mthis +, +UINTN + + mfd +, +UINT64 + + mwpos +); + +54 } + text2fs_r_t +; + +56  + #EXT2FS_PROTOCOL + \ + +57 { 0x6924f6, 0xc9f2, 0x4331, {0x83, 0x54, 0x19, 0xd0, 0x17, 0x50, 0xd9, 0xc7} } + + ) + +59 +EFI_STATUS + +ext2fs_l +( +VOID +); + +60 +EFI_STATUS + +ext2fs_unl +( +VOID +); + + @fs/fs.h + +1 #ide +_LINUX_FS_H + + +2  + #_LINUX_FS_H + + + ) + +9  + ~ + +10  + ~ + +11  + ~ + +12  + ~ + +13  + ~ + +14  + ~ + +15  + ~ + +16  + ~ + +17  + ~ + +18  + ~ + +19  + ~ + +20  + ~ + +21  + ~ + +22  + ~ + +23  + ~ + +25  + ~ + +26  + ~ + +28  + gpl_b_ru +; + +42 #unde +NR_OPEN + + +43  + #NR_OPEN + (1024*1024 + + ) + +44  + #INR_OPEN + 1024 + + ) + +46  + #BLOCK_SIZE_BITS + 10 + + ) + +47  + #BLOCK_SIZE + (1<< +BLOCK_SIZE_BITS +) + + ) + +50  + sfes__ru + { + +51  + m_fes +; + +52  + m__fes +; + +53  + mmax_fes +; + +55  +fes__ru + +fes_ +; + +57  + sodes__t + { + +58  + m_odes +; + +59  + m_unud +; + +60  + mdummy +[5]; + +62  +odes__t + +odes_ +; + +64  +max_sur_blocks +, +_sur_blocks +; + +65  +as_ab +, +d_nify_ab +, +a_bak_time +; + +67  + #NR_FILE + 8192 + + ) + +68  + #NR_RESERVED_FILES + 10 + + ) + +69  + #NR_SUPER + 256 + + ) + +71  + #MAY_EXEC + 1 + + ) + +72  + #MAY_WRITE + 2 + + ) + +73  + #MAY_READ + 4 + + ) + +75  + #FMODE_READ + 1 + + ) + +76  + #FMODE_WRITE + 2 + + ) + +78  + #READ + 0 + + ) + +79  + #WRITE + 1 + + ) + +80  + #READA + 2 + + ) + +81  + #SPECIAL + 4 + + ) + +83  + #SEL_IN + 1 + + ) + +84  + #SEL_OUT + 2 + + ) + +85  + #SEL_EX + 4 + + ) + +88  + #FS_REQUIRES_DEV + 1 + + ) + +89  + #FS_NO_DCACHE + 2 + + ) + +90  + #FS_NO_PRELIM + 4 + + ) + +93  + #FS_SINGLE + 8 + + ) + +99  + #FS_NOMOUNT + 16 + + ) + +100  + #FS_LITTER + 32 + + ) + +101  + #FS_ODD_RENAME + 32768 + + ) + +107  + #MS_RDONLY + 1 + + ) + +108  + #MS_NOSUID + 2 + + ) + +109  + #MS_NODEV + 4 + + ) + +110  + #MS_NOEXEC + 8 + + ) + +111  + #MS_SYNCHRONOUS + 16 + + ) + +112  + #MS_REMOUNT + 32 + + ) + +113  + #MS_MANDLOCK + 64 + + ) + +114  + #MS_NOATIME + 1024 + + ) + +115  + #MS_NODIRATIME + 2048 + + ) + +116  + #MS_BIND + 4096 + + ) + +121  + #MS_RMT_MASK + ( +MS_RDONLY +| +MS_NOSUID +| +MS_NODEV +| +MS_NOEXEC +|\ + +122 +MS_SYNCHRONOUS +| +MS_MANDLOCK +| +MS_NOATIME +| +MS_NODIRATIME +) + + ) + +127  + #MS_MGC_VAL + 0xC0ED0000 + + ) + +128  + #MS_MGC_MSK + 0xffff0000 + + ) + +132  + #S_SYNC + 1 + + ) + +133  + #S_NOATIME + 2 + + ) + +134  + #S_QUOTA + 4 + + ) + +135  + #S_APPEND + 8 + + ) + +136  + #S_IMMUTABLE + 16 + + ) + +137  + #S_DEAD + 32 + + ) + +152  + #__IS_FLG +( +ode +, +g +((ode)-> +i_sb +-> +s_ags + & (g)) + + ) + +154  + #IS_RDONLY +( +ode +((ode)-> +i_sb +-> +s_ags + & +MS_RDONLY +) + + ) + +155  + #IS_NOSUID +( +ode + + `__IS_FLG +(ode, +MS_NOSUID +) + + ) + +156  + #IS_NODEV +( +ode + + `__IS_FLG +(ode, +MS_NODEV +) + + ) + +157  + #IS_NOEXEC +( +ode + + `__IS_FLG +(ode, +MS_NOEXEC +) + + ) + +158  + #IS_SYNC +( +ode +( + `__IS_FLG +(ode, +MS_SYNCHRONOUS +|| ((ode)-> +i_ags + & +S_SYNC +)) + + ) + +159  + #IS_MANDLOCK +( +ode + + `__IS_FLG +(ode, +MS_MANDLOCK +) + + ) + +161  + #IS_QUOTAINIT +( +ode +((ode)-> +i_ags + & +S_QUOTA +) + + ) + +162  + #IS_APPEND +( +ode +((ode)-> +i_ags + & +S_APPEND +) + + ) + +163  + #IS_IMMUTABLE +( +ode +((ode)-> +i_ags + & +S_IMMUTABLE +) + + ) + +164  + #IS_NOATIME +( +ode +( + `__IS_FLG +(ode, +MS_NOATIME +|| ((ode)-> +i_ags + & +S_NOATIME +)) + + ) + +165  + #IS_NODIRATIME +( +ode + + `__IS_FLG +(ode, +MS_NODIRATIME +) + + ) + +167  + #IS_DEADDIR +( +ode +((ode)-> +i_ags + & +S_DEAD +) + + ) + +172  + #BLKROSET + + `_IO +(0x12,93 + + ) + +173  + #BLKROGET + + `_IO +(0x12,94 + + ) + +174  + #BLKRRPART + + `_IO +(0x12,95 + + ) + +175  + #BLKGETSIZE + + `_IO +(0x12,96 + + ) + +176  + #BLKFLSBUF + + `_IO +(0x12,97 + + ) + +177  + #BLKRASET + + `_IO +(0x12,98 + + ) + +178  + #BLKRAGET + + `_IO +(0x12,99 + + ) + +179  + #BLKFRASET + + `_IO +(0x12,100) + + ) + +180  + #BLKFRAGET + + `_IO +(0x12,101) + + ) + +181  + #BLKSECTSET + + `_IO +(0x12,102) + + ) + +182  + #BLKSECTGET + + `_IO +(0x12,103) + + ) + +183  + #BLKSSZGET + + `_IO +(0x12,104) + + ) + +185  + #BLKPG + + `_IO +(0x12,105) + + ) + +186  + #BLKELVGET + + `_IOR +(0x12,106,( +blkv_iol_g_t +)) + + ) + +187  + #BLKELVSET + + `_IOW +(0x12,107,( +blkv_iol_g_t +)) + + ) + +193  + #BMAP_IOCTL + 1 + + ) + +194  + #FIBMAP + + `_IO +(0x00,1 + + ) + +195  + #FIGETBSZ + + `_IO +(0x00,2 + + ) + +197 #ifde +__KERNEL__ + + +199  + ~ + +200  + ~ + +202  +upde_ime + ( +ode + *); + +203  + #UPDATE_ATIME +( +ode + + `upde_ime + (ode) + + ) + +205  +bufr_ +(); + +206  +ode_ +(); + +209  + #BH_Uode + 0 + + ) + +210  + #BH_Dty + 1 + + ) + +211  + #BH_Lock + 2 + + ) + +212  + #BH_Req + 3 + + ) + +213  + #BH_Md + 4 + + ) + +214  + #BH_New + 5 + + ) + +215  + #BH_Preed + 6 + + ) + +228  + sbufr_hd + { + +230  +bufr_hd + * + mb_xt +; + +231  + mb_block +; + +232  + mb_size +; + +233  + mb_li +; + +234 +kdev_t + + mb_dev +; + +236 +omic_t + + mb_cou +; + +237 +kdev_t + + mb_rdev +; + +238  + mb_e +; + +239  + mb_ushtime +; + +241  +bufr_hd + * + mb_xt_ +; + +242  +bufr_hd + * + mb_ev_ +; + +243  +bufr_hd + * + mb_this_ge +; + +244  +bufr_hd + * + mb_qxt +; + +246  +bufr_hd + ** + mb_v +; + +247 * + mb_da +; + +248  +ge + * + mb_ge +; + +249 (* + mb_d_io +)( +bufr_hd + * + mbh +,  + muode +); + +250 * + mb_ive +; + +252  + mb_r +; + +253 +wa_queue_hd_t + + mb_wa +; + +255  +ode + * + mb_ode +; + +256  +li_hd + + mb_ode_bufrs +; + +259 ( + tbh_d_io_t +)( + tbufr_hd + * + tbh +,  + tuode +); + +260  + `_bufr +( +bufr_hd + *, +bh_d_io_t + *, *); + +262  + #__bufr_e +( +bh +, +e +(((bh)-> +b_e + & (1UL << +BH_ +##e)!0) + + ) + +264  + #bufr_uode +( +bh + + `__bufr_e +(bh, +Uode +) + + ) + +265  + #bufr_dty +( +bh + + `__bufr_e +(bh, +Dty +) + + ) + +266  + #bufr_locked +( +bh + + `__bufr_e +(bh, +Lock +) + + ) + +267  + #bufr_q +( +bh + + `__bufr_e +(bh, +Req +) + + ) + +268  + #bufr_md +( +bh + + `__bufr_e +(bh, +Md +) + + ) + +269  + #bufr_w +( +bh + + `__bufr_e +(bh, +New +) + + ) + +270  + #bufr_eed +( +bh + + `__bufr_e +(bh, +Preed +) + + ) + +272  + #bh_offt +( +bh +(()(bh)-> +b_da + & ~ +PAGE_MASK +) + + ) + +274  + `t_bh_ge +( +bufr_hd + * +bh +,  +ge + *ge,  +offt +); + +276  + #touch_bufr +( +bh + + `SPageRend +(bh-> +b_ge +) + + ) + +279  + ~ + +280  + ~ + +281  + ~ + +282  + ~ + +283  + ~ + +284  + ~ + +285  + ~ + +286  + ~ + +287  + ~ + +288  + ~ + +289  + ~ + +290  + ~ + +291  + ~ + +292  + ~ + +293  + ~ + +294  + ~ + +295  + ~ + +296  + ~ + +297  + ~ + +298  + ~ + +299  + ~ + +300  + ~ + +301  + ~ + +302  + ~ + +303  + ~ + +304  + ~ + +310  + #ATTR_MODE + 1 + + ) + +311  + #ATTR_UID + 2 + + ) + +312  + #ATTR_GID + 4 + + ) + +313  + #ATTR_SIZE + 8 + + ) + +314  + #ATTR_ATIME + 16 + + ) + +315  + #ATTR_MTIME + 32 + + ) + +316  + #ATTR_CTIME + 64 + + ) + +317  + #ATTR_ATIME_SET + 128 + + ) + +318  + #ATTR_MTIME_SET + 256 + + ) + +319  + #ATTR_FORCE + 512 + + ) + +320  + #ATTR_ATTR_FLAG + 1024 + + ) + +331  + sr + { + +332  +_vid +; + +333 +umode_t + +_mode +; + +334 +uid_t + +_uid +; + +335 +gid_t + +_gid +; + +336 +loff_t + +_size +; + +337 +time_t + +_ime +; + +338 +time_t + +_mtime +; + +339 +time_t + +_ime +; + +340  +__ags +; + +346  + #ATTR_FLAG_SYNCRONOUS + 1 + + ) + +347  + #ATTR_FLAG_NOATIME + 2 + + ) + +348  + #ATTR_FLAG_APPEND + 4 + + ) + +349  + #ATTR_FLAG_IMMUTABLE + 8 + + ) + +350  + #ATTR_FLAG_NODIRATIME + 16 + + ) + +355  + ~ + +356  + ~ + +361  +ge +; + +362  +addss_a +; + +364  + saddss_a_ݔis + { + +365 (* +wrage +)( +ge + *); + +366 (* +adge +)( +fe + *,  +ge + *); + +367 (* +sync_ge +)( +ge + *); + +368 (* +e_wre +)( +fe + *,  +ge + *, , ); + +369 (* +comm_wre +)( +fe + *,  +ge + *, , ); + +371 (* +bm +)( +addss_a + *, ); + +374  + saddss_a + { + +375  +li_hd + +n_ges +; + +376  +li_hd + +dty_ges +; + +377  +li_hd + +locked_ges +; + +378  +ķges +; + +379  +addss_a_ݔis + * +a_s +; + +380  +ode + * +ho +; + +381  +vm__ru + * +i_mm +; + +382  +vm__ru + * +i_mm_shed +; + +383 +lock_t + +i_shed_lock +; + +384  +g_mask +; + +387  + sch_devi + { + +388  +li_hd + +hash +; + +389 +omic_t + +cou +; + +390 +dev_t + +dev +; + +391 +omic_t + +ݒs +; + +392  +mhe + +m +; + +395  + sblock_devi + { + +396  +li_hd + +bd_hash +; + +397 +omic_t + +bd_cou +; + +399 +dev_t + +bd_dev +; + +400 +omic_t + +bd_ݒs +; + +401 cڡ  +block_devi_ݔis + * +bd_ +; + +402  +mhe + +bd_m +; + +405  + sode + { + +406  +li_hd + +i_hash +; + +407  +li_hd + +i_li +; + +408  +li_hd + +i_dy +; + +410  +li_hd + +i_dty_bufrs +; + +412  +i_o +; + +413 +omic_t + +i_cou +; + +414 +kdev_t + +i_dev +; + +415 +umode_t + +i_mode +; + +416 +ƚk_t + +i_ƚk +; + +417 +uid_t + +i_uid +; + +418 +gid_t + +i_gid +; + +419 +kdev_t + +i_rdev +; + +420 +loff_t + +i_size +; + +421 +time_t + +i_ime +; + +422 +time_t + +i_mtime +; + +423 +time_t + +i_ime +; + +424  +i_blksize +; + +425  +i_blocks +; + +426  +i_vsi +; + +427  +mhe + +i_m +; + +428  +mhe + +i_zomb +; + +429  +ode_ݔis + * +i_ +; + +430  +fe_ݔis + * +i_f +; + +431  +sur_block + * +i_sb +; + +432 +wa_queue_hd_t + +i_wa +; + +433  +fe_lock + * +i_ock +; + +434  +addss_a + * +i_mpg +; + +435  +addss_a + +i_da +; + +436  +dqu + * +i_dqu +[ +MAXQUOTAS +]; + +438  +pe_ode_fo + * +i_pe +; + +439  +block_devi + * +i_bdev +; + +440  +ch_devi + * +i_cdev +; + +442  +i_dnify_mask +; + +443  +dnify_ru + * +i_dnify +; + +445  +i_e +; + +447  +i_ags +; + +448  +i_sock +; + +450 +omic_t + +i_wrecou +; + +451  +i__ags +; + +452 +__u32 + +i_gi +; + +454  +mix_ode_fo + +mix_i +; + +455  +ext2_ode_fo + +ext2_i +; + +456  +hpfs_ode_fo + +hpfs_i +; + +457  +fs_ode_fo + +fs_i +; + +458  +msdos_ode_fo + +msdos_i +; + +459  +umsdos_ode_fo + +umsdos_i +; + +460  +iso_ode_fo + +isofs_i +; + +461  +nfs_ode_fo + +nfs_i +; + +462  +sysv_ode_fo + +sysv_i +; + +463  +affs_ode_fo + +affs_i +; + +464  +ufs_ode_fo + +ufs_i +; + +465  +efs_ode_fo + +efs_i +; + +466  +romfs_ode_fo + +romfs_i +; + +467  +shmem_ode_fo + +shmem_i +; + +468  +coda_ode_fo + +coda_i +; + +469  +smb_ode_fo + +smbfs_i +; + +470  +hfs_ode_fo + +hfs_i +; + +471  +adfs_ode_fo + +adfs_i +; + +472  +qnx4_ode_fo + +qnx4_i +; + +473  +irfs_ode_fo + +irfs_i +; + +474  +bfs_ode_fo + +bfs_i +; + +475  +udf_ode_fo + +udf_i +; + +476  +n_ode_fo + +nfs_i +; + +477  +oc_ode_fo + +oc_i +; + +478  +sock + +sock_i +; + +479  +usbdev_ode_fo + +usbdev_i +; + +480 * +gic_ +; + +481 } +u +; + +484  + sfown_ru + { + +485  +pid +; + +486 +uid_t + +uid +, +euid +; + +487  +signum +; + +490  + sfe + { + +491  +li_hd + +f_li +; + +492  +dy + * +f_dy +; + +493  +vfsmou + * +f_vfsm +; + +494  +fe_ݔis + * +f_ +; + +495 +omic_t + +f_cou +; + +496  +f_ags +; + +497 +mode_t + +f_mode +; + +498 +loff_t + +f_pos +; + +499  +f_ada +, +f_max +, +f_d +, +f_n +, +f_w +; + +500  +fown_ru + +f_owr +; + +501  +f_uid +, +f_gid +; + +502  +f_r +; + +504  +f_vsi +; + +507 * +ive_da +; + +509 +lock_t + +fes_lock +; + +510  + #fe_li_lock +( + `_lock +(& +fes_lock +); + + ) + +511  + #fe_li_uock +( + `_uock +(& +fes_lock +); + + ) + +513  + #g_fe +( +x + + `omic_c +(&(x)-> +f_cou +) + + ) + +514  + #fe_cou +( +x + + `omic_ad +(&(x)-> +f_cou +) + + ) + +516  + `_ive_fe +( +fe + *,  +dy + *, ); + +518  + #MAX_NON_LFS + ((1UL<<31- 1) + + ) + +520  + #FL_POSIX + 1 + + ) + +521  + #FL_FLOCK + 2 + + ) + +522  + #FL_BROKEN + 4 + + ) + +523  + #FL_ACCESS + 8 + + ) + +524  + #FL_LOCKD + 16 + + ) + +525  + #FL_LEASE + 32 + + ) + +534  +fes_ru + * + t_owr_t +; + +536  + sfe_lock + { + +537  +fe_lock + * +_xt +; + +538  +li_hd + +_lk +; + +539  +li_hd + +_block +; + +540 +_owr_t + +_owr +; + +541  +_pid +; + +542 +wa_queue_hd_t + +_wa +; + +543  +fe + * +_fe +; + +544  +_ags +; + +545  +_ty +; + +546 +loff_t + +_t +; + +547 +loff_t + +_d +; + +549 (* +_nify +)( +fe_lock + *); + +550 (* +_ +)( +fe_lock + *); + +551 (* +_move +)( +fe_lock + *); + +553  +sync_ru + * +_sync +; + +556  +nfs_lock_fo + +nfs_ +; + +557 } +_u +; + +561 #ide +OFFSET_MAX + + +562  + #INT_LIMIT +( +x +(~((x)1 << ((x)*8 - 1))) + + ) + +563  + #OFFSET_MAX + + `INT_LIMIT +( +loff_t +) + + ) + +564  + #OFFT_OFFSET_MAX + + `INT_LIMIT +( +off_t +) + + ) + +567  +li_hd + +fe_lock_li +; + +569  + ~ + +571  + `f_glk +(,  +ock + *); + +572  + `f_k +(, ,  +ock + *); + +574  + `f_glk64 +(,  +ock64 + *); + +575  + `f_k64 +(, ,  +ock64 + *); + +578  + `locks__lock +( +fe_lock + *); + +579  + `locks_cy_lock +( +fe_lock + *, file_lock *); + +580  + `locks_move_posix +( +fe + *, +_owr_t +); + +581  + `locks_move_ock +( +fe + *); + +582  +fe_lock + * + `posix__lock +( +fe + *, file_lock *); + +583  + `posix_lock_fe +( +fe + *,  +fe_lock + *, ); + +584  + `posix_block_lock +( +fe_lock + *, file_lock *); + +585  + `posix_unblock_lock +( +fe_lock + *); + +586  + `__g_a +( +ode + *ode,  +ags +); + +587 +time_t + + `a_g_mtime +( +ode + *); + +588  + `lock_may_ad +( +ode + *, +loff_t + +t +,  +cou +); + +589  + `lock_may_wre +( +ode + *, +loff_t + +t +,  +cou +); + +591  + ssync_ru + { + +592  +magic +; + +593  +_fd +; + +594  +sync_ru + * +_xt +; + +595  +fe + * +_fe +; + +598  + #FASYNC_MAGIC + 0x4601 + + ) + +601  + `sync_hr +(,  +fe + *, ,  +sync_ru + **); + +603  + `kl_sync +( +sync_ru + **, , ); + +605  + `__kl_sync +( +sync_ru + *, , ); + +607  + smeida + { + +608  +dy + *dentry; + +609  +vfsmou + * +m +; + +610  +qr + +ϡ +; + +611  +ags +; + +612  +ϡ_ty +; + +615  + #DQUOT_USR_ENABLED + 0x01 + + ) + +616  + #DQUOT_GRP_ENABLED + 0x02 + + ) + +618  + squa_mou_tis + + +620  +ags +; + +621  +mhe + +dqio_m +; + +622  +mhe + +dqoff_m +; + +623  +fe + * +fes +[ +MAXQUOTAS +]; + +624 +time_t + +ode_expe +[ +MAXQUOTAS +]; + +625 +time_t + +block_expe +[ +MAXQUOTAS +]; + +626  +rsquash +[ +MAXQUOTAS +]; + +633  + #MNT_FORCE + 0x00000001 + + ) + +635  + ~ + +636  + ~ + +637  + ~ + +638  + ~ + +639  + ~ + +640  + ~ + +641  + ~ + +642  + ~ + +643  + ~ + +644  + ~ + +645  + ~ + +646  + ~ + +647  + ~ + +648  + ~ + +649  + ~ + +650  + ~ + +651  + ~ + +652  + ~ + +653  + ~ + +654  + ~ + +655  + ~ + +657  +li_hd + +sur_blocks +; + +659  + #sb_y +( +li + + `li_y +(i),  +sur_block +, +s_li +) + + ) + +660  + ssur_block + { + +661  +li_hd + +s_li +; + +662 +kdev_t + +s_dev +; + +663  +s_blocksize +; + +664  +s_blocksize_bs +; + +665  +s_dt +; + +666  +s_maxbys +; + +667  +fe_syem_ty + * +s_ty +; + +668  +sur_ݔis + * +s_ +; + +669  +dqu_ݔis + * +dq_ +; + +670  +s_ags +; + +671  +s_magic +; + +672  +dy + * +s_ro +; + +673  +rw_mhe + +s_umou +; + +674  +mhe + +s_lock +; + +676  +li_hd + +s_dty +; + +677  +li_hd + +s_locked_odes +; + +678  +li_hd + +s_fes +; + +680  +block_devi + * +s_bdev +; + +681  +li_hd + +s_mous +; + +682  +qua_mou_tis + +s_dqu +; + +685  +mix_sb_fo + +mix_sb +; + +686  +ext2_sb_fo + +ext2_sb +; + +687  +hpfs_sb_fo + +hpfs_sb +; + +688  +fs_sb_fo + +fs_sb +; + +689  +msdos_sb_fo + +msdos_sb +; + +690  +isofs_sb_fo + +isofs_sb +; + +691  +nfs_sb_fo + +nfs_sb +; + +692  +sysv_sb_fo + +sysv_sb +; + +693  +affs_sb_fo + +affs_sb +; + +694  +ufs_sb_fo + +ufs_sb +; + +695  +efs_sb_fo + +efs_sb +; + +696  +shmem_sb_fo + +shmem_sb +; + +697  +romfs_sb_fo + +romfs_sb +; + +698  +smb_sb_fo + +smbfs_sb +; + +699  +hfs_sb_fo + +hfs_sb +; + +700  +adfs_sb_fo + +adfs_sb +; + +701  +qnx4_sb_fo + +qnx4_sb +; + +702  +irfs_sb_fo + +irfs_sb +; + +703  +bfs_sb_fo + +bfs_sb +; + +704  +udf_sb_fo + +udf_sb +; + +705  +n_sb_fo + +nfs_sb +; + +706  +usbdev_sb_fo + +usbdevfs_sb +; + +707 * +gic_sbp +; + +708 } +u +; + +713  +mhe + +s_vfs_me_m +; + +722  +mhe + +s_nfsd__th_m +; + +728  + `vfs_ +( +ode + *,  +dy + *, ); + +729  + `vfs_mkd +( +ode + *,  +dy + *, ); + +730  + `vfs_mknod +( +ode + *,  +dy + *, , +dev_t +); + +731  + `vfs_symlk +( +ode + *,  +dy + *, const *); + +732  + `vfs_lk +( +dy + *,  +ode + *, dentry *); + +733  + `vfs_rmd +( +ode + *,  +dy + *); + +734  + `vfs_uƚk +( +ode + *,  +dy + *); + +735  + `vfs_me +( +ode + *,  +dy + *, inode *, dentry *); + +740  + #DT_UNKNOWN + 0 + + ) + +741  + #DT_FIFO + 1 + + ) + +742  + #DT_CHR + 2 + + ) + +743  + #DT_DIR + 4 + + ) + +744  + #DT_BLK + 6 + + ) + +745  + #DT_REG + 8 + + ) + +746  + #DT_LNK + 10 + + ) + +747  + #DT_SOCK + 12 + + ) + +748  + #DT_WHT + 14 + + ) + +756 (* + tfld_t +)(*, cڡ *, , + toff_t +, + to_t +, ); + +758  + sblock_devi_ݔis + { + +759 (* +ݒ +( +ode + *,  +fe + *); + +760 (* +a +( +ode + *,  +fe + *); + +761 (* +iol +( +ode + *,  +fe + *, , ); + +762 (* +check_med_chge +( +kdev_t +); + +763 (* +vide +( +kdev_t +); + +771  + sfe_ݔis + { + +772  +modu + * +owr +; + +773 + `loff_t + (* +Σek +( +fe + *, +loff_t +, ); + +774 + `ssize_t + (* +ad +( +fe + *, *, +size_t +, +loff_t + *); + +775 + `ssize_t + (* +wre +( +fe + *, cڡ *, +size_t +, +loff_t + *); + +776 (* +add +( +fe + *, *, +fld_t +); + +777 (* +pl +( +fe + *,  +pl_b_ru + *); + +778 (* +iol +( +ode + *,  +fe + *, , ); + +779 (* +mm +( +fe + *,  +vm__ru + *); + +780 (* +ݒ +( +ode + *,  +fe + *); + +781 (* +ush +( +fe + *); + +782 (* +a +( +ode + *,  +fe + *); + +783 (* +fsync +( +fe + *,  +dy + *,  +dasync +); + +784 (* +sync +(,  +fe + *, ); + +785 (* +lock +( +fe + *, ,  +fe_lock + *); + +786 + `ssize_t + (* +adv +( +fe + *, cڡ  +iovec + *, , +loff_t + *); + +787 + `ssize_t + (* +wrev +( +fe + *, cڡ  +iovec + *, , +loff_t + *); + +788 + `ssize_t + (* +ndge +( +fe + *,  +ge + *, , +size_t +, +loff_t + *, ); + +789 (* +g_unmd_ +)( +fe + *, , , , ); + +792  + sode_ݔis + { + +793 (* + +( +ode + *, +dy + *,); + +794  +dy + * (* +lookup +( +ode + *,dentry *); + +795 (* +lk +( +dy + *, +ode + *,dentry *); + +796 (* +uƚk +( +ode + *, +dy + *); + +797 (* +symlk +( +ode + *, +dy + *,const *); + +798 (* +mkd +( +ode + *, +dy + *,); + +799 (* +rmd +( +ode + *, +dy + *); + +800 (* +mknod +( +ode + *, +dy + *,,); + +801 (* +me +( +ode + *,  +dy + *, + +802  +ode + *,  +dy + *); + +803 (* +adlk +( +dy + *, *,); + +804 (* +flow_lk +( +dy + *,  +meida + *); + +805 (* +un +( +ode + *); + +806 (* +rmissi +( +ode + *, ); + +807 (* +vide +( +dy + *); + +808 (* +r +( +dy + *,  +r + *); + +809 (* +g +( +dy + *,  +r + *); + +816  + ssur_ݔis + { + +817 (* +ad_ode +( +ode + *); + +825 (* +ad_ode2 +( +ode + *, *) ; + +826 (* +dty_ode +( +ode + *); + +827 (* +wre_ode +( +ode + *, ); + +828 (* +put_ode +( +ode + *); + +829 (* +de_ode +( +ode + *); + +830 (* +put_sur +( +sur_block + *); + +831 (* +wre_sur +( +sur_block + *); + +832 (* +wre_sur_lockfs +( +sur_block + *); + +833 (* +uockfs +( +sur_block + *); + +834 (* +fs +( +sur_block + *, statfs *); + +835 (* +mou_fs +( +sur_block + *, *, *); + +836 (* +r_ode +( +ode + *); + +837 (* +umou_beg +( +sur_block + *); + +841  + #I_DIRTY_SYNC + 1 + + ) + +842  + #I_DIRTY_DATASYNC + 2 + + ) + +843  + #I_DIRTY_PAGES + 4 + + ) + +844  + #I_LOCK + 8 + + ) + +845  + #I_FREEING + 16 + + ) + +846  + #I_CLEAR + 32 + + ) + +848  + #I_DIRTY + ( +I_DIRTY_SYNC + | +I_DIRTY_DATASYNC + | +I_DIRTY_PAGES +) + + ) + +850  + `__mk_ode_dty +( +ode + *, ); + +851  +le +  + $mk_ode_dty +( +ode + *inode) + +853 + `__mk_ode_dty +( +ode +, +I_DIRTY +); + +854 + } +} + +856  +le +  + $mk_ode_dty_sync +( +ode + *inode) + +858 + `__mk_ode_dty +( +ode +, +I_DIRTY_SYNC +); + +859 + } +} + +861  +le +  + $mk_ode_dty_ges +( +ode + *inode) + +863 + `__mk_ode_dty +( +ode +, +I_DIRTY_PAGES +); + +864 + } +} + +866  + sdqu_ݔis + { + +867 (* + mlize +( + mode + *, ); + +868 (* + mdr +( + mode + *); + +869 (* + mloc_block +(cڡ  + mode + *, , ); + +870 (* + mloc_ode +(cڡ  + mode + *, ); + +871 (* + m_block +(cڡ  + mode + *, ); + +872 (* + m_ode +(cڡ  + mode + *, ); + +873 (* + msr +( + mdy + *,  + mr + *); + +876  + sfe_syem_ty + { + +877 cڡ * + mme +; + +878  + mfs_ags +; + +879  + msur_block + *(* + mad_sur +) (super_block *, *, ); + +880  +modu + * + mowr +; + +881  +vfsmou + * + mkn_m +; + +882  +fe_syem_ty + * + mxt +; + +885  + #DECLARE_FSTYPE +( +v +, +ty +, +ad +, +ags +) \ + +886  +fe_syem_ty + +v + = { \ + +887 +me +: +ty +, \ + +888 +ad_sur +: +ad +, \ + +889 +fs_ags +: +ags +, \ + +890 +owr +: +THIS_MODULE +, \ + +891 } + + ) + +893  + #DECLARE_FSTYPE_DEV +( +v +, +ty +, +ad +) \ + +894 + `DECLARE_FSTYPE +( +v +, +ty +, +ad +, +FS_REQUIRES_DEV +) + + ) + +897  + #fs_g +( +fs +) \ + +898 ((( +fs +&& (fs)-> +owr +) \ + +899 ? ( + `y_c_mod_cou +(( +fs +)-> +owr +? (fs: +NULL + ) \ + +900 : ( +fs +)) + + ) + +902  + #fs_put +( +fs +) \ + +904 i(( +fs +&& (fs)-> +owr +) \ + +905 + `__MOD_DEC_USE_COUNT +(( +fs +)-> +owr +); \ + +906 } 0) + + ) + +908  +gi_fesyem +( +fe_syem_ty + *); + +909  +uegi_fesyem +( +fe_syem_ty + *); + +910  +vfsmou + * +kn_mou +( +fe_syem_ty + *); + +911  +may_umou +( +vfsmou + *); + +912  +do_mou +(*, *, *, , *); + +914  + #kn_umou + +mput + + + ) + +916  +vfs_fs +( +sur_block + *,  +fs + *); + +921  + #LOCK_USE_CLNT + 1 + + ) + +923  + #FLOCK_VERIFY_READ + 1 + + ) + +924  + #FLOCK_VERIFY_WRITE + 2 + + ) + +926  +locks_mdy_locked +( +ode + *); + +927  +locks_mdy_ +(,  +ode + *,  +fe + *, +loff_t +, +size_t +); + +933  + #MANDATORY_LOCK +( +ode +) \ + +934 ( + `IS_MANDLOCK +( +ode +&& ((ode)-> +i_mode + & ( +S_ISGID + | +S_IXGRP +)=S_ISGID) + + ) + +936  +le +  + $locks_vify_locked +( +ode + *inode) + +938 i( + `MANDATORY_LOCK +( +ode +)) + +939  + `locks_mdy_locked +( +ode +); + +941 + } +} + +943  +le +  + $locks_vify_ +( +ad_wre +,  +ode + *inode, + +944  +fe + * +fp +, +loff_t + +offt +, + +945 +size_t + +cou +) + +947 i( +ode +-> +i_ock + && + `MANDATORY_LOCK +(inode)) + +948  + `locks_mdy_ +( +ad_wre +, +ode +, +fp +, +offt +, +cou +); + +950 + } +} + +952  +le +  + $locks_vify_un +( +ode + *inode, + +953  +fe + * +fp +, + +954 +loff_t + +size +) + +956 i( +ode +-> +i_ock + && + `MANDATORY_LOCK +(inode)) + +957  + `locks_mdy_ +( + +958 +FLOCK_VERIFY_WRITE +, +ode +, +fp +, + +959 +size + < +ode +-> +i_size + ? size : inode->i_size, + +960 ( +size + < +ode +-> +i_size + ? inode->i_size - size + +961 : +size + - +ode +-> +i_size +) + +964 + } +} + +966 +le +  + $g_a +( +ode + *ode,  +mode +) + +968 i( +ode +-> +i_ock + && (ode->i_ock-> +_ags + & +FL_LEASE +)) + +969  + `__g_a +( +ode +, +mode +); + +971 + } +} + +975 +asmlkage +  +sys_ݒ +(const *, , ); + +976 +asmlkage +  +sys_o +(); + +977  +do_un +( +dy + *, +loff_t + +t +); + +979  +fe + * +fp_ݒ +(const *, , ); + +980  +fe + * +dy_ݒ +( +dy + *,  +vfsmou + *, ); + +981  +fp_o +( +fe + *, +_owr_t + +id +); + +982 * +gme +(const *); + +985  +vfs_ches_ +(); + +987  + #__gme +( + `kmem_che_loc +( +mes_ch +, +SLAB_KERNEL +) + + ) + +988  + #puame +( +me + + `kmem_che_ +( +mes_ch +, (*)ame)) + + ) + +990 um { + mBDEV_FILE +, + mBDEV_SWAP +, + mBDEV_FS +, + mBDEV_RAW +}; + +991  +gi_blkdev +(, cڡ *,  +block_devi_ݔis + *); + +992  +uegi_blkdev +(, const *); + +993  +block_devi + * +bdg +( +dev_t +); + +994  +bdput +( +block_devi + *); + +995  +ch_devi + * +cdg +( +dev_t +); + +996  +cdput +( +ch_devi + *); + +997  +blkdev_ݒ +( +ode + *,  +fe + *); + +998  +fe_ݔis + +def_blk_fs +; + +999  +fe_ݔis + +def_fifo_fs +; + +1000  +iol_by_bdev +( +block_devi + *, , ); + +1001  +blkdev_g +( +block_devi + *, +mode_t +, , ); + +1002  +blkdev_put +( +block_devi + *, ); + +1005 cڡ  +block_devi_ݔis + * +g_blkfs +(); + +1006  +gi_chrdev +(, cڡ *,  +fe_ݔis + *); + +1007  +uegi_chrdev +(, const *); + +1008  +chrdev_ݒ +( +ode + *,  +fe + *); + +1009 cڡ * +bdevme +( +kdev_t +); + +1010 cڡ * +cdevme +( +kdev_t +); + +1011 cڡ * +kdevme +( +kdev_t +); + +1012  +_ecl_ode +( +ode + *, +umode_t +, ); + +1015  +make_bad_ode +( +ode + *); + +1016  +is_bad_ode +( +ode + *); + +1018  +fe_ݔis + +ad_fifo_fs +; + +1019  +fe_ݔis + +wre_fifo_fs +; + +1020  +fe_ݔis + +rdwr_fifo_fs +; + +1021  +fe_ݔis + +ad_pe_fs +; + +1022  +fe_ݔis + +wre_pe_fs +; + +1023  +fe_ݔis + +rdwr_pe_fs +; + +1025  +fs_may_mou_ro +( +sur_block + *); + +1027  +y_to__bufrs +( +ge + *, ); + +1028  +fe_bufr +( +bufr_hd + * +buf +); + +1031  +t_bufr_async_io +( +bufr_hd + * +bh +) ; + +1033  + #BUF_CLEAN + 0 + + ) + +1034  + #BUF_LOCKED + 1 + + ) + +1035  + #BUF_DIRTY + 2 + + ) + +1036  + #BUF_PROTECTED + 3 + + ) + +1037  + #NR_LIST + 4 + + ) + +1042  +le +  + $mk_bufr_uode +( +bufr_hd + * +bh +,  + +) + +1044 i( + +) + +1045 + `t_b +( +BH_Uode +, & +bh +-> +b_e +); + +1047 + `r_b +( +BH_Uode +, & +bh +-> +b_e +); + +1048 + } +} + +1050  + #omic_t_bufr_n +( +bh + + `_d_r_b +( +BH_Dty +, &(bh)-> +b_e +) + + ) + +1052  +le +  + $__mk_bufr_n +( +bufr_hd + * +bh +) + +1054 + `fe_bufr +( +bh +); + +1055 + } +} + +1057  +le +  + $mk_bufr_n +( +bufr_hd + * +bh +) + +1059 i( + `omic_t_bufr_n +( +bh +)) + +1060 + `__mk_bufr_n +( +bh +); + +1061 + } +} + +1063  + #omic_t_bufr_eed +( +bh + + `_d_t_b +( +BH_Preed +, &(bh)-> +b_e +) + + ) + +1065  +le +  + $__mk_bufr_eed +( +bufr_hd + * +bh +) + +1067 + `fe_bufr +( +bh +); + +1068 + } +} + +1070  +le +  + $mk_bufr_eed +( +bufr_hd + * +bh +) + +1072 i(! + `omic_t_bufr_eed +( +bh +)) + +1073 + `__mk_bufr_eed +( +bh +); + +1074 + } +} + +1076  +FASTCALL +( +__mk_bufr_dty +( +bufr_hd + * +bh +)); + +1077  +FASTCALL +( +mk_bufr_dty +( +bufr_hd + * +bh +)); + +1079  + #omic_t_bufr_dty +( +bh + + `_d_t_b +( +BH_Dty +, &(bh)-> +b_e +) + + ) + +1087  +le +  + $bufr_IO_r +( +bufr_hd + * +bh +) + +1089 + `mk_bufr_n +( +bh +); + +1093 +bh +-> + `b_d_io +(bh, 0); + +1094 + } +} + +1096  +bufr__ode_queue +( +bufr_hd + *,  +ode + *); + +1097  +le +  + $mk_bufr_dty_ode +( +bufr_hd + * +bh +,  +ode + *inode) + +1099 + `mk_bufr_dty +( +bh +); + +1100 + `bufr__ode_queue +( +bh +, +ode +); + +1101 + } +} + +1103  +b_dty +( +kdev_t +); + +1104  +check_disk_chge +( +kdev_t +); + +1105  +vide_odes +( +sur_block + *); + +1106  +vide_devi +( +kdev_t +, ); + +1107  +vide_ode_ges +( +ode + *); + +1108  +vide_ode_bufrs +( +ode + *); + +1109  + #vide_bufrs +( +dev + + `__vide_bufrs +((dev), 0) + + ) + +1110  + #deroy_bufrs +( +dev + + `__vide_bufrs +((dev), 1) + + ) + +1111  +__vide_bufrs +( +kdev_t + +dev +, ); + +1112  +sync_odes +( +kdev_t +); + +1113  +sync_uocked_odes +(); + +1114  +wre_ode_now +( +ode + *, ); + +1115  +sync_dev +( +kdev_t +); + +1116  +fsync_dev +( +kdev_t +); + +1117  +fsync_sur +( +sur_block + *); + +1118  +sync_odes_sb +( +sur_block + *); + +1119  +fsync_ode_bufrs +( +ode + *); + +1120  +osync_ode_bufrs +( +ode + *); + +1121  +ode_has_bufrs +( +ode + *); + +1122  +fem_fdasync +( +addss_a + *); + +1123  +fem_fdawa +( +addss_a + *); + +1124  +sync_surs +( +kdev_t +); + +1125  +bm +( +ode + *, ); + +1126  +nify_chge +( +dy + *,  +r + *); + +1127  +rmissi +( +ode + *, ); + +1128  +vfs_rmissi +( +ode + *, ); + +1129  +g_wre_acss +( +ode + *); + +1130  +dy_wre_acss +( +fe + *); + +1131  +le +  + $put_wre_acss +( +ode + * inode) + +1133 + `omic_dec +(& +ode +-> +i_wrecou +); + +1134 + } +} + +1135  +le +  + $low_wre_acss +( +fe + *file) + +1137 i( +fe +) + +1138 + `omic_c +(& +fe +-> +f_dy +-> +d_ode +-> +i_wrecou +); + +1139 + } +} + +1140  +do_pe +(*); + +1142  +ݒ_mei +(cڡ *, , ,  +meida + *); + +1144  +kl_ad +( +fe + *, , *, ); + +1145  +fe + * +ݒ_exec +(const *); + +1148  +is_subd +( +dy + *, dentry *); + +1149 +o_t + +fd_ode_numb +( +dy + *,  +qr + *); + +1159  +le + * + $ERR_PTR +( +r +) + +1161  (* +r +; + +1162 + } +} + +1164  +le +  + $PTR_ERR +(cڡ * +r +) + +1166  ( +r +; + +1167 + } +} + +1169  +le +  + $IS_ERR +(cڡ * +r +) + +1171  () +r + > ()-1000L; + +1172 + } +} + +1181  + #LOOKUP_FOLLOW + (1) + + ) + +1182  + #LOOKUP_DIRECTORY + (2) + + ) + +1183  + #LOOKUP_CONTINUE + (4) + + ) + +1184  + #LOOKUP_POSITIVE + (8) + + ) + +1185  + #LOOKUP_PARENT + (16) + + ) + +1186  + #LOOKUP_NOALT + (32) + + ) + +1190 um { + mLAST_NORM +, + mLAST_ROOT +, + mLAST_DOT +, + mLAST_DOTDOT +, + mLAST_BIND +}; + +1202 +size_t + + mwrn +; + +1203 +size_t + + mcou +; + +1204 * + mbuf +; + +1205  + mr +; + +1206 } + tad_dest_t +; + +1208 (* + tad_a_t +)( + tad_dest_t + *,  + tge + *, , ); + +1211 +loff_t + + `deu_Σek +( +fe + *fe,off_ +offt +,  +ig +); + +1213  + `__ur_wk +(cڡ *, ,  +meida + *); + +1214  + `th_ +(cڡ *, ,  +meida + *); + +1215  + `th_wk +(cڡ *,  +meida + *); + +1216  + `th_a +( +meida + *); + +1217  + `flow_down +( +vfsmou + **,  +dy + **); + +1218  + `flow_up +( +vfsmou + **,  +dy + **); + +1219  +dy + * + `lookup_e_n +(const *, dentry *, ); + +1220  +dy + * + `lookup_hash +( +qr + *, dentry *); + +1221  + #ur_th_wk +( +me +, +nd + + `__ur_wk +ame, +LOOKUP_FOLLOW +| +LOOKUP_POSITIVE +,d) + + ) + +1222  + #ur_th_wk_lk +( +me +, +nd + + `__ur_wk +ame, +LOOKUP_POSITIVE +,d) + + ) + +1224  + `ut +( +ode + *); + +1225  + `f_de +( +ode + *); + +1226  +ode + * + `igb +(inode *); + +1227 +o_t + + `iunique +( +sur_block + *, ino_t); + +1229 (* + tfd_ode_t +)( + tode + *, , *); + +1230  +ode + * + `ig4 +( +sur_block + *, , +fd_ode_t +, *); + +1231  +le +  +ode + * + $ig +( +sur_block + * +sb +,  +o +) + +1233  + `ig4 +( +sb +, +o +, +NULL +, NULL); + +1234 + } +} + +1236  +r_ode +( +ode + *); + +1237  +ode + * +g_emy_ode +(); + +1238  +le +  +ode + * + $w_ode +( +sur_block + * +sb +) + +1240  +ode + *od + `g_emy_ode +(); + +1241 i( +ode +) { + +1242 +ode +-> +i_sb + = +sb +; + +1243 +ode +-> +i_dev + = +sb +-> +s_dev +; + +1245  +ode +; + +1246 + } +} + +1247  +move_suid +( +ode + *inode); + +1249  +_ode_hash +( +ode + *); + +1250  +move_ode_hash +( +ode + *); + +1251  +fe + * +g_emy_fp +(); + +1252  +fe_move +( +fe + * +f +,  +li_hd + * +li +); + +1253  +fe_movo +( +fe + * +w +, f* +d +); + +1254  +bufr_hd + * +g_hash_b +( +kdev_t +, , ); + +1255  +bufr_hd + * +gblk +( +kdev_t +, , ); + +1256  +_rw_block +(, ,  +bufr_hd + * +bh +[]); + +1257  +subm_bh +(,  +bufr_hd + *); + +1258  +is_ad_ly +( +kdev_t +); + +1259  +__bl +( +bufr_hd + *); + +1260  +le +  + $bl +( +bufr_hd + * +buf +) + +1262 i( +buf +) + +1263 + `__bl +( +buf +); + +1264 + } +} + +1265  +__bfg +( +bufr_hd + *); + +1266  +le +  + $bfg +( +bufr_hd + * +buf +) + +1268 i( +buf +) + +1269 + `__bfg +( +buf +); + +1270 + } +} + +1271  +t_blocksize +( +kdev_t +, ); + +1272  +bufr_hd + * +bad +( +kdev_t +, , ); + +1273  +wakeup_bdush +( +wa +); + +1275  +brw_ge +(,  +ge + *, +kdev_t +, [], ); + +1277 ( + tg_block_t +)( + tode +*,, + tbufr_hd +*,); + +1280  + `block_ushge +( +ge + *, ); + +1281  + `block_symlk +( +ode + *, const *, ); + +1282  + `block_wre_fu_ge +( +ge +*, +g_block_t +*); + +1283  + `block_ad_fu_ge +( +ge +*, +g_block_t +*); + +1284  + `block_e_wre +( +ge +*, , , +g_block_t +*); + +1285  + `ct_e_wre +( +ge +*, , , +g_block_t +*, + +1287  + `block_sync_ge +( +ge + *); + +1289  + `gic_block_bm +( +addss_a + *, , +g_block_t + *); + +1290  + `gic_comm_wre +( +fe + *,  +ge + *, , ); + +1291  + `block_un_ge +( +addss_a + *, +loff_t +, +g_block_t + *); + +1293  + `waf_e_ge +( +ge +*); + +1294  + `gic_fe_mm +( +fe + *,  +vm__ru + *); + +1295  + `fe_ad_a +( +ad_dest_t + * +desc +,  +ge + *ge,  +offt +,  +size +); + +1296 +ssize_t + + `gic_fe_ad +( +fe + *, *, +size_t +, +loff_t + *); + +1297 +ssize_t + + `gic_fe_wre +( +fe + *, cڡ *, +size_t +, +loff_t + *); + +1298  + `do_gic_fe_ad +( +fe + *, +loff_t + *, +ad_dest_t + *, +ad_a_t +); + +1300 +ssize_t + + `gic_ad_d +( +fe + *, *, +size_t +, +loff_t + *); + +1302  +fe_ݔis + +gic_ro_fs +; + +1304  + `vfs_adlk +( +dy + *, *, , const *); + +1305  + `vfs_flow_lk +( +meida + *, const *); + +1306  + `ge_adlk +( +dy + *, *, ); + +1307  + `ge_flow_lk +( +dy + *,  +meida + *); + +1308  +ode_ݔis + +ge_symlk_ode_ݔis +; + +1310  + `vfs_add +( +fe + *, +fld_t +, *); + +1311  + `dche_add +( +fe + *, *, +fld_t +); + +1313  +fe_syem_ty + * + `g_fs_ty +(cڡ * +me +); + +1314  +sur_block + * + `g_sur +( +kdev_t +); + +1315  + `put_sur +( +kdev_t +); + +1316  +le +  + $is_moued +( +kdev_t + +dev +) + +1318  +sur_block + * +sb + = + `g_sur +( +dev +); + +1319 i( +sb +) { + +1324 + } +} + +1325  +ge_u +( +kdev_t +,  +b +[], ); + +1326  +ge_u_swab32 +( +kdev_t +,  +b +[], ); + +1327 +kdev_t + +ROOT_DEV +; + +1328  +ro_devi_me +[]; + +1331  +show_bufrs +(); + +1332  +mou_ro +(); + +1334 #ifde +CONFIG_BLK_DEV_INITRD + + +1335 +kdev_t + +_ro_dev +; + +1336  +chge_ro +( +kdev_t +, const *); + +1339 +ssize_t + +ch_ad +( +fe + *, *, +size_t +, +loff_t + *); + +1340 +ssize_t + +block_ad +( +fe + *, *, +size_t +, +loff_t + *); + +1341  +ad_ahd +[]; + +1343 +ssize_t + +ch_wre +( +fe + *, cڡ *, +size_t +, +loff_t + *); + +1344 +ssize_t + +block_wre +( +fe + *, cڡ *, +size_t +, +loff_t + *); + +1346  +fe_fsync +( +fe + *,  +dy + *, ); + +1347  +gic_bufr_fdasync +( +ode + *ode,  +t_idx +,  +d_idx +); + +1348  +gic_osync_ode +( +ode + *, ); + +1350  +ode_chge_ok +( +ode + *,  +r + *); + +1351  +ode_r +( +ode + *,  +r + *); + +1372  +le +  +dy + * + $lock_ +( +dy + *dentry) + +1374  +dy + * +d + = + `dg +(dy-> +d_ +); + +1376 + `down +(& +d +-> +d_ode +-> +i_m +); + +1377  +d +; + +1378 + } +} + +1380  +le +  +dy + * + $g_ +( +dy + *dentry) + +1382  + `dg +( +dy +-> +d_ +); + +1383 + } +} + +1385  +le +  + $uock_d +( +dy + * +d +) + +1387 + `up +(& +d +-> +d_ode +-> +i_m +); + +1388 + `dput +( +d +); + +1389 + } +} + +1395  +le +  + $doub_down +( +mhe + * +s1 +, mhܐ* +s2 +) + +1397 i( +s1 + ! +s2 +) { + +1398 i(( +s1 + < ( +s2 +) { + +1399  +mhe + * +tmp + = +s2 +; + +1400 +s2 + = +s1 +; s1 = +tmp +; + +1402 + `down +( +s1 +); + +1404 + `down +( +s2 +); + +1405 + } +} + +1416  +le +  + $_down +( +mhe + * +s1 +, + +1417  +mhe + * +s2 +, + +1418  +mhe + * +s3 +) + +1420 i( +s1 + ! +s2 +) { + +1421 i(( +s1 + < ( +s2 +) { + +1422 i(( +s1 + < ( +s3 +) { + +1423  +mhe + * +tmp + = +s3 +; + +1424 +s3 + = +s1 +; s1 = +tmp +; + +1426 i(( +s1 + < ( +s2 +) { + +1427  +mhe + * +tmp + = +s2 +; + +1428 +s2 + = +s1 +; s1 = +tmp +; + +1431 i(( +s1 + < ( +s3 +) { + +1432  +mhe + * +tmp + = +s3 +; + +1433 +s3 + = +s1 +; s1 = +tmp +; + +1435 i(( +s2 + < ( +s3 +) { + +1436  +mhe + * +tmp + = +s3 +; + +1437 +s3 + = +s2 +; s2 = +tmp +; + +1440 + `down +( +s1 +); + +1441 } i(( +s2 + < ( +s3 +) { + +1442  +mhe + * +tmp + = +s3 +; + +1443 +s3 + = +s2 +; s2 = +tmp +; + +1445 + `down +( +s2 +); + +1446 + `down +( +s3 +); + +1447 + } +} + +1449  +le +  + $doub_up +( +mhe + * +s1 +, mhܐ* +s2 +) + +1451 + `up +( +s1 +); + +1452 i( +s1 + ! +s2 +) + +1453 + `up +( +s2 +); + +1454 + } +} + +1456  +le +  + $_up +( +mhe + * +s1 +, + +1457  +mhe + * +s2 +, + +1458  +mhe + * +s3 +) + +1460 + `up +( +s1 +); + +1461 i( +s1 + ! +s2 +) + +1462 + `up +( +s2 +); + +1463 + `up +( +s3 +); + +1464 + } +} + +1466  +le +  + $doub_lock +( +dy + * +d1 +, dy * +d2 +) + +1468 + `doub_down +(& +d1 +-> +d_ode +-> +i_m +, & +d2 +->d_inode->i_sem); + +1469 + } +} + +1471  +le +  + $doub_uock +( +dy + * +d1 +, dy * +d2 +) + +1473 + `doub_up +(& +d1 +-> +d_ode +-> +i_m +,& +d2 +->d_inode->i_sem); + +1474 + `dput +( +d1 +); + +1475 + `dput +( +d2 +); + +1476 + } +} + + @fs/localfs.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"fs/lolfs.h +" + +36  + #FS_NAME + +L +"vt" + + ) + +40 +EFI_HANDLE + + mdev +; + +41 +EFI_FILE_HANDLE + + mvume +; + +42 } + tlolfs_iv_e_t +; + +44  + #LOCALFS_F2FD +( +f +(( +UINTN +)(f)) + + ) + +45  + #LOCALFS_FD2F +( +fd +(( +EFI_FILE_HANDLE +)(fd)) + + ) + +48 +lolfs_r_t + + mpub_tf +; + +50 +lolfs_r_t + + mpub_tf +; + +51 +lolfs_iv_e_t + + miv_da +; + +52 } + mlolfs_iv +; + +53 } + tlolfs_t +; + +55  + #FS_PRIVATE +( +n +(&((( +lolfs_t + *)-> +lolfs_iv +. +iv_da +)) + + ) + +58  +EFI_GUID + + gLolFsProc + = +LOCALFS_PROTOCOL +; + +64 +EFI_HANDLE + * + mdev +; + +65 +lolfs_t + * + mtf +; + +66 } + tdev_b_t +; + +68  +dev_b_t + * + gdev_b +; + +69  +UINTN + + gndev +; + +71  +EFI_STATUS + + +72 + $lolfs_me +( +lolfs_r_t + * +this +, +CHAR16 + * +me +, +UINTN + +maxn +) + +74 i( +me + = +NULL + || +maxn + < 1 +EFI_INVALID_PARAMETER +; + +76 + `SnCpy +( +me +, +FS_NAME +, +maxn +-1); + +78 +me +[ +maxn +-1] = +CHAR_NULL +; + +80  +EFI_SUCCESS +; + +81 + } +} + +84  +EFI_STATUS + + +85 + $lolfs_ݒ +( +lolfs_r_t + * +this +, +CHAR16 + * +me +, +UINTN + * +fd +) + +87 +lolfs_iv_e_t + * +lfs +; + +88 +EFI_STATUS + +us +; + +89 +EFI_FILE_HANDLE + +fh +; + +91 i( +this + = +NULL + || +me + =NULL || +fd + =NULL +EFI_INVALID_PARAMETER +; + +93 +lfs + = + `FS_PRIVATE +( +this +); + +95 + `DBG_PRT +(( +L +"lolfs_ݒ o%s\n", +me +)); + +97 +us + = +lfs +-> +vume +-> + `On +fs->vume, & +fh +, +me +, +EFI_FILE_MODE_READ +, 0); + +98 i( +us + = +EFI_SUCCESS +) { + +99 * +fd + = + `LOCALFS_F2FD +( +fh +); + +101  +us +; + +102 + } +} + +104  +EFI_STATUS + + +105 + $lolfs_ad +( +lolfs_r_t + * +this +, +UINTN + +fd +, +VOID + * +buf +, UINTN * +size +) + +107 +lolfs_iv_e_t + * +lfs +; + +109 i( +this + = +NULL + || +fd + =0 || +buf + =NULL || +size + =NULL +EFI_INVALID_PARAMETER +; + +111 +lfs + = + `FS_PRIVATE +( +this +); + +113  +lfs +-> +vume +-> + `Rd +( + `LOCALFS_FD2F +( +fd +), +size +, +buf +); + +114 + } +} + +116  +EFI_STATUS + + +117 + $lolfs_o +( +lolfs_r_t + * +this +, +UINTN + +fd +) + +119 +lolfs_iv_e_t + * +lfs +; + +121 i( +this + = +NULL + || +fd + =0 +EFI_INVALID_PARAMETER +; + +123 +lfs + = + `FS_PRIVATE +( +this +); + +125  +lfs +-> +vume +-> + `Clo +( + `LOCALFS_FD2F +( +fd +)); + +126 + } +} + +128  +EFI_STATUS + + +129 + $lolfs_fosize +( +lolfs_r_t + * +this +, +UINTN + +fd +, +UINT64 + * +sz +) + +131 +lolfs_iv_e_t + * +lfs +; + +132 +EFI_FILE_INFO + * +fo +; + +134 i( +this + = +NULL + || +fd + =0 || +sz + =NULL +EFI_INVALID_PARAMETER +; + +136 +lfs + = + `FS_PRIVATE +( +this +); + +138 +fo + = + `LibFeInfo +( + `LOCALFS_FD2F +( +fd +)); + +139 i( +fo + = +NULL + +EFI_UNSUPPORTED +; + +141 * +sz + = +fo +-> +FeSize +; + +143 + `FePo +( +fo +); + +145  +EFI_SUCCESS +; + +146 + } +} + +148  +EFI_STATUS + + +149 + $lolfs_ek +( +lolfs_r_t + * +this +, +UINTN + +fd +, +UINT64 + +wpos +) + +151 +lolfs_iv_e_t + * +lfs +; + +153 i( +this + = +NULL + || +fd + =0 +EFI_INVALID_PARAMETER +; + +155 +lfs + = + `FS_PRIVATE +( +this +); + +157  +lfs +-> +vume +-> + `SPosi +( + `LOCALFS_FD2F +( +fd +), +wpos +); + +158 + } +} + +160  +VOID + + +161 + $lolfs__e +( +lolfs_t + * +lolfs +, +EFI_HANDLE + +dev +, +EFI_FILE_HANDLE + +vume +) + +163 +lolfs_iv_e_t + * +lfs + = + `FS_PRIVATE +( +lolfs +); + +166 + `Memt +( +lolfs +, 0, (*localfs)); + +168 +lolfs +-> +pub_tf +. +lolfs_me + =ocalfs_name; + +169 +lolfs +-> +pub_tf +. +lolfs_ݒ + =ocalfs_open; + +170 +lolfs +-> +pub_tf +. +lolfs_ad + =ocalfs_read; + +171 +lolfs +-> +pub_tf +. +lolfs_o + =ocalfs_close; + +172 +lolfs +-> +pub_tf +. +lolfs_fosize + =ocalfs_infosize; + +173 +lolfs +-> +pub_tf +. +lolfs_ek + =ocalfs_seek; + +175 +lfs +-> +dev + = dev; + +176 +lfs +-> +vume + = volume; + +177 + } +} + +179  +EFI_STATUS + + +180 + $lolfs_l_e +( +EFI_HANDLE + +dev +, +VOID + ** +tf +) + +183 +EFI_STATUS + +us +; + +184 +lolfs_t + * +lolfs +; + +185 +EFI_FILE_IO_INTERFACE + * +vume +; + +186 +EFI_FILE_HANDLE + +vume_fh +; + +188 +us + = +BS +-> + `HdProc + ( +dev +, & +LolFsProc +, ( +VOID + **)& +lolfs +); + +189 i( +us + = +EFI_SUCCESS +) { + +190 + `ERR_PRT +(( +L +"Wng: foundxig %oc odevi", +FS_NAME +)); + +191  +found +; + +194 +us + = +BS +-> + `HdProc + ( +dev +, & +FeSyemProc +, ( +VOID + **)& +vume +); + +195 i( + `EFI_ERROR +( +us +) +EFI_INVALID_PARAMETER +; + +197 +us + = +vume +-> + `OnVume +(vume, & +vume_fh +); + +198 i( + `EFI_ERROR +( +us +)) { + +199 + `ERR_PRT +(( +L +"cannot open volume")); + +200  +us +; + +203 +lolfs + = ( +lolfs_t + *) + `loc +((*lolfs), +EfiLdDa +); + +204 i( +lolfs + = +NULL +) { + +205 + `ERR_PRT +(( +L +"edخlo %s", +FS_NAME +)); + +206  +EFI_OUT_OF_RESOURCES +; + +208 + `lolfs__e +( +lolfs +, +dev +, +vume_fh +); + +210 +us + = + `LibInlProcIs +(& +dev +, & +LolFsProc +, +lolfs +, +NULL +); + +211 i( + `EFI_ERROR +( +us +)) { + +212 + `ERR_PRT +(( +L +"Cn in%oc: %r", +FS_NAME +, +us +)); + +213 + ` +( +lolfs +); + +214  +us +; + +216 +found +: + +217 i( +tf +*t( +VOID + *) +lolfs +; + +219 + `VERB_PRT +(3, + +220 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +221 +dp + = + `DeviPhFromHd +( +dev +); + +222 +r + = + `DeviPhToS +( +dp +); + +223 + `Prt +( +L +"ched %t%s\n", +FS_NAME +, +r +); + +224 + `FePo +( +r +); + +227  +EFI_SUCCESS +; + +228 + } +} + +230 +EFI_STATUS + + +231 + $lolfs_l +( +VOID +) + +233 +UINTN + +size + = 0; + +234 +UINTN + +i +; + +235 +EFI_STATUS + +us +; + +236 +VOID + * +tf +; + +238 +BS +-> + `LoHd +( +ByProc +, & +FeSyemProc +, +NULL +, & +size +, NULL); + +239 i( +size + =0 +EFI_UNSUPPORTED +; + +241 + `DBG_PRT +(( +L +"size=%d", +size +)); + +243 +dev_b + = ( +dev_b_t + *) + `loc +( +size +, +EfiLdDa +); + +244 i( +dev_b + = +NULL +) { + +245 + `ERR_PRT +(( +L +"failedollocate handleable")); + +246  +EFI_OUT_OF_RESOURCES +; + +249 +us + = +BS +-> + `LoHd +( +ByProc +, & +FeSyemProc +, +NULL +, & +size +, ( +VOID + **) +dev_b +); + +250 i( +us + ! +EFI_SUCCESS +) { + +251 + `ERR_PRT +(( +L +"edg hds: %r", +us +)); + +252 + ` +( +dev_b +); + +253  +us +; + +255 +ndev + = +size + / ( +EFI_HANDLE +); + +257  +i +=0; i < +ndev +; i++) { + +258 +tf + = +NULL +; + +259 + `lolfs_l_e +( +dev_b +[ +i +]. +dev +, & +tf +); + +261 +dev_b +[ +i +]. +tf + = intf; + +264  +EFI_SUCCESS +; + +265 + } +} + +267 +EFI_STATUS + + +268 + $lolfs_unl +( +VOID +) + +271 +lolfs_iv_e_t + * +lfs +; + +272 +EFI_STATUS + +us +; + +273 +UINTN + +i +; + +275  +i +=0; i < +ndev +; i++) { + +276 i( +dev_b +[ +i +]. +tf + = +NULL +) ; + +277 +lfs + = + `FS_PRIVATE +( +dev_b +[ +i +]. +tf +); + +278 +us + = +BS +-> + `UnlProcI +( +lfs +-> +dev +, & +LolFsProc +, +dev_b +[ +i +]. +tf +); + +279 i( + `EFI_ERROR +( +us +)) { + +280 + `ERR_PRT +(( +L +"Un%r: %r", +FS_NAME +, +us +)); + +283 + `VERB_PRT +(3, + +284 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +285 +dp + = + `DeviPhFromHd +( +lfs +-> +dev +); + +286 +r + = + `DeviPhToS +( +dp +); + +287 + `Prt +( +L +"und % %s\n", +FS_NAME +, +r +); + +288 + `FePo +( +r +); + +290 + ` +( +dev_b +[ +i +]. +tf +); + +292 i( +dev_b + + ` +(dev_tab); + +294  +EFI_SUCCESS +; + +295 + } +} + + @fs/localfs.h + +26 #ide +__LOCALFS_H__ + + +27  + #__LOCALFS_H__ + + + ) + +29 +INTERFACE_DECL +( +_lolfs_r_t +); + +31  + s_lolfs_r_t + { + +32 +EFI_STATUS + (* +lolfs_me +)( +_lolfs_r_t + * + mthis +, +CHAR16 + * + mme +, +UINTN + + mmaxn +); + +33 +EFI_STATUS + (* +lolfs_ݒ +)( +_lolfs_r_t + * + mthis +, +CHAR16 + * + mme +, +UINTN + * + mfd +); + +34 +EFI_STATUS + (* +lolfs_ad +)( +_lolfs_r_t + * + mthis +, +UINTN + + mfd +, +VOID + * + mbuf +, UINTN * + msize +); + +35 +EFI_STATUS + (* +lolfs_o +)( +_lolfs_r_t + * + mthis +, +UINTN + + mfd +); + +36 +EFI_STATUS + (* +lolfs_fosize +)( +_lolfs_r_t + * + mthis +, +UINTN + + mfd +, +UINT64 + * + msize +); + +37 +EFI_STATUS + (* +lolfs_ek +)( +_lolfs_r_t + * + mthis +, +UINTN + + mfd +, +UINT64 + + mwpos +); + +38 } + tlolfs_r_t +; + +40  + #LOCALFS_PROTOCOL + \ + +41 { 0x3a42ff5d, 0x43c9, 0x4db8, {0x82, 0x4e, 0xb8, 0x5b, 0xab, 0x97, 0x63, 0xcc} } + + ) + +43 +EFI_STATUS + +lolfs_l +( +VOID +); + +44 +EFI_STATUS + +lolfs_unl +( +VOID +); + + @fs/netfs.c + +26  + ~ + +27  + ~ + +29  + ~"fs/tfs.h +" + +31  + ~"o.h +" + +33  + #FS_NAME + +L +"tfs" + + ) + +35  + #NETFS_DEFAULT_BUFSIZE + 16* +MB + + + ) + +36  + #NETFS_DEFAULT_BUFSIZE_INC + 8* +MB + + + ) + +38  + #NETFS_DEFAULT_SERVER_TYPE + +EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP + + + ) + +39  + #NETFS_FD_MAX + 2 + + ) + +41  + s_tfs_fd + { + +42  +_tfs_fd + * + mxt +; + +44 +CHAR8 + * + mtbuf +; + +45 +UINT64 + + mtbuf_maxsize +; + +46 +UINTN + + mtbuf_size +; + +47 +UINT64 + + mtbuf_pos +; + +48 +BOOLEAN + + mis_vid +; + +49 +BOOLEAN + + mtbuf_u +; + +51 +CHAR16 + + mϡ_fe +[ +FILENAME_MAXLEN +]; + +52 } + ttfs_fd_t +; + +56 +EFI_PXE_BASE_CODE + * + mpxe +; + +57 +EFI_HANDLE + + mdev +; + +58 +BOOLEAN + + musg_pxe +; + +60 +EFI_IP_ADDRESS + + mv_ +; + +61 +EFI_IP_ADDRESS + + mn_ +; + +62 +EFI_IP_ADDRESS + + mgw_ +; + +63 +EFI_IP_ADDRESS + + mtmask +; + +64 +UINT8 + + mhw_addr +[16]; + +66 +tfs_fd_t + + mfd_b +[ +NETFS_FD_MAX +]; + +67 +tfs_fd_t + * + m_fd +; + +68 +UINTN + + m_fd_cou +; + +70 } + ttfs_iv_e_t +; + +72  + #NETFS_F2FD +( +l +, +f +( +UINTN +)((f)-)-> +fd_b +) + + ) + +73  + #NETFS_FD2F +( +l +, +fd +()-> +fd_b ++fd) + + ) + +74  + #NETFS_F_INVALID +( +f +((f)-> +is_vid + = +FALSE +) + + ) + +78 +tfs_r_t + + mpub_tf +; + +80 +tfs_r_t + + mpub_tf +; + +81 +tfs_iv_e_t + + miv_da +; + +82 } + mtfs_iv +; + +83 } + ttfs_t +; + +85  + #FS_PRIVATE +( +n +(&((( +tfs_t + *)-> +tfs_iv +. +iv_da +)) + + ) + +88 +EFI_HANDLE + * + mdev +; + +89 +tfs_t + * + mtf +; + +90 } + tdev_b_t +; + +92  +dev_b_t + * + gdev_b +; + +93  +UINTN + + gndev +; + +95  +EFI_GUID + + gNFsProc + = +NETFS_PROTOCOL +; + +99  +EFI_PXE_BASE_CODE_CALLBACK_STATUS + + +100 + $tfs_back_func +( + +101 +IN + +EFI_PXE_BASE_CODE_CALLBACK + * +this +, + +102 +IN + +EFI_PXE_BASE_CODE_FUNCTION + +funi +, + +103 +IN + +BOOLEAN + +ived +, + +104 +IN + +UINT32 + +ck_n +, + +105 +IN + +EFI_PXE_BASE_CODE_PACKET + * +ck + +OPTIONAL + + +108 + `Prt +( +L +"tfs_back cdeived=%dack_n=%d\n", +ived +, +ck_n +); + +109  +EFI_ABORTED +; + +110 + } +} + +112  +EFI_PXE_BASE_CODE_CALLBACK + + gtfs_back + = { + +113 +EFI_PXE_BASE_CODE_CALLBACK_INTERFACE_REVISION +, + +114 & +tfs_back_func + + +118  +tfs_fd_t + * + +119 + $tfs_fd_loc +( +tfs_iv_e_t + * +nfs +, +CHAR16 + * +me +) + +121 +tfs_fd_t + * +tmp + = +NULL +, * +ev + = NULL, * +mch +; + +122 +UINT8 + +tbuf_u + = 0; + +124 i( +nfs +-> +_fd + = +NULL +) { + +125 + `ERR_PRT +(( +L +"out of file descriptor")); + +126  +NULL +; + +128 +mch + = +nfs +-> +_fd +; + +129  +tmp + = +nfs +-> +_fd +;mp;mtmp-> +xt +) { + +130 i(! + `SCmp +( +me +, +tmp +-> +ϡ_fe +)) { + +131 + `DBG_PRT +(( +L +"Usg cached f%tbuf_size=%d", +tmp +-> +ϡ_fe +,mp-> +tbuf_size +)); + +132 +tbuf_u + = 1; + +133 +mch + = +tmp +; + +136 +ev + = +tmp +; + +139 +mch +-> +tbuf_u + =etbuf_reuse; + +141 i( +mch + = +nfs +-> +_fd +) + +142 +nfs +-> +_fd + = +mch +-> +xt +; + +144 +ev +-> +xt + = +mch +->next; + +146 +nfs +-> +_fd_cou +--; + +148  +mch +; + +149 + } +} + +151  +VOID + + +152 + $tfs_fd_ +( +tfs_iv_e_t + * +nfs +, +tfs_fd_t + * +f +) + +154 i( +f + = +NULL +) { + +155 + `ERR_PRT +(( +L +"invalid fd")); + +158 +f +-> +xt + = +nfs +-> +_fd +; + +161 +f +-> +is_vid + = +FALSE +; + +163 +nfs +-> +_fd + = +f +; + +164 +nfs +-> +_fd_cou +++; + +166 i( +nfs +-> +_fd_cou + > +NETFS_FD_MAX +) { + +167 + `ERR_PRT +(( +L +"tomy fdestܠ%d", +nfs +-> +_fd_cou +)); + +169 + } +} + +172  +INTN + + +173 + $tbuf_loc +( +tfs_fd_t + * +f +) + +176 i( +f +-> +tbuf + != 0)  0; + +178 +f +-> +tbuf_pos + = 0; + +180 +f +-> +tbuf + = ( +CHAR8 + *) + `loc_ges +( + `EFI_SIZE_TO_PAGES +(f-> +tbuf_maxsize +), +EfiLdDa +, +AoAnyPages +, 0); + +182  +f +-> +tbuf + == 0 ? -1 : 0; + +183 + } +} + +185  +EFI_STATUS + + +186 + $tfs_me +( +tfs_r_t + * +this +, +CHAR16 + * +me +, +UINTN + +maxn +) + +188 i( +me + = +NULL + || +maxn + < 1 +EFI_INVALID_PARAMETER +; + +190 + `SnCpy +( +me +, +FS_NAME +, +maxn +-1); + +192 +me +[ +maxn +-1] = +CHAR_NULL +; + +194  +EFI_SUCCESS +; + +195 + } +} + +197  +VOID + + +198 + $tfs_exa_ +( +tfs_iv_e_t + * +nfs +) + +200 +EFI_PXE_BASE_CODE + * +pxe + = +nfs +->pxe; + +202 i( +pxe +-> +Mode +-> +PxeDiscovVid +) { + +203 +nfs +-> +usg_pxe + = +TRUE +; + +204 + `Memy +(& +nfs +-> +v_ +, +pxe +-> +Mode +-> +PxeRly +. +Dhv4 +. +BopSiAddr +, ( +EFI_IP_ADDRESS +)); + +205 + `Memy +(& +nfs +-> +hw_addr +, +pxe +-> +Mode +-> +PxeRly +. +Dhv4 +. +BopHwAddr +, 16*( +UINT8 +)); + +207 + `Memy +(& +nfs +-> +v_ +, +pxe +-> +Mode +-> +DhAck +. +Dhv4 +. +BopSiAddr +, ( +EFI_IP_ADDRESS +)); + +208 + `Memy +(& +nfs +-> +hw_addr +, +pxe +-> +Mode +-> +DhAck +. +Dhv4 +. +BopHwAddr +, (nfs->hw_addr)); + +211 + `Memy +(& +nfs +-> +n_ +, & +pxe +-> +Mode +-> +StiIp +, ( +EFI_IP_ADDRESS +)); + +212 + `Memy +(& +nfs +-> +tmask +, & +pxe +-> +Mode +-> +SubtMask +, ( +EFI_IP_ADDRESS +)); + +217 i( +pxe +-> +Mode +-> +RouTabErs +>0) + +218 + `Memy +(& +nfs +-> +gw_ +, & +pxe +-> +Mode +-> +RouTab +[0]. +GwAddr +, ( +EFI_IP_ADDRESS +)); + +220 + `VERB_PRT +(1, + `Prt +( +L +"PXE PxeDiscovVid: %s\n", +pxe +-> +Mode +-> +PxeDiscovVid +? L"Yes (PXE-aware DHCPD)" : L"No (Regular DHCPD)")); + +222 +us + = +BS +-> + `HdProc +( +dev +, & +PxeClbackProc +, ( +VOID + **)& +tfs_back +); + +223 +us + = + `LibInlProcIs +(& +dev +, & +PxeClbackProc +, & +tfs_back +, +NULL +); + +224 + `Prt +( +L +"PXE Clback su܈: %r\n", +us +); + +225 i( +us + = +EFI_SUCCESS +) { + +226 +BOOLEAN + +do + = +TRUE +; + +227 +us + = +pxe +-> + `SPams +xe, +NULL +, NULL, NULL, NULL, & +do +); + +228 + `Prt +( +L +"PXE Clback SPams: %r\n", +us +); + +234 + `VERB_PRT +(1, + `Prt +( +L +"Local IP: %d.%d.%d.%d\n", + +235 +pxe +-> +Mode +-> +StiIp +. +v4 +. +Addr +[0] & 0xff, + +236 +pxe +-> +Mode +-> +StiIp +. +v4 +. +Addr +[1] & 0xff, + +237 +pxe +-> +Mode +-> +StiIp +. +v4 +. +Addr +[2] & 0xff, + +238 +pxe +-> +Mode +-> +StiIp +. +v4 +. +Addr +[3] & 0xff)); + +240 + `VERB_PRT +(1, + `Prt +( +L +"SM: %d.%d.%d.%d\n", + +241 +pxe +-> +Mode +-> +SubtMask +. +v4 +. +Addr +[0] & 0xff, + +242 +pxe +-> +Mode +-> +SubtMask +. +v4 +. +Addr +[1] & 0xff, + +243 +pxe +-> +Mode +-> +SubtMask +. +v4 +. +Addr +[2] & 0xff, + +244 +pxe +-> +Mode +-> +SubtMask +. +v4 +. +Addr +[3] & 0xff)); + +246 + `VERB_PRT +(1, + `Prt +( +L +"TFTPD IP: %d.%d.%d.%d\n", + +247 +nfs +-> +v_ +. +v4 +. +Addr +[0] & 0xff, + +248 +nfs +-> +v_ +. +v4 +. +Addr +[1] & 0xff, + +249 +nfs +-> +v_ +. +v4 +. +Addr +[2] & 0xff, + +250 +nfs +-> +v_ +. +v4 +. +Addr +[3] & 0xff)); + +252 + `VERB_PRT +(1, + `Prt +( +L +"Gateway IP: %d.%d.%d.%d\n", + +253 +nfs +-> +gw_ +. +v4 +. +Addr +[0] & 0xff, + +254 +nfs +-> +gw_ +. +v4 +. +Addr +[1] & 0xff, + +255 +nfs +-> +gw_ +. +v4 +. +Addr +[2] & 0xff, + +256 +nfs +-> +gw_ +. +v4 +. +Addr +[3] & 0xff)); + +258 + } +} + +260  +EFI_STATUS + + +261 + $tfs_t +( +EFI_PXE_BASE_CODE + * +pxe +) + +263 +EFI_STATUS + +us +; + +265 +us + = +pxe +-> + `S +xe, +FALSE +); + +266 i( + `EFI_ERROR +( +us +))  status; + +268  +pxe +-> + `Dh +xe, +FALSE +); + +269 + } +} + +271  +EFI_STATUS + + +272 + $tfs_ݒ +( +tfs_r_t + * +this +, +CHAR16 + * +me +, +UINTN + * +fd +) + +274 +tfs_iv_e_t + * +nfs +; + +275 +tfs_fd_t + * +f +; + +276 +EFI_STATUS + +us +; + +277 +CHAR8 + +ascii_me +[ +FILENAME_MAXLEN +]; + +278 +UINTN + +blocksize + = 0, +ev_tbufsize +; + +280 i( +this + = +NULL + || +me + =NULL || +fd + =NULL +EFI_INVALID_PARAMETER +; + +282 +nfs + = + `FS_PRIVATE +( +this +); + +284 i( +nfs +-> +pxe + = +NULL + +EFI_INVALID_PARAMETER +; + +289 i( +nfs +-> +pxe +-> +Mode +-> +Sed + = +FALSE +) { + +290 +us + = + `tfs_t +( +nfs +-> +pxe +); + +291 i( + `EFI_ERROR +( +us +))  status; + +292 + `tfs_exa_ +( +nfs +); + +295 i(( +f += + `tfs_fd_loc +( +nfs +, +me +)= +NULL + +EFI_OUT_OF_RESOURCES +; + +297 i( +f +-> +tbuf_u +) { + +298 +f +-> +tbuf_pos + = 0; + +299 +f +-> +is_vid + = +TRUE +; + +300 * +fd + = + `NETFS_F2FD +( +nfs +, +f +); + +301  +EFI_SUCCESS +; + +303 +f +-> +tbuf_maxsize + = +NETFS_DEFAULT_BUFSIZE +; + +305 i( +f +-> +tbuf + = +NULL + && + `tbuf_loc +(f) == -1) { + +306 + `tfs_fd_ +( +nfs +, +f +); + +307  +EFI_OUT_OF_RESOURCES +; + +312 + `U2ascii +( +me +, +ascii_me +, +FILENAME_MAXLEN +); + +314 + `VERB_PRT +(2, + `Prt +( +L +"dowdg %om %d.%d.%d.%d...", +ascii_me +, + +315 +nfs +-> +v_ +. +v4 +. +Addr +[0], + +316 +nfs +-> +v_ +. +v4 +. +Addr +[1], + +317 +nfs +-> +v_ +. +v4 +. +Addr +[2], + +318 +nfs +-> +v_ +. +v4 +. +Addr +[3])); + +319 +y +: + +320 +f +-> +tbuf_size + = f-> +tbuf_maxsize +; + +322 + `DBG_PRT +(( +L +"\nbefܐtbuf:0x%lxbuf_size=%ld\n", +f +-> +tbuf +, f-> +tbuf_size +)); + +338 +ev_tbufsize + = +f +-> +tbuf_size +; + +340 +us + = +nfs +-> +pxe +-> + `Mtp +fs->pxe, +EFI_PXE_BASE_CODE_TFTP_READ_FILE +, +f +-> +tbuf +, +FALSE +, + +341 &( +f +-> +tbuf_size +), + +342 +blocksize + > 0 ? &blocksiz: +NULL +, + +343 & +nfs +-> +v_ +, + +344 +ascii_me +, + +345 +NULL +, + +346 +FALSE +); + +348 + `DBG_PRT +(( +L +"after Mftp=%retbuf:0x%lxetbuf_size=%ld blocksize=%ld\n", + +349 +us +, + +350 +f +-> +tbuf +, + +351 +f +-> +tbuf_size +, + +352 +blocksize +)); + +354 i( +us + = +EFI_TIMEOUT + && +blocksize + == 0) { + +359 +us + = +EFI_BUFFER_TOO_SMALL +; + +364 i( +us + = +EFI_BUFFER_TOO_SMALL +) { + +365 + `DBG_PRT +(( +L +"buftosml,dbuf_size=%d", +f +-> +tbuf_size +)); + +372 i( +f +-> +tbuf_size + = +ev_tbufsize +) { + +373 +f +-> +tbuf_maxsize + + +NETFS_DEFAULT_BUFSIZE_INC +; + +376 +f +-> +tbuf_maxsize + = f-> +tbuf_size +; + +378 + ` +( +f +-> +tbuf +); + +380 +f +-> +tbuf + = +NULL +; + +382 i( + `tbuf_loc +( +f +=0 +y +; + +387 i( +us + = +EFI_SUCCESS +) { + +389 +f +-> +tbuf_pos + = 0; + +392 + `SCpy +( +f +-> +ϡ_fe +, +me +); + +394 +f +-> +is_vid + = 1; + +396 * +fd + = + `NETFS_F2FD +( +nfs +, +f +); + +397 + `VERB_PRT +(2, + `Prt +( +L +"Done\n")); + +399 + `tfs_fd_ +( +nfs +, +f +); + +400 + `VERB_PRT +(2, + `Prt +( +L +"Faed: %r\n", +us +)); + +402 + `DBG_PRT +(( +L +"F%tbuf_size=%d: %r", +me +, +f +-> +tbuf_size +, +us +)); + +404 + `Prt +( +L +"\n---\n"); + +405 { +INTN + +i +; + +406  +i +=0; i < +tbuf_size +; i++) { + +407 + `Prt +( +L +"%c", ( +CHAR16 +) +tbuf +[ +i +]); + +410 + `Prt +( +L +"\n---\n"); + +412  +us +; + +413 + } +} + +416  +EFI_STATUS + + +417 + $tfs_ad +( +tfs_r_t + * +this +, +UINTN + +fd +, +VOID + * +buf +, UINTN * +size +) + +419 +tfs_iv_e_t + * +nfs +; + +420 +tfs_fd_t + * +f +; + +421 +UINTN + +cou +; + +423 i( +this + = +NULL + || +fd + > +NETFS_FD_MAX + || +buf + =NULL || +size + =NULL +EFI_INVALID_PARAMETER +; + +425 +nfs + = + `FS_PRIVATE +( +this +); + +426 +f + = + `NETFS_FD2F +( +nfs +, +fd +); + +428 i( + `NETFS_F_INVALID +( +f +) +EFI_INVALID_PARAMETER +; + +430 +cou + = + `MIN +(* +size +, +f +-> +tbuf_size + - f-> +tbuf_pos +); + +432 i( +cou + + `Memy +( +buf +, +f +-> +tbuf ++f-> +tbuf_pos +, count); + +434 * +size + = +cou +; + +435 +f +-> +tbuf_pos + + +cou +; + +437  +EFI_SUCCESS +; + +438 + } +} + +440  +EFI_STATUS + + +441 + $tfs_o +( +tfs_r_t + * +this +, +UINTN + +fd +) + +443 +tfs_iv_e_t + * +nfs +; + +444 +tfs_fd_t + * +f +; + +446 i( +this + = +NULL + || +fd + > +NETFS_FD_MAX + +EFI_INVALID_PARAMETER +; + +448 +nfs + = + `FS_PRIVATE +( +this +); + +449 +f + = + `NETFS_FD2F +( +nfs +, +fd +); + +451 i( + `NETFS_F_INVALID +( +f +) +EFI_INVALID_PARAMETER +; + +453 + `tfs_fd_ +( +nfs +, +f +); + +455  +EFI_SUCCESS +; + +456 + } +} + +458  +EFI_STATUS + + +459 + $tfs_ek +( +tfs_r_t + * +this +, +UINTN + +fd +, +UINT64 + +wpos +) + +461 +tfs_iv_e_t + * +nfs +; + +462 +tfs_fd_t + * +f +; + +464 i( +this + = +NULL + || +fd + > +NETFS_FD_MAX + +EFI_INVALID_PARAMETER +; + +466 +nfs + = + `FS_PRIVATE +( +this +); + +467 +f + = + `NETFS_FD2F +( +nfs +, +fd +); + +469 i( + `NETFS_F_INVALID +( +f +) +EFI_INVALID_PARAMETER +; + +471 i( +wpos + > +f +-> +tbuf_size + +EFI_INVALID_PARAMETER +; + +473 +f +-> +tbuf_pos + = +wpos +; + +475  +EFI_SUCCESS +; + +476 + } +} + +478  +EFI_STATUS + + +479 + $tfs_fosize +( +tfs_r_t + * +this +, +UINTN + +fd +, +UINT64 + * +sz +) + +481 +tfs_iv_e_t + * +nfs +; + +482 +tfs_fd_t + * +f +; + +484 i( +this + = +NULL + || +fd + > +NETFS_FD_MAX + || +sz + =NULL +EFI_INVALID_PARAMETER +; + +486 +nfs + = + `FS_PRIVATE +( +this +); + +487 +f + = + `NETFS_FD2F +( +nfs +, +fd +); + +489 i( + `NETFS_F_INVALID +( +f +) +EFI_INVALID_PARAMETER +; + +491 * +sz + = +f +-> +tbuf_size +; + +493  +EFI_SUCCESS +; + +494 + } +} + +496  +INTN + + +497 + $fd_dh_ti +( +EFI_PXE_BASE_CODE_PACKET + * +ck +, +UINT8 + +u_v6 +, UINT8 +ti +, +CHAR8 + * +r +, +INTN + * +n +) + +499 +INTN + +i + = 0; + +500 +UINT8 + +g +, +ngth +; + +501 +UINT8 + * +ts + = +ck +-> +Dhv4 +. +DhOis +; + +503 * +n + = 0; + +506 i( +i + >= 56) { + +507 + `DBG_PRT +(( +L +"reachnd of options (no marker)\n")); + +510 +g + = +ts +[ +i +++]; + +512 i( +g + == 0) ; + +513 i( +g + == 255) ; + +515 +ngth + = +ts +[ +i +++]; + +518 { +UINT8 + +l + = +ngth +, +k + = 0; + +519 + `Prt +( +L +"found oi %d=%d: ", +g +, +ngth +); + +520  +l +--{ + `Prt +( +L +"%c(%d)\n", ( +CHAR16 +) +ts +[ +k +], opts[k]); k++; } + +521 + `Prt +( +L +"\n"); + +524 i( +g + = +ti +) { + +525 * +n + = +ngth +; + +526  +ngth +--{ * +r +++ = +ts +[ +i +++]; } + +529 +i + + +ngth +; + +532 + } +} + +534  +EFI_STATUS + + +535 + $tfs_gfo +( +tfs_r_t + * +this +, +tfs_fo_t + * +fo +) + +537 +tfs_iv_e_t + * +nfs +; + +538 +CHAR8 + +r +[256]; + +539 +INTN + +n +, +r +; + +541 i( +this + = +NULL + || +fo + =NULL +EFI_INVALID_PARAMETER +; + +543 +nfs + = + `FS_PRIVATE +( +this +); + +545 + `Memy +(& +fo +-> +n_addr +, & +nfs +-> +n_ +, ( +EFI_IP_ADDRESS +)); + +546 + `Memy +(& +fo +-> +v_addr +, & +nfs +-> +v_ +, ( +EFI_IP_ADDRESS +)); + +547 + `Memy +(& +fo +-> +tmask +, & +nfs +->tmask, ( +EFI_IP_ADDRESS +)); + +548 + `Memy +(& +fo +-> +gw_addr +, & +nfs +-> +gw_ +, ( +EFI_IP_ADDRESS +)); + +549 + `Memy +(& +fo +-> +hw_addr +, & +nfs +->hw_addr, (info->hw_addr)); + +551 +fo +-> +usg_pxe + = +nfs +->using_pxe; + +552 +fo +-> +d + = +nfs +-> +pxe +-> +Mode +-> +Sed +; + +553 +fo +-> +usg_v6 + = +nfs +-> +pxe +-> +Mode +-> +UsgIpv6 +; + +555 i( +nfs +-> +pxe +-> +Mode +-> +UsgIpv6 + +sk_tis +; + +557 +r + = + `fd_dh_ti +(& +nfs +-> +pxe +-> +Mode +-> +DhAck +,nfs->pxe->Mode-> +UsgIpv6 +, 15, +r +, & +n +); + +558 +r +[ +n +] = '\0'; + +559 + `ascii2U +( +r +, +fo +-> +domaame +, 255); + +561 + `VERB_PRT +(3, + `Prt +( +L +"doma(15): %a\n", +r +)); + +563 +r + = + `fd_dh_ti +(& +nfs +-> +pxe +-> +Mode +-> +DhAck +,nfs->pxe->Mode-> +UsgIpv6 +, 12, +r +, & +n +); + +564 +r +[ +n +] = '\0'; + +565 + `ascii2U +( +r +, +fo +-> +home +, 255); + +567 + `VERB_PRT +(3, + `Prt +( +L +"home(12): %a\n", +r +)); + +572 i( +nfs +-> +usg_pxe + == 0) { + +573 + `ascii2U +( +nfs +-> +pxe +-> +Mode +-> +DhAck +. +Dhv4 +. +BopBoFe +, +fo +-> +bofe +, +NETFS_BOOTFILE_MAXLEN +); + +574 + `VERB_PRT +(3, + `Prt +( +L +"bofe: %s\n", +fo +-> +bofe +)); + +577 +sk_tis +: + +578  +EFI_SUCCESS +; + +579 + } +} + +581  +UINT16 + + +582 + $fd_pxe_rv_ty +( +EFI_PXE_BASE_CODE + * +pxe +) + +584 +INTN + +i + = 0, +max +; + +585 +UINT8 + +g +, +ngth +; + +586 +UINT8 + * +ts + = +pxe +-> +Mode +-> +PxeRly +. +Dhv4 +. +DhOis +; + +587 +UINT16 + +rv_ty +; + +589  +i + < 55) { + +590 +g + = +ts +[ +i +]; + +591 +ngth + = +ts +[ +i ++1]; + +593 + `DBG_PRT +(( +L +"Tag #%d Lgth %d\n", +g +, +ngth +)); + +595 i( +g + =43 +found +; + +597 +i + +2 + +ngth +; + +599  +NETFS_DEFAULT_SERVER_TYPE +; + +600 +found +: + +601 +max + = +i ++2+ +ngth +; + +602 +i + += 2; + +603  +i + < +max +) { + +604 +g + = +ts +[ +i +]; + +605 +ngth + = +ts +[ +i ++1]; + +606 i( +g + == 71) { + +607 +rv_ty + =( +ts +[ +i ++2]<<8) | opts[i+3]; + +608 + `DBG_PRT +(( +L +"SvTy: %d\n", +rv_ty +)); + +609  +rv_ty +; + +611 +i ++2 + +ngth +; + +613  +NETFS_DEFAULT_SERVER_TYPE +; + +614 + } +} + +616  +EFI_STATUS + + +617 + $tfs_quy_y +( +tfs_r_t + * +this +, +UINT16 + +rv_ty +, UINT16 +y +, +UINTN + +maxn +, +CHAR16 + * +r +) + +619 +tfs_iv_e_t + * +nfs +; + +620 +EFI_STATUS + +us +; + +622 i( +this + = +NULL + || +r + =NULL +EFI_INVALID_PARAMETER +; + +624 +nfs + = + `FS_PRIVATE +( +this +); + +626 i( +nfs +-> +usg_pxe + = +FALSE + +EFI_UNSUPPORTED +; + +628 i( +rv_ty + =0rv_ty = + `fd_pxe_rv_ty +( +nfs +-> +pxe +); + +630 +us + = +nfs +-> +pxe +-> + `Discov +fs->pxe, +rv_ty +, & +y +, +FALSE +, 0); + +631 if( +us + = +EFI_SUCCESS +) { + +632 + `ascii2U +( +nfs +-> +pxe +-> +Mode +-> +PxeRly +. +Dhv4 +. +BopBoFe +, +r +, +maxn +); + +634  +us +; + +635 + } +} + +637  +VOID + + +638 + $tfs__e +( +tfs_t + * +tfs +, +EFI_HANDLE + +dev +, +EFI_PXE_BASE_CODE + * +pxe +) + +640 +tfs_iv_e_t + * +nfs + = + `FS_PRIVATE +( +tfs +); + +641 +UINTN + +i +; + +644 + `Memt +( +tfs +, 0, (*netfs)); + +647 +tfs +-> +pub_tf +. +tfs_me + =etfs_name; + +648 +tfs +-> +pub_tf +. +tfs_ݒ + =etfs_open; + +649 +tfs +-> +pub_tf +. +tfs_ad + =etfs_read; + +650 +tfs +-> +pub_tf +. +tfs_o + =etfs_close; + +651 +tfs +-> +pub_tf +. +tfs_fosize + =etfs_infosize; + +652 +tfs +-> +pub_tf +. +tfs_ek + =etfs_seek; + +653 +tfs +-> +pub_tf +. +tfs_quy_y + =etfs_query_layer; + +654 +tfs +-> +pub_tf +. +tfs_gfo + =etfs_getinfo; + +656 +nfs +-> +dev + = dev; + +657 +nfs +-> +pxe + =xe; + +662 i( +pxe +-> +Mode +-> +Sed + = +TRUE + + `tfs_exa_ +( +nfs +); + +664 + `Memt +( +nfs +-> +fd_b +, 0, (nfs->fd_tab)); + +666  +i +=0; i < +NETFS_FD_MAX +-1; i++) { + +667 +nfs +-> +fd_b +[ +i +]. +xt + = &nfs->fd_tab[i+1]; + +671 +nfs +-> +_fd + =fs-> +fd_b +; + +672 +nfs +-> +_fd_cou + = +NETFS_FD_MAX +; + +673 + } +} + +675  +EFI_STATUS + + +676 + $tfs_l_e +( +EFI_HANDLE + +dev +, +VOID + ** +tf +) + +679 +EFI_STATUS + +us +; + +680 +tfs_t + * +tfs +; + +681 +EFI_PXE_BASE_CODE + * +pxe +; + +683 +us + = +BS +-> + `HdProc + ( +dev +, & +NFsProc +, ( +VOID + **)& +tfs +); + +684 i( +us + = +EFI_SUCCESS +) { + +685 + `ERR_PRT +(( +L +"Wng: foundxig %oc odevi", +FS_NAME +)); + +686  +found +; + +689 +us + = +BS +-> + `HdProc + ( +dev +, & +PxeBaCodeProc +, ( +VOID + **)& +pxe +); + +690 i( + `EFI_ERROR +( +us +) +EFI_INVALID_PARAMETER +; + +693 +tfs + = ( +tfs_t + *) + `loc +((*tfs), +EfiLdDa +); + +694 i( +tfs + = +NULL +) { + +695 + `ERR_PRT +(( +L +"edخlo %s", +FS_NAME +)); + +696  +EFI_OUT_OF_RESOURCES +; + +699 + `tfs__e +( +tfs +, +dev +, +pxe +); + +701 +us + = + `LibInlProcIs +(& +dev +, & +NFsProc +, +tfs +, +NULL +); + +702 i( + `EFI_ERROR +( +us +)) { + +703 + `ERR_PRT +(( +L +"Cn in%oc: %r", +FS_NAME +, +us +)); + +704 + ` +( +tfs +); + +705  +us +; + +708 +found +: + +709 i( +tf +*t( +VOID + *) +tfs +; + +711 + `VERB_PRT +(3, + +712 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +713 +dp + = + `DeviPhFromHd +( +dev +); + +714 +r + = + `DeviPhToS +( +dp +); + +715 + `Prt +( +L +"ched %t%s\n", +FS_NAME +, +r +); + +716 + `FePo +( +r +); + +719  +EFI_SUCCESS +; + +720 + } +} + +722 +EFI_STATUS + + +723 + $tfs_l +( +VOID +) + +725 +UINTN + +size + = 0; + +726 +UINTN + +i +; + +727 +EFI_STATUS + +us +; + +728 +VOID + * +tf +; + +730 +BS +-> + `LoHd +( +ByProc +, & +PxeBaCodeProc +, +NULL +, & +size +, NULL); + +731 i( +size + =0 +EFI_UNSUPPORTED +; + +733 + `DBG_PRT +(( +L +"size=%d", +size +)); + +735 +dev_b + = ( +dev_b_t + *) + `loc +( +size +, +EfiLdDa +); + +736 i( +dev_b + = +NULL +) { + +737 + `ERR_PRT +(( +L +"failedollocate handleable")); + +738  +EFI_OUT_OF_RESOURCES +; + +741 +us + = +BS +-> + `LoHd +( +ByProc +, & +PxeBaCodeProc +, +NULL +, & +size +, ( +VOID + **) +dev_b +); + +742 i( +us + ! +EFI_SUCCESS +) { + +743 + `ERR_PRT +(( +L +"edg hds: %r", +us +)); + +744 + ` +( +dev_b +); + +745  +us +; + +747 +ndev + = +size + / ( +EFI_HANDLE +); + +749  +i +=0; i < +ndev +; i++) { + +750 +tf + = +NULL +; + +751 + `tfs_l_e +( +dev_b +[ +i +]. +dev +, & +tf +); + +753 +dev_b +[ +i +]. +tf + = intf; + +756  +EFI_SUCCESS +; + +757 + } +} + +759 +EFI_STATUS + + +760 + $tfs_unl +( +VOID +) + +763 +tfs_iv_e_t + * +nfs +; + +764 +EFI_STATUS + +us +; + +765 +UINTN + +i +; + +767  +i +=0; i < +ndev +; i++) { + +768 i( +dev_b +[ +i +]. +tf + = +NULL +) ; + +769 +nfs + = + `FS_PRIVATE +( +dev_b +[ +i +]. +tf +); + +770 +us + = +BS +-> + `UnlProcI +( +nfs +-> +dev +, & +NFsProc +, +dev_b +[ +i +]. +tf +); + +771 i( + `EFI_ERROR +( +us +)) { + +772 + `ERR_PRT +(( +L +"Un%r: %r", +FS_NAME +, +us +)); + +775 + `VERB_PRT +(3, + +776 { +EFI_DEVICE_PATH + * +dp +; +CHAR16 + * +r +; + +777 +dp + = + `DeviPhFromHd +( +nfs +-> +dev +); + +778 +r + = + `DeviPhToS +( +dp +); + +779 + `Prt +( +L +"und % %s\n", +FS_NAME +, +r +); + +780 + `FePo +( +r +); + +783 i( +nfs +-> +pxe +-> +Mode +-> +Sed + = +TRUE +nfs->pxe-> + `St +(nfs->pxe); + +785 + ` +( +dev_b +[ +i +]. +tf +); + +787 i( +dev_b + + ` +(dev_tab); + +789  +EFI_SUCCESS +; + +790 + } +} + + @fs/netfs.h + +26 #ide +__NETLFS_H__ + + +27  + #__NETLFS_H__ + + + ) + +29  + ~ + +30  + ~ + +32  + #NETFS_BOOTFILE_MAXLEN + 256 + + ) + +35 +EFI_IP_ADDRESS + + mn_addr +; + +36 +EFI_IP_ADDRESS + + mv_addr +; + +37 +EFI_IP_ADDRESS + + mtmask +; + +38 +EFI_IP_ADDRESS + + mgw_addr +; + +39 +UINT8 + + mhw_addr +[16]; + +40 +CHAR16 + + mhome +[255]; + +41 +CHAR16 + + mdomaame +[255]; + +42 +CHAR16 + + mbofe +[ +NETFS_BOOTFILE_MAXLEN +]; + +43 +BOOLEAN + + musg_pxe +; + +44 +BOOLEAN + + md +; + +45 +BOOLEAN + + musg_v6 +; + +46 } + ttfs_fo_t +; + +49 +INTERFACE_DECL +( +_tfs_r_t +); + +51  + s_tfs_r_t + { + +52 +EFI_STATUS + (* +tfs_me +)( +_tfs_r_t + * + mthis +, +CHAR16 + * + mme +, +UINTN + + mmaxn +); + +53 +EFI_STATUS + (* +tfs_ݒ +)( +_tfs_r_t + * + mthis +, +CHAR16 + * + mme +, +UINTN + * + mfd +); + +54 +EFI_STATUS + (* +tfs_ad +)( +_tfs_r_t + * + mthis +, +UINTN + + mfd +, +VOID + * + mbuf +, UINTN * + msize +); + +55 +EFI_STATUS + (* +tfs_o +)( +_tfs_r_t + * + mthis +, +UINTN + + mfd +); + +56 +EFI_STATUS + (* +tfs_fosize +)( +_tfs_r_t + * + mthis +, +UINTN + + mfd +, +UINT64 + * + msize +); + +57 +EFI_STATUS + (* +tfs_ek +)( +_tfs_r_t + * + mthis +, +UINTN + + mfd +, +UINT64 + + mwpos +); + +58 +EFI_STATUS + (* +tfs_quy_y +)( +_tfs_r_t + * + mthis +, +UINT16 + + mrv_ty +, UINT16 + my +, +UINTN + + mmaxn +, +CHAR16 + * + mr +); + +59 +EFI_STATUS + (* +tfs_gfo +)( +_tfs_r_t + * + mthis +, +tfs_fo_t + * + mfo +); + +60 } + ttfs_r_t +; + +62  + #NETFS_PROTOCOL + \ + +63 { 0x6746de4f, 0xcc1e, 0x4c5f, {0xb7, 0xfb, 0x85, 0x6a, 0x5d, 0x69, 0x0f, 0x06} } + + ) + +65 +EFI_STATUS + +tfs_l +( +VOID +); + +66 +EFI_STATUS + +tfs_unl +( +VOID +); + + @getopt.c + +29  + ~ + +30  + ~ + +33  + #DASH + ( +CHAR16 +)'-' + + ) + +34  + #COLON + ( +CHAR16 +)':' + + ) + +35  + #EOS + ( +CHAR16 +)'\0' + + ) + +36  + #BADCH + ( +INTN +)'?' + + ) + +37  + #BADARG + ( +INTN +)':' + + ) + +39 +CHAR16 + * +SChr +( +IN + cڡ CHAR16 * +s +, +INT16 + +c +); + +41 +CHAR16 + * + gOg +; + +42 +INTN + + gOd + = 1; + +43 +INTN + + gOt +; + +54 +INTN + + +55 + $Gt +( +INTN + +gc +, +CHAR16 + *cڡ +gv +[], cڡ CHAR16 * +trg +) + +57  +CHAR16 + * +cur_chr + = +NULL +; + +58 +CHAR16 + * +t +; + +60 i( +Od + > +gc +) { + +61 +cur_chr + = +NULL +; + +64 i( +cur_chr + = +NULL + || *cur_ch= +EOS +) { + +65 +cur_chr + = +gv +[ +Od +]; + +66 i(* +cur_chr +++ ! +DASH +) { + +67 +cur_chr + = +NULL +; + +70 i(* +cur_chr + = +DASH +) { + +71 +cur_chr + = +NULL +; + +72 +Od +++; + +76 +Ot + = * +cur_chr +++; + +77 +t + = + `SChr +( +trg +, +Ot +); + +78 i(! +t +) { + +79 + `Prt +( +L +"%s: ieg oi -- %c\n", +gv +[0], +Ot +); + +80 i(* +cur_chr + = +EOS + +Od +++; + +81  +BADCH +; + +83 i(*( +t ++1! +COLON +) { + +84 +Og + = +NULL +; + +85 i(* +cur_chr + = +EOS + +Od +++; + +87 i(* +cur_chr +) { + +88 +Og + = +cur_chr +; + +89 } i++ +Od + > +gc + ) { + +90 + `Prt +( +L +"%s: oi `%s'equergumt\n", +gv +[0],rgv[ +Od +-1]), + +91 +cur_chr + = +NULL +; + +92  +BADARG +; + +94 +Og + = +gv +[ +Od +]; + +96 +Od +++; + +98  +Ot +; + +99 + } +} + + @getopt.h + +25 #ide +__EFI_GETOPT_H__ + + +26  + #__EFI_GETOPT_H__ + + + ) + +28 +CHAR16 + * +Og +; + +29 +INTN + +Od +, +Ot +; + +31 +INTN + +Gt +(INTN +gc +, +CHAR16 + *cڡ +gv +[], cڡ CHAR16 * +trg +); + + @glue_ext2fs.c + +25  + ~ + +26  + ~ + +28  + ~"glue_ext2fs.h +" + +29  + ~"fs/ext2fs.h +" + +30  + ~"rs.h +" + +33  +INTN + +glue +( +fes_t + * +this +, +VOID + * +tf +); + +37 +fes_fs_t + + gext2fs_glue + = { +EXT2FS_PROTOCOL + , +glue +, +ext2fs_l +, +ext2fs_unl +}; + +39  +EFI_STATUS + + +40 + $ext2fs_fosize +( +ext2fs_r_t + * +this +, +fs_fd_t + +fd +, +UINT64 + * +sz +) + +42 +ext2fs__t + + +; + +43 +EFI_STATUS + +us +; + +45 i( +this + = +NULL + || +sz + =NULL +EFI_INVALID_PARAMETER +; + +47 +us + = +this +-> + `ext2fs_f +his, +fd +, & + +); + +48 i( +us + ! +EFI_SUCCESS +)  status; + +50 * +sz + = ( +UINT64 +) + +. +_size +; + +52  +EFI_SUCCESS +; + +53 + } +} + +55  +INTN + + +56 + $glue +( +fes_t + * + +, +VOID + * +tf +) + +58 +ext2fs_r_t + * +ext2fs + = (ext2fs_r_*) +tf +; + +61 + +-> +tf + = intf; + +63 + +-> +ݒ + = ( +fs_ݒ_t +) +ext2fs +-> +ext2fs_ݒ +; + +64 + +-> +ad + = ( +fs_ad_t +) +ext2fs +-> +ext2fs_ad +; + +65 + +-> +o + = ( +fs_o_t +) +ext2fs +-> +ext2fs_o +; + +66 + +-> +fosize + = ( +fs_fosize_t +) +ext2fs_fosize +; + +67 + +-> +ek + = ( +fs_ek_t +) +ext2fs +-> +ext2fs_ek +; + +70 +ext2fs +-> + `ext2fs_me +xt2fs, + +-> +me +, +FILEOPS_NAME_MAXLEN +); + +73 + } +} + + @glue_ext2fs.h + +26 #ide +__GLUE_EXT2FS_H__ + + +27  + #__GLUE_EXT2FS_H__ + + + ) + +29  + ~"fes.h +" + +31 +fes_fs_t + +ext2fs_glue +; + + @glue_localfs.c + +25  + ~ + +26  + ~ + +28  + ~"fs/lolfs.h +" + +29  + ~"glue_lolfs.h +" + +30  + ~"rs.h +" + +31  + ~"o.h +" + +33  +INTN + +glue +( +fes_t + * +this +, +VOID + * +tf +); + +37 +fes_fs_t + + glolfs_glue + = { +LOCALFS_PROTOCOL +, +glue +, +lolfs_l +, +lolfs_unl +}; + +40  +CHAR16 + + glolfs_deu_th +[ +FILENAME_MAXLEN +]; + +58  +VOID + + +59 + $t_deu_th +( +CHAR16 + * + +) + +61  + #is_p +( +h +(h = +CHAR_SLASH + || h = +CHAR_BACKSLASH +) + + ) + +62 +CHAR16 + * +dr +, * +ϡ_p + = +NULL +; + +63 +UINTN + +n + = +FILENAME_MAXLEN + - 1; + +64 +UINTN + +ϡ_was_p + = 0; + +65 +CHAR16 + +c +; + +67 +dr + = +lolfs_deu_th +; + +69  +n +-- && * + +) { + +70 +c + = + +[0]; + +72 i( + `is_p +( +c +)) { + +73 i( +ϡ_was_p +) { + +74 + +++; + +77 +c + = +CHAR_BACKSLASH +; + +78 +ϡ_was_p + = 1; + +79 +ϡ_p + = +dr +; + +81 +ϡ_was_p + = 0; + +83 * +dr +++ = +c +; + +84 + +++; + +86 i( +ϡ_p +) + +87 *++ +ϡ_p + = +CHAR_NULL +; + +89 * +dr + = +CHAR_NULL +; + +91 + `DBG_PRT +(( +L +"lolfs_deu_th=%s\n", +lolfs_deu_th +)); + +92 + } +} + +99  + #LOCALFS_DEFAULT_KERNEL + +L +"vmlux" + + ) + +100  + #LOCALFS_DEFAULT_CONFIG + +L +"o.cf" + + ) + +101  +EFI_STATUS + + +102 + $lolfs_tdeus +( +VOID + * +this +, +cfig_fe_t + * +cfig +, +CHAR16 + * +kme +, +UINTN + +maxn +, CHAR16 * +devth +) + +104 + `SnCpy +( +kme +, +LOCALFS_DEFAULT_KERNEL +, +maxn +-1); + +105 +kme +[ +maxn +-1] = +CHAR_NULL +; + +107 + `SnCpy +( +cfig +[0]. +ame +, +LOCALFS_DEFAULT_CONFIG +, +maxn +-1); + +108 +cfig +[0]. +ame +[ +maxn +-1] = +CHAR_NULL +; + +110 + `t_deu_th +( +devth +); + +112  +EFI_SUCCESS +; + +113 + } +} + +115  +EFI_STATUS + + +116 + $lolfs_gdeu_th +( +CHAR16 + * +th +, +UINTN + +maxn +) + +118 i( +maxn + < + `SL +( +lolfs_deu_th +) +EFI_BUFFER_TOO_SMALL +; + +120 + `SCpy +( +th +, +lolfs_deu_th +); + +121  +EFI_SUCCESS +; + +122 + } +} + +131  +EFI_STATUS + + +132 + $glue_ݒ +( +VOID + * +tf +, +CHAR16 + * +me +, +fs_fd_t + * +fd +) + +134 +CHAR16 + * +p +; + +135 +lolfs_r_t + * +lolfs + = (lolfs_r_*) +tf +; + +136 +CHAR16 + +fume +[ +FILENAME_MAXLEN +]; + +141  +p + +me +; *! +CHAR_NULL +;++) { + +142 i(* +p + = +CHAR_SLASH +* +CHAR_BACKSLASH +; + +144 i( +me +[0] ! +CHAR_BACKSLASH + && +lolfs_deu_th +[0] ! +CHAR_NULL +) { + +145 i( + `SL +( +lolfs_deu_th ++ SL( +me ++ 1 > +FILENAME_MAXLEN +) + +146  +EFI_INVALID_PARAMETER +; + +148 + `SCpy +( +fume +, +lolfs_deu_th +); + +149 + `SC +( +fume +, +me +); + +150 +me + = +fume +; + +152  +lolfs +-> + `lolfs_ݒ +( +tf +, +me +, +fd +); + +153 + } +} + +155  +INTN + + +156 + $glue +( +fes_t + * + +, +VOID + * +tf +) + +158 +lolfs_r_t + * +lolfs + = (lolfs_r_*) +tf +; + +160 + +-> +ݒ + = +glue_ݒ +; + +161 + +-> +ad + = ( +fs_ad_t +) +lolfs +-> +lolfs_ad +; + +162 + +-> +o + = ( +fs_o_t +) +lolfs +-> +lolfs_o +; + +163 + +-> +fosize + = ( +fs_fosize_t +) +lolfs +-> +lolfs_fosize +; + +164 + +-> +ek + = ( +fs_ek_t +) +lolfs +-> +lolfs_ek +; + +165 + +-> +tdeus + = ( +fs_tdeus_t +) +lolfs_tdeus +; + +166 + +-> +gdeu_th + = ( +fs_gdeu_th_t +) +lolfs_gdeu_th +; + +167 + +-> +tf + = intf; + +170 +lolfs +-> + `lolfs_me +olfs, + +-> +me +, +FILEOPS_NAME_MAXLEN +); + +173 + } +} + + @glue_localfs.h + +26 #ide +__GLUE_LOCALFS_H__ + + +27  + #__GLUE_LOCALFS_H__ + + + ) + +29  + ~"fes.h +" + +31 +fes_fs_t + +lolfs_glue +; + + @glue_netfs.c + +25  + ~ + +26  + ~ + +28  + ~"glue_tfs.h +" + +29  + ~"fs/tfs.h +" + +30  + ~"rs.h +" + +32  + ~"o.h +" + +33  + ~"vs.h +" + +40  +INTN + +glue +( +fes_t + * +this +, +VOID + * +tf +); + +43 +fes_fs_t + + gtfs_glue + = { +NETFS_PROTOCOL + , +glue +, +tfs_l +, +tfs_unl +}; + +46  + #NETFS_DEFAULT_KERNEL + +L +"vmlux" + + ) + +47  + #NETFS_DEFAULT_CONFIG + +L +"o.cf" + + ) + +48  + #NETFS_DEFAULT_SERVER_TYPE + +EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_BOOT + + + ) + +51  +CHAR16 + + gtfs_deu_th +[ +FILENAME_MAXLEN +]; + +58  + #NETFS_CONFIG_LAYER + 1 + + ) + +59  + #NETFS_KERNEL_LAYER + 2 + + ) + +61  +CHAR16 + * + ghexa += +L +"0123456789ABCDEF"; + +63  +VOID + + +64 + $cvt_2hex +( +UINT8 + * + +, +INTN + +l +, +CHAR16 + * +r +) + +66 +UINTN + +i +; + +68  +i +=0; i < +l +; i++) { + +69 +r +[2* +i +] = +hexa +[( + +[i] & 0xf0)>>4]; + +70 +r +[2* +i ++1] = +hexa +[ + +[i] & 0x0f]; + +72 + } +} + +74  +VOID + + +75 + $cvt_2decr +( +UINT8 + * + +, +INTN + +l +, +CHAR16 + * +r +) + +77 +UINTN + +i +, +j +; + +78 +UINTN + +v +, +v +; + +80  +i +=0, +j +=0; i < +l +; i++) { + +81 +v + = + +[ +i +]; + +82 +v + = +v + / 100; + +83 i( +v +) { + +84 +r +[ +j +++] = +L +'0'+ +v +; + +86 +v + = val % 100; + +87 +v + = +v + / 10; + +88 i( +v + || + +[ +i +] >= 100) { + +89 +r +[ +j +++] = +L +'0'+ +v +; + +92 +v + = +v + % 10; + +93 +r +[ +j +++] = +L +'0'+ +v +; + +94 i( +i + < +l +-1 +r +[ +j +++] = +L +'.'; + +96 +r +[ +j +] = +CHAR_NULL +; + +97 + } +} + +100 + $tfs_t_deu_th +( +tfs_r_t + * +tfs +, +tfs_fo_t + * +fo +) + +102 +INTN + +n +; + +104 + `SnCpy +( +tfs_deu_th +, +fo +-> +bofe +, +FILENAME_MAXLEN +); + +106 +n + = + `SL +( +tfs_deu_th +) - 1; + +108  +n + >= 0) { + +109 i( +tfs_deu_th +[ +n +] = +CHAR_SLASH + ||fs_deu_th[n] = +CHAR_BACKSLASH +) ; + +110 +n +--; + +112 +tfs_deu_th +[ +n ++1] = +CHAR_NULL +; + +114 + `DBG_PRT +(( +L +"tfs_deu_th=%s\n", +tfs_deu_th +)); + +116  +EFI_SUCCESS +; + +117 + } +} + +119  +EFI_STATUS + + +120 + $tfs_tdeus +( +VOID + * +tf +, +cfig_fe_t + * +cfig +, +CHAR16 + * +kme +, +UINTN + +maxn +, CHAR16 * +devth +) + +122 +tfs_r_t + * +tfs + = (tfs_r_*) +tf +; + +123 +tfs_fo_t + +fo +; + +124 +EFI_STATUS + +us +; + +125 +UINT8 + * +addr +; + +126 +UINTN + +m +; + +127 +CHAR16 + +_v +[64], +r +[64]; + +128 +UINT8 + * + +; + +130 i( +cfig + = +NULL + || +kme + =NULL || +maxn + < 1 +EFI_INVALID_PARAMETER +; + +132 +tfs +-> + `tfs_gfo +ґfs, & +fo +); + +134 +m + = +fo +. +usg_v6 + ? 16 : 4; + +135 +addr + = +fo +. +usg_v6 + ? info. +n_addr +. +v6 +. +Addr +: info.n_addr. +v4 +.Addr; + +137 + `cvt_2decr +( +addr +, +m +, +_v +); + +138 + `t_v +( +VAR_NETFS_IPADDR +, +_v +); + +140 + + = +fo +. +usg_v6 + ? info. +tmask +. +v6 +. +Addr +: info.tmask. +v4 +.Addr; + +141 + `cvt_2decr +( + +, +m +, +r +); + +142 + `t_v +( +VAR_NETFS_NETMASK +, +r +); + +144 + + = +fo +. +usg_v6 + ? info. +gw_addr +. +v6 +. +Addr +: info.gw_addr. +v4 +.Addr; + +145 + `cvt_2decr +( + +, +m +, +r +); + +146 + `t_v +( +VAR_NETFS_GATEWAY +, +r +); + +148 + `t_v +( +VAR_NETFS_HOSTNAME +, +fo +. +home +); + +149 + `t_v +( +VAR_NETFS_DOMAINAME +, +fo +. +domaame +); + +151 i( +fo +. +usg_pxe +) { + +152 +us + = +tfs +-> + `tfs_quy_y +ґfs, 0, +NETFS_CONFIG_LAYER +, +maxn +, +cfig +[0]. +ame +); + +153 i( + `EFI_ERROR +( +us +)) { + +154 + `SnCpy +( +cfig +[0]. +ame +, +NETFS_DEFAULT_CONFIG +, +maxn +-1); + +155 +cfig +[0]. +ame +[ +maxn +-1] = +CHAR_NULL +; + +158 +us + = +tfs +-> + `tfs_quy_y +ґfs, 0, +NETFS_KERNEL_LAYER +, +maxn +, +kme +); + +159 i( + `EFI_ERROR +( +us +)) { + +160 + `SnCpy +( +kme +, +NETFS_DEFAULT_KERNEL +, +maxn +-1); + +161 +kme +[ +maxn +-1] = +CHAR_NULL +; + +164 #ifde +ENABLE_MACHINE_SPECIFIC_NETCONFIG + + +166 #i + `defed +( +CONFIG_64 +) + +167  + #CONFIG_ARCH_EXTENSION + +L +"-64.cf\0" + + ) + +168 #i + `defed + ( +CONFIG_32 +) + +169  + #CONFIG_ARCH_EXTENSION + +L +"-64.cf\0" + + ) + +174  + #CONFIG_EXTENSION + +L +".cf\0" + + ) + +179 + `cvt_2hex +( +addr +, +m +, +r +); + +180 + `SnCpy +( +cfig +[0]. +ame +, +r +, +maxn +-1); + +181 + `SnCpy +( +cfig +[0]. +ame ++8, +CONFIG_EXTENSION +, 6); + +183 + `SnCpy +( +cfig +[1]. +ame +, +r +, +maxn +-1); + +184 + `SnCpy +( +cfig +[1]. +ame ++6, +CONFIG_ARCH_EXTENSION +, 11); + +186 + `SnCpy +( +cfig +[2]. +ame +, +r +, +maxn +-1); + +187 + `SnCpy +( +cfig +[2]. +ame ++6, +CONFIG_EXTENSION +, 6); + +189 + `SnCpy +( +cfig +[3]. +ame +, +r +, +maxn +-1); + +190 + `SnCpy +( +cfig +[3]. +ame ++4, +CONFIG_ARCH_EXTENSION +, 11); + +192 + `SnCpy +( +cfig +[4]. +ame +, +r +, +maxn +-1); + +193 + `SnCpy +( +cfig +[4]. +ame ++4, +CONFIG_EXTENSION +, 6); + +195 + `SnCpy +( +cfig +[5]. +ame +, +r +, +maxn +-1); + +196 + `SnCpy +( +cfig +[5]. +ame ++2, +CONFIG_ARCH_EXTENSION +, 11); + +198 + `SnCpy +( +cfig +[6]. +ame +, +r +, +maxn +-1); + +199 + `SnCpy +( +cfig +[6]. +ame ++2, +CONFIG_EXTENSION +, 6); + +201 + `SnCpy +( +cfig +[0]. +ame +, +NETFS_DEFAULT_CONFIG +, +maxn +-1); + +202 +cfig +[0]. +ame +[ +maxn +-1] = +CHAR_NULL +; + +204 + `SnCpy +( +kme +, +NETFS_DEFAULT_KERNEL +, +maxn +-1); + +205 +kme +[ +maxn +-1] = +CHAR_NULL +; + +212 + `tfs_t_deu_th +( +tfs +, & +fo +); + +214  +EFI_SUCCESS +; + +215 + } +} + +217  +EFI_STATUS + + +218 + $tfs_gdeu_th +( +CHAR16 + * +th +, +UINTN + +maxn +) + +220 i( +maxn + < + `SL +( +tfs_deu_th +) +EFI_BUFFER_TOO_SMALL +; + +222 + `SCpy +( +th +, +tfs_deu_th +); + +223  +EFI_SUCCESS +; + +224 + } +} + +227  +EFI_STATUS + + +228 + $glue_ݒ +( +VOID + * +tf +, +CHAR16 + * +me +, +fs_fd_t + * +fd +) + +230 +tfs_r_t + * +tfs + = (tfs_r_*) +tf +; + +231 +CHAR16 + +fume +[ +FILENAME_MAXLEN +]; + +233 i( +me +[0] ! +CHAR_SLASH + &&ame[0] ! +CHAR_BACKSLASH + && +tfs_deu_th +[0] ! +CHAR_NULL +) { + +234 i( + `SL +( +tfs_deu_th ++ SL( +me ++ 1 > +FILENAME_MAXLEN +) + +235  +EFI_INVALID_PARAMETER +; + +237 + `SCpy +( +fume +, +tfs_deu_th +); + +238 + `SC +( +fume +, +me +); + +239 +me + = +fume +; + +241  +tfs +-> + `tfs_ݒ +( +tf +, +me +, +fd +); + +242 + } +} + +244  +INTN + + +245 + $glue +( +fes_t + * + +, +VOID + * +tf +) + +247 +tfs_r_t + * +tfs + = (tfs_r_*) +tf +; + +250 + +-> +tf + = intf; + +252 + +-> +ݒ + = +glue_ݒ +; + +253 + +-> +ad + = ( +fs_ad_t +) +tfs +-> +tfs_ad +; + +254 + +-> +o + = ( +fs_o_t +) +tfs +-> +tfs_o +; + +255 + +-> +fosize + = ( +fs_fosize_t +) +tfs +-> +tfs_fosize +; + +256 + +-> +ek + = ( +fs_ek_t +) +tfs +-> +tfs_ek +; + +257 + +-> +tdeus + = ( +fs_tdeus_t +) +tfs_tdeus +; + +258 + +-> +gdeu_th + = ( +fs_gdeu_th_t +) +tfs_gdeu_th +; + +259 + +-> +tf + = intf; + +262 +tfs +-> + `tfs_me +ґfs, + +-> +me +, +FILEOPS_NAME_MAXLEN +); + +265 + } +} + + @glue_netfs.h + +26 #ide +__GLUE_NETFS_H__ + + +27  + #__GLUE_NETFS_H__ + + + ) + +29  + ~"fes.h +" + +31 +fes_fs_t + +tfs_glue +; + + @gunzip.c + +32  + ~ + +33  + ~ + +35  + ~"o.h +" + +37  + ~"gz.h +" + +39  + #LD_NAME + +L +"gunz" + + ) + +41  + #memzo +( +s +, +n + + `Memt +(( +VOID + *)(s), 0, (n)) + + ) + +42  + #memy +( +a +, +b +, +n + + `Memy +(( +VOID + *)),(b),)) + + ) + +45  + #WSIZE + 0x8000 + + ) + +50  + #OF +( +gs + + ) +args + +51  + #FUNC_STATIC +  + + ) + +53  + tuch +; + +54  + tush +; + +55  + tulg +; + +62  +uch + * + gbuf +; + +63  +uch + * + gwdow +; + +65  +VOID + * + goutbuf +; + +66 * + gou +; + +67  + goutsize +; + +69  + gr + = 0; + +70  + goutt + = 0; + +72  + #g_by +( +buf +[ +r +++] + + ) + +75 #ifde +INFLATE_DEBUG + + +76  + #As +( +cd +, +msg +{if(!(cd) + `r +(msg);} + + ) + +77  + gdr +; + +78  + #T +( +x + + `Prt +( +L +"l%d:\n", +__LINE__ +); + + ) + +79  + #Tv +( +x +{i( +vbo + + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +80  + #Tvv +( +x +{i( +vbo +>1 + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +81  + #Tc +( +c +, +x +{i( +vbo + && (c) + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +82  + #Tcv +( +c +, +x +{i( +vbo +>1 && (c) + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +84  + #As +( +cd +, +msg +) + + ) + +85  + #T +( +x +) + + ) + +86  + #Tv +( +x +) + + ) + +87  + #Tvv +( +x +) + + ) + +88  + #Tc +( +c +, +x +) + + ) + +89  + #Tcv +( +c +, +x +) + + ) + +92  +ush_wdow +(); + +93  +r +(* +m +); + +94  + gbys_out +; + +96  +r +(* +m +); + +98  + #gz_mloc +( +size +(*) + `loc +(size, 0) + + ) + +99  + #gz_ +( +whe + + ` +(whe) + + ) + +101  + ~"e.c +" + +113 + $updc +(* +s +,  +n +) + +115  +c +; + +118 +c + = +c +; + +119  +n +--) { + +120 +c + = +c_32_b +[(()^ (* +s +++)) & 0xff] ^ (c >> 8); + +122 +c + = +c +; + +124 + } +} + +130 + $r_bufs +() + +132 +outt + = 0; + +133 +r + = 0; + +134 + } +} + +141 + $ush_wdow +() + +147 i(! +outt + || +bys_out + + out> +outsize +) + +150 + `updc +( +wdow +, +outt +); + +152 + `Memy +( +ou +, +wdow +, +outt +); + +153 +ou + + +outt +; + +154 +bys_out + + +outt +; + +156 +outt + = 0; + +157 + } +} + +160 + $r +(* +x +) + +162 + `ERR_PRT +(( +L +"%: %a", +LD_NAME +, +x +)); + +164 + } +} + +166  +INT32 + + +167 + $decomess +( +VOID +) + +169 +INT32 + +t +; + +171 + `r_bufs +(); + +172 + `makec +(); + +173 + `Prt +( +L +"Uncompressing... "); + +174 +t + = + `gunz +(); + +175 i( +t + =0 + `Prt +( +L +"done\n"); + +176  +t + == 0 ? 0 : -1; + +177 + } +} + +180 + $gunz_image +( +memdesc_t + * +image +) + +182 +UINTN + +pgt +; + +184 +buf + = +image +-> +t_addr +; + +189 +outsize + = +buf +[ +image +-> +size + - 1] << 24 | inbuf[image->size - 2] << 16 | + +190 +buf +[ +image +-> +size + - 3] << 8 | inbuf[image->size - 4]; + +192 +pgt + = + `EFI_SIZE_TO_PAGES +( +outsize +); + +194 +outbuf + = + `loc_ges +( +pgt +, +EfiLdDa +, +AoAnyPages +, 0); + +195 i( +outbuf + = +NULL +) { + +196 + `ERR_PRT +(( +L +"%:o ouubufed\n", +LD_NAME +)); + +199 +ou + = +outbuf +; + +201 +wdow + = (*) + `loc +( +WSIZE +, 0); + +202 i( +wdow + = +NULL +) { + +203 + `ERR_PRT +(( +L +"%:o ouuwdow faed\n", +LD_NAME +)); + +204 + ` +( +outbuf +); + +208 +bys_out + = 0; + +210 i( + `decomess +() != 0) { + +211 + ` +( +wdow +); + +212 + ` +( +outbuf +); + +213  +ELILO_LOAD_ERROR +; + +216 + ` +( +wdow +); + +217 + ` +( +image +-> +t_addr +); + +219 +image +-> +t_addr + = +outbuf +; + +220 +image +-> +size + = +outsize +; + +221 +image +-> +pgt + =gcnt; + +223  +ELILO_LOAD_SUCCESS +; + +224 + } +} + + @gzip.h + +26 #ide +__GZIP_H__ + + +27  + #__GZIP_H__ + + + ) + +29  +gunz_image +( +memdesc_t + *); + +30  +gunz_kl +( +fs_fd_t +, +kdesc_t + *); + +33  + #ASCII_FLAG + 0x01 + + ) + +34  + #CONTINUATION + 0x02 + + ) + +35  + #EXTRA_FIELD + 0x04 + + ) + +36  + #ORIG_NAME + 0x08 + + ) + +37  + #COMMENT + 0x10 + + ) + +38  + #ENCRYPTED + 0x20 + + ) + +39  + #RESERVED + 0xC0 + + ) + +47  +le +  + +48 + $gz_obe +(* +buf +,  +size +) + +50 i( +size + < 4)  -1; + +52 i( +buf +[0] != 037 || + +53 (( +buf +[1] != 0213) && (buf[1] != 0236)))  -1; + +56 i( +buf +[2] != 8)  -1; + +58 i(( +buf +[3] & +ENCRYPTED +) != 0)  -1; + +60 i(( +buf +[3] & +CONTINUATION +) != 0)  -1; + +62 i(( +buf +[3] & +RESERVED +) != 0)  -1; + +65 + } +} + + @ia32/bin_to_h.c + +1  + ~ + +2  + ~ + +5 + $ma +() + +7  +n + = 0; + +8  +c +; + +10 + `tf +("UINT8mswitch_image[] = {\n"); + +12 ( +c + = + `gch +()! +EOF +) { + +13 + `tf +("0x%02x,%s", + +14 +c + & 0xFF, + +15 (++ +n + & 0x07) ? " " : "\n"); + +18 i( +n + & 0x07) { + +19 + `tf +("\n"); + +22 + `tf +( + +27 + } +} + + @ia32/bzimage.c + +28  + ~ + +29  + ~ + +31  + ~"o.h +" + +32  + ~"ld.h +" + +34 +bo_ms_t + * + gm_t + = +NULL +; + +35 +UINTN + + gm_size + = 0; + +37 +UINTN + + gkl_size + = 0x200000; + +39  +INTN + + +40 + $bzImage_obe +( +CHAR16 + * +kme +) + +42 +EFI_STATUS + +efi_us +; + +43 +UINTN + +size +; + +44 +fs_fd_t + +fd +; + +45 +UINT8 + +bo٣ +[512]; + +47 + `DBG_PRT +(( +L +"probe_bzImage_boot()\n")); + +49 i(! +kme +) { + +50 + `ERR_PRT +(( +L +"km=%xh", +kme +)); + +51 + `_kmem +(); + +58 + `DBG_PRT +(( +L +"ݒg %s...\n", +kme +)); + +60 +efi_us + = + `fs_ݒ +( +kme +, & +fd +); + +61 i( + `EFI_ERROR +( +efi_us +)) { + +62 + `ERR_PRT +(( +L +"Could o%s.", +kme +)); + +63 + `_kmem +(); + +70 + `DBG_PRT +(( +L +"\nreading boot sector...\n")); + +72 +size + =  +bo٣ +; + +73 +efi_us + = + `fs_ad +( +fd +, +bo٣ +, & +size +); + +74 i( + `EFI_ERROR +( +efi_us +|| +size + ! +bo٣ +) { + +75 + `ERR_PRT +(( +L +"Couldلd bo se from %s.", +kme +)); + +76 + `fs_o +( +fd +); + +77 + `_kmem +(); + +84 i( +bo٣ +[0x1FE] != 0x55 || bootsect[0x1FF] != 0xAA) { + +85 + `ERR_PRT +(( +L +"%inه bzImagkimage.\n", +kme +)); + +86 + `fs_o +( +fd +); + +87 + `_kmem +(); + +95 + `DBG_PRT +(( +L +"bo٣[1F1h] =%d sus\n", +bo٣ +[0x1F1])); + +97 i( +bo٣ +[0x1F1] < 1 || bootsect[0x1F1] > 64) { + +98 + `ERR_PRT +(( +L +"%s isot valid bzImage kernel image.", + +99 +kme +)); + +100 + `fs_o +( +fd +); + +101 + `_kmem +(); + +108 + `DBG_PRT +(( +L +"reading setup data...\n")); + +110 +m_size + = ( +bo٣ +[0x1F1] + 1) * 512; + +111 +m_t + = + `loc +( +m_size +, +EfiLdDa +); + +113 + `DBG_PRT +(( +L +"m_size=%dam_t=%x", +m_size +, +m_t +)); + +115 i(! +m_t +) { + +116 + `ERR_PRT +(( +L +"Couldotllocate %d bytes of setup data.", + +117 +m_size +)); + +118 + `fs_o +( +fd +); + +119 + `_kmem +(); + +123 + `CyMem +( +m_t +, +bo٣ +,  bootsect); + +125 +size + = +m_size + - 512; + +126 +efi_us + = + `fs_ad +( +fd +, (( +UINT8 + *) +m_t ++ 512, & +size +); + +128 i( + `EFI_ERROR +( +efi_us +|| +size + ! +m_size + - 512) { + +129 + `ERR_PRT +(( +L +"Couldotead %d bytes of setup data.", + +130 +m_size + - 512)); + +131 + ` +( +m_t +); + +132 +m_t + = +NULL +; + +133 +m_size + = 0; + +134 + `fs_o +( +fd +); + +135 + `_kmem +(); + +143 +UINT8 + * +c + = ((UINT8 *) +m_t +)+514; + +144 + `DBG_PRT +(( +L +"param_start(c=%x): %c-%c-%c-%c", + +145 +c +, ( +CHAR16 +)c[0],(CHAR16) c[1], (CHAR16)c[2], (CHAR16)c[3])); + +147 i( + `ComMem +((( +UINT8 + *) +m_t +) + 514, "HdrS", 4)) { + +148 + `ERR_PRT +(( +L +"%s doesot have setup signature.", + +149 +kme +)); + +150 + ` +( +m_t +); + +151 +m_t + = +NULL +; + +152 +m_size + = 0; + +153 + `fs_o +( +fd +); + +154 + `_kmem +(); + +161 i( + `loc_kmem +( +kl_t +, + `EFI_SIZE_TO_PAGES +( +kl_size +))) { + +162 + `ERR_PRT +(( +L +"Couldotllocate kernel memory.")); + +165 + `VERB_PRT +(3, + `Prt +( +L +"kernel_start: 0x%x kernel_size: %d\n", + +166 +kl_t +, +kl_size +)); + +172 + `DBG_PRT +(( +L +"reading kernel image...\n")); + +174 +size + = +kl_size +; + +175 +efi_us + = + `fs_ad +( +fd +, +kl_t +, & +size +); + +176 i( + `EFI_ERROR +( +efi_us +|| +size + < 0x10000) { + +177 + `ERR_PRT +(( +L +"E܄dg kimag%s.", +kme +)); + +178 + ` +( +m_t +); + +179 +m_t + = +NULL +; + +180 +m_size + = 0; + +181 + `fs_o +( +fd +); + +182 + `_kmem +(); + +186 + `DBG_PRT +(( +L +"kimagad: %d bys, %d Kbys\n", +size +, size / 1024)); + +192 + `fs_o +( +fd +); + +194 + } +} + +197  +INTN + + +198 + $bzImage_ld +( +CHAR16 + * +kme +, +kdesc_t + * +kd +) + +200 + `DBG_PRT +(( +L +"load_bzImage_boot()\n")); + +202 i(! +kme + || ! +kd +) { + +203 + `ERR_PRT +(( +L +"kme=0x%x kd=0x%x", +kme +, +kd +)); + +204 + ` +( +m_t +); + +205 +m_t + = +NULL +; + +206 +m_size + = 0; + +207 + `_kmem +(); + +210 +kd +-> +kt + = kd-> +ky + = +kl_t +; + +211 +kd +-> +kd + = (( +UINT8 + *)kd-> +kt ++ +kl_size +; + +213 + `DBG_PRT +(( +L +"kt=0x%x ky=0x%x kd=0x%x\n", +kd +-> +kt +, kd-> +ky +, kd-> +kd +)); + +216 + } +} + +219 +ld_s_t + + gbzimage_ld + = { + +220 +NULL +, + +221 +L +"bzImage_loader", + +222 & +bzImage_obe +, + +223 & +bzImage_ld + + + @ia32/config.c + +27  + ~ + +28  + ~ + +30  + ~"o.h +" + +31  + ~"cfig.h +" + +32  + ~"ive.h +" + +35 +UINTN + + mgacy__bo +; + +36 } + t32_glob_cfig_t +; + +39  +32_glob_cfig_t + + g32_gcf +; + +41  +cfig_ti_t + + gsysds_glob_tis +[]={ + +42 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"gacy-", +NULL +, NULL, & +32_gcf +. +gacy__bo +} + +53 +INTN + + +54 + $sysds_o_ais +( +EFI_HANDLE + +dev +, +CHAR16 + ** +gv +, +INTN + +gc +, INTN +dex +, EFI_HANDLE +image +) + +57 + } +} + +59  + #IA32_CMDLINE_OPTIONS + +L +"" + + ) + +61 +CHAR16 + * + +62 + $sysds_g_cmdle_ts +( +VOID +) + +64  +IA32_CMDLINE_OPTIONS +; + +65 + } +} + +67 +INTN + + +68 + $sysds_gt +( +INTN + +c +, INTN +td +, +CHAR16 + * +ݏrg +) + +71 + } +} + +73 +VOID + + +74 + $sysds_t_cmdle_ts +( +VOID +) + +76 + } +} + +79 +INTN + + +80 + $32_u_gacy__bo +( +VOID +) + +82  +32_gcf +. +gacy__bo + ? 1 : 0; + +83 + } +} + +85 +INTN + + +86 + $sysds_gi_tis +( +VOID +) + +88 +INTN + +t +; + +90 +t + = + `gi_cfig_tis +( +sysds_glob_tis +, + +91 ( +sysds_glob_tis +)/( +cfig_ti_t +), + +92 +OPTIONS_GROUP_GLOBAL +); + +95 i( +t + == -1 ) et; + +97 +t + = + `gi_cfig_tis +( +sysds_image_tis +, + +98 ( +sysds_image_tis +)/( +cfig_ti_t +), + +99 +OPTIONS_GROUP_IMAGE +); + +102  +t +; + +103 + } +} + + @ia32/gzip.c + +29  + ~ + +30  + ~ + +32  + ~"f.h +" + +33  + ~"o.h +" + +34  + ~"gz.h +" + +35  + ~"ive.h +" + +37  + #LD_NAME + +L +"gz_32" + + ) + +39  + #memzo +( +s +, +n + + `Memt +(( +VOID + *)(s), 0, (n)) + + ) + +40  + #memy +( +a +, +b +, +n + + `Memy +(( +VOID + *)),(b),)) + + ) + +43  + #WSIZE + 0x8000 + + ) + +46  + #INBUFSIZE + 0x8000 + + ) + +52  + #OF +( +gs + + ) +args + +53  + #FUNC_STATIC +  + + ) + +55  + tuch +; + +56  + tush +; + +57  + tulg +; + +60  + sgmt + { + +61  + maddr +; + +62  + mofft +; + +63  + msize +; + +64  + mbss_sz +; + +65 +UINT8 + + mags +; + +66 } + tgmt_t +; + +68  + #CHUNK_FL_VALID + 0x1 + + ) + +69  + #CHUNK_FL_LOAD + 0x2 + + ) + +71  + #CHUNK_CAN_LOAD +( +n + +chunks +[)]. +ags + | +CHUNK_FL_LOAD + + + ) + +72  + #CHUNK_NO_LOAD +( +n + +chunks +[)]. +ags + &~ +CHUNK_FL_LOAD + + + ) + +73  + #CHUNK_IS_LOAD +( +n +( +chunks +[)]. +ags + & +CHUNK_FL_LOAD +) + + ) + +75  + #CHUNK_VALIDATE +( +n + +chunks +[)]. +ags + | +CHUNK_FL_VALID + + + ) + +76  + #CHUNK_INVALIDATE +( +n + +chunks +[)]. +ags + = 0 + + ) + +77  + #CHUNK_IS_VALID +( +n +( +chunks +[)]. +ags + & +CHUNK_FL_VALID +) + + ) + +84  +gmt_t + * + gchunks +; + +85  +gmt_t + * + gcur_chunk +; + +86  +UINTN + + gnchunks +; + +87  +UINTN + + gchunk +; + +88  +UINTN + + gput_fd +; + +89  +VOID + * + gkl_y +, * + gkl_ba +, * + gkl_d +; + +91  +uch + * + gbuf +; + +92  +uch + * + gwdow +; + +93  + gfe_offt +; + +95  + gsize + = 0; + +96  + gr + = 0; + +97  + goutt + = 0; + +100  + #ASCII_FLAG + 0x01 + + ) + +101  + #CONTINUATION + 0x02 + + ) + +102  + #EXTRA_FIELD + 0x04 + + ) + +103  + #ORIG_NAME + 0x08 + + ) + +104  + #COMMENT + 0x10 + + ) + +105  + #ENCRYPTED + 0x20 + + ) + +106  + #RESERVED + 0xC0 + + ) + +108  + #g_by +(( +r + < +size + ? +buf +[r++] : + `fl_buf +()) + + ) + +111 #ifde +INFLATE_DEBUG + + +112  + #As +( +cd +, +msg +{if(!(cd) + `r +(msg);} + + ) + +113  + gdr +; + +114  + #T +( +x + + `Prt +( +L +"l%d:\n", +__LINE__ +); + + ) + +115  + #Tv +( +x +{i( +vbo + + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +116  + #Tvv +( +x +{i( +vbo +>1 + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +117  + #Tc +( +c +, +x +{i( +vbo + && (c) + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +118  + #Tcv +( +c +, +x +{i( +vbo +>1 && (c) + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +120  + #As +( +cd +, +msg +) + + ) + +121  + #T +( +x +) + + ) + +122  + #Tv +( +x +) + + ) + +123  + #Tvv +( +x +) + + ) + +124  + #Tc +( +c +, +x +) + + ) + +125  + #Tcv +( +c +, +x +) + + ) + +128  +fl_buf +(); + +129  +ush_wdow +(); + +130  +r +(* +m +); + +131  + gbys_out +; + +132  +r +(* +m +); + +133  + gr_tu +; + +136 + $gz_mloc +( +size +) + +138  (*) + `loc +( +size +, 0); + +139 + } +} + +142 + $gz_ +(* +whe +) + +144  + ` +( +whe +); + +145 + } +} + +147  + ~"e.c +" + +154 + $fl_buf +() + +156 +INTN + +exed +, +ėd +; + +157 +EFI_STATUS + +us +; + +159 +exed + = +ėd + = +INBUFSIZE +; + +161 +us + = + `fs_ad +( +put_fd +, +buf +, & +ėd +); + +162 i( + `EFI_ERROR +( +us +)) { + +163 + `r +("elilo: Read failed"); + +165 + `DBG_PRT +(( +L +"%:d %d byo%d bys\n", +LD_NAME +, +ėd +, +exed +)); + +167 +size + = +ėd +; + +168 +r + = 1; + +170  +buf +[0]; + +171 + } +} + +188 + $updc +(* +s +,  +n +) + +190  +c +; + +193 i(! +s +) { + +194 +c + = 0xffffffffL; + +196 +c + = +c +; + +197  +n +--) { + +198 +c + = +c_32_b +[(()^ (* +s +++)) & 0xff] ^ (c >> 8); + +201 +c + = +c +; + +202  +c + ^ 0xffffffffUL; + +203 + } +} + +210 + $r_bufs +() + +212 +outt + = 0; + +213 +r + = 0; + +214 +chunk + = 0; + +215 +cur_chunk + = +NULL +; + +216 +fe_offt + = 0; + +217 + } +} + +220  +INTN + + +221 + $is_vid_hd +( +Elf32_Ehdr + * +ehdr +) + +223 +UINT16 + +ty +, +mache +; + +225 +ty + = +ehdr +-> +e_ty +; + +226 +mache + = +ehdr +-> +e_mache +; + +228 + `VERB_PRT +(3, + `Prt +( +L +"class=%dype=%d data=%d machine=%d\n", + +229 +ehdr +-> +e_idt +[ +EI_CLASS +], + +230 +ty +, + +231 +ehdr +-> +e_idt +[ +EI_DATA +], + +232 +mache +)); + +234  +ehdr +-> +e_idt +[ +EI_MAG0 +] == 0x7f + +235 && +ehdr +-> +e_idt +[ +EI_MAG1 +] == 'E' + +236 && +ehdr +-> +e_idt +[ +EI_MAG2 +] == 'L' + +237 && +ehdr +-> +e_idt +[ +EI_MAG3 +] == 'F' + +238 && +ehdr +-> +e_idt +[ +EI_CLASS +] = +ELFCLASS32 + + +239 && +ty + = +ET_EXEC + + +240 && +mache + = +EM_386 + ? 0 : -1; + +241 + } +} + +247 + $check_ovp +( +i +) + +249  +j +; + +250  +nd + = +chunks +[ +i +]. +addr + + chunks[i]. +size +; + +252  +j +=0; j < +nchunks +; j++) { + +253 i( +j + == +i +) ; + +254 i( +chunks +[ +i +]. +addr + >chunks[ +j +].add&& +nd + < (chunks[j].add+ chunks[j]. +size +)) { + +255 + `DBG_PRT +(( +L +"%: segm%d fuy inuded igm%d\n", +LD_NAME +, +i +, +j +)); + +256 + `CHUNK_INVALIDATE +( +i +); + +260 + } +} + +263 + $yze_chunks +() + +265 +INTN + +i +; + +267  +i +=0; i < +nchunks +; i++) { + +268 i( + `CHUNK_IS_VALID +( +i +&& ! + `CHUNK_IS_LOAD +(i)) + +269 + `check_ovp +( +i +); + +271 + } +} + +280 + $f_block + (cڡ * +buf +,  +blocksize +) + +282 +Elf32_Ehdr + * +f +; + +283 +Elf32_Phdr + * +phdrs +; + +284 +UINTN + +tٮ_size +, +ges +; + +285 +UINTN + +low_addr +, +max_addr +; + +286 +UINTN + +offs + = 0; + +287 +UINT16 + +phnum +; + +288 +UINTN + +ddr +, +memsz +; + +289 +INTN + +i +; + +291 +f + = ( +Elf32_Ehdr + *) +buf +; + +293 i( + `is_vid_hd +( +f +) == -1) + +296 +offs + = +f +-> +e_phoff +; + +297 +phnum + = +f +-> +e_phnum +; + +299 + `VERB_PRT +(3, { + +300 + `Prt +( +L +"Eryo0x%lx\n", +f +-> +e_y +); + +301 + `Prt +( +L +"%drogm hds\n", +phnum +); + +302 + `Prt +( +L +"%d segmhds\n", +f +-> +e_shnum +); + +305 i( +offs + + +phnum + * (* +phdrs +> ( +blocksize +) { + +306 + `ERR_PRT +(( +L +"%: ELFrogm hdn if block (%ld)\n", +LD_NAME +, +offs +)); + +310 +kl_y + = ( +VOID + *)( +f +-> +e_y + & +PADDR_MASK +); + +312 +phdrs + = ( +Elf32_Phdr + *( +buf + + +offs +); + +313 +low_addr + = ~0; + +314 +max_addr + = 0; + +321 +chunks + = (*) + `loc +(( +gmt +)* +phnum +, 0); + +322 i( +chunks + = +NULL +) { + +323 + `ERR_PRT +(( +L +"%: faedochunk%r\n", +LD_NAME +)); + +326 +nchunks + = +phnum +; + +331  +i + = 0; i < +phnum +; ++i) { + +336 +ddr + = ( +phdrs +[ +i +]. +p_ddr + & +PADDR_MASK +); + +337 +memsz + = +phdrs +[ +i +]. +p_memsz +, + +339 +chunks +[ +i +]. +addr + = +ddr +; + +340 +chunks +[ +i +]. +offt + = +phdrs +[i]. +p_offt +; + +341 +chunks +[ +i +]. +size + = +phdrs +[i]. +p_fesz +; + +342 +chunks +[ +i +]. +bss_sz + = +phdrs +[i]. +p_memsz + -hdrs[i]. +p_fesz +; + +344 + `CHUNK_VALIDATE +( +i +); + +346 i( +phdrs +[ +i +]. +p_ty + ! +PT_LOAD +) { + +347 + `CHUNK_NO_LOAD +( +i +); + +348 + `DBG_PRT +(( +L +"%: skpg segm%ld\n", +LD_NAME +, +i +)); + +352 + `CHUNK_CAN_LOAD +( +i +); + +354 + `VERB_PRT +(3, + +355 + `Prt +( +L +"\n%s : segment %ld vaddr [0x%lx-0x%lx] offset %ld filesz %ld " + +357 +LD_NAME +, 1+ +i +, +chunks +[i]. +addr +, chunks[i].addr+ +phdrs +[i]. +p_fesz +, + +358 +chunks +[ +i +]. +offt +, chunks[i]. +size +, +memsz +, chunks[i]. +bss_sz +)); + +360 i( +ddr + < +low_addr +) + +361 +low_addr + = +ddr +; + +362 i( +ddr + + +memsz + > +max_addr +) + +363 +max_addr + = +ddr + + +memsz +; + +366 i( +low_addr + & ( +EFI_PAGE_SIZE + - 1)) { + +367 + `ERR_PRT +(( +L +"%:ow_addnمagigd 0x%lx\n", +LD_NAME +, +low_addr +)); + +368  +r +; + +370 + `yze_chunks +(); + +372 + `DBG_PRT +(( +L +"%s : %drogram headersntry=0x%lx\nlowest_addr=0x%lx highest_addr=0x%lx\n", + +373 +LD_NAME +, + +374 +phnum +, +kl_y +, +low_addr +, +max_addr +)); + +376 +tٮ_size + = ( +UINTN +) +max_addr + - (UINTN) +low_addr +; + +377 +ges + = + `EFI_SIZE_TO_PAGES +( +tٮ_size +); + +382 +kl_ba + = (*) +low_addr +; + +383 +kl_d + = (*)( +low_addr + + ( +ges + << +EFI_PAGE_SHIFT +)); + +386 i( + `loc_kmem +((*) +low_addr +, +ges +) == -1) { + +387 + `ERR_PRT +(( +L +"%s : AllocatePages(%d, 0x%lx) for kernel failed\n", + +388 +LD_NAME +, +ges +, +low_addr +)); + +389 + `ERR_PRT +(( +L +"%: Couldنd kȩ 0x%lx\n", +LD_NAME +, +low_addr +)); + +390 + `ERR_PRT +(( +L +"%: Bag\n", +LD_NAME +)); + +391  +r +; + +394 +r +: + +395 i( +chunks +) + +396 + ` +( +chunks +); + +398 + } +} + +405 + $xtchunk +() + +407  +i +; + +408 +gmt_t + * + +; + +410 + + = +NULL +; + +411  +i +=0; i < +nchunks +; i++) { + +413 i(! + `CHUNK_IS_VALID +( +i +|| ! + `CHUNK_IS_LOAD +(i)) ; + +415 i( +fe_offt + > +chunks +[ +i +]. +offt +) ; + +417 i( + + = +NULL + || +chunks +[ +i +]. +offt + < cp->offset) cp = &chunks[i]; + +419 +cur_chunk + = + +; + +420 + } +} + +428 + $ush_wdow +() + +430 cڡ +CHAR8 + +hic݋r +[4] = { '|' , '/' , '-' , '\\' }; + +431  +UINTN + +hi_cou +; + +432  +gmt + * + +; + +433 * +c +, * +d +; + +434  +t +; + +436 i(! +outt +) ; + +438 + `DBG_PRT +(( +L +"%: flush_wdow ou=%d fe_offt=%ld\n", +LD_NAME +, +outt +, +fe_offt +)); + +440 + `Prt +( +L +"%c\b", +hic݋r +[ +hi_cou +++%4]); + +442 + `updc +( +wdow +, +outt +); + +445 i(! +bys_out +) { + +446 i( + `f_block +( +wdow +, +outt +) < 0) + +447 + `r +("invalidxec header"); + +448 + `xtchunk +(); + +451 +bys_out + + +outt +; + +452 +c + = +wdow +; + +453 + +: + +455 i( + `check_abt +(= +EFI_SUCCESS + +ld_abt +; + +457 + + = +cur_chunk +; + +458 i( + + = +NULL + || +fe_offt + + +outt + <-> +offt +) { + +459 +fe_offt + + +outt +; + +464 i( +fe_offt + < + +-> +offt +) { + +465  +sk + = + +-> +offt + - +fe_offt +; + +467 +c + + +sk +; + +468 +fe_offt + + +sk +; + +469 +outt + - +sk +; + +471 +d + = (*) + +-> +addr + + ( +fe_offt + - cp-> +offt +); + +472 +t + = + +-> +offt + + cp-> +size + - +fe_offt +; + +473 i( +t + > +outt +) + +474 +t + = +outt +; + +476 + `Memy +( +d +, +c +, +t +); + +478 +fe_offt + + +t +; + +479 +outt + - +t +; + +480 +c + + +t +; + +483 i( +fe_offt + = + +-> +offt + + cp-> +size +) { + +484 i( + +-> +bss_sz +) { + +485 +d + = (*) + +-> +addr + + cp-> +size +; + +486 + `Memt +( +d +, 0, + +-> +bss_sz +); + +488 + `xtchunk +(); + +490 i( +outt +) + +491  + +; + +494 +ld_abt +: + +495 + `_kmem +(); + +496 +r_tu + = +ELILO_LOAD_ABORTED +; + +497 + } +} + +500 + $r +(* +x +) + +502 + `ERR_PRT +(( +L +"%: %a", +LD_NAME +, +x +)); + +504 + } +} + +506 +INT32 + + +507 + $decomess_kl +( +VOID +) + +509 +INT32 + +t +; + +511 + `r_bufs +(); + +512 + `makec +(); + +513 + `Prt +( +L +"Uncompressing Linux... "); + +514 +t + = + `gunz +(); + +515 i( +t + == 0) + +516 + `Prt +( +L +"done\n"); + +517  +t + == 0 ? 0 : -1; + +518 + } +} + +521 + $gunz_kl +( +fs_fd_t + +fd +, +kdesc_t + * +kd +) + +523  +t + = -1; + +525 +r_tu + = +ELILO_LOAD_ERROR +; + +527 +wdow + = (*) + `loc +( +WSIZE +, 0); + +528 i( +wdow + = +NULL +) { + +529 + `ERR_PRT +(( +L +"%:o ouuwdow faed\n", +LD_NAME +)); + +533 +buf + = (*) + `loc +( +INBUFSIZE +, 0); + +534 i( +buf + = +NULL +) { + +535 + `ERR_PRT +(( +L +"%:o iuwdow faedr\n", +LD_NAME +)); + +536  +r +; + +538 +put_fd + = +fd +; + +539 +size + = 0; + +540 +bys_out + = 0; + +542 +t + = + `decomess_kl +(); + +543 +r +: + +544 i( +wdow + + ` +(window); + +545 i( +buf + + ` +(inbuf); + +547 i( +t + == 0) { + +548 +kd +-> +ky + = +kl_y +; + +549 +kd +-> +kd + = +kl_d +; + +550 +kd +-> +kt + = +kl_ba +; + +551 +r_tu + = +ELILO_LOAD_SUCCESS +; + +553  +r_tu +; + +554 + } +} + + @ia32/gzip_loader.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"ld.h +" + +31  + ~"gz.h +" + +33  + #LD_NAME + +L +"gz_32" + + ) + +35  +INTN + + +36 + $gz_obe_fm +( +CHAR16 + * +kme +) + +38 +UINT8 + +buf +[4]; + +39 +EFI_STATUS + +us +; + +40 +INTN + +t + = -1; + +41 +UINTN + +size +; + +42 +fs_fd_t + +fd +; + +44 +us + = + `fs_ݒ +( +kme +, & +fd +); + +45 i( + `EFI_ERROR +( +us +))  -1; + +47 +size + = ( +buf +); + +48 +us + = + `fs_ad +( +fd +, +buf +, & +size +); + +50 i( + `EFI_ERROR +( +us +|| +size + !( +buf +) +r +; + +52 +t + = + `gz_obe +( +buf +, (buf)); + +53 +r +: + +54 + `fs_o +( +fd +); + +55  +t +; + +56 + } +} + +59  +INTN + + +60 + $gz_ld_kl +( +CHAR16 + * +kme +, +kdesc_t + * +kd +) + +62 +EFI_STATUS + +us +; + +63 +INT32 + +t +; + +64 +fs_fd_t + +fd +; + +66 +us + = + `fs_ݒ +( +kme +, & +fd +); + +67 i( + `EFI_ERROR +( +us +) +ELILO_LOAD_ERROR +; + +69 +t + = + `gunz_kl +( +fd +, +kd +); + +71 + `fs_o +( +fd +); + +73  +t +; + +74 + } +} + +76 +ld_s_t + + ggz_ld +={ + +77 +NULL +, + +78 +LD_NAME +, + +79 +gz_obe_fm +, + +80 +gz_ld_kl + + + @ia32/plain_loader.c + +29  + ~ + +30  + ~ + +32  + ~"o.h +" + +33  + ~"ld.h +" + +34  + ~"f.h +" + +35  + ~"ive.h +" + +37  + #LD_NAME + +L +"a_f32" + + ) + +39  +INTN + + +40 + $is_vid_hd +( +Elf32_Ehdr + * +ehdr +) + +42 +UINT16 + +ty +, +mache +; + +44 +ty + = +ehdr +-> +e_ty +; + +45 +mache + = +ehdr +-> +e_mache +; + +47 + `DBG_PRT +(( +L +"class=%dype=%d data=%d machine=%d\n", + +48 +ehdr +-> +e_idt +[ +EI_CLASS +], + +49 +ty +, + +50 +ehdr +-> +e_idt +[ +EI_DATA +], + +51 +mache +)); + +53  +ehdr +-> +e_idt +[ +EI_MAG0 +] == 0x7f + +54 && +ehdr +-> +e_idt +[ +EI_MAG1 +] == 'E' + +55 && +ehdr +-> +e_idt +[ +EI_MAG2 +] == 'L' + +56 && +ehdr +-> +e_idt +[ +EI_MAG3 +] == 'F' + +57 && +ehdr +-> +e_idt +[ +EI_CLASS +] = +ELFCLASS32 + + +58 && +ty + = +ET_EXEC + + +59 && +mache + = +EM_386 + ? 0 : -1; + +60 + } +} + +62  +INTN + + +63 + $a_obe +( +CHAR16 + * +kme +) + +65 +Elf32_Ehdr + +ehdr +; + +66 +EFI_STATUS + +us +; + +67 +INTN + +t + = -1; + +68 +fs_fd_t + +fd +; + +69 +UINTN + +size + = ( +ehdr +); + +71 +us + = + `fs_ݒ +( +kme +, & +fd +); + +72 i( + `EFI_ERROR +( +us +)) + +75 +us + = + `fs_ad +( +fd +, & +ehdr +, & +size +); + +76 i( + `EFI_ERROR +( +us +|| +size + !( +ehdr +)) + +77  +r +; + +79 +t + = + `is_vid_hd +(& +ehdr +); + +80 +r +: + +81 + `fs_o +( +fd +); + +82  +t +; + +83 + } +} + +86  +INTN + + +87 + $ld_f +( +fs_fd_t + +fd +, +kdesc_t + * +kd +) + +89 +Elf32_Ehdr + +ehdr +; + +90 +Elf32_Phdr + * +phdrs +; + +91 +EFI_STATUS + +us +; + +92 +INTN + +t + = +ELILO_LOAD_ERROR +; + +93 +UINTN + +i +, +tٮ_size + = 0; + +94 +UINTN + +ges +, +size +, +bss_sz +, +osize +; + +95 +VOID + * +low_addr + = (VOID *)~0; + +96 +VOID + * +max_addr + = (VOID *)0; + +97 +UINTN + +ddr +, +memsz +, +fesz +; + +98 +UINT16 + +phnum +; + +100 + `Prt +( +L +"Loading Linux... "); + +102 +size + = ( +ehdr +); + +104 +us + = + `fs_ad +( +fd +, & +ehdr +, & +size +); + +105 i( + `EFI_ERROR +( +us +|| +size + < ( +ehdr +)) + +106  +ELILO_LOAD_ERROR +; + +108 i( + `is_vid_hd +(& +ehdr +) == -1) { + +109 + `ERR_PRT +(( +L +"%:ه 32-b ELF image\n", +LD_NAME +)); + +110  +ELILO_LOAD_ERROR +; + +112 + `VERB_PRT +(3, { + +113 + `Prt +( +L +"ELF Header information: \n"); + +114 + `Prt +( +L +"\tEryo0x%x\n", ( +ehdr +. +e_y + & +PADDR_MASK +)); + +115 + `Prt +( +L +"\t%drogm hds\n", +ehdr +. +e_phnum +); + +116 + `Prt +( +L +"\t%d segmhds\n", +ehdr +. +e_shnum +); + +119 +phnum + = +ehdr +. +e_phnum +; + +121 i( + `fs_ek +( +fd +, +ehdr +. +e_phoff +) < 0) { + +122 + `ERR_PRT +(( +L +"%: sk%d f܅hdred", +LD_NAME +, +ehdr +. +e_phoff +)); + +123  +ELILO_LOAD_ERROR +; + +125 +size + = +osize + = ( +phnum + * ( +Elf32_Phdr +)); + +127 + `DBG_PRT +(( +L +"%s :llocate %d bytes for %dheadersach of size:%dhentsize=%d\n", + +128 +LD_NAME +, +size +, +phnum +, ( +Elf32_Phdr +), +ehdr +. +e_phtsize +)); + +130 +phdrs + = ( +Elf32_Phdr + *) + `loc +( +size +, 0); + +131 i( +phdrs + = +NULL +) { + +132 + `ERR_PRT +(( +L +"%:o f܅hdred", +LD_NAME +)); + +133  +ELILO_LOAD_ERROR +; + +135 +us + = + `fs_ad +( +fd +, +phdrs +, & +size +); + +136 i( + `EFI_ERROR +( +us +|| +size + ! +osize +) { + +137 + `ERR_PRT +(( +L +"%:hdld faed", +LD_NAME +, +us +)); + +138  +out +; + +143  +i + = 0; i < +phnum +; i++) { + +145 +ddr + = ( +phdrs +[ +i +]. +p_ddr + & +PADDR_MASK +); + +146 +memsz + = +phdrs +[ +i +]. +p_memsz +; + +148 + `DBG_PRT +(( +L +"Phdr %daddr [0x%x-0x%x] offset 0x%x" + +150 1+ +i +, +ddr +,addr+ +phdrs +[i]. +p_fesz +,hdrs[i]. +p_offt +, + +151 +phdrs +[ +i +]. +p_fesz +, +memsz +, + +152 ( +memsz + - +phdrs +[ +i +]. +p_fesz +),hdrs[i]. +p_ty +)); + +154 i( +phdrs +[ +i +]. +p_ty + ! +PT_LOAD +) + +156 i( +ddr + < ( +UINTN +) +low_addr +) + +157 +low_addr + = ( +VOID + *) +ddr +; + +158 i( +ddr + + +memsz + > ( +UINTN +) +max_addr +) + +159 +max_addr + = ( +VOID + *) +ddr + + +memsz +; + +162 i(( +UINTN +) +low_addr + & ( +EFI_PAGE_SIZE + - 1)) { + +163 + `ERR_PRT +(( +L +"%s : kernelowddress 0x%xotageligned\n", + +164 +LD_NAME +, +low_addr +)); + +165  +out +; + +168 +tٮ_size + = ( +UINTN +) +max_addr + - (UINTN) +low_addr +; + +171 +ges + = + `EFI_SIZE_TO_PAGES +( +tٮ_size +); + +174 +kd +-> +kt + = +low_addr +; + +175 +kd +-> +kd + = ( +low_addr + + ( +ges + << +EFI_PAGE_SHIFT +)); + +176 +kd +-> +ky + = ( +VOID + *)( +ehdr +. +e_y + & +PADDR_MASK +); + +178 + `VERB_PRT +(3, { + +179 + `Prt +( +L +"Lowest PhysAddr: 0x%x\nTotalMemSize:%d bytes (%dages)\n", + +180 +low_addr +, +tٮ_size +, +ges +); + +181 + `Prt +( +L +"KȒy @ 0x%x\n", +kd +-> +ky +); + +185 i( + `loc_kmem +( +low_addr +, +ges +) == -1) { + +186 + `ERR_PRT +(( +L +"%s : AllocatePages(%d, 0x%lx) for kernel failed\n", + +187 +LD_NAME +, +ges +, +low_addr +)); + +188 + `ERR_PRT +(( +L +"%s : Couldotlloc %dages forhe kernelt 0x%lx " + +190 +LD_NAME +, +ges +, +low_addr +)); + +191  +ld_abt +; + +194 + `Memt +( +low_addr +, 0, ( +ges + << +EFI_PAGE_SHIFT +)); + +196 + `VERB_PRT +(1, + `Prt +( +L +"Pressny keyo interrupt\n")); + +203  +i + = 0; i < +phnum +; i++) { + +206 i( +phdrs +[ +i +]. +p_ty + ! +PT_LOAD +) + +209 + `VERB_PRT +(3, + `Prt +( +L +"poffs: 0x%x (phdrs[%d].p_offset)\n", + +210 +phdrs +[ +i +]. +p_offt +, i)); + +212 +fesz + = +phdrs +[ +i +]. +p_fesz +; + +213 +low_addr + = ( +VOID + *)(( +UINTN + +phdrs +[ +i +]. +p_ddr + & +PADDR_MASK +); + +216 i( + `fs_ek +( +fd +, +phdrs +[ +i +]. +p_offt +) < 0) + +217  +out_kl +; + +220 +bss_sz + = +phdrs +[ +i +]. +p_memsz + - +fesz +; + +222 + `VERB_PRT +(4, { + +223 + `Prt +( +L +"\nHd #%d\n", +i +); + +224 + `Prt +( +L +"Off f0x%x\n", +phdrs +[ +i +]. +p_offt +); + +225 + `Prt +( +L +"Physiadd0x%x\n", +low_addr +); + +226 + `Prt +( +L +"BSS siz0x%x bys\n", +bss_sz +); + +232 +t + = + `fs_ad +( +fd +, +low_addr +, & +fesz +); + +233 i( +t + = +ELILO_LOAD_ABORTED + +ld_abt +; + +234 i( +t + = +ELILO_LOAD_ERROR + +out +; + +239 i( +bss_sz +) + +240 + `Memt +(( +VOID + *) +low_addr ++ +fesz +, 0, +bss_sz +); + +243 + ` +( +phdrs +); + +245 + `Prt +( +L +"..Done\n"); + +246  +ELILO_LOAD_SUCCESS +; + +248 +ld_abt +: + +249 + `Prt +( +L +"..Aborted\n"); + +250 +t + = +ELILO_LOAD_ABORTED +; + +251 +out_kl +: + +253 + `_kmem +(); + +254 +out +: + +255 + ` +( +phdrs +); + +256  +t +; + +257 + } +} + +259  +INTN + + +260 + $a_ld_kl +( +CHAR16 + * +kme +, +kdesc_t + * +kd +) + +262 +INTN + +t +; + +263 +fs_fd_t + +fd +; + +264 +EFI_STATUS + +us +; + +269 +us + = + `fs_ݒ +( +kme +, & +fd +); + +270 i( + `EFI_ERROR +( +us +) +ELILO_LOAD_ERROR +; + +272 + `Prt +( +L +"Ldg %s...", +kme +); + +274 +t + = + `ld_f +( +fd +, +kd +); + +276 + `fs_o +( +fd +); + +277  +t +; + +278 + } +} + +280 +ld_s_t + + ga_ld +={ + +281 +NULL +, + +282 +LD_NAME +, + +283 +a_obe +, + +284 +a_ld_kl + + + @ia32/private.h + +26 #ide +__ELILO_PRIVATE_IA32_H__ + + +27  + #__ELILO_PRIVATE_IA32_H__ + + + ) + + @ia32/sysdeps.h + +32 #ide +__ELILO_SYSDEPS_IA32_H__ + + +33  + #__ELILO_SYSDEPS_IA32_H__ + + + ) + +35  + #ELILO_ARCH + "IA-32" + + ) + +36  + #PADDR_MASK + 0xfffffff + + ) + +39  + #Memt +( +a +, +v +, +n + + `SMem +(),),(v)) + + ) + +40  + #Memy +( +a +, +b +, +n + + `CyMem +(),(b),)) + + ) + +61 #agm +ck +(1) + +62  + u32_bo_ms + { + +63 +UINT8 + + mw +[0x2000]; + +66 +UINT8 + + mig_curs_c +; + +67 +UINT8 + + mig_curs_row +; + +70 +UINT16 + + mext_mem_k +; + +73 +UINT16 + + mig_video_ge +; + +74 +UINT8 + + mig_video_mode +; + +75 +UINT8 + + mig_video_cs +; + +77 +UINT16 + + munud_1 +; + +80 +UINT16 + + mig_ega_bx +; + +82 +UINT16 + + munud_2 +; + +85 +UINT8 + + mig_video_rows +; + +88 +UINT8 + + mis_vga +; + +89 +UINT16 + + mig_video_pots +; + +92 +UINT16 + + mlfb_width +; + +93 +UINT16 + + mlfb_height +; + +94 +UINT16 + + mlfb_dth +; + +95 +UINT32 + + mlfb_ba +; + +96 +UINT32 + + mlfb_size +; + +101 +UINT16 + + mcmdle_magik +; + +102  + #CMDLINE_MAGIK + 0xA33F + + ) + +103 +UINT16 + + mcmdle_offt +; + +106 +UINT16 + + mlfb_le_n +; + +109 +UINT8 + + mlfb_d_size +; + +110 +UINT8 + + mlfb_d_pos +; + +111 +UINT8 + + mlfb_g_size +; + +112 +UINT8 + + mlfb_g_pos +; + +113 +UINT8 + + mlfb_blue_size +; + +114 +UINT8 + + mlfb_blue_pos +; + +115 +UINT8 + + mlfb_rsvd_size +; + +116 +UINT8 + + mlfb_rsvd_pos +; + +119 +UINT16 + + mve_g +; + +120 +UINT16 + + mve_off +; + +123 +UINT16 + + mlfb_ges +; + +124 +UINT8 + + mlfb_rved +[0x0C]; + +127 +UINT16 + + mm_bios_v +; + +128  + #NO_APM_BIOS + 0x0000 + + ) + +131 +UINT16 + + mbios_code_g +; + +132 +UINT32 + + mbios_y_pot +; + +133 +UINT16 + + mbios_code_g16 +; + +134 +UINT16 + + mbios_da_g +; + +137 +UINT16 + + mm_bios_ags +; + +138  + #NO_32BIT_APM_MASK + 0xFFFD + + ) + +141 +UINT32 + + mbios_code_n +; + +142 +UINT16 + + mbios_da_n +; + +144 +UINT8 + + munud_3 +[0x2C]; + +147 +UINT8 + + mhd0_fo +[0x10]; + +148 +UINT8 + + mhd1_fo +[0x10]; + +151 +UINT16 + + mm_fo_n +; + +152 +UINT8 + + mm_fo_buf +[0x10]; + +154 +UINT8 + + munud_4 +[0x10E]; + +157 +UINT8 + + mefi_ld_sig +[4]; + +158  + #EFI_LOADER_SIG + "EFIL" + + ) + +161 +UINT32 + + mefi_sys_tbl +; + +164 +UINT32 + + mefi_mem_desc_size +; + +167 +UINT32 + + mefi_mem_desc_v +; + +170 +UINT32 + + mefi_mem_m +; + +171 +UINT32 + + mefi_mem_m_size +; + +174 +UINT32 + + mld_t +; + +175 +UINT32 + + mld_size +; + +178 +UINT32 + + mt_mem_k +; + +180 +UINT8 + + munud_5 +[0x0D]; + +183 +UINT8 + + mtup_s +; + +186 +UINT16 + + mmou_ro_rdly +; + +189 +UINT16 + + msys_size +; + +192 +UINT16 + + msw_dev +; + +195 +UINT16 + + mmdisk_ags +; + +196  + #RAMDISK_PROMPT + 0x8000 + + ) + +197  + #RAMDISK_LOAD + 0x4000 + + ) + +200 +UINT16 + + mvideo_mode_ag +; + +203 +UINT16 + + mig_ro_dev +; + +205 +UINT8 + + munud_6 +; + +208 +UINT8 + + maux_dev_fo +; + +209  + #NO_MOUSE + 0x00 + + ) + +210  + #FOUND_MOUSE + 0xAA + + ) + +213 +UINT16 + + mjump +; + +216 +UINT8 + + mtup_sig +[4]; + +217  + #SETUP_SIG + "HdrS" + + ) + +220 +UINT8 + + mhdr_m +; + +221 +UINT8 + + mhdr_maj +; + +224 +UINT32 + + mrm_swch +; + +227 +UINT16 + + mt_sys_g +; + +230 +UINT16 + + mkl_vr_offt +; + +233 +UINT8 + + mld_ty +; + +234  + #LDRTYPE_ELILO + 0x50 + + ) + +237 +UINT8 + + mld_ags +; + +238  + #LDRFLAG_CAN_USE_HEAP + 0x80 + + ) + +239  + #LDRFLAG_BOOT_PARAM_RELOC + 0x40 + + ) + +242 +UINT16 + + mtup_move_size +; + +245 +UINT32 + + mkl_t +; + +248 +UINT32 + + mrd_t +; + +249 +UINT32 + + mrd_size +; + +252 +UINT32 + + mbo٣_hr +; + +255 +UINT16 + + mhp_d_r +; + +258 +UINT16 + + munud_7 +; + +260 +UINT32 + + mcmdle_addr +; + +261 } + ms +; + +262 } + tbo_ms_t +; + +263 #agm +ck +() + +274  + #MEMCPY +( +to +, +om +, +t +) { \ + +275 +UINT8 + * +t + = (UINT8 *)( +to +); \ + +276 +UINT8 + * +f + = (UINT8 *)( +om +); \ + +277 +UINTN + +n + = +t +; \ + +278 i( +t + && +f + && +n +) { \ + +279  +n +--) { \ + +280 * +t +++ = * +f +++; \ + +283 } + + ) + +285  + #MEMSET +( +r +, +size +, +v +) { \ + +286 +UINT8 + * +p + = (UINT8 *)( +r +); \ + +287 +UINTN + +n + = (UINTN)( +size +); \ + +288 +UINT8 + +v + = (UINT8)( +v +); \ + +289 i( +p + && +n +) { \ + +290  +n +--) { \ + +291 * +p +++ = +v +; \ + +294 } + + ) + +299 #agm +ck +(1) + +301 +UINT16 + + mlim +; + +302 +UINT32 + + mba +; + +303 } + tdt_addr_t +; + +304 #agm +ck +() + +306 +UINTN + +high_ba_mem +; + +307 +UINTN + +high_ext_mem +; + +309 +bo_ms_t + * +m_t +; + +310 +UINTN + +m_size +; + +312 +VOID + * +kl_t +; + +313 +UINTN + +kl_size +; + +315 +VOID + * +rd_t +; + +316 +UINTN + +rd_size +; + +318 +dt_addr_t + +gdt_addr +; + +319 +dt_addr_t + +idt_addr +; + +321 +UINT16 + +_gdt +[]; + +322 +UINTN + +sizeof__gdt +; + +324 +UINT8 + +rmswch_image +[]; + +325 +UINTN + +rmswch_size +; + +327 +INTN + +32_u_gacy__bo +(); + +333  +le +  + +334 + $t_kl +( +VOID + * +ky +, +bo_ms_t + * +bp +) + +339 +asm + volatile ( "cli" : : ); + +345 i( +bp +-> +s +. +rd_t +) { + +346 + `MEMCPY +(15 * 1024 * 1024, +bp +-> +s +. +rd_t +, bp->s. +rd_size +); + +347 +bp +-> +s +. +rd_t + = 15 * 1024 * 1024; + +355 + `MEMCPY +( +high_ba_mem +, +bp +, 0x4000); + +361 + `MEMSET +( +gdt_addr +. +ba +, gdt_addr. +lim +, 0); + +362 + `MEMCPY +( +gdt_addr +. +ba +, +_gdt +, +sizeof__gdt +); + +364 i(! + `32_u_gacy__bo +()) { + +370 + `MEMCPY +(0x7C00, +rmswch_image +, +rmswch_size +); + +372 +asm + volatile ( "movl $0x7C00, %%ebx" : : ); + +373 +asm + volatile ( "jmp *%%ebx" : : ); + +380 +asm + vީ"lid%0" : : "m" ( +idt_addr +) ); + +381 +asm + vީ"lgd%0" : : "m" ( +gdt_addr +) ); + +389 +asm + vީ"mov%0, %%esi" : : "m" ( +high_ba_mem +) ); + +390 +asm + vީ"mov%0, %%ecx" : : "m" ( +ky +) ); + +391 +asm + volatile ( "xorl %%ebx, %%ebx" : : ); + +397 +asm + volatile ( "jmp *%%ecx" : : ); + +398 + } +} + +400  + ssys_img_tis + { + +401 +UINT8 + + mnhg_y +; + +402 } + tsys_img_tis_t +; + + @ia32/system.c + +31  + ~ + +32  + ~ + +34  + ~"o.h +" + +35  + ~"ld.h +" + +36  + ~"rmswch.h +" + +38 +ld_s_t + +bzimage_ld +, +a_ld +, +gz_ld +; + +44 +dt_addr_t + + ggdt_addr + = { 0x800, 0x94000 }; + +45 +dt_addr_t + + gidt_addr + = { 0, 0 }; + +51 +UINT16 + + g_gdt +[] = { + +71 +UINTN + + gsizeof__gdt + =  +_gdt +; + +86 +UINTN + + ghigh_ba_mem + = 0x90000; + +97 +UINTN + + ghigh_ext_mem + = 32 * 1024 * 1024; + +100 +VOID + * + gkl_t + = (VOID *)0x100000; + +102 +VOID + * + grd_t + = +NULL +; + +103 +UINTN + + grd_size + = 0; + +105 +INTN + + +106 + $sysds_ +( +EFI_HANDLE + +dev +) + +108 + `DBG_PRT +(( +L +"sysdeps_init()\n")); + +114 + `ld_gi +(& +bzimage_ld +); + +115 + `ld_gi +(& +a_ld +); + +116 + `ld_gi +(& +gz_ld +); + +118 + } +} + +128 +INTN + + +129 + $sysds_rd_g_addr +( +kdesc_t + * +kd +, +memdesc_t + * +imem +) + +131 + `DBG_PRT +(( +L +"initrd_get_addr()\n")); + +133 i(! +kd + || ! +imem +) { + +134 + `ERR_PRT +(( +L +"kd=0x%x imem=0x%x", +kd +, +imem +)); + +138 + `VERB_PRT +(3, + `Prt +( +L +"kstart=0x%x kentry=0x%x kend=0x%x\n", + +139 +kd +-> +kt +, kd-> +ky +, kd-> +kd +)); + +141 +imem +-> +t_addr + = +kd +-> +kd +; + +143 + `VERB_PRT +(3, + `Prt +( +L +"initrd start_addr=0x%xgcnt=%d\n", + +144 +imem +-> +t_addr +, imem-> +pgt +)); + +147 + } +} + +149 +VOID + + +150 + $sysds__bo_ms +( +bo_ms_t + * +bp +) + +152 +mm_desc_t + +md +; + +154 + `ZoMem +(& +md +,  md); + +155 +md +.md = ( +VOID + *) +bp +-> +s +. +efi_mem_m +; + +156 + `_memm +(& +md +); + +157 + } +} + +162 +INTN + + +163 + $sysds__bo_ms +( + +164 +bo_ms_t + * +bp +, + +165 +CHAR8 + * +cmdle +, + +166 +memdesc_t + * +rd +, + +167 +memdesc_t + * +vmcode +, + +168 +UINTN + * +cook +) + +170 +mm_desc_t + +mdesc +; + +171 +EFI_STATUS + +efi_us +; + +172 +UINTN + +rows +, +cs +; + +173 +UINT8 + +row +, +c +; + +174 +UINT8 + +mode +; + +175 +UINT16 + +hdr_vsi +; + +177 + `DBG_PRT +(( +L +"fill_boot_params()\n")); + +179 i(! +bp + || ! +cmdle + || ! +rd + || ! +cook +) { + +180 + `ERR_PRT +(( +L +"bp=0x%x cmdline=0x%x initrd=0x%x cookie=0x%x", + +181 +bp +, +cmdle +, +rd +, +cook +)); + +183 i( +m_t + ! +NULL +) { + +184 + ` +( +m_t +); + +185 +m_t + = +NULL +; + +186 +m_size + = 0; + +188 + `_kmem +(); + +198 i( +m_t + ! +NULL +) { + +199 + `CyMem +( +bp +, +m_t +, 0x2000); + +200 + ` +( +m_t +); + +201 +m_t + = +NULL +; + +202 +m_size + = 0; + +207 +hdr_vsi + = ( +bp +-> +s +. +hdr_maj + << 8| bp->s. +hdr_m +; + +212 +bp +-> +s +. +unud_1 + = 0; + +213 +bp +-> +s +. +unud_2 + = 0; + +214 + `ZoMem +( +bp +-> +s +. +unud_3 +,  bp->s.unused_3); + +215 + `ZoMem +( +bp +-> +s +. +unud_4 +,  bp->s.unused_4); + +216 + `ZoMem +( +bp +-> +s +. +unud_5 +,  bp->s.unused_5); + +217 +bp +-> +s +. +unud_6 + = 0; + +218 +bp +-> +s +. +unud_7 + = 0; + +226 +bp +-> +s +. +ld_ty + = +LDRTYPE_ELILO +; + +232 +bp +-> +s +. +cmdle_magik + = +CMDLINE_MAGIK +; + +233 +bp +-> +s +. +cmdle_offt + = ( +UINT8 + *) +cmdle + - (UINT8 *)bp; + +239 +bp +-> +s +. +cmdle_addr + = 0x0; + +247 + `ZoMem +( +bp +-> +s +. +hd0_fo +,  bp->s.hd0_info); + +248 + `ZoMem +( +bp +-> +s +. +hd1_fo +,  bp->s.hd1_info); + +254 +bp +-> +s +. +t_mem_k + = +high_ext_mem + / 1024; + +256 i( +bp +-> +s +. +t_mem_k + <= 65535) + +257 +bp +-> +s +. +ext_mem_k + = ( +UINT16 +)bp->s. +t_mem_k +; + +259 +bp +-> +s +. +ext_mem_k + = 65535; + +265 + `DBG_PRT +(( +L +"initrd->start_addr=0x%x initrd->pgcnt=%d\n", + +266 +rd +-> +t_addr +, inrd-> +pgt +)); + +269 +bp +-> +s +. +mdisk_ags + = 0; + +271 i( +rd +-> +t_addr + && inrd-> +pgt +) { + +273 +bp +-> +s +. +rd_t + = ( +UINT32 +) +rd +-> +t_addr +; + +274 +bp +-> +s +. +rd_size + = ( +UINT32 +)( +rd +-> +size +); + +281 +bp +-> +s +. +ig_ro_dev + = 0x0100; + +283 +bp +-> +s +. +rd_t + = 0; + +284 +bp +-> +s +. +rd_size + = 0; + +290 +bp +-> +s +. +m_bios_v + = +NO_APM_BIOS +; + +291 +bp +-> +s +. +bios_code_g + = 0; + +292 +bp +-> +s +. +bios_y_pot + = 0; + +293 +bp +-> +s +. +bios_code_g16 + = 0; + +294 +bp +-> +s +. +bios_da_g + = 0; + +295 +bp +-> +s +. +m_bios_ags + = 0; + +296 +bp +-> +s +. +bios_code_n + = 0; + +297 +bp +-> +s +. +bios_da_n + = 0; + +302 +bp +-> +s +. +m_fo_n + = 0; + +303 + `ZoMem +( +bp +-> +s +. +m_fo_buf +,  bp->s.mca_info_buf); + +308 +bp +-> +s +. +aux_dev_fo + = +NO_MOUSE +; + +313 + `CyMem +( +bp +-> +s +. +efi_ld_sig +, +EFI_LOADER_SIG +, 4); + +318 +bp +-> +s +. +kl_t + = ( +UINT32 +)kernel_start; + +330  + #CHECK_OFFSET +( +n +, +o +, +f +) \ + +332 +UINTN + +p + = ( +UINT8 + *)& +bp +-> +s +. +n + - (UINT8 *)bp; \ + +333 +UINTN + +q + = (UINTN)( +o +); \ + +334 i( +p + ! +q +) { \ + +335 + + |= 1; \ + +336 + `Prt +( +L +"%20a: %3xh %3xh ", #n, +p +, +q +); \ + +337 i(* +f +) { \ + +338 + `Prt +( +f +, +bp +-> +s +. +n +); \ + +340 + `Prt +( +L +"\n"); \ + +342 } + + ) + +344  + #WAIT_FOR_KEY +() \ + +346 +EFI_INPUT_KEY + +key +; \ + +347  +ST +-> +CIn +-> + `RdKeySoke +(ST->CIn, & +key +! +EFI_SUCCESS +) { \ + +350 } + + ) + +352 +UINTN + + + = 0; + +354 + `CHECK_OFFSET +( +ig_curs_c +, 0x00, +L +"%xh"); + +355 + `CHECK_OFFSET +( +ig_curs_row +, 0x01, +L +"%xh"); + +356 + `CHECK_OFFSET +( +ext_mem_k +, 0x02, +L +"%xh"); + +357 + `CHECK_OFFSET +( +ig_video_ge +, 0x04, +L +"%xh"); + +358 + `CHECK_OFFSET +( +ig_video_mode +, 0x06, +L +"%xh"); + +359 + `CHECK_OFFSET +( +ig_video_cs +, 0x07, +L +"%xh"); + +360 + `CHECK_OFFSET +( +ig_ega_bx +, 0x0A, +L +"%xh"); + +361 + `CHECK_OFFSET +( +ig_video_rows +, 0x0E, +L +"%xh"); + +362 + `CHECK_OFFSET +( +is_vga +, 0x0F, +L +"%xh"); + +363 + `CHECK_OFFSET +( +ig_video_pots +, 0x10, +L +"%xh"); + +364 + `CHECK_OFFSET +( +lfb_width +, 0x12, +L +"%xh"); + +365 + `CHECK_OFFSET +( +lfb_height +, 0x14, +L +"%xh"); + +366 + `CHECK_OFFSET +( +lfb_dth +, 0x16, +L +"%xh"); + +367 + `CHECK_OFFSET +( +lfb_ba +, 0x18, +L +"%xh"); + +368 + `CHECK_OFFSET +( +lfb_size +, 0x1C, +L +"%xh"); + +369 + `CHECK_OFFSET +( +cmdle_magik +, 0x20, +L +"%xh"); + +370 + `CHECK_OFFSET +( +cmdle_offt +, 0x22, +L +"%xh"); + +371 + `CHECK_OFFSET +( +lfb_le_n +, 0x24, +L +"%xh"); + +372 + `CHECK_OFFSET +( +lfb_d_size +, 0x26, +L +"%xh"); + +373 + `CHECK_OFFSET +( +lfb_d_pos +, 0x27, +L +"%xh"); + +374 + `CHECK_OFFSET +( +lfb_g_size +, 0x28, +L +"%xh"); + +375 + `CHECK_OFFSET +( +lfb_g_pos +, 0x29, +L +"%xh"); + +376 + `CHECK_OFFSET +( +lfb_blue_size +, 0x2A, +L +"%xh"); + +377 + `CHECK_OFFSET +( +lfb_blue_pos +, 0x2B, +L +"%xh"); + +378 + `CHECK_OFFSET +( +lfb_rsvd_size +, 0x2C, +L +"%xh"); + +379 + `CHECK_OFFSET +( +lfb_rsvd_pos +, 0x2D, +L +"%xh"); + +380 + `CHECK_OFFSET +( +ve_g +, 0x2E, +L +"%xh"); + +381 + `CHECK_OFFSET +( +ve_off +, 0x30, +L +"%xh"); + +382 + `CHECK_OFFSET +( +lfb_ges +, 0x32, +L +"%xh"); + +383 + `CHECK_OFFSET +( +lfb_rved +, 0x34, +L +""); + +384 + `CHECK_OFFSET +( +m_bios_v +, 0x40, +L +"%xh"); + +385 + `CHECK_OFFSET +( +bios_code_g +, 0x42, +L +"%xh"); + +386 + `CHECK_OFFSET +( +bios_y_pot +, 0x44, +L +"%xh"); + +387 + `CHECK_OFFSET +( +bios_code_g16 +, 0x48, +L +"%xh"); + +388 + `CHECK_OFFSET +( +bios_da_g +, 0x4A, +L +"%xh"); + +389 + `CHECK_OFFSET +( +m_bios_ags +, 0x4C, +L +"%xh"); + +390 + `CHECK_OFFSET +( +bios_code_n +, 0x4E, +L +"%xh"); + +391 + `CHECK_OFFSET +( +bios_da_n +, 0x52, +L +"%xh"); + +392 + `CHECK_OFFSET +( +hd0_fo +, 0x80, +L +""); + +393 + `CHECK_OFFSET +( +hd1_fo +, 0x90, +L +""); + +394 + `CHECK_OFFSET +( +m_fo_n +, 0xA0, +L +"%xh"); + +395 + `CHECK_OFFSET +( +m_fo_buf +, 0xA2, +L +""); + +396 + `CHECK_OFFSET +( +efi_ld_sig +, 0x1C0, +L +"'%-4.4a'"); + +397 + `CHECK_OFFSET +( +efi_sys_tbl +, 0x1C4, +L +"%xh"); + +398 + `CHECK_OFFSET +( +efi_mem_desc_size +, 0x1C8, +L +"%xh"); + +399 + `CHECK_OFFSET +( +efi_mem_desc_v +, 0x1CC, +L +"%xh"); + +400 + `CHECK_OFFSET +( +efi_mem_m +, 0x1D0, +L +"%xh"); + +401 + `CHECK_OFFSET +( +efi_mem_m_size +, 0x1D4, +L +"%xh"); + +402 + `CHECK_OFFSET +( +ld_t +, 0x1D8, +L +"%xh"); + +403 + `CHECK_OFFSET +( +ld_size +, 0x1DC, +L +"%xh"); + +404 + `CHECK_OFFSET +( +t_mem_k +, 0x1E0, +L +"%xh"); + +405 + `CHECK_OFFSET +( +tup_s +, 0x1F1, +L +"%xh"); + +406 + `CHECK_OFFSET +( +mou_ro_rdly +, 0x1F2, +L +"%xh"); + +407 + `CHECK_OFFSET +( +sys_size +, 0x1F4, +L +"%xh"); + +408 + `CHECK_OFFSET +( +sw_dev +, 0x1F6, +L +"%xh"); + +409 + `CHECK_OFFSET +( +mdisk_ags +, 0x1F8, +L +"%xh"); + +410 + `CHECK_OFFSET +( +video_mode_ag +, 0x1FA, +L +"%xh"); + +411 + `CHECK_OFFSET +( +ig_ro_dev +, 0x1FC, +L +"%xh"); + +412 + `CHECK_OFFSET +( +aux_dev_fo +, 0x1FF, +L +"%xh"); + +413 + `CHECK_OFFSET +( +jump +, 0x200, +L +"%xh"); + +414 + `CHECK_OFFSET +( +tup_sig +, 0x202, +L +"'%-4.4a'"); + +415 + `CHECK_OFFSET +( +hdr_m +, 0x206, +L +"%xh"); + +416 + `CHECK_OFFSET +( +hdr_maj +, 0x207, +L +"%xh"); + +417 + `CHECK_OFFSET +( +rm_swch +, 0x208, +L +"%xh"); + +418 + `CHECK_OFFSET +( +t_sys_g +, 0x20C, +L +"%xh"); + +419 + `CHECK_OFFSET +( +kl_vr_offt +, 0x20E, +L +"%xh"); + +420 + `CHECK_OFFSET +( +ld_ty +, 0x210, +L +"%xh"); + +421 + `CHECK_OFFSET +( +ld_ags +, 0x211, +L +"%xh"); + +422 + `CHECK_OFFSET +( +tup_move_size +, 0x212, +L +"%xh"); + +423 + `CHECK_OFFSET +( +kl_t +, 0x214, +L +"%xh"); + +424 + `CHECK_OFFSET +( +rd_t +, 0x218, +L +"%xh"); + +425 + `CHECK_OFFSET +( +rd_size +, 0x21C, +L +"%xh"); + +426 + `CHECK_OFFSET +( +bo٣_hr +, 0x220, +L +"%xh"); + +427 + `CHECK_OFFSET +( +hp_d_r +, 0x224, +L +"%xh"); + +428 + `CHECK_OFFSET +( +cmdle_addr +, 0x228, +L +"%xh"); + +430 i( + +) { + +431 + `ERR_PRT +(( +L +"Boot sectornd/or setuparameterlignmentrror.")); + +432 + `_kmem +(); + +443 +efi_us + = +ST +-> +COut +-> + `QuyMode +( + +444 +ST +-> +COut +, + +445 +ST +-> +COut +-> +Mode +->Mode, + +446 & +cs +, + +447 & +rows +); + +449 i( + `EFI_ERROR +( +efi_us +)) { + +450 + `ERR_PRT +(( +L +"QueryMode failed. Fake it.")); + +451 +mode + = 3; + +452 +rows + = 25; + +453 +cs + = 80; + +454 +row + = 24; + +455 +c + = 0; + +457 +mode + = ( +UINT8 +) +ST +-> +COut +-> +Mode +->Mode; + +458 +c + = ( +UINT8 +) +ST +-> +COut +-> +Mode +-> +CursCumn +; + +459 +row + = ( +UINT8 +) +ST +-> +COut +-> +Mode +-> +CursRow +; + +462 +bp +-> +s +. +ig_curs_c + = +c +; + +463 +bp +-> +s +. +ig_curs_row + = +row +; + +464 +bp +-> +s +. +ig_video_ge + = 0; + +465 +bp +-> +s +. +ig_video_mode + = +mode +; + +466 +bp +-> +s +. +ig_video_cs + = ( +UINT8 +) +cs +; + +467 +bp +-> +s +. +ig_video_rows + = ( +UINT8 +) +rows +; + +469 +bp +-> +s +. +ig_ega_bx + = 0; + +470 +bp +-> +s +. +is_vga + = 0; + +471 +bp +-> +s +. +ig_video_pots + = 16; + +473 +bp +-> +s +. +lfb_width + = 0; + +474 +bp +-> +s +. +lfb_height + = 0; + +475 +bp +-> +s +. +lfb_dth + = 0; + +476 +bp +-> +s +. +lfb_ba + = 0; + +477 +bp +-> +s +. +lfb_size + = 0; + +478 +bp +-> +s +. +lfb_le_n + = 0; + +479 +bp +-> +s +. +lfb_d_size + = 0; + +480 +bp +-> +s +. +lfb_d_pos + = 0; + +481 +bp +-> +s +. +lfb_g_size + = 0; + +482 +bp +-> +s +. +lfb_g_pos + = 0; + +483 +bp +-> +s +. +lfb_blue_size + = 0; + +484 +bp +-> +s +. +lfb_blue_pos + = 0; + +485 +bp +-> +s +. +lfb_rsvd_size + = 0; + +486 +bp +-> +s +. +lfb_rsvd_pos + = 0; + +487 +bp +-> +s +. +lfb_ges + = 0; + +488 +bp +-> +s +. +ve_g + = 0; + +489 +bp +-> +s +. +ve_off + = 0; + +495 i( + `g_memm +(& +mdesc +)) { + +496 + `ERR_PRT +(( +L +"Couldot get memory map.")); + +497 + `_kmem +(); + +500 * +cook + = +mdesc +.cookie; + +501 +bp +-> +s +. +efi_mem_m + = ( +UINTN +) +mdesc +. +md +; + +502 +bp +-> +s +. +efi_mem_m_size + = +mdesc +. +m_size +; + +503 +bp +-> +s +. +efi_mem_desc_size + = +mdesc +. +desc_size +; + +504 +bp +-> +s +. +efi_mem_desc_v + = +mdesc +. +desc_vsi +; + +505 +bp +-> +s +. +efi_sys_tbl + = ( +UINTN +) +syab +; + +508 + } +} + + @ia64/config.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"cfig.h +" + +31  + ~"ive.h +" + +32  + ~"sysds.h +" + +33  + ~"gt.h +" + +36 +CHAR16 + + mswa +[ +FILENAME_MAXLEN +]; + +37 +CHAR16 + + mcmd_swa +[ +FILENAME_MAXLEN +]; + +38 +UINTN + + mlow_loti +; + +39 } + t64_glob_cfig_t +; + +41  + #64_t_offtof +( +ti +(&(( +sys_img_tis_t + *)(0x0))->ti) + + ) + +43  +64_glob_cfig_t + + g64_gcf +; + +50 +cfig_ti_t + + gsysds_glob_tis +[]={ + +51 { +OPT_FILE +, +OPT_GLOBAL +, +L +"swa", +NULL +, NULL, +64_gcf +. +swa +}, + +52 { +OPT_BOOL +, +OPT_GLOBAL +, +L +"lob", +NULL +, NULL, & +64_gcf +. +low_loti +}, + +55 +cfig_ti_t + + gsysds_image_tis +[]={ + +56 { +OPT_BOOL +, +OPT_IMAGE_SYS +, +L +"lob", +NULL +, NULL, +64_t_offtof +( +low_loti +)}, + +67 +INTN + + +68 + $sysds_o_ais +( +EFI_HANDLE + +dev +, +CHAR16 + ** +gv +, +INTN + +gc +, INTN +dex +, EFI_HANDLE +image +) + +74 i( +64_gcf +. +cmd_swa +[0] ! +CHAR_NULL +) { + +75 + `check_swa +( +image +, +dev +, +64_gcf +. +cmd_swa +); + +76 } i( +64_gcf +. +swa +[0] ! +CHAR_NULL +) + +77 + `check_swa +( +image +, +dev +, +64_gcf +. +swa +); + +79 + `check_swa +( +image +, +dev +, +NULL +); + +82 + } +} + +92 +INTN + + +93 + $64_n_lo +( +VOID +) + +95  +64_gcf +. +low_loti + = +TRUE + + +96 || ( +o_t +. +sys_img_ts + &&lo_t.sys_img_ts-> +low_loti + == +TRUE +) ? 1 : 0; + +97 + } +} + +99  + #IA64_CMDLINE_OPTIONS + +L +"rF:" + + ) + +101 +CHAR16 + * + +102 + $sysds_g_cmdle_ts +( +VOID +) + +104  +IA64_CMDLINE_OPTIONS +; + +105 + } +} + +107 +INTN + + +108 + $sysds_gt +( +INTN + +c +, INTN +td +, +CHAR16 + * +ݏrg +) + +110 +INTN + +t + = 0; + +115  +c +) { + +116  +L +'r': + +117 +64_gcf +. +low_loti + = 1; + +119  +L +'F': + +120 i( + `SL +( +Og +> +FILENAME_MAXLEN +) { + +121 + `Prt +( +L +"FPSWA familimed%d chas\n", +FILENAME_MAXLEN +); + +124 + `SCpy +( +64_gcf +. +cmd_swa +, +Og +); + +127 +t + = -1; + +129  +t +; + +130 + } +} + +132 +VOID + + +133 + $sysds_t_cmdle_ts +( +VOID +) + +135 + `Prt +( +L +"-r kernel image can beelocated ifoadddress inexistent\n"); + +136 + `Prt +( +L +"-F fileame of specific FPSWA EFI driverooad\n"); + +137 + } +} + +139 +INTN + + +140 + $sysds_gi_tis +( +VOID +) + +142 +INTN + +t +; + +144 +t + = + `gi_cfig_tis +( +sysds_glob_tis +, + +145 ( +sysds_glob_tis +)/( +cfig_ti_t +), + +146 +OPTIONS_GROUP_GLOBAL +); + +147 i( +t + == -1 ) et; + +149 +t + = + `gi_cfig_tis +( +sysds_image_tis +, + +150 ( +sysds_image_tis +)/( +cfig_ti_t +), + +151 +OPTIONS_GROUP_IMAGE +); + +153  +t +; + +154 + } +} + + @ia64/fpswa.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"fes.h +" + +33 +UINT32 + + mvisi +; + +34 +UINT32 + + mrved +; + +35 +VOID + * + mswa +; + +36 } + tswa_r_t +; + +38 +INTN + + +39 + $quy_swa +( +VOID + ** +swa +) + +41 +EFI_HANDLE + +swa_image +; + +42 +UINTN + +size +; + +43 +EFI_STATUS + +us +; + +44 +EFI_GUID + +FpswaProc + = +FPSWA_PROTOCOL +; + +46 + `DBG_PRT +(( +L +"Querying FpswaProtocol")); + +48 +size + = ( +EFI_HANDLE +); + +50 +us + = +BS +-> + `LoHd +( +ByProc +, & +FpswaProc +, +NULL +, & +size +, & +swa_image +); + +51 i( + `EFI_ERROR +( +us +)) { + +52 + `ERR_PRT +(( +L +"bo_mcouldنo FPSWA driv", +us +)); + +55 +us + = +BS +-> + `HdProc +( +swa_image +, & +FpswaProc +, +swa +); + +56 i( + `EFI_ERROR +( +us +)) { + +57 + `ERR_PRT +(( +L +"boot_params FpswaProtocolotble findhe interface")); + +60 + `VERB_PRT +(3, + `Prt +( +L +"FpswaProc = 0x%lxevisi=%x\n", * +swa +, + +61 (( +swa_r_t + *)* +swa +)-> +visi +)); + +63 + } +} + +66  +INTN + + +67 + $do_check_swa +( +EFI_HANDLE + +image +, EFI_HANDLE +dev +, +CHAR16 + * +swa_fe +) + +69 +EFI_STATUS + +us +; + +70 +EFI_HANDLE + +hd +; + +71 +EFI_DEVICE_PATH + * +dp +; + +74 +dp + = + `FeDeviPh +( +dev +, +swa_fe +); + +75 i( +dp + = +NULL +) { + +76 + `ERR_PRT +(( +L +"Cn cFePh f %s", +swa_fe +)); + +79 +us + = +BS +-> + `LdImage +(0, +image +, +dp +, +NULL +, 0, & +hd +); + +80 i( + `EFI_ERROR +( +us +)) { + +81 + `VERB_PRT +(3, + `Prt +( +L +"..not found\n")); + +82 + `FePo +( +dp +); + +85 + `VERB_PRT +(3, + `Prt +( +L +"..starting..")); + +87 +us + = +BS +-> + `SImage +( +hd +, 0, 0); + +88 i( + `EFI_ERROR +( +us +)) { + +89 + `VERB_PRT +(3, + `Prt +( +L +"ed (%r)\n", +us +)); + +96 + `VERB_PRT +(3, + `Prt +( +L +"..ok\n")); + +98 + `FePo +( +dp +); + +101 + } +} + +111 +INTN + + +112 + $check_swa +( +EFI_HANDLE + +image +, EFI_HANDLE +dev +, +CHAR16 + * +swa_fe +) + +123  +CHAR16 + * +swa_fames +[] ={ + +124 +L +"\\efi\\intel firmware\\fpswa.efi", + +126 +L +"\\fpswa.efi", + +127 +L +"\\fw\\fpswa.efi", + +128 +L +"\\efi\\fpswa.efi", + +129 +L +"\\efi\\tools\\fpswa.efi", + +130 +L +"\\fpswa.efi", + +131 +L +"fpswa.efi", + +134 +UINTN + +j +, +cou + = ( +swa_fames +)/( +CHAR16 + *); + +135 +INTN + +cook +; + +136 +CHAR16 + +devme +[ +FILENAME_MAXLEN +]; + +138 i( +swa_fe +) { + +139 +INTN + +r +; + +140 +devme +[0] = +CHAR_NULL +; + +141 +r + = + `fs_l_th +( +swa_fe +, +devme +); + +142 i( +r + == -1) { + +143 + `ERR_PRT +(( +L +"FPSWA driv famtolg %s", +swa_fe +)); + +146 i( +devme +[0] ! +CHAR_NULL +) { + +147 i( + `fs_g_devi_hd +( +devme +, & +dev +! +EFI_SUCCESS +) { + +148 + `ERR_PRT +(( +L +" fd devi %f FPSWA driv", +devme +)); + +152  + `do_check_swa +( +image +, +dev +, +swa_fe +); + +155 +cook + = 0; + +156  + `fs_g_xt_devi +( +cook +, +L +"vt", +FILENAME_MAXLEN +, &cook, +devme +, & +dev += +EFI_SUCCESS +) { + +157  +j + = 0; j < +cou +; j++) { + +158 + `VERB_PRT +(3, + `Prt +( +L +"Tryg FPSWA driv %s:%s..", +devme +, +swa_fames +[ +j +])); + +163 + `do_check_swa +( +image +, +dev +, +swa_fames +[ +j +]); + +167 + } +} + + @ia64/gzip.c + +29  + ~ + +30  + ~ + +32  + ~"f.h +" + +33  + ~"o.h +" + +35  + ~"gz.h +" + +37  + ~"ive.h +" + +38  + ~"tjmp.h +" + +40  + #LD_NAME + +L +"gz_64" + + ) + +42  + #memzo +( +s +, +n + + `Memt +(( +VOID + *)(s), 0, (n)) + + ) + +43  + #memy +( +a +, +b +, +n + + `Memy +(( +VOID + *)),(b),)) + + ) + +46  + #WSIZE + 0x8000 + + ) + +49  + #INBUFSIZE + 0x8000 + + ) + +55  + #OF +( +gs + + ) +args + +56  + #FUNC_STATIC +  + + ) + +58  + tuch +; + +59  + tush +; + +60  + tulg +; + +63  + sgmt + { + +64  + maddr +; + +65  + mofft +; + +66  + msize +; + +67  + mbss_sz +; + +68 +UINT8 + + mags +; + +69 } + tgmt_t +; + +71  + #CHUNK_FL_VALID + 0x1 + + ) + +72  + #CHUNK_FL_LOAD + 0x2 + + ) + +73  + #CHUNK_FL_X + 0x4 + + ) + +75  + #CHUNK_CAN_LOAD +( +n + +chunks +[)]. +ags + | +CHUNK_FL_LOAD + + + ) + +76  + #CHUNK_NO_LOAD +( +n + +chunks +[)]. +ags + &~ +CHUNK_FL_LOAD + + + ) + +77  + #CHUNK_IS_LOAD +( +n +( +chunks +[)]. +ags + & +CHUNK_FL_LOAD +) + + ) + +79  + #CHUNK_VALIDATE +( +n + +chunks +[)]. +ags + | +CHUNK_FL_VALID + + + ) + +80  + #CHUNK_INVALIDATE +( +n + +chunks +[)]. +ags + = 0 + + ) + +81  + #CHUNK_IS_VALID +( +n +( +chunks +[)]. +ags + & +CHUNK_FL_VALID +) + + ) + +88  +gmt_t + * + gchunks +; + +89  +gmt_t + * + gcur_chunk +; + +90  +UINTN + + gnchunks +; + +91  +UINTN + + gchunk +; + +92  +UINTN + + gput_fd +; + +93  +VOID + * + gkl_y +, * + gkl_ba +, * + gkl_d +; + +95  +uch + * + gbuf +; + +96  +uch + * + gwdow +; + +97  + gfe_offt +; + +99  + gsize + = 0; + +100  + gr + = 0; + +101  + goutt + = 0; + +104  + #ASCII_FLAG + 0x01 + + ) + +105  + #CONTINUATION + 0x02 + + ) + +106  + #EXTRA_FIELD + 0x04 + + ) + +107  + #ORIG_NAME + 0x08 + + ) + +108  + #COMMENT + 0x10 + + ) + +109  + #ENCRYPTED + 0x20 + + ) + +110  + #RESERVED + 0xC0 + + ) + +112  + #g_by +(( +r + < +size + ? +buf +[r++] : + `fl_buf +()) + + ) + +115 #ifde +INFLATE_DEBUG + + +116  + #As +( +cd +, +msg +{if(!(cd) + `r +(msg);} + + ) + +117  + gdr +; + +118  + #T +( +x + + `Prt +( +L +"l%d:\n", +__LINE__ +); + + ) + +119  + #Tv +( +x +{i( +vbo + + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +120  + #Tvv +( +x +{i( +vbo +>1 + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +121  + #Tc +( +c +, +x +{i( +vbo + && (c) + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +122  + #Tcv +( +c +, +x +{i( +vbo +>1 && (c) + `Prt +( +L +"l%d:\n", +__LINE__ +;} + + ) + +124  + #As +( +cd +, +msg +) + + ) + +125  + #T +( +x +) + + ) + +126  + #Tv +( +x +) + + ) + +127  + #Tvv +( +x +) + + ) + +128  + #Tc +( +c +, +x +) + + ) + +129  + #Tcv +( +c +, +x +) + + ) + +132  +fl_buf +(); + +133  +ush_wdow +(); + +134  +r +(* +m +); + +135  + gbys_out +; + +137  +r +(* +m +); + +139  +jmp_buf + + gjbuf +; + +140  + gr_tu +; + +141  +UINTN + + gf_is_big_dn +; + +144 + $gz_mloc +( +size +) + +146  (*) + `loc +( +size +, 0); + +147 + } +} + +150 + $gz_ +(* +whe +) + +152  + ` +( +whe +); + +153 + } +} + +155  + ~"e.c +" + +162 + $fl_buf +() + +164 +INTN + +exed +, +ėd +; + +165 +EFI_STATUS + +us +; + +167 +exed + = +ėd + = +INBUFSIZE +; + +169 +us + = + `fs_ad +( +put_fd +, +buf +, & +ėd +); + +170 i( + `EFI_ERROR +( +us +)) { + +171 + `r +("elilo: Read failed"); + +173 + `DBG_PRT +(( +L +"%:d %d byo%d bys\n", +LD_NAME +, +ėd +, +exed +)); + +175 +size + = +ėd +; + +176 +r + = 1; + +178  +buf +[0]; + +179 + } +} + +196 + $updc +(* +s +,  +n +) + +198  +c +; + +201 i(! +s +) { + +202 +c + = 0xffffffffL; + +204 +c + = +c +; + +205  +n +--) { + +206 +c + = +c_32_b +[(()^ (* +s +++)) & 0xff] ^ (c >> 8); + +209 +c + = +c +; + +210  +c + ^ 0xffffffffUL; + +211 + } +} + +218 + $r_bufs +() + +220 +outt + = 0; + +221 +r + = 0; + +222 +chunk + = 0; + +223 +cur_chunk + = +NULL +; + +224 +fe_offt + = 0; + +225 + } +} + +228  +le + +UINT64 + + +229 + $bsw64 +( +UINT64 + +v +) + +231 if( +f_is_big_dn + +v + = + `__64_swab64 +(v); + +232  +v +; + +233 + } +} + +235  +le + +UINT32 + + +236 + $bsw32 +( +UINT32 + +v +) + +238 if( +f_is_big_dn + +v + = + `__64_swab32 +(v); + +239  +v +; + +240 + } +} + +242  +le + +UINT16 + + +243 + $bsw16 +( +UINT16 + +v +) + +245 if( +f_is_big_dn + +v + = + `__64_swab16 +(v); + +246  +v +; + +247 + } +} + +249  +INTN + + +250 + $is_vid_hd +( +Elf64_Ehdr + * +ehdr +) + +252 +UINT16 + +ty +, +mache +; + +254 i( +ehdr +-> +e_idt +[ +EI_DATA +] = +ELFDATA2MSB +) { + +255 +ty + = + `__64_swab16 +( +ehdr +-> +e_ty +); + +256 +mache + = + `__64_swab16 +( +ehdr +-> +e_mache +); + +258 +ty + = +ehdr +-> +e_ty +; + +259 +mache + = +ehdr +-> +e_mache +; + +261 + `VERB_PRT +(3, + `Prt +( +L +"class=%dype=%d data=%d machine=%d\n", + +262 +ehdr +-> +e_idt +[ +EI_CLASS +], + +263 +ty +, + +264 +ehdr +-> +e_idt +[ +EI_DATA +], + +265 +mache +)); + +267  +ehdr +-> +e_idt +[ +EI_MAG0 +] == 0x7f + +268 && +ehdr +-> +e_idt +[ +EI_MAG1 +] == 'E' + +269 && +ehdr +-> +e_idt +[ +EI_MAG2 +] == 'L' + +270 && +ehdr +-> +e_idt +[ +EI_MAG3 +] == 'F' + +271 && +ehdr +-> +e_idt +[ +EI_CLASS +] = +ELFCLASS64 + + +272 && +ty + = +ET_EXEC + + +273 && +mache + = +EM_IA_64 + ? 0 : -1; + +274 + } +} + +280 + $check_ovp +( +i +) + +282  +j +; + +283  +nd + = +chunks +[ +i +]. +addr + + chunks[i]. +size +; + +285  +j +=0; j < +nchunks +; j++) { + +286 i( +j + == +i +) ; + +287 i( +chunks +[ +i +]. +addr + >chunks[ +j +].add&& +nd + < (chunks[j].add+ chunks[j]. +size +)) { + +288 + `DBG_PRT +(( +L +"%: segm%d fuy inuded igm%d\n", +LD_NAME +, +i +, +j +)); + +289 + `CHUNK_INVALIDATE +( +i +); + +293 + } +} + +296 + $yze_chunks +() + +298 +INTN + +i +; + +300  +i +=0; i < +nchunks +; i++) { + +301 i( + `CHUNK_IS_VALID +( +i +&& ! + `CHUNK_IS_LOAD +(i) + `check_ovp +(i); + +303 + } +} + +312 + $f_block + (cڡ * +buf +,  +blocksize +) + +314 +Elf64_Ehdr + * +f +; + +315 +Elf64_Phdr + * +phdrs +; + +316 +UINTN + +tٮ_size +, +ges +; + +317 +UINTN + +low_addr +, +max_addr +; + +318 +UINTN + +ld_offt + = 0; + +319 +UINTN + +offs + = 0; + +320 +UINT16 + +phnum +; + +321 +UINTN + +ddr +, +memsz +; + +322 +INTN + +i +; + +324 +f + = ( +Elf64_Ehdr + *) +buf +; + +326 i( + `is_vid_hd +( +f +) == -1)  -1; + +329 +f_is_big_dn + = +f +-> +e_idt +[ +EI_DATA +] = +ELFDATA2MSB + ? 1 : 0; + +332 +offs + = + `bsw64 +( +f +-> +e_phoff +); + +333 +phnum + = + `bsw16 +( +f +-> +e_phnum +); + +335 + `VERB_PRT +(3, { + +336 + `Prt +( +L +"ELF fi%s\n", +f_is_big_dn + ? L"bigndian" : L"littlendian"); + +337 + `Prt +( +L +"Eryo0x%lx\n", + `bsw64 +( +f +-> +e_y +)); + +338 + `Prt +( +L +"%drogm hds\n", +phnum +); + +339 + `Prt +( +L +"%d segmhds\n", + `bsw16 +( +f +-> +e_shnum +)); + +344 i( +offs + + +phnum + * (* +phdrs +> ( +blocksize +) { + +345 + `ERR_PRT +(( +L +"%: ELFrogm hdn if block (%ld)\n", +LD_NAME +, +offs +)); + +349 +kl_y + = (*) + `bsw64 +( +f +-> +e_y +); + +351 i((( +UINTN +) +kl_y + >> 61) != 0) { + +352 + `ERR_PRT +(( +L +"%s: <>ryoivtudds0x%lx : su܋dnyme\n", +LD_NAME +, +kl_y +)); + +355 +phdrs + = ( +Elf64_Phdr + *( +buf + + +offs +); + +357 +low_addr + = ~0; + +358 +max_addr + = 0; + +365 +chunks + = (*) + `loc +(( +gmt +)* +phnum +, 0); + +366 i( +chunks + = +NULL +) { + +367 + `ERR_PRT +(( +L +"%: faedochunk%r\n", +LD_NAME +)); + +370 +nchunks + = +phnum +; + +375  +i + = 0; i < +phnum +; ++i) { + +381 +ddr + = + `bsw64 +( +phdrs +[ +i +]. +p_ddr +); + +382 +memsz + = + `bsw64 +( +phdrs +[ +i +]. +p_memsz +), + +384 +chunks +[ +i +]. +addr + = +ddr +; + +385 +chunks +[ +i +]. +offt + = + `bsw64 +( +phdrs +[i]. +p_offt +); + +386 +chunks +[ +i +]. +size + = + `bsw64 +( +phdrs +[i]. +p_fesz +); + +387 +chunks +[ +i +]. +bss_sz + = + `bsw64 +( +phdrs +[i]. +p_memsz +- bsw64hdrs[i]. +p_fesz +); + +389 + `CHUNK_VALIDATE +( +i +); + +391 i( + `bsw32 +( +phdrs +[ +i +]. +p_ty +! +PT_LOAD +) { + +392 + `CHUNK_NO_LOAD +( +i +); + +393 + `DBG_PRT +(( +L +"%: skpg segm%ld\n", +LD_NAME +, +i +)); + +397 i( + `bsw32 +( +phdrs +[ +i +]. +p_ags +& +PF_X +) + +398 +chunks +[ +i +]. +ags + | +CHUNK_FL_X +; + +400 + `CHUNK_CAN_LOAD +( +i +); + +402 + `VERB_PRT +(3, + +403 + `Prt +( +L +"\n%s : segment %ld vaddr [0x%lx-0x%lx] offset %ld filesz %ld memsz=%ld bss_sz=%ld\n", + +404 +LD_NAME +, + +405 1+ +i +, + +406 +chunks +[ +i +]. +addr +, + +407 +chunks +[ +i +]. +addr ++ + `bsw64 +( +phdrs +[i]. +p_fesz +), + +408 +chunks +[ +i +]. +offt +, + +409 +chunks +[ +i +]. +size +, + +410 +memsz +, + +411 +chunks +[ +i +]. +bss_sz +)); + +413 i( +ddr + < +low_addr +)ow_addr =addr; + +415 i( +ddr + + +memsz + > +max_addr +) max_addr =addr + memsz; + +418 i( +low_addr + & ( +EFI_PAGE_SIZE + - 1)) { + +419 + `ERR_PRT +(( +L +"%:ow_addnمagigd 0x%lx\n", +LD_NAME +, +low_addr +)); + +420  +r +; + +423 + `yze_chunks +(); + +425 + `DBG_PRT +(( +L +"%s : %drogram headersntry=0x%lx\nlowest_addr=0x%lx highest_addr=0x%lx\n", + +426 +LD_NAME +, + +427 +phnum +, +kl_y +, +low_addr +, +max_addr +)); + +429 +tٮ_size + = ( +UINTN +) +max_addr + - (UINTN) +low_addr +; + +430 +ges + = + `EFI_SIZE_TO_PAGES +( +tٮ_size +); + +435 +kl_ba + = (*) +low_addr +; + +436 +kl_d + = (*)( +low_addr + + ( +ges + << +EFI_PAGE_SHIFT +)); + +439 i( + `loc_kmem +((*) +low_addr +, +ges +) == -1) { + +440 +VOID + * +w_addr +; + +442 + `VERB_PRT +(1, ( +L +"%: AoPages(%d, 0x%lxf ked\n", +LD_NAME +, +ges +, +low_addr +)); + +444 i( + `64_n_lo +() == 0) { + +445 + `ERR_PRT +(( +L +"relocation is disabled, cannotoad kernel")); + +446  +r +; + +458 + `VERB_PRT +(1, + `Prt +( +L +"Attemptingoelocate kernel.\n")); + +460 i( + `fd_kl_memy +(( +VOID +* +low_addr +, (VOID* +max_addr +, 256* +MB +, & +w_addr +) == -1) { + +461 + `ERR_PRT +(( +L +"%: fd_kl_memy(0x%lx, 0x%lx, 0x%lx, 0x%lxed\n", +LD_NAME +, +low_addr +, +max_addr +, 256* +MB +, & +ld_offt +)); + +462  +r +; + +465 +ld_offt + = ( +UINTN +( +w_addr + - + `ROUNDDOWN +((UINTN +low_addr +,256* +MB +)); + +467 + `VERB_PRT +(1, ( +L +"low_addr=0x%lxew_addr=0x%lx offt=0x%lx", +low_addr +, +w_addr +, +ld_offt +)); + +472 +kl_ba + = (*(( +UINTN +kl_ba + +ld_offt +); + +473 +kl_d + = (*(( +UINTN +kl_d + +ld_offt +); + +474 +kl_y + = (*(( +UINTN +kl_y + +ld_offt +); + +476  +i + = 0; i < +phnum +; ++i) { + +477 +chunks +[ +i +]. +addr + + +ld_offt +; + +478 +phdrs +[ +i +]. +p_ddr + = ( +Elf64_Addr +(( +UINT64 +phdrs[i].p_dd+ +ld_offt +); + +484 i( + `loc_kmem +((*) +low_addr ++ +ld_offt +, +ges +) == -1) { + +485 + `ERR_PRT +(( +L +"%: AoPages(%d, 0x%lxf ked\n", +LD_NAME +, +ges +, +low_addr ++ +ld_offt +)); + +486 + `ERR_PRT +(( +L +"Roti by 0x%lx byed.\n", +ld_offt +)); + +487  +r +; + +491 +r +: + +492 i( +chunks + + ` +(chunks); + +494 + } +} + +501 + $xtchunk +() + +503  +i +; + +504 +gmt_t + * + +; + +506 + + = +NULL +; + +507  +i +=0; i < +nchunks +; i++) { + +509 i(! + `CHUNK_IS_VALID +( +i +|| ! + `CHUNK_IS_LOAD +(i)) ; + +511 i( +fe_offt + > +chunks +[ +i +]. +offt +) ; + +513 i( + + = +NULL + || +chunks +[ +i +]. +offt + < cp->offset) cp = &chunks[i]; + +515 +cur_chunk + = + +; + +516 + } +} + +524 + $ush_wdow +() + +526 cڡ +CHAR8 + +hic݋r +[4] = { '|' , '/' , '-' , '\\' }; + +527  +UINTN + +hi_cou +; + +528  +gmt + * + +; + +529 * +c +, * +d +; + +530  +t +; + +532 i(! +outt +) ; + +534 + `DBG_PRT +(( +L +"%: flush_wdow ou=%d fe_offt=%ld\n", +LD_NAME +, +outt +, +fe_offt +)); + +536 + `Prt +( +L +"%c\b", +hic݋r +[ +hi_cou +++%4]); + +538 + `updc +( +wdow +, +outt +); + +543 i(! +bys_out +) { + +544 i( + `f_block +( +wdow +, +outt +< 0 + `r +("invalidxec header"); + +545 + `xtchunk +(); + +548 +bys_out + + +outt +; + +549 +c + = +wdow +; + +550 + +: + +552 i( + `check_abt +(= +EFI_SUCCESS + +ld_abt +; + +554 + + = +cur_chunk +; + +555 i( + + = +NULL + || +fe_offt + + +outt + <-> +offt +) { + +556 +fe_offt + + +outt +; + +561 i( +fe_offt + < + +-> +offt +) { + +562  +sk + = + +-> +offt + - +fe_offt +; + +564 +c + + +sk +; + +565 +fe_offt + + +sk +; + +566 +outt + - +sk +; + +568 +d + = (*) + +-> +addr + + ( +fe_offt + - cp-> +offt +); + +570 +t + = + +-> +offt + + cp-> +size + - +fe_offt +; + +572 i( +t + > +outt +) cnt = outcnt; + +574 + `Memy +( +d +, +c +, +t +); + +575 i( + +-> +ags + & +CHUNK_FL_X +) + +576 + `ush_dche + ( +d +, +t +); + +578 +fe_offt + + +t +; + +579 +outt + - +t +; + +580 +c + + +t +; + +583 i( +fe_offt + = + +-> +offt + + cp-> +size +) { + +584 i( + +-> +bss_sz +) { + +585 +d + = (*) + +-> +addr + + cp-> +size +; + +586 + `Memt +( +d +, 0, + +-> +bss_sz +); + +588 + `xtchunk +(); + +590 i( +outt + + +; + +593 +ld_abt +: + +594 + `_kmem +(); + +595 +r_tu + = +ELILO_LOAD_ABORTED +; + +596 + `lgjmp +( +jbuf +, 1); + +597 + } +} + +600 + $r +(* +x +) + +602 + `ERR_PRT +(( +L +"%: %a", +LD_NAME +, +x +)); + +604 + `lgjmp +( +jbuf +,1); + +605 + } +} + +607 +INT32 + + +608 + $decomess_kl +( +VOID +) + +610 +INT32 + +t +; + +612 + `r_bufs +(); + +613 + `makec +(); + +614 + `Prt +( +L +"Uncompressing Linux... "); + +615 +t + = + `gunz +(); + +616 i( +t + =0 + `Prt +( +L +"done\n"); + +617  +t + == 0 ? 0 : -1; + +618 + } +} + +621 + $gunz_kl +( +fs_fd_t + +fd +, +kdesc_t + * +kd +) + +623  +t + = -1; + +625 +r_tu + = +ELILO_LOAD_ERROR +; + +627 +wdow + = (*) + `loc +( +WSIZE +, 0); + +628 i( +wdow + = +NULL +) { + +629 + `ERR_PRT +(( +L +"%:o ouuwdow faed\n", +LD_NAME +)); + +633 +buf + = (*) + `loc +( +INBUFSIZE +, 0); + +634 i( +buf + = +NULL +) { + +635 + `ERR_PRT +(( +L +"%:o iuwdow faedr\n", +LD_NAME +)); + +636  +r +; + +639 +put_fd + = +fd +; + +640 +size + = 0; + +641 +bys_out + = 0; + +643 i( + `tjmp +( +jbuf +=1 +r +; + +646 +t + = + `decomess_kl +(); + +648 +r +: + +649 i( +wdow + + ` +(window); + +650 i( +buf + + ` +(inbuf); + +652 i( +t + == 0) { + +653 +kd +-> +ky + = +kl_y +; + +654 +kd +-> +kd + = +kl_d +; + +655 +kd +-> +kt + = +kl_ba +; + +656 +r_tu + = +ELILO_LOAD_SUCCESS +; + +658  +r_tu +; + +659 + } +} + + @ia64/gzip_loader.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"ld.h +" + +31  + ~"gz.h +" + +33  + #LD_NAME + +L +"gz_64" + + ) + +35  +INTN + + +36 + $gz_obe_fm +( +CHAR16 + * +kme +) + +38 +UINT8 + +buf +[4]; + +39 +EFI_STATUS + +us +; + +40 +INTN + +t + = -1; + +41 +UINTN + +size +; + +42 +fs_fd_t + +fd +; + +44 +us + = + `fs_ݒ +( +kme +, & +fd +); + +45 i( + `EFI_ERROR +( +us +))  -1; + +47 +size + = ( +buf +); + +48 +us + = + `fs_ad +( +fd +, +buf +, & +size +); + +50 i( + `EFI_ERROR +( +us +|| +size + !( +buf +) +r +; + +52 +t + = + `gz_obe +( +buf +, (buf)); + +53 +r +: + +54 + `fs_o +( +fd +); + +55  +t +; + +56 + } +} + +59  +INTN + + +60 + $gz_ld_kl +( +CHAR16 + * +kme +, +kdesc_t + * +kd +) + +62 +EFI_STATUS + +us +; + +63 +INT32 + +t +; + +64 +fs_fd_t + +fd +; + +66 +us + = + `fs_ݒ +( +kme +, & +fd +); + +67 i( + `EFI_ERROR +( +us +) +ELILO_LOAD_ERROR +; + +69 +t + = + `gunz_kl +( +fd +, +kd +); + +71 + `fs_o +( +fd +); + +73  +t +; + +74 + } +} + +76 +ld_s_t + + ggz_ld +={ + +77 +NULL +, + +78 +LD_NAME +, + +79 +gz_obe_fm +, + +80 +gz_ld_kl + + + @ia64/plain_loader.c + +29  + ~ + +30  + ~ + +32  + ~"o.h +" + +33  + ~"ld.h +" + +34  + ~"f.h +" + +35  + ~"ive.h +" + +37  + #LD_NAME + +L +"a_f64" + + ) + +39  + #PLAIN_MIN_BLOCK_SIZE + ( +Elf64_Ehdr + + + ) + +41  + #SKIPBUFSIZE + 2048 + + ) + +42  +CHAR8 + * + gsk_bufr +; + +43  +UINTN + + gsk_bufsize +; + +44  +UINTN + + gf_is_big_dn +; + +46  +le + +UINT64 + + +47 + $bsw64 +( +UINT64 + +v +) + +49 if( +f_is_big_dn + +v + = + `__64_swab64 +(v); + +50  +v +; + +51 + } +} + +53  +le + +UINT32 + + +54 + $bsw32 +( +UINT32 + +v +) + +56 if( +f_is_big_dn + +v + = + `__64_swab32 +(v); + +57  +v +; + +58 + } +} + +60  +le + +UINT16 + + +61 + $bsw16 +( +UINT16 + +v +) + +63 if( +f_is_big_dn + +v + = + `__64_swab16 +(v); + +64  +v +; + +65 + } +} + +67  +INTN + + +68 + $is_vid_hd +( +Elf64_Ehdr + * +ehdr +) + +70 +UINT16 + +ty +, +mache +; + +72 i( +ehdr +-> +e_idt +[ +EI_DATA +] = +ELFDATA2MSB +) { + +73 +ty + = + `__64_swab16 +( +ehdr +-> +e_ty +); + +74 +mache + = + `__64_swab16 +( +ehdr +-> +e_mache +); + +76 +ty + = +ehdr +-> +e_ty +; + +77 +mache + = +ehdr +-> +e_mache +; + +79 + `DBG_PRT +(( +L +"class=%dype=%d data=%d machine=%d\n", + +80 +ehdr +-> +e_idt +[ +EI_CLASS +], + +81 +ty +, + +82 +ehdr +-> +e_idt +[ +EI_DATA +], + +83 +mache +)); + +85  +ehdr +-> +e_idt +[ +EI_MAG0 +] == 0x7f + +86 && +ehdr +-> +e_idt +[ +EI_MAG1 +] == 'E' + +87 && +ehdr +-> +e_idt +[ +EI_MAG2 +] == 'L' + +88 && +ehdr +-> +e_idt +[ +EI_MAG3 +] == 'F' + +89 && +ehdr +-> +e_idt +[ +EI_CLASS +] = +ELFCLASS64 + + +90 && +ty + = +ET_EXEC + + +91 && +mache + = +EM_IA_64 + ? 0 : -1; + +92 + } +} + +94  +INTN + + +95 + $a_obe +( +CHAR16 + * +kme +) + +97 +Elf64_Ehdr + +ehdr +; + +98 +EFI_STATUS + +us +; + +99 +INTN + +t + = -1; + +100 +fs_fd_t + +fd +; + +101 +UINTN + +size + = ( +ehdr +); + +103 +us + = + `fs_ݒ +( +kme +, & +fd +); + +104 i( + `EFI_ERROR +( +us +))  -1; + +106 +us + = + `fs_ad +( +fd +, & +ehdr +, & +size +); + +108 i( + `EFI_ERROR +( +us +|| +size + !( +ehdr +) +r +; + +110 +t + = + `is_vid_hd +(& +ehdr +); + +111 +r +: + +112 + `fs_o +( +fd +); + +113  +t +; + +114 + } +} + +121  +INTN + + +122 + $sk_bys +( +fs_fd_t + +fd +, +UINTN + +cuos +, UINTN +wpos +) + +124 +EFI_STATUS + +us +; + +125 +UINTN + +n +, +sk +; + +127 +sk + = +wpos + - +cuos +; + +130 +us + = + `fs_ek +( +fd +, +wpos +); + +131 i( +us + = +EFI_SUCCESS +)  0; + +133 i( +us + ! +EFI_UNSUPPORTED + +r +; + +137 i( +sk_bufr + = +NULL +) { + +138 +sk_bufsize + = + `MAX +( +sk +, +SKIPBUFSIZE +); + +139 +sk_bufr +( +CHAR8 + *) + `loc +( +sk_bufsize +, +EfiLdDa +); + +140 i( +sk_bufr + = +NULL +)  -1; + +142  +sk +) { + +143 +n + = +sk + > +sk_bufsize +? skip_bufsize : skip; + +145 +us + = + `fs_ad +( +fd +, +sk_bufr +, & +n +); + +146 i( + `EFI_ERROR +( +us +) +r +; + +148 +sk + -= +n +; + +152 +r +: + +153 + `ERR_PRT +(( +L +"%: cn sk %d bys\n", +LD_NAME +, +n +)); + +155 + } +} + +157  +INTN + + +158 + $ld_f +( +fs_fd_t + +fd +, +kdesc_t + * +kd +) + +160 +Elf64_Ehdr + +ehdr +; + +161 +Elf64_Phdr + * +phdrs +; + +162 +EFI_STATUS + +us +; + +163 +INTN + +t + = +ELILO_LOAD_ERROR +; + +164 +UINTN + +i +, +tٮ_size + = 0; + +165 +UINTN + +ges +, +size +, +bss_sz +, +osize +; + +166 +UINTN + +offs + = 0; + +167 +VOID + * +low_addr + = (VOID *)~0; + +168 +VOID + * +max_addr + = (VOID *)0; + +169 +UINTN + +ld_offt + = 0; + +170 +UINTN + +ddr +, +memsz +, +fesz +, +poffs +; + +171 +UINT16 + +phnum +; + +173 + `Prt +( +L +"Loading Linux... "); + +175 +size + = ( +ehdr +); + +177 +us + = + `fs_ad +( +fd +, & +ehdr +, & +size +); + +178 i( + `EFI_ERROR +( +us +|| +size + < ( +ehdr +) +ELILO_LOAD_ERROR +; + +180 +offs + + +size +; + +185 i( + `is_vid_hd +(& +ehdr +) == -1) { + +186 + `ERR_PRT +(( +L +"%:ه64-b fe\n", +LD_NAME +)); + +187  +ELILO_LOAD_ERROR +; + +191 +f_is_big_dn + = +ehdr +. +e_idt +[ +EI_DATA +] = +ELFDATA2MSB + ? 1 : 0; + +193 + `VERB_PRT +(3, { + +194 + `Prt +( +L +"ELF fi%s\n", +f_is_big_dn + ? L"bigndian" : L"littlendian"); + +195 + `Prt +( +L +"Eryo0x%lx\n", + `bsw64 +( +ehdr +. +e_y +)); + +196 + `Prt +( +L +"%drogm hds\n", + `bsw16 +( +ehdr +. +e_phnum +)); + +197 + `Prt +( +L +"%d segmhds\n", + `bsw16 +( +ehdr +. +e_shnum +)); + +200 +phnum + = + `bsw16 +( +ehdr +. +e_phnum +); + +202 i( + `sk_bys +( +fd +, +offs +, + `bsw64 +( +ehdr +. +e_phoff +)) != 0) { + +203 + `ERR_PRT +(( +L +"%: sk%ld f܅hdred", +LD_NAME +, +offs +)); + +204  +ELILO_LOAD_ERROR +; + +206 +offs + = + `bsw64 +( +ehdr +. +e_phoff +); + +208 +size + = +osize + = +phnum +*( +Elf64_Phdr +); + +210 + `DBG_PRT +(( +L +"%:hdrlo %d bysizeof=%dsize=%d\n", +LD_NAME +, +size +,( +Elf64_Phdr +), + `bsw16 +( +ehdr +. +e_phtsize +))); + +212 +phdrs + = ( +Elf64_Phdr + *) + `loc +( +size +, 0); + +213 i( +phdrs + = +NULL +) { + +214 + `ERR_PRT +(( +L +"%:ohdred", +LD_NAME +)); + +215  +ELILO_LOAD_ERROR +; + +218 +us + = + `fs_ad +( +fd +, +phdrs +, & +size +); + +219 i( + `EFI_ERROR +( +us +|| +size + ! +osize +) { + +220 + `ERR_PRT +(( +L +"%:dhdred", +LD_NAME +, +us +)); + +221  +out +; + +223 +offs + + +size +; + +229  +i + = 0; i < +phnum +; i++) { + +231 +ddr + = + `bsw64 +( +phdrs +[ +i +]. +p_ddr +); + +232 +memsz + = + `bsw64 +( +phdrs +[ +i +]. +p_memsz +); + +234 + `DBG_PRT +(( +L +"Phdr %daddr [0x%lx-0x%lx] offset %ld" + +236 1+ +i +, + +237 +ddr +, + +238 +ddr ++ + `bsw64 +( +phdrs +[ +i +]. +p_fesz +), + +239 + `bsw64 +( +phdrs +[ +i +]. +p_offt +), + +240 + `bsw64 +( +phdrs +[ +i +]. +p_fesz +), + +241 +memsz +, + +242 +memsz + - + `bsw64 +( +phdrs +[ +i +]. +p_fesz +), + `bsw32 +hdrs[i]. +p_ty +))); + +244 i( + `bsw32 +( +phdrs +[ +i +]. +p_ty +! +PT_LOAD +) ; + +247 i( +ddr + < ( +UINTN +) +low_addr +low_add( +VOID + *)paddr; + +249 i( +ddr + + +memsz + > ( +UINTN +) +max_addr +) + +250 +max_addr + = ( +VOID + *) +ddr + + +memsz +; + +253 i(( +UINTN +) +low_addr + & ( +EFI_PAGE_SIZE + - 1)) { + +254 + `ERR_PRT +(( +L +"%: klowdds0x%lxمagigd\n", +LD_NAME +, +low_addr +)); + +255  +out +; + +259 +tٮ_size + = ( +UINTN +) +max_addr + - (UINTN) +low_addr +; + +262 +ges + = + `EFI_SIZE_TO_PAGES +( +tٮ_size +); + +267 +kd +-> +kt + = +low_addr +; + +268 +kd +-> +kd + = +low_addr ++ ( +ges + << +EFI_PAGE_SHIFT +); + +273 +kd +-> +ky + = ( +VOID + *) + `bsw64 +( +ehdr +. +e_y +); + +275 i((( +UINTN +) +kd +-> +ky + >> 61) != 0) { + +276 + `ERR_PRT +(( +L +"%s: <>ryoivtudds0x%lx : su܋dnyme\n", +LD_NAME +, +kd +-> +ky +)); + +279 + `VERB_PRT +(3, { + +280 + `Prt +( +L +"Lowest PhysAddr: 0x%lx\nTotalMemSize:%d bytes (%dages)\n", + +281 +low_addr +, +tٮ_size +, +ges +); + +282 + `Prt +( +L +"KȒy @ 0x%lx\n", +kd +-> +ky +); + +288 i( + `loc_kmem +( +low_addr +, +ges +) == -1) { + +289 +VOID + * +w_addr +; + +291 + `VERB_PRT +(1, ( +L +"%: AoPages(%d, 0x%lxf ked\n", +LD_NAME +, +ges +, +low_addr +)); + +293 i( + `64_n_lo +() == 0) { + +294 + `ERR_PRT +(( +L +"relocation is disabled, cannotoad kernel")); + +295  +out +; + +307 + `Prt +( +L +"Attemptingoelocate kernel.\n"); + +308 i( + `fd_kl_memy +( +low_addr +, +max_addr +, 256* +MB +, & +w_addr +) == -1) { + +309 + `ERR_PRT +(( +L +"%: fd_kl_memy(0x%lx, 0x%lx, 0x%lx, 0x%lxed\n", +LD_NAME +, +low_addr +, +max_addr +, 256* +MB +, & +ld_offt +)); + +310  +out +; + +313 +ld_offt + = ( +UINTN +( +w_addr + - + `ROUNDDOWN +((UINTN +low_addr +,256* +MB +)); + +315 + `VERB_PRT +(3, + `Prt +( +L +"low_addr=0x%lxew_addr=0x%lx offt=0x%lx", +low_addr +, +w_addr +, +ld_offt +)); + +320 +low_addr + = ( +VOID +*(( +UINTN +low_add+ +ld_offt +); + +321 +max_addr + = ( +VOID +*(( +UINTN +max_add+ +ld_offt +); + +322 +kd +-> +kt + = ( +VOID + *(( +UINTN +kd->k+ +ld_offt +); + +323 +kd +-> +kd + = ( +VOID + *(( +UINTN +kd->kd + +ld_offt +); + +324 +kd +-> +ky + = ( +VOID + *(( +UINTN +kd->ky + +ld_offt +); + +329 i( + `loc_kmem +( +low_addr +, +ges +) == -1) { + +330 + `ERR_PRT +(( +L +"%: AoPages(%d, 0x%lxf ked\n", +LD_NAME +, +ges +, +low_addr +)); + +331 + `ERR_PRT +(( +L +"Roti by 0x%lx byed.\n", +ld_offt +)); + +332  +out +; + +336 + `VERB_PRT +(1, + `Prt +( +L +"Pressny keyo interrupt\n")); + +342  +i + = 0; i < +phnum +; i++) { + +347 i( + `bsw32 +( +phdrs +[ +i +]. +p_ty +! +PT_LOAD +) ; + +349 +poffs + = + `bsw64 +( +phdrs +[ +i +]. +p_offt +); + +351 +size + = +poffs + - +offs +; + +353 + `VERB_PRT +(3, + `Prt +( +L +"\noff=%ldoffs=%ld size=%ld\n", +offs +, +poffs +, +size +)); + +355 +fesz + = + `bsw64 +( +phdrs +[ +i +]. +p_fesz +); + +359 +phdrs +[ +i +]. +p_ddr + = ( +Elf64_Addr +(( +UINTN + + `bsw64 +hdrs[i].p_ddr+ +ld_offt +); + +364 i( +size + && + `sk_bys +( +fd +, +offs +, +poffs +!0 +out_kl +; + +369 +offs + + +size +; + +374 +bss_sz + = + `bsw64 +( +phdrs +[ +i +]. +p_memsz +- +fesz +; + +376 + `VERB_PRT +(4, { + +377 + `Prt +( +L +"\nHd #%d\n", +i +); + +378 + `Prt +( +L +"off%ld\n", +poffs +); + +379 + `Prt +( +L +"Phyadd0x%lx\n", +phdrs +[ +i +]. +p_ddr +); + +380 + `Prt +( +L +"BSS siz%ld bys\n", +bss_sz +); + +381 + `Prt +( +L +"sk=%ld offs=%ld\n", +size +, +offs +); + +387 +t + = + `ad_fe +( +fd +, +fesz +, ( +CHAR8 + *) +phdrs +[ +i +]. +p_ddr +); + +388 i( +t + = +ELILO_LOAD_ABORTED + +ld_abt +; + +389 i( +t + = +ELILO_LOAD_ERROR + +out +; + +390 i( + `bsw32 +( +phdrs +[ +i +]. +p_ags +& +PF_X +) + +391 + `ush_dche + (( +CHAR8 + *) +phdrs +[ +i +]. +p_ddr +, +fesz +); + +396 +offs + + +fesz +; + +401 i( +bss_sz + + `Memt +(( +VOID + * +phdrs +[ +i +]. +p_ddr ++ +fesz +, 0, bss_sz); + +404 + ` +( +phdrs +); + +406 + `Prt +( +L +"..done\n"); + +407  +ELILO_LOAD_SUCCESS +; + +409 +ld_abt +: + +410 + `Prt +( +L +"..Aborted\n"); + +411 +t + = +ELILO_LOAD_ABORTED +; + +412 +out_kl +: + +414 + `_kmem +(); + +415 +out +: + +416 + ` +( +phdrs +); + +417  +t +; + +418 + } +} + +420  +INTN + + +421 + $a_ld_kl +( +CHAR16 + * +kme +, +kdesc_t + * +kd +) + +423 +INTN + +t +; + +424 +fs_fd_t + +fd +; + +425 +EFI_STATUS + +us +; + +430 +us + = + `fs_ݒ +( +kme +, & +fd +); + +431 i( + `EFI_ERROR +( +us +) +ELILO_LOAD_ERROR +; + +433 + `Prt +( +L +"Ldg %s...", +kme +); + +435 +t + = + `ld_f +( +fd +, +kd +); + +437 + `fs_o +( +fd +); + +442 i( +sk_bufr +) { + +443 + ` +( +sk_bufr +); + +445 +sk_bufr + = +NULL +; + +447  +t +; + +448 + } +} + +450 +ld_s_t + + ga_ld +={ + +451 +NULL +, + +452 +LD_NAME +, + +453 +a_obe +, + +454 +a_ld_kl + + + @ia64/private.h + +26 #ide +__ELILO_PRIVATE_IA64_H__ + + +27  + #__ELILO_PRIVATE_IA64_H__ + + + ) + +29 +INTN + +check_swa +( +EFI_HANDLE +, EFI_HANDLE, +CHAR16 + *); + +30 +INTN + +quy_swa +( +VOID + **); + +32 +INTN + +64_n_lo +(); + +34  +ush_dche + ( +CHAR8 + * +addr +, +UINT64 + +n +); + + @ia64/setjmp.h + +22  + #_JBLEN + 70 + + ) + +25  + tjmp_buf +[ +_JBLEN +] + t__ibu__ + (( + tigd + (16))); + +27  +tjmp + ( +jmp_buf + +__v +); + +28  +lgjmp + ( +jmp_buf + +__v +,  +__v +); + + @ia64/sysdeps.h + +32 #ide +__ELILO_SYSDEPS_IA64_H__ + + +33  + #__ELILO_SYSDEPS_IA64_H__ + + + ) + +35  + #ELILO_ARCH + "IA-64" + + ) + +38 +VOID + +Memt +(VOID *, +INTN +, +UINTN +); + +39 +VOID + +Memy +(VOID *, VOID *, +UINTN +); + +41 +VOID + +sysd_gi_tis +(VOID); + +46  + s64_bo_ms + { + +52 +UINTN + + mcommd_le +; + +53 +UINTN + + mefi_syab +; + +54 +UINTN + + mefi_memm +; + +55 +UINTN + + mefi_memm_size +; + +56 +UINTN + + mefi_memdesc_size +; + +57 +UINT32 + + mefi_memdesc_vsi +; + +59 +UINT16 + + mnum_cs +; + +60 +UINT16 + + mnum_rows +; + +61 +UINT16 + + mig_x +; + +62 +UINT16 + + mig_y +; + +63 } + mcse_fo +; + +64 +UINTN + + mswa +; + +65 +UINTN + + mrd_t +; + +66 +UINTN + + mrd_size +; + +68 +UINTN + + mvmcode_t +; + +69 +UINTN + + mvmcode_size +; + +70 +UINTN + + mld_addr +; + +71 +UINTN + + mld_size +; + +73 } + tbo_ms_t +; + +75  + ssys_img_tis + { + +76 +UINT8 + + mdummy +; + +77 +UINT8 + + mlow_loti +; + +78 } + tsys_img_tis_t +; + +83  +le +  + +84 + $t_kl +( +VOID + * +ky +, VOID * +bp +) + +86 +asm + vީ("mov28=%1; br.tk.w %0" :: "b"( +ky +),"r"( +bp +)); + +87 + } +} + +89  +le + cڡ +UINT64 + + +90 + $__64_swab64 + ( +UINT64 + +x +) + +92 +UINT64 + +su +; + +94 +asm + vީ("mux1 %0=%1,@v" : "" ( +su +: "r" ( +x +)); + +95  +su +; + +96 + } +} + +98  +le + cڡ +UINT32 + + +99 + $__64_swab32 + ( +UINT32 + +x +) + +101  + `__64_swab64 +( +x +) >> 32; + +102 + } +} + +104  +le + cڡ +UINT16 + + +105 + $__64_swab16 +( +UINT16 + +x +) + +107  + `__64_swab64 +( +x +) >> 48; + +108 + } +} + + @ia64/system.c + +29  + ~ + +30  + ~ + +32  + ~"o.h +" + +33  + ~"ld.h +" + +34  + ~"ive.h +" + +36 +ld_s_t + +a_ld +, +gz_ld +; + +41 +INTN + + +42 + $sysds__bo_ms +( +bo_ms_t + * +bp +, +CHAR8 + * +cmdle +, +memdesc_t + * +rd +, memdesc_* +vmcode +, +UINTN + * +cook +) + +44 +UINTN + +cs +, +rows +; + +45 +SIMPLE_TEXT_OUTPUT_INTERFACE + * +cout +; + +46 +EFI_STATUS + +us +; + +47 +mm_desc_t + +mdesc +; + +54 + `quy_swa +(( +VOID + **)& +bp +-> +swa +); + +56 i( + `g_memm +(& +mdesc +) == -1)  -1; + +58 + `DBG_PRT +(( +L +"G memy m @ 0x%lx (%d bys)", +mdesc +. +md +, mdesc. +m_size +)); + +60 +bp +-> +efi_syab + = ( +UINTN +) +syab +; + +61 +bp +-> +efi_memm + = ( +UINTN +) +mdesc +. +md +; + +62 +bp +-> +efi_memm_size + = +mdesc +. +m_size +; + +63 +bp +-> +efi_memdesc_size + = +mdesc +. +desc_size +; + +64 +bp +-> +efi_memdesc_vsi + = +mdesc +. +desc_vsi +; + +65 +bp +-> +commd_le + = ( +UINTN +) +cmdle +; + +66 +bp +-> +rd_t + = ( +UINTN + +rd +-> +t_addr +; + +67 +bp +-> +rd_size + = +rd +-> +size +; + +68 + `DBG_PRT +(( +L +"G inrd @ 0x%lx (%d bys)", +rd +-> +t_addr +, inrd-> +size +)); + +70 +bp +-> +vmcode_t + = ( +UINTN + +vmcode +-> +t_addr +; + +71 +bp +-> +vmcode_size + = +vmcode +-> +size +; + +72 + `DBG_PRT +(( +L +"G vmcod@ 0x%lx (%d bys)", +vmcode +-> +t_addr +, vmcode-> +size +)); + +75 +cout + = +syab +-> +COut +; + +76 +us + = +cout +-> + `QuyMode +(cout, cout-> +Mode +->Mode, & +cs +, & +rows +); + +77 i( + `EFI_ERROR +( +us +)) { + +78 + `ERR_PRT +(( +L +"bo_mQuyModed %r", +us +)); + +79  +r +; + +81 + `DBG_PRT +(( +L +"Got console info: cols=%dows=%d x=%d y=%d", + +82 +cs +, +rows +, +cout +-> +Mode +-> +CursCumn +, cout->Mode-> +CursRow +)); + +84 +bp +-> +cse_fo +. +num_cs + = +cs +; + +85 +bp +-> +cse_fo +. +num_rows + = +rows +; + +86 +bp +-> +cse_fo +. +ig_x + = +cout +-> +Mode +-> +CursCumn +; + +87 +bp +-> +cse_fo +. +ig_y + = +cout +-> +Mode +-> +CursRow +; + +89 * +cook + = +mdesc +.cookie; + +92 +r +: + +94 + `_memm +(& +mdesc +); + +97 + } +} + +99 +VOID + + +100 + $sysds__bo_ms +( +bo_ms_t + * +bp +) + +102 +mm_desc_t + +md +; + +104 + `Memt +(& +md +, 0, (md)); + +106 +md +.md = ( +VOID + *) +bp +-> +efi_memm +; + +108 + `_memm +(& +md +); + +109 + } +} + +111 +INTN + + +112 + $sysds_ +( +EFI_HANDLE + +dev +) + +114 + `ld_gi +(& +a_ld +); + +115 + `ld_gi +(& +gz_ld +); + +118 + } +} + +120 +INTN + + +121 + $sysds_rd_g_addr +( +kdesc_t + * +kd +, +memdesc_t + * +imem +) + +135 +imem +-> +t_addr + = ( +VOID + *) + `ROUNDUP +(( +UINTN +) +kd +-> +kd +, +EFI_PAGE_SIZE +); + +137 +imem +-> +t_addr + = 0; + +141 + } +} + +145 + $ush_dche + ( +CHAR8 + * +addr +, +UINT64 + +n +) + +148 +UINT64 + +a + = (UINT64) +addr + & ~0x1f; + +150 + `VERB_PRT +(3, + `Prt +( +L +"Flush 0x%lx-", +a +)); + +153  +n + = (+ 31& ~0x1f; > 0; -0x20, +a + += 0x20) + +154 +asm + vީ("f%0" : : "r" ( +a +)); + +156 +asm + volatile (";; sync.i;; srlz.i;;"); + +158 + `VERB_PRT +(3, + `Prt +( +L +"0x%lx\n", +a +)); + +159 + } +} + + @inflate.c + +1  + #DEBG +( +x +) + + ) + +2  + #DEBG1 +( +x +) + + ) + +106 #ifde +RCSID + + +107  + grcsid +[] = "#Id: inflate.c,v 0.14 1993/06/10 13:27:04 jloup Exp #"; + +110 #ide +FUNC_STATIC + + +112 #i +defed +( +STDC_HEADERS +|| defed( +HAVE_STDLIB_H +) + +113  + ~ + +114  + ~ + +117  + ~"gz.h +" + +118  + #FUNC_STATIC + + + ) + +121  + #ide + +wdow + + + ) + +130  + shu + { + +131 +uch + + me +; + +132 +uch + + mb +; + +134 +ush + + mn +; + +135  +hu + * + mt +; + +136 } + mv +; + +141 +FUNC_STATIC +  +hu_bud + +OF +((*, , , + +142 cڡ +ush + *, cڡ ush *,  +hu + **, *)); + +143 +FUNC_STATIC +  +hu_ + +OF +(( +hu + *)); + +144 +FUNC_STATIC +  +e_codes + +OF +(( +hu + *, huft *, , )); + +145 +FUNC_STATIC +  +e_ed + +OF +(()); + +146 +FUNC_STATIC +  +e_fixed + +OF +(()); + +147 +FUNC_STATIC +  +e_dymic + +OF +(()); + +148 +FUNC_STATIC +  +e_block + +OF +((*)); + +149 +FUNC_STATIC +  +e + +OF +(()); + +161  + #wp + +outt + + + ) + +162  + #ush_ouut +( +w +( +wp +=(w), + `ush_wdow +()) + + ) + +165 cڡ  + gbd +[] = { + +167 cڡ +ush + + gns +[] = { + +171 cڡ +ush + + gxt +[] = { + +174 cڡ +ush + + gdi +[] = { + +178 cڡ +ush + + gdext +[] = { + +215 +FUNC_STATIC + +ulg + + gbb +; + +216 +FUNC_STATIC +  + gbk +; + +218 +FUNC_STATIC + cڡ +ush + + gmask_bs +[] = { + +224  + #NEXTBYTE +(( +uch +) + `g_by +() + + ) + +225  + #NEEDBITS +( +n +{ +k +<)){ +b +|=(( +ulg +) + `NEXTBYTE +())<>=); +k +-=);} + + ) + +262 +FUNC_STATIC + cڡ  + glbs + = 9; + +263 +FUNC_STATIC + cڡ  + gdbs + = 6; + +267  + #BMAX + 16 + + ) + +268  + #N_MAX + 288 + + ) + +271 +FUNC_STATIC +  + ghus +; + +274 +FUNC_STATIC +  + $hu_bud +( +b +, +n +, +s +, +d +, +e +, +t +, +m +) + +275 * +b +; + +276  +n +; + +277  +s +; + +278 cڡ +ush + * +d +; + +279 cڡ +ush + * +e +; + +280  +hu + ** +t +; + +281 * +m +; + +288  +a +; + +289  +c +[ +BMAX ++1]; + +290  +f +; + +291  +g +; + +292  +h +; + +293  +i +; + +294  +j +; + +295  +k +; + +296  +l +; + +297 * +p +; + +298  +hu + * +q +; + +299  +hu + +r +; + +300  +hu + * +u +[ +BMAX +]; + +301  +v +[ +N_MAX +]; + +302  +w +; + +303  +x +[ +BMAX ++1]; + +304 * +xp +; + +305  +y +; + +306  +z +; + +308 + `DEBG +("huft1 "); + +311 + `memzo +( +c +, (c)); + +313 +p + = +b +; +i + = +n +; + +315 + `Tcv +(* +p +, ( +dr +, ( +n +- +i + >= ' ' &&-i <= '~' ? "%c %d\n" : "0x%x %d\n"), + +316 +n +- +i +, * +p +)); + +317 +c +[* +p +]++; + +318 +p +++; + +319 } -- +i +); + +320 i( +c +[0] = +n +) + +322 * +t + = ( +hu + *) +NULL +; + +323 * +m + = 0; + +327 + `DEBG +("huft2 "); + +330 +l + = * +m +; + +331  +j + = 1; j < +BMAX +; j++) + +332 i( +c +[ +j +]) + +334 +k + = +j +; + +335 i(() +l + < +j +) + +336 +l + = +j +; + +337  +i + = +BMAX +; i; i--) + +338 i( +c +[ +i +]) + +340 +g + = +i +; + +341 i(() +l + > +i +) + +342 +l + = +i +; + +343 * +m + = +l +; + +345 + `DEBG +("huft3 "); + +348  +y + = 1 << +j +; j < +i +; j++, y <<= 1) + +349 i(( +y + - +c +[ +j +]) < 0) + +351 i(( +y + - +c +[ +i +]) < 0) + +353 +c +[ +i +] + +y +; + +355 + `DEBG +("huft4 "); + +358 +x +[1] = +j + = 0; + +359 +p + = +c + + 1; +xp + = +x + + 2; + +360 -- +i +) { + +361 * +xp +++ = ( +j + +* +p +++); + +364 + `DEBG +("huft5 "); + +367 +p + = +b +; +i + = 0; + +369 i(( +j + = * +p +++) != 0) + +370 +v +[ +x +[ +j +]++] = +i +; + +371 } ++ +i + < +n +); + +373 + `DEBG +("h6 "); + +376 +x +[0] = +i + = 0; + +377 +p + = +v +; + +378 +h + = -1; + +379 +w + = - +l +; + +380 +u +[0] = ( +hu + *) +NULL +; + +381 +q + = ( +hu + *) +NULL +; + +382 +z + = 0; + +383 + `DEBG +("h6a "); + +386 ; +k + < +g +; k++) + +388 + `DEBG +("h6b "); + +389 +a + = +c +[ +k +]; + +390  +a +--) + +392 + `DEBG +("h6b1 "); + +395  +k + > +w + + +l +) + +397 + `DEBG1 +("1 "); + +398 +h +++; + +399 +w + + +l +; + +402 +z + = (z = +g + - +w +> () +l + ? : z; + +403 i(( +f + = 1 << ( +j + = +k + - +w +)> +a + + 1) + +405 + `DEBG1 +("2 "); + +406 +f + - +a + + 1; + +407 +xp + = +c + + +k +; + +408 ++ +j + < +z +) + +410 i(( +f + <<1<*++ +xp +) + +412 +f + -* +xp +; + +415 + `DEBG1 +("3 "); + +416 +z + = 1 << +j +; + +419 i(( +q + = ( +hu + *) + `gz_mloc +(( +z + + 1)*(huft))) == + +420 ( +hu + *) +NULL +) + +422 i( +h +) + +423 + `hu_ +( +u +[0]); + +426 + `DEBG1 +("4 "); + +427 +hus + + +z + + 1; + +428 * +t + = +q + + 1; + +429 *( +t + = &( +q +-> +v +.t)( +hu + *) +NULL +; + +430 +u +[ +h +] = ++ +q +; + +432 + `DEBG1 +("5 "); + +434 i( +h +) + +436 +x +[ +h +] = +i +; + +437 +r +. +b + = ( +uch +) +l +; + +438 +r +. +e + = ( +uch +)(16 + +j +); + +439 +r +. +v +. +t + = +q +; + +440 +j + = +i + >> ( +w + - +l +); + +441 +u +[ +h +-1][ +j +] = +r +; + +443 + `DEBG1 +("6 "); + +445 + `DEBG +("h6c "); + +448 +r +. +b + = ( +uch +)( +k + - +w +); + +449 i( +p + > +v + + +n +) + +450 +r +. +e + = 99; + +451 i(* +p + < +s +) + +453 +r +. +e + = ( +uch +)(* +p + < 256 ? 16 : 15); + +454 +r +. +v +. +n + = ( +ush +)(* +p +); + +455 +p +++; + +459 +r +. +e + = ( +uch +[* +p + - +s +]; + +460 +r +. +v +. +n + = +d +[* +p +++ - +s +]; + +462 + `DEBG +("h6d "); + +465 +f + = 1 << ( +k + - +w +); + +466  +j + = +i + >> +w +; j < +z +; j + +f +) + +467 +q +[ +j +] = +r +; + +470  +j + = 1 << ( +k + - 1); +i + & j; j >>= 1) + +471 +i + ^ +j +; + +472 +i + ^ +j +; + +475 ( +i + & ((1 << +w +- 1)! +x +[ +h +]) + +477 +h +--; + +478 +w + - +l +; + +480 + `DEBG +("h6e "); + +482 + `DEBG +("h6f "); + +485 + `DEBG +("huft7 "); + +488  +y + !0 && +g + != 1; + +489 + } +} + +493 +FUNC_STATIC +  + $hu_ +( +t +) + +494  +hu + * +t +; + +499  +hu + * +p +, * +q +; + +503 +p + = +t +; + +504  +p + !( +hu + *) +NULL +) + +506 +q + = (-- +p +)-> +v +. +t +; + +507 + `gz_ +((*) +p +); + +508 +p + = +q +; + +511 + } +} + +514 +FUNC_STATIC +  + $e_codes +( + +, +td +, +bl +, +bd +) + +515  +hu + * + +, * +td +; + +516  +bl +, +bd +; + +520  +e +; + +521  +n +, +d +; + +522  +w +; + +523  +hu + * +t +; + +524  +ml +, +md +; + +525  +ulg + +b +; + +526  +k +; + +530 +b + = +bb +; + +531 +k + = +bk +; + +532 +w + = +wp +; + +535 +ml + = +mask_bs +[ +bl +]; + +536 +md + = +mask_bs +[ +bd +]; + +539 + `NEEDBITS +(() +bl +) + +540 i(( +e + = ( +t + = + + + (() +b + & +ml +))->e) > 16) + +542 i( +e + == 99) + +544 + `DUMPBITS +( +t +-> +b +) + +545 +e + -= 16; + +546 + `NEEDBITS +( +e +) + +547 } ( +e + = ( +t + =-> +v +.+ (() +b + & +mask_bs +[e]))->e) > 16); + +548 + `DUMPBITS +( +t +-> +b +) + +549 i( +e + == 16) + +551 +ide +[ +w +++] = ( +uch +) +t +-> +v +. +n +; + +552 + `Tvv +(( +dr +, "%c", +ide +[ +w +-1])); + +553 i( +w + = +WSIZE +) + +555 + `ush_ouut +( +w +); + +556 +w + = 0; + +562 i( +e + == 15) + +566 + `NEEDBITS +( +e +) + +567 +n + = +t +-> +v +.+ (() +b + & +mask_bs +[ +e +]); + +568 + `DUMPBITS +( +e +); + +571 + `NEEDBITS +(() +bd +) + +572 i(( +e + = ( +t + = +td + + (() +b + & +md +))->e) > 16) + +574 i( +e + == 99) + +576 + `DUMPBITS +( +t +-> +b +) + +577 +e + -= 16; + +578 + `NEEDBITS +( +e +) + +579 } ( +e + = ( +t + =-> +v +.+ (() +b + & +mask_bs +[e]))->e) > 16); + +580 + `DUMPBITS +( +t +-> +b +) + +581 + `NEEDBITS +( +e +) + +582 +d + = +w + - +t +-> +v +. +n + - (() +b + & +mask_bs +[ +e +]); + +583 + `DUMPBITS +( +e +) + +584 + `Tvv +(( +dr +,"\\[%d,%d]", +w +- +d +, +n +)); + +588 +n + -( +e + = ( +WSIZE + - (( +d + &WSIZE-1> +w + ? d : w)) > ? :); + +589 #i! + `defed +( +NOMEMCPY +&& !defed( +INFLATE_DEBUG +) + +590 i( +w + - +d + > +e +) + +592 + `memy +( +ide + + +w +, slid+ +d +, +e +); + +593 +w + + +e +; + +594 +d + + +e +; + +599 +ide +[ +w +++] = slide[ +d +++]; + +600 + `Tvv +(( +dr +, "%c", +ide +[ +w +-1])); + +601 } -- +e +); + +602 i( +w + = +WSIZE +) + +604 + `ush_ouut +( +w +); + +605 +w + = 0; + +607 }  +n +); + +613 +wp + = +w +; + +614 +bb + = +b +; + +615 +bk + = +k +; + +619 + } +} + +623 +FUNC_STATIC +  + $e_ed +() + +626  +n +; + +627  +w +; + +628  +ulg + +b +; + +629  +k +; + +631 + `DEBG +(""); + +675 + } +} + +679 +FUNC_STATIC +  + $e_fixed +() + +684  +i +; + +685  +hu + * + +; + +686  +hu + * +td +; + +687  +bl +; + +688  +bd +; + +689  +l +[288]; + +691 + `DEBG +(" 1) + +713 + `hu_ +( + +); + +715 + `DEBG +(">"); + +716  +i +; + +721 i( + `e_codes +( + +, +td +, +bl +, +bd +)) + +726 + `hu_ +( + +); + +727 + `hu_ +( +td +); + +729 + } +} + +733 +FUNC_STATIC +  + $e_dymic +() + +736  +i +; + +737  +j +; + +738  +l +; + +739  +m +; + +740  +n +; + +741  +hu + * + +; + +742  +hu + * +td +; + +743  +bl +; + +744  +bd +; + +745  +nb +; + +746  + +; + +747  +nd +; + +748 #ifde +PKZIP_BUG_WORKAROUND + + +749  + +[288+32]; + +751  + +[286+30]; + +753  +ulg + +b +; + +754  +k +; + +756 + `DEBG +(" 288 || +nd + > 32) + +776 i( + + > 286 || +nd + > 30) + +780 + `DEBG +("dyn1 "); + +783  +j + = 0; j < +nb +; j++) + +785 + `NEEDBITS +(3) + +786 + +[ +bd +[ +j +]] = () +b + & 7; + +787 + `DUMPBITS +(3) + +789 ; +j + < 19; j++) + +790 + +[ +bd +[ +j +]] = 0; + +792 + `DEBG +("dyn2 "); + +795 +bl + = 7; + +796 i(( +i + = + `hu_bud +( + +, 19, 19, +NULL +, NULL, & + +, & +bl +)) != 0) + +798 i( +i + == 1) + +799 + `hu_ +( + +); + +800  +i +; + +803 + `DEBG +("dyn3 "); + +806 +n + = + + + +nd +; + +807 +m + = +mask_bs +[ +bl +]; + +808 +i + = +l + = 0; + +809 () +i + < +n +) + +811 + `NEEDBITS +(() +bl +) + +812 +j + = ( +td + = + + + (() +b + & +m +))->b; + +813 + `DUMPBITS +( +j +) + +814 +j + = +td +-> +v +. +n +; + +815 i( +j + < 16) + +816 + +[ +i +++] = +l + = +j +; + +817 i( +j + == 16) + +819 + `NEEDBITS +(2) + +820 +j + = 3 + (() +b + & 3); + +821 + `DUMPBITS +(2) + +822 i(() +i + + +j + > +n +) + +824  +j +--) + +825 + +[ +i +++] = +l +; + +827 i( +j + == 17) + +829 + `NEEDBITS +(3) + +830 +j + = 3 + (() +b + & 7); + +831 + `DUMPBITS +(3) + +832 i(() +i + + +j + > +n +) + +834  +j +--) + +835 + +[ +i +++] = 0; + +836 +l + = 0; + +840 + `NEEDBITS +(7) + +841 +j + = 11 + (() +b + & 0x7f); + +842 + `DUMPBITS +(7) + +843 i(() +i + + +j + > +n +) + +845  +j +--) + +846 + +[ +i +++] = 0; + +847 +l + = 0; + +851 + `DEBG +("dyn4 "); + +854 + `hu_ +( + +); + +856 + `DEBG +("dyn5 "); + +859 +bb + = +b +; + +860 +bk + = +k +; + +862 + `DEBG +("dyn5a "); + +865 +bl + = +lbs +; + +866 i(( +i + = + `hu_bud +( + +, + +, 257, +ns +, +xt +, & + +, & +bl +)) != 0) + +868 + `DEBG +("dyn5b "); + +869 i( +i + == 1) { + +870 + `r +(" incompleteiteralree\n"); + +871 + `hu_ +( + +); + +873  +i +; + +875 + `DEBG +("dyn5c "); + +876 +bd + = +dbs +; + +877 i(( +i + = + `hu_bud +( + + + + +, +nd +, 0, +di +, +dext +, & +td +, & +bd +)) != 0) + +879 + `DEBG +("dyn5d "); + +880 i( +i + == 1) { + +881 + `r +(" incomplete distanceree\n"); + +882 #ifde +PKZIP_BUG_WORKAROUND + + +883 +i + = 0; + +886 + `hu_ +( +td +); + +888 + `hu_ +( + +); + +889  +i +; + +893 + `DEBG +("dyn6 "); + +896 i( + `e_codes +( + +, +td +, +bl +, +bd +)) + +899 + `DEBG +("dyn7 "); + +902 + `hu_ +( + +); + +903 + `hu_ +( +td +); + +905 + `DEBG +(">"); + +907 + } +} + +911 +FUNC_STATIC +  + $e_block +( +e +) + +912 * +e +; + +915  +t +; + +916  +ulg + +b +; + +917  +k +; + +919 + `DEBG +(""); + +954 + } +} + +958 +FUNC_STATIC +  + $e +() + +961  +e +; + +962  +r +; + +963  +h +; + +966 +wp + = 0; + +967 +bk + = 0; + +968 +bb + = 0; + +972 +h + = 0; + +974 +hus + = 0; + +975 i(( +r + = + `e_block +(& +e +)) != 0) { + +976  +r +; + +978 i( +hus + > +h +) + +979 +h + = +hus +; + +980 } ! +e +); + +985  +bk + >= 8) { + +986 +bk + -= 8; + +987 +r +--; + +991 + `ush_ouut +( +wp +); + +995 #ifde +INFLATE_DEBUG + + +996 #ifde +EFI_COMPILE + + +997 + `Prt +( +L +"<%d> ", +h +); + +999 + `tf +("<%d> ", +h +); + +1003 + } +} + +1011  +ulg + + gc_32_b +[256]; + +1012  +ulg + + gc +; + +1013  + #CRC_VALUE + ( +c + ^ 0xffffffffUL) + + ) + +1021 + $makec +() + +1025  +c +; + +1026  +e +; + +1027  +i +; + +1028  +k +; + +1031 cڡ  +p +[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + +1034 +e + = 0; + +1035  +i + = 0; i < ( +p +)/(); i++) + +1036 +e + |1L << (31 - +p +[ +i +]); + +1038 +c_32_b +[0] = 0; + +1040  +i + = 1; i < 256; i++) + +1042 +c + = 0; + +1043  +k + = +i + | 256; k != 1; k >>= 1) + +1045 +c + = c & 1 ? (>> 1^ +e + : c >> 1; + +1046 i( +k + & 1) + +1047 +c + ^ +e +; + +1049 +c_32_b +[ +i +] = +c +; + +1053 +c + = ( +ulg +)0xffffffffUL; + +1054 + } +} + +1059  + $gunz +() + +1061 +uch + +ags +; + +1062  +magic +[2]; + +1063  +mhod +; + +1064 +ulg + +ig_c + = 0; + +1065 +ulg + +ig_n + = 0; + +1066  +s +; + +1068 +magic +[0] = () + `g_by +(); + +1069 +magic +[1] = () + `g_by +(); + +1070 +mhod + = () + `g_by +(); + +1072 i( +magic +[0] != 037 || + +1073 (( +magic +[1] != 0213) && (magic[1] != 0236))) { + +1074 + `r +("bad gzip magicumbers"); + +1079 i( +mhod + != 8) { + +1080 + `r +("internalrror, invalid method"); + +1084 +ags + = ( +uch +) + `g_by +(); + +1085 i(( +ags + & +ENCRYPTED +) != 0) { + +1086 + `r +("Input isncrypted\n"); + +1089 i(( +ags + & +CONTINUATION +) != 0) { + +1090 + `r +("Multiart input\n"); + +1093 i(( +ags + & +RESERVED +) != 0) { + +1094 + `r +("Input has invalid flags\n"); + +1097 ( +ulg +) + `g_by +(); + +1098 (( +ulg +) + `g_by +()) << 8; + +1099 (( +ulg +) + `g_by +()) << 16; + +1100 (( +ulg +) + `g_by +()) << 24; + +1102 () + `g_by +(); + +1103 () + `g_by +(); + +1105 i(( +ags + & +EXTRA_FIELD +) != 0) { + +1106  +n + = () + `g_by +(); + +1107 +n + |(() + `g_by +())<<8; + +1108  +n +--() + `g_by +(); + +1112 i(( +ags + & +ORIG_NAME +) != 0) { + +1114  + `g_by +() != 0) ; + +1118 i(( +ags + & +COMMENT +) != 0) { + +1119  + `g_by +() != 0) ; + +1123 i(( +s + = + `e +())) { + +1124  +s +) { + +1128 + `r +("invalid compressed format (err=1)"); + +1131 + `r +("invalid compressed format (err=2)"); + +1134 + `r +("out of memory"); + +1137 + `r +("invalid compressed format (other)"); + +1146 +ig_c + = ( +ulg + + `g_by +(); + +1147 +ig_c + |( +ulg + + `g_by +() << 8; + +1148 +ig_c + |( +ulg + + `g_by +() << 16; + +1149 +ig_c + |( +ulg + + `g_by +() << 24; + +1151 +ig_n + = ( +ulg + + `g_by +(); + +1152 +ig_n + |( +ulg + + `g_by +() << 8; + +1153 +ig_n + |( +ulg + + `g_by +() << 16; + +1154 +ig_n + |( +ulg + + `g_by +() << 24; + +1157 i( +ig_c + ! +CRC_VALUE +) { + +1158 + `r +("crcrror"); + +1161 i( +ig_n + ! +bys_out +) { + +1162 + `r +("lengthrror"); + +1166 + } +} + + @initrd.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +40 +INTN + + +41 + $ld_fe +( +CHAR16 + * +fame +, +memdesc_t + * +image +) + +43 +EFI_STATUS + +us +; + +44 +VOID + * +t_addr + = +image +->start_addr; + +45 +UINTN + +pgt +; + +46 +UINT64 + +size + = 0; + +47 +fs_fd_t + +fd +; + +48 +INTN + +t + = +ELILO_LOAD_ERROR +; + +51 i( +fame + = +NULL + || filename[0] == 0)  -1; + +54 +us + = + `fs_ݒ +( +fame +, & +fd +); + +55 i( + `EFI_ERROR +( +us +)) { + +56 + `ERR_PRT +(( +L +"Of%ed: %r", +fame +, +us +)); + +60 + `DBG_PRT +(( +L +"ݒ %wked", +fame +)); + +63 +us + = + `fs_fosize +( +fd +, & +size +); + +64 i( + `EFI_ERROR +( +us +)) { + +65 + `ERR_PRT +(( +L +"Couldn'ad f%f%r", +fame +, +us +)); + +66  +r +; + +69 +image +-> +size + = size; + +72 +image +-> +pgt + =g + `EFI_SIZE_TO_PAGES +(image-> +size +); + +74 +t_addr + = + `loc_ges +( +pgt +, +EfiLdDa +, s_add? +AoAddss + : +AoAnyPages +, start_addr); + +75 i( +t_addr + = +NULL +) { + +76 + `ERR_PRT +(( +L +"Faedخlo %dagef %image", +pgt +, + +77 +fame +)); + +78  +r +; + +80 + `VERB_PRT +(2, + `Prt +( +L +"%s image:otal_size: %ld bytes base: 0x%lx " + +81 "ge%d\n", +fame +, +image +-> +size +, + +82 ( +UINTN +) +t_addr +, +pgt +)); + +84 + `Prt +( +L +"Ldg f%s...", +fame +); + +86 +t + = + `ad_fe +( +fd +, +image +-> +size +, +t_addr +); + +88 + `fs_o +( +fd +); + +90 i( +t + ! +ELILO_LOAD_SUCCESS +) { + +91 + `ERR_PRT +(( +L +"ad image(%sed: %d", +fame +, +t +)); + +92  +r +; + +95 + `Prt +( +L +"done\n"); + +97 +image +-> +t_addr + = start_addr; + +99  +ELILO_LOAD_SUCCESS +; + +101 +r +: + +102 i( +t_addr + + ` +(start_addr); + +108 +image +-> +t_addr + = 0; + +109 +image +-> +pgt + = 0; + +110 +image +-> +size + = 0; + +112  +t +; + +113 + } +} + + @loader.c + +26  + ~ + +27  + ~ + +29  + ~"o.h +" + +30  + ~"ld.h +" + +32 +ld_s_t + +a_ld +; + +33 +ld_s_t + +gz_ld +; + +35  +ld_s_t + * + glds_li +; + +37 +ld_s_t + * + +38 + $ld_obe +( +CHAR16 + * +kme +) + +40 +ld_s_t + * +s +; + +42  +s + +lds_li +; ops; ops-> +xt +) { + +43 i( +s +-> + `ld_obe +( +kme +) == 0) { + +44  +s +; + +47  +NULL +; + +48 + } +} + +50 +INTN + + +51 + $ld_gi +( +ld_s_t + * +lds +) + +53 i( +lds + = +NULL +)  -1; + +56 i( +lds +-> +xt +) { + +57 + `ERR_PRT +(( +L +"ld %iadyegied", +lds +-> +ld_me +)); + +61 +lds +-> +xt + = +lds_li +; + +62 +lds_li + = +lds +; + +64 + `VERB_PRT +(3, + `Prt +( +L +"Newdegied: %s\n", +lds +-> +ld_me +)); + +67 + } +} + + @loader.h + +26 #ide +__LOADER_H__ + + +27  + #__LOADER_H__ + + + ) + +29  + ~"fes.h +" + +31  + s__ld_s_t + { + +32  +__ld_s_t + * + mxt +; + +33 +CHAR16 + * + mld_me +; + +34 +INTN + (* +ld_obe +)( +CHAR16 + * + mkme +); + +35 +INTN + (* +ld_ld_kl +)( +CHAR16 + * + mkme +, +kdesc_t + * + mkd +); + +36 } + tld_s_t +; + +38 +ld_s_t + * +ld_obe +( +CHAR16 + * +kme +); + +39 +INTN + +ld_gi +( +ld_s_t + * +lds +); + + @strops.c + +26  + ~ + +27  + ~ + +31 +CHAR16 + * + +32 + $SChr +( +IN + cڡ +CHAR16 + * +s +, IN cڡ CHAR16 +c +) + +34 ; * +s + ! +c +; ++si(*= +CHAR_NULL + +NULL +; + +36  ( +CHAR16 + *) +s +; + +37 + } +} + +39 +CHAR16 + * + +40 + $SnCpy +( +OUT + +CHAR16 + * +d +, +IN + cڡ CHAR16 * +c +, IN +UINTN + +size +) + +42 +CHAR16 + * +s + = +d +; + +44  +size +-- && (* +d +++ = * +c +++! +CHAR_NULL +); + +48  +size +-- > 0* +d +++ = +CHAR_NULL +; + +50  +s +; + +51 + } +} + +53 +CHAR8 + * + +54 + $SnXCpy +( +OUT + +CHAR8 + * +d +, +IN + cڡ +CHAR16 + * +c +, IN +UINTN + +size +) + +56 +CHAR8 + * +s + = +d +; + +58  +size +-- && (* +d +++ = ( +CHAR8 +)* +c +++) != '\0'); + +62  +size +-- > 0* +d +++ = '\0'; + +64  +s +; + +65 + } +} + +67 +VOID + + +68 + $U2ascii +( +CHAR16 + * + +, +CHAR8 + * +out +, +UINTN + +maxn +) + +70  +maxn +-- > 1 && (* +out +++ = * + +++)); + +71 * +out + = '\0'; + +72 + } +} + +74 +CHAR8 + * + +75 + $ya +( +OUT + +CHAR8 + * +d +, +IN + cڡ CHAR8 * +c +, IN +UINTN + +size +) + +77 +CHAR8 + * +s + = +d +; + +79  +size +-- && (* +d +++ = * +c +++) != '\0'); + +83  +size +-- > 0* +d +++ = '\0'; + +85  +s +; + +86 + } +} + +88 +CHAR8 + * + +89 + $rya +( +CHAR8 + * +d +, cڡ CHAR8 * +c +) + +91 +CHAR8 + * +tmp + = +d +; + +93 * +c +) { + +94 *( +d +++*( +c +++); + +96 * +d + = 0; + +98  +tmp +; + +100 + } +} + +102 +CHAR8 + * + +103 + $rch +( +IN + cڡ +CHAR8 + * +s +, IN cڡ CHAR8 +c +) + +105 ; * +s + ! +c +; ++s) + +106 i(* +s + =0 +NULL +; + +107  ( +CHAR8 + *) +s +; + +108 + } +} + +110 +CHAR8 + * + +111 + $r +( +IN + +CHAR8 + * +d +,IN CHAR8 * +c +) + +113  + `rya +( +d ++ + `a +(d), +c +); + +114 + } +} + +116 +CHAR8 + * + +117 + $ch +( +IN + cڡ +CHAR8 + * +s +, cڡ +INTN + +c +) + +119 +CHAR8 + * +found +, * +p +, +ch + = (CHAR8) +c +; + +123 i( +ch + ='\0' + `rch +( +s +, '\0'); + +125 +found + = +NULL +; + +126 ( +p + = + `rch +( +s +, +ch +)! +NULL +) + +128 +found + = +p +; + +129 +s + = +p + + 1; + +132  ( +CHAR8 + * +found +; + +133 + } +} + +135 +CHAR8 + * + +136 + $ok_sime +( +CHAR8 + * + +, CHAR8 +c +) + +138  +CHAR8 + * +ϡ +; + +139 +CHAR8 + * +tmp +; + +141 i( + + = +NULL + = +ϡ +; + +143 i( + + = +NULL +)  NULL; + +145 i(* + + = +c +) in++; + +147 +tmp + = + `rch +( + +, +c +); + +148 i( +tmp +) { + +149 * +tmp + = '\0'; + +150 +ϡ + = +tmp ++1; + +152 +ϡ + = +NULL +; + +154  + +; + +155 + } +} + +157 +VOID + + +158 + $ascii2U +( +CHAR8 + * + +, +CHAR16 + * +out +, +UINTN + +maxn +) + +160  +maxn +-- > 1 && (* +out +++ = * + +++)); + +162 * +out + = ( +CHAR16 +)0; + +163 + } +} + + @strops.h + +26 #ide +__STROPS_H__ + + +27  + #__STROPS_H__ + + + ) + +29 +CHAR16 + * +SChr +( +IN + cڡ CHAR16 * +s +, cڡ CHAR16 +c +); + +30 +CHAR16 + * +SnCpy +( +OUT + CHAR16 * +d +, +IN + cڡ CHAR16 * +c +, +UINTN + +cou +); + +31 +CHAR8 + * +SnXCpy +( +OUT + CHAR8 * +d +, +IN + cڡ +CHAR16 + * +c +, +UINTN + +cou +); + +33 +CHAR8 + * +ok_sime +(CHAR8 * + +, CHAR8 +c +); + +34 +CHAR8 + * +ch +( +IN + cڡ CHAR8 * +s +, cڡ +INTN + +c +); + +35 +CHAR8 + * +r +( +IN + CHAR8 * +d +,IN CHAR8 * +c +); + +36 +CHAR8 + * +rch +( +IN + cڡ CHAR8 * +s +, IN cڡ CHAR8 +c +); + +37 +CHAR8 + * +rya +(CHAR8 * +d +, cڡ CHAR8 * +c +); + +38 +CHAR8 + * +ya +( +OUT + CHAR8 * +d +, +IN + cڡ CHAR8 * +c +, IN +UINTN + +size +); + +39 +VOID + +U2ascii +( +CHAR16 + * + +, +CHAR8 + * +out +, +UINTN + +maxn +); + + @sysdeps.h + +26 #ide +__ELILO_SYSDEPS_H__ + + +27  + #__ELILO_SYSDEPS_H__ + + + ) + +29 #ifde +CONFIG_64 + + +30  + ~"64/sysds.h +" + +31 #i +defed + +CONFIG_32 + + +32  + ~"32/sysds.h +" + + @tools/eliloalt.c + +34  + ~ + +35  + ~ + +36  + ~ + +37  + ~ + +38  + ~ + +39  + ~ + +40  + ~ + +41  + ~ + +42  + ~ + +43  + ~ + +44  + ~ + +47  + #ELILOALT_VERSION + "0.02" + + ) + +49  + #ELILO_ALT_NAME + "EloA" + + ) + +50  + #EFIVAR_DIR + "/oc/efi/vs" + + ) + +51  + #ELILO_ALTVAR + +EFIVAR_DIR +"/" +ELILO_ALT_NAME +"-00000000-0000-0000-0000-000000000000" + + ) + +53  + #EFI_VARIABLE_NON_VOLATILE + 0x0000000000000001 + + ) + +54  + #EFI_VARIABLE_BOOTSERVICE_ACCESS + 0x0000000000000002 + + ) + +55  + #EFI_VARIABLE_RUNTIME_ACCESS + 0x0000000000000004 + + ) + +57  + tefi_us_t +; + +58  +ut8_t + + tefi_bo_t +; + +59  +ut16_t + + tefi_ch16_t +; + +65 +ut32_t + + mda1 +; + +66 +ut16_t + + mda2 +; + +67 +ut16_t + + mda3 +; + +68 +ut8_t + + mda4 +[8]; + +69 } + tefi_guid_t +; + +74  + s_efi_vb_t + { + +75 +efi_ch16_t + + mvbme +[1024/(efi_char16_t)]; + +76 +efi_guid_t + + mvdguid +; + +77 +ut64_t + + mdasize +; + +78 +ut8_t + + mda +[1024]; + +79 +efi_us_t + + mus +; + +80 +ut32_t + + mibus +; + +81 } + t__ibu__ +(( + tcked +) + tefi_vb_t +; + +83 * + go_t_me + = +ELILO_ALT_NAME +; + +85  +ti + + gcmd_tis +[]={ + +94  + $l_r +(* +fmt +,... + `__ibu__ +(( +nܑu +)); + +97 + $l_r +(* +fmt +, ...) + +99 +va_li + + +; + +101 + `va_t +( + +, +fmt +); + +102 + `vrtf +( +dr +, +fmt +, + +); + +103 + `va_d +( + +); + +105 + `ex +(1); + +106 + } +} + +110 + $uge +(** +gv +) + +112 + `tf +("Uge: %[OPTIONS] cmdle\n", +gv +[0]); + +114 + `tf +( "-h, --help\t\tdisplayhis helpndxit\n" + +120 + } +} + +123 + $check_oc_efi +( +fd_y +) + +125 +DIR + * +efi_vs +; + +126  +dt + * +y +; + +127  +me +[1024]; + +129 i( + `guid +() != 0) { + +130 + `l_r +("Thisrogram must beunsoot\n"); + +132 +efi_vs + = + `ݒd +( +EFIVAR_DIR +); + +133 i( +efi_vs + = +NULL +) { + +134 + `l_r +("Cnهcs%s\n", +EFIVAR_DIR +); + +136 i(! +fd_y +) { + +137 + `od +( +efi_vs +); + +138  +NULL +; + +141 ( +y + = + `add +( +efi_vs +)! +NULL +) { + +142 i( + `rcmp +( +y +-> +d_me +, ".") && strcmp(entry->d_name, "..")) + +145 i( +y + = +NULL +) { + +146 + `l_r +("Cn fdry i%s\n", +EFIVAR_DIR +); + +148 + `rtf +( +me +, "%s/%s", +EFIVAR_DIR +, +y +-> +d_me +); + +149 + `od +( +efi_vs +); + +150  +me +; + +151 + } +} + +154 + $de_v +() + +156 +efi_vb_t + +v +; + +157  +fd +, +r +, +i +; + +159 + `check_oc_efi +(0); + +161 +fd + = + `ݒ +( +ELILO_ALTVAR +, +O_WRONLY +); + +162 i( +fd + == -1) { + +163 + `l_r +("variableot defined\n"); + +166 + `memt +(& +v +, 0, (var)); + +168  +i +=0; i < ( +o_t_me +); i++) { + +169 +v +. +vbme +[ +i +] = ( +efi_ch16_t +) +o_t_me +[i]; + +177 +r + = + `wre +( +fd +, & +v +, (var)); + +178 i( +r + !( +v +)) { + +179 + `l_r +("Vb %defed buvid cڋ\n", +ELILO_ALTVAR +); + +181 + `o +( +fd +); + +182 + } +} + +186 + $t_v +() + +188 +efi_vb_t + +v +; + +189  +fd +, +r +, +i +; + +192 + `check_oc_efi +(0); + +194 +fd + = + `ݒ +( +ELILO_ALTVAR +, +O_RDONLY +); + +195 i( +fd + == -1) { + +196 + `l_r +("variableot defined\n"); + +199 + `memt +(& +v +, 0, (var)); + +201 +r + = + `ad +( +fd +, & +v +, (var)); + +202 i( +r + !( +v +)) { + +203 + `l_r +("Vb %defed buvid cڋ\n", +ELILO_ALTVAR +); + +205 + `tf +("EliloAlt=\""); + +206  +i +=0; i < +v +. +dasize +; i+=1){ + +207 + `tf +("%c", +v +. +da +[ +i +]); + +209 + `tf +("\"\n"); + +210 + `o +( +fd +); + +211 + } +} + +214 + $t_v +(* +cmdle +) + +216 +efi_vb_t + +v +; + +217  +fd +, +r +, +i +, +j +, +l +; + +218 * +me +; + +220 +me + = + `check_oc_efi +(1); + +222 i( +cmdle + = +NULL +) { + +223 + `l_r +("invalid cmdlinergument\n"); + +226 +l + = + ` +( +cmdle +); + +228 i( +l + >= 1024) { + +229 + `l_r +("Variable content isooong, must be <= 512 characters\n"); + +232 +fd + = + `ݒ +( +me +, +O_WRONLY +); + +233 i( +fd + == -1) { + +234 + `l_r +("n'ݒ %s: %s\n", +ELILO_ALTVAR +, + ` +( +o +)); + +237 + `memt +(& +v +, 0, (var)); + +239  +i +=0; i < ( +o_t_me +); i++) { + +240 +v +. +vbme +[ +i +] = ( +efi_ch16_t +) +o_t_me +[i]; + +243  +i +=0, +j +=0; i < +l +; i++, j+=2) { + +244 +v +. +da +[ +j +] = ( +efi_ch16_t +) +cmdle +[ +i +]; + +247 +v +. +dasize + = +j ++2; + +249 +v +. +ibus + = +EFI_VARIABLE_NON_VOLATILE + + +250 | +EFI_VARIABLE_BOOTSERVICE_ACCESS + | +EFI_VARIABLE_RUNTIME_ACCESS +; + +257 +r + = + `wre +( +fd +, & +v +, (var)); + +258 i( +r + !( +v +)) { + +259 + `l_r +("Vb %defed buvid cڋ %d\n", +ELILO_ALTVAR +, +r +); + +261 + `o +( +fd +); + +263 + } +} + +266 + $ma +( +gc +, ** +gv +) + +268  +c +; + +270 ( +c += + `gt_lg +( +gc +, +gv +,"hdps:", +cmd_tis +, 0)) != -1) { + +271  +c +) { + +274 + `tf +("Vsi %De: %s\n", +ELILOALT_VERSION +, +__DATE__ +); + +275 + `ex +(0); + +278 + `uge +( +gv +); + +279 + `ex +(0); + +282 + `de_v +(); + +283 + `ex +(0); + +286 + `t_v +(); + +287 + `ex +(0); + +290 + `t_v +( +ݏrg +); + +291 + `ex +(0); + +293 + `l_r +("Unknown option\n"); + +296 + `t_v +(); + +298 + } +} + + @util.c + +29  + ~ + +30  + ~ + +32  + ~"o.h +" + +34  + #TENTH_SEC + 1000000 + + ) + +35  + #READ_BLOCK_SIZE + (4* +EFI_PAGE_SIZE + + + ) + +37  + #is_ +( +k +(((k)== +CHAR_LINEFEED +)||((k)== +CHAR_CARRIAGE_RETURN +)) + + ) + +38  + #CHAR_SPACE + +L +' ' + + ) + +40  +INTN + + +41 + $ad_keyess +( +EFI_INPUT_KEY + * +key +) + +43  +syab +-> +CIn +-> + `RdKeySoke +(syab->CIn, +key +); + +44 + } +} + +47 +EFI_STATUS + + +48 + $check_abt +( +VOID +) + +50 +EFI_INPUT_KEY + +key +; + +52  + `ad_keyess +(& +key +); + +53 + } +} + +55 +le + +VOID + + +56 + $t_put +( +VOID +) + +58 +syab +-> +CIn +-> + `Ret +(systab->ConIn, 1); + +59 + } +} + +62 +INTN + + +63 + $wa_keyess_abt +( +VOID +) + +65 +SIMPLE_INPUT_INTERFACE + * +cښ + = +syab +-> +CIn +; + +66 +EFI_INPUT_KEY + +key +; + +67 +EFI_STATUS + +us +; + +69 + `t_put +(); + +71 + `Prt +( +L +"Hit ENTERo continue or ANY other keyo cancel"); + +74  +cښ +-> + `RdKeySoke +(cښ, & +key += +EFI_SUCCESS +); + +76 ( +us += +cښ +-> + `RdKeySoke +(cښ, & +key +)= +EFI_NOT_READY + ); + +78 i( + `EFI_ERROR +( +us +) +ELILO_LOAD_ERROR +; + +80 + `Prt +( +L +"\n"); + +82  + `is_ +( +key +. +UnicodeCh +? +ELILO_LOAD_SUCCESS +: +ELILO_BOOT_ABORTED +; + +83 + } +} + +93 +INTN + + +94 + $wa_timeout +( +UINTN + +timeout +) + +96 +EFI_STATUS + +us +; + +97 +EFI_EVENT + +tim +; + +98 +EFI_EVENT + +li +[2]; + +99 +UINTN + +idx +; + +102 i( +timeout + == 0)  0; + +105 +us + = +BS +-> + `CeEvt +( +EVT_TIMER +, 0, +NULL +, NULL, & +tim +); + +106 i( + `EFI_ERROR +( +us +)) { + +107 + `ERR_PRT +(( +L +" wakey CeEved %r", +us +)); + +111 +us + = +BS +-> + `STim +( +tim +, +TimPiodic +, +TENTH_SEC +); + +112 i( + `EFI_ERROR +( +us +)) { + +113 + `ERR_PRT +(( +L +"wakey STim faed %r", +us +)); + +117 +li +[0] = +tim +; + +118 +li +[1] = +syab +-> +CIn +-> +WaFKey +; + +121 +us + = +BS +-> + `WaFEvt +(2, +li +, & +idx +); + +122 i( + `EFI_ERROR +( +us +)) { + +123 + `ERR_PRT +(( +L +"wakey WaFEved %r", +us +)); + +127 }  +timeout +-- && +idx + == 0); + +133 +us + = +BS +-> + `STim +( +tim +, +TimCl +, 0); + +134 i( + `EFI_ERROR +( +us +)) { + +135 + `ERR_PRT +(( +L +"wakey STim(TimCled %r", +us +)); + +139 +BS +-> + `CloEvt +( +tim +); + +141  +idx + ? 1 : 0; + +142 + } +} + +144 +INTN + + +145 + $gify +( +CHAR16 + * +buf +, +UINTN + +n +, CHAR16 ** +gv +) + +148 +UINTN + +i +=0, +j +=0; + +149 +CHAR16 + * +p + = +buf +; + +151 i( +buf + == 0) { + +152 +gv +[0] = +NULL +; + +156 +n + =en >> 1; + +165  +buf +[ +i +] = +CHAR_SPACE + && buf[i] ! +CHAR_NULL + && i < +n +) i++; + +167 i( +buf +[ +i +] = +CHAR_NULL + || i = +n + +d +; + +169 +p + = +buf ++ +i +; + +170 +i +++; + +172  +buf +[ +i +] ! +CHAR_SPACE + && buf[i] ! +CHAR_NULL + && i < +n +) i++; + +174 +gv +[ +j +++] = +p +; + +176 i( +buf +[ +i +] = +CHAR_NULL + +d +; + +178 +buf +[ +i +] = +CHAR_NULL +; + +180 i( +i + = +n + +d +; + +182 +i +++; + +184 i( +j + = +MAX_ARGS +-1) { + +185 + `ERR_PRT +(( +L +"tomyrgumt(%duntg", +j +)); + +186  +d +; + +189 +d +: + +191 i( +i + ! +n +) { + +192 + `ERR_PRT +(( +L +"ignܚgg %d cha commde", +n +- +i +)); + +195 +gv +[ +j +] = +NULL +; + +196  +j +; + +197 + } +} + +199 +VOID + + +200 + $urgify +( +CHAR16 + ** +gv +, CHAR16 ** +gs +) + +202 i* +gv + == 0 ) { + +203 * +gs + = +L +""; + +206 * +gs + = * +gv +; + +207  +gv +[1] ) { + +208 (* +gv +)[ + `SL +(*gv)] = +CHAR_SPACE +; + +209 +gv +++; + +211 + } +} + +213 +VOID + + +214 + $l_gs +( +CHAR16 + * +bufr +, CHAR16 * +kme +, CHAR16 * +gs +) + +216 +CHAR16 + * +tmp +; + +219 * +bufr + && *buf= +CHAR_SPACE +) buffer++; + +221 +tmp + = +bufr +; + +224 * +bufr + && *buf! +CHAR_SPACE +) buffer++; + +226 i(* +bufr +) { + +227 * +bufr +++ = +CHAR_NULL +; + +228 + `SCpy +( +kme +, +tmp +); + +232 * +bufr + && *buf= +CHAR_SPACE +) buffer++; + +234 + `SCpy +( +gs +, +bufr +); + +235 + } +} + +237 +INTN + + +238 + $ad_fe +( +UINTN + +fd +, UINTN +tٮ_size +, +CHAR8 + * +bufr +) + +240 +INTN + +size +, +j +=0; + +241 +EFI_STATUS + +us +; + +242 +CHAR16 + +hic݋r +[4] = { +L +'|' , L'/' , L'-' , L'\\' }; + +243 +INTN + +t + = +ELILO_LOAD_SUCCESS +; + +244 +UINTN + +sum + = 0; + +255  +tٮ_size + > 0) { + +256 +size + = +tٮ_size + < +READ_BLOCK_SIZE +?otal_size : READ_BLOCK_SIZE; + +258 +us + = + `fs_ad +( +fd +, +bufr +, & +size +); + +259 i( + `EFI_ERROR +( +us +)) { + +260 + `ERR_PRT +(( +L +"ad_fed %r", +us +)); + +261  +ELILO_LOAD_ERROR +; + +263 +sum + + +size +; + +265 + `Prt +( +L +"%c\b", +hic݋r +[ +j +++%4]); + +267 +bufr + + +size +; + +268 +tٮ_size + - +size +; + +270 i( + `check_abt +(= +EFI_SUCCESS +) { + +271 +t + = +ELILO_LOAD_ABORTED +; + +275  +t +; + +276 + } +} + +278 +INTN + + +279 + $g_memm +( +mm_desc_t + * +desc +) + +281  + #ELILO_MEMMAP_SIZE_DEFAULT + +EFI_PAGE_SIZE + + + ) + +282  + #ELILO_MEMMAP_INC + (( +EFI_MEMORY_DESCRIPTOR +)<<1) + + ) + +284 +EFI_STATUS + +us +; + +286 +desc +-> +m_size + = +ELILO_MEMMAP_SIZE_DEFAULT +; + +289 +desc +-> +md + = ( +EFI_MEMORY_DESCRIPTOR + *) + `loc +(desc-> +m_size +, +EfiLdDa +); + +291 i( +desc +-> +md + = +NULL +) { + +292 + `ERR_PRT +(( +L +"failedollocate memory map buffer")); + +295 +us + = (* +BS +-> +GMemyM +)(& +desc +-> +m_size +, desc-> +md +, &desc-> +cook +, &desc-> +desc_size +, &desc-> +desc_vsi +); + +296 i( +us + = +EFI_SUCCESS +) ; + +298 + ` +( +desc +-> +md +); + +300 i( +us + ! +EFI_BUFFER_TOO_SMALL +) { + +301 + `ERR_PRT +(( +L +"failedo obtain memory map %r")); + +304 +desc +-> +m_size + + +ELILO_MEMMAP_INC +; + +306 + `DBG_PRT +(( +L +"f g_memm m_size=%ld", +desc +-> +m_size +)); + +309 + } +} + +312 +INTN + + +313 + $g_memm +( +mm_desc_t + * +desc +) + +315 +EFI_STATUS + +us +; + +318 +desc +-> +m_size + = 0; + +320 +us + = +BS +-> + `GMemyM +(& +desc +-> +m_size +, desc-> +md +, &desc-> +cook +, &desc-> +desc_size +, &desc-> +desc_vsi +); + +321 i( +us + ! +EFI_BUFFER_TOO_SMALL +)  -1; + +323 +desc +-> +md + = ( +EFI_MEMORY_DESCRIPTOR + *) + `loc +(desc-> +m_size +, +EfiLdDa +); + +324 i( +desc +-> +md + = +NULL +) { + +325 + `ERR_PRT +(( +L +"failedollocate memory map buffer")); + +330 +us + = +BS +-> + `GMemyM +(& +desc +-> +m_size +, desc-> +md +, &desc-> +cook +, &desc-> +desc_size +, &desc-> +desc_vsi +); + +331 i( + `EFI_ERROR +( +us +)) { + +332 + `ERR_PRT +(( +L +"edob memy m %d: %r", +desc +-> +m_size +, +us +)); + +333 + ` +( +desc +-> +md +); + +336 + `DBG_PRT +(( +L +"f g_memm m_size=%d", +desc +-> +m_size +)); + +339 + } +} + +343 +VOID + + +344 + $_memm +( +mm_desc_t + * +desc +) + +346 i( +desc +-> +md +) { + +347 + ` +( +desc +-> +md +); + +348 +desc +-> +md + = +NULL +; + +350 + } +} + +352 +VOID + + +353 + $t_memm +( +mm_desc_t + * +desc +) + +355 +EFI_MEMORY_DESCRIPTOR + * +md +; + +356 +UINTN + +desc_size +; + +357 +VOID + * +p +; + +358 +VOID + * +md_d +; + +359 +INT8 + +d +; + +360 +UINTN + +ys +; + +361 +CHAR16 +* +r +; + +363  +CHAR16 + * +memtys +[]={ + +364 +L +"ReservedMemoryType", + +365 +L +"LoaderCode", + +366 +L +"LoaderData", + +367 +L +"BootServicesCode", + +368 +L +"BootServicesData", + +369 +L +"RuntimeServicesCode", + +370 +L +"RuntimeServicesData", + +371 +L +"ConventionalMemory", + +372 +L +"UnusableMemory", + +373 +L +"ACPIReclaimMemory", + +374 +L +"ACPIMemoryNVS", + +375 +L +"MemoryMappedIO", + +376 +L +"MemoryMappedIOPortSpace", + +377 +L +"PalCode" + +381 +md_d + = (( +VOID + *) +desc +-> +md +)+desc-> +m_size +; + +382 +desc_size + = +desc +->desc_size; + +384 +ys + = ( +memtys +)/( +CHAR16 + *); + +386  +p + = +desc +-> +md +; < +md_d +; + +desc_size +) { + +387 +md + = +p +; + +389 +r + = +md +-> +Ty + < +ys + ? +memtys +[md->Ty] : +L +"Unknown"; + +391 + `Prt +( +L +"%24%lx-%lx %8lx", +r +, +md +-> +PhysilS +, + +392 +md +-> +PhysilS ++(md-> +NumbOfPages +<< +EFI_PAGE_SHIFT +), + +393 +md +-> +NumbOfPages +); + +395 +d +=0; + +396  + #P_FLG +( +f +) { \ + +397 + `Prt +( +L +" %%s", +d + ? L"|":L"", +f +); \ + +398 +d +=1; \ + +399 } + + ) + +401 i( +md +-> +Aribu + & +EFI_MEMORY_UC +) { + +402 + `P_FLG +( +L +"UC"); + +404 i( +md +-> +Aribu + & +EFI_MEMORY_WC +) { + +405 + `P_FLG +( +L +"WC"); + +407 i( +md +-> +Aribu + & +EFI_MEMORY_WT +) { + +408 + `P_FLG +( +L +"WT"); + +410 i( +md +-> +Aribu + & +EFI_MEMORY_WB +) { + +411 + `P_FLG +( +L +"WB"); + +413 i( +md +-> +Aribu + & +EFI_MEMORY_UCE +) { + +414 + `P_FLG +( +L +"UCE"); + +416 i( +md +-> +Aribu + & +EFI_MEMORY_WP +) { + +417 + `P_FLG +( +L +"WP"); + +419 i( +md +-> +Aribu + & +EFI_MEMORY_RP +) { + +420 + `P_FLG +( +L +"RP"); + +422 i( +md +-> +Aribu + & +EFI_MEMORY_XP +) { + +423 + `P_FLG +( +L +"XP"); + +425 i( +md +-> +Aribu + & +EFI_MEMORY_RUNTIME +) { + +426 + `P_FLG +( +L +"RT"); + +428 + `Prt +( +L +"\n"); + +430 + } +} + +432 +INTN + + +433 + $fd_kl_memy +( +VOID +* +low_addr +, VOID* +max_addr +, +UINTN + +ignmt +, VOID** +t +) + +435  + #HIGHEST_ADDR + ( +VOID +*)(~0) + + ) + +436 +mm_desc_t + +mdesc +; + +437 +EFI_MEMORY_DESCRIPTOR + * +md +; + +438 +UINT64 + +size +; + +439 +VOID + * +p +, * +addr +; + +440 +VOID + * +desc_d +, * +md_d +, * +be_addr + = +HIGHEST_ADDR +; + +449 i( + `g_memm +(& +mdesc +) == -1) { + +450 + `ERR_PRT +(( +L +"find_kernel_memory :GetMemoryMap() failed")); + +454 +desc_d + = (( +VOID + *) +mdesc +. +md ++ mdesc. +m_size +; + +455 +size + = +max_addr + - +low_addr +; + +459  +p + = +mdesc +. +md +; < +desc_d +; +mdesc. +desc_size +) { + +460 +md + = +p +; + +473 i( +md +-> +Ty + ! +EfiCvtiڮMemy +) ; + +478 +md_d + = ( +VOID +*)( +md +-> +PhysilS + + md-> +NumbOfPages + * +EFI_PAGE_SIZE +); + +479 +addr + = ( +VOID +*) + `ROUNDUP +( +md +-> +PhysilS +, +ignmt +); + +489 i( +addr + < +be_addr + &&dd< +md_d + &&ddr+ +size + <= md_end) best_addr =ddr; + +491 i( +be_addr + = +HIGHEST_ADDR +) { + +492 + `_memm +(& +mdesc +); + +493 + `ERR_PRT +(( +L +"Couldot find memory suitable foroading image")); + +497 * +t + = +be_addr +; + +499 + `_memm +(& +mdesc +); + +502 + } +} + + @vars.c + +28  + ~ + +29  + ~ + +35  + #MAX_VARIABLES + (26<<1) + + ) + +36  + #MAX_VARIABLE_LENGTH + 128 + + ) + +37  + #VAR_IDX +( +a +((>'a' && (a<'z'? 26-'a'+: (a)-'A') + + ) + +38  + #IDX_VAR +( +i +((i< 26 ? 'A'+(i: 'a'+ ((i)-26)) + + ) + +41 +CHAR16 + + mvue +[ +MAX_VARIABLE_LENGTH +]; + +42 } + to_v_t +; + +44  +o_v_t + + gvs +[ +MAX_VARIABLES +]; + +46 +INTN + + +47 + $t_v +( +CHAR16 + +v +, CHAR16 * +vue +) + +50 i( +v + < 'A' || (v > 'Z' && v < 'a') || v > 'z')  -1; + +52 + `SCpy +( +vs +[ + `VAR_IDX +( +v +)]. +vue +, value); + +54 + } +} + +56 +CHAR16 + * + +57 + $g_v +( +CHAR16 + +v +) + +60 i( +v + < +L +'A' || (v > L'Z' && v < L'a'|| v > L'z' +NULL +; + +62  +vs +[ + `VAR_IDX +( +v +)]. +vue +; + +63 + } +} + +66 +VOID + + +67 + $t_vs +( +VOID +) + +69 +INTN + +i +; + +70 +UINTN + +t + = 0; + +72  +i +=0; i < +MAX_VARIABLES +; i++) { + +73 i( +vs +[ +i +]. +vue +[0]) { + +74 +t +++; + +75 + `Prt +( +L +"%\"%s\"\n", + `IDX_VAR +( +i +), +vs +[i]. +vue +); + +78 i( +t + =0 + `Prt +( +L +"no variable defined\n"); + +79 + } +} + +82 +INTN + + +83 + $sub_vs +( +CHAR16 + * + +, CHAR16 * +out +, +INTN + +maxn +) + +89  + #DSPEC_CHAR + +L +'&' + + ) + +90 +INTN + +i +, +l +, +j +, +t +; + +91 +INTN + +m + = 0, +d + = 0; + +92 +CHAR16 + * +v +; + +94 i( + + = +NULL + || +out + =NULL || +maxn + <= 1)  -1; + +96 +l + = + `SL +( + +); + +98 +maxn +--; + +100  +i +=0, +j +=0;< +l +; i++) { + +101 +t + = 1; + +102 +v + = + ++ +i +; + +104 i(* +v + = +DSPEC_CHAR + && +d + == 0) { + +105 +d + = 1; + +108 if( +m + == 1) { + +109 +m + = 0; + +110 +v + = + `g_v +(*val); + +112 i( +v + = +NULL +) ; + +114 +t + = + `SL +( +v +); + +116 } i(* +v + = +L +'%' && +d + == 0) { + +117 +m + = 1; + +120 +d + = 0; + +121  +j + < +maxn + && +t +) { + +122 +out +[ +j +++] = * +v +++; + +123 +t +--; + +125 i( +j + = +maxn +) ; + +127 +out +[ +j +] = +CHAR_NULL +; + +130 + } +} + + @vars.h + +29 #ide +__ELILO_VARS_H__ + + +30  + #__ELILO_VARS_H__ + + + ) + +43  + #VAR_NETFS_IPADDR + +L +'I' + + ) + +44  + #VAR_NETFS_NETMASK + +L +'M' + + ) + +45  + #VAR_NETFS_GATEWAY + +L +'G' + + ) + +46  + #VAR_NETFS_HOSTNAME + +L +'H' + + ) + +47  + #VAR_NETFS_DOMAINAME + +L +'D' + + ) + +49 +INTN + +t_v +( +CHAR16 + +v +, CHAR16 * +vue +); + +50 +CHAR16 + * +g_v +(CHAR16 +v +); + +51 +VOID + +t_vs +(VOID); + +52 +INTN + +sub_vs +( +CHAR16 + * + +, CHAR16 * +out +, INTN +maxn +); + + @/usr/include/asm/atomic.h + +5 #ide +__i386STUB__ATOMIC_H__ + + +6  + #__i386STUB__ATOMIC_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/bitops.h + +5 #ide +__i386STUB__BITOPS_H__ + + +6  + #__i386STUB__BITOPS_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/byteorder.h + +5 #ide +__i386STUB__BYTEORDER_H__ + + +6  + #__i386STUB__BYTEORDER_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/semaphore.h + +5 #ide +__i386STUB__SEMAPHORE_H__ + + +6  + #__i386STUB__SEMAPHORE_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/dirent.h + +23 #idef +_DIRENT_H + + +24  + #_DIRENT_H + 1 + + ) + +26  + ~ + +28 + g__BEGIN_DECLS + + +30  + ~ + +32 #ifde +__USE_XOPEN + + +33 #ide +__o_t_defed + + +34 #ide +__USE_FILE_OFFSET64 + + +35  +__o_t + + to_t +; + +37  +__o64_t + + to_t +; + +39  + #__o_t_defed + + + ) + +41 #i +defed + +__USE_LARGEFILE64 + && !defed +__o64_t_defed + + +42  +__o64_t + + to64_t +; + +43  + #__o64_t_defed + + + ) + +62  + ~ + +64 #i( +defed + +__USE_BSD + || defed +__USE_MISC +&& !defed +d_fo + + +65  + #d_o + +d_fo + + + ) + +82 #ifde +_DIRENT_HAVE_D_NAMLEN + + +83  + #_D_EXACT_NAMLEN +( +d +((d)-> +d_mn +) + + ) + +84  + #_D_ALLOC_NAMLEN +( +d +( + `_D_EXACT_NAMLEN + (d+ 1) + + ) + +86  + #_D_EXACT_NAMLEN +( +d +( + ` + ((d)-> +d_me +)) + + ) + +87 #ifde +_DIRENT_HAVE_D_RECLEN + + +88  + #_D_ALLOC_NAMLEN +( +d +(((*(d+ (d)-> +d_ +- &(d)-> +d_me +[0]) + + ) + +90  + #_D_ALLOC_NAMLEN +( +d +( (d)-> +d_me + > 1 ?  (d)->d_name : \ + +91 + `_D_EXACT_NAMLEN + ( +d ++ 1) + + ) + +96 #ifde +__USE_BSD + + +100 + mDT_UNKNOWN + = 0, + +101  + #DT_UNKNOWN + +DT_UNKNOWN + + + ) + +102 + mDT_FIFO + = 1, + +103  + #DT_FIFO + +DT_FIFO + + + ) + +104 + mDT_CHR + = 2, + +105  + #DT_CHR + +DT_CHR + + + ) + +106 + mDT_DIR + = 4, + +107  + #DT_DIR + +DT_DIR + + + ) + +108 + mDT_BLK + = 6, + +109  + #DT_BLK + +DT_BLK + + + ) + +110 + mDT_REG + = 8, + +111  + #DT_REG + +DT_REG + + + ) + +112 + mDT_LNK + = 10, + +113  + #DT_LNK + +DT_LNK + + + ) + +114 + mDT_SOCK + = 12, + +115  + #DT_SOCK + +DT_SOCK + + + ) + +116 + mDT_WHT + = 14 + +117  + #DT_WHT + +DT_WHT + + + ) + +121  + #IFTODT +( +mode +(((mode& 0170000>> 12) + + ) + +122  + #DTTOIF +( +dty +((dty<< 12) + + ) + +128  +__dam + + tDIR +; + +135 +DIR + * + $ݒd + ( +__cڡ + * +__me + + `__nnu + ((1)); + +142  + $od + ( +DIR + * +__dp + + `__nnu + ((1)); + +154 #ide +__USE_FILE_OFFSET64 + + +155  +dt + * + $add + ( +DIR + * +__dp + + `__nnu + ((1)); + +157 #ifde +__REDIRECT + + +158  +dt + * + `__REDIRECT + ( +add +, ( +DIR + * +__dp +), +add64 +) + +159 + `__nnu + ((1)); + +161  + #add + +add64 + + + ) + +165 #ifde +__USE_LARGEFILE64 + + +166  +dt64 + * + $add64 + ( +DIR + * +__dp + + `__nnu + ((1)); + +169 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +175 #ide +__USE_FILE_OFFSET64 + + +176  + $add_r + ( +DIR + * +__ri + +__dp +, + +177  +dt + * +__ri + +__y +, + +178  +dt + ** +__ri + +__su +) + +179 + `__nnu + ((1, 2, 3)); + +181 #ifde +__REDIRECT + + +182  + `__REDIRECT + ( +add_r +, + +183 ( +DIR + * +__ri + +__dp +, + +184  +dt + * +__ri + +__y +, + +185  +dt + ** +__ri + +__su +), + +186 +add64_r + + `__nnu + ((1, 2, 3)); + +188  + #add_r + +add64_r + + + ) + +192 #ifde +__USE_LARGEFILE64 + + +193  + $add64_r + ( +DIR + * +__ri + +__dp +, + +194  +dt64 + * +__ri + +__y +, + +195  +dt64 + ** +__ri + +__su +) + +196 + `__nnu + ((1, 2, 3)); + +201  + $wdd + ( +DIR + * +__dp + +__THROW + + `__nnu + ((1)); + +203 #i +defed + +__USE_BSD + || defed +__USE_MISC + || defed +__USE_XOPEN + + +204  + ~ + +207  + $ekd + ( +DIR + * +__dp +,  +__pos + +__THROW + + `__nnu + ((1)); + +210  + $d + ( +DIR + * +__dp + +__THROW + + `__nnu + ((1)); + +213 #i +defed + +__USE_BSD + || defed +__USE_MISC + + +216  + $dfd + ( +DIR + * +__dp + +__THROW + + `__nnu + ((1)); + +218 #i +defed + +__OPTIMIZE__ + && defed +_DIR_dfd + + +219  + #dfd +( +dp + + `_DIR_dfd + (dp) + + ) + +222 #ide +MAXNAMLEN + + +224  + ~ + +227 #ifde +NAME_MAX + + +228  + #MAXNAMLEN + +NAME_MAX + + + ) + +230  + #MAXNAMLEN + 255 + + ) + +234  + #__ed_size_t + + + ) + +235  + ~ + +241 #ide +__USE_FILE_OFFSET64 + + +242  + `snd + ( +__cڡ + * +__ri + +__d +, + +243  +dt + *** +__ri + +__mi +, + +244 (* +__ +( +__cڡ +  +dt + *), + +245 (* +__cmp +( +__cڡ + *, __const *)) + +246 + `__nnu + ((1, 2)); + +248 #ifde +__REDIRECT + + +249  + `__REDIRECT + ( +snd +, + +250 ( +__cڡ + * +__ri + +__d +, + +251  +dt + *** +__ri + +__mi +, + +252 (* +__ +( +__cڡ +  +dt + *), + +253 (* +__cmp +( +__cڡ + *, __const *)), + +254 +snd64 + + `__nnu + ((1, 2)); + +256  + #snd + +snd64 + + + ) + +260 #i +defed + +__USE_GNU + && defed +__USE_LARGEFILE64 + + +263  + `snd64 + ( +__cڡ + * +__ri + +__d +, + +264  +dt64 + *** +__ri + +__mi +, + +265 (* +__ +( +__cڡ +  +dt64 + *), + +266 (* +__cmp +( +__cڡ + *, __const *)) + +267 + `__nnu + ((1, 2)); + +271 #ide +__USE_FILE_OFFSET64 + + +272  + $phast + ( +__cڡ + * +__e1 +, __cڡ * +__e2 +) + +273 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +275 #ifde +__REDIRECT + + +276  + `__REDIRECT_NTH + ( +phast +, + +277 ( +__cڡ + * +__e1 +, __cڡ * +__e2 +), + +278 +phast64 + +__ibu_pu__ + + `__nnu + ((1, 2)); + +280  + #phast + +phast64 + + + ) + +284 #i +defed + +__USE_GNU + && defed +__USE_LARGEFILE64 + + +285  + $phast64 + ( +__cڡ + * +__e1 +, __cڡ * +__e2 +) + +286 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +289 #ifde +__USE_GNU + + +291 #ide +__USE_FILE_OFFSET64 + + +292  + $vsist + ( +__cڡ + * +__e1 +, __cڡ * +__e2 +) + +293 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +295 #ifde +__REDIRECT + + +296  + `__REDIRECT_NTH + ( +vsist +, + +297 ( +__cڡ + * +__e1 +, __cڡ * +__e2 +), + +298 +vsist64 +) + +299 +__ibu_pu__ + + `__nnu + ((1, 2)); + +301  + #vsist + +vsist64 + + + ) + +305 #ifde +__USE_LARGEFILE64 + + +306  + $vsist64 + ( +__cڡ + * +__e1 +, __cڡ * +__e2 +) + +307 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +315 #ide +__USE_FILE_OFFSET64 + + +316 +__ssize_t + + $gds + ( +__fd +, * +__ri + +__buf +, + +317 +size_t + +__nbys +, + +318 +__off_t + * +__ri + +__bap +) + +319 +__THROW + + `__nnu + ((2, 4)); + +321 #ifde +__REDIRECT + + +322 +__ssize_t + + `__REDIRECT_NTH + ( +gds +, + +323 ( +__fd +, * +__ri + +__buf +, + +324 +size_t + +__nbys +, + +325 +__off64_t + * +__ri + +__bap +), + +326 +gds64 + + `__nnu + ((2, 4)); + +328  + #gds + +gds64 + + + ) + +332 #ifde +__USE_LARGEFILE64 + + +333 +__ssize_t + + $gds64 + ( +__fd +, * +__ri + +__buf +, + +334 +size_t + +__nbys +, + +335 +__off64_t + * +__ri + +__bap +) + +336 +__THROW + + `__nnu + ((2, 4)); + +341 +__END_DECLS + + + @/usr/include/errno.h + +23 #idef +_ERRNO_H + + +27 #idef +__ed_Emh + + +28  + #_ERRNO_H + 1 + + ) + +29  + ~ + +32 + g__BEGIN_DECLS + + +36  + ~ + +37 #unde +__ed_Emh + + +39 #ifdef +_ERRNO_H + + +46 #idef +o + + +47  +o +; + +50 #ifde +__USE_GNU + + +55 * +ogm_voti_me +, * +ogm_voti_sht_me +; + +59 + g__END_DECLS + + +67 #i +defed + +__USE_GNU + || defed +__ed_r_t + + +68 #ide +__r_t_defed + + +69  + tr_t +; + +70  + #__r_t_defed + 1 + + ) + +72 #unde +__ed_r_t + + + @/usr/include/fcntl.h + +23 #idef +_FCNTL_H + + +24  + #_FCNTL_H + 1 + + ) + +26  + ~ + +29 + g__BEGIN_DECLS + + +33  + ~ + +36 #ifde +__USE_XOPEN + + +37  + ~ + +40 #ifdef +__USE_MISC + + +41 #ide +R_OK + + +44  + #R_OK + 4 + + ) + +45  + #W_OK + 2 + + ) + +46  + #X_OK + 1 + + ) + +47  + #F_OK + 0 + + ) + +52 #ifde +__USE_XOPEN + + +53  + #SEEK_SET + 0 + + ) + +54  + #SEEK_CUR + 1 + + ) + +55  + #SEEK_END + 2 + + ) + +63  +f + ( +__fd +,  +__cmd +, ...); + +71 #ide +__USE_FILE_OFFSET64 + + +72  + $ݒ + ( +__cڡ + * +__fe +,  +__oag +, ... + `__nnu + ((1)); + +74 #ifde +__REDIRECT + + +75  + `__REDIRECT + ( +ݒ +, ( +__cڡ + * +__fe +,  +__oag +, ...), +ݒ64 +) + +76 + `__nnu + ((1)); + +78  + #ݒ + +ݒ64 + + + ) + +81 #ifde +__USE_LARGEFILE64 + + +82  + $ݒ64 + ( +__cڡ + * +__fe +,  +__oag +, ... + `__nnu + ((1)); + +90 #ide +__USE_FILE_OFFSET64 + + +91  + $t + ( +__cڡ + * +__fe +, +__mode_t + +__mode + + `__nnu + ((1)); + +93 #ifde +__REDIRECT + + +94  + `__REDIRECT + ( +t +, ( +__cڡ + * +__fe +, +__mode_t + +__mode +), + +95 +t64 + + `__nnu + ((1)); + +97  + #t + +t64 + + + ) + +100 #ifde +__USE_LARGEFILE64 + + +101  + $t64 + ( +__cڡ + * +__fe +, +__mode_t + +__mode + + `__nnu + ((1)); + +104 #i! +defed + +F_LOCK + && (defed +__USE_MISC + || (defed +__USE_XOPEN_EXTENDED + \ + +105 && ! +defed + +__USE_POSIX +)) + +114  + #F_ULOCK + 0 + + ) + +115  + #F_LOCK + 1 + + ) + +116  + #F_TLOCK + 2 + + ) + +117  + #F_TEST + 3 + + ) + +119 #ide +__USE_FILE_OFFSET64 + + +120  + `lockf + ( +__fd +,  +__cmd +, +__off_t + +__n +); + +122 #ifde +__REDIRECT + + +123  + `__REDIRECT + ( +lockf +, ( +__fd +,  +__cmd +, +__off64_t + +__n +), +lockf64 +); + +125  + #lockf + +lockf64 + + + ) + +128 #ifde +__USE_LARGEFILE64 + + +129  + `lockf64 + ( +__fd +,  +__cmd +, +__off64_t + +__n +); + +133 #ifde +__USE_XOPEN2K + + +136 #ide +__USE_FILE_OFFSET64 + + +137  + $posix_dvi + ( +__fd +, +__off_t + +__offt +, __off_ +__n +, + +138  +__advi + +__THROW +; + +140 #ifde +__REDIRECT_NTH + + +141  + `__REDIRECT_NTH + ( +posix_dvi +, ( +__fd +, +__off64_t + +__offt +, + +142 +__off64_t + +__n +,  +__advi +), + +143 +posix_dvi64 +); + +145  + #posix_dvi + +posix_dvi64 + + + ) + +148 #ifde +__USE_LARGEFILE64 + + +149  + $posix_dvi64 + ( +__fd +, +__off64_t + +__offt +, __off64_ +__n +, + +150  +__advi + +__THROW +; + +158 #ide +__USE_FILE_OFFSET64 + + +159  + `posix_o + ( +__fd +, +__off_t + +__offt +, __off_ +__n +); + +161 #ifde +__REDIRECT + + +162  + `__REDIRECT + ( +posix_o +, ( +__fd +, +__off64_t + +__offt +, + +163 +__off64_t + +__n +), + +164 +posix_o64 +); + +166  + #posix_o + +posix_o64 + + + ) + +169 #ifde +__USE_LARGEFILE64 + + +170  + `posix_o64 + ( +__fd +, +__off64_t + +__offt +, __off64_ +__n +); + +174 +__END_DECLS + + + @/usr/include/linux/adfs_fs_sb.h + +7 #ide +_ADFS_FS_SB + + +8  + #_ADFS_FS_SB + + + ) + +10  + ~ + +15  + gadfs_discm +; + +16  + gadfs_d_s +; + +21  + sadfs_sb_fo + { + +22  +adfs_discm + * + ms_m +; + +23  +adfs_d_s + * + ms_d +; + +25 +uid_t + + ms_uid +; + +26 +gid_t + + ms_gid +; + +27 +umode_t + + ms_owr_mask +; + +28 +umode_t + + ms_h_mask +; + +30 +__u32 + + ms_ids_r_ze +; + +31 +__u32 + + ms_idn +; + +32 +__u32 + + ms_m_size +; + +33  + ms_size +; + +34 sigd  + ms_m2blk +; + +35  + ms_log2shesize +; + +36 +__32 + + ms_vsi +; + +37  + ms_m +; + + @/usr/include/linux/cache.h + +1 #ide +__LINUX_CACHE_H + + +2  + #__LINUX_CACHE_H + + + ) + +4  + ~ + +5  + ~ + +7 #ide +L1_CACHE_ALIGN + + +8  + #L1_CACHE_ALIGN +( +x + + `ALIGN +(x, +L1_CACHE_BYTES +) + + ) + +11 #ide +SMP_CACHE_BYTES + + +12  + #SMP_CACHE_BYTES + +L1_CACHE_BYTES + + + ) + +15 #ide +____che_igd + + +16  + #____che_igd + + `__ibu__ +(( + `__igd__ +( +SMP_CACHE_BYTES +))) + + ) + +19 #ide +____che_igd__smp + + +20 #ifde +CONFIG_SMP + + +21  + #____che_igd__smp + +____che_igd + + + ) + +23  + #____che_igd__smp + + + ) + +27 #ide +__che_igd + + +28  + #__che_igd + \ + +29 + `__ibu__ +(( + `__igd__ +( +SMP_CACHE_BYTES +), \ + +30 + `__i__ +(".da.che_igd"))) + + ) + +33 #ide +__che_igd__smp + + +34 #ifde +CONFIG_SMP + + +35  + #__che_igd__smp + +__che_igd + + + ) + +37  + #__che_igd__smp + + + ) + +41 #i! +defed +( +____che_maxigd__smp +) + +42 #i +defed +( +CONFIG_SMP +) + +43  + #____che_maxigd__smp + \ + +44 + `__ibu__ +(( + `__igd__ +(1 << ( +L1_CACHE_SHIFT_MAX +)))) + + ) + +46  + #____che_maxigd__smp + + + ) + + @/usr/include/linux/config.h + + @/usr/include/linux/efs_fs_i.h + +9 #idef +__EFS_FS_I_H__ + + +10  + #__EFS_FS_I_H__ + + + ) + +12  +t32_t + + tefs_block_t +; + +13  +ut32_t + + tefs_o_t +; + +15  + #EFS_DIRECTEXTENTS + 12 + + ) + +20  + uex_u + { + +21  + mw +[8]; + +22  + sex_s + { + +23  + mex_magic +:8; + +24  + mex_bn +:24; + +25  + mex_ngth +:8; + +26  + mex_offt +:24; + +27 } + mcooked +; + +28 } + tefs_ex +; + +30  + sedevs + { + +31 +__be16 + + modev +; + +32 +__be32 + + mndev +; + +33 } + tefs_devs +; + +39  + sefs_dode + { + +40 +__be16 + + mdi_mode +; + +41 +__be16 + + mdi_ƚk +; + +42 +__be16 + + mdi_uid +; + +43 +__be16 + + mdi_gid +; + +44 +__be32 + + mdi_size +; + +45 +__be32 + + mdi_ime +; + +46 +__be32 + + mdi_mtime +; + +47 +__be32 + + mdi_ime +; + +48 +__be32 + + mdi_g +; + +49 +__be16 + + mdi_numexs +; + +50 +u_ch + + mdi_vsi +; + +51 +u_ch + + mdi_e +; + +52  + udi_addr + { + +53 +efs_ex + + mdi_exs +[ +EFS_DIRECTEXTENTS +]; + +54 +efs_devs + + mdi_dev +; + +55 } + mdi_u +; + + @/usr/include/linux/efs_fs_sb.h + +9 #ide +__EFS_FS_SB_H__ + + +10  + #__EFS_FS_SB_H__ + + + ) + +12  + ~ + +15  + #EFS_SUPER_MAGIC + 0x414A53 + + ) + +18  + #EFS_MAGIC + 0x072959 + + ) + +19  + #EFS_NEWMAGIC + 0x07295a + + ) + +21  + #IS_EFS_MAGIC +( +x +((x = +EFS_MAGIC +|| (x = +EFS_NEWMAGIC +)) + + ) + +23  + #EFS_SUPER + 1 + + ) + +24  + #EFS_ROOTINODE + 2 + + ) + +27  + sefs_sur + { + +28 +__be32 + + mfs_size +; + +29 +__be32 + + mfs_fcg +; + +30 +__be32 + + mfs_cgfsize +; + +31 +__be16 + + mfs_cgisize +; + +32 +__be16 + + mfs_s +; + +33 +__be16 + + mfs_hds +; + +34 +__be16 + + mfs_ncg +; + +35 +__be16 + + mfs_dty +; + +36 +__be32 + + mfs_time +; + +37 +__be32 + + mfs_magic +; + +38  + mfs_ame +[6]; + +39  + mfs_ack +[6]; + +40 +__be32 + + mfs_bmsize +; + +41 +__be32 + + mfs_t +; + +42 +__be32 + + mfs_tode +; + +43 +__be32 + + mfs_bmblock +; + +44 +__be32 + + mfs_sb +; + +45 +__be32 + + mfs_ϡoc +; + +46  + mfs_e +[20]; + +47 +__be32 + + mfs_checksum +; + +51  + sefs_sb_fo + { + +52 +__u32 + + mfs_magic +; + +53 +__u32 + + mfs_t +; + +54 +__u32 + + mf_block +; + +55 +__u32 + + mtٮ_blocks +; + +56 +__u32 + + mgroup_size +; + +57 +__u32 + + mda_ +; + +58 +__u32 + + mode_ +; + +59 +__u16 + + mode_blocks +; + +60 +__u16 + + mtٮ_groups +; + + @/usr/include/linux/fcntl.h + +1 #ide +_LINUX_FCNTL_H + + +2  + #_LINUX_FCNTL_H + + + ) + +4  + ~ + +6  + #F_SETLEASE + ( +F_LINUX_SPECIFIC_BASE ++0) + + ) + +7  + #F_GETLEASE + ( +F_LINUX_SPECIFIC_BASE ++1) + + ) + +13  + #F_NOTIFY + ( +F_LINUX_SPECIFIC_BASE ++2) + + ) + +18  + #DN_ACCESS + 0x00000001 + + ) + +19  + #DN_MODIFY + 0x00000002 + + ) + +20  + #DN_CREATE + 0x00000004 + + ) + +21  + #DN_DELETE + 0x00000008 + + ) + +22  + #DN_RENAME + 0x00000010 + + ) + +23  + #DN_ATTRIB + 0x00000020 + + ) + +24  + #DN_MULTISHOT + 0x80000000 + + ) + + @/usr/include/linux/ioctl.h + +1 #ide +_LINUX_IOCTL_H + + +2  + #_LINUX_IOCTL_H + + + ) + +4  + ~ + + @/usr/include/linux/iso_fs_i.h + +1 #ide +_ISO_FS_I + + +2  + #_ISO_FS_I + + + ) + +4  + ~ + +6 + eisofs_fe_fm + { + +7 + misofs_fe_nm + = 0, + +8 + misofs_fe_ + = 1, + +9 + misofs_fe_comesd + = 2 + + @/usr/include/linux/iso_fs_sb.h + +1 #ide +_ISOFS_FS_SB + + +2  + #_ISOFS_FS_SB + + + ) + +7  + sisofs_sb_fo + { + +8  + ms_nodes +; + +9  + ms_nzes +; + +10  + ms_fdaze +; + +11  + ms_log_ze_size +; + +12  + ms_max_size +; + +14  + ms_high_sa +; + +15  + ms_mpg +; + +16  + ms_rock_offt +; + +17  + ms_rock +; + +18  + ms_jޛt_v +; + +19  + ms_utf8 +; + +20  + ms_u +; + +23  + ms_unhide +; + +24  + ms_nosuid +; + +25  + ms_nodev +; + +26  + ms_nocomess +; + +28 +mode_t + + ms_mode +; + +29 +gid_t + + ms_gid +; + +30 +uid_t + + ms_uid +; + +31  +s_b + * + ms_s_iocht +; + + @/usr/include/linux/kdev_t.h + +1 #ide +_LINUX_KDEV_T_H + + +2  + #_LINUX_KDEV_T_H + + + ) + +8  + #MAJOR +( +dev +((dev)>>8) + + ) + +9  + #MINOR +( +dev +((dev& 0xff) + + ) + +10  + #MKDEV +( +ma +, +mi +((ma)<<8 | (mi)) + + ) + + @/usr/include/linux/limits.h + +1 #ide +_LINUX_LIMITS_H + + +2  + #_LINUX_LIMITS_H + + + ) + +4  + #NR_OPEN + 1024 + + ) + +6  + #NGROUPS_MAX + 65536 + + ) + +7  + #ARG_MAX + 131072 + + ) + +8  + #CHILD_MAX + 999 + + ) + +9  + #OPEN_MAX + 256 + + ) + +10  + #LINK_MAX + 127 + + ) + +11  + #MAX_CANON + 255 + + ) + +12  + #MAX_INPUT + 255 + + ) + +13  + #NAME_MAX + 255 + + ) + +14  + #PATH_MAX + 4096 + + ) + +15  + #PIPE_BUF + 4096 + + ) + +16  + #XATTR_NAME_MAX + 255 + + ) + +17  + #XATTR_SIZE_MAX + 65536 + + ) + +18  + #XATTR_LIST_MAX + 65536 + + ) + +20  + #RTSIG_MAX + 32 + + ) + + @/usr/include/linux/linkage.h + +1 #ide +_LINUX_LINKAGE_H + + +2  + #_LINUX_LINKAGE_H + + + ) + +4  + ~ + +6 #ifde +__lulus + + +7  + #CPP_ASMLINKAGE + "C" + + ) + +9  + #CPP_ASMLINKAGE + + + ) + +12 #ide +asmlkage + + +13  + #asmlkage + +CPP_ASMLINKAGE + + + ) + +16 #ide +evt__ + + +17  + #evt__ +( +t +d{ } 0) + + ) + +20 #ide +__ALIGN + + +21  + #__ALIGN + . +ign + 4,0x90 + + ) + +22  + #__ALIGN_STR + ".ig4,0x90" + + ) + +25 #ifde +__ASSEMBLY__ + + +27  + #ALIGN + +__ALIGN + + + ) + +28  + #ALIGN_STR + +__ALIGN_STR + + + ) + +30  + #ENTRY +( +me +) \ + +31 . +globl + +me +; \ + +32 +ALIGN +; \ + +33 +me +: + + ) + +37  + #NORET_TYPE + + + ) + +38  + #ATTRIB_NORET + + `__ibu__ +(( +nܑu +)) + + ) + +39  + #NORET_AND + +nܑu +, + + ) + +41 #ide +FASTCALL + + +42  + #FASTCALL +( +x + + ) +x + +43  + # + + + ) + + @/usr/include/linux/list.h + +1  + ~ + + @/usr/include/linux/mount.h + +1  + ~ + + @/usr/include/linux/net.h + +18 #ide +_LINUX_NET_H + + +19  + #_LINUX_NET_H + + + ) + +21  + #NPROTO + 32 + + ) + +23  + #SYS_SOCKET + 1 + + ) + +24  + #SYS_BIND + 2 + + ) + +25  + #SYS_CONNECT + 3 + + ) + +26  + #SYS_LISTEN + 4 + + ) + +27  + #SYS_ACCEPT + 5 + + ) + +28  + #SYS_GETSOCKNAME + 6 + + ) + +29  + #SYS_GETPEERNAME + 7 + + ) + +30  + #SYS_SOCKETPAIR + 8 + + ) + +31  + #SYS_SEND + 9 + + ) + +32  + #SYS_RECV + 10 + + ) + +33  + #SYS_SENDTO + 11 + + ) + +34  + #SYS_RECVFROM + 12 + + ) + +35  + #SYS_SHUTDOWN + 13 + + ) + +36  + #SYS_SETSOCKOPT + 14 + + ) + +37  + #SYS_GETSOCKOPT + 15 + + ) + +38  + #SYS_SENDMSG + 16 + + ) + +39  + #SYS_RECVMSG + 17 + + ) + +42 + mSS_FREE + = 0, + +43 + mSS_UNCONNECTED +, + +44 + mSS_CONNECTING +, + +45 + mSS_CONNECTED +, + +46 + mSS_DISCONNECTING + + +47 } + tsock_e +; + +49  + #__SO_ACCEPTCON + (1 << 16 + + ) + + @/usr/include/linux/nfs_fs_i.h + +1 #ide +_NFS_FS_I + + +2  + #_NFS_FS_I + + + ) + +4  + ~ + +5  + ~ + +7  + gm_lockowr +; + +12  + snfs_lock_fo + { + +13 +__u32 + + me +; + +14 +__u32 + + mags +; + +15  +m_lockowr + * + mowr +; + +21  + #NFS_LCK_GRANTED + 0x0001 + + ) + +22  + #NFS_LCK_RECLAIM + 0x0002 + + ) + + @/usr/include/linux/nfs_fs_sb.h + +1 #ide +_NFS_FS_SB + + +2  + #_NFS_FS_SB + + + ) + +4  + ~ + +6  + ~ + +11  + snfs_rv + { + +12  +c_ + * + m +; + +13  +c_ + * + m_sys +; + +14  +nfs_c_s + * + mc_s +; + +15  +backg_dev_fo + + mbackg_dev_fo +; + +16  + mags +; + +17  + mps +; + +18  + mrsize +; + +19  + mages +; + +20  + mwsize +; + +21  + mwges +; + +22  + mwtmu +; + +23  + mdtsize +; + +24  + mbsize +; + +25  + maegm +; + +26  + maegmax +; + +27  + macdm +; + +28  + macdmax +; + +29  + mm +; + +30 * + mhome +; + +31  +nfs_fh + + mfh +; + +32  +sockaddr_ + + maddr +; + +33 #ifde +CONFIG_NFS_V4 + + +37  + m_addr +[16]; + +38 * + mm_th +; + +39  +nfs4_ + * + mnfs4_e +; + +40  +li_hd + + mnfs4_siblgs +; + +43 +__u32 + + m_bmask +[2]; + +46 +__u32 + + ma_bmask +; + +53  + #NFS_CAP_READDIRPLUS + (1U << 0) + + ) + +54  + #NFS_CAP_HARDLINKS + (1U << 1) + + ) + +55  + #NFS_CAP_SYMLINKS + (1U << 2) + + ) + +56  + #NFS_CAP_ACLS + (1U << 3) + + ) + + @/usr/include/linux/pipe_fs_i.h + +1 #ide +_LINUX_PIPE_FS_I_H + + +2  + #_LINUX_PIPE_FS_I_H + + + ) + +4  + #PIPEFS_MAGIC + 0x50495045 + + ) + +6  + #PIPE_BUFFERS + (16) + + ) + +8  + spe_bufr + { + +9  +ge + * + mge +; + +10  + mofft +, + mn +; + +11  +pe_buf_ݔis + * + ms +; + +14  + spe_buf_ݔis + { + +15  + mn_mge +; + +16 * (* + mm +)( + mfe + *,  + mpe_ode_fo + *,  + mpe_bufr + *); + +17 (* + munm +)( + mpe_ode_fo + *,  + mpe_bufr + *); + +18 (* + ma +)( + mpe_ode_fo + *,  + mpe_bufr + *); + +21  + spe_ode_fo + { + +22 +wa_queue_hd_t + + mwa +; + +23  + mbufs +, + mcurbuf +; + +24  +pe_bufr + + mbufs +[ +PIPE_BUFFERS +]; + +25  +ge + * + mtmp_ge +; + +26  + mt +; + +27  + mads +; + +28  + mwrs +; + +29  + mwag_wrs +; + +30  + mr_cou +; + +31  + mw_cou +; + +32  +sync_ru + * + msync_ads +; + +33  +sync_ru + * + msync_wrs +; + +38  + #PIPE_SIZE + +PAGE_SIZE + + + ) + +40  + #PIPE_SEM +( +ode +(&(ode). +i_m +) + + ) + +41  + #PIPE_WAIT +( +ode +(&(ode). +i_pe +-> +wa +) + + ) + +42  + #PIPE_BASE +( +ode +((ode). +i_pe +-> +ba +) + + ) + +43  + #PIPE_START +( +ode +((ode). +i_pe +-> +t +) + + ) + +44  + #PIPE_LEN +( +ode +((ode). +i_pe +-> +n +) + + ) + +45  + #PIPE_READERS +( +ode +((ode). +i_pe +-> +ads +) + + ) + +46  + #PIPE_WRITERS +( +ode +((ode). +i_pe +-> +wrs +) + + ) + +47  + #PIPE_WAITING_WRITERS +( +ode +((ode). +i_pe +-> +wag_wrs +) + + ) + +48  + #PIPE_RCOUNTER +( +ode +((ode). +i_pe +-> +r_cou +) + + ) + +49  + #PIPE_WCOUNTER +( +ode +((ode). +i_pe +-> +w_cou +) + + ) + +50  + #PIPE_FASYNC_READERS +( +ode +(&((ode). +i_pe +-> +sync_ads +)) + + ) + +51  + #PIPE_FASYNC_WRITERS +( +ode +(&((ode). +i_pe +-> +sync_wrs +)) + + ) + + @/usr/include/linux/quota.h + +34 #ide +_LINUX_QUOTA_ + + +35  + #_LINUX_QUOTA_ + + + ) + +37  + ~ + +38  + ~ + +40  + #__DQUOT_VERSION__ + "dqu_6.5.1" + + ) + +41  + #__DQUOT_NUM_VERSION__ + 6*10000+5*100+1 + + ) + +43  +__kl_uid32_t + + tqid_t +; + +44  +__u64 + + tqsize_t +; + +47  + #QUOTABLOCK_BITS + 10 + + ) + +48  + #QUOTABLOCK_SIZE + (1 << +QUOTABLOCK_BITS +) + + ) + +51  + #qb2kb +( +x +((x<< ( +QUOTABLOCK_BITS +-10)) + + ) + +52  + #kb2qb +( +x +((x>> ( +QUOTABLOCK_BITS +-10)) + + ) + +53  + #toqb +( +x +(((x+ +QUOTABLOCK_SIZE + - 1>> +QUOTABLOCK_BITS +) + + ) + +55  + #MAXQUOTAS + 2 + + ) + +56  + #USRQUOTA + 0 + + ) + +57  + #GRPQUOTA + 1 + + ) + +62  + #INITQFNAMES + { \ + +66 }; + + ) + +74  + #SUBCMDMASK + 0x00ff + + ) + +75  + #SUBCMDSHIFT + 8 + + ) + +76  + #QCMD +( +cmd +, +ty +(((cmd<< +SUBCMDSHIFT +| (y& +SUBCMDMASK +)) + + ) + +78  + #Q_SYNC + 0x800001 + + ) + +79  + #Q_QUOTAON + 0x800002 + + ) + +80  + #Q_QUOTAOFF + 0x800003 + + ) + +81  + #Q_GETFMT + 0x800004 + + ) + +82  + #Q_GETINFO + 0x800005 + + ) + +83  + #Q_SETINFO + 0x800006 + + ) + +84  + #Q_GETQUOTA + 0x800007 + + ) + +85  + #Q_SETQUOTA + 0x800008 + + ) + +91  + #QIF_BLIMITS + 1 + + ) + +92  + #QIF_SPACE + 2 + + ) + +93  + #QIF_ILIMITS + 4 + + ) + +94  + #QIF_INODES + 8 + + ) + +95  + #QIF_BTIME + 16 + + ) + +96  + #QIF_ITIME + 32 + + ) + +97  + #QIF_LIMITS + ( +QIF_BLIMITS + | +QIF_ILIMITS +) + + ) + +98  + #QIF_USAGE + ( +QIF_SPACE + | +QIF_INODES +) + + ) + +99  + #QIF_TIMES + ( +QIF_BTIME + | +QIF_ITIME +) + + ) + +100  + #QIF_ALL + ( +QIF_LIMITS + | +QIF_USAGE + | +QIF_TIMES +) + + ) + +102  + sif_dqblk + { + +103 +__u64 + + mdqb_bhdlim +; + +104 +__u64 + + mdqb_bsolim +; + +105 +__u64 + + mdqb_cura +; + +106 +__u64 + + mdqb_ihdlim +; + +107 +__u64 + + mdqb_isolim +; + +108 +__u64 + + mdqb_curodes +; + +109 +__u64 + + mdqb_btime +; + +110 +__u64 + + mdqb_ime +; + +111 +__u32 + + mdqb_vid +; + +118  + #IIF_BGRACE + 1 + + ) + +119  + #IIF_IGRACE + 2 + + ) + +120  + #IIF_FLAGS + 4 + + ) + +121  + #IIF_ALL + ( +IIF_BGRACE + | +IIF_IGRACE + | +IIF_FLAGS +) + + ) + +123  + sif_dqfo + { + +124 +__u64 + + mdqi_bg +; + +125 +__u64 + + mdqi_ig +; + +126 +__u32 + + mdqi_ags +; + +127 +__u32 + + mdqi_vid +; + + @/usr/include/linux/stat.h + +1 #ide +_LINUX_STAT_H + + +2  + #_LINUX_STAT_H + + + ) + +4 #i! +defed +( +__GLIBC__ +) + +6  + #S_IFMT + 00170000 + + ) + +7  + #S_IFSOCK + 0140000 + + ) + +8  + #S_IFLNK + 0120000 + + ) + +9  + #S_IFREG + 0100000 + + ) + +10  + #S_IFBLK + 0060000 + + ) + +11  + #S_IFDIR + 0040000 + + ) + +12  + #S_IFCHR + 0020000 + + ) + +13  + #S_IFIFO + 0010000 + + ) + +14  + #S_ISUID + 0004000 + + ) + +15  + #S_ISGID + 0002000 + + ) + +16  + #S_ISVTX + 0001000 + + ) + +18  + #S_ISLNK +( +m +(((m& +S_IFMT += +S_IFLNK +) + + ) + +19  + #S_ISREG +( +m +(((m& +S_IFMT += +S_IFREG +) + + ) + +20  + #S_ISDIR +( +m +(((m& +S_IFMT += +S_IFDIR +) + + ) + +21  + #S_ISCHR +( +m +(((m& +S_IFMT += +S_IFCHR +) + + ) + +22  + #S_ISBLK +( +m +(((m& +S_IFMT += +S_IFBLK +) + + ) + +23  + #S_ISFIFO +( +m +(((m& +S_IFMT += +S_IFIFO +) + + ) + +24  + #S_ISSOCK +( +m +(((m& +S_IFMT += +S_IFSOCK +) + + ) + +26  + #S_IRWXU + 00700 + + ) + +27  + #S_IRUSR + 00400 + + ) + +28  + #S_IWUSR + 00200 + + ) + +29  + #S_IXUSR + 00100 + + ) + +31  + #S_IRWXG + 00070 + + ) + +32  + #S_IRGRP + 00040 + + ) + +33  + #S_IWGRP + 00020 + + ) + +34  + #S_IXGRP + 00010 + + ) + +36  + #S_IRWXO + 00007 + + ) + +37  + #S_IROTH + 00004 + + ) + +38  + #S_IWOTH + 00002 + + ) + +39  + #S_IXOTH + 00001 + + ) + + @/usr/include/linux/stddef.h + +1 #ide +_LINUX_STDDEF_H + + +2  + #_LINUX_STDDEF_H + + + ) + +4 #unde +NULL + + +5 #i +defed +( +__lulus +) + +6  + #NULL + 0 + + ) + +8  + #NULL + ((*)0) + + ) + +11 #unde +offtof + + +12 #ifde +__comp_offtof + + +13  + #offtof +( +TYPE +, +MEMBER + + `__comp_offtof +(TYPE,MEMBER) + + ) + +15  + #offtof +( +TYPE +, +MEMBER +(( +size_t +&((TYPE *)0)->MEMBER) + + ) + + @/usr/include/linux/types.h + +1 #ide +_LINUX_TYPES_H + + +2  + #_LINUX_TYPES_H + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +8 #ide +__KERNEL_STRICT_NAMES + + +10  +__u32 + + t__kl_dev_t +; + +12 #i +defed + +WANT_KERNEL_TYPES + || !defed( +__GLIBC__ +) + +13  +__kl_fd_t + + tfd_t +; + +14  +__kl_dev_t + + tdev_t +; + +15  +__kl_o_t + + to_t +; + +16  +__kl_mode_t + + tmode_t +; + +17  +__kl_ƚk_t + + tƚk_t +; + +18  +__kl_off_t + + toff_t +; + +19  +__kl_pid_t + + tpid_t +; + +20  +__kl_daddr_t + + tdaddr_t +; + +21  +__kl_key_t + + tkey_t +; + +22  +__kl_sucds_t + + tsucds_t +; + +23  +__kl_tim_t + + ttim_t +; + +24  +__kl_ockid_t + + tockid_t +; + +25  +__kl_mqd_t + + tmqd_t +; + +27  +__kl_uid_t + + tuid_t +; + +28  +__kl_gid_t + + tgid_t +; + +30 #i( +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +)|| ( +__STDC_VERSION__ + >= 199901L) + +31  +__kl_loff_t + + tloff_t +; + +38 #ide +_SIZE_T + + +39  + #_SIZE_T + + + ) + +40  +__kl_size_t + + tsize_t +; + +43 #ide +_SSIZE_T + + +44  + #_SSIZE_T + + + ) + +45  +__kl_ssize_t + + tssize_t +; + +48 #ide +_PTRDIFF_T + + +49  + #_PTRDIFF_T + + + ) + +50  +__kl_rdiff_t + + trdiff_t +; + +53 #ide +_TIME_T + + +54  + #_TIME_T + + + ) + +55  +__kl_time_t + + ttime_t +; + +58 #ide +_CLOCK_T + + +59  + #_CLOCK_T + + + ) + +60  +__kl_ock_t + + tock_t +; + +63 #ide +_CADDR_T + + +64  + #_CADDR_T + + + ) + +65  +__kl_ddr_t + + tddr_t +; + +69  + tu_ch +; + +70  + tu_sht +; + +71  + tu_t +; + +72  + tu_lg +; + +75  + tunch +; + +76  + tusht +; + +77  + tut +; + +78  + tulg +; + +80 #ide +__BIT_TYPES_DEFINED__ + + +81  + #__BIT_TYPES_DEFINED__ + + + ) + +83  +__u8 + + tu_t8_t +; + +84  +__s8 + + tt8_t +; + +85  +__u16 + + tu_t16_t +; + +86  +__s16 + + tt16_t +; + +87  +__u32 + + tu_t32_t +; + +88  +__s32 + + tt32_t +; + +92  +__u8 + + tut8_t +; + +93  +__u16 + + tut16_t +; + +94  +__u32 + + tut32_t +; + +96 #i( +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +)|| ( +__STDC_VERSION__ + >= 199901L) + +97  +__u64 + + tut64_t +; + +98  +__u64 + + tu_t64_t +; + +99  +__s64 + + tt64_t +; + +107 #ide +HAVE_SECTOR_T + + +108  + t_t +; + +115 #ide +pgoff_t + + +116  + #pgoff_t +  + + ) + +121  + tunch +; + +122 #ide +HAVE_SECTOR_T + + +123  + t_t +; + +125 #ide +pgoff_t + + +126  + #pgoff_t +  + + ) + +133  +__u16 + + t__16 +; + +134  +__u16 + + t__be16 +; + +135  +__u32 + + t__32 +; + +136  +__u32 + + t__be32 +; + +138 #i +defed +( +__GNUC__ +) + +139 #i! +defed +( +__STRICT_ANSI__ +|| ( +__STDC_VERSION__ + >199901L|| defed( +__LLH_TYPE_LONG_IS_64BIT__ +) + +140  +__u64 + + t__64 +; + +141  +__u64 + + t__be64 +; + +153  + su + { + +154 +__kl_daddr_t + + mf_t +; + +155 +__kl_o_t + + mf_tode +; + +156  + mf_ame +[6]; + +157  + mf_ack +[6]; + + @/usr/include/linux/udf_fs_i.h + +18 #ide +_UDF_FS_I_H + + +19  + #_UDF_FS_I_H + 1 + + ) + +24  + #UDF_GETEASIZE + + `_IOR +('l', 0x40, ) + + ) + +25  + #UDF_GETEABLOCK + + `_IOR +('l', 0x41, *) + + ) + +26  + #UDF_GETVOLIDENT + + `_IOR +('l', 0x42, *) + + ) + +27  + #UDF_RELOCATE_BLOCKS + + `_IOWR +('l', 0x43, ) + + ) + + @/usr/include/linux/udf_fs_sb.h + +18 #ide +_UDF_FS_SB_H + + +19  + #_UDF_FS_SB_H + 1 + + ) + +21  + ~ + +23  + ~ + +25 #agm +ck +(1) + +27  + #UDF_MAX_BLOCK_LOADED + 8 + + ) + +29  + #UDF_TYPE1_MAP15 + 0x1511U + + ) + +30  + #UDF_VIRTUAL_MAP15 + 0x1512U + + ) + +31  + #UDF_VIRTUAL_MAP20 + 0x2012U + + ) + +32  + #UDF_SPARABLE_MAP15 + 0x1522U + + ) + +35  + sudf_vtu_da + + +37 +__u32 + + ms_num_s +; + +38 +__u16 + + ms_t_offt +; + +43 #agm +ck +() + + @/usr/include/linux/wait.h + +1 #ide +_LINUX_WAIT_H + + +2  + #_LINUX_WAIT_H + + + ) + +4 #i +defed +( +__GLIBC__ +) + +6 #i +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +) + +9  + ~ + +13  + #WNOHANG + 0x00000001 + + ) + +14  + #WUNTRACED + 0x00000002 + + ) + +15  + #WSTOPPED + +WUNTRACED + + + ) + +16  + #WEXITED + 0x00000004 + + ) + +17  + #WCONTINUED + 0x00000008 + + ) + +18  + #WNOWAIT + 0x01000000 + + ) + +20  + #__WNOTHREAD + 0x20000000 + + ) + +21  + #__WALL + 0x40000000 + + ) + +22  + #__WCLONE + 0x80000000 + + ) + +25  + #P_ALL + 0 + + ) + +26  + #P_PID + 1 + + ) + +27  + #P_PGID + 2 + + ) + + @/usr/include/setjmp.h + +23 #idef +_SETJMP_H + + +24  + #_SETJMP_H + 1 + + ) + +26  + ~ + +28 + g__BEGIN_DECLS + + +30  + ~ + +31  + ~ + +33 +__BEGIN_NAMESPACE_STD + + +36  + s__jmp_buf_g + + +42 +__jmp_buf + + m__jmpbuf +; + +43  + m__mask_was_ved +; + +44 +__sigt_t + + m__ved_mask +; + +45 } + tjmp_buf +[1]; + +50  + $tjmp + ( +jmp_buf + +__v + +__THROW +; + +52 +__END_NAMESPACE_STD + + +53 + $__USING_NAMESPACE_STD +( +__jmp_buf_g +) + +58  + `__sigtjmp + ( +__jmp_buf_g + +__v +[1],  +__vemask + +__THROW +; + +60 #idef +__FAVOR_BSD + + +63  + `_tjmp + ( +__jmp_buf_g + +__v +[1] +__THROW +; + +67  + #tjmp +( +v + + `_tjmp + (v) + + ) + +72  + #tjmp +( +v + + `tjmp + (v) + + ) + +76 +__BEGIN_NAMESPACE_STD + + +80  + `lgjmp + ( +__jmp_buf_g + +__v +[1],  +__v +) + +81 +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +83 +__END_NAMESPACE_STD + + +85 #i +defed + +__USE_BSD + || defed +__USE_XOPEN + + +89  + `_lgjmp + ( +__jmp_buf_g + +__v +[1],  +__v +) + +90 +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +94 #ifdef +__USE_POSIX + + +98  +__jmp_buf_g + + tsigjmp_buf +[1]; + +102  + #sigtjmp +( +v +, +vemask + + `__sigtjmp + (v, savemask) + + ) + +108  + $siglgjmp + ( +sigjmp_buf + +__v +,  +__v +) + +109 +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +112 +__END_DECLS + + + @/usr/include/stdint.h + +23 #ide +_STDINT_H + + +24  + #_STDINT_H + 1 + + ) + +26  + ~ + +27  + ~ + +28  + ~ + +35 #ide +__t8_t_defed + + +36  + #__t8_t_defed + + + ) + +37 sigd  + tt8_t +; + +38  + tt16_t +; + +39  + tt32_t +; + +40 #i +__WORDSIZE + == 64 + +41  + tt64_t +; + +43 +__exnsi__ + + +44  + tt64_t +; + +49  + tut8_t +; + +50  + tut16_t +; + +51 #ide +__ut32_t_defed + + +52  + tut32_t +; + +53  + #__ut32_t_defed + + + ) + +55 #i +__WORDSIZE + == 64 + +56  + tut64_t +; + +58 +__exnsi__ + + +59  + tut64_t +; + +66 sigd  + tt_a8_t +; + +67  + tt_a16_t +; + +68  + tt_a32_t +; + +69 #i +__WORDSIZE + == 64 + +70  + tt_a64_t +; + +72 +__exnsi__ + + +73  + tt_a64_t +; + +77  + tut_a8_t +; + +78  + tut_a16_t +; + +79  + tut_a32_t +; + +80 #i +__WORDSIZE + == 64 + +81  + tut_a64_t +; + +83 +__exnsi__ + + +84  + tut_a64_t +; + +91 sigd  + tt_8_t +; + +92 #i +__WORDSIZE + == 64 + +93  + tt_16_t +; + +94  + tt_32_t +; + +95  + tt_64_t +; + +97  + tt_16_t +; + +98  + tt_32_t +; + +99 +__exnsi__ + + +100  + tt_64_t +; + +104  + tut_8_t +; + +105 #i +__WORDSIZE + == 64 + +106  + tut_16_t +; + +107  + tut_32_t +; + +108  + tut_64_t +; + +110  + tut_16_t +; + +111  + tut_32_t +; + +112 +__exnsi__ + + +113  + tut_64_t +; + +118 #i +__WORDSIZE + == 64 + +119 #ide +___t_defed + + +120  + t_t +; + +121  + #___t_defed + + + ) + +123  + tu_t +; + +125 #ide +___t_defed + + +126  + t_t +; + +127  + #___t_defed + + + ) + +129  + tu_t +; + +134 #i +__WORDSIZE + == 64 + +135  + ttmax_t +; + +136  + tutmax_t +; + +138 +__exnsi__ + + +139  + ttmax_t +; + +140 +__exnsi__ + + +141  + tutmax_t +; + +147 #i! +defed + +__lulus + || defed +__STDC_LIMIT_MACROS + + +149 #i +__WORDSIZE + == 64 + +150  + #__INT64_C +( +c +## +L + + + ) + +151  + #__UINT64_C +( +c +## +UL + + + ) + +153  + #__INT64_C +( +c +## +LL + + + ) + +154  + #__UINT64_C +( +c +## +ULL + + + ) + +160  + #INT8_MIN + (-128) + + ) + +161  + #INT16_MIN + (-32767-1) + + ) + +162  + #INT32_MIN + (-2147483647-1) + + ) + +163  + #INT64_MIN + (- + `__INT64_C +(9223372036854775807)-1) + + ) + +165  + #INT8_MAX + (127) + + ) + +166  + #INT16_MAX + (32767) + + ) + +167  + #INT32_MAX + (2147483647) + + ) + +168  + #INT64_MAX + ( + `__INT64_C +(9223372036854775807)) + + ) + +171  + #UINT8_MAX + (255) + + ) + +172  + #UINT16_MAX + (65535) + + ) + +173  + #UINT32_MAX + (4294967295U) + + ) + +174  + #UINT64_MAX + ( + `__UINT64_C +(18446744073709551615)) + + ) + +178  + #INT_LEAST8_MIN + (-128) + + ) + +179  + #INT_LEAST16_MIN + (-32767-1) + + ) + +180  + #INT_LEAST32_MIN + (-2147483647-1) + + ) + +181  + #INT_LEAST64_MIN + (- + `__INT64_C +(9223372036854775807)-1) + + ) + +183  + #INT_LEAST8_MAX + (127) + + ) + +184  + #INT_LEAST16_MAX + (32767) + + ) + +185  + #INT_LEAST32_MAX + (2147483647) + + ) + +186  + #INT_LEAST64_MAX + ( + `__INT64_C +(9223372036854775807)) + + ) + +189  + #UINT_LEAST8_MAX + (255) + + ) + +190  + #UINT_LEAST16_MAX + (65535) + + ) + +191  + #UINT_LEAST32_MAX + (4294967295U) + + ) + +192  + #UINT_LEAST64_MAX + ( + `__UINT64_C +(18446744073709551615)) + + ) + +196  + #INT_FAST8_MIN + (-128) + + ) + +197 #i +__WORDSIZE + == 64 + +198  + #INT_FAST16_MIN + (-9223372036854775807L-1) + + ) + +199  + #INT_FAST32_MIN + (-9223372036854775807L-1) + + ) + +201  + #INT_FAST16_MIN + (-2147483647-1) + + ) + +202  + #INT_FAST32_MIN + (-2147483647-1) + + ) + +204  + #INT_FAST64_MIN + (- + `__INT64_C +(9223372036854775807)-1) + + ) + +206  + #INT_FAST8_MAX + (127) + + ) + +207 #i +__WORDSIZE + == 64 + +208  + #INT_FAST16_MAX + (9223372036854775807L) + + ) + +209  + #INT_FAST32_MAX + (9223372036854775807L) + + ) + +211  + #INT_FAST16_MAX + (2147483647) + + ) + +212  + #INT_FAST32_MAX + (2147483647) + + ) + +214  + #INT_FAST64_MAX + ( + `__INT64_C +(9223372036854775807)) + + ) + +217  + #UINT_FAST8_MAX + (255) + + ) + +218 #i +__WORDSIZE + == 64 + +219  + #UINT_FAST16_MAX + (18446744073709551615UL) + + ) + +220  + #UINT_FAST32_MAX + (18446744073709551615UL) + + ) + +222  + #UINT_FAST16_MAX + (4294967295U) + + ) + +223  + #UINT_FAST32_MAX + (4294967295U) + + ) + +225  + #UINT_FAST64_MAX + ( + `__UINT64_C +(18446744073709551615)) + + ) + +229 #i +__WORDSIZE + == 64 + +230  + #INTPTR_MIN + (-9223372036854775807L-1) + + ) + +231  + #INTPTR_MAX + (9223372036854775807L) + + ) + +232  + #UINTPTR_MAX + (18446744073709551615UL) + + ) + +234  + #INTPTR_MIN + (-2147483647-1) + + ) + +235  + #INTPTR_MAX + (2147483647) + + ) + +236  + #UINTPTR_MAX + (4294967295U) + + ) + +241  + #INTMAX_MIN + (- + `__INT64_C +(9223372036854775807)-1) + + ) + +243  + #INTMAX_MAX + ( + `__INT64_C +(9223372036854775807)) + + ) + +246  + #UINTMAX_MAX + ( + `__UINT64_C +(18446744073709551615)) + + ) + +252 #i +__WORDSIZE + == 64 + +253  + #PTRDIFF_MIN + (-9223372036854775807L-1) + + ) + +254  + #PTRDIFF_MAX + (9223372036854775807L) + + ) + +256  + #PTRDIFF_MIN + (-2147483647-1) + + ) + +257  + #PTRDIFF_MAX + (2147483647) + + ) + +261  + #SIG_ATOMIC_MIN + (-2147483647-1) + + ) + +262  + #SIG_ATOMIC_MAX + (2147483647) + + ) + +265 #i +__WORDSIZE + == 64 + +266  + #SIZE_MAX + (18446744073709551615UL) + + ) + +268  + #SIZE_MAX + (4294967295U) + + ) + +272 #ide +WCHAR_MIN + + +274  + #WCHAR_MIN + +__WCHAR_MIN + + + ) + +275  + #WCHAR_MAX + +__WCHAR_MAX + + + ) + +279  + #WINT_MIN + (0u) + + ) + +280  + #WINT_MAX + (4294967295u) + + ) + +287 #i! +defed + +__lulus + || defed +__STDC_CONSTANT_MACROS + + +290  + #INT8_C +( +c + + ) +c + +291  + #INT16_C +( +c + + ) +c + +292  + #INT32_C +( +c + + ) +c + +293 #i +__WORDSIZE + == 64 + +294  + #INT64_C +( +c +## +L + + + ) + +296  + #INT64_C +( +c +## +LL + + + ) + +300  + #UINT8_C +( +c +## +U + + + ) + +301  + #UINT16_C +( +c +## +U + + + ) + +302  + #UINT32_C +( +c +## +U + + + ) + +303 #i +__WORDSIZE + == 64 + +304  + #UINT64_C +( +c +## +UL + + + ) + +306  + #UINT64_C +( +c +## +ULL + + + ) + +310 #i +__WORDSIZE + == 64 + +311  + #INTMAX_C +( +c +## +L + + + ) + +312  + #UINTMAX_C +( +c +## +UL + + + ) + +314  + #INTMAX_C +( +c +## +LL + + + ) + +315  + #UINTMAX_C +( +c +## +ULL + + + ) + + @/usr/include/stdio.h + +24 #ide +_STDIO_H + + +26 #i! +defed + +__ed_FILE + && !defed +__ed___FILE + + +27  + #_STDIO_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +32  + #__ed_size_t + + + ) + +33  + #__ed_NULL + + + ) + +34  + ~ + +36  + ~ + +37  + #__ed_FILE + + + ) + +38  + #__ed___FILE + + + ) + +42 #i! +defed + +__FILE_defed + && defed +__ed_FILE + + +44 +__BEGIN_NAMESPACE_STD + + +46  +_IO_FILE + + tFILE +; + +47 + g__END_NAMESPACE_STD + + +48 #i +defed + +__USE_LARGEFILE64 + || defed +__USE_SVID + || defed +__USE_POSIX + \ + +49 || +defed + + g__USE_BSD + || defed + g__USE_ISOC99 + || defed + g__USE_XOPEN + \ + +50 || +defed + +__USE_POSIX2 + + +51 + $__USING_NAMESPACE_STD +( +FILE +) + +54  + #__FILE_defed + 1 + + ) + +56 #unde +__ed_FILE + + +59 #i! +defed + +____FILE_defed + && defed +__ed___FILE + + +62  +_IO_FILE + + t__FILE +; + +64  + #____FILE_defed + 1 + + ) + +66 #unde +__ed___FILE + + +69 #ifdef +_STDIO_H + + +70  + #_STDIO_USES_IOSTREAM + + + ) + +72  + ~ + +74 #ifde +__USE_XOPEN + + +75 #ifde +__GNUC__ + + +76 #ide +_VA_LIST_DEFINED + + +77  +_G_va_li + + tva_li +; + +78  + #_VA_LIST_DEFINED + + + ) + +81  + ~ + +86 +__BEGIN_NAMESPACE_STD + + +87 #ide +__USE_FILE_OFFSET64 + + +88  +_G_os_t + + tos_t +; + +90  +_G_os64_t + + tos_t +; + +92 +__END_NAMESPACE_STD + + +93 #ifde +__USE_LARGEFILE64 + + +94  +_G_os64_t + + tos64_t +; + +98  + #_IOFBF + 0 + + ) + +99  + #_IOLBF + 1 + + ) + +100  + #_IONBF + 2 + + ) + +104 #ide +BUFSIZ + + +105  + #BUFSIZ + +_IO_BUFSIZ + + + ) + +111 #ide +EOF + + +112  + #EOF + (-1) + + ) + +118  + #SEEK_SET + 0 + + ) + +119  + #SEEK_CUR + 1 + + ) + +120  + #SEEK_END + 2 + + ) + +123 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +125  + #P_tmpd + "/tmp" + + ) + +138  + ~ + +142  +_IO_FILE + * +d +; + +143  +_IO_FILE + * +dout +; + +144  +_IO_FILE + * +dr +; + +146  + #d + +d + + + ) + +147  + #dout + +dout + + + ) + +148  + #dr + +dr + + + ) + +150 +__BEGIN_NAMESPACE_STD + + +152  + $move + ( +__cڡ + * +__fame + +__THROW +; + +154  + $me + ( +__cڡ + * +__d +, __cڡ * +__w + +__THROW +; + +155 +__END_NAMESPACE_STD + + +158 +__BEGIN_NAMESPACE_STD + + +163 #ide +__USE_FILE_OFFSET64 + + +164 +FILE + * + `tmpfe + (); + +166 #ifde +__REDIRECT + + +167 +FILE + * + `__REDIRECT + ( +tmpfe +, (), +tmpfe64 +); + +169  + #tmpfe + +tmpfe64 + + + ) + +173 #ifde +__USE_LARGEFILE64 + + +174 +FILE + * + `tmpfe64 + (); + +178 * + $tmam + (* +__s + +__THROW +; + +179 +__END_NAMESPACE_STD + + +181 #ifde +__USE_MISC + + +184 * + $tmam_r + (* +__s + +__THROW +; + +188 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +196 * + $mam + ( +__cڡ + * +__d +, __cڡ * +__pfx +) + +197 +__THROW + +__ibu_mloc__ +; + +201 +__BEGIN_NAMESPACE_STD + + +206  + `fo + ( +FILE + * +__am +); + +211  + `fush + ( +FILE + * +__am +); + +212 +__END_NAMESPACE_STD + + +214 #ifde +__USE_MISC + + +221  + `fush_uocked + ( +FILE + * +__am +); + +224 #ifde +__USE_GNU + + +231  + `fol + (); + +235 +__BEGIN_NAMESPACE_STD + + +236 #ide +__USE_FILE_OFFSET64 + + +241 +FILE + * + `fݒ + ( +__cڡ + * +__ri + +__fame +, + +242 +__cڡ + * +__ri + +__modes +); + +247 +FILE + * + `eݒ + ( +__cڡ + * +__ri + +__fame +, + +248 +__cڡ + * +__ri + +__modes +, + +249 +FILE + * +__ri + +__am +); + +251 #ifde +__REDIRECT + + +252 +FILE + * + `__REDIRECT + ( +fݒ +, ( +__cڡ + * +__ri + +__fame +, + +253 +__cڡ + * +__ri + +__modes +), +fݒ64 +); + +254 +FILE + * + `__REDIRECT + ( +eݒ +, ( +__cڡ + * +__ri + +__fame +, + +255 +__cڡ + * +__ri + +__modes +, + +256 +FILE + * +__ri + +__am +), +eݒ64 +); + +258  + #fݒ + +fݒ64 + + + ) + +259  + #eݒ + +eݒ64 + + + ) + +262 +__END_NAMESPACE_STD + + +263 #ifde +__USE_LARGEFILE64 + + +264 +FILE + * + `fݒ64 + ( +__cڡ + * +__ri + +__fame +, + +265 +__cڡ + * +__ri + +__modes +); + +266 +FILE + * + `eݒ64 + ( +__cڡ + * +__ri + +__fame +, + +267 +__cڡ + * +__ri + +__modes +, + +268 +FILE + * +__ri + +__am +); + +271 #ifdef +__USE_POSIX + + +273 +FILE + * + $fdݒ + ( +__fd +, +__cڡ + * +__modes + +__THROW +; + +276 #ifdef +__USE_GNU + + +279 +FILE + * + $fݒcook + (* +__ri + +__magic_cook +, + +280 +__cڡ + * +__ri + +__modes +, + +281 +_IO_cook_io_funis_t + +__io_funcs + +__THROW +; + +284 +FILE + * + $fmemݒ + (* +__s +, +size_t + +__n +, +__cڡ + * +__modes + +__THROW +; + +289 +FILE + * + $ݒ_memam + (** +__ri + +__buoc +, + +290 +size_t + * +__ri + +__sizoc + +__THROW +; + +294 +__BEGIN_NAMESPACE_STD + + +297  + $tbuf + ( +FILE + * +__ri + +__am +, *__ri +__buf + +__THROW +; + +301  + $tvbuf + ( +FILE + * +__ri + +__am +, *__ri +__buf +, + +302  +__modes +, +size_t + +__n + +__THROW +; + +303 +__END_NAMESPACE_STD + + +305 #ifdef +__USE_BSD + + +308  + $tbufr + ( +FILE + * +__ri + +__am +, *__ri +__buf +, + +309 +size_t + +__size + +__THROW +; + +312  + $ebuf + ( +FILE + * +__am + +__THROW +; + +316 +__BEGIN_NAMESPACE_STD + + +321  + `rtf + ( +FILE + * +__ri + +__am +, + +322 +__cڡ + * +__ri + +__fm +, ...); + +327  + `tf + ( +__cڡ + * +__ri + +__fm +, ...); + +329  + $rtf + (* +__ri + +__s +, + +330 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +336  + `vrtf + ( +FILE + * +__ri + +__s +, +__cڡ + *__ri +__fm +, + +337 +_G_va_li + +__g +); + +342  + `vtf + ( +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +); + +344  + $vrtf + (* +__ri + +__s +, +__cڡ + *__ri +__fm +, + +345 +_G_va_li + +__g + +__THROW +; + +346 +__END_NAMESPACE_STD + + +348 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +349 +__BEGIN_NAMESPACE_C99 + + +351  + $tf + (* +__ri + +__s +, +size_t + +__maxn +, + +352 +__cڡ + * +__ri + +__fm +, ...) + +353 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +355  + $vtf + (* +__ri + +__s +, +size_t + +__maxn +, + +356 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +357 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +358 +__END_NAMESPACE_C99 + + +361 #ifde +__USE_GNU + + +364  + $vartf + (** +__ri + +__r +, +__cڡ + *__ri +__f +, + +365 +_G_va_li + +__g +) + +366 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +367  + $__artf + (** +__ri + +__r +, + +368 +__cڡ + * +__ri + +__fmt +, ...) + +369 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +370  + $artf + (** +__ri + +__r +, + +371 +__cڡ + * +__ri + +__fmt +, ...) + +372 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +380  + $vdtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, + +381 +_G_va_li + +__g +) + +382 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +383  + $dtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, ...) + +384 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +388 +__BEGIN_NAMESPACE_STD + + +393  + `fsnf + ( +FILE + * +__ri + +__am +, + +394 +__cڡ + * +__ri + +__fm +, ...); + +399  + `snf + ( +__cڡ + * +__ri + +__fm +, ...); + +401  + $ssnf + ( +__cڡ + * +__ri + +__s +, + +402 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +403 +__END_NAMESPACE_STD + + +405 #ifdef +__USE_ISOC99 + + +406 +__BEGIN_NAMESPACE_C99 + + +411  + $vfsnf + ( +FILE + * +__ri + +__s +, +__cڡ + *__ri +__fm +, + +412 +_G_va_li + +__g +) + +413 + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 2, 0))); + +419  + $vsnf + ( +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +420 + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 1, 0))); + +423  + $vssnf + ( +__cڡ + * +__ri + +__s +, + +424 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +425 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 2, 0))); + +426 +__END_NAMESPACE_C99 + + +430 +__BEGIN_NAMESPACE_STD + + +435  + `fgc + ( +FILE + * +__am +); + +436  + `gc + ( +FILE + * +__am +); + +442  + `gch + (); + +443 +__END_NAMESPACE_STD + + +447  + #gc +( +_ + + `_IO_gc + (_) + + ) + +449 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +454  + `gc_uocked + ( +FILE + * +__am +); + +455  + `gch_uocked + (); + +458 #ifde +__USE_MISC + + +465  + `fgc_uocked + ( +FILE + * +__am +); + +469 +__BEGIN_NAMESPACE_STD + + +477  + `utc + ( +__c +, +FILE + * +__am +); + +478  + `putc + ( +__c +, +FILE + * +__am +); + +484  + `putch + ( +__c +); + +485 +__END_NAMESPACE_STD + + +489  + #putc +( +_ch +, +_ + + `_IO_putc + (_ch, _) + + ) + +491 #ifde +__USE_MISC + + +498  + `utc_uocked + ( +__c +, +FILE + * +__am +); + +501 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +506  + `putc_uocked + ( +__c +, +FILE + * +__am +); + +507  + `putch_uocked + ( +__c +); + +511 #i +defed + +__USE_SVID + || defed +__USE_MISC + \ + +512 || ( +defed + +__USE_XOPEN + && !defed +__USE_XOPEN2K +) + +514  + `gw + ( +FILE + * +__am +); + +517  + `putw + ( +__w +, +FILE + * +__am +); + +521 +__BEGIN_NAMESPACE_STD + + +526 * + `fgs + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +); + +533 * + `gs + (* +__s +); + +534 +__END_NAMESPACE_STD + + +536 #ifde +__USE_GNU + + +543 * + `fgs_uocked + (* +__ri + +__s +,  +__n +, + +544 +FILE + * +__ri + +__am +); + +548 #ifdef +__USE_GNU + + +559 +_IO_ssize_t + + `__gdim + (** +__ri + +__l +, + +560 +size_t + * +__ri + +__n +,  +__dim +, + +561 +FILE + * +__ri + +__am +); + +562 +_IO_ssize_t + + `gdim + (** +__ri + +__l +, + +563 +size_t + * +__ri + +__n +,  +__dim +, + +564 +FILE + * +__ri + +__am +); + +572 +_IO_ssize_t + + `gle + (** +__ri + +__l +, + +573 +size_t + * +__ri + +__n +, + +574 +FILE + * +__ri + +__am +); + +578 +__BEGIN_NAMESPACE_STD + + +583  + `uts + ( +__cڡ + * +__ri + +__s +, +FILE + *__ri +__am +); + +589  + `puts + ( +__cڡ + * +__s +); + +596  + `ungc + ( +__c +, +FILE + * +__am +); + +603 +size_t + + `d + (* +__ri + +__r +, size_ +__size +, + +604 +size_t + +__n +, +FILE + * +__ri + +__am +); + +609 +size_t + + `fwre + ( +__cڡ + * +__ri + +__r +, size_ +__size +, + +610 +size_t + +__n +, +FILE + * +__ri + +__s +); + +611 +__END_NAMESPACE_STD + + +613 #ifde +__USE_GNU + + +620  + `uts_uocked + ( +__cڡ + * +__ri + +__s +, + +621 +FILE + * +__ri + +__am +); + +624 #ifde +__USE_MISC + + +631 +size_t + + `d_uocked + (* +__ri + +__r +, size_ +__size +, + +632 +size_t + +__n +, +FILE + * +__ri + +__am +); + +633 +size_t + + `fwre_uocked + ( +__cڡ + * +__ri + +__r +, size_ +__size +, + +634 +size_t + +__n +, +FILE + * +__ri + +__am +); + +638 +__BEGIN_NAMESPACE_STD + + +643  + `fek + ( +FILE + * +__am +,  +__off +,  +__wh +); + +648  + `l + ( +FILE + * +__am +); + +653  + `wd + ( +FILE + * +__am +); + +654 +__END_NAMESPACE_STD + + +661 #i +defed + +__USE_LARGEFILE + || defed +__USE_XOPEN2K + + +662 #ide +__USE_FILE_OFFSET64 + + +667  + `feko + ( +FILE + * +__am +, +__off_t + +__off +,  +__wh +); + +672 +__off_t + + `lo + ( +FILE + * +__am +); + +674 #ifde +__REDIRECT + + +675  + `__REDIRECT + ( +feko +, + +676 ( +FILE + * +__am +, +__off64_t + +__off +,  +__wh +), + +677 +feko64 +); + +678 +__off64_t + + `__REDIRECT + ( +lo +, ( +FILE + * +__am +), +lo64 +); + +680  + #feko + +feko64 + + + ) + +681  + #lo + +lo64 + + + ) + +686 +__BEGIN_NAMESPACE_STD + + +687 #ide +__USE_FILE_OFFSET64 + + +692  + `fgpos + ( +FILE + * +__ri + +__am +, +os_t + *__ri +__pos +); + +697  + `fos + ( +FILE + * +__am +, +__cڡ + +os_t + * +__pos +); + +699 #ifde +__REDIRECT + + +700  + `__REDIRECT + ( +fgpos +, ( +FILE + * +__ri + +__am +, + +701 +os_t + * +__ri + +__pos +), +fgpos64 +); + +702  + `__REDIRECT + ( +fos +, + +703 ( +FILE + * +__am +, +__cڡ + +os_t + * +__pos +), +fos64 +); + +705  + #fgpos + +fgpos64 + + + ) + +706  + #fos + +fos64 + + + ) + +709 +__END_NAMESPACE_STD + + +711 #ifde +__USE_LARGEFILE64 + + +712  + `feko64 + ( +FILE + * +__am +, +__off64_t + +__off +,  +__wh +); + +713 +__off64_t + + `lo64 + ( +FILE + * +__am +); + +714  + `fgpos64 + ( +FILE + * +__ri + +__am +, +os64_t + *__ri +__pos +); + +715  + `fos64 + ( +FILE + * +__am +, +__cڡ + +os64_t + * +__pos +); + +718 +__BEGIN_NAMESPACE_STD + + +720  + $ + ( +FILE + * +__am + +__THROW +; + +722  + $of + ( +FILE + * +__am + +__THROW +; + +724  + $ + ( +FILE + * +__am + +__THROW +; + +725 +__END_NAMESPACE_STD + + +727 #ifde +__USE_MISC + + +729  + $_uocked + ( +FILE + * +__am + +__THROW +; + +730  + $of_uocked + ( +FILE + * +__am + +__THROW +; + +731  + $_uocked + ( +FILE + * +__am + +__THROW +; + +735 +__BEGIN_NAMESPACE_STD + + +740  + ` + ( +__cڡ + * +__s +); + +741 +__END_NAMESPACE_STD + + +747  + ~ + +750 #ifdef +__USE_POSIX + + +752  + $fo + ( +FILE + * +__am + +__THROW +; + +755 #ifde +__USE_MISC + + +757  + $fo_uocked + ( +FILE + * +__am + +__THROW +; + +761 #i( +defed + +__USE_POSIX2 + || defed +__USE_SVID + || defed +__USE_BSD + || \ + +762 +defed + +__USE_MISC +) + +767 +FILE + * + `pݒ + ( +__cڡ + * +__commd +, __cڡ * +__modes +); + +773  + `po + ( +FILE + * +__am +); + +777 #ifdef +__USE_POSIX + + +779 * + $mid + (* +__s + +__THROW +; + +783 #ifde +__USE_XOPEN + + +785 * + `curid + (* +__s +); + +789 #ifdef +__USE_GNU + + +790  +oback +; + +793  + $oback_tf + ( +oback + * +__ri + +__oback +, + +794 +__cڡ + * +__ri + +__fm +, ...) + +795 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +796  + $oback_vtf + ( +oback + * +__ri + +__oback +, + +797 +__cڡ + * +__ri + +__fm +, + +798 +_G_va_li + +__gs +) + +799 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +803 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +807  + $ockfe + ( +FILE + * +__am + +__THROW +; + +811  + $rylockfe + ( +FILE + * +__am + +__THROW +; + +814  + $fuockfe + ( +FILE + * +__am + +__THROW +; + +817 #i +defed + +__USE_XOPEN + && !defed +__USE_XOPEN2K + && !defed +__USE_GNU + + +821  + #__ed_gt + + + ) + +822  + ~ + +827 #ifde +__USE_EXTERN_INLINES + + +828  + ~ + +830 #i +__USE_FORTIFY_LEVEL + > 0 && ! +defed + +__lulus + + +831  + ~ + +834 +__END_DECLS + + + @/usr/include/stdlib.h + +23 #idef +_STDLIB_H + + +25  + ~ + +28  + #__ed_size_t + + + ) + +29 #ide +__ed_mloc_d_oc + + +30  + #__ed_wch_t + + + ) + +31  + #__ed_NULL + + + ) + +33  + ~ + +35 + g__BEGIN_DECLS + + +37 #ide +__ed_mloc_d_oc + + +38  + #_STDLIB_H + 1 + + ) + +40 #i +defed + +__USE_XOPEN + && !defed +_SYS_WAIT_H + + +42  + ~ + +43  + ~ + +45 #ifde +__USE_BSD + + +50 #i +defed + +__GNUC__ + && !defed +__lulus + + +51  + #__WAIT_INT +( +us +) \ + +52 ( + `__exnsi__ + ({ uni { + `__tyof +( +us + +__ +;  +__i +; } +__u +; \ + +53 +__u +. +__ + = ( +us +); __u. +__i +; })) + + ) + +55  + #__WAIT_INT +( +us +(*(*&(us)) + + ) + +63 #i! +defed + +__GNUC__ + || __GNUC__ < 2 || defed +__lulus + + +64  + #__WAIT_STATUS + * + + ) + +65  + #__WAIT_STATUS_DEFN + * + + ) + +70  +wa + * + m__ur +; + +71 * + m__ +; + +72 } + t__WAIT_STATUS + + t__ibu__ + (( + t__t_uni__ +)); + +73  + #__WAIT_STATUS_DEFN + * + + ) + +78  + #__WAIT_INT +( +us +(us) + + ) + +79  + #__WAIT_STATUS + * + + ) + +80  + #__WAIT_STATUS_DEFN + * + + ) + +85  + #WEXITSTATUS +( +us + + `__WEXITSTATUS +( + `__WAIT_INT +(us)) + + ) + +86  + #WTERMSIG +( +us + + `__WTERMSIG +( + `__WAIT_INT +(us)) + + ) + +87  + #WSTOPSIG +( +us + + `__WSTOPSIG +( + `__WAIT_INT +(us)) + + ) + +88  + #WIFEXITED +( +us + + `__WIFEXITED +( + `__WAIT_INT +(us)) + + ) + +89  + #WIFSIGNALED +( +us + + `__WIFSIGNALED +( + `__WAIT_INT +(us)) + + ) + +90  + #WIFSTOPPED +( +us + + `__WIFSTOPPED +( + `__WAIT_INT +(us)) + + ) + +91 #ifde +__WIFCONTINUED + + +92  + #WIFCONTINUED +( +us + + `__WIFCONTINUED +( + `__WAIT_INT +(us)) + + ) + +96 +__BEGIN_NAMESPACE_STD + + +100  + mqu +; + +101  + mm +; + +102 } + tdiv_t +; + +105 #ide +__ldiv_t_defed + + +108  + mqu +; + +109  + mm +; + +110 } + tldiv_t +; + +111  + #__ldiv_t_defed + 1 + + ) + +113 + g__END_NAMESPACE_STD + + +115 #i +defed + +__USE_ISOC99 + && !defed +__div_t_defed + + +116 +__BEGIN_NAMESPACE_C99 + + +118 +__exnsi__ + struct + +120  + mqu +; + +121  + mm +; + +122 } + tdiv_t +; + +123  + #__div_t_defed + 1 + + ) + +124 + g__END_NAMESPACE_C99 + + +129  + #RAND_MAX + 2147483647 + + ) + +134  + #EXIT_FAILURE + 1 + + ) + +135  + #EXIT_SUCCESS + 0 + + ) + +139  + #MB_CUR_MAX + ( + `__y_g_mb_cur_max + ()) + + ) + +140 +size_t + + $__y_g_mb_cur_max + ( +__THROW +; + +143 +__BEGIN_NAMESPACE_STD + + +145  + $of + ( +__cڡ + * +__Ō +) + +146 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +148  + $oi + ( +__cڡ + * +__Ō +) + +149 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +151  + $ + ( +__cڡ + * +__Ō +) + +152 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +153 +__END_NAMESPACE_STD + + +155 #i +defed + +__USE_ISOC99 + || (defed +__GLIBC_HAVE_LONG_LONG + && defed +__USE_MISC +) + +156 +__BEGIN_NAMESPACE_C99 + + +158 +__exnsi__ +  + $l + ( +__cڡ + * +__Ō +) + +159 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +160 +__END_NAMESPACE_C99 + + +163 +__BEGIN_NAMESPACE_STD + + +165  + $od + ( +__cڡ + * +__ri + +__Ō +, + +166 ** +__ri + +__dr + +__THROW + + `__nnu + ((1)); + +167 +__END_NAMESPACE_STD + + +169 #ifdef +__USE_ISOC99 + + +170 +__BEGIN_NAMESPACE_C99 + + +172  + $of + ( +__cڡ + * +__ri + +__Ō +, + +173 ** +__ri + +__dr + +__THROW + + `__nnu + ((1)); + +175  + $d + ( +__cڡ + * +__ri + +__Ō +, + +176 ** +__ri + +__dr +) + +177 +__THROW + + `__nnu + ((1)); + +178 +__END_NAMESPACE_C99 + + +181 +__BEGIN_NAMESPACE_STD + + +183  + $ + ( +__cڡ + * +__ri + +__Ō +, + +184 ** +__ri + +__dr +,  +__ba +) + +185 +__THROW + + `__nnu + ((1)); + +187  + $oul + ( +__cڡ + * +__ri + +__Ō +, + +188 ** +__ri + +__dr +,  +__ba +) + +189 +__THROW + + `__nnu + ((1)); + +190 +__END_NAMESPACE_C99 + + +192 #i +defed + +__GLIBC_HAVE_LONG_LONG + && defed +__USE_BSD + + +194 +__exnsi__ + + +195  + $oq + ( +__cڡ + * +__ri + +__Ō +, + +196 ** +__ri + +__dr +,  +__ba +) + +197 +__THROW + + `__nnu + ((1)); + +199 +__exnsi__ + + +200  + $ouq + ( +__cڡ + * +__ri + +__Ō +, + +201 ** +__ri + +__dr +,  +__ba +) + +202 +__THROW + + `__nnu + ((1)); + +205 #i +defed + +__USE_ISOC99 + || (defed +__GLIBC_HAVE_LONG_LONG + && defed +__USE_MISC +) + +206 +__BEGIN_NAMESPACE_C99 + + +208 +__exnsi__ + + +209  + $l + ( +__cڡ + * +__ri + +__Ō +, + +210 ** +__ri + +__dr +,  +__ba +) + +211 +__THROW + + `__nnu + ((1)); + +213 +__exnsi__ + + +214  + $ou + ( +__cڡ + * +__ri + +__Ō +, + +215 ** +__ri + +__dr +,  +__ba +) + +216 +__THROW + + `__nnu + ((1)); + +217 +__END_NAMESPACE_C99 + + +221 #ifde +__USE_GNU + + +235  + ~ + +239  + $_l + ( +__cڡ + * +__ri + +__Ō +, + +240 ** +__ri + +__dr +,  +__ba +, + +241 +__lo_t + +__loc + +__THROW + + `__nnu + ((1, 4)); + +243  + $oul_l + ( +__cڡ + * +__ri + +__Ō +, + +244 ** +__ri + +__dr +, + +245  +__ba +, +__lo_t + +__loc +) + +246 +__THROW + + `__nnu + ((1, 4)); + +248 +__exnsi__ + + +249  + $l_l + ( +__cڡ + * +__ri + +__Ō +, + +250 ** +__ri + +__dr +,  +__ba +, + +251 +__lo_t + +__loc +) + +252 +__THROW + + `__nnu + ((1, 4)); + +254 +__exnsi__ + + +255  + $ou_l + ( +__cڡ + * +__ri + +__Ō +, + +256 ** +__ri + +__dr +, + +257  +__ba +, +__lo_t + +__loc +) + +258 +__THROW + + `__nnu + ((1, 4)); + +260  + $od_l + ( +__cڡ + * +__ri + +__Ō +, + +261 ** +__ri + +__dr +, +__lo_t + +__loc +) + +262 +__THROW + + `__nnu + ((1, 3)); + +264  + $of_l + ( +__cڡ + * +__ri + +__Ō +, + +265 ** +__ri + +__dr +, +__lo_t + +__loc +) + +266 +__THROW + + `__nnu + ((1, 3)); + +268  + $d_l + ( +__cڡ + * +__ri + +__Ō +, + +269 ** +__ri + +__dr +, + +270 +__lo_t + +__loc + +__THROW + + `__nnu + ((1, 3)); + +277  + $__od_ + ( +__cڡ + * +__ri + +__Ō +, + +278 ** +__ri + +__dr +,  +__group +) + +279 +__THROW + + `__nnu + ((1)); + +280  + $__of_ + ( +__cڡ + * +__ri + +__Ō +, + +281 ** +__ri + +__dr +,  +__group +) + +282 +__THROW + + `__nnu + ((1)); + +283  + $__d_ + ( +__cڡ + * +__ri + +__Ō +, + +284 ** +__ri + +__dr +, + +285  +__group + +__THROW + + `__nnu + ((1)); + +286 #ide +____defed + + +287  + $___ + ( +__cڡ + * +__ri + +__Ō +, + +288 ** +__ri + +__dr +, + +289  +__ba +,  +__group +) + +290 +__THROW + + `__nnu + ((1)); + +291  + #____defed + 1 + + ) + +293 #ide +__oul__defed + + +294  + $__oul_ + ( +__cڡ + * +__ri + +__Ō +, + +295 ** +__ri + +__dr +, + +296  +__ba +,  +__group +) + +297 +__THROW + + `__nnu + ((1)); + +298  + #__oul__defed + 1 + + ) + +300 #i +defed + +__GNUC__ + || defed +__USE_ISOC99 + + +301 #ide +__l__defed + + +302 +__exnsi__ + + +303  + $__l_ + ( +__cڡ + * +__ri + +__Ō +, + +304 ** +__ri + +__dr +, + +305  +__ba +,  +__group +) + +306 +__THROW + + `__nnu + ((1)); + +307  + #__l__defed + 1 + + ) + +309 #ide +__ou__defed + + +310 +__exnsi__ + + +311  + $__ou_ + ( +__cڡ + * + +312 +__ri + +__Ō +, + +313 ** +__ri + +__dr +, + +314  +__ba +,  +__group +) + +315 +__THROW + + `__nnu + ((1)); + +316  + #__ou__defed + 1 + + ) + +320 #ifde +__USE_EXTERN_INLINES + + +323 +__BEGIN_NAMESPACE_STD + + +324 +__le +  + +325 + `__NTH + ( + $od + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +)) + +327  + `__od_ + ( +__Ō +, +__dr +, 0); + +328 + } +} + +329 +__le +  + +330 +__NTH + ( + $ + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +, + +331  +__ba +)) + +333  + `___ + ( +__Ō +, +__dr +, +__ba +, 0); + +334 + } +} + +335 +__le +  + +336 +__NTH + ( + $oul + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +, + +337  +__ba +)) + +339  + `__oul_ + ( +__Ō +, +__dr +, +__ba +, 0); + +340 + } +} + +341 +__END_NAMESPACE_STD + + +343 #ifde +__USE_ISOC99 + + +344 +__BEGIN_NAMESPACE_C99 + + +345 +__le +  + +346 +__NTH + ( + $of + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +)) + +348  + `__of_ + ( +__Ō +, +__dr +, 0); + +349 + } +} + +350 +__le +  + +351 +__NTH + ( + $d + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +)) + +353  + `__d_ + ( +__Ō +, +__dr +, 0); + +354 + } +} + +355 +__END_NAMESPACE_C99 + + +358 #ifde +__USE_BSD + + +359 +__exnsi__ + +__le +  + +360 +__NTH + ( + $oq + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +, + +361  +__ba +)) + +363  + `__l_ + ( +__Ō +, +__dr +, +__ba +, 0); + +364 + } +} + +365 +__exnsi__ + +__le +  + +366 +__NTH + ( + $ouq + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +, + +367  +__ba +)) + +369  + `__ou_ + ( +__Ō +, +__dr +, +__ba +, 0); + +370 + } +} + +373 #i +defed + +__USE_MISC + || defed +__USE_ISOC99 + + +374 +__BEGIN_NAMESPACE_C99 + + +375 +__exnsi__ + +__le +  + +376 +__NTH + ( + $l + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +, + +377  +__ba +)) + +379  + `__l_ + ( +__Ō +, +__dr +, +__ba +, 0); + +380 + } +} + +381 +__exnsi__ + +__le +  + +382 +__NTH + ( + $ou + ( +__cڡ + * +__ri + +__Ō +, **__ri +__dr +, + +383  +__ba +)) + +385  + `__ou_ + ( +__Ō +, +__dr +, +__ba +, 0); + +386 + } +} + +387 +__END_NAMESPACE_C99 + + +390 +__BEGIN_NAMESPACE_STD + + +391 +__le +  + +392 +__NTH + ( + $of + ( +__cڡ + * +__Ō +)) + +394  + `od + ( +__Ō +, (** +NULL +); + +395 + } +} + +396 +__le +  + +397 +__NTH + ( + $oi + ( +__cڡ + * +__Ō +)) + +399  ( + ` + ( +__Ō +, (** +NULL +, 10); + +400 + } +} + +401 +__le +  + +402 +__NTH + ( + $ + ( +__cڡ + * +__Ō +)) + +404  + ` + ( +__Ō +, (** +NULL +, 10); + +405 + } +} + +406 +__END_NAMESPACE_STD + + +408 #i +defed + +__USE_MISC + || defed +__USE_ISOC99 + + +409 +__BEGIN_NAMESPACE_C99 + + +410 +__exnsi__ + +__le +  + +411 +__NTH + ( + $l + ( +__cڡ + * +__Ō +)) + +413  + `l + ( +__Ō +, (** +NULL +, 10); + +414 + } +} + +415 +__END_NAMESPACE_C99 + + +420 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + + +424 * + $l64a + ( +__n + +__THROW +; + +427  + $a64l + ( +__cڡ + * +__s +) + +428 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +432 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_BSD + + +433  + ~ + +440  + $ndom + ( +__THROW +; + +443  + $dom + ( +__ed + +__THROW +; + +449 * + $e + ( +__ed +, * +__ebuf +, + +450 +size_t + +__ + +__THROW + + `__nnu + ((2)); + +454 * + $te + (* +__ebuf + +__THROW + + `__nnu + ((1)); + +457 #ifde +__USE_MISC + + +462  + sndom_da + + +464 +t32_t + * + +; + +465 +t32_t + * + +; + +466 +t32_t + * +e +; + +467  +nd_ty +; + +468  +nd_deg +; + +469  +nd_p +; + +470 +t32_t + * +d_r +; + +473  + $ndom_r + ( +ndom_da + * +__ri + +__buf +, + +474 +t32_t + * +__ri + +__su + +__THROW + + `__nnu + ((1, 2)); + +476  + $dom_r + ( +__ed +,  +ndom_da + * +__buf +) + +477 +__THROW + + `__nnu + ((2)); + +479  + $e_r + ( +__ed +, * +__ri + +__ebuf +, + +480 +size_t + +__ +, + +481  +ndom_da + * +__ri + +__buf +) + +482 +__THROW + + `__nnu + ((2, 4)); + +484  + $te_r + (* +__ri + +__ebuf +, + +485  +ndom_da + * +__ri + +__buf +) + +486 +__THROW + + `__nnu + ((1, 2)); + +491 +__BEGIN_NAMESPACE_STD + + +493  + $nd + ( +__THROW +; + +495  + $d + ( +__ed + +__THROW +; + +496 +__END_NAMESPACE_STD + + +498 #ifde +__USE_POSIX + + +500  + $nd_r + (* +__ed + +__THROW +; + +504 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +508  + $dnd48 + ( +__THROW +; + +509  + `d48 + ( +__xsubi +[3] +__THROW + + `__nnu + ((1)); + +512  + $̪d48 + ( +__THROW +; + +513  + `Īd48 + ( +__xsubi +[3]) + +514 +__THROW + + `__nnu + ((1)); + +517  + $mnd48 + ( +__THROW +; + +518  + `jnd48 + ( +__xsubi +[3]) + +519 +__THROW + + `__nnu + ((1)); + +522  + $d48 + ( +__edv + +__THROW +; + +523 * + `ed48 + ( +__ed16v +[3]) + +524 +__THROW + + `__nnu + ((1)); + +525  + `lcg48 + ( +__m +[7] +__THROW + + `__nnu + ((1)); + +527 #ifde +__USE_MISC + + +531  + sdnd48_da + + +533  +__x +[3]; + +534  +__d_x +[3]; + +535  +__c +; + +536  +__ +; + +537  +__a +; + +541  + $dnd48_r + ( +dnd48_da + * +__ri + +__bufr +, + +542 * +__ri + +__su + +__THROW + + `__nnu + ((1, 2)); + +543  + `d48_r + ( +__xsubi +[3], + +544  +dnd48_da + * +__ri + +__bufr +, + +545 * +__ri + +__su + +__THROW + + `__nnu + ((1, 2)); + +548  + $̪d48_r + ( +dnd48_da + * +__ri + +__bufr +, + +549 * +__ri + +__su +) + +550 +__THROW + + `__nnu + ((1, 2)); + +551  + `Īd48_r + ( +__xsubi +[3], + +552  +dnd48_da + * +__ri + +__bufr +, + +553 * +__ri + +__su +) + +554 +__THROW + + `__nnu + ((1, 2)); + +557  + $mnd48_r + ( +dnd48_da + * +__ri + +__bufr +, + +558 * +__ri + +__su +) + +559 +__THROW + + `__nnu + ((1, 2)); + +560  + `jnd48_r + ( +__xsubi +[3], + +561  +dnd48_da + * +__ri + +__bufr +, + +562 * +__ri + +__su +) + +563 +__THROW + + `__nnu + ((1, 2)); + +566  + $d48_r + ( +__edv +,  +dnd48_da + * +__bufr +) + +567 +__THROW + + `__nnu + ((2)); + +569  + `ed48_r + ( +__ed16v +[3], + +570  +dnd48_da + * +__bufr + +__THROW + + `__nnu + ((1, 2)); + +572  + `lcg48_r + ( +__m +[7], + +573  +dnd48_da + * +__bufr +) + +574 +__THROW + + `__nnu + ((1, 2)); + +580 #ide +__mloc_d_oc_defed + + +581  + #__mloc_d_oc_defed + + + ) + +582 +__BEGIN_NAMESPACE_STD + + +584 * + $mloc + ( +size_t + +__size + +__THROW + +__ibu_mloc__ +; + +586 * + $oc + ( +size_t + +__nmemb +, size_ +__size +) + +587 +__THROW + +__ibu_mloc__ +; + +588 +__END_NAMESPACE_STD + + +591 #ide +__ed_mloc_d_oc + + +592 +__BEGIN_NAMESPACE_STD + + +595 * + $loc + (* +__r +, +size_t + +__size + +__THROW + +__ibu_mloc__ +; + +597  + $ + (* +__r + +__THROW +; + +598 +__END_NAMESPACE_STD + + +600 #ifdef +__USE_MISC + + +602  + $c + (* +__r + +__THROW +; + +605 #i +defed + +__USE_GNU + || defed +__USE_BSD + || defed +__USE_MISC + + +606  + ~ + +609 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +611 * + $vloc + ( +size_t + +__size + +__THROW + +__ibu_mloc__ +; + +614 #ifde +__USE_XOPEN2K + + +616  + $posix_memign + (** +__memr +, +size_t + +__ignmt +, size_ +__size +) + +617 +__THROW + + `__nnu + ((1)); + +620 +__BEGIN_NAMESPACE_STD + + +622  + $abt + ( +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +626  + `ex + ((* +__func +() +__THROW + + `__nnu + ((1)); + +627 +__END_NAMESPACE_STD + + +629 #ifdef +__USE_MISC + + +632  + `_ex + ((* +__func +( +__us +, * +__g +), *__arg) + +633 +__THROW + + `__nnu + ((1)); + +636 +__BEGIN_NAMESPACE_STD + + +640  + $ex + ( +__us + +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +641 +__END_NAMESPACE_STD + + +643 #ifde +__USE_ISOC99 + + +644 +__BEGIN_NAMESPACE_C99 + + +647  + $_Ex + ( +__us + +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +648 +__END_NAMESPACE_C99 + + +652 +__BEGIN_NAMESPACE_STD + + +654 * + $gv + ( +__cڡ + * +__me + +__THROW + + `__nnu + ((1)); + +655 +__END_NAMESPACE_STD + + +659 * + $__cu_gv + ( +__cڡ + * +__me + +__THROW + + `__nnu + ((1)); + +661 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +665  + $punv + (* +__rg + +__THROW + + `__nnu + ((1)); + +668 #i +defed + +__USE_BSD + || defed +__USE_XOPEN2K + + +671  + $nv + ( +__cڡ + * +__me +, __cڡ * +__vue +,  +__a +) + +672 +__THROW + + `__nnu + ((2)); + +675  + $unnv + ( +__cڡ + * +__me + +__THROW +; + +678 #ifdef +__USE_MISC + + +682  + $nv + ( +__THROW +; + +686 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + + +691 * + $mkmp + (* +__me + +__THROW + + `__nnu + ((1)); + +701 #ide +__USE_FILE_OFFSET64 + + +702  + $mkemp + (* +__me + + `__nnu + ((1)); + +704 #ifde +__REDIRECT + + +705  + `__REDIRECT + ( +mkemp +, (* +__me +), +mkemp64 + + `__nnu + ((1)); + +707  + #mkemp + +mkemp64 + + + ) + +710 #ifde +__USE_LARGEFILE64 + + +711  + $mkemp64 + (* +__me + + `__nnu + ((1)); + +715 #ifde +__USE_BSD + + +721 * + $mkdmp + (* +__me + +__THROW + + `__nnu + ((1)); + +725 +__BEGIN_NAMESPACE_STD + + +730  + `syem + ( +__cڡ + * +__commd +); + +731 +__END_NAMESPACE_STD + + +734 #ifdef +__USE_GNU + + +738 * + $nilize_fe_me + ( +__cڡ + * +__me +) + +739 +__THROW + + `__nnu + ((1)); + +742 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +749 * + $th + ( +__cڡ + * +__ri + +__me +, + +750 * +__ri + +__sved + +__THROW +; + +755 #ide +__COMPAR_FN_T + + +756  + #__COMPAR_FN_T + + + ) + +757 (* + t__comr__t +( + t__cڡ + *, __const *); + +759 #ifdef +__USE_GNU + + +760  +__comr__t + + tcomris__t +; + +764 +__BEGIN_NAMESPACE_STD + + +767 * + $bch + ( +__cڡ + * +__key +, __cڡ * +__ba +, + +768 +size_t + +__nmemb +, size_ +__size +, +__comr__t + +__comr +) + +769 + `__nnu + ((1, 2, 5)); + +773  + $qst + (* +__ba +, +size_t + +__nmemb +, size_ +__size +, + +774 +__comr__t + +__comr + + `__nnu + ((1, 4)); + +778  + $abs + ( +__x + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +779  + $bs + ( +__x + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +780 +__END_NAMESPACE_STD + + +782 #ifde +__USE_ISOC99 + + +783 +__exnsi__ +  + $abs + ( +__x +) + +784 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +788 +__BEGIN_NAMESPACE_STD + + +792 +div_t + + $div + ( +__num +,  +__dom +) + +793 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +794 +ldiv_t + + $ldiv + ( +__num +,  +__dom +) + +795 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +796 +__END_NAMESPACE_STD + + +798 #ifde +__USE_ISOC99 + + +799 +__BEGIN_NAMESPACE_C99 + + +800 +__exnsi__ + +div_t + + $div + ( +__num +, + +801  +__dom +) + +802 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +803 +__END_NAMESPACE_C99 + + +807 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + + +814 * + $ecvt + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +815 * +__ri + +__sign + +__THROW + + `__nnu + ((3, 4)); + +820 * + $fcvt + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +821 * +__ri + +__sign + +__THROW + + `__nnu + ((3, 4)); + +826 * + $gcvt + ( +__vue +,  +__ndig +, * +__buf +) + +827 +__THROW + + `__nnu + ((3)); + +830 #ifde +__USE_MISC + + +832 * + $qecvt + ( +__vue +,  +__ndig +, + +833 * +__ri + +__det +, *__ri +__sign +) + +834 +__THROW + + `__nnu + ((3, 4)); + +835 * + $qfcvt + ( +__vue +,  +__ndig +, + +836 * +__ri + +__det +, *__ri +__sign +) + +837 +__THROW + + `__nnu + ((3, 4)); + +838 * + $qgcvt + ( +__vue +,  +__ndig +, * +__buf +) + +839 +__THROW + + `__nnu + ((3)); + +844  + $ecvt_r + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +845 * +__ri + +__sign +, *__ri +__buf +, + +846 +size_t + +__n + +__THROW + + `__nnu + ((3, 4, 5)); + +847  + $fcvt_r + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +848 * +__ri + +__sign +, *__ri +__buf +, + +849 +size_t + +__n + +__THROW + + `__nnu + ((3, 4, 5)); + +851  + $qecvt_r + ( +__vue +,  +__ndig +, + +852 * +__ri + +__det +, *__ri +__sign +, + +853 * +__ri + +__buf +, +size_t + +__n +) + +854 +__THROW + + `__nnu + ((3, 4, 5)); + +855  + $qfcvt_r + ( +__vue +,  +__ndig +, + +856 * +__ri + +__det +, *__ri +__sign +, + +857 * +__ri + +__buf +, +size_t + +__n +) + +858 +__THROW + + `__nnu + ((3, 4, 5)); + +863 +__BEGIN_NAMESPACE_STD + + +866  + $mbn + ( +__cڡ + * +__s +, +size_t + +__n + +__THROW +; + +869  + $mbtowc + ( +wch_t + * +__ri + +__pwc +, + +870 +__cڡ + * +__ri + +__s +, +size_t + +__n + +__THROW +; + +873  + $womb + (* +__s +, +wch_t + +__wch + +__THROW +; + +877 +size_t + + $mbowcs + ( +wch_t + * +__ri + +__pwcs +, + +878 +__cڡ + * +__ri + +__s +, +size_t + +__n + +__THROW +; + +880 +size_t + + $wcombs + (* +__ri + +__s +, + +881 +__cڡ + +wch_t + * +__ri + +__pwcs +, +size_t + +__n +) + +882 +__THROW +; + +883 +__END_NAMESPACE_STD + + +886 #ifde +__USE_SVID + + +891  + $mch + ( +__cڡ + * +__ڣ + +__THROW + + `__nnu + ((1)); + +895 #ifde +__USE_XOPEN_EXTENDED + + +902  + $gsubt + (** +__ri + +__tip +, + +903 * +__cڡ + * +__ri + +__toks +, + +904 ** +__ri + +__vu +) + +905 +__THROW + + `__nnu + ((1, 2, 3)); + +909 #ifde +__USE_XOPEN + + +911  + $tkey + ( +__cڡ + * +__key + +__THROW + + `__nnu + ((1)); + +917 #ifde +__USE_XOPEN2K + + +919  + `posix_ݒ + ( +__oag +); + +922 #ifde +__USE_XOPEN + + +927  + $g + ( +__fd + +__THROW +; + +931  + $uock + ( +__fd + +__THROW +; + +936 * + $ame + ( +__fd + +__THROW +; + +939 #ifde +__USE_GNU + + +943  + $ame_r + ( +__fd +, * +__buf +, +size_t + +__bu +) + +944 +__THROW + + `__nnu + ((2)); + +947  + `g + (); + +950 #ifde +__USE_BSD + + +954  + $gldavg + ( +__ldavg +[],  +__m +) + +955 +__THROW + + `__nnu + ((1)); + +959 #unde +__ed_mloc_d_oc + + +961 +__END_DECLS + + + @/usr/include/string.h + +23 #idef +_STRING_H + + +24  + #_STRING_H + 1 + + ) + +26  + ~ + +28 + g__BEGIN_DECLS + + +31  + #__ed_size_t + + + ) + +32  + #__ed_NULL + + + ) + +33  + ~ + +36 +__BEGIN_NAMESPACE_STD + + +38 * + $memy + (* +__ri + +__de +, + +39 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +40 +__THROW + + `__nnu + ((1, 2)); + +43 * + $memmove + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +44 +__THROW + + `__nnu + ((1, 2)); + +45 +__END_NAMESPACE_STD + + +50 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN + + +51 * + $memcy + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +52  +__c +, +size_t + +__n +) + +53 +__THROW + + `__nnu + ((1, 2)); + +57 +__BEGIN_NAMESPACE_STD + + +59 * + $memt + (* +__s +,  +__c +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +62  + $memcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +63 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +66 * + $memchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +67 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +68 +__END_NAMESPACE_STD + + +70 #ifde +__USE_GNU + + +73 * + $wmemchr + ( +__cڡ + * +__s +,  +__c +) + +74 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +77 * + $memrchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +78 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +82 +__BEGIN_NAMESPACE_STD + + +84 * + $ry + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +85 +__THROW + + `__nnu + ((1, 2)); + +87 * + $y + (* +__ri + +__de +, + +88 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +89 +__THROW + + `__nnu + ((1, 2)); + +92 * + $rt + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +93 +__THROW + + `__nnu + ((1, 2)); + +95 * + $t + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +96 +size_t + +__n + +__THROW + + `__nnu + ((1, 2)); + +99  + $rcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +100 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +102  + $cmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +103 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +106  + $rcl + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +107 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +109 +size_t + + $rxm + (* +__ri + +__de +, + +110 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +111 +__THROW + + `__nnu + ((2)); + +112 +__END_NAMESPACE_STD + + +114 #ifde +__USE_GNU + + +118  + ~ + +121  + $rcl_l + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +__lo_t + +__l +) + +122 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2, 3)); + +124 +size_t + + $rxm_l + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +, + +125 +__lo_t + +__l + +__THROW + + `__nnu + ((2, 4)); + +128 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +130 * + $rdup + ( +__cڡ + * +__s +) + +131 +__THROW + +__ibu_mloc__ + + `__nnu + ((1)); + +137 #i +defed + +__USE_GNU + + +138 * + $dup + ( +__cڡ + * +__rg +, +size_t + +__n +) + +139 +__THROW + +__ibu_mloc__ + + `__nnu + ((1)); + +142 #i +defed + +__USE_GNU + && defed +__GNUC__ + + +144  + #rdu +( +s +) \ + +145 ( +__exnsi__ + \ + +147 +__cڡ + * +__d + = ( +s +); \ + +148 +size_t + +__n + = + ` + ( +__d +) + 1; \ + +149 * +__w + = (* + `__but_lo + ( +__n +); \ + +150 (* + `memy + ( +__w +, +__d +, +__n +); \ + +151 + } +})) + + ) + +154  + #du +( +s +, +n +) \ + +155 ( +__exnsi__ + \ + +157 +__cڡ + * +__d + = ( +s +); \ + +158 +size_t + +__n + = + `n + ( +__d +, ( +n +)); \ + +159 * +__w + = (* + `__but_lo + ( +__n + + 1); \ + +160 +__w +[ +__n +] = '\0'; \ + +161 (* + `memy + ( +__w +, +__d +, +__n +); \ + +162 })) + + ) + +165 +__BEGIN_NAMESPACE_STD + + +167 * + $rchr + ( +__cڡ + * +__s +,  +__c +) + +168 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +170 * + $chr + ( +__cڡ + * +__s +,  +__c +) + +171 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +172 +__END_NAMESPACE_STD + + +174 #ifde +__USE_GNU + + +177 * + $rchul + ( +__cڡ + * +__s +,  +__c +) + +178 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +181 +__BEGIN_NAMESPACE_STD + + +184 +size_t + + $rcn + ( +__cڡ + * +__s +, __cڡ * +__je +) + +185 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +188 +size_t + + $rn + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +189 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +191 * + $brk + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +192 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +194 * + $rr + ( +__cڡ + * +__hayack +, __cڡ * +__ed +) + +195 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +199 * + $ok + (* +__ri + +__s +, +__cڡ + *__ri +__dim +) + +200 +__THROW + + `__nnu + ((2)); + +201 +__END_NAMESPACE_STD + + +205 * + $__ok_r + (* +__ri + +__s +, + +206 +__cڡ + * +__ri + +__dim +, + +207 ** +__ri + +__ve_r +) + +208 +__THROW + + `__nnu + ((2, 3)); + +209 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +210 * + $ok_r + (* +__ri + +__s +, +__cڡ + *__ri +__dim +, + +211 ** +__ri + +__ve_r +) + +212 +__THROW + + `__nnu + ((2, 3)); + +215 #ifde +__USE_GNU + + +217 * + $rr + ( +__cڡ + * +__hayack +, __cڡ * +__ed +) + +218 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +221 #ifde +__USE_GNU + + +225 * + $memmem + ( +__cڡ + * +__hayack +, +size_t + +__hayackn +, + +226 +__cڡ + * +__ed +, +size_t + +__edn +) + +227 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 3)); + +231 * + $__mempy + (* +__ri + +__de +, + +232 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +233 +__THROW + + `__nnu + ((1, 2)); + +234 * + $mempy + (* +__ri + +__de +, + +235 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +236 +__THROW + + `__nnu + ((1, 2)); + +240 +__BEGIN_NAMESPACE_STD + + +242 +size_t + + $ + ( +__cڡ + * +__s +) + +243 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +244 +__END_NAMESPACE_STD + + +246 #ifdef +__USE_GNU + + +249 +size_t + + $n + ( +__cڡ + * +__rg +, +size_t + +__maxn +) + +250 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +254 +__BEGIN_NAMESPACE_STD + + +256 * + $ + ( +__um + +__THROW +; + +257 +__END_NAMESPACE_STD + + +258 #i +defed + +__USE_XOPEN2K + || defed +__USE_MISC + + +266 #i +defed + +__USE_XOPEN2K + && !defed +__USE_GNU + + +269 #ifde +__REDIRECT_NTH + + +270  + `__REDIRECT_NTH + ( +_r +, + +271 ( +__um +, * +__buf +, +size_t + +__bu +), + +272 +__xpg__r + + `__nnu + ((2)); + +274  + $__xpg__r + ( +__um +, * +__buf +, +size_t + +__bu +) + +275 +__THROW + + `__nnu + ((2)); + +276  + #_r + +__xpg__r + + + ) + +281 * + $_r + ( +__um +, * +__buf +, +size_t + +__bu +) + +282 +__THROW + + `__nnu + ((2)); + +288  + $__bzo + (* +__s +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +290 #ifde +__USE_BSD + + +292  + $bcy + ( +__cڡ + * +__c +, * +__de +, +size_t + +__n +) + +293 +__THROW + + `__nnu + ((1, 2)); + +296  + $bzo + (* +__s +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +299  + $bcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +300 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +303 * + $dex + ( +__cڡ + * +__s +,  +__c +) + +304 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +307 * + $rdex + ( +__cڡ + * +__s +,  +__c +) + +308 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +312  + $ffs + ( +__i + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +316 #ifdef +__USE_GNU + + +317  + $ff + ( +__l + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +318 #ifde +__GNUC__ + + +319 +__exnsi__ +  + $ffl + ( +__ +) + +320 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +325  + $rcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +326 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +329  + $cmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +330 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +333 #ifdef +__USE_GNU + + +336  + $rcmp_l + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, + +337 +__lo_t + +__loc +) + +338 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2, 3)); + +340  + $cmp_l + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, + +341 +size_t + +__n +, +__lo_t + +__loc +) + +342 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2, 4)); + +345 #ifdef +__USE_BSD + + +348 * + $rp + (** +__ri + +__rgp +, + +349 +__cڡ + * +__ri + +__dim +) + +350 +__THROW + + `__nnu + ((1, 2)); + +353 #ifdef +__USE_GNU + + +355  + $rvscmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +356 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +359 * + $rsigl + ( +__sig + +__THROW +; + +362 * + $__py + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +363 +__THROW + + `__nnu + ((1, 2)); + +364 * + $py + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +365 +__THROW + + `__nnu + ((1, 2)); + +369 * + $__y + (* +__ri + +__de +, + +370 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +371 +__THROW + + `__nnu + ((1, 2)); + +372 * + $y + (* +__ri + +__de +, + +373 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +374 +__THROW + + `__nnu + ((1, 2)); + +377 * + $ry + (* +__rg + +__THROW + + `__nnu + ((1)); + +380 * + $memob + (* +__s +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +382 #ide +bame + + +387 * + $bame + ( +__cڡ + * +__fame + +__THROW + + `__nnu + ((1)); + +392 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +393 #i +defed + +__OPTIMIZE__ + && !defed +__OPTIMIZE_SIZE__ + \ + +394 && ! +defed + +__NO_INLINE__ + && !defed +__lulus + + +414  + ~ + +417  + ~ + +420 #i +__USE_FORTIFY_LEVEL + > 0 && ! +defed + +__lulus + + +422  + ~ + +426 +__END_DECLS + + + @/usr/include/sys/types.h + +24 #idef +_SYS_TYPES_H + + +25  + #_SYS_TYPES_H + 1 + + ) + +27  + ~ + +29 + g__BEGIN_DECLS + + +31  + ~ + +33 #ifdef +__USE_BSD + + +34 #ide +__u_ch_defed + + +35  +__u_ch + + tu_ch +; + +36  +__u_sht + + tu_sht +; + +37  +__u_t + + tu_t +; + +38  +__u_lg + + tu_lg +; + +39  +__quad_t + + tquad_t +; + +40  +__u_quad_t + + tu_quad_t +; + +41  +__fsid_t + + tfsid_t +; + +42  + #__u_ch_defed + + + ) + +46  +__loff_t + + tloff_t +; + +48 #ide +__o_t_defed + + +49 #ide +__USE_FILE_OFFSET64 + + +50  +__o_t + + to_t +; + +52  +__o64_t + + to_t +; + +54  + #__o_t_defed + + + ) + +56 #i +defed + +__USE_LARGEFILE64 + && !defed +__o64_t_defed + + +57  +__o64_t + + to64_t +; + +58  + #__o64_t_defed + + + ) + +61 #ide +__dev_t_defed + + +62  +__dev_t + + tdev_t +; + +63  + #__dev_t_defed + + + ) + +66 #ide +__gid_t_defed + + +67  +__gid_t + + tgid_t +; + +68  + #__gid_t_defed + + + ) + +71 #ide +__mode_t_defed + + +72  +__mode_t + + tmode_t +; + +73  + #__mode_t_defed + + + ) + +76 #ide +__ƚk_t_defed + + +77  +__ƚk_t + + tƚk_t +; + +78  + #__ƚk_t_defed + + + ) + +81 #ide +__uid_t_defed + + +82  +__uid_t + + tuid_t +; + +83  + #__uid_t_defed + + + ) + +86 #ide +__off_t_defed + + +87 #ide +__USE_FILE_OFFSET64 + + +88  +__off_t + + toff_t +; + +90  +__off64_t + + toff_t +; + +92  + #__off_t_defed + + + ) + +94 #i +defed + +__USE_LARGEFILE64 + && !defed +__off64_t_defed + + +95  +__off64_t + + toff64_t +; + +96  + #__off64_t_defed + + + ) + +99 #ide +__pid_t_defed + + +100  +__pid_t + + tpid_t +; + +101  + #__pid_t_defed + + + ) + +104 #i( +defed + +__USE_SVID + || defed +__USE_XOPEN +&& !defed +__id_t_defed + + +105  +__id_t + + tid_t +; + +106  + #__id_t_defed + + + ) + +109 #ide +__ssize_t_defed + + +110  +__ssize_t + + tssize_t +; + +111  + #__ssize_t_defed + + + ) + +114 #ifdef +__USE_BSD + + +115 #ide +__daddr_t_defed + + +116  +__daddr_t + + tdaddr_t +; + +117  +__ddr_t + + tddr_t +; + +118  + #__daddr_t_defed + + + ) + +122 #i( +defed + +__USE_SVID + || defed +__USE_XOPEN +&& !defed +__key_t_defed + + +123  +__key_t + + tkey_t +; + +124  + #__key_t_defed + + + ) + +127 #ifde +__USE_XOPEN + + +128  + #__ed_ock_t + + + ) + +130  + #__ed_time_t + + + ) + +131  + #__ed_tim_t + + + ) + +132  + #__ed_ockid_t + + + ) + +133  + ~ + +135 #ifde +__USE_XOPEN + + +136 #ide +__ucds_t_defed + + +137  +__ucds_t + + tucds_t +; + +138  + #__ucds_t_defed + + + ) + +140 #ide +__sucds_t_defed + + +141  +__sucds_t + + tsucds_t +; + +142  + #__sucds_t_defed + + + ) + +146  + #__ed_size_t + + + ) + +147  + ~ + +149 #ifde +__USE_MISC + + +151  + tulg +; + +152  + tusht +; + +153  + tut +; + +158 #i! +__GNUC_PREREQ + (2, 7) + +161 #ide +__t8_t_defed + + +162  + #__t8_t_defed + + + ) + +163  + tt8_t +; + +164  + tt16_t +; + +165  + tt32_t +; + +166 #i +__GLIBC_HAVE_LONG_LONG + + +167 +__exnsi__ +  + tt64_t +; + +172  + tu_t8_t +; + +173  + tu_t16_t +; + +174  + tu_t32_t +; + +175 #i +__GLIBC_HAVE_LONG_LONG + + +176 +__exnsi__ +  + tu_t64_t +; + +179  + tgi_t +; + +184  + #__tN_t +( +N +, +MODE +) \ + +185 ## + tN +## + t_t + + t__ibu__ + (( + t__mode__ + ( + tMODE +))) + + ) + +186  + t__u_tN_t +( + tN +, + tMODE +) \ + +187  + tu_t +## + tN +## + t_t + + t__ibu__ + (( + t__mode__ + ( + tMODE +))) + + ) + +189 #ide + t__t8_t_defed + + +190  + t__t8_t_defed + + + ) + +191 + t__tN_t + (8, + t__QI__ +); + +192 +__tN_t + (16, +__HI__ +); + +193 +__tN_t + (32, +__SI__ +); + +194 +__tN_t + (64, +__DI__ +); + +197 +__u_tN_t + (8, +__QI__ +); + +198 +__u_tN_t + (16, +__HI__ +); + +199 +__u_tN_t + (32, +__SI__ +); + +200 +__u_tN_t + (64, +__DI__ +); + +202  + tgi_t + + t__ibu__ + (( + t__mode__ + ( + t__wd__ +))); + +208  + #__BIT_TYPES_DEFINED__ + 1 + + ) + +211 #ifdef +__USE_BSD + + +213  + ~ + +216  + ~ + +219  + ~ + +223 #i +defed + +__USE_UNIX98 + && !defed +__blksize_t_defed + + +224  +__blksize_t + + tblksize_t +; + +225  + #__blksize_t_defed + + + ) + +229 #ide +__USE_FILE_OFFSET64 + + +230 #ide +__blkt_t_defed + + +231  +__blkt_t + + tblkt_t +; + +232  + #__blkt_t_defed + + + ) + +234 #ide +__fsblkt_t_defed + + +235  +__fsblkt_t + + tfsblkt_t +; + +236  + #__fsblkt_t_defed + + + ) + +238 #ide +__fsft_t_defed + + +239  +__fsft_t + + tfsft_t +; + +240  + #__fsft_t_defed + + + ) + +243 #ide +__blkt_t_defed + + +244  +__blkt64_t + + tblkt_t +; + +245  + #__blkt_t_defed + + + ) + +247 #ide +__fsblkt_t_defed + + +248  +__fsblkt64_t + + tfsblkt_t +; + +249  + #__fsblkt_t_defed + + + ) + +251 #ide +__fsft_t_defed + + +252  +__fsft64_t + + tfsft_t +; + +253  + #__fsft_t_defed + + + ) + +257 #ifde +__USE_LARGEFILE64 + + +258  +__blkt64_t + + tblkt64_t +; + +259  +__fsblkt64_t + + tfsblkt64_t +; + +260  +__fsft64_t + + tfsft64_t +; + +265 #i +defed + +__USE_POSIX199506 + || defed +__USE_UNIX98 + + +266  + ~ + +269 + g__END_DECLS + + + @/usr/include/unistd.h + +23 #idef +_UNISTD_H + + +24  + #_UNISTD_H + 1 + + ) + +26  + ~ + +28 + g__BEGIN_DECLS + + +34  + #_POSIX_VERSION + 200112L + + ) + +40  + #_POSIX2_VERSION + 200112L + + ) + +44  + #_POSIX2_C_BIND + 200112L + + ) + +48  + #_POSIX2_C_DEV + 200112L + + ) + +52  + #_POSIX2_SW_DEV + 200112L + + ) + +56  + #_POSIX2_LOCALEDEF + 200112L + + ) + +59 #ifde +__USE_UNIX98 + + +60  + #_XOPEN_VERSION + 500 + + ) + +62  + #_XOPEN_VERSION + 4 + + ) + +66  + #_XOPEN_XCU_VERSION + 4 + + ) + +69  + #_XOPEN_XPG2 + 1 + + ) + +70  + #_XOPEN_XPG3 + 1 + + ) + +71  + #_XOPEN_XPG4 + 1 + + ) + +74  + #_XOPEN_UNIX + 1 + + ) + +77  + #_XOPEN_CRYPT + 1 + + ) + +81  + #_XOPEN_ENH_I18N + 1 + + ) + +84  + #_XOPEN_LEGACY + 1 + + ) + +171  + ~ + +174 #ifde +__USE_UNIX98 + + +175  + ~ + +179  + #STDIN_FILENO + 0 + + ) + +180  + #STDOUT_FILENO + 1 + + ) + +181  + #STDERR_FILENO + 2 + + ) + +186  + ~ + +188 #idef +__ssize_t_defed + + +189  +__ssize_t + + tssize_t +; + +190  + #__ssize_t_defed + + + ) + +193  + #__ed_size_t + + + ) + +194  + #__ed_NULL + + + ) + +195  + ~ + +197 #i +defed + +__USE_XOPEN + || defed +__USE_XOPEN2K + + +200 #ide +__gid_t_defed + + +201  +__gid_t + + tgid_t +; + +202  + #__gid_t_defed + + + ) + +205 #ide +__uid_t_defed + + +206  +__uid_t + + tuid_t +; + +207  + #__uid_t_defed + + + ) + +210 #ide +__off_t_defed + + +211 #ide +__USE_FILE_OFFSET64 + + +212  +__off_t + + toff_t +; + +214  +__off64_t + + toff_t +; + +216  + #__off_t_defed + + + ) + +218 #i +defed + +__USE_LARGEFILE64 + && !defed +__off64_t_defed + + +219  +__off64_t + + toff64_t +; + +220  + #__off64_t_defed + + + ) + +223 #ide +__ucds_t_defed + + +224  +__ucds_t + + tucds_t +; + +225  + #__ucds_t_defed + + + ) + +228 #ide +__pid_t_defed + + +229  +__pid_t + + tpid_t +; + +230  + #__pid_t_defed + + + ) + +234 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + + +235 #ide +___t_defed + + +236  +___t + + t_t +; + +237  + #___t_defed + + + ) + +241 #i +defed + +__USE_BSD + || defed +__USE_XOPEN + + +242 #ide +__sockn_t_defed + + +243  +__sockn_t + + tsockn_t +; + +244  + #__sockn_t_defed + + + ) + +250  + #R_OK + 4 + + ) + +251  + #W_OK + 2 + + ) + +252  + #X_OK + 1 + + ) + +253  + #F_OK + 0 + + ) + +256  + $acss + ( +__cڡ + * +__me +,  +__ty + +__THROW + + `__nnu + ((1)); + +258 #ifde +__USE_GNU + + +261  + $euidacss + ( +__cڡ + * +__me +,  +__ty +) + +262 +__THROW + + `__nnu + ((1)); + +267 #idef +_STDIO_H + + +268  + #SEEK_SET + 0 + + ) + +269  + #SEEK_CUR + 1 + + ) + +270  + #SEEK_END + 2 + + ) + +273 #i +defed + +__USE_BSD + && !defed +L_SET + + +275  + #L_SET + +SEEK_SET + + + ) + +276  + #L_INCR + +SEEK_CUR + + + ) + +277  + #L_XTND + +SEEK_END + + + ) + +286 #ide +__USE_FILE_OFFSET64 + + +287 +__off_t + + $lek + ( +__fd +, +__off_t + +__offt +,  +__wh + +__THROW +; + +289 #ifde +__REDIRECT_NTH + + +290 +__off64_t + + `__REDIRECT_NTH + ( +lek +, + +291 ( +__fd +, +__off64_t + +__offt +,  +__wh +), + +292 +lek64 +); + +294  + #lek + +lek64 + + + ) + +297 #ifde +__USE_LARGEFILE64 + + +298 +__off64_t + + $lek64 + ( +__fd +, +__off64_t + +__offt +,  +__wh + +__THROW +; + +305  + `o + ( +__fd +); + +312 +ssize_t + + `ad + ( +__fd +, * +__buf +, +size_t + +__nbys +); + +318 +ssize_t + + `wre + ( +__fd +, +__cڡ + * +__buf +, +size_t + +__n +); + +320 #ifde +__USE_UNIX98 + + +321 #ide +__USE_FILE_OFFSET64 + + +328 +ssize_t + + `d + ( +__fd +, * +__buf +, +size_t + +__nbys +, + +329 +__off_t + +__offt +); + +336 +ssize_t + + `pwre + ( +__fd +, +__cڡ + * +__buf +, +size_t + +__n +, + +337 +__off_t + +__offt +); + +339 #ifde +__REDIRECT + + +340 +ssize_t + + `__REDIRECT + ( +d +, ( +__fd +, * +__buf +, +size_t + +__nbys +, + +341 +__off64_t + +__offt +), + +342 +d64 +); + +343 +ssize_t + + `__REDIRECT + ( +pwre +, ( +__fd +, +__cڡ + * +__buf +, + +344 +size_t + +__nbys +, +__off64_t + +__offt +), + +345 +pwre64 +); + +347  + #d + +d64 + + + ) + +348  + #pwre + +pwre64 + + + ) + +352 #ifde +__USE_LARGEFILE64 + + +356 +ssize_t + + `d64 + ( +__fd +, * +__buf +, +size_t + +__nbys +, + +357 +__off64_t + +__offt +); + +360 +ssize_t + + `pwre64 + ( +__fd +, +__cڡ + * +__buf +, +size_t + +__n +, + +361 +__off64_t + +__offt +); + +369  + `pe + ( +__pedes +[2] +__THROW +; + +378  + $m + ( +__cds + +__THROW +; + +390  + `p + ( +__cds +); + +392 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +397 +__ucds_t + + $um + ( +__ucds_t + +__vue +, __ucds_ +__rv +) + +398 +__THROW +; + +405  + `up + ( +__ucds_t + +__ucds +); + +414  + `u + (); + +418  + $chown + ( +__cڡ + * +__fe +, +__uid_t + +__owr +, +__gid_t + +__group +) + +419 +__THROW + + `__nnu + ((1)); + +421 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +423  + $fchown + ( +__fd +, +__uid_t + +__owr +, +__gid_t + +__group + +__THROW +; + +428  + $lchown + ( +__cڡ + * +__fe +, +__uid_t + +__owr +, +__gid_t + +__group +) + +429 +__THROW + + `__nnu + ((1)); + +434  + $chd + ( +__cڡ + * +__th + +__THROW + + `__nnu + ((1)); + +436 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +438  + $fchd + ( +__fd + +__THROW +; + +448 * + $gcwd + (* +__buf +, +size_t + +__size + +__THROW +; + +450 #ifdef +__USE_GNU + + +454 * + $g_cut_d_me + ( +__THROW +; + +457 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +461 * + $gwd + (* +__buf + +__THROW + + `__nnu + ((1)); + +466  + $dup + ( +__fd + +__THROW +; + +469  + $dup2 + ( +__fd +,  +__fd2 + +__THROW +; + +472 ** +__v +; + +473 #ifde +__USE_GNU + + +474 ** +v +; + +480  + $execve + ( +__cڡ + * +__th +, *__cڡ +__gv +[], + +481 * +__cڡ + +__vp +[] +__THROW + + `__nnu + ((1)); + +483 #ifde +__USE_GNU + + +486  + $xecve + ( +__fd +, * +__cڡ + +__gv +[], *__cڡ +__vp +[]) + +487 +__THROW +; + +492  + $execv + ( +__cڡ + * +__th +, *__cڡ +__gv +[]) + +493 +__THROW + + `__nnu + ((1)); + +497  + $exee + ( +__cڡ + * +__th +, __cڡ * +__g +, ...) + +498 +__THROW + + `__nnu + ((1)); + +502  + $exe + ( +__cڡ + * +__th +, __cڡ * +__g +, ...) + +503 +__THROW + + `__nnu + ((1)); + +507  + $execvp + ( +__cڡ + * +__fe +, *__cڡ +__gv +[]) + +508 +__THROW + + `__nnu + ((1)); + +513  + $exep + ( +__cڡ + * +__fe +, __cڡ * +__g +, ...) + +514 +__THROW + + `__nnu + ((1)); + +517 #i +defed + +__USE_MISC + || defed +__USE_XOPEN + + +519  + $ni + ( +__c + +__THROW +; + +524  + $_ex + ( +__us + + `__ibu__ + (( +__nܑu__ +)); + +530  + ~ + +533  + $thcf + ( +__cڡ + * +__th +,  +__me +) + +534 +__THROW + + `__nnu + ((1)); + +537  + $hcf + ( +__fd +,  +__me + +__THROW +; + +540  + $syscf + ( +__me + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +542 #ifdef +__USE_POSIX2 + + +544 +size_t + + $cfr + ( +__me +, * +__buf +, +size_t + +__n + +__THROW +; + +549 +__pid_t + + $gpid + ( +__THROW +; + +552 +__pid_t + + $gid + ( +__THROW +; + +556 #ide +__FAVOR_BSD + + +557 +__pid_t + + $gpg + ( +__THROW +; + +559 #ifde +__REDIRECT_NTH + + +560 +__pid_t + + `__REDIRECT_NTH + ( +gpg +, (__pid_ +__pid +), +__gpgid +); + +562  + #gpg + +__gpgid + + + ) + +567 +__pid_t + + $__gpgid + ( +__pid_t + +__pid + +__THROW +; + +568 #ifde +__USE_XOPEN_EXTENDED + + +569 +__pid_t + + $gpgid + ( +__pid_t + +__pid + +__THROW +; + +576  + $gid + ( +__pid_t + +__pid +, __pid_ +__pgid + +__THROW +; + +578 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +589 #ide +__FAVOR_BSD + + +593  + $g + ( +__THROW +; + +598 #ifde +__REDIRECT_NTH + + +599  + `__REDIRECT_NTH + ( +g +, ( +__pid_t + +__pid +, __pid_ +__pg +), +gid +); + +601  + #g + +gid + + + ) + +610 +__pid_t + + $tsid + ( +__THROW +; + +612 #ifde +__USE_XOPEN_EXTENDED + + +614 +__pid_t + + $gsid + ( +__pid_t + +__pid + +__THROW +; + +618 +__uid_t + + $guid + ( +__THROW +; + +621 +__uid_t + + $geuid + ( +__THROW +; + +624 +__gid_t + + $ggid + ( +__THROW +; + +627 +__gid_t + + $gegid + ( +__THROW +; + +632  + $ggroups + ( +__size +, +__gid_t + +__li +[] +__THROW +; + +634 #ifdef +__USE_GNU + + +636  + $group_memb + ( +__gid_t + +__gid + +__THROW +; + +643  + $tuid + ( +__uid_t + +__uid + +__THROW +; + +645 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +648  + $euid + ( +__uid_t + +__ruid +, __uid_ +__euid + +__THROW +; + +651 #i +defed + +__USE_BSD + || defed +__USE_XOPEN2K + + +653  + $uid + ( +__uid_t + +__uid + +__THROW +; + +660  + $tgid + ( +__gid_t + +__gid + +__THROW +; + +662 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +665  + $egid + ( +__gid_t + +__rgid +, __gid_ +__egid + +__THROW +; + +668 #i +defed + +__USE_BSD + || defed +__USE_XOPEN2K + + +670  + $gid + ( +__gid_t + +__gid + +__THROW +; + +673 #ifde +__USE_GNU + + +676  + `gsuid + ( +__uid_t + * +__euid +, __uid_* +__ruid +, __uid_* +__suid +); + +680  + `gsgid + ( +__gid_t + * +__egid +, __gid_* +__rgid +, __gid_* +__sgid +); + +684  + `esuid + ( +__uid_t + +__euid +, __uid_ +__ruid +, __uid_ +__suid +); + +688  + `esgid + ( +__gid_t + +__egid +, __gid_ +__rgid +, __gid_ +__sgid +); + +695 +__pid_t + + $fk + ( +__THROW +; + +697 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +702 +__pid_t + + $vfk + ( +__THROW +; + +708 * + $yme + ( +__fd + +__THROW +; + +712  + $yme_r + ( +__fd +, * +__buf +, +size_t + +__bu +) + +713 +__THROW + + `__nnu + ((2)); + +717  + $iy + ( +__fd + +__THROW +; + +719 #i +defed + +__USE_BSD + \ + +720 || ( +defed + +__USE_XOPEN_EXTENDED + && !defed +__USE_UNIX98 +) + +723  + $y + ( +__THROW +; + +728  + $lk + ( +__cڡ + * +__om +, __cڡ * +__to +) + +729 +__THROW + + `__nnu + ((1, 2)); + +731 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_XOPEN2K + + +733  + $symlk + ( +__cڡ + * +__om +, __cڡ * +__to +) + +734 +__THROW + + `__nnu + ((1, 2)); + +739  + $adlk + ( +__cڡ + * +__ri + +__th +, *__ri +__buf +, + +740 +size_t + +__n + +__THROW + + `__nnu + ((1, 2)); + +744  + $uƚk + ( +__cڡ + * +__me + +__THROW + + `__nnu + ((1)); + +747  + $rmd + ( +__cڡ + * +__th + +__THROW + + `__nnu + ((1)); + +751 +__pid_t + + $tcgpg + ( +__fd + +__THROW +; + +754  + $tcg + ( +__fd +, +__pid_t + +__pg_id + +__THROW +; + +761 * + `glog + (); + +762 #i +defed + +__USE_REENTRANT + || defed +__USE_UNIX98 + + +769  + $glog_r + (* +__me +, +size_t + +__me_n + + `__nnu + ((1)); + +772 #ifdef +__USE_BSD + + +774  + $og + ( +__cڡ + * +__me + +__THROW + + `__nnu + ((1)); + +778 #ifdef +__USE_POSIX2 + + +782  + #__ed_gt + + + ) + +783  + ~ + +787 #i +defed + +__USE_BSD + || defed +__USE_UNIX98 + + +791  + $ghome + (* +__me +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +795 #i +defed + +__USE_BSD + || (defed +__USE_XOPEN + && !defed +__USE_UNIX98 +) + +798  + $thome + ( +__cڡ + * +__me +, +size_t + +__n +) + +799 +__THROW + + `__nnu + ((1)); + +803  + $thoid + ( +__id + +__THROW +; + +809  + $gdomame + (* +__me +, +size_t + +__n +) + +810 +__THROW + + `__nnu + ((1)); + +811  + $tdomame + ( +__cڡ + * +__me +, +size_t + +__n +) + +812 +__THROW + + `__nnu + ((1)); + +818  + $vhgup + ( +__THROW +; + +821  + $voke + ( +__cڡ + * +__fe + +__THROW + + `__nnu + ((1)); + +829  + $of + (* +__me_bufr +, +size_t + +__size +, + +830 +size_t + +__offt +,  +__s +) + +831 +__THROW + + `__nnu + ((1)); + +837  + $ac + ( +__cڡ + * +__me + +__THROW +; + +841 * + $gurshl + ( +__THROW +; + +842  + $durshl + ( +__THROW +; + +843  + $turshl + ( +__THROW +; + +849  + $dm + ( +__nochd +,  +__noo + +__THROW +; + +853 #i +defed + +__USE_BSD + || (defed +__USE_XOPEN + && !defed +__USE_XOPEN2K +) + +856  + $chro + ( +__cڡ + * +__th + +__THROW + + `__nnu + ((1)); + +860 * + $gss + ( +__cڡ + * +__om + + `__nnu + ((1)); + +864 #i +defed + +__USE_BSD + || defed +__USE_XOPEN + + +869  + `fsync + ( +__fd +); + +873 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +876  + `ghoid + (); + +879  + $sync + ( +__THROW +; + +884  + $ggesize + ( +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +889  + $gdbsize + ( +__THROW +; + +893 #ide +__USE_FILE_OFFSET64 + + +894  + $un + ( +__cڡ + * +__fe +, +__off_t + +__ngth +) + +895 +__THROW + + `__nnu + ((1)); + +897 #ifde +__REDIRECT_NTH + + +898  + `__REDIRECT_NTH + ( +un +, + +899 ( +__cڡ + * +__fe +, +__off64_t + +__ngth +), + +900 +un64 + + `__nnu + ((1)); + +902  + #un + +un64 + + + ) + +905 #ifde +__USE_LARGEFILE64 + + +906  + $un64 + ( +__cڡ + * +__fe +, +__off64_t + +__ngth +) + +907 +__THROW + + `__nnu + ((1)); + +912 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_XOPEN2K + + +915 #ide +__USE_FILE_OFFSET64 + + +916  + $run + ( +__fd +, +__off_t + +__ngth + +__THROW +; + +918 #ifde +__REDIRECT_NTH + + +919  + `__REDIRECT_NTH + ( +run +, ( +__fd +, +__off64_t + +__ngth +), + +920 +run64 +); + +922  + #run + +run64 + + + ) + +925 #ifde +__USE_LARGEFILE64 + + +926  + $run64 + ( +__fd +, +__off64_t + +__ngth + +__THROW +; + +932 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + + +936  + $brk + (* +__addr + +__THROW +; + +942 * + $sbrk + ( +_t + +__d + +__THROW +; + +946 #ifde +__USE_MISC + + +957  + $sys + ( +__syo +, ... +__THROW +; + +962 #i( +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED +&& !defed +F_LOCK + + +974  + #F_ULOCK + 0 + + ) + +975  + #F_LOCK + 1 + + ) + +976  + #F_TLOCK + 2 + + ) + +977  + #F_TEST + 3 + + ) + +979 #ide +__USE_FILE_OFFSET64 + + +980  + `lockf + ( +__fd +,  +__cmd +, +__off_t + +__n +); + +982 #ifde +__REDIRECT + + +983  + `__REDIRECT + ( +lockf +, ( +__fd +,  +__cmd +, +__off64_t + +__n +), + +984 +lockf64 +); + +986  + #lockf + +lockf64 + + + ) + +989 #ifde +__USE_LARGEFILE64 + + +990  + `lockf64 + ( +__fd +,  +__cmd +, +__off64_t + +__n +); + +995 #ifde +__USE_GNU + + +1000  + #TEMP_FAILURE_RETRY +( +exessi +) \ + +1001 ( +__exnsi__ + \ + +1002 ({  +__su +; \ + +1003 d +__su + = (( +exessi +); \ + +1004  +__su + =-1L && +o + = +EINTR +); \ + +1005 +__su +; + } +})) + + ) + +1008 #i +defed + +__USE_POSIX199309 + || defed +__USE_UNIX98 + + +1011  + $fdasync + ( +__fdes + +__THROW +; + +1017 #ifdef +__USE_XOPEN + + +1019 * + $y + ( +__cڡ + * +__key +, __cڡ * +__ +) + +1020 +__THROW + + `__nnu + ((1, 2)); + +1024  + $y + (* +__block +,  +__edag + +__THROW + + `__nnu + ((1)); + +1031  + $swab + ( +__cڡ + * +__ri + +__om +, *__ri +__to +, + +1032 +ssize_t + +__n + +__THROW + + `__nnu + ((1, 2)); + +1038 #ifde +__USE_XOPEN + + +1040 * + $mid + (* +__s + +__THROW + + `__nnu + ((1)); + +1043 +__END_DECLS + + + @/usr/include/alloca.h + +19 #idef +_ALLOCA_H + + +20  + #_ALLOCA_H + 1 + + ) + +22  + ~ + +24  + #__ed_size_t + + + ) + +25  + ~ + +27 + g__BEGIN_DECLS + + +30 #unde +lo + + +33 * + $lo + ( +size_t + +__size + +__THROW +; + +35 #ifdef +__GNUC__ + + +36  + #lo +( +size + + `__but_lo + (size) + + ) + +39 +__END_DECLS + + + @/usr/include/asm-i386/atomic.h + +1 #ide +__ARCH_I386_ATOMIC__ + + +2  + #__ARCH_I386_ATOMIC__ + + + ) + +10 #ifde +CONFIG_SMP + + +11  + #LOCK + "lock ; " + + ) + +13  + #LOCK + "" + + ) + +21 ru { vީ + mcou +; } + tomic_t +; + +23  + #ATOMIC_INIT +( +i +{ (i} + + ) + +31  + #omic_ad +( +v +((v)-> +cou +) + + ) + +40  + #omic_t +( +v +, +i +(((v)-> +cou +(i)) + + ) + +49  +__le__ +  + $omic_add +( +i +, +omic_t + * +v +) + +51 +__asm__ + + `__vީe__ +( + +52 +LOCK + "addl %1,%0" + +53 :"=m" ( +v +-> +cou +) + +54 :"" ( +i +), "m" ( +v +-> +cou +)); + +55 + } +} + +64  +__le__ +  + $omic_sub +( +i +, +omic_t + * +v +) + +66 +__asm__ + + `__vީe__ +( + +67 +LOCK + "subl %1,%0" + +68 :"=m" ( +v +-> +cou +) + +69 :"" ( +i +), "m" ( +v +-> +cou +)); + +70 + } +} + +81  +__le__ +  + $omic_sub_d_ +( +i +, +omic_t + * +v +) + +83  +c +; + +85 +__asm__ + + `__vީe__ +( + +86 +LOCK + "subl %2,%0; sete %1" + +87 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +88 :"" ( +i +), "m" ( +v +-> +cou +) : "memory"); + +89  +c +; + +90 + } +} + +98  +__le__ +  + $omic_c +( +omic_t + * +v +) + +100 +__asm__ + + `__vީe__ +( + +101 +LOCK + "incl %0" + +102 :"=m" ( +v +-> +cou +) + +103 :"m" ( +v +-> +cou +)); + +104 + } +} + +112  +__le__ +  + $omic_dec +( +omic_t + * +v +) + +114 +__asm__ + + `__vީe__ +( + +115 +LOCK + "decl %0" + +116 :"=m" ( +v +-> +cou +) + +117 :"m" ( +v +-> +cou +)); + +118 + } +} + +128  +__le__ +  + $omic_dec_d_ +( +omic_t + * +v +) + +130  +c +; + +132 +__asm__ + + `__vީe__ +( + +133 +LOCK + "decl %0; sete %1" + +134 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +135 :"m" ( +v +-> +cou +) : "memory"); + +136  +c + != 0; + +137 + } +} + +147  +__le__ +  + $omic_c_d_ +( +omic_t + * +v +) + +149  +c +; + +151 +__asm__ + + `__vީe__ +( + +152 +LOCK + "incl %0; sete %1" + +153 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +154 :"m" ( +v +-> +cou +) : "memory"); + +155  +c + != 0; + +156 + } +} + +167  +__le__ +  + $omic_add_give +( +i +, +omic_t + * +v +) + +169  +c +; + +171 +__asm__ + + `__vީe__ +( + +172 +LOCK + "addl %2,%0; sets %1" + +173 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +174 :"" ( +i +), "m" ( +v +-> +cou +) : "memory"); + +175  +c +; + +176 + } +} + +185  +__le__ +  + $omic_add_tu +( +i +, +omic_t + * +v +) + +187  +__i +; + +188 #ifde +CONFIG_M386 + + +189 if( + `uiky +( +bo_u_da +. +x86 +==3)) + +190  +no_xadd +; + +193 +__i + = +i +; + +194 +__asm__ + + `__vީe__ +( + +195 +LOCK + "xaddl %0, %1;" + +196 :""( +i +) + +197 :"m"( +v +-> +cou +), "0"( +i +)); + +198  +i + + +__i +; + +200 #ifde +CONFIG_M386 + + +201 +no_xadd +: + +202 + `lol_q_dib +(); + +203 +__i + = + `omic_ad +( +v +); + +204 + `omic_t +( +v +, +i + + +__i +); + +205 + `lol_q_ab +(); + +206  +i + + +__i +; + +208 + } +} + +210  +__le__ +  + $omic_sub_tu +( +i +, +omic_t + * +v +) + +212  + `omic_add_tu +(- +i +, +v +); + +213 + } +} + +215  + #omic_c_tu +( +v +( + `omic_add_tu +(1,v)) + + ) + +216  + #omic_dec_tu +( +v +( + `omic_sub_tu +(1,v)) + + ) + +219  + #omic_r_mask +( +mask +, +addr +) \ + +220 +__asm__ + + `__vީe__ +( +LOCK + "andl %0,%1" \ + +221 : : "r" (~( +mask +)),"m" (* +addr +: "memy") + + ) + +223  + #omic_t_mask +( +mask +, +addr +) \ + +224 +__asm__ + + `__vީe__ +( +LOCK + "orl %0,%1" \ + +225 : : "r" ( +mask +),"m" (*( +addr +): "memy") + + ) + +228  + #smp_mb__befe_omic_dec +( + `brr +() + + ) + +229  + #smp_mb__a_omic_dec +( + `brr +() + + ) + +230  + #smp_mb__befe_omic_c +( + `brr +() + + ) + +231  + #smp_mb__a_omic_c +( + `brr +() + + ) + + @/usr/include/asm-i386/bitops.h + +1 #ide +_I386_BITOPS_H + + +2  + #_I386_BITOPS_H + + + ) + +18 #i0 && +defed +( +CONFIG_SMP +) + +19  + #LOCK_PREFIX + "lock ; " + + ) + +21  + #LOCK_PREFIX + "" + + ) + +24  + #ADDR + (*(vީ* +addr +) + + ) + +41  +le +  + $t_b +( + +, vީ* +addr +) + +43 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +45 :"=m" ( +ADDR +) + +46 :"Ir" ( + +)); + +47 + } +} + +58  +le +  + $__t_b +( + +, vީ* +addr +) + +60 + `__asm__ +( + +62 :"=m" ( +ADDR +) + +63 :"Ir" ( + +)); + +64 + } +} + +76  +le +  + $r_b +( + +, vީ* +addr +) + +78 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +80 :"=m" ( +ADDR +) + +81 :"Ir" ( + +)); + +82 + } +} + +84  +le +  + $__r_b +( + +, vީ* +addr +) + +86 +__asm__ + + `__vީe__ +( + +88 :"=m" ( +ADDR +) + +89 :"Ir" ( + +)); + +90 + } +} + +101  +le +  + $__chge_b +( + +, vީ* +addr +) + +103 +__asm__ + + `__vީe__ +( + +105 :"=m" ( +ADDR +) + +106 :"Ir" ( + +)); + +107 + } +} + +119  +le +  + $chge_b +( + +, vީ* +addr +) + +121 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +123 :"=m" ( +ADDR +) + +124 :"Ir" ( + +)); + +125 + } +} + +136  +le +  + $_d_t_b +( + +, vީ* +addr +) + +138  +db +; + +140 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +142 :"" ( +db +),"=m" ( +ADDR +) + +143 :"Ir" ( + +) : "memory"); + +144  +db +; + +145 + } +} + +156  +le +  + $___d_t_b +( + +, vީ* +addr +) + +158  +db +; + +160 + `__asm__ +( + +162 :"" ( +db +),"=m" ( +ADDR +) + +163 :"Ir" ( + +)); + +164  +db +; + +165 + } +} + +176  +le +  + $_d_r_b +( + +, vީ* +addr +) + +178  +db +; + +180 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +182 :"" ( +db +),"=m" ( +ADDR +) + +183 :"Ir" ( + +) : "memory"); + +184  +db +; + +185 + } +} + +196  +le +  + $___d_r_b +( + +, vީ* +addr +) + +198  +db +; + +200 + `__asm__ +( + +202 :"" ( +db +),"=m" ( +ADDR +) + +203 :"Ir" ( + +)); + +204  +db +; + +205 + } +} + +208  +le +  + $___d_chge_b +( + +, vީ* +addr +) + +210  +db +; + +212 +__asm__ + + `__vީe__ +( + +214 :"" ( +db +),"=m" ( +ADDR +) + +215 :"Ir" ( + +) : "memory"); + +216  +db +; + +217 + } +} + +227  +le +  + $_d_chge_b +( + +, vީ* +addr +) + +229  +db +; + +231 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +233 :"" ( +db +),"=m" ( +ADDR +) + +234 :"Ir" ( + +) : "memory"); + +235  +db +; + +236 + } +} + +244  +_b +( + +, cڡ vީ* +addr +); + +247  +le +  + $cڡt__b +( + +, cڡ vީ* +addr +) + +249  ((1UL << ( + + & 31)& ( +addr +[nr >> 5])) != 0; + +250 + } +} + +252  +le +  + $vb__b +( + +, cڡ vީ* +addr +) + +254  +db +; + +256 +__asm__ + + `__vީe__ +( + +258 :"" ( +db +) + +259 :"m" ( +ADDR +),"Ir" ( + +)); + +260  +db +; + +261 + } +} + +263  + #_b +( + +, +addr +) \ + +264 ( + `__but_cڡt_p +( + +) ? \ + +265 + `cڡt__b +(( + +),( +addr +)) : \ + +266 + `vb__b +(( + +),( +addr +))) + + ) + +268 #unde +ADDR + + +278  +le +  + $fd_f_zo_b +(cڡ * +addr +,  +size +) + +280  +d0 +, +d1 +, +d2 +; + +281  +s +; + +283 i(! +size +) + +286 +__asm__ + + `__vީe__ +( + +297 :"=d" ( +s +), "=&c" ( +d0 +), "=&D" ( +d1 +), "=&a" ( +d2 +) + +298 :"1" (( +size + + 31>> 5), "2" ( +addr +), "b" (addr) : "memory"); + +299  +s +; + +300 + } +} + +308  +fd_xt_zo_b +(cڡ * +addr +,  +size +,  +offt +); + +318  +le +  + $fd_f_b +(cڡ * +addr +,  +size +) + +320  +d0 +, +d1 +; + +321  +s +; + +324 +__asm__ + + `__vީe__ +( + +333 :"" ( +s +), "=&c" ( +d0 +), "=&D" ( +d1 +) + +334 :"1" (( +size + + 31>> 5), "2" ( +addr +), "b" (addr) : "memory"); + +335  +s +; + +336 + } +} + +344  +fd_xt_b +(cڡ * +addr +,  +size +,  +offt +); + +352  +le +  + $ffz +( +wd +) + +354 + `__asm__ +("bsfl %1,%0" + +355 :"" ( +wd +) + +356 :"r" (~ +wd +)); + +357  +wd +; + +358 + } +} + +366  +le +  + $__ffs +( +wd +) + +368 + `__asm__ +("bsfl %1,%0" + +369 :"" ( +wd +) + +370 :"rm" ( +wd +)); + +371  +wd +; + +372 + } +} + +378  + #s +( +x + + `gic_s +(x) + + ) + + @/usr/include/asm-i386/byteorder.h + +1 #ide +_I386_BYTEORDER_H + + +2  + #_I386_BYTEORDER_H + + + ) + +4  + ~ + + @/usr/include/asm-i386/semaphore.h + +1 #ide +_I386_SEMAPHORE_H + + +2  + #_I386_SEMAPHORE_H + + + ) + +4  + ~ + + @/usr/include/asm-x86_64/atomic.h + +1 #ide +__ARCH_X86_64_ATOMIC__ + + +2  + #__ARCH_X86_64_ATOMIC__ + + + ) + +12 #ifde +CONFIG_SMP + + +13  + #LOCK + "lock ; " + + ) + +15  + #LOCK + "" + + ) + +23 ru { vީ + mcou +; } + tomic_t +; + +25  + #ATOMIC_INIT +( +i +{ (i} + + ) + +33  + #omic_ad +( +v +((v)-> +cou +) + + ) + +42  + #omic_t +( +v +, +i +(((v)-> +cou +(i)) + + ) + +51  +__le__ +  + $omic_add +( +i +, +omic_t + * +v +) + +53 +__asm__ + + `__vީe__ +( + +54 +LOCK + "addl %1,%0" + +55 :"=m" ( +v +-> +cou +) + +56 :"" ( +i +), "m" ( +v +-> +cou +)); + +57 + } +} + +66  +__le__ +  + $omic_sub +( +i +, +omic_t + * +v +) + +68 +__asm__ + + `__vީe__ +( + +69 +LOCK + "subl %1,%0" + +70 :"=m" ( +v +-> +cou +) + +71 :"" ( +i +), "m" ( +v +-> +cou +)); + +72 + } +} + +83  +__le__ +  + $omic_sub_d_ +( +i +, +omic_t + * +v +) + +85  +c +; + +87 +__asm__ + + `__vީe__ +( + +88 +LOCK + "subl %2,%0; sete %1" + +89 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +90 :"" ( +i +), "m" ( +v +-> +cou +) : "memory"); + +91  +c +; + +92 + } +} + +100  +__le__ +  + $omic_c +( +omic_t + * +v +) + +102 +__asm__ + + `__vީe__ +( + +103 +LOCK + "incl %0" + +104 :"=m" ( +v +-> +cou +) + +105 :"m" ( +v +-> +cou +)); + +106 + } +} + +114  +__le__ +  + $omic_dec +( +omic_t + * +v +) + +116 +__asm__ + + `__vީe__ +( + +117 +LOCK + "decl %0" + +118 :"=m" ( +v +-> +cou +) + +119 :"m" ( +v +-> +cou +)); + +120 + } +} + +130  +__le__ +  + $omic_dec_d_ +( +omic_t + * +v +) + +132  +c +; + +134 +__asm__ + + `__vީe__ +( + +135 +LOCK + "decl %0; sete %1" + +136 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +137 :"m" ( +v +-> +cou +) : "memory"); + +138  +c + != 0; + +139 + } +} + +149  +__le__ +  + $omic_c_d_ +( +omic_t + * +v +) + +151  +c +; + +153 +__asm__ + + `__vީe__ +( + +154 +LOCK + "incl %0; sete %1" + +155 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +156 :"m" ( +v +-> +cou +) : "memory"); + +157  +c + != 0; + +158 + } +} + +169  +__le__ +  + $omic_add_give +( +i +, +omic_t + * +v +) + +171  +c +; + +173 +__asm__ + + `__vީe__ +( + +174 +LOCK + "addl %2,%0; sets %1" + +175 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +176 :"" ( +i +), "m" ( +v +-> +cou +) : "memory"); + +177  +c +; + +178 + } +} + +182 ru { vީ + mcou +; } + tomic64_t +; + +184  + #ATOMIC64_INIT +( +i +{ (i} + + ) + +193  + #omic64_ad +( +v +((v)-> +cou +) + + ) + +202  + #omic64_t +( +v +, +i +(((v)-> +cou +(i)) + + ) + +211  +__le__ +  + $omic64_add +( +i +, +omic64_t + * +v +) + +213 +__asm__ + + `__vީe__ +( + +214 +LOCK + "addq %1,%0" + +215 :"=m" ( +v +-> +cou +) + +216 :"" ( +i +), "m" ( +v +-> +cou +)); + +217 + } +} + +226  +__le__ +  + $omic64_sub +( +i +, +omic64_t + * +v +) + +228 +__asm__ + + `__vީe__ +( + +229 +LOCK + "subq %1,%0" + +230 :"=m" ( +v +-> +cou +) + +231 :"" ( +i +), "m" ( +v +-> +cou +)); + +232 + } +} + +243  +__le__ +  + $omic64_sub_d_ +( +i +, +omic64_t + * +v +) + +245  +c +; + +247 +__asm__ + + `__vީe__ +( + +248 +LOCK + "subq %2,%0; sete %1" + +249 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +250 :"" ( +i +), "m" ( +v +-> +cou +) : "memory"); + +251  +c +; + +252 + } +} + +260  +__le__ +  + $omic64_c +( +omic64_t + * +v +) + +262 +__asm__ + + `__vީe__ +( + +263 +LOCK + "incq %0" + +264 :"=m" ( +v +-> +cou +) + +265 :"m" ( +v +-> +cou +)); + +266 + } +} + +274  +__le__ +  + $omic64_dec +( +omic64_t + * +v +) + +276 +__asm__ + + `__vީe__ +( + +277 +LOCK + "decq %0" + +278 :"=m" ( +v +-> +cou +) + +279 :"m" ( +v +-> +cou +)); + +280 + } +} + +290  +__le__ +  + $omic64_dec_d_ +( +omic64_t + * +v +) + +292  +c +; + +294 +__asm__ + + `__vީe__ +( + +295 +LOCK + "decq %0; sete %1" + +296 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +297 :"m" ( +v +-> +cou +) : "memory"); + +298  +c + != 0; + +299 + } +} + +309  +__le__ +  + $omic64_c_d_ +( +omic64_t + * +v +) + +311  +c +; + +313 +__asm__ + + `__vީe__ +( + +314 +LOCK + "incq %0; sete %1" + +315 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +316 :"m" ( +v +-> +cou +) : "memory"); + +317  +c + != 0; + +318 + } +} + +329  +__le__ +  + $omic64_add_give +( +i +, +omic64_t + * +v +) + +331  +c +; + +333 +__asm__ + + `__vީe__ +( + +334 +LOCK + "addq %2,%0; sets %1" + +335 :"=m" ( +v +-> +cou +), "=qm" ( +c +) + +336 :"" ( +i +), "m" ( +v +-> +cou +) : "memory"); + +337  +c +; + +338 + } +} + +347  +__le__ +  + $omic_add_tu +( +i +, +omic_t + * +v +) + +349  +__i + = +i +; + +350 +__asm__ + + `__vީe__ +( + +351 +LOCK + "xaddl %0, %1;" + +352 :""( +i +) + +353 :"m"( +v +-> +cou +), "0"( +i +)); + +354  +i + + +__i +; + +355 + } +} + +357  +__le__ +  + $omic_sub_tu +( +i +, +omic_t + * +v +) + +359  + `omic_add_tu +(- +i +, +v +); + +360 + } +} + +362  + #omic_c_tu +( +v +( + `omic_add_tu +(1,v)) + + ) + +363  + #omic_dec_tu +( +v +( + `omic_sub_tu +(1,v)) + + ) + +366  + #omic_r_mask +( +mask +, +addr +) \ + +367 +__asm__ + + `__vީe__ +( +LOCK + "andl %0,%1" \ + +368 : : "r" (~( +mask +)),"m" (* +addr +: "memy") + + ) + +370  + #omic_t_mask +( +mask +, +addr +) \ + +371 +__asm__ + + `__vީe__ +( +LOCK + "orl %0,%1" \ + +372 : : "r" (() +mask +),"m" (*( +addr +): "memy") + + ) + +375  + #smp_mb__befe_omic_dec +( + `brr +() + + ) + +376  + #smp_mb__a_omic_dec +( + `brr +() + + ) + +377  + #smp_mb__befe_omic_c +( + `brr +() + + ) + +378  + #smp_mb__a_omic_c +( + `brr +() + + ) + + @/usr/include/asm-x86_64/bitops.h + +1 #ide +_X86_64_BITOPS_H + + +2  + #_X86_64_BITOPS_H + + + ) + +11 #i0 && +defed +( +CONFIG_SMP +) + +12  + #LOCK_PREFIX + "lock ; " + + ) + +14  + #LOCK_PREFIX + "" + + ) + +17  + #ADDR + (*(vީ* +addr +) + + ) + +29  +__le__ +  + $t_b +( + +, vީ* +addr +) + +31 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +33 :"=m" ( +ADDR +) + +34 :"dIr" ( + +) : "memory"); + +35 + } +} + +46  +__le__ +  + $__t_b +( + +, vީ* +addr +) + +48 +__asm__ + volatile( + +50 :"=m" ( +ADDR +) + +51 :"dIr" ( + +) : "memory"); + +52 + } +} + +64  +__le__ +  + $r_b +( + +, vީ* +addr +) + +66 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +68 :"=m" ( +ADDR +) + +69 :"dIr" ( + +)); + +70 + } +} + +72  +__le__ +  + $__r_b +( + +, vީ* +addr +) + +74 +__asm__ + + `__vީe__ +( + +76 :"=m" ( +ADDR +) + +77 :"dIr" ( + +)); + +78 + } +} + +89  +__le__ +  + $__chge_b +( + +, vީ* +addr +) + +91 +__asm__ + + `__vީe__ +( + +93 :"=m" ( +ADDR +) + +94 :"dIr" ( + +)); + +95 + } +} + +106  +__le__ +  + $chge_b +( + +, vީ* +addr +) + +108 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +110 :"=m" ( +ADDR +) + +111 :"dIr" ( + +)); + +112 + } +} + +122  +__le__ +  + $_d_t_b +( + +, vީ* +addr +) + +124  +db +; + +126 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +128 :"" ( +db +),"=m" ( +ADDR +) + +129 :"dIr" ( + +) : "memory"); + +130  +db +; + +131 + } +} + +142  +__le__ +  + $___d_t_b +( + +, vީ* +addr +) + +144  +db +; + +146 + `__asm__ +( + +148 :"" ( +db +),"=m" ( +ADDR +) + +149 :"dIr" ( + +)); + +150  +db +; + +151 + } +} + +161  +__le__ +  + $_d_r_b +( + +, vީ* +addr +) + +163  +db +; + +165 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +167 :"" ( +db +),"=m" ( +ADDR +) + +168 :"dIr" ( + +) : "memory"); + +169  +db +; + +170 + } +} + +181  +__le__ +  + $___d_r_b +( + +, vީ* +addr +) + +183  +db +; + +185 + `__asm__ +( + +187 :"" ( +db +),"=m" ( +ADDR +) + +188 :"dIr" ( + +)); + +189  +db +; + +190 + } +} + +193  +__le__ +  + $___d_chge_b +( + +, vީ* +addr +) + +195  +db +; + +197 +__asm__ + + `__vީe__ +( + +199 :"" ( +db +),"=m" ( +ADDR +) + +200 :"dIr" ( + +) : "memory"); + +201  +db +; + +202 + } +} + +212  +__le__ +  + $_d_chge_b +( + +, vީ* +addr +) + +214  +db +; + +216 +__asm__ + + `__vީe__ + +LOCK_PREFIX + + +218 :"" ( +db +),"=m" ( +ADDR +) + +219 :"dIr" ( + +) : "memory"); + +220  +db +; + +221 + } +} + +229  +_b +( + +, cڡ vީ* +addr +); + +232  +__le__ +  + $cڡt__b +( + +, cڡ vީ* +addr +) + +234  ((1UL << ( + + & 31)& (((cڡ vީ* +addr +)[nr >> 5])) != 0; + +235 + } +} + +237  +__le__ +  + $vb__b +( + +, vީcڡ * +addr +) + +239  +db +; + +241 +__asm__ + + `__vީe__ +( + +243 :"" ( +db +) + +244 :"m" ( +ADDR +),"dIr" ( + +)); + +245  +db +; + +246 + } +} + +248  + #_b +( + +, +addr +) \ + +249 ( + `__but_cڡt_p +( + +) ? \ + +250 + `cڡt__b +(( + +),( +addr +)) : \ + +251 + `vb__b +(( + +),( +addr +))) + + ) + +253 #unde +ADDR + + +255  +fd_f_zo_b +(cڡ * +addr +,  +size +); + +256  +fd_xt_zo_b + (cڡ * +addr +,  +size +,  +offt +); + +257  +fd_f_b +(cڡ * +addr +,  +size +); + +258  +fd_xt_b +(cڡ * +addr +,  +size +,  +offt +); + +261  +le +  + $__snb +( +v +,  +max +) + +263 + `asm +("bsfq %1,%0 ; cmovz %2,%0" : "=&r" ( +v +: "r" (v), "r" ( +max +)); + +264  +v +; + +265 + } +} + +267  + #fd_f_b +( +addr +, +size +) \ + +268 (( + `__but_cڡt_p +( +size +&& (size< +BITS_PER_LONG + ? \ + +269 ( + `__snb +(*(*) +addr +,( +size +))) : \ + +270 + `fd_f_b +( +addr +, +size +))) + + ) + +272  + #fd_xt_b +( +addr +, +size +, +off +) \ + +273 (( + `__but_cڡt_p +( +size +&& (size< +BITS_PER_LONG + ? \ + +274 (( +off ++ ( + `__snb +((*(*) +addr +>> (off),( +size +)-(off)))) : \ + +275 + `fd_xt_b +( +addr +, +size +, +off +))) + + ) + +277  + #fd_f_zo_b +( +addr +, +size +) \ + +278 (( + `__but_cڡt_p +( +size +&& (size< +BITS_PER_LONG + ? \ + +279 ( + `__snb +(~*(*) +addr +,( +size +))) : \ + +280 + `fd_f_zo_b +( +addr +, +size +))) + + ) + +282  + #fd_xt_zo_b +( +addr +, +size +, +off +) \ + +283 (( + `__but_cڡt_p +( +size +&& (size< +BITS_PER_LONG + ? \ + +284 (( +off +)+( + `__snb +(~(((*(*) +addr +)>> (off)),( +size +)-(off)))) : \ + +285 + `fd_xt_zo_b +( +addr +, +size +, +off +))) + + ) + +287  +le +  + $t_b_rg +(* +bm +,  +i +, + +288  +n +) + +290  +d + = +i + + +n +; + +291  +i + < +d +) { + +292 + `__t_b +( +i +, +bm +); + +293 +i +++; + +295 + } +} + +297  +le +  + $__r_b_rg +(* +bm +,  +i +, + +298  +n +) + +300  +d + = +i + + +n +; + +301  +i + < +d +) { + +302 + `__r_b +( +i +, +bm +); + +303 +i +++; + +305 + } +} + +313  +__le__ +  + $ffz +( +wd +) + +315 + `__asm__ +("bsfq %1,%0" + +316 :"" ( +wd +) + +317 :"r" (~ +wd +)); + +318  +wd +; + +319 + } +} + +327  +__le__ +  + $__ffs +( +wd +) + +329 + `__asm__ +("bsfq %1,%0" + +330 :"" ( +wd +) + +331 :"rm" ( +wd +)); + +332  +wd +; + +333 + } +} + + @/usr/include/asm-x86_64/byteorder.h + +1 #ide +_X86_64_BYTEORDER_H + + +2  + #_X86_64_BYTEORDER_H + + + ) + +4  + ~ + + @/usr/include/asm-x86_64/semaphore.h + +1 #ide +_X86_64_SEMAPHORE_H + + +2  + #_X86_64_SEMAPHORE_H + + + ) + +4  + ~ + + @/usr/include/asm/cache.h + +5 #ide +__i386STUB__CACHE_H__ + + +6  + #__i386STUB__CACHE_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/fcntl.h + +5 #ide +__i386STUB__FCNTL_H__ + + +6  + #__i386STUB__FCNTL_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/ioctl.h + +5 #ide +__i386STUB__IOCTL_H__ + + +6  + #__i386STUB__IOCTL_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/linkage.h + +5 #ide +__i386STUB__LINKAGE_H__ + + +6  + #__i386STUB__LINKAGE_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/types.h + +5 #ide +__i386STUB__TYPES_H__ + + +6  + #__i386STUB__TYPES_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/bits/confname.h + +21 #ide +_UNISTD_H + + +28 + m_PC_LINK_MAX +, + +29  + #_PC_LINK_MAX + +_PC_LINK_MAX + + + ) + +30 + m_PC_MAX_CANON +, + +31  + #_PC_MAX_CANON + +_PC_MAX_CANON + + + ) + +32 + m_PC_MAX_INPUT +, + +33  + #_PC_MAX_INPUT + +_PC_MAX_INPUT + + + ) + +34 + m_PC_NAME_MAX +, + +35  + #_PC_NAME_MAX + +_PC_NAME_MAX + + + ) + +36 + m_PC_PATH_MAX +, + +37  + #_PC_PATH_MAX + +_PC_PATH_MAX + + + ) + +38 + m_PC_PIPE_BUF +, + +39  + #_PC_PIPE_BUF + +_PC_PIPE_BUF + + + ) + +40 + m_PC_CHOWN_RESTRICTED +, + +41  + #_PC_CHOWN_RESTRICTED + +_PC_CHOWN_RESTRICTED + + + ) + +42 + m_PC_NO_TRUNC +, + +43  + #_PC_NO_TRUNC + +_PC_NO_TRUNC + + + ) + +44 + m_PC_VDISABLE +, + +45  + #_PC_VDISABLE + +_PC_VDISABLE + + + ) + +46 + m_PC_SYNC_IO +, + +47  + #_PC_SYNC_IO + +_PC_SYNC_IO + + + ) + +48 + m_PC_ASYNC_IO +, + +49  + #_PC_ASYNC_IO + +_PC_ASYNC_IO + + + ) + +50 + m_PC_PRIO_IO +, + +51  + #_PC_PRIO_IO + +_PC_PRIO_IO + + + ) + +52 + m_PC_SOCK_MAXBUF +, + +53  + #_PC_SOCK_MAXBUF + +_PC_SOCK_MAXBUF + + + ) + +54 + m_PC_FILESIZEBITS +, + +55  + #_PC_FILESIZEBITS + +_PC_FILESIZEBITS + + + ) + +56 + m_PC_REC_INCR_XFER_SIZE +, + +57  + #_PC_REC_INCR_XFER_SIZE + +_PC_REC_INCR_XFER_SIZE + + + ) + +58 + m_PC_REC_MAX_XFER_SIZE +, + +59  + #_PC_REC_MAX_XFER_SIZE + +_PC_REC_MAX_XFER_SIZE + + + ) + +60 + m_PC_REC_MIN_XFER_SIZE +, + +61  + #_PC_REC_MIN_XFER_SIZE + +_PC_REC_MIN_XFER_SIZE + + + ) + +62 + m_PC_REC_XFER_ALIGN +, + +63  + #_PC_REC_XFER_ALIGN + +_PC_REC_XFER_ALIGN + + + ) + +64 + m_PC_ALLOC_SIZE_MIN +, + +65  + #_PC_ALLOC_SIZE_MIN + +_PC_ALLOC_SIZE_MIN + + + ) + +66 + m_PC_SYMLINK_MAX +, + +67  + #_PC_SYMLINK_MAX + +_PC_SYMLINK_MAX + + + ) + +68 + m_PC_2_SYMLINKS + + +69  + #_PC_2_SYMLINKS + +_PC_2_SYMLINKS + + + ) + +75 + m_SC_ARG_MAX +, + +76  + #_SC_ARG_MAX + +_SC_ARG_MAX + + + ) + +77 + m_SC_CHILD_MAX +, + +78  + #_SC_CHILD_MAX + +_SC_CHILD_MAX + + + ) + +79 + m_SC_CLK_TCK +, + +80  + #_SC_CLK_TCK + +_SC_CLK_TCK + + + ) + +81 + m_SC_NGROUPS_MAX +, + +82  + #_SC_NGROUPS_MAX + +_SC_NGROUPS_MAX + + + ) + +83 + m_SC_OPEN_MAX +, + +84  + #_SC_OPEN_MAX + +_SC_OPEN_MAX + + + ) + +85 + m_SC_STREAM_MAX +, + +86  + #_SC_STREAM_MAX + +_SC_STREAM_MAX + + + ) + +87 + m_SC_TZNAME_MAX +, + +88  + #_SC_TZNAME_MAX + +_SC_TZNAME_MAX + + + ) + +89 + m_SC_JOB_CONTROL +, + +90  + #_SC_JOB_CONTROL + +_SC_JOB_CONTROL + + + ) + +91 + m_SC_SAVED_IDS +, + +92  + #_SC_SAVED_IDS + +_SC_SAVED_IDS + + + ) + +93 + m_SC_REALTIME_SIGNALS +, + +94  + #_SC_REALTIME_SIGNALS + +_SC_REALTIME_SIGNALS + + + ) + +95 + m_SC_PRIORITY_SCHEDULING +, + +96  + #_SC_PRIORITY_SCHEDULING + +_SC_PRIORITY_SCHEDULING + + + ) + +97 + m_SC_TIMERS +, + +98  + #_SC_TIMERS + +_SC_TIMERS + + + ) + +99 + m_SC_ASYNCHRONOUS_IO +, + +100  + #_SC_ASYNCHRONOUS_IO + +_SC_ASYNCHRONOUS_IO + + + ) + +101 + m_SC_PRIORITIZED_IO +, + +102  + #_SC_PRIORITIZED_IO + +_SC_PRIORITIZED_IO + + + ) + +103 + m_SC_SYNCHRONIZED_IO +, + +104  + #_SC_SYNCHRONIZED_IO + +_SC_SYNCHRONIZED_IO + + + ) + +105 + m_SC_FSYNC +, + +106  + #_SC_FSYNC + +_SC_FSYNC + + + ) + +107 + m_SC_MAPPED_FILES +, + +108  + #_SC_MAPPED_FILES + +_SC_MAPPED_FILES + + + ) + +109 + m_SC_MEMLOCK +, + +110  + #_SC_MEMLOCK + +_SC_MEMLOCK + + + ) + +111 + m_SC_MEMLOCK_RANGE +, + +112  + #_SC_MEMLOCK_RANGE + +_SC_MEMLOCK_RANGE + + + ) + +113 + m_SC_MEMORY_PROTECTION +, + +114  + #_SC_MEMORY_PROTECTION + +_SC_MEMORY_PROTECTION + + + ) + +115 + m_SC_MESSAGE_PASSING +, + +116  + #_SC_MESSAGE_PASSING + +_SC_MESSAGE_PASSING + + + ) + +117 + m_SC_SEMAPHORES +, + +118  + #_SC_SEMAPHORES + +_SC_SEMAPHORES + + + ) + +119 + m_SC_SHARED_MEMORY_OBJECTS +, + +120  + #_SC_SHARED_MEMORY_OBJECTS + +_SC_SHARED_MEMORY_OBJECTS + + + ) + +121 + m_SC_AIO_LISTIO_MAX +, + +122  + #_SC_AIO_LISTIO_MAX + +_SC_AIO_LISTIO_MAX + + + ) + +123 + m_SC_AIO_MAX +, + +124  + #_SC_AIO_MAX + +_SC_AIO_MAX + + + ) + +125 + m_SC_AIO_PRIO_DELTA_MAX +, + +126  + #_SC_AIO_PRIO_DELTA_MAX + +_SC_AIO_PRIO_DELTA_MAX + + + ) + +127 + m_SC_DELAYTIMER_MAX +, + +128  + #_SC_DELAYTIMER_MAX + +_SC_DELAYTIMER_MAX + + + ) + +129 + m_SC_MQ_OPEN_MAX +, + +130  + #_SC_MQ_OPEN_MAX + +_SC_MQ_OPEN_MAX + + + ) + +131 + m_SC_MQ_PRIO_MAX +, + +132  + #_SC_MQ_PRIO_MAX + +_SC_MQ_PRIO_MAX + + + ) + +133 + m_SC_VERSION +, + +134  + #_SC_VERSION + +_SC_VERSION + + + ) + +135 + m_SC_PAGESIZE +, + +136  + #_SC_PAGESIZE + +_SC_PAGESIZE + + + ) + +137  + #_SC_PAGE_SIZE + +_SC_PAGESIZE + + + ) + +138 + m_SC_RTSIG_MAX +, + +139  + #_SC_RTSIG_MAX + +_SC_RTSIG_MAX + + + ) + +140 + m_SC_SEM_NSEMS_MAX +, + +141  + #_SC_SEM_NSEMS_MAX + +_SC_SEM_NSEMS_MAX + + + ) + +142 + m_SC_SEM_VALUE_MAX +, + +143  + #_SC_SEM_VALUE_MAX + +_SC_SEM_VALUE_MAX + + + ) + +144 + m_SC_SIGQUEUE_MAX +, + +145  + #_SC_SIGQUEUE_MAX + +_SC_SIGQUEUE_MAX + + + ) + +146 + m_SC_TIMER_MAX +, + +147  + #_SC_TIMER_MAX + +_SC_TIMER_MAX + + + ) + +151 + m_SC_BC_BASE_MAX +, + +152  + #_SC_BC_BASE_MAX + +_SC_BC_BASE_MAX + + + ) + +153 + m_SC_BC_DIM_MAX +, + +154  + #_SC_BC_DIM_MAX + +_SC_BC_DIM_MAX + + + ) + +155 + m_SC_BC_SCALE_MAX +, + +156  + #_SC_BC_SCALE_MAX + +_SC_BC_SCALE_MAX + + + ) + +157 + m_SC_BC_STRING_MAX +, + +158  + #_SC_BC_STRING_MAX + +_SC_BC_STRING_MAX + + + ) + +159 + m_SC_COLL_WEIGHTS_MAX +, + +160  + #_SC_COLL_WEIGHTS_MAX + +_SC_COLL_WEIGHTS_MAX + + + ) + +161 + m_SC_EQUIV_CLASS_MAX +, + +162  + #_SC_EQUIV_CLASS_MAX + +_SC_EQUIV_CLASS_MAX + + + ) + +163 + m_SC_EXPR_NEST_MAX +, + +164  + #_SC_EXPR_NEST_MAX + +_SC_EXPR_NEST_MAX + + + ) + +165 + m_SC_LINE_MAX +, + +166  + #_SC_LINE_MAX + +_SC_LINE_MAX + + + ) + +167 + m_SC_RE_DUP_MAX +, + +168  + #_SC_RE_DUP_MAX + +_SC_RE_DUP_MAX + + + ) + +169 + m_SC_CHARCLASS_NAME_MAX +, + +170  + #_SC_CHARCLASS_NAME_MAX + +_SC_CHARCLASS_NAME_MAX + + + ) + +172 + m_SC_2_VERSION +, + +173  + #_SC_2_VERSION + +_SC_2_VERSION + + + ) + +174 + m_SC_2_C_BIND +, + +175  + #_SC_2_C_BIND + +_SC_2_C_BIND + + + ) + +176 + m_SC_2_C_DEV +, + +177  + #_SC_2_C_DEV + +_SC_2_C_DEV + + + ) + +178 + m_SC_2_FORT_DEV +, + +179  + #_SC_2_FORT_DEV + +_SC_2_FORT_DEV + + + ) + +180 + m_SC_2_FORT_RUN +, + +181  + #_SC_2_FORT_RUN + +_SC_2_FORT_RUN + + + ) + +182 + m_SC_2_SW_DEV +, + +183  + #_SC_2_SW_DEV + +_SC_2_SW_DEV + + + ) + +184 + m_SC_2_LOCALEDEF +, + +185  + #_SC_2_LOCALEDEF + +_SC_2_LOCALEDEF + + + ) + +187 + m_SC_PII +, + +188  + #_SC_PII + +_SC_PII + + + ) + +189 + m_SC_PII_XTI +, + +190  + #_SC_PII_XTI + +_SC_PII_XTI + + + ) + +191 + m_SC_PII_SOCKET +, + +192  + #_SC_PII_SOCKET + +_SC_PII_SOCKET + + + ) + +193 + m_SC_PII_INTERNET +, + +194  + #_SC_PII_INTERNET + +_SC_PII_INTERNET + + + ) + +195 + m_SC_PII_OSI +, + +196  + #_SC_PII_OSI + +_SC_PII_OSI + + + ) + +197 + m_SC_POLL +, + +198  + #_SC_POLL + +_SC_POLL + + + ) + +199 + m_SC_SELECT +, + +200  + #_SC_SELECT + +_SC_SELECT + + + ) + +201 + m_SC_UIO_MAXIOV +, + +202  + #_SC_UIO_MAXIOV + +_SC_UIO_MAXIOV + + + ) + +203 + m_SC_IOV_MAX + = +_SC_UIO_MAXIOV +, + +204  + #_SC_IOV_MAX + +_SC_IOV_MAX + + + ) + +205 + m_SC_PII_INTERNET_STREAM +, + +206  + #_SC_PII_INTERNET_STREAM + +_SC_PII_INTERNET_STREAM + + + ) + +207 + m_SC_PII_INTERNET_DGRAM +, + +208  + #_SC_PII_INTERNET_DGRAM + +_SC_PII_INTERNET_DGRAM + + + ) + +209 + m_SC_PII_OSI_COTS +, + +210  + #_SC_PII_OSI_COTS + +_SC_PII_OSI_COTS + + + ) + +211 + m_SC_PII_OSI_CLTS +, + +212  + #_SC_PII_OSI_CLTS + +_SC_PII_OSI_CLTS + + + ) + +213 + m_SC_PII_OSI_M +, + +214  + #_SC_PII_OSI_M + +_SC_PII_OSI_M + + + ) + +215 + m_SC_T_IOV_MAX +, + +216  + #_SC_T_IOV_MAX + +_SC_T_IOV_MAX + + + ) + +219 + m_SC_THREADS +, + +220  + #_SC_THREADS + +_SC_THREADS + + + ) + +221 + m_SC_THREAD_SAFE_FUNCTIONS +, + +222  + #_SC_THREAD_SAFE_FUNCTIONS + +_SC_THREAD_SAFE_FUNCTIONS + + + ) + +223 + m_SC_GETGR_R_SIZE_MAX +, + +224  + #_SC_GETGR_R_SIZE_MAX + +_SC_GETGR_R_SIZE_MAX + + + ) + +225 + m_SC_GETPW_R_SIZE_MAX +, + +226  + #_SC_GETPW_R_SIZE_MAX + +_SC_GETPW_R_SIZE_MAX + + + ) + +227 + m_SC_LOGIN_NAME_MAX +, + +228  + #_SC_LOGIN_NAME_MAX + +_SC_LOGIN_NAME_MAX + + + ) + +229 + m_SC_TTY_NAME_MAX +, + +230  + #_SC_TTY_NAME_MAX + +_SC_TTY_NAME_MAX + + + ) + +231 + m_SC_THREAD_DESTRUCTOR_ITERATIONS +, + +232  + #_SC_THREAD_DESTRUCTOR_ITERATIONS + +_SC_THREAD_DESTRUCTOR_ITERATIONS + + + ) + +233 + m_SC_THREAD_KEYS_MAX +, + +234  + #_SC_THREAD_KEYS_MAX + +_SC_THREAD_KEYS_MAX + + + ) + +235 + m_SC_THREAD_STACK_MIN +, + +236  + #_SC_THREAD_STACK_MIN + +_SC_THREAD_STACK_MIN + + + ) + +237 + m_SC_THREAD_THREADS_MAX +, + +238  + #_SC_THREAD_THREADS_MAX + +_SC_THREAD_THREADS_MAX + + + ) + +239 + m_SC_THREAD_ATTR_STACKADDR +, + +240  + #_SC_THREAD_ATTR_STACKADDR + +_SC_THREAD_ATTR_STACKADDR + + + ) + +241 + m_SC_THREAD_ATTR_STACKSIZE +, + +242  + #_SC_THREAD_ATTR_STACKSIZE + +_SC_THREAD_ATTR_STACKSIZE + + + ) + +243 + m_SC_THREAD_PRIORITY_SCHEDULING +, + +244  + #_SC_THREAD_PRIORITY_SCHEDULING + +_SC_THREAD_PRIORITY_SCHEDULING + + + ) + +245 + m_SC_THREAD_PRIO_INHERIT +, + +246  + #_SC_THREAD_PRIO_INHERIT + +_SC_THREAD_PRIO_INHERIT + + + ) + +247 + m_SC_THREAD_PRIO_PROTECT +, + +248  + #_SC_THREAD_PRIO_PROTECT + +_SC_THREAD_PRIO_PROTECT + + + ) + +249 + m_SC_THREAD_PROCESS_SHARED +, + +250  + #_SC_THREAD_PROCESS_SHARED + +_SC_THREAD_PROCESS_SHARED + + + ) + +252 + m_SC_NPROCESSORS_CONF +, + +253  + #_SC_NPROCESSORS_CONF + +_SC_NPROCESSORS_CONF + + + ) + +254 + m_SC_NPROCESSORS_ONLN +, + +255  + #_SC_NPROCESSORS_ONLN + +_SC_NPROCESSORS_ONLN + + + ) + +256 + m_SC_PHYS_PAGES +, + +257  + #_SC_PHYS_PAGES + +_SC_PHYS_PAGES + + + ) + +258 + m_SC_AVPHYS_PAGES +, + +259  + #_SC_AVPHYS_PAGES + +_SC_AVPHYS_PAGES + + + ) + +260 + m_SC_ATEXIT_MAX +, + +261  + #_SC_ATEXIT_MAX + +_SC_ATEXIT_MAX + + + ) + +262 + m_SC_PASS_MAX +, + +263  + #_SC_PASS_MAX + +_SC_PASS_MAX + + + ) + +265 + m_SC_XOPEN_VERSION +, + +266  + #_SC_XOPEN_VERSION + +_SC_XOPEN_VERSION + + + ) + +267 + m_SC_XOPEN_XCU_VERSION +, + +268  + #_SC_XOPEN_XCU_VERSION + +_SC_XOPEN_XCU_VERSION + + + ) + +269 + m_SC_XOPEN_UNIX +, + +270  + #_SC_XOPEN_UNIX + +_SC_XOPEN_UNIX + + + ) + +271 + m_SC_XOPEN_CRYPT +, + +272  + #_SC_XOPEN_CRYPT + +_SC_XOPEN_CRYPT + + + ) + +273 + m_SC_XOPEN_ENH_I18N +, + +274  + #_SC_XOPEN_ENH_I18N + +_SC_XOPEN_ENH_I18N + + + ) + +275 + m_SC_XOPEN_SHM +, + +276  + #_SC_XOPEN_SHM + +_SC_XOPEN_SHM + + + ) + +278 + m_SC_2_CHAR_TERM +, + +279  + #_SC_2_CHAR_TERM + +_SC_2_CHAR_TERM + + + ) + +280 + m_SC_2_C_VERSION +, + +281  + #_SC_2_C_VERSION + +_SC_2_C_VERSION + + + ) + +282 + m_SC_2_UPE +, + +283  + #_SC_2_UPE + +_SC_2_UPE + + + ) + +285 + m_SC_XOPEN_XPG2 +, + +286  + #_SC_XOPEN_XPG2 + +_SC_XOPEN_XPG2 + + + ) + +287 + m_SC_XOPEN_XPG3 +, + +288  + #_SC_XOPEN_XPG3 + +_SC_XOPEN_XPG3 + + + ) + +289 + m_SC_XOPEN_XPG4 +, + +290  + #_SC_XOPEN_XPG4 + +_SC_XOPEN_XPG4 + + + ) + +292 + m_SC_CHAR_BIT +, + +293  + #_SC_CHAR_BIT + +_SC_CHAR_BIT + + + ) + +294 + m_SC_CHAR_MAX +, + +295  + #_SC_CHAR_MAX + +_SC_CHAR_MAX + + + ) + +296 + m_SC_CHAR_MIN +, + +297  + #_SC_CHAR_MIN + +_SC_CHAR_MIN + + + ) + +298 + m_SC_INT_MAX +, + +299  + #_SC_INT_MAX + +_SC_INT_MAX + + + ) + +300 + m_SC_INT_MIN +, + +301  + #_SC_INT_MIN + +_SC_INT_MIN + + + ) + +302 + m_SC_LONG_BIT +, + +303  + #_SC_LONG_BIT + +_SC_LONG_BIT + + + ) + +304 + m_SC_WORD_BIT +, + +305  + #_SC_WORD_BIT + +_SC_WORD_BIT + + + ) + +306 + m_SC_MB_LEN_MAX +, + +307  + #_SC_MB_LEN_MAX + +_SC_MB_LEN_MAX + + + ) + +308 + m_SC_NZERO +, + +309  + #_SC_NZERO + +_SC_NZERO + + + ) + +310 + m_SC_SSIZE_MAX +, + +311  + #_SC_SSIZE_MAX + +_SC_SSIZE_MAX + + + ) + +312 + m_SC_SCHAR_MAX +, + +313  + #_SC_SCHAR_MAX + +_SC_SCHAR_MAX + + + ) + +314 + m_SC_SCHAR_MIN +, + +315  + #_SC_SCHAR_MIN + +_SC_SCHAR_MIN + + + ) + +316 + m_SC_SHRT_MAX +, + +317  + #_SC_SHRT_MAX + +_SC_SHRT_MAX + + + ) + +318 + m_SC_SHRT_MIN +, + +319  + #_SC_SHRT_MIN + +_SC_SHRT_MIN + + + ) + +320 + m_SC_UCHAR_MAX +, + +321  + #_SC_UCHAR_MAX + +_SC_UCHAR_MAX + + + ) + +322 + m_SC_UINT_MAX +, + +323  + #_SC_UINT_MAX + +_SC_UINT_MAX + + + ) + +324 + m_SC_ULONG_MAX +, + +325  + #_SC_ULONG_MAX + +_SC_ULONG_MAX + + + ) + +326 + m_SC_USHRT_MAX +, + +327  + #_SC_USHRT_MAX + +_SC_USHRT_MAX + + + ) + +329 + m_SC_NL_ARGMAX +, + +330  + #_SC_NL_ARGMAX + +_SC_NL_ARGMAX + + + ) + +331 + m_SC_NL_LANGMAX +, + +332  + #_SC_NL_LANGMAX + +_SC_NL_LANGMAX + + + ) + +333 + m_SC_NL_MSGMAX +, + +334  + #_SC_NL_MSGMAX + +_SC_NL_MSGMAX + + + ) + +335 + m_SC_NL_NMAX +, + +336  + #_SC_NL_NMAX + +_SC_NL_NMAX + + + ) + +337 + m_SC_NL_SETMAX +, + +338  + #_SC_NL_SETMAX + +_SC_NL_SETMAX + + + ) + +339 + m_SC_NL_TEXTMAX +, + +340  + #_SC_NL_TEXTMAX + +_SC_NL_TEXTMAX + + + ) + +342 + m_SC_XBS5_ILP32_OFF32 +, + +343  + #_SC_XBS5_ILP32_OFF32 + +_SC_XBS5_ILP32_OFF32 + + + ) + +344 + m_SC_XBS5_ILP32_OFFBIG +, + +345  + #_SC_XBS5_ILP32_OFFBIG + +_SC_XBS5_ILP32_OFFBIG + + + ) + +346 + m_SC_XBS5_LP64_OFF64 +, + +347  + #_SC_XBS5_LP64_OFF64 + +_SC_XBS5_LP64_OFF64 + + + ) + +348 + m_SC_XBS5_LPBIG_OFFBIG +, + +349  + #_SC_XBS5_LPBIG_OFFBIG + +_SC_XBS5_LPBIG_OFFBIG + + + ) + +351 + m_SC_XOPEN_LEGACY +, + +352  + #_SC_XOPEN_LEGACY + +_SC_XOPEN_LEGACY + + + ) + +353 + m_SC_XOPEN_REALTIME +, + +354  + #_SC_XOPEN_REALTIME + +_SC_XOPEN_REALTIME + + + ) + +355 + m_SC_XOPEN_REALTIME_THREADS +, + +356  + #_SC_XOPEN_REALTIME_THREADS + +_SC_XOPEN_REALTIME_THREADS + + + ) + +358 + m_SC_ADVISORY_INFO +, + +359  + #_SC_ADVISORY_INFO + +_SC_ADVISORY_INFO + + + ) + +360 + m_SC_BARRIERS +, + +361  + #_SC_BARRIERS + +_SC_BARRIERS + + + ) + +362 + m_SC_BASE +, + +363  + #_SC_BASE + +_SC_BASE + + + ) + +364 + m_SC_C_LANG_SUPPORT +, + +365  + #_SC_C_LANG_SUPPORT + +_SC_C_LANG_SUPPORT + + + ) + +366 + m_SC_C_LANG_SUPPORT_R +, + +367  + #_SC_C_LANG_SUPPORT_R + +_SC_C_LANG_SUPPORT_R + + + ) + +368 + m_SC_CLOCK_SELECTION +, + +369  + #_SC_CLOCK_SELECTION + +_SC_CLOCK_SELECTION + + + ) + +370 + m_SC_CPUTIME +, + +371  + #_SC_CPUTIME + +_SC_CPUTIME + + + ) + +372 + m_SC_THREAD_CPUTIME +, + +373  + #_SC_THREAD_CPUTIME + +_SC_THREAD_CPUTIME + + + ) + +374 + m_SC_DEVICE_IO +, + +375  + #_SC_DEVICE_IO + +_SC_DEVICE_IO + + + ) + +376 + m_SC_DEVICE_SPECIFIC +, + +377  + #_SC_DEVICE_SPECIFIC + +_SC_DEVICE_SPECIFIC + + + ) + +378 + m_SC_DEVICE_SPECIFIC_R +, + +379  + #_SC_DEVICE_SPECIFIC_R + +_SC_DEVICE_SPECIFIC_R + + + ) + +380 + m_SC_FD_MGMT +, + +381  + #_SC_FD_MGMT + +_SC_FD_MGMT + + + ) + +382 + m_SC_FIFO +, + +383  + #_SC_FIFO + +_SC_FIFO + + + ) + +384 + m_SC_PIPE +, + +385  + #_SC_PIPE + +_SC_PIPE + + + ) + +386 + m_SC_FILE_ATTRIBUTES +, + +387  + #_SC_FILE_ATTRIBUTES + +_SC_FILE_ATTRIBUTES + + + ) + +388 + m_SC_FILE_LOCKING +, + +389  + #_SC_FILE_LOCKING + +_SC_FILE_LOCKING + + + ) + +390 + m_SC_FILE_SYSTEM +, + +391  + #_SC_FILE_SYSTEM + +_SC_FILE_SYSTEM + + + ) + +392 + m_SC_MONOTONIC_CLOCK +, + +393  + #_SC_MONOTONIC_CLOCK + +_SC_MONOTONIC_CLOCK + + + ) + +394 + m_SC_MULTI_PROCESS +, + +395  + #_SC_MULTI_PROCESS + +_SC_MULTI_PROCESS + + + ) + +396 + m_SC_SINGLE_PROCESS +, + +397  + #_SC_SINGLE_PROCESS + +_SC_SINGLE_PROCESS + + + ) + +398 + m_SC_NETWORKING +, + +399  + #_SC_NETWORKING + +_SC_NETWORKING + + + ) + +400 + m_SC_READER_WRITER_LOCKS +, + +401  + #_SC_READER_WRITER_LOCKS + +_SC_READER_WRITER_LOCKS + + + ) + +402 + m_SC_SPIN_LOCKS +, + +403  + #_SC_SPIN_LOCKS + +_SC_SPIN_LOCKS + + + ) + +404 + m_SC_REGEXP +, + +405  + #_SC_REGEXP + +_SC_REGEXP + + + ) + +406 + m_SC_REGEX_VERSION +, + +407  + #_SC_REGEX_VERSION + +_SC_REGEX_VERSION + + + ) + +408 + m_SC_SHELL +, + +409  + #_SC_SHELL + +_SC_SHELL + + + ) + +410 + m_SC_SIGNALS +, + +411  + #_SC_SIGNALS + +_SC_SIGNALS + + + ) + +412 + m_SC_SPAWN +, + +413  + #_SC_SPAWN + +_SC_SPAWN + + + ) + +414 + m_SC_SPORADIC_SERVER +, + +415  + #_SC_SPORADIC_SERVER + +_SC_SPORADIC_SERVER + + + ) + +416 + m_SC_THREAD_SPORADIC_SERVER +, + +417  + #_SC_THREAD_SPORADIC_SERVER + +_SC_THREAD_SPORADIC_SERVER + + + ) + +418 + m_SC_SYSTEM_DATABASE +, + +419  + #_SC_SYSTEM_DATABASE + +_SC_SYSTEM_DATABASE + + + ) + +420 + m_SC_SYSTEM_DATABASE_R +, + +421  + #_SC_SYSTEM_DATABASE_R + +_SC_SYSTEM_DATABASE_R + + + ) + +422 + m_SC_TIMEOUTS +, + +423  + #_SC_TIMEOUTS + +_SC_TIMEOUTS + + + ) + +424 + m_SC_TYPED_MEMORY_OBJECTS +, + +425  + #_SC_TYPED_MEMORY_OBJECTS + +_SC_TYPED_MEMORY_OBJECTS + + + ) + +426 + m_SC_USER_GROUPS +, + +427  + #_SC_USER_GROUPS + +_SC_USER_GROUPS + + + ) + +428 + m_SC_USER_GROUPS_R +, + +429  + #_SC_USER_GROUPS_R + +_SC_USER_GROUPS_R + + + ) + +430 + m_SC_2_PBS +, + +431  + #_SC_2_PBS + +_SC_2_PBS + + + ) + +432 + m_SC_2_PBS_ACCOUNTING +, + +433  + #_SC_2_PBS_ACCOUNTING + +_SC_2_PBS_ACCOUNTING + + + ) + +434 + m_SC_2_PBS_LOCATE +, + +435  + #_SC_2_PBS_LOCATE + +_SC_2_PBS_LOCATE + + + ) + +436 + m_SC_2_PBS_MESSAGE +, + +437  + #_SC_2_PBS_MESSAGE + +_SC_2_PBS_MESSAGE + + + ) + +438 + m_SC_2_PBS_TRACK +, + +439  + #_SC_2_PBS_TRACK + +_SC_2_PBS_TRACK + + + ) + +440 + m_SC_SYMLOOP_MAX +, + +441  + #_SC_SYMLOOP_MAX + +_SC_SYMLOOP_MAX + + + ) + +442 + m_SC_STREAMS +, + +443  + #_SC_STREAMS + +_SC_STREAMS + + + ) + +444 + m_SC_2_PBS_CHECKPOINT +, + +445  + #_SC_2_PBS_CHECKPOINT + +_SC_2_PBS_CHECKPOINT + + + ) + +447 + m_SC_V6_ILP32_OFF32 +, + +448  + #_SC_V6_ILP32_OFF32 + +_SC_V6_ILP32_OFF32 + + + ) + +449 + m_SC_V6_ILP32_OFFBIG +, + +450  + #_SC_V6_ILP32_OFFBIG + +_SC_V6_ILP32_OFFBIG + + + ) + +451 + m_SC_V6_LP64_OFF64 +, + +452  + #_SC_V6_LP64_OFF64 + +_SC_V6_LP64_OFF64 + + + ) + +453 + m_SC_V6_LPBIG_OFFBIG +, + +454  + #_SC_V6_LPBIG_OFFBIG + +_SC_V6_LPBIG_OFFBIG + + + ) + +456 + m_SC_HOST_NAME_MAX +, + +457  + #_SC_HOST_NAME_MAX + +_SC_HOST_NAME_MAX + + + ) + +458 + m_SC_TRACE +, + +459  + #_SC_TRACE + +_SC_TRACE + + + ) + +460 + m_SC_TRACE_EVENT_FILTER +, + +461  + #_SC_TRACE_EVENT_FILTER + +_SC_TRACE_EVENT_FILTER + + + ) + +462 + m_SC_TRACE_INHERIT +, + +463  + #_SC_TRACE_INHERIT + +_SC_TRACE_INHERIT + + + ) + +464 + m_SC_TRACE_LOG +, + +465  + #_SC_TRACE_LOG + +_SC_TRACE_LOG + + + ) + +467 + m_SC_LEVEL1_ICACHE_SIZE +, + +468  + #_SC_LEVEL1_ICACHE_SIZE + +_SC_LEVEL1_ICACHE_SIZE + + + ) + +469 + m_SC_LEVEL1_ICACHE_ASSOC +, + +470  + #_SC_LEVEL1_ICACHE_ASSOC + +_SC_LEVEL1_ICACHE_ASSOC + + + ) + +471 + m_SC_LEVEL1_ICACHE_LINESIZE +, + +472  + #_SC_LEVEL1_ICACHE_LINESIZE + +_SC_LEVEL1_ICACHE_LINESIZE + + + ) + +473 + m_SC_LEVEL1_DCACHE_SIZE +, + +474  + #_SC_LEVEL1_DCACHE_SIZE + +_SC_LEVEL1_DCACHE_SIZE + + + ) + +475 + m_SC_LEVEL1_DCACHE_ASSOC +, + +476  + #_SC_LEVEL1_DCACHE_ASSOC + +_SC_LEVEL1_DCACHE_ASSOC + + + ) + +477 + m_SC_LEVEL1_DCACHE_LINESIZE +, + +478  + #_SC_LEVEL1_DCACHE_LINESIZE + +_SC_LEVEL1_DCACHE_LINESIZE + + + ) + +479 + m_SC_LEVEL2_CACHE_SIZE +, + +480  + #_SC_LEVEL2_CACHE_SIZE + +_SC_LEVEL2_CACHE_SIZE + + + ) + +481 + m_SC_LEVEL2_CACHE_ASSOC +, + +482  + #_SC_LEVEL2_CACHE_ASSOC + +_SC_LEVEL2_CACHE_ASSOC + + + ) + +483 + m_SC_LEVEL2_CACHE_LINESIZE +, + +484  + #_SC_LEVEL2_CACHE_LINESIZE + +_SC_LEVEL2_CACHE_LINESIZE + + + ) + +485 + m_SC_LEVEL3_CACHE_SIZE +, + +486  + #_SC_LEVEL3_CACHE_SIZE + +_SC_LEVEL3_CACHE_SIZE + + + ) + +487 + m_SC_LEVEL3_CACHE_ASSOC +, + +488  + #_SC_LEVEL3_CACHE_ASSOC + +_SC_LEVEL3_CACHE_ASSOC + + + ) + +489 + m_SC_LEVEL3_CACHE_LINESIZE +, + +490  + #_SC_LEVEL3_CACHE_LINESIZE + +_SC_LEVEL3_CACHE_LINESIZE + + + ) + +491 + m_SC_LEVEL4_CACHE_SIZE +, + +492  + #_SC_LEVEL4_CACHE_SIZE + +_SC_LEVEL4_CACHE_SIZE + + + ) + +493 + m_SC_LEVEL4_CACHE_ASSOC +, + +494  + #_SC_LEVEL4_CACHE_ASSOC + +_SC_LEVEL4_CACHE_ASSOC + + + ) + +495 + m_SC_LEVEL4_CACHE_LINESIZE +, + +496  + #_SC_LEVEL4_CACHE_LINESIZE + +_SC_LEVEL4_CACHE_LINESIZE + + + ) + +499 + m_SC_IPV6 + = +_SC_LEVEL1_ICACHE_SIZE + + 50, + +500  + #_SC_IPV6 + +_SC_IPV6 + + + ) + +501 + m_SC_RAW_SOCKETS + + +502  + #_SC_RAW_SOCKETS + +_SC_RAW_SOCKETS + + + ) + +508 + m_CS_PATH +, + +509  + #_CS_PATH + +_CS_PATH + + + ) + +511 + m_CS_V6_WIDTH_RESTRICTED_ENVS +, + +512  + #_CS_V6_WIDTH_RESTRICTED_ENVS + +_CS_V6_WIDTH_RESTRICTED_ENVS + + + ) + +514 + m_CS_GNU_LIBC_VERSION +, + +515  + #_CS_GNU_LIBC_VERSION + +_CS_GNU_LIBC_VERSION + + + ) + +516 + m_CS_GNU_LIBPTHREAD_VERSION +, + +517  + #_CS_GNU_LIBPTHREAD_VERSION + +_CS_GNU_LIBPTHREAD_VERSION + + + ) + +519 + m_CS_LFS_CFLAGS + = 1000, + +520  + #_CS_LFS_CFLAGS + +_CS_LFS_CFLAGS + + + ) + +521 + m_CS_LFS_LDFLAGS +, + +522  + #_CS_LFS_LDFLAGS + +_CS_LFS_LDFLAGS + + + ) + +523 + m_CS_LFS_LIBS +, + +524  + #_CS_LFS_LIBS + +_CS_LFS_LIBS + + + ) + +525 + m_CS_LFS_LINTFLAGS +, + +526  + #_CS_LFS_LINTFLAGS + +_CS_LFS_LINTFLAGS + + + ) + +527 + m_CS_LFS64_CFLAGS +, + +528  + #_CS_LFS64_CFLAGS + +_CS_LFS64_CFLAGS + + + ) + +529 + m_CS_LFS64_LDFLAGS +, + +530  + #_CS_LFS64_LDFLAGS + +_CS_LFS64_LDFLAGS + + + ) + +531 + m_CS_LFS64_LIBS +, + +532  + #_CS_LFS64_LIBS + +_CS_LFS64_LIBS + + + ) + +533 + m_CS_LFS64_LINTFLAGS +, + +534  + #_CS_LFS64_LINTFLAGS + +_CS_LFS64_LINTFLAGS + + + ) + +536 + m_CS_XBS5_ILP32_OFF32_CFLAGS + = 1100, + +537  + #_CS_XBS5_ILP32_OFF32_CFLAGS + +_CS_XBS5_ILP32_OFF32_CFLAGS + + + ) + +538 + m_CS_XBS5_ILP32_OFF32_LDFLAGS +, + +539  + #_CS_XBS5_ILP32_OFF32_LDFLAGS + +_CS_XBS5_ILP32_OFF32_LDFLAGS + + + ) + +540 + m_CS_XBS5_ILP32_OFF32_LIBS +, + +541  + #_CS_XBS5_ILP32_OFF32_LIBS + +_CS_XBS5_ILP32_OFF32_LIBS + + + ) + +542 + m_CS_XBS5_ILP32_OFF32_LINTFLAGS +, + +543  + #_CS_XBS5_ILP32_OFF32_LINTFLAGS + +_CS_XBS5_ILP32_OFF32_LINTFLAGS + + + ) + +544 + m_CS_XBS5_ILP32_OFFBIG_CFLAGS +, + +545  + #_CS_XBS5_ILP32_OFFBIG_CFLAGS + +_CS_XBS5_ILP32_OFFBIG_CFLAGS + + + ) + +546 + m_CS_XBS5_ILP32_OFFBIG_LDFLAGS +, + +547  + #_CS_XBS5_ILP32_OFFBIG_LDFLAGS + +_CS_XBS5_ILP32_OFFBIG_LDFLAGS + + + ) + +548 + m_CS_XBS5_ILP32_OFFBIG_LIBS +, + +549  + #_CS_XBS5_ILP32_OFFBIG_LIBS + +_CS_XBS5_ILP32_OFFBIG_LIBS + + + ) + +550 + m_CS_XBS5_ILP32_OFFBIG_LINTFLAGS +, + +551  + #_CS_XBS5_ILP32_OFFBIG_LINTFLAGS + +_CS_XBS5_ILP32_OFFBIG_LINTFLAGS + + + ) + +552 + m_CS_XBS5_LP64_OFF64_CFLAGS +, + +553  + #_CS_XBS5_LP64_OFF64_CFLAGS + +_CS_XBS5_LP64_OFF64_CFLAGS + + + ) + +554 + m_CS_XBS5_LP64_OFF64_LDFLAGS +, + +555  + #_CS_XBS5_LP64_OFF64_LDFLAGS + +_CS_XBS5_LP64_OFF64_LDFLAGS + + + ) + +556 + m_CS_XBS5_LP64_OFF64_LIBS +, + +557  + #_CS_XBS5_LP64_OFF64_LIBS + +_CS_XBS5_LP64_OFF64_LIBS + + + ) + +558 + m_CS_XBS5_LP64_OFF64_LINTFLAGS +, + +559  + #_CS_XBS5_LP64_OFF64_LINTFLAGS + +_CS_XBS5_LP64_OFF64_LINTFLAGS + + + ) + +560 + m_CS_XBS5_LPBIG_OFFBIG_CFLAGS +, + +561  + #_CS_XBS5_LPBIG_OFFBIG_CFLAGS + +_CS_XBS5_LPBIG_OFFBIG_CFLAGS + + + ) + +562 + m_CS_XBS5_LPBIG_OFFBIG_LDFLAGS +, + +563  + #_CS_XBS5_LPBIG_OFFBIG_LDFLAGS + +_CS_XBS5_LPBIG_OFFBIG_LDFLAGS + + + ) + +564 + m_CS_XBS5_LPBIG_OFFBIG_LIBS +, + +565  + #_CS_XBS5_LPBIG_OFFBIG_LIBS + +_CS_XBS5_LPBIG_OFFBIG_LIBS + + + ) + +566 + m_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS +, + +567  + #_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS + +_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS + + + ) + +569 + m_CS_POSIX_V6_ILP32_OFF32_CFLAGS +, + +570  + #_CS_POSIX_V6_ILP32_OFF32_CFLAGS + +_CS_POSIX_V6_ILP32_OFF32_CFLAGS + + + ) + +571 + m_CS_POSIX_V6_ILP32_OFF32_LDFLAGS +, + +572  + #_CS_POSIX_V6_ILP32_OFF32_LDFLAGS + +_CS_POSIX_V6_ILP32_OFF32_LDFLAGS + + + ) + +573 + m_CS_POSIX_V6_ILP32_OFF32_LIBS +, + +574  + #_CS_POSIX_V6_ILP32_OFF32_LIBS + +_CS_POSIX_V6_ILP32_OFF32_LIBS + + + ) + +575 + m_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS +, + +576  + #_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS + +_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS + + + ) + +577 + m_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS +, + +578  + #_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS + +_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS + + + ) + +579 + m_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS +, + +580  + #_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS + +_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS + + + ) + +581 + m_CS_POSIX_V6_ILP32_OFFBIG_LIBS +, + +582  + #_CS_POSIX_V6_ILP32_OFFBIG_LIBS + +_CS_POSIX_V6_ILP32_OFFBIG_LIBS + + + ) + +583 + m_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS +, + +584  + #_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS + +_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS + + + ) + +585 + m_CS_POSIX_V6_LP64_OFF64_CFLAGS +, + +586  + #_CS_POSIX_V6_LP64_OFF64_CFLAGS + +_CS_POSIX_V6_LP64_OFF64_CFLAGS + + + ) + +587 + m_CS_POSIX_V6_LP64_OFF64_LDFLAGS +, + +588  + #_CS_POSIX_V6_LP64_OFF64_LDFLAGS + +_CS_POSIX_V6_LP64_OFF64_LDFLAGS + + + ) + +589 + m_CS_POSIX_V6_LP64_OFF64_LIBS +, + +590  + #_CS_POSIX_V6_LP64_OFF64_LIBS + +_CS_POSIX_V6_LP64_OFF64_LIBS + + + ) + +591 + m_CS_POSIX_V6_LP64_OFF64_LINTFLAGS +, + +592  + #_CS_POSIX_V6_LP64_OFF64_LINTFLAGS + +_CS_POSIX_V6_LP64_OFF64_LINTFLAGS + + + ) + +593 + m_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS +, + +594  + #_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS + +_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS + + + ) + +595 + m_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS +, + +596  + #_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS + +_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS + + + ) + +597 + m_CS_POSIX_V6_LPBIG_OFFBIG_LIBS +, + +598  + #_CS_POSIX_V6_LPBIG_OFFBIG_LIBS + +_CS_POSIX_V6_LPBIG_OFFBIG_LIBS + + + ) + +599 + m_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS + + +600  + #_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS + +_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS + + + ) + + @/usr/include/bits/dirent.h + +19 #ide +_DIRENT_H + + +23  + sdt + + +25 #ide +__USE_FILE_OFFSET64 + + +26 +__o_t + + md_o +; + +27 +__off_t + + md_off +; + +29 +__o64_t + + md_o +; + +30 +__off64_t + + md_off +; + +32  + md_ +; + +33  + md_ty +; + +34  + md_me +[256]; + +37 #ifde +__USE_LARGEFILE64 + + +38  + sdt64 + + +40 +__o64_t + + md_o +; + +41 +__off64_t + + md_off +; + +42  + md_ +; + +43  + md_ty +; + +44  + md_me +[256]; + +48  + #d_fo + +d_o + + + ) + +50 #unde +_DIRENT_HAVE_D_NAMLEN + + +51  + #_DIRENT_HAVE_D_RECLEN + + + ) + +52  + #_DIRENT_HAVE_D_OFF + + + ) + +53  + #_DIRENT_HAVE_D_TYPE + + + ) + + @/usr/include/bits/environments.h + +19 #ide +_UNISTD_H + + +41  + #_POSIX_V6_ILP32_OFF32 + 1 + + ) + +42  + #_POSIX_V6_ILP32_OFFBIG + 1 + + ) + +43  + #_XBS5_ILP32_OFF32 + 1 + + ) + +44  + #_XBS5_ILP32_OFFBIG + 1 + + ) + +57  + #__ILP32_OFF32_CFLAGS + "-m32" + + ) + +58  + #__ILP32_OFFBIG_CFLAGS + "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64" + + ) + +59  + #__ILP32_OFF32_LDFLAGS + "-m32" + + ) + +60  + #__ILP32_OFFBIG_LDFLAGS + "-m32" + + ) + +61  + #__LP64_OFF64_CFLAGS + "-m64" + + ) + +62  + #__LP64_OFF64_LDFLAGS + "-m64" + + ) + + @/usr/include/bits/errno.h + +20 #ifde +_ERRNO_H + + +22 #unde +EDOM + + +23 #unde +EILSEQ + + +24 #unde +ERANGE + + +25  + ~ + +28  + #ENOTSUP + +EOPNOTSUPP + + + ) + +32 #ide +ECANCELED + + +33  + #ECANCELED + 125 + + ) + +36 #ide +__ASSEMBLER__ + + +38 * + $__o_loti + ( +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +40 #i! +defed + +_LIBC + || defed +_LIBC_REENTRANT + + +42  + #o + (* + `__o_loti + ()) + + ) + +47 #i! +defed + +_ERRNO_H + && defed +__ed_Emh + + +51  + #EDOM + 33 + + ) + +52  + #EILSEQ + 84 + + ) + +53  + #ERANGE + 34 + + ) + + @/usr/include/bits/fcntl.h + +21 #idef +_FCNTL_H + + +26  + ~ + +30  + #O_ACCMODE + 0003 + + ) + +31  + #O_RDONLY + 00 + + ) + +32  + #O_WRONLY + 01 + + ) + +33  + #O_RDWR + 02 + + ) + +34  + #O_CREAT + 0100 + + ) + +35  + #O_EXCL + 0200 + + ) + +36  + #O_NOCTTY + 0400 + + ) + +37  + #O_TRUNC + 01000 + + ) + +38  + #O_APPEND + 02000 + + ) + +39  + #O_NONBLOCK + 04000 + + ) + +40  + #O_NDELAY + +O_NONBLOCK + + + ) + +41  + #O_SYNC + 010000 + + ) + +42  + #O_FSYNC + +O_SYNC + + + ) + +43  + #O_ASYNC + 020000 + + ) + +45 #ifde +__USE_GNU + + +46  + #O_DIRECT + 040000 + + ) + +47  + #O_DIRECTORY + 0200000 + + ) + +48  + #O_NOFOLLOW + 0400000 + + ) + +49  + #O_NOATIME + 01000000 + + ) + +55 #i +defed + +__USE_POSIX199309 + || defed +__USE_UNIX98 + + +56  + #O_DSYNC + +O_SYNC + + + ) + +57  + #O_RSYNC + +O_SYNC + + + ) + +60 #ifde +__USE_LARGEFILE64 + + +61  + #O_LARGEFILE + 0100000 + + ) + +65  + #F_DUPFD + 0 + + ) + +66  + #F_GETFD + 1 + + ) + +67  + #F_SETFD + 2 + + ) + +68  + #F_GETFL + 3 + + ) + +69  + #F_SETFL + 4 + + ) + +70 #ide +__USE_FILE_OFFSET64 + + +71  + #F_GETLK + 5 + + ) + +72  + #F_SETLK + 6 + + ) + +73  + #F_SETLKW + 7 + + ) + +75  + #F_GETLK + +F_GETLK64 + + + ) + +76  + #F_SETLK + +F_SETLK64 + + + ) + +77  + #F_SETLKW + +F_SETLKW64 + + + ) + +79  + #F_GETLK64 + 12 + + ) + +80  + #F_SETLK64 + 13 + + ) + +81  + #F_SETLKW64 + 14 + + ) + +83 #i +defed + +__USE_BSD + || defed +__USE_UNIX98 + + +84  + #F_SETOWN + 8 + + ) + +85  + #F_GETOWN + 9 + + ) + +88 #ifde +__USE_GNU + + +89  + #F_SETSIG + 10 + + ) + +90  + #F_GETSIG + 11 + + ) + +93 #ifde +__USE_GNU + + +94  + #F_SETLEASE + 1024 + + ) + +95  + #F_GETLEASE + 1025 + + ) + +96  + #F_NOTIFY + 1026 + + ) + +100  + #FD_CLOEXEC + 1 + + ) + +103  + #F_RDLCK + 0 + + ) + +104  + #F_WRLCK + 1 + + ) + +105  + #F_UNLCK + 2 + + ) + +108  + #F_EXLCK + 4 + + ) + +109  + #F_SHLCK + 8 + + ) + +111 #ifde +__USE_BSD + + +113  + #LOCK_SH + 1 + + ) + +114  + #LOCK_EX + 2 + + ) + +115  + #LOCK_NB + 4 + + ) + +117  + #LOCK_UN + 8 + + ) + +120 #ifde +__USE_GNU + + +121  + #LOCK_MAND + 32 + + ) + +122  + #LOCK_READ + 64 + + ) + +123  + #LOCK_WRITE + 128 + + ) + +124  + #LOCK_RW + 192 + + ) + +127 #ifde +__USE_GNU + + +129  + #DN_ACCESS + 0x00000001 + + ) + +130  + #DN_MODIFY + 0x00000002 + + ) + +131  + #DN_CREATE + 0x00000004 + + ) + +132  + #DN_DELETE + 0x00000008 + + ) + +133  + #DN_RENAME + 0x00000010 + + ) + +134  + #DN_ATTRIB + 0x00000020 + + ) + +135  + #DN_MULTISHOT + 0x80000000 + + ) + +138  + sock + + +140  + ml_ty +; + +141  + ml_wh +; + +142 #ide +__USE_FILE_OFFSET64 + + +143 +__off_t + + ml_t +; + +144 +__off_t + + ml_n +; + +146 +__off64_t + + ml_t +; + +147 +__off64_t + + ml_n +; + +149 +__pid_t + + ml_pid +; + +152 #ifde +__USE_LARGEFILE64 + + +153  + sock64 + + +155  + ml_ty +; + +156  + ml_wh +; + +157 +__off64_t + + ml_t +; + +158 +__off64_t + + ml_n +; + +159 +__pid_t + + ml_pid +; + +165 #ifdef +__USE_BSD + + +166  + #FAPPEND + +O_APPEND + + + ) + +167  + #FFSYNC + +O_FSYNC + + + ) + +168  + #FASYNC + +O_ASYNC + + + ) + +169  + #FNONBLOCK + +O_NONBLOCK + + + ) + +170  + #FNDELAY + +O_NDELAY + + + ) + +174 #ifde +__USE_XOPEN2K + + +175  + #POSIX_FADV_NORMAL + 0 + + ) + +176  + #POSIX_FADV_RANDOM + 1 + + ) + +177  + #POSIX_FADV_SEQUENTIAL + 2 + + ) + +178  + #POSIX_FADV_WILLNEED + 3 + + ) + +179  + #POSIX_FADV_DONTNEED + 4 + + ) + +180  + #POSIX_FADV_NOREUSE + 5 + + ) + +183 +__BEGIN_DECLS + + +186 +ssize_t + + $adahd + ( +__fd +, +__off64_t + +__offt +, +size_t + +__cou +) + +187 +__THROW +; + +189 +__END_DECLS + + + @/usr/include/bits/posix1_lim.h + +25 #idef +_BITS_POSIX1_LIM_H + + +26  + #_BITS_POSIX1_LIM_H + 1 + + ) + +32  + #_POSIX_AIO_LISTIO_MAX + 2 + + ) + +35  + #_POSIX_AIO_MAX + 1 + + ) + +38  + #_POSIX_ARG_MAX + 4096 + + ) + +41 #ifde +__USE_XOPEN2K + + +42  + #_POSIX_CHILD_MAX + 25 + + ) + +44  + #_POSIX_CHILD_MAX + 6 + + ) + +48  + #_POSIX_DELAYTIMER_MAX + 32 + + ) + +52  + #_POSIX_HOST_NAME_MAX + 255 + + ) + +55  + #_POSIX_LINK_MAX + 8 + + ) + +58  + #_POSIX_LOGIN_NAME_MAX + 9 + + ) + +61  + #_POSIX_MAX_CANON + 255 + + ) + +65  + #_POSIX_MAX_INPUT + 255 + + ) + +68  + #_POSIX_MQ_OPEN_MAX + 8 + + ) + +71  + #_POSIX_MQ_PRIO_MAX + 32 + + ) + +74  + #_POSIX_NAME_MAX + 14 + + ) + +77 #ifde +__USE_XOPEN2K + + +78  + #_POSIX_NGROUPS_MAX + 8 + + ) + +80  + #_POSIX_NGROUPS_MAX + 0 + + ) + +84 #ifde +__USE_XOPEN2K + + +85  + #_POSIX_OPEN_MAX + 20 + + ) + +87  + #_POSIX_OPEN_MAX + 16 + + ) + +92  + #_POSIX_FD_SETSIZE + +_POSIX_OPEN_MAX + + + ) + +95  + #_POSIX_PATH_MAX + 256 + + ) + +98  + #_POSIX_PIPE_BUF + 512 + + ) + +102  + #_POSIX_RE_DUP_MAX + 255 + + ) + +105  + #_POSIX_RTSIG_MAX + 8 + + ) + +108  + #_POSIX_SEM_NSEMS_MAX + 256 + + ) + +111  + #_POSIX_SEM_VALUE_MAX + 32767 + + ) + +114  + #_POSIX_SIGQUEUE_MAX + 32 + + ) + +117  + #_POSIX_SSIZE_MAX + 32767 + + ) + +120  + #_POSIX_STREAM_MAX + 8 + + ) + +123  + #_POSIX_SYMLINK_MAX + 255 + + ) + +127  + #_POSIX_SYMLOOP_MAX + 8 + + ) + +130  + #_POSIX_TIMER_MAX + 32 + + ) + +133  + #_POSIX_TTY_NAME_MAX + 9 + + ) + +136  + #_POSIX_TZNAME_MAX + 6 + + ) + +139  + #_POSIX_QLIMIT + 1 + + ) + +143  + #_POSIX_HIWAT + +_POSIX_PIPE_BUF + + + ) + +146  + #_POSIX_UIO_MAXIOV + 16 + + ) + +149  + #_POSIX_CLOCKRES_MIN + 20000000 + + ) + +153  + ~ + +156 #idef +SSIZE_MAX + + +157  + #SSIZE_MAX + +LONG_MAX + + + ) + +164 #idef +NGROUPS_MAX + + +165  + #NGROUPS_MAX + 8 + + ) + + @/usr/include/bits/posix_opt.h + +20 #idef +_POSIX_OPT_H + + +21  + #_POSIX_OPT_H + 1 + + ) + +24  + #_POSIX_JOB_CONTROL + 1 + + ) + +27  + #_POSIX_SAVED_IDS + 1 + + ) + +30  + #_POSIX_PRIORITY_SCHEDULING + 200112L + + ) + +33  + #_POSIX_SYNCHRONIZED_IO + 200112L + + ) + +36  + #_POSIX_FSYNC + 200112L + + ) + +39  + #_POSIX_MAPPED_FILES + 200112L + + ) + +42  + #_POSIX_MEMLOCK + 200112L + + ) + +45  + #_POSIX_MEMLOCK_RANGE + 200112L + + ) + +48  + #_POSIX_MEMORY_PROTECTION + 200112L + + ) + +51  + #_POSIX_CHOWN_RESTRICTED + 1 + + ) + +55  + #_POSIX_VDISABLE + '\0' + + ) + +58  + #_POSIX_NO_TRUNC + 1 + + ) + +61  + #_XOPEN_REALTIME + 1 + + ) + +64  + #_XOPEN_REALTIME_THREADS + 1 + + ) + +67  + #_XOPEN_SHM + 1 + + ) + +70  + #_POSIX_THREADS + 200112L + + ) + +73  + #_POSIX_REENTRANT_FUNCTIONS + 1 + + ) + +74  + #_POSIX_THREAD_SAFE_FUNCTIONS + 200112L + + ) + +77  + #_POSIX_THREAD_PRIORITY_SCHEDULING + 200112L + + ) + +80  + #_POSIX_THREAD_ATTR_STACKSIZE + 200112L + + ) + +83  + #_POSIX_THREAD_ATTR_STACKADDR + 200112L + + ) + +86  + #_POSIX_SEMAPHORES + 200112L + + ) + +89  + #_POSIX_REALTIME_SIGNALS + 200112L + + ) + +92  + #_POSIX_ASYNCHRONOUS_IO + 200112L + + ) + +93  + #_POSIX_ASYNC_IO + 1 + + ) + +95  + #_LFS_ASYNCHRONOUS_IO + 1 + + ) + +97  + #_POSIX_PRIORITIZED_IO + 200112L + + ) + +100  + #_LFS64_ASYNCHRONOUS_IO + 1 + + ) + +103  + #_LFS_LARGEFILE + 1 + + ) + +104  + #_LFS64_LARGEFILE + 1 + + ) + +105  + #_LFS64_STDIO + 1 + + ) + +108  + #_POSIX_SHARED_MEMORY_OBJECTS + 200112L + + ) + +111  + #_POSIX_CPUTIME + 0 + + ) + +114  + #_POSIX_THREAD_CPUTIME + 0 + + ) + +117  + #_POSIX_REGEXP + 1 + + ) + +120  + #_POSIX_READER_WRITER_LOCKS + 200112L + + ) + +123  + #_POSIX_SHELL + 1 + + ) + +126  + #_POSIX_TIMEOUTS + 200112L + + ) + +129  + #_POSIX_SPIN_LOCKS + 200112L + + ) + +132  + #_POSIX_SPAWN + 200112L + + ) + +135  + #_POSIX_TIMERS + 200112L + + ) + +138  + #_POSIX_BARRIERS + 200112L + + ) + +141  + #_POSIX_MESSAGE_PASSING + 200112L + + ) + +144  + #_POSIX_THREAD_PROCESS_SHARED + -1 + + ) + +147  + #_POSIX_MONOTONIC_CLOCK + 0 + + ) + +150  + #_POSIX_CLOCK_SELECTION + -1 + + ) + +153  + #_POSIX_ADVISORY_INFO + 200112L + + ) + +156  + #_POSIX_IPV6 + 200112L + + ) + +159  + #_POSIX_RAW_SOCKETS + 200112L + + ) + +162  + #_POSIX2_CHAR_TERM + 200112L + + ) + +165  + #_POSIX_SPORADIC_SERVER + -1 + + ) + +166  + #_POSIX_THREAD_SPORADIC_SERVER + -1 + + ) + +169  + #_POSIX_TRACE + -1 + + ) + +170  + #_POSIX_TRACE_EVENT_FILTER + -1 + + ) + +171  + #_POSIX_TRACE_INHERIT + -1 + + ) + +172  + #_POSIX_TRACE_LOG + -1 + + ) + +175  + #_POSIX_TYPED_MEMORY_OBJECTS + -1 + + ) + +178  + #_POSIX_THREAD_PRIO_INHERIT + -1 + + ) + +179  + #_POSIX_THREAD_PRIO_PROTECT + -1 + + ) + + @/usr/include/bits/pthreadtypes.h + +15 #i! +defed + +_BITS_TYPES_H + && !defed +_PTHREAD_H + + +19 #ide +_BITS_PTHREADTYPES_H + + +20  + #_BITS_PTHREADTYPES_H + 1 + + ) + +22  + #__ed_schedm + + + ) + +23  + ~ + +25  + t__omic_lock_t +; + +28  + s_had_lock + + +30  + m__us +; + +31 +__omic_lock_t + + m__lock +; + +35 #ide +_PTHREAD_DESCR_DEFINED + + +37  +_had_des_ru + * + t_had_des +; + +38  + #_PTHREAD_DESCR_DEFINED + + + ) + +43  + s__had__s + + +45  + m__dache +; + +46  + m__schedpicy +; + +47  +__sched_m + + m__schedm +; + +48  + m__hsched +; + +49  + m__sce +; + +50 +size_t + + m__gudsize +; + +51  + m__ackaddr_t +; + +52 * + m__ackaddr +; + +53 +size_t + + m__acksize +; + +54 } + thad__t +; + +59 #ifde +__GLIBC_HAVE_LONG_LONG + + +60 +__exnsi__ +  + t__had_cd_ign_t +; + +62  + t__had_cd_ign_t +; + +67  +_had_lock + + m__c_lock +; + +68 +_had_des + + m__c_wag +; + +69  + m__ddg +[48 -  ( +_had_lock +) + +70 -  ( +_had_des +-  ( +__had_cd_ign_t +)]; + +71 +__had_cd_ign_t + + m__ign +; + +72 } + thad_cd_t +; + +78  + m__dummy +; + +79 } + thad_cd_t +; + +82  + thad_key_t +; + +90  + m__m_rved +; + +91  + m__m_cou +; + +92 +_had_des + + m__m_owr +; + +93  + m__m_kd +; + +94  +_had_lock + + m__m_lock +; + +95 } + thad_mux_t +; + +101  + m__muxkd +; + +102 } + thad_mux_t +; + +106  + thad__t +; + +109 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +111  + s_had_rwlock_t + + +113  +_had_lock + + m__rw_lock +; + +114  + m__rw_ads +; + +115 +_had_des + + m__rw_wr +; + +116 +_had_des + + m__rw_ad_wag +; + +117 +_had_des + + m__rw_wre_wag +; + +118  + m__rw_kd +; + +119  + m__rw_pshed +; + +120 } + thad_rwlock_t +; + +126  + m__lockkd +; + +127  + m__pshed +; + +128 } + thad_rwlock_t +; + +131 #ifde +__USE_XOPEN2K + + +133 vީ + thad_lock_t +; + +137  +_had_lock + + m__ba_lock +; + +138  + m__ba_qued +; + +139  + m__ba_e +; + +140 +_had_des + + m__ba_wag +; + +141 } + thad_brr_t +; + +145  + m__pshed +; + +146 } + thad_brr_t +; + +152  + thad_t +; + + @/usr/include/bits/setjmp.h + +20 #ide +_BITS_SETJMP_H + + +21  + #_BITS_SETJMP_H + 1 + + ) + +23 #i! +defed + +_SETJMP_H + && !defed +_PTHREAD_H + + +27 #i +defed + +__USE_MISC + || defed +_ASM + + +28  + #JB_BX + 0 + + ) + +29  + #JB_SI + 1 + + ) + +30  + #JB_DI + 2 + + ) + +31  + #JB_BP + 3 + + ) + +32  + #JB_SP + 4 + + ) + +33  + #JB_PC + 5 + + ) + +34  + #JB_SIZE + 24 + + ) + +37 #idef +_ASM + + +38  + t__jmp_buf +[6]; + +43  + #_JMPBUF_UNWINDS +( +jmpbuf +, +addss +) \ + +44 ((*( +addss +< (*( +jmpbuf +)[ +JB_SP +]) + + ) + + @/usr/include/bits/sigset.h + +20 #idef +_SIGSET_H_tys + + +21  + #_SIGSET_H_tys + 1 + + ) + +23  + t__sig_omic_t +; + +27  + #_SIGSET_NWORDS + (1024 / (8 *  ())) + + ) + +30  + m__v +[ +_SIGSET_NWORDS +]; + +31 } + t__sigt_t +; + +42 #i! +defed + +_SIGSET_H_s + && defed +_SIGNAL_H + + +43  + #_SIGSET_H_s + 1 + + ) + +45 #ide +_EXTERN_INLINE + + +46  + #_EXTERN_INLINE + +__le + + + ) + +50  + #__sigmask +( +sig +) \ + +51 (((1<< ((( +sig +- 1% (8 *  ()))) + + ) + +54  + #__sigwd +( +sig +(((sig- 1/ (8 *  ())) + + ) + +56 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +57  + #__sigemyt +( +t +) \ + +58 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +59 +sigt_t + * +__t + = ( +t +); \ + +60 -- +__t + >0 +__t +-> +__v +[__cnt] = 0; \ + +61 0; })) + + ) + +62  + #__sigflt +( +t +) \ + +63 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +64 +sigt_t + * +__t + = ( +t +); \ + +65 -- +__t + >0 +__t +-> +__v +[__cnt] = ~0UL; \ + +66 0; })) + + ) + +68 #ifde +__USE_GNU + + +72  + #__sigimyt +( +t +) \ + +73 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +74 cڡ +sigt_t + * +__t + = ( +t +); \ + +75  +__t + = +__t +-> +__v +[-- +__t +]; \ + +76 ! +__t + && -- +__t + >= 0) \ + +77 +__t + = +__t +-> +__v +[ +__t +]; \ + +78 +__t + =0; })) + + ) + +79  + #__sigdt +( +de +, + +, +right +) \ + +80 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +81 +sigt_t + * +__de + = ( +de +); \ + +82 cڡ +sigt_t + * +__ + = ( + +); \ + +83 cڡ +sigt_t + * +__right + = ( +right +); \ + +84 -- +__t + >= 0) \ + +85 +__de +-> +__v +[ +__t +] = ( +__ +->__val[__cnt] \ + +86 & +__right +-> +__v +[ +__t +]); \ + +87 0; })) + + ) + +88  + #__sigܣt +( +de +, + +, +right +) \ + +89 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +90 +sigt_t + * +__de + = ( +de +); \ + +91 cڡ +sigt_t + * +__ + = ( + +); \ + +92 cڡ +sigt_t + * +__right + = ( +right +); \ + +93 -- +__t + >= 0) \ + +94 +__de +-> +__v +[ +__t +] = ( +__ +->__val[__cnt] \ + +95 | +__right +-> +__v +[ +__t +]); \ + +96 0; })) + + ) + +103  +__sigismemb + ( +__cڡ + +__sigt_t + *, ); + +104  +__sigaddt + ( +__sigt_t + *, ); + +105  +__sigdt + ( +__sigt_t + *, ); + +107 #ifde +__USE_EXTERN_INLINES + + +108  + #__SIGSETFN +( +NAME +, +BODY +, +CONST +) \ + +109 +_EXTERN_INLINE + \ + +110 + `NAME + ( +CONST + +__sigt_t + * +__t +,  +__sig +) \ + +112  +__mask + = + `__sigmask + ( +__sig +); \ + +113  +__wd + = + `__sigwd + ( +__sig +); \ + +114  +BODY +; \ + +115 } + + ) + +117 +__SIGSETFN + ( +__sigismemb +, ( +__t +-> +__v +[ +__wd +] & +__mask +? 1 : 0, +__cڡ +) + +118 +__SIGSETFN + ( +__sigaddt +, (( +__t +-> +__v +[ +__wd +] | +__mask +), 0), ) + +119 +__SIGSETFN + ( +__sigdt +, (( +__t +-> +__v +[ +__wd +] &~ +__mask +), 0), ) + +121 #unde +__SIGSETFN + + + @/usr/include/bits/stdio.h + +20 #ide +_STDIO_H + + +24 #ifde +__lulus + + +25  + #__STDIO_INLINE + +le + + + ) + +27  + #__STDIO_INLINE + +__le + + + ) + +31 #ifde +__USE_EXTERN_INLINES + + +33 +__STDIO_INLINE +  + +34 + $vtf + ( +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +36  + `vrtf + ( +dout +, +__fmt +, +__g +); + +37 + } +} + +40 +__STDIO_INLINE +  + +41 + $gch + () + +43  + `_IO_gc + ( +d +); + +44 + } +} + +47 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +49 +__STDIO_INLINE +  + +50 + $gc_uocked + ( +FILE + * +__ +) + +52  + `_IO_gc_uocked + ( +__ +); + +53 + } +} + +56 +__STDIO_INLINE +  + +57 + $gch_uocked + () + +59  + `_IO_gc_uocked + ( +d +); + +60 + } +} + +65 +__STDIO_INLINE +  + +66 + $putch + ( +__c +) + +68  + `_IO_putc + ( +__c +, +dout +); + +69 + } +} + +72 #ifde +__USE_MISC + + +74 +__STDIO_INLINE +  + +75 + $utc_uocked + ( +__c +, +FILE + * +__am +) + +77  + `_IO_putc_uocked + ( +__c +, +__am +); + +78 + } +} + +82 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +84 +__STDIO_INLINE +  + +85 + $putc_uocked + ( +__c +, +FILE + * +__am +) + +87  + `_IO_putc_uocked + ( +__c +, +__am +); + +88 + } +} + +91 +__STDIO_INLINE +  + +92 + $putch_uocked + ( +__c +) + +94  + `_IO_putc_uocked + ( +__c +, +dout +); + +95 + } +} + +99 #ifdef +__USE_GNU + + +101 +__STDIO_INLINE + +_IO_ssize_t + + +102 + $gle + (** +__l +, +size_t + * +__n +, +FILE + * +__am +) + +104  + `__gdim + ( +__l +, +__n +, '\n', +__am +); + +105 + } +} + +109 #ifde +__USE_MISC + + +111 +__STDIO_INLINE +  + +112 +__NTH + ( + $of_uocked + ( +FILE + * +__am +)) + +114  + `_IO_of_uocked + ( +__am +); + +115 + } +} + +118 +__STDIO_INLINE +  + +119 +__NTH + ( + $_uocked + ( +FILE + * +__am +)) + +121  + `_IO__uocked + ( +__am +); + +122 + } +} + +128 #i +defed + +__USE_MISC + && defed +__GNUC__ + && defed +__OPTIMIZE__ + + +130  + #d_uocked +( +r +, +size +, +n +, +am +) \ + +131 ( + `__exnsi__ + (( + `__but_cڡt_p + ( +size +&& __but_cڡt_( +n +) \ + +132 && ( +size_t +( +size +* (size_t( +n +) <= 8 \ + +133 && ( +size_t +( +size +) != 0) \ + +134 ? ({ * +__r + = (*( +r +); \ + +135 +FILE + * +__am + = ( +am +); \ + +136 +size_t + +__t +; \ + +137  +__t + = ( +size_t +( +size +* (size_t( +n +); \ + +138 +__t + > 0; --__cnt) \ + +140  +__c + = + `_IO_gc_uocked + ( +__am +); \ + +141 i( +__c + = +EOF +) \ + +143 * +__r +++ = +__c +; \ + +145 (( +size_t +( +size +* (size_t( +n +- +__t +) \ + +146 / ( +size_t +( +size +); }) \ + +147 : ((( + `__but_cڡt_p + ( +size +&& ( +size_t +) (size) == 0) \ + +148 || ( + `__but_cڡt_p + ( +n +&& ( +size_t +) (n) == 0)) \ + +150 ? ((( +r +), (( +am +), (( +size +), \ + +151 (( +n +), ( +size_t +) 0) \ + +152 : + `d_uocked + ( +r +, +size +, +n +, +am +)))) + + ) + +154  + #fwre_uocked +( +r +, +size +, +n +, +am +) \ + +155 ( + `__exnsi__ + (( + `__but_cڡt_p + ( +size +&& __but_cڡt_( +n +) \ + +156 && ( +size_t +( +size +* (size_t( +n +) <= 8 \ + +157 && ( +size_t +( +size +) != 0) \ + +158 ? ({ cڡ * +__r + = (cڡ *( +r +); \ + +159 +FILE + * +__am + = ( +am +); \ + +160 +size_t + +__t +; \ + +161  +__t + = ( +size_t +( +size +* (size_t( +n +); \ + +162 +__t + > 0; --__cnt) \ + +163 i( + `_IO_putc_uocked + (* +__r +++, +__am += +EOF +) \ + +165 (( +size_t +( +size +* (size_t( +n +- +__t +) \ + +166 / ( +size_t +( +size +); }) \ + +167 : ((( + `__but_cڡt_p + ( +size +&& ( +size_t +) (size) == 0) \ + +168 || ( + `__but_cڡt_p + ( +n +&& ( +size_t +) (n) == 0)) \ + +170 ? ((( +r +), (( +am +), (( +size +), \ + +171 (( +n +), ( +size_t +) 0) \ + +172 : + `fwre_uocked + ( +r +, +size +, +n +, +am +)))) + + ) + +176 #unde +__STDIO_INLINE + + + @/usr/include/bits/stdio2.h + +20 #ide +_STDIO_H + + +24  + $__rtf_chk + (* +__ri + +__s +,  +__ag +, +size_t + +__ +, + +25 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +26  + $__vrtf_chk + (* +__ri + +__s +,  +__ag +, +size_t + +__ +, + +27 +__cڡ + * +__ri + +__fm +, + +28 +_G_va_li + +__ + +__THROW +; + +30  + #rtf +( +r +, ...) \ + +31 + `__but___rtf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +32 +__VA_ARGS__ +) + + ) + +33  + #vrtf +( +r +, +fmt +, + +) \ + +34 + `__but___vrtf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (r), +fmt +, + +) + + ) + +36 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +38  + $__tf_chk + (* +__ri + +__s +, +size_t + +__n +,  +__ag +, + +39 +size_t + +__ +, +__cڡ + * +__ri + +__fm +, + +40 ... +__THROW +; + +41  + $__vtf_chk + (* +__ri + +__s +, +size_t + +__n +,  +__ag +, + +42 +size_t + +__ +, +__cڡ + * +__ri + +__fm +, + +43 +_G_va_li + +__ + +__THROW +; + +45  + #tf +( +r +, +n +, ...) \ + +46 + `__but___tf_chk + ( +r +, +n +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +47 +__VA_ARGS__ +) + + ) + +48  + #vtf +( +r +, +n +, +fmt +, + +) \ + +49 + `__but___vtf_chk + ( +r +, +n +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +50 +fmt +, + +) + + ) + +54 #i +__USE_FORTIFY_LEVEL + > 1 + +56  + `__rtf_chk + ( +FILE + * +__ri + +__am +,  +__ag +, + +57 +__cڡ + * +__ri + +__fm +, ...); + +58  + `__tf_chk + ( +__ag +, +__cڡ + * +__ri + +__fm +, ...); + +59  + `__vrtf_chk + ( +FILE + * +__ri + +__am +,  +__ag +, + +60 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__ +); + +61  + `__vtf_chk + ( +__ag +, +__cڡ + * +__ri + +__fm +, + +62 +_G_va_li + +__ +); + +64  + #tf +(...) \ + +65 + `__tf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +66  + #rtf +( +am +, ...) \ + +67 + `__rtf_chk + ( +am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +68  + #vtf +( +fm +, + +) \ + +69 + `__vtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +fm +, + +) + + ) + +70  + #vrtf +( +am +, +fm +, + +) \ + +71 + `__vrtf_chk + ( +am +, +__USE_FORTIFY_LEVEL + - 1, +fm +, + +) + + ) + +75 * + `__gs_chk + (* +__r +, +size_t +); + +76  + #gs +( +__r +) \ + +77 (( + `__bos + ( +__r +=( +size_t +) -1) \ + +78 ? ( +gs +( +__r +: + `__gs_chk + (__r, + `__bos + (__r))) + + ) + + @/usr/include/bits/stdio_lim.h + +19 #i! +defed + +_STDIO_H + && !defed +__ed_FOPEN_MAX + && !defed +__ed_IOV_MAX + + +23 #ifde +_STDIO_H + + +24  + #L_tmam + 20 + + ) + +25  + #TMP_MAX + 238328 + + ) + +26  + #FILENAME_MAX + 4096 + + ) + +28 #ifde +__USE_POSIX + + +29  + #L_mid + 9 + + ) + +30  + #L_curid + 9 + + ) + +34 #i +defed + +__ed_FOPEN_MAX + || defed +_STDIO_H + + +35 #unde +FOPEN_MAX + + +36  + #FOPEN_MAX + 16 + + ) + +39 #i +defed + +__ed_IOV_MAX + && !defed +IOV_MAX + + +40  + #IOV_MAX + 1024 + + ) + + @/usr/include/bits/string.h + +21 #ide +_STRING_H + + +26  + #_STRING_ARCH_uligd + 1 + + ) + +31 #i! +defed + +__NO_STRING_INLINES + && defed +__USE_STRING_INLINES + \ + +32 && +defed + + g__GNUC__ + && __GNUC__ >2 && ! +__BOUNDED_POINTERS__ + + +34 #ide +__STRING_INLINE + + +35 #ifde +__lulus + + +36  + #__STRING_INLINE + +le + + + ) + +38  + #__STRING_INLINE + +__le + + + ) + +43  + #__STRING_SMALL_GET16 +( +c +, +idx +) \ + +44 (((( +__cڡ + *( +c +))[ +idx + + 1] << 8) \ + +45 | (( +__cڡ + *( +c +))[ +idx +]) + + ) + +46  + #__STRING_SMALL_GET32 +( +c +, +idx +) \ + +47 ((((( +__cڡ + *( +c +))[ +idx + + 3] << 8 \ + +48 | (( +__cڡ + *( +c +))[ +idx + + 2]) << 8 \ + +49 | (( +__cڡ + *( +c +))[ +idx + + 1]) << 8 \ + +50 | (( +__cڡ + *( +c +))[ +idx +]) + + ) + +54  + #_HAVE_STRING_ARCH_memy + 1 + + ) + +55  + #memy +( +de +, +c +, +n +) \ + +56 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +n +) \ + +57 ? + `__memy_c + (( +de +), ( +c +), ( +n +)) \ + +58 : + `__memy_g + (( +de +), ( +c +), ( +n +)))) + + ) + +59  + #__memy_c +( +de +, +c +, +n +) \ + +60 (( +n +) == 0 \ + +61 ? ( +de +) \ + +62 : ((( +n +) % 4 == 0) \ + +63 ? + `__memy_by4 + ( +de +, +c +, +n +) \ + +64 : ((( +n +) % 2 == 0) \ + +65 ? + `__memy_by2 + ( +de +, +c +, +n +) \ + +66 : + `__memy_g + ( +de +, +c +, +n +)))) + + ) + +68 +__STRING_INLINE + * +__memy_by4 + (* +__de +, +__cڡ + * +__c +, + +69 +size_t + +__n +); + +71 +__STRING_INLINE + * + +72 + $__memy_by4 + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +74  +__d0 +, +__d1 +; + +75 * +__tmp + = +__de +; + +76 +__asm__ + +__vީe__ + + +84 : "=&r" ( +__d0 +), "=&r" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__d1 +) + +85 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__n + / 4) + +87  +__de +; + +88 + } +} + +90 +__STRING_INLINE + * +__memy_by2 + (* +__de +, +__cڡ + * +__c +, + +91 +size_t + +__n +); + +93 +__STRING_INLINE + * + +94 + $__memy_by2 + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +96  +__d0 +, +__d1 +; + +97 * +__tmp + = +__de +; + +98 +__asm__ + +__vީe__ + + +111 : "=&q" ( +__d0 +), "=&r" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__d1 +) + +112 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__n + / 2) + +114  +__de +; + +115 + } +} + +117 +__STRING_INLINE + * +__memy_g + (* +__de +, +__cڡ + * +__c +, + +118 +size_t + +__n +); + +120 +__STRING_INLINE + * + +121 + $__memy_g + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +123  +__d0 +, +__d1 +, +__d2 +; + +124 * +__tmp + = +__de +; + +125 +__asm__ + +__vީe__ + + +136 : "=&c" ( +__d0 +), "=&D" ( +__d1 +), "=&S" ( +__d2 +), + +137 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__de +) + +138 : "0" ( +__n +), "1" ( +__tmp +), "2" ( +__c +), + +139 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__c +) + +141  +__de +; + +142 + } +} + +144  + #_HAVE_STRING_ARCH_memmove + 1 + + ) + +145 #ide +_FORCE_INLINES + + +148 +__STRING_INLINE + * + +149 + $memmove + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +151  +__d0 +, +__d1 +, +__d2 +; + +152 * +__tmp + = +__de +; + +153 i( +__de + < +__c +) + +154 +__asm__ + +__vީe__ + + +157 : "=&c" ( +__d0 +), "=&S" ( +__d1 +), "=&D" ( +__d2 +), + +158 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__de +) + +159 : "0" ( +__n +), "1" ( +__c +), "2" ( +__tmp +), + +160 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__c +)); + +162 +__asm__ + +__vީe__ + + +166 : "=&c" ( +__d0 +), "=&S" ( +__d1 +), "=&D" ( +__d2 +), + +167 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__de +) + +168 : "0" ( +__n +), "1" (__- 1 + ( +__cڡ + * +__c +), + +169 "2" ( +__n + - 1 + (* +__tmp +), + +170 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__c +)); + +171  +__de +; + +172 + } +} + +176  + #_HAVE_STRING_ARCH_memcmp + 1 + + ) + +177 #ide +_FORCE_INLINES + + +178 #ide +__PIC__ + + +180 +__STRING_INLINE +  + +181 + $memcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +183  +__d0 +, +__d1 +, +__d2 +; + +184  +__s +; + +185 +__asm__ + +__vީe__ + + +193 : "=&a" ( +__s +), "=&S" ( +__d0 +), "=&D" ( +__d1 +), "=&c" ( +__d2 +) + +194 : "0" (0), "1" ( +__s1 +), "2" ( +__s2 +), "3" ( +__n +), + +195 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s1 +), + +196 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s2 +) + +198  +__s +; + +199 + } +} + +204  + #_HAVE_STRING_ARCH_memt + 1 + + ) + +205  + #_USE_STRING_ARCH_memt + 1 + + ) + +206  + #memt +( +s +, +c +, +n +) \ + +207 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +n +) && (n) <= 16 \ + +208 ? (( +n +) == 1 \ + +209 ? + `__memt_c1 + (( +s +), ( +c +)) \ + +210 : + `__memt_gc + (( +s +), ( +c +), ( +n +))) \ + +211 : ( + `__but_cڡt_p + ( +c +) \ + +212 ? ( + `__but_cڡt_p + ( +n +) \ + +213 ? + `__memt_c + (( +s +), ( +c +), ( +n +)) \ + +214 : + `memt + (( +s +), ( +c +), ( +n +))) \ + +215 : ( + `__but_cڡt_p + ( +n +) \ + +216 ? + `__memt_g + (( +s +), ( +c +), ( +n +)) \ + +217 : + `memt + (( +s +), ( +c +), ( +n +)))))) + + ) + +219  + #__memt_c1 +( +s +, +c +({ * +__s + = (s); \ + +220 *((* +__s +(( +c +); \ + +221 +__s +; }) + + ) + +223  + #__memt_gc +( +s +, +c +, +n +) \ + +224 ({ * +__s + = ( +s +); \ + +226  +__ui +; \ + +227  +__usi +; \ + +228  +__uc +; \ + +229 } * +__u + = +__s +; \ + +230  +__c + = ((((( +c +))) * 0x01010101; \ + +236 i(( +n +) == 3 || (n) >= 5) \ + +237 +__asm__ + + `__vީe__ + ("" : "" ( +__c +) : "0" (__c)); \ + +240  +n +) \ + +243 +__u +-> +__ui + = +__c +; \ + +244 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +246 +__u +-> +__ui + = +__c +; \ + +247 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +249 +__u +-> +__ui + = +__c +; \ + +250 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +252 +__u +-> +__usi + = ( +__c +; \ + +253 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +254 +__u +-> +__uc + = ( +__c +; \ + +258 +__u +-> +__ui + = +__c +; \ + +259 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +261 +__u +-> +__ui + = +__c +; \ + +262 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +264 +__u +-> +__ui + = +__c +; \ + +265 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +267 +__u +-> +__usi + = ( +__c +; \ + +271 +__u +-> +__ui + = +__c +; \ + +272 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +274 +__u +-> +__ui + = +__c +; \ + +275 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +277 +__u +-> +__ui + = +__c +; \ + +278 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +280 +__u +-> +__uc + = ( +__c +; \ + +284 +__u +-> +__ui + = +__c +; \ + +285 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +287 +__u +-> +__ui + = +__c +; \ + +288 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +290 +__u +-> +__ui + = +__c +; \ + +291 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +293 +__u +-> +__ui + = +__c +; \ + +298 +__s +; }) + + ) + +300  + #__memt_c +( +s +, +c +, +n +) \ + +301 ((( +n +) % 4 == 0) \ + +302 ? + `__memt_c_by4 + ( +s +, ((((( +c +))) * 0x01010101,\ + +303 +n +) \ + +304 : ((( +n +) % 2 == 0) \ + +305 ? + `__memt_c_by2 + ( +s +, \ + +306 ((((( +c +))) * 0x01010101,\ + +307 +n +) \ + +308 : + `memt + ( +s +, +c +, +n +))) + + ) + +310 +__STRING_INLINE + * +__memt_c_by4 + (* +__s +,  +__c +, + +311 +size_t + +__n +); + +313 +__STRING_INLINE + * + +314 + $__memt_c_by4 + (* +__s +,  +__c +, +size_t + +__n +) + +316 * +__tmp + = +__s +; + +317  +__d0 +; + +318 #ifde +__i686__ + + +319 +__asm__ + +__vީe__ + + +322 : "=&a" ( +__c +), "=&D" ( +__tmp +), "=&c" ( +__d0 +), + +323 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +324 : "0" (( +__c +), "1" ( +__tmp +), "2" ( +__n + / 4) + +327 +__asm__ + +__vީe__ + + +333 : "=&r" ( +__c +), "=&r" ( +__tmp +), "=&r" ( +__d0 +), + +334 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +335 : "0" (( +__c +), "1" ( +__tmp +), "2" ( +__n + / 4) + +338  +__s +; + +339 + } +} + +341 +__STRING_INLINE + * +__memt_c_by2 + (* +__s +,  +__c +, + +342 +size_t + +__n +); + +344 +__STRING_INLINE + * + +345 + $__memt_c_by2 + (* +__s +,  +__c +, +size_t + +__n +) + +347  +__d0 +, +__d1 +; + +348 * +__tmp + = +__s +; + +349 #ifde +__i686__ + + +350 +__asm__ + +__vީe__ + + +354 : "=&a" ( +__d0 +), "=&D" ( +__tmp +), "=&c" ( +__d1 +), + +355 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +356 : "0" (( +__c +), "1" ( +__tmp +), "2" ( +__n + / 4) + +359 +__asm__ + +__vީe__ + + +365 : "=&q" ( +__d0 +), "=&r" ( +__tmp +), "=&r" ( +__d1 +), + +366 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +367 : "0" (( +__c +), "1" ( +__tmp +), "2" ( +__n + / 4) + +370  +__s +; + +371 + } +} + +373  + #__memt_g +( +s +, +c +, +n +) \ + +374 ((( +n +) % 4 == 0) \ + +375 ? + `__memt_g_by4 + ( +s +, +c +, +n +) \ + +376 : ((( +n +) % 2 == 0) \ + +377 ? + `__memt_g_by2 + ( +s +, +c +, +n +) \ + +378 : + `memt + ( +s +, +c +, +n +))) + + ) + +380 +__STRING_INLINE + * +__memt_g_by4 + (* +__s +,  +__c +, +size_t + +__n +); + +382 +__STRING_INLINE + * + +383 + $__memt_g_by4 + (* +__s +,  +__c +, +size_t + +__n +) + +385 * +__tmp + = +__s +; + +386  +__d0 +; + +387 +__asm__ + +__vީe__ + + +397 : "=&q" ( +__c +), "=&r" ( +__tmp +), "=&r" ( +__d0 +), + +398 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +399 : "0" (( +__c +), "1" ( +__tmp +), "2" ( +__n + / 4) + +401  +__s +; + +402 + } +} + +404 +__STRING_INLINE + * +__memt_g_by2 + (* +__s +,  +__c +, +size_t + +__n +); + +406 +__STRING_INLINE + * + +407 + $__memt_g_by2 + (* +__s +,  +__c +, +size_t + +__n +) + +409  +__d0 +, +__d1 +; + +410 * +__tmp + = +__s +; + +411 +__asm__ + +__vީe__ + + +422 : "=&q" ( +__d0 +), "=&r" ( +__tmp +), "=&r" ( +__d1 +), + +423 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +424 : "0" (( +__c +), "1" ( +__tmp +), "2" ( +__n + / 4) + +426  +__s +; + +427 + } +} + +431  + #_HAVE_STRING_ARCH_memchr + 1 + + ) + +432 #ide +_FORCE_INLINES + + +433 +__STRING_INLINE + * + +434 + $memchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +436  +__d0 +; + +437 #ifde +__i686__ + + +438  +__d1 +; + +440 * +__s +; + +441 i( +__n + == 0) + +442  +NULL +; + +443 #ifde +__i686__ + + +444 +__asm__ + +__vީe__ + + +448 : "=D" ( +__s +), "=&c" ( +__d0 +), "=&r" ( +__d1 +) + +449 : "a" ( +__c +), "0" ( +__s +), "1" ( +__n +), "2" (1), + +450 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +453 +__asm__ + +__vީe__ + + +459 : "=D" ( +__s +), "=&c" ( +__d0 +) + +460 : "a" ( +__c +), "0" ( +__s +), "1" ( +__n +), + +461 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +464  +__s + - 1; + +465 + } +} + +468  + #_HAVE_STRING_ARCH_memrchr + 1 + + ) + +469 #ide +_FORCE_INLINES + + +470 +__STRING_INLINE + * +__memrchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +); + +472 +__STRING_INLINE + * + +473 + $__memrchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +475  +__d0 +; + +476 #ifde +__i686__ + + +477  +__d1 +; + +479 * +__s +; + +480 i( +__n + == 0) + +481  +NULL +; + +482 #ifde +__i686__ + + +483 +__asm__ + +__vީe__ + + +489 : "=D" ( +__s +), "=&c" ( +__d0 +), "=&r" ( +__d1 +) + +490 : "a" ( +__c +), "0" ( +__s + + +__n + - 1), "1" (__n), "2" (-1), + +491 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +494 +__asm__ + +__vީe__ + + +501 : "=D" ( +__s +), "=&c" ( +__d0 +) + +502 : "a" ( +__c +), "0" ( +__s + + +__n + - 1), "1" (__n), + +503 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s +) + +506  +__s +; + +507 + } +} + +508 #ifde +__USE_GNU + + +509  + #memrchr +( +s +, +c +, +n + + `__memrchr + ((s), (c), (n)) + + ) + +514  + #_HAVE_STRING_ARCH_wmemchr + 1 + + ) + +515 +__STRING_INLINE + * +__wmemchr + (cڡ * +__s +,  +__c +); + +517 #ide +_FORCE_INLINES + + +518 +__STRING_INLINE + * + +519 + $__wmemchr + (cڡ * +__s +,  +__c +) + +521  +__d0 +; + +522 * +__s +; + +523 +__asm__ + +__vީe__ + + +526 : "=D" ( +__s +), "=&c" ( +__d0 +) + +527 : "a" ( +__c +), "0" ( +__s +), "1" (0xffffffff), + +528 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +530  +__s + - 1; + +531 + } +} + +532 #ifde +__USE_GNU + + +533 +__STRING_INLINE + * + +534 + $wmemchr + (cڡ * +__s +,  +__c +) + +536  + `__wmemchr + ( +__s +, +__c +); + +537 + } +} + +543  + #_HAVE_STRING_ARCH_ + 1 + + ) + +544  + # +( +r +) \ + +545 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +r +) \ + +546 ? + `__but_ + ( +r +) \ + +547 : + `___g + ( +r +))) + + ) + +548 +__STRING_INLINE + +size_t + +___g + ( +__cڡ + * +__r +); + +550 +__STRING_INLINE + +size_t + + +551 + $___g + ( +__cڡ + * +__r +) + +553  +__dummy +; + +554  +__cڡ + * +__tmp + = +__r +; + +555 +__asm__ + +__vީe__ + + +561 : "" ( +__tmp +), "=&q" ( +__dummy +) + +562 : "0" ( +__r +), + +563 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__r +) + +565  +__tmp + - +__r + - 1; + +566 + } +} + +570  + #_HAVE_STRING_ARCH_ry + 1 + + ) + +571  + #ry +( +de +, +c +) \ + +572 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +573 ? ( (( +c +)[0]=1 && + ` + (src) + 1 <= 8 \ + +574 ? + `__ry_a_sml + (( +de +), ( +c +), + ` + (src) + 1) \ + +575 : (* + `memy + ((*( +de +), \ + +576 ( +__cڡ + *( +c +), \ + +577 + ` + ( +c +) + 1)) \ + +578 : + `__ry_g + (( +de +), ( +c +)))) + + ) + +580  + #__ry_a_sml +( +de +, +c +, + +) \ + +581 ( + `__exnsi__ + ({ * +__de + = ( +de +); \ + +583  +__ui +; \ + +584  +__usi +; \ + +585  +__uc +; \ + +586  +__c +; \ + +587 } * +__u + = (* +__de +; \ + +588  + +) \ + +591 +__u +-> +__uc + = '\0'; \ + +594 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 0); \ + +597 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 0); \ + +598 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +599 +__u +-> +__uc + = '\0'; \ + +602 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +605 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +606 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +607 +__u +-> +__uc + = '\0'; \ + +610 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +611 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +612 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 4); \ + +615 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +616 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +617 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 4); \ + +618 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +619 +__u +-> +__uc + = '\0'; \ + +622 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +623 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +624 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 4); \ + +627 (* +__de +; })) + + ) + +629 +__STRING_INLINE + * +__ry_g + (* +__de +, +__cڡ + * +__c +); + +631 +__STRING_INLINE + * + +632 + $__ry_g + (* +__de +, +__cڡ + * +__c +) + +634 * +__tmp + = +__de +; + +635  +__dummy +; + +636 +__asm__ + +__vީe__ + + +645 : "=&r" ( +__c +), "=&r" ( +__tmp +), "=&q" ( +__dummy +), + +646 "=m" ( *(ru {  +__x +[0xfffffff]; } *) +__de +) + +647 : "0" ( +__c +), "1" ( +__tmp +), + +648 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__c +) + +650  +__de +; + +651 + } +} + +654 #ifde +__USE_GNU + + +655  + #_HAVE_STRING_ARCH_py + 1 + + ) + +657  + #__py +( +de +, +c +) \ + +658 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +659 ? ( + ` + ( +c +) + 1 <= 8 \ + +660 ? + `__py_a_sml + (( +de +), ( +c +), + ` + (src) + 1) \ + +661 : + `__py_c + (( +de +), ( +c +), + ` + (src) + 1)) \ + +662 : + `__py_g + (( +de +), ( +c +)))) + + ) + +663  + #__py_c +( +de +, +c +, + +) \ + +664 (( + +) % 4 == 0 \ + +665 ? + `__mempy_by4 + ( +de +, +c +, + +) - 1 \ + +666 : (( + +) % 2 == 0 \ + +667 ? + `__mempy_by2 + ( +de +, +c +, + +) - 1 \ + +668 : + `__mempy_byn + ( +de +, +c +, + +- 1)) + + ) + +671  + #py +( +de +, +c + + `__py + ((de), (c)) + + ) + +673  + #__py_a_sml +( +de +, +c +, + +) \ + +674 ( + `__exnsi__ + ({ union { \ + +675  +__ui +; \ + +676  +__usi +; \ + +677  +__uc +; \ + +678  +__c +; \ + +679 } * +__u + = (*( +de +); \ + +680  + +) \ + +683 +__u +-> +__uc + = '\0'; \ + +686 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 0); \ + +687 +__u + = + `__exnsi__ + ((*) __u + 1); \ + +690 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 0); \ + +691 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +692 +__u +-> +__uc + = '\0'; \ + +695 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +696 +__u + = + `__exnsi__ + ((*) __u + 3); \ + +699 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +700 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +701 +__u +-> +__uc + = '\0'; \ + +704 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +705 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +706 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 4); \ + +707 +__u + = + `__exnsi__ + ((*) __u + 1); \ + +710 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +711 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +712 +__u +-> +__usi + = + `__STRING_SMALL_GET16 + ( +c +, 4); \ + +713 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +714 +__u +-> +__uc + = '\0'; \ + +717 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 0); \ + +718 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +719 +__u +-> +__ui + = + `__STRING_SMALL_GET32 + ( +c +, 4); \ + +720 +__u + = + `__exnsi__ + ((*) __u + 3); \ + +723 (* +__u +; })) + + ) + +725 +__STRING_INLINE + * +__mempy_by4 + (* +__de +, +__cڡ + * +__c +, + +726 +size_t + +__ +); + +728 +__STRING_INLINE + * + +729 + $__mempy_by4 + (* +__de +, +__cڡ + * +__c +, +size_t + +__ +) + +731 * +__tmp + = +__de +; + +732  +__d0 +, +__d1 +; + +733 +__asm__ + +__vީe__ + + +741 : "=&r" ( +__d0 +), "" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__d1 +) + +742 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__ + / 4) + +744  +__tmp +; + +745 + } +} + +747 +__STRING_INLINE + * +__mempy_by2 + (* +__de +, +__cڡ + * +__c +, + +748 +size_t + +__ +); + +750 +__STRING_INLINE + * + +751 + $__mempy_by2 + (* +__de +, +__cڡ + * +__c +, +size_t + +__ +) + +753 * +__tmp + = +__de +; + +754  +__d0 +, +__d1 +; + +755 +__asm__ + +__vީe__ + + +768 : "=&q" ( +__d0 +), "" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__d1 +), + +769 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__de +) + +770 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__ + / 2), + +771 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +773  +__tmp + + 2; + +774 + } +} + +776 +__STRING_INLINE + * +__mempy_byn + (* +__de +, +__cڡ + * +__c +, + +777 +size_t + +__ +); + +779 +__STRING_INLINE + * + +780 + $__mempy_byn + (* +__de +, +__cڡ + * +__c +, +size_t + +__ +) + +782  +__d0 +, +__d1 +; + +783 * +__tmp + = +__de +; + +784 +__asm__ + +__vީe__ + + +795 : "=D" ( +__tmp +), "=&c" ( +__d0 +), "=&S" ( +__d1 +), + +796 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__de +) + +797 : "0" ( +__tmp +), "1" ( +__ +), "2" ( +__c +), + +798 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +800  +__tmp +; + +801 + } +} + +803 +__STRING_INLINE + * +__py_g + (* +__de +, +__cڡ + * +__c +); + +805 +__STRING_INLINE + * + +806 + $__py_g + (* +__de +, +__cڡ + * +__c +) + +808 * +__tmp + = +__de +; + +809  +__dummy +; + +810 +__asm__ + +__vީe__ + + +819 : "=&r" ( +__c +), "" ( +__tmp +), "=&q" ( +__dummy +), + +820 "=m" ( *(ru {  +__x +[0xfffffff]; } *) +__de +) + +821 : "0" ( +__c +), "1" ( +__tmp +), + +822 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__c +) + +824  +__tmp + - 1; + +825 + } +} + +830  + #_HAVE_STRING_ARCH_y + 1 + + ) + +831  + #y +( +de +, +c +, +n +) \ + +832 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +833 ? (( + ` + ( +c ++ 1 >(( +size_t +( +n +)) \ + +834 ? (* + `memy + ((*( +de +), \ + +835 ( +__cڡ + *( +c +), +n +) \ + +836 : + `__y_cg + (( +de +), ( +c +), + ` + (c+ 1, +n +))) \ + +837 : + `__y_gg + (( +de +), ( +c +), +n +))) + + ) + +838  + #__y_cg +( +de +, +c +, + +, +n +) \ + +839 ((( + +) % 4 == 0) \ + +840 ? + `__y_by4 + ( +de +, +c +, + +, +n +) \ + +841 : ((( + +) % 2 == 0) \ + +842 ? + `__y_by2 + ( +de +, +c +, + +, +n +) \ + +843 : + `__y_byn + ( +de +, +c +, + +, +n +))) + + ) + +845 +__STRING_INLINE + * +__y_by4 + (* +__de +, +__cڡ +  +__c +[], + +846 +size_t + +__ +, size_ +__n +); + +848 +__STRING_INLINE + * + +849 + $__y_by4 + (* +__de +, +__cڡ +  +__c +[], +size_t + +__ +, size_ +__n +) + +851 * +__tmp + = +__de +; + +852  +__dummy1 +, +__dummy2 +; + +853 +__asm__ + +__vީe__ + + +861 : "=&r" ( +__dummy1 +), "" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__dummy2 +), + +862 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__de +) + +863 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__ + / 4), + +864 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +866 ( + `memt + ( +__tmp +, '\0', +__n + - +__ +); + +867  +__de +; + +868 + } +} + +870 +__STRING_INLINE + * +__y_by2 + (* +__de +, +__cڡ +  +__c +[], + +871 +size_t + +__ +, size_ +__n +); + +873 +__STRING_INLINE + * + +874 + $__y_by2 + (* +__de +, +__cڡ +  +__c +[], +size_t + +__ +, size_ +__n +) + +876 * +__tmp + = +__de +; + +877  +__dummy1 +, +__dummy2 +; + +878 +__asm__ + +__vީe__ + + +891 : "=&q" ( +__dummy1 +), "" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__dummy2 +), + +892 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__de +) + +893 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__ + / 2), + +894 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +896 ( + `memt + ( +__tmp + + 2, '\0', +__n + - +__ +); + +897  +__de +; + +898 + } +} + +900 +__STRING_INLINE + * +__y_byn + (* +__de +, +__cڡ +  +__c +[], + +901 +size_t + +__ +, size_ +__n +); + +903 +__STRING_INLINE + * + +904 + $__y_byn + (* +__de +, +__cڡ +  +__c +[], +size_t + +__ +, size_ +__n +) + +906  +__d0 +, +__d1 +; + +907 * +__tmp + = +__de +; + +908 +__asm__ + +__vީe__ + + +919 : "=D" ( +__tmp +), "=&c" ( +__d0 +), "=&S" ( +__d1 +), + +920 "=m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__de +) + +921 : "1" ( +__ +), "0" ( +__tmp +),"2" ( +__c +), + +922 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +924 ( + `memt + ( +__tmp +, '\0', +__n + - +__ +); + +925  +__de +; + +926 + } +} + +928 +__STRING_INLINE + * +__y_gg + (* +__de +, +__cڡ + * +__c +, + +929 +size_t + +__n +); + +931 +__STRING_INLINE + * + +932 + $__y_gg + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +934 * +__tmp + = +__de +; + +935  +__dummy +; + +936 i( +__n + > 0) + +937 +__asm__ + +__vީe__ + + +953 : "=&r" ( +__c +), "=&r" ( +__tmp +), "=&q" ( +__dummy +), "=&r" ( +__n +) + +954 : "0" ( +__c +), "1" ( +__tmp +), "3" ( +__n +) + +957  +__de +; + +958 + } +} + +962  + #_HAVE_STRING_ARCH_rt + 1 + + ) + +963  + #rt +( +de +, +c +) \ + +964 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +965 ? + `__rt_c + (( +de +), ( +c +), + ` + (src) + 1) \ + +966 : + `__rt_g + (( +de +), ( +c +)))) + + ) + +968 +__STRING_INLINE + * +__rt_c + (* +__de +, +__cڡ +  +__c +[], + +969 +size_t + +__ +); + +971 +__STRING_INLINE + * + +972 + $__rt_c + (* +__de +, +__cڡ +  +__c +[], +size_t + +__ +) + +974 #ifde +__i686__ + + +975  +__d0 +; + +976 * +__tmp +; + +977 +__asm__ + +__vީe__ + + +979 : "=D" ( +__tmp +), "=&c" ( +__d0 +), + +980 "=m" ( *(ru {  +__x +[0xfffffff]; } *) +__de +) + +981 : "0" ( +__de +), "1" (0xffffffff), "a" (0), + +982 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +984 -- +__tmp +; + +986 * +__tmp + = +__de + - 1; + +987 +__asm__ + +__vީe__ + + +992 : "" ( +__tmp +), + +993 "=m" ( *(ru {  +__x +[0xfffffff]; } *) +__de +) + +994 : "0" ( +__tmp +), + +995 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ +]; } *) +__c +) + +998 ( + `memy + ( +__tmp +, +__c +, +__ +); + +999  +__de +; + +1000 + } +} + +1002 +__STRING_INLINE + * +__rt_g + (* +__de +, +__cڡ + * +__c +); + +1004 +__STRING_INLINE + * + +1005 + $__rt_g + (* +__de +, +__cڡ + * +__c +) + +1007 * +__tmp + = +__de + - 1; + +1008  +__dummy +; + +1009 +__asm__ + +__vީe__ + + +1021 : "=&q" ( +__dummy +), "=&r" ( +__tmp +), "=&r" ( +__c +), + +1022 "=m" ( *(ru {  +__x +[0xfffffff]; } *) +__de +) + +1023 : "1" ( +__tmp +), "2" ( +__c +), + +1024 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__c +) + +1026  +__de +; + +1027 + } +} + +1031  + #_HAVE_STRING_ARCH_t + 1 + + ) + +1032  + #t +( +de +, +c +, +n +) \ + +1033 ( + `__exnsi__ + ({ * +__de + = ( +de +); \ + +1034 + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +1035 ? ( + ` + ( +c +< (( +size_t +( +n +)) \ + +1036 ? + `rt + ( +__de +, ( +c +)) \ + +1037 : (*(*) + `__mempy + ( + `rchr + ( +__de +, '\0'), \ + +1038 ( +__cڡ + *( +c +), \ + +1039 ( +n +)0, +__de +)) \ + +1040 : + `__t_g + ( +__de +, ( +c +), ( +n +)); })) + + ) + +1042 +__STRING_INLINE + * +__t_g + (* +__de +, +__cڡ +  +__c +[], + +1043 +size_t + +__n +); + +1045 +__STRING_INLINE + * + +1046 + $__t_g + (* +__de +, +__cڡ +  +__c +[], +size_t + +__n +) + +1048 * +__tmp + = +__de +; + +1049  +__dummy +; + +1050 #ifde +__i686__ + + +1051 +__asm__ + +__vީe__ + + +1065 : "=&a" ( +__dummy +), "=&D" ( +__tmp +), "=&S" ( +__c +), "=&c" ( +__n +) + +1066 : "g" ( +__n +), "0" (0), "1" ( +__tmp +), "2" ( +__c +), "3" (0xffffffff) + +1069 -- +__tmp +; + +1070 +__asm__ + +__vީe__ + + +1087 : "=&q" ( +__dummy +), "=&r" ( +__tmp +), "=&r" ( +__c +), "=&r" ( +__n +) + +1088 : "1" ( +__tmp +), "2" ( +__c +), "3" ( +__n +) + +1091  +__de +; + +1092 + } +} + +1096  + #_HAVE_STRING_ARCH_rcmp + 1 + + ) + +1097  + #rcmp +( +s1 +, +s2 +) \ + +1098 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +s1 +&& __but_cڡt_( +s2 +) \ + +1099 && ( (( +s1 +)[0]!1 || + ` + (s1) >= 4) \ + +1100 && ( (( +s2 +)[0]!1 || + ` + (s2) >= 4) \ + +1101 ? + `memcmp + (( +__cڡ + *( +s1 +), (__cڡ *( +s2 +), \ + +1102 ( + ` + ( +s1 +< s( +s2 +) \ + +1103 ? + ` + ( +s1 +: s( +s2 +)) + 1) \ + +1104 : ( + `__but_cڡt_p + ( +s1 +) &&  ((s1)[0]) == 1 \ + +1105 &&  (( +s2 +)[0]=1 && + ` + ( +s1 +) < 4 \ + +1106 ? ( + `__but_cڡt_p + ( +s2 +) &&  ((s2)[0]) == 1 \ + +1107 ? + `__rcmp_cc + (( +__cڡ + *( +s1 +), \ + +1108 ( +__cڡ + *( +s2 +), \ + +1109 + ` + ( +s1 +)) \ + +1110 : + `__rcmp_cg + (( +__cڡ + *( +s1 +), \ + +1111 ( +__cڡ + *( +s2 +), \ + +1112 + ` + ( +s1 +))) \ + +1113 : ( + `__but_cڡt_p + ( +s2 +&&  (( +s1 +)[0]) == 1 \ + +1114 &&  (( +s2 +)[0]=1 && + ` + (s2) < 4 \ + +1115 ? ( + `__but_cڡt_p + ( +s1 +) \ + +1116 ? + `__rcmp_cc + (( +__cڡ + *( +s1 +), \ + +1117 ( +__cڡ + *( +s2 +), \ + +1118 + ` + ( +s2 +)) \ + +1119 : + `__rcmp_gc + (( +__cڡ + *( +s1 +), \ + +1120 ( +__cڡ + *( +s2 +), \ + +1121 + ` + ( +s2 +))) \ + +1122 : + `__rcmp_gg + (( +s1 +), ( +s2 +)))))) + + ) + +1124  + #__rcmp_cc +( +s1 +, +s2 +, +l +) \ + +1125 ( + `__exnsi__ + ({  +__su + = ( +s1 +)[0] - ( +s2 +)[0]; \ + +1126 i( +l + > 0 && +__su + == 0) \ + +1128 +__su + = ( +s1 +)[1] - ( +s2 +)[1]; \ + +1129 i( +l + > 1 && +__su + == 0) \ + +1131 +__su + = ( +s1 +)[2] - ( +s2 +)[2]; \ + +1132 i( +l + > 2 && +__su + == 0) \ + +1133 +__su + = ( +s1 +)[3] - ( +s2 +)[3]; \ + +1136 +__su +; })) + + ) + +1138  + #__rcmp_cg +( +s1 +, +s2 +, +l1 +) \ + +1139 ( + `__exnsi__ + ({ +__cڡ + * +__s2 + = ( +s2 +); \ + +1140  +__su + = ( +s1 +)[0] - +__s2 +[0]; \ + +1141 i( +l1 + > 0 && +__su + == 0) \ + +1143 +__su + = ( +s1 +)[1] - +__s2 +[1]; \ + +1144 i( +l1 + > 1 && +__su + == 0) \ + +1146 +__su + = ( +s1 +)[2] - +__s2 +[2]; \ + +1147 i( +l1 + > 2 && +__su + == 0) \ + +1148 +__su + = ( +s1 +)[3] - +__s2 +[3]; \ + +1151 +__su +; })) + + ) + +1153  + #__rcmp_gc +( +s1 +, +s2 +, +l2 +) \ + +1154 ( + `__exnsi__ + ({ +__cڡ + * +__s1 + = ( +s1 +); \ + +1155  +__su + = +__s1 +[0] - ( +s2 +)[0]; \ + +1156 i( +l2 + > 0 && +__su + == 0) \ + +1158 +__su + = +__s1 +[1] - ( +s2 +)[1]; \ + +1159 i( +l2 + > 1 && +__su + == 0) \ + +1161 +__su + = +__s1 +[2] - ( +s2 +)[2]; \ + +1162 i( +l2 + > 2 && +__su + == 0) \ + +1163 +__su + = +__s1 +[3] - ( +s2 +)[3]; \ + +1166 +__su +; })) + + ) + +1168 +__STRING_INLINE +  +__rcmp_gg + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +); + +1170 +__STRING_INLINE +  + +1171 + $__rcmp_gg + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +1173  +__s +; + +1174 +__asm__ + +__vީe__ + + +1190 : "=q" ( +__s +), "=&r" ( +__s1 +), "=&r" ( +__s2 +) + +1191 : "1" ( +__s1 +), "2" ( +__s2 +), + +1192 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s1 +), + +1193 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s2 +) + +1195  +__s +; + +1196 + } +} + +1200  + #_HAVE_STRING_ARCH_cmp + 1 + + ) + +1201  + #cmp +( +s1 +, +s2 +, +n +) \ + +1202 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +s1 +&& + ` + (s1< (( +size_t +( +n +)) \ + +1203 ? + `rcmp + (( +s1 +), ( +s2 +)) \ + +1204 : ( + `__but_cڡt_p + ( +s2 +&& + ` + (s2< (( +size_t +( +n +))\ + +1205 ? + `rcmp + (( +s1 +), ( +s2 +)) \ + +1206 : + `__cmp_g + (( +s1 +), ( +s2 +), ( +n +))))) + + ) + +1208 +__STRING_INLINE +  +__cmp_g + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, + +1209 +size_t + +__n +); + +1211 +__STRING_INLINE +  + +1212 + $__cmp_g + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +1214  +__s +; + +1215 +__asm__ + +__vީe__ + + +1234 : "=q" ( +__s +), "=&r" ( +__s1 +), "=&r" ( +__s2 +), "=&r" ( +__n +) + +1235 : "1" ( +__s1 +), "2" ( +__s2 +), "3" ( +__n +), + +1236 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s1 +), + +1237 "m" ( *(ru { +__exnsi__ +  +__x +[ +__n +]; } *) +__s2 +) + +1239  +__s +; + +1240 + } +} + +1244  + #_HAVE_STRING_ARCH_rchr + 1 + + ) + +1245  + #_USE_STRING_ARCH_rchr + 1 + + ) + +1246  + #rchr +( +s +, +c +) \ + +1247 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +1248 ? (( +c +) == '\0' \ + +1249 ? (* + `__wmemchr + (( +s +), ( +c +)) \ + +1250 : + `__rchr_c + (( +s +), (( +c +) & 0xff) << 8)) \ + +1251 : + `__rchr_g + (( +s +), ( +c +)))) + + ) + +1253 +__STRING_INLINE + * +__rchr_c + ( +__cڡ + * +__s +,  +__c +); + +1255 +__STRING_INLINE + * + +1256 + $__rchr_c + ( +__cڡ + * +__s +,  +__c +) + +1258  +__d0 +; + +1259 * +__s +; + +1260 +__asm__ + +__vީe__ + + +1270 : "" ( +__s +), "=&a" ( +__d0 +) + +1271 : "0" ( +__s +), "1" ( +__c +), + +1272 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1274  +__s +; + +1275 + } +} + +1277 +__STRING_INLINE + * +__rchr_g + ( +__cڡ + * +__s +,  +__c +); + +1279 +__STRING_INLINE + * + +1280 + $__rchr_g + ( +__cڡ + * +__s +,  +__c +) + +1282  +__d0 +; + +1283 * +__s +; + +1284 +__asm__ + +__vީe__ + + +1295 : "" ( +__s +), "=&a" ( +__d0 +) + +1296 : "0" ( +__s +), "1" ( +__c +), + +1297 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1299  +__s +; + +1300 + } +} + +1304  + #_HAVE_STRING_ARCH_rchul + 1 + + ) + +1305  + #__rchul +( +s +, +c +) \ + +1306 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +1307 ? (( +c +) == '\0' \ + +1308 ? (* + `__wmemchr + (( +s +), +c +) \ + +1309 : + `__rchul_c + (( +s +), (( +c +) & 0xff) << 8)) \ + +1310 : + `__rchul_g + (( +s +), +c +))) + + ) + +1312 +__STRING_INLINE + * +__rchul_c + ( +__cڡ + * +__s +,  +__c +); + +1314 +__STRING_INLINE + * + +1315 + $__rchul_c + ( +__cڡ + * +__s +,  +__c +) + +1317  +__d0 +; + +1318 * +__s +; + +1319 +__asm__ + +__vީe__ + + +1329 : "" ( +__s +), "=&a" ( +__d0 +) + +1330 : "0" ( +__s +), "1" ( +__c +), + +1331 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1333  +__s +; + +1334 + } +} + +1336 +__STRING_INLINE + * +__rchul_g + ( +__cڡ + * +__s +,  +__c +); + +1338 +__STRING_INLINE + * + +1339 + $__rchul_g + ( +__cڡ + * +__s +,  +__c +) + +1341  +__d0 +; + +1342 * +__s +; + +1343 +__asm__ + +__vީe__ + + +1354 : "" ( +__s +), "=&a" ( +__d0 +) + +1355 : "0" ( +__s +), "1" ( +__c +), + +1356 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1358  +__s +; + +1359 + } +} + +1360 #ifde +__USE_GNU + + +1361  + #rchul +( +s +, +c + + `__rchul + ((s), (c)) + + ) + +1365 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +1367  + #_HAVE_STRING_ARCH_dex + 1 + + ) + +1368  + #dex +( +s +, +c +) \ + +1369 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +1370 ? + `__rchr_c + (( +s +), (( +c +) & 0xff) << 8) \ + +1371 : + `__rchr_g + (( +s +), ( +c +)))) + + ) + +1376  + #_HAVE_STRING_ARCH_chr + 1 + + ) + +1377  + #chr +( +s +, +c +) \ + +1378 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +1379 ? + `__chr_c + (( +s +), (( +c +) & 0xff) << 8) \ + +1380 : + `__chr_g + (( +s +), ( +c +)))) + + ) + +1382 #ifde +__i686__ + + +1383 +__STRING_INLINE + * +__chr_c + ( +__cڡ + * +__s +,  +__c +); + +1385 +__STRING_INLINE + * + +1386 + $__chr_c + ( +__cڡ + * +__s +,  +__c +) + +1388  +__d0 +, +__d1 +; + +1389 * +__s +; + +1390 +__asm__ + +__vީe__ + + +1398 : "=d" ( +__s +), "=&S" ( +__d0 +), "=&a" ( +__d1 +) + +1399 : "0" (1), "1" ( +__s +), "2" ( +__c +), + +1400 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1402  +__s + - 1; + +1403 + } +} + +1405 +__STRING_INLINE + * +__chr_g + ( +__cڡ + * +__s +,  +__c +); + +1407 +__STRING_INLINE + * + +1408 + $__chr_g + ( +__cڡ + * +__s +,  +__c +) + +1410  +__d0 +, +__d1 +; + +1411 * +__s +; + +1412 +__asm__ + +__vީe__ + + +1421 : "=d" ( +__s +), "=&S" ( +__d0 +), "=&a" ( +__d1 +) + +1422 : "0" (1), "1" ( +__s +), "2" ( +__c +), + +1423 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1425  +__s + - 1; + +1426 + } +} + +1428 +__STRING_INLINE + * +__chr_c + ( +__cڡ + * +__s +,  +__c +); + +1430 +__STRING_INLINE + * + +1431 + $__chr_c + ( +__cڡ + * +__s +,  +__c +) + +1433  +__d0 +, +__d1 +; + +1434 * +__s +; + +1435 +__asm__ + +__vީe__ + + +1445 : "=d" ( +__s +), "=&S" ( +__d0 +), "=&a" ( +__d1 +) + +1446 : "0" (0), "1" ( +__s +), "2" ( +__c +), + +1447 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1449  +__s +; + +1450 + } +} + +1452 +__STRING_INLINE + * +__chr_g + ( +__cڡ + * +__s +,  +__c +); + +1454 +__STRING_INLINE + * + +1455 + $__chr_g + ( +__cڡ + * +__s +,  +__c +) + +1457  +__d0 +, +__d1 +; + +1458 * +__s +; + +1459 +__asm__ + +__vީe__ + + +1470 : "" ( +__s +), "=&S" ( +__d0 +), "=&a" ( +__d1 +) + +1471 : "0" (0), "1" ( +__s +), "2" ( +__c +), + +1472 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1474  +__s +; + +1475 + } +} + +1479 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +1481  + #_HAVE_STRING_ARCH_rdex + 1 + + ) + +1482  + #rdex +( +s +, +c +) \ + +1483 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +1484 ? + `__chr_c + (( +s +), (( +c +) & 0xff) << 8) \ + +1485 : + `__chr_g + (( +s +), ( +c +)))) + + ) + +1491  + #_HAVE_STRING_ARCH_rcn + 1 + + ) + +1492  + #rcn +( +s +, +je +) \ + +1493 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +je +) &&  ((reject)[0]) == 1 \ + +1494 ? (( +je +)[0] == '\0' \ + +1495 ? + ` + ( +s +) \ + +1496 : (( +je +)[1] == '\0' \ + +1497 ? + `__rcn_c1 + (( +s +), ((( +je +)[0] << 8) & 0xff00)) \ + +1498 : + `__rcn_cg + (( +s +), ( +je +), + ` + (reject)))) \ + +1499 : + `__rcn_g + (( +s +), ( +je +)))) + + ) + +1501 +__STRING_INLINE + +size_t + +__rcn_c1 + ( +__cڡ + * +__s +,  +__je +); + +1503 #ide +_FORCE_INLINES + + +1504 +__STRING_INLINE + +size_t + + +1505 + $__rcn_c1 + ( +__cڡ + * +__s +,  +__je +) + +1507  +__d0 +; + +1508 * +__s +; + +1509 +__asm__ + +__vީe__ + + +1518 : "" ( +__s +), "=&a" ( +__d0 +) + +1519 : "0" ( +__s +), "1" ( +__je +), + +1520 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1522  ( +__s + - 1- +__s +; + +1523 + } +} + +1526 +__STRING_INLINE + +size_t + +__rcn_cg + ( +__cڡ + * +__s +, __cڡ  +__je +[], + +1527 +size_t + +__je_n +); + +1529 +__STRING_INLINE + +size_t + + +1530 + $__rcn_cg + ( +__cڡ + * +__s +, __cڡ  +__je +[], +size_t + +__je_n +) + +1532  +__d0 +, +__d1 +, +__d2 +; + +1533  +__cڡ + * +__s +; + +1534 +__asm__ + +__vީe__ + + +1545 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +) + +1546 : "0" ( +__s +), "d" ( +__je +), "g" ( +__je_n +) + +1548  ( +__s + - 1- +__s +; + +1549 + } +} + +1551 +__STRING_INLINE + +size_t + +__rcn_g + ( +__cڡ + * +__s +, __cڡ * +__je +); + +1552 #ifde +__PIC__ + + +1554 +__STRING_INLINE + +size_t + + +1555 + $__rcn_g + ( +__cڡ + * +__s +, __cڡ * +__je +) + +1557  +__d0 +, +__d1 +, +__d2 +; + +1558  +__cڡ + * +__s +; + +1559 +__asm__ + +__vީe__ + + +1576 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +) + +1577 : "r" ( +__je +), "0" ( +__s +), "1" (0), "2" (0xffffffff) + +1579  ( +__s + - 1- +__s +; + +1580 + } +} + +1582 +__STRING_INLINE + +size_t + + +1583 + $__rcn_g + ( +__cڡ + * +__s +, __cڡ * +__je +) + +1585  +__d0 +, +__d1 +, +__d2 +, +__d3 +; + +1586  +__cڡ + * +__s +; + +1587 +__asm__ + +__vީe__ + + +1601 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +), "=&d" ( +__d3 +) + +1602 : "0" ( +__s +), "1" (0), "2" (0xffffffff), "3" ( +__je +), "b" (__reject) + +1605  ( +__s + - 1- +__s +; + +1606 + } +} + +1612  + #_HAVE_STRING_ARCH_rn + 1 + + ) + +1613  + #rn +( +s +, +ac +) \ + +1614 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +ac +) &&  ((accept)[0]) == 1 \ + +1615 ? (( +ac +)[0] == '\0' \ + +1616 ? ((( +s +), 0) \ + +1617 : (( +ac +)[1] == '\0' \ + +1618 ? + `__rn_c1 + (( +s +), ((( +ac +)[0] << 8 ) & 0xff00)) \ + +1619 : + `__rn_cg + (( +s +), ( +ac +), + ` + (accept)))) \ + +1620 : + `__rn_g + (( +s +), ( +ac +)))) + + ) + +1622 #ide +_FORCE_INLINES + + +1623 +__STRING_INLINE + +size_t + +__rn_c1 + ( +__cڡ + * +__s +,  +__ac +); + +1625 +__STRING_INLINE + +size_t + + +1626 + $__rn_c1 + ( +__cڡ + * +__s +,  +__ac +) + +1628  +__d0 +; + +1629 * +__s +; + +1631 +__asm__ + +__vީe__ + + +1637 : "" ( +__s +), "=&q" ( +__d0 +) + +1638 : "0" ( +__s +), "1" ( +__ac +), + +1639 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +) + +1641  ( +__s + - 1- +__s +; + +1642 + } +} + +1645 +__STRING_INLINE + +size_t + +__rn_cg + ( +__cڡ + * +__s +, __cڡ  +__ac +[], + +1646 +size_t + +__ac_n +); + +1648 +__STRING_INLINE + +size_t + + +1649 + $__rn_cg + ( +__cڡ + * +__s +, __cڡ  +__ac +[], +size_t + +__ac_n +) + +1651  +__d0 +, +__d1 +, +__d2 +; + +1652  +__cڡ + * +__s +; + +1653 +__asm__ + +__vީe__ + + +1664 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +) + +1665 : "0" ( +__s +), "g" ( +__ac +), "g" ( +__ac_n +), + +1668 "m" ( *(ru {  +__x +[0xfffffff]; } *) +__s +), + +1669 "m" ( *(ru { +__exnsi__ +  +__x +[ +__ac_n +]; } *) +__ac +) + +1671  ( +__s + - 1- +__s +; + +1672 + } +} + +1674 +__STRING_INLINE + +size_t + +__rn_g + ( +__cڡ + * +__s +, __cڡ * +__ac +); + +1675 #ifde +__PIC__ + + +1677 +__STRING_INLINE + +size_t + + +1678 + $__rn_g + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +1680  +__d0 +, +__d1 +, +__d2 +; + +1681  +__cڡ + * +__s +; + +1682 +__asm__ + +__vީe__ + + +1698 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +) + +1699 : "d" ( +__ac +), "0" ( +__s +), "1" (0), "2" (0xffffffff), "3" (__accept) + +1701  ( +__s + - 1- +__s +; + +1702 + } +} + +1704 +__STRING_INLINE + +size_t + + +1705 + $__rn_g + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +1707  +__d0 +, +__d1 +, +__d2 +, +__d3 +; + +1708  +__cڡ + * +__s +; + +1709 +__asm__ + +__vީe__ + + +1723 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +), "=&d" ( +__d3 +) + +1724 : "0" ( +__s +), "1" (0), "2" (0xffffffff), "3" ( +__ac +), "b" (__accept) + +1726  ( +__s + - 1- +__s +; + +1727 + } +} + +1732  + #_HAVE_STRING_ARCH_brk + 1 + + ) + +1733  + #brk +( +s +, +ac +) \ + +1734 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +ac +) &&  ((accept)[0]) == 1 \ + +1735 ? (( +ac +)[0] == '\0' \ + +1736 ? ((( +s +), (*) 0) \ + +1737 : (( +ac +)[1] == '\0' \ + +1738 ? + `rchr + (( +s +), ( +ac +)[0]) \ + +1739 : + `__brk_cg + (( +s +), ( +ac +), + ` + (accept)))) \ + +1740 : + `__brk_g + (( +s +), ( +ac +)))) + + ) + +1742 +__STRING_INLINE + * +__brk_cg + ( +__cڡ + * +__s +, __cڡ  +__ac +[], + +1743 +size_t + +__ac_n +); + +1745 +__STRING_INLINE + * + +1746 + $__brk_cg + ( +__cڡ + * +__s +, __cڡ  +__ac +[], +size_t + +__ac_n +) + +1748  +__d0 +, +__d1 +, +__d2 +; + +1749 * +__s +; + +1750 +__asm__ + +__vީe__ + + +1765 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +) + +1766 : "0" ( +__s +), "d" ( +__ac +), "g" ( +__ac_n +) + +1768  +__s +; + +1769 + } +} + +1771 +__STRING_INLINE + * +__brk_g + ( +__cڡ + * +__s +, __cڡ * +__ac +); + +1772 #ifde +__PIC__ + + +1774 +__STRING_INLINE + * + +1775 + $__brk_g + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +1777  +__d0 +, +__d1 +, +__d2 +; + +1778 * +__s +; + +1779 +__asm__ + +__vީe__ + + +1800 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&D" ( +__d2 +) + +1801 : "d" ( +__ac +), "0" ( +__s +), "1" (0), "2" (0xffffffff) + +1803  +__s +; + +1804 + } +} + +1806 +__STRING_INLINE + * + +1807 + $__brk_g + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +1809  +__d0 +, +__d1 +, +__d2 +, +__d3 +; + +1810 * +__s +; + +1811 +__asm__ + +__vީe__ + + +1830 : "=S" ( +__s +), "=&a" ( +__d0 +), "=&c" ( +__d1 +), "=&d" ( +__d2 +), "=&D" ( +__d3 +) + +1831 : "0" ( +__s +), "1" (0), "2" (0xffffffff), "b" ( +__ac +) + +1833  +__s +; + +1834 + } +} + +1839  + #_HAVE_STRING_ARCH_rr + 1 + + ) + +1840  + #rr +( +hayack +, +ed +) \ + +1841 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +ed +) &&  ((needle)[0]) == 1 \ + +1842 ? (( +ed +)[0] == '\0' \ + +1843 ? ( +hayack +) \ + +1844 : (( +ed +)[1] == '\0' \ + +1845 ? + `rchr + (( +hayack +), ( +ed +)[0]) \ + +1846 : + `__rr_cg + (( +hayack +), ( +ed +), \ + +1847 + ` + ( +ed +)))) \ + +1848 : + `__rr_g + (( +hayack +), ( +ed +)))) + + ) + +1852 +__STRING_INLINE + * +__rr_cg + ( +__cڡ + * +__hayack +, __cڡ  +__ed +[], + +1853 +size_t + +__ed_n +); + +1855 +__STRING_INLINE + * + +1856 + $__rr_cg + ( +__cڡ + * +__hayack +, __cڡ  +__ed +[], + +1857 +size_t + +__ed_n +) + +1859  +__d0 +, +__d1 +, +__d2 +; + +1860 * +__s +; + +1861 +__asm__ + +__vީe__ + + +1874 : "=&a" ( +__s +), "=&S" ( +__d0 +), "=&D" ( +__d1 +), "=&c" ( +__d2 +) + +1875 : "g" ( +__ed_n +), "1" ( +__hayack +), "d" ( +__ed +) + +1877  +__s +; + +1878 + } +} + +1880 +__STRING_INLINE + * +__rr_g + ( +__cڡ + * +__hayack +, __cڡ * +__ed +); + +1881 #ifde +__PIC__ + + +1883 +__STRING_INLINE + * + +1884 + $__rr_g + ( +__cڡ + * +__hayack +, __cڡ * +__ed +) + +1886  +__d0 +, +__d1 +, +__d2 +; + +1887 * +__s +; + +1888 +__asm__ + +__vީe__ + + +1907 : "=&a" ( +__s +), "=&c" ( +__d0 +), "=&S" ( +__d1 +), "=&D" ( +__d2 +) + +1908 : "0" (0), "1" (0xffffffff), "2" ( +__hayack +), "3" ( +__ed +), + +1909 "d" ( +__ed +) + +1911  +__s +; + +1912 + } +} + +1914 +__STRING_INLINE + * + +1915 + $__rr_g + ( +__cڡ + * +__hayack +, __cڡ * +__ed +) + +1917  +__d0 +, +__d1 +, +__d2 +, +__d3 +; + +1918 * +__s +; + +1919 +__asm__ + +__vީe__ + + +1936 : "=&a" ( +__s +), "=&c" ( +__d0 +), "=&S" ( +__d1 +), "=&D" ( +__d2 +), "=&d" ( +__d3 +) + +1937 : "0" (0), "1" (0xffffffff), "2" ( +__hayack +), "3" ( +__ed +), + +1938 "b" ( +__ed +) + +1940  +__s +; + +1941 + } +} + +1947 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +1948 #ifde +__i686__ + + +1949  + #_HAVE_STRING_ARCH_ffs + 1 + + ) + +1950  + #ffs +( +wd +( + `__but_cڡt_p + (word) \ + +1951 ? + `__but_ffs + ( +wd +) \ + +1952 : ({  +__t +, +__tmp +; \ + +1953 +__asm__ + +__vީe__ + \ + +1956 : "=&r" ( +__t +), "" ( +__tmp +) \ + +1957 : "rm" ( +wd +), "1" (-1)); \ + +1958 +__t + + 1; })) + + ) + +1960 #ide +ff + + +1961  + #ff +( +wd + + `ffs +(wd) + + ) + +1966 #ide +_FORCE_INLINES + + +1967 #unde +__STRING_INLINE + + + @/usr/include/bits/string2.h + +21 #ide +_STRING_H + + +25 #i! +defed + +__NO_STRING_INLINES + && !defed +__BOUNDED_POINTERS__ + + +42 #ide +__STRING_INLINE + + +43 #ifde +__lulus + + +44  + #__STRING_INLINE + +le + + + ) + +46  + #__STRING_INLINE + +__le + + + ) + +50 #i +_STRING_ARCH_uligd + + +52  + ~ + +53  + ~ + +55 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +56  + #__STRING2_SMALL_GET16 +( +c +, +idx +) \ + +57 ((( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1] << 8 \ + +58 | (( +__cڡ + *(__cڡ *( +c +))[ +idx +]) + + ) + +59  + #__STRING2_SMALL_GET32 +( +c +, +idx +) \ + +60 ((((( +__cڡ + *(__cڡ *( +c +))[ +idx + + 3] << 8 \ + +61 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 2]) << 8 \ + +62 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1]) << 8 \ + +63 | (( +__cڡ + *(__cڡ *( +c +))[ +idx +]) + + ) + +65  + #__STRING2_SMALL_GET16 +( +c +, +idx +) \ + +66 ((( +__cڡ + *(__cڡ *( +c +))[ +idx +] << 8 \ + +67 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1]) + + ) + +68  + #__STRING2_SMALL_GET32 +( +c +, +idx +) \ + +69 ((((( +__cڡ + *(__cڡ *( +c +))[ +idx +] << 8 \ + +70 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1]) << 8 \ + +71 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 2]) << 8 \ + +72 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 3]) + + ) + +77  + #__STRING2_COPY_TYPE +( +N +) \ + +78 ru {  +__r +[ +N +]; } \ + +79 + t__ibu__ + (( + t__cked__ +) + t__STRING2_COPY_ARR +## + tN + + + ) + +80 + t__STRING2_COPY_TYPE + (2); + +81 +__STRING2_COPY_TYPE + (3); + +82 +__STRING2_COPY_TYPE + (4); + +83 +__STRING2_COPY_TYPE + (5); + +84 +__STRING2_COPY_TYPE + (6); + +85 +__STRING2_COPY_TYPE + (7); + +86 +__STRING2_COPY_TYPE + (8); + +87 #unde +__STRING2_COPY_TYPE + + +93  + #__rg2_1br_p +( +__x +) \ + +94 (( +size_t +)(cڡ *)(( +__x ++ 1- (size_t)(cڡ *)(__x=1) + + ) + +97 #i! +defed + +_HAVE_STRING_ARCH_memt + + +98 #i! +__GNUC_PREREQ + (3, 0) + +99 #i +_STRING_ARCH_uligd + + +100  + #memt +( +s +, +c +, +n +) \ + +101 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +n +) && (n) <= 16 \ + +102 ? (( +n +) == 1 \ + +103 ? + `__memt_1 + ( +s +, +c +) \ + +104 : + `__memt_gc + ( +s +, +c +, +n +)) \ + +105 : ( + `__but_cڡt_p + ( +c +) && (c) == '\0' \ + +106 ? ({ * +__s + = ( +s +); + `__bzo + (__s, +n +); __s; }) \ + +107 : + `memt + ( +s +, +c +, +n +)))) + + ) + +109  + #__memt_1 +( +s +, +c +({ * +__s + = (s); \ + +110 *(( +__ut8_t + * +__s +(__ut8_t( +c +); __s; }) + + ) + +112  + #__memt_gc +( +s +, +c +, +n +) \ + +113 ({ * +__s + = ( +s +); \ + +115  +__ui +; \ + +116  +__usi +; \ + +117  +__uc +; \ + +118 } * +__u + = +__s +; \ + +119 +__ut8_t + +__c + = (__ut8_t( +c +); \ + +122 (( +n +)) \ + +125 +__u +-> +__ui + = +__c + * 0x01010101; \ + +126 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +128 +__u +-> +__ui + = +__c + * 0x01010101; \ + +129 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +131 +__u +-> +__ui + = +__c + * 0x01010101; \ + +132 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +134 +__u +-> +__usi + = ( +__c + * 0x0101; \ + +135 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +136 +__u +-> +__uc + = ( +__c +; \ + +140 +__u +-> +__ui + = +__c + * 0x01010101; \ + +141 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +143 +__u +-> +__ui + = +__c + * 0x01010101; \ + +144 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +146 +__u +-> +__ui + = +__c + * 0x01010101; \ + +147 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +149 +__u +-> +__usi + = ( +__c + * 0x0101; \ + +153 +__u +-> +__ui + = +__c + * 0x01010101; \ + +154 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +156 +__u +-> +__ui + = +__c + * 0x01010101; \ + +157 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +159 +__u +-> +__ui + = +__c + * 0x01010101; \ + +160 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +162 +__u +-> +__uc + = ( +__c +; \ + +166 +__u +-> +__ui + = +__c + * 0x01010101; \ + +167 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +169 +__u +-> +__ui + = +__c + * 0x01010101; \ + +170 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +172 +__u +-> +__ui + = +__c + * 0x01010101; \ + +173 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +175 +__u +-> +__ui + = +__c + * 0x01010101; \ + +180 +__s +; }) + + ) + +182  + #memt +( +s +, +c +, +n +) \ + +183 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) && (c) == '\0' \ + +184 ? ({ * +__s + = ( +s +); + `__bzo + (__s, +n +); __s; }) \ + +185 : + `memt + ( +s +, +c +, +n +))) + + ) + +194 #i +__GNUC_PREREQ + (2, 91) + +195  + #__bzo +( +s +, +n + + `__but_memt + (s, '\0',) + + ) + +203 #ifde +__USE_GNU + + +204 #i! +defed + +_HAVE_STRING_ARCH_mempy + || defed +_FORCE_INLINES + + +205 #ide +_HAVE_STRING_ARCH_mempy + + +206 #i +__GNUC_PREREQ + (3, 4) + +207  + #__mempy +( +de +, +c +, +n + + `__but_mempy + (de, src,) + + ) + +208 #i +__GNUC_PREREQ + (3, 0) + +209  + #__mempy +( +de +, +c +, +n +) \ + +210 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +211 && + `__rg2_1br_p + ( +c +&& +n + <= 8 \ + +212 ? + `__but_memy + ( +de +, +c +, +n +) + (n) \ + +213 : + `__mempy + ( +de +, +c +, +n +))) + + ) + +215  + #__mempy +( +de +, +c +, +n +) \ + +216 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +217 && + `__rg2_1br_p + ( +c +&& +n + <= 8 \ + +218 ? + `__mempy_sml + ( +de +, + `__mempy_gs + ( +c +), +n +) \ + +219 : + `__mempy + ( +de +, +c +, +n +))) + + ) + +223  + #mempy +( +de +, +c +, +n + + `__mempy + (de, src,) + + ) + +226 #i! +__GNUC_PREREQ + (3, 0|| +defed + +_FORCE_INLINES + + +227 #i +_STRING_ARCH_uligd + + +228 #ide +_FORCE_INLINES + + +229  + #__mempy_gs +( +c +) \ + +230 (( +__cڡ + *( +c +))[0], ((__const *) (src))[2], \ + +231 (( +__cڡ + *( +c +))[4], ((__const *) (src))[6], \ + +232 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 0), \ + +233 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 4), \ + +234 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 0), \ + +235 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 4) + + ) + +237 +__STRING_INLINE + * +__mempy_sml + (*, , , , , + +238 +__ut16_t +, __ut16_t, +__ut32_t +, + +239 +__ut32_t +, +size_t +); + +240 +__STRING_INLINE + * + +241 + $__mempy_sml + (* +__de1 +, + +242  +__c0_1 +,  +__c2_1 +,  +__c4_1 +,  +__c6_1 +, + +243 +__ut16_t + +__c0_2 +, __ut16_ +__c4_2 +, + +244 +__ut32_t + +__c0_4 +, __ut32_ +__c4_4 +, + +245 +size_t + +__ +) + +248 +__ut32_t + +__ui +; + +249 +__ut16_t + +__usi +; + +250  +__uc +; + +251  +__c +; + +252 } * +__u + = +__de1 +; + +253 ( +__ +) + +256 +__u +-> +__c + = +__c0_1 +; + +257 +__u + = + `__exnsi__ + ((*) __u + 1); + +260 +__u +-> +__usi + = +__c0_2 +; + +261 +__u + = + `__exnsi__ + ((*) __u + 2); + +264 +__u +-> +__usi + = +__c0_2 +; + +265 +__u + = + `__exnsi__ + ((*) __u + 2); + +266 +__u +-> +__c + = +__c2_1 +; + +267 +__u + = + `__exnsi__ + ((*) __u + 1); + +270 +__u +-> +__ui + = +__c0_4 +; + +271 +__u + = + `__exnsi__ + ((*) __u + 4); + +274 +__u +-> +__ui + = +__c0_4 +; + +275 +__u + = + `__exnsi__ + ((*) __u + 4); + +276 +__u +-> +__c + = +__c4_1 +; + +277 +__u + = + `__exnsi__ + ((*) __u + 1); + +280 +__u +-> +__ui + = +__c0_4 +; + +281 +__u + = + `__exnsi__ + ((*) __u + 4); + +282 +__u +-> +__usi + = +__c4_2 +; + +283 +__u + = + `__exnsi__ + ((*) __u + 2); + +286 +__u +-> +__ui + = +__c0_4 +; + +287 +__u + = + `__exnsi__ + ((*) __u + 4); + +288 +__u +-> +__usi + = +__c4_2 +; + +289 +__u + = + `__exnsi__ + ((*) __u + 2); + +290 +__u +-> +__c + = +__c6_1 +; + +291 +__u + = + `__exnsi__ + ((*) __u + 1); + +294 +__u +-> +__ui + = +__c0_4 +; + +295 +__u + = + `__exnsi__ + ((*) __u + 4); + +296 +__u +-> +__ui + = +__c4_4 +; + +297 +__u + = + `__exnsi__ + ((*) __u + 4); + +300  (* +__u +; + +301 + } +} + +303 #ide +_FORCE_INLINES + + +304  + #__mempy_gs +( +c +) \ + +305 (( +__cڡ + *( +c +))[0], \ + +306 + `__exnsi__ + (( +__STRING2_COPY_ARR2 +) \ + +307 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1] } }), \ + +308 + `__exnsi__ + (( +__STRING2_COPY_ARR3 +) \ + +309 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +310 (( +__cڡ + *( +c +))[2] } }), \ + +311 + `__exnsi__ + (( +__STRING2_COPY_ARR4 +) \ + +312 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +313 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3] } }), \ + +314 + `__exnsi__ + (( +__STRING2_COPY_ARR5 +) \ + +315 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +316 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +317 (( +__cڡ + *( +c +))[4] } }), \ + +318 + `__exnsi__ + (( +__STRING2_COPY_ARR6 +) \ + +319 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +320 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +321 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5] } }), \ + +322 + `__exnsi__ + (( +__STRING2_COPY_ARR7 +) \ + +323 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +324 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +325 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +326 (( +__cڡ + *( +c +))[6] } }), \ + +327 + `__exnsi__ + (( +__STRING2_COPY_ARR8 +) \ + +328 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +329 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +330 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +331 (( +__cڡ + *( +c +))[6], ((__cڡ *(c))[7] } }) + + ) + +333 +__STRING_INLINE + * +__mempy_sml + (*, , +__STRING2_COPY_ARR2 +, + +334 +__STRING2_COPY_ARR3 +, + +335 +__STRING2_COPY_ARR4 +, + +336 +__STRING2_COPY_ARR5 +, + +337 +__STRING2_COPY_ARR6 +, + +338 +__STRING2_COPY_ARR7 +, + +339 +__STRING2_COPY_ARR8 +, +size_t +); + +340 +__STRING_INLINE + * + +341 + $__mempy_sml + (* +__de +,  +__c1 +, + +342 +__STRING2_COPY_ARR2 + +__c2 +, +__STRING2_COPY_ARR3 + +__c3 +, + +343 +__STRING2_COPY_ARR4 + +__c4 +, +__STRING2_COPY_ARR5 + +__c5 +, + +344 +__STRING2_COPY_ARR6 + +__c6 +, +__STRING2_COPY_ARR7 + +__c7 +, + +345 +__STRING2_COPY_ARR8 + +__c8 +, +size_t + +__ +) + +348  +__c +; + +349 +__STRING2_COPY_ARR2 + +__s2 +; + +350 +__STRING2_COPY_ARR3 + +__s3 +; + +351 +__STRING2_COPY_ARR4 + +__s4 +; + +352 +__STRING2_COPY_ARR5 + +__s5 +; + +353 +__STRING2_COPY_ARR6 + +__s6 +; + +354 +__STRING2_COPY_ARR7 + +__s7 +; + +355 +__STRING2_COPY_ARR8 + +__s8 +; + +356 } * +__u + = +__de +; + +357 ( +__ +) + +360 +__u +-> +__c + = +__c1 +; + +363 +__exnsi__ + +__u +-> +__s2 + = +__c2 +; + +366 +__exnsi__ + +__u +-> +__s3 + = +__c3 +; + +369 +__exnsi__ + +__u +-> +__s4 + = +__c4 +; + +372 +__exnsi__ + +__u +-> +__s5 + = +__c5 +; + +375 +__exnsi__ + +__u +-> +__s6 + = +__c6 +; + +378 +__exnsi__ + +__u +-> +__s7 + = +__c7 +; + +381 +__exnsi__ + +__u +-> +__s8 + = +__c8 +; + +384  + `__exnsi__ + ((* +__u + + +__ +); + +385 + } +} + +393 #ide +_HAVE_STRING_ARCH_rchr + + +394 * +__wmemchr + (cڡ * +__s +,  +__c +); + +395 #i +__GNUC_PREREQ + (3, 2) + +396  + #rchr +( +s +, +c +) \ + +397 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& !__but_cڡt_( +s +) \ + +398 && ( +c +) == '\0' \ + +399 ? (* + `__wmemchr + ( +s +, +c +) \ + +400 : + `__but_rchr + ( +s +, +c +))) + + ) + +402  + #rchr +( +s +, +c +) \ + +403 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) && (c) == '\0' \ + +404 ? (* + `__wmemchr + ( +s +, +c +) \ + +405 : + `rchr + ( +s +, +c +))) + + ) + +411 #i(! +defed + +_HAVE_STRING_ARCH_ry + && ! +__GNUC_PREREQ + (3, 0)) \ + +412 || +defed + + g_FORCE_INLINES + + +413 #i! +defed + +_HAVE_STRING_ARCH_ry + && ! +__GNUC_PREREQ + (3, 0) + +414  + #ry +( +de +, +c +) \ + +415 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +416 ? ( + `__rg2_1br_p + ( +c +&& + ` + (src) + 1 <= 8 \ + +417 ? + `__ry_sml + ( +de +, + `__ry_gs + ( +c +), \ + +418 + ` + ( +c +) + 1) \ + +419 : (* + `memy + ( +de +, +c +, + ` + (src) + 1)) \ + +420 : + `ry + ( +de +, +c +))) + + ) + +423 #i +_STRING_ARCH_uligd + + +424 #ide +_FORCE_INLINES + + +425  + #__ry_gs +( +c +) \ + +426 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 0), \ + +427 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 4), \ + +428 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 0), \ + +429 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 4) + + ) + +431 +__STRING_INLINE + * +__ry_sml + (*, +__ut16_t +, __uint16_t, + +432 +__ut32_t +, __ut32_t, +size_t +); + +433 +__STRING_INLINE + * + +434 + $__ry_sml + (* +__de +, + +435 +__ut16_t + +__c0_2 +, __ut16_ +__c4_2 +, + +436 +__ut32_t + +__c0_4 +, __ut32_ +__c4_4 +, + +437 +size_t + +__ +) + +440 +__ut32_t + +__ui +; + +441 +__ut16_t + +__usi +; + +442  +__uc +; + +443 } * +__u + = (* +__de +; + +444 ( +__ +) + +447 +__u +-> +__uc + = '\0'; + +450 +__u +-> +__usi + = +__c0_2 +; + +453 +__u +-> +__usi + = +__c0_2 +; + +454 +__u + = + `__exnsi__ + ((*) __u + 2); + +455 +__u +-> +__uc + = '\0'; + +458 +__u +-> +__ui + = +__c0_4 +; + +461 +__u +-> +__ui + = +__c0_4 +; + +462 +__u + = + `__exnsi__ + ((*) __u + 4); + +463 +__u +-> +__uc + = '\0'; + +466 +__u +-> +__ui + = +__c0_4 +; + +467 +__u + = + `__exnsi__ + ((*) __u + 4); + +468 +__u +-> +__usi + = +__c4_2 +; + +471 +__u +-> +__ui + = +__c0_4 +; + +472 +__u + = + `__exnsi__ + ((*) __u + 4); + +473 +__u +-> +__usi + = +__c4_2 +; + +474 +__u + = + `__exnsi__ + ((*) __u + 2); + +475 +__u +-> +__uc + = '\0'; + +478 +__u +-> +__ui + = +__c0_4 +; + +479 +__u + = + `__exnsi__ + ((*) __u + 4); + +480 +__u +-> +__ui + = +__c4_4 +; + +483  +__de +; + +484 + } +} + +486 #ide +_FORCE_INLINES + + +487  + #__ry_gs +( +c +) \ + +488 + `__exnsi__ + (( +__STRING2_COPY_ARR2 +) \ + +489 { { (( +__cڡ + *( +c +))[0], '\0' } }), \ + +490 + `__exnsi__ + (( +__STRING2_COPY_ARR3 +) \ + +491 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +493 + `__exnsi__ + (( +__STRING2_COPY_ARR4 +) \ + +494 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +495 (( +__cڡ + *( +c +))[2], '\0' } }), \ + +496 + `__exnsi__ + (( +__STRING2_COPY_ARR5 +) \ + +497 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +498 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +500 + `__exnsi__ + (( +__STRING2_COPY_ARR6 +) \ + +501 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +502 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +503 (( +__cڡ + *( +c +))[4], '\0' } }), \ + +504 + `__exnsi__ + (( +__STRING2_COPY_ARR7 +) \ + +505 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +506 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +507 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +509 + `__exnsi__ + (( +__STRING2_COPY_ARR8 +) \ + +510 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +511 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +512 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +513 (( +__cڡ + *( +c +))[6], '\0' } }) + + ) + +515 +__STRING_INLINE + * +__ry_sml + (*, +__STRING2_COPY_ARR2 +, + +516 +__STRING2_COPY_ARR3 +, + +517 +__STRING2_COPY_ARR4 +, + +518 +__STRING2_COPY_ARR5 +, + +519 +__STRING2_COPY_ARR6 +, + +520 +__STRING2_COPY_ARR7 +, + +521 +__STRING2_COPY_ARR8 +, +size_t +); + +522 +__STRING_INLINE + * + +523 + $__ry_sml + (* +__de +, + +524 +__STRING2_COPY_ARR2 + +__c2 +, +__STRING2_COPY_ARR3 + +__c3 +, + +525 +__STRING2_COPY_ARR4 + +__c4 +, +__STRING2_COPY_ARR5 + +__c5 +, + +526 +__STRING2_COPY_ARR6 + +__c6 +, +__STRING2_COPY_ARR7 + +__c7 +, + +527 +__STRING2_COPY_ARR8 + +__c8 +, +size_t + +__ +) + +530  +__c +; + +531 +__STRING2_COPY_ARR2 + +__s2 +; + +532 +__STRING2_COPY_ARR3 + +__s3 +; + +533 +__STRING2_COPY_ARR4 + +__s4 +; + +534 +__STRING2_COPY_ARR5 + +__s5 +; + +535 +__STRING2_COPY_ARR6 + +__s6 +; + +536 +__STRING2_COPY_ARR7 + +__s7 +; + +537 +__STRING2_COPY_ARR8 + +__s8 +; + +538 } * +__u + = (* +__de +; + +539 ( +__ +) + +542 +__u +-> +__c + = '\0'; + +545 +__exnsi__ + +__u +-> +__s2 + = +__c2 +; + +548 +__exnsi__ + +__u +-> +__s3 + = +__c3 +; + +551 +__exnsi__ + +__u +-> +__s4 + = +__c4 +; + +554 +__exnsi__ + +__u +-> +__s5 + = +__c5 +; + +557 +__exnsi__ + +__u +-> +__s6 + = +__c6 +; + +560 +__exnsi__ + +__u +-> +__s7 + = +__c7 +; + +563 +__exnsi__ + +__u +-> +__s8 + = +__c8 +; + +566  +__de +; + +567 + } +} + +573 #ifde +__USE_GNU + + +574 #i! +defed + +_HAVE_STRING_ARCH_py + || defed +_FORCE_INLINES + + +575 #ide +_HAVE_STRING_ARCH_py + + +576 #i +__GNUC_PREREQ + (3, 4) + +577  + #__py +( +de +, +c + + `__but_py + (de, src) + + ) + +578 #i +__GNUC_PREREQ + (3, 0) + +579  + #__py +( +de +, +c +) \ + +580 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +581 ? ( + `__rg2_1br_p + ( +c +&& + ` + (src) + 1 <= 8 \ + +582 ? + `__but_ry + ( +de +, +c ++ + ` + (src) \ + +583 : ((*( +__mempy +( +de +, +c +, + ` + (src) + 1) \ + +585 : + `__py + ( +de +, +c +))) + + ) + +587  + #__py +( +de +, +c +) \ + +588 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +589 ? ( + `__rg2_1br_p + ( +c +&& + ` + (src) + 1 <= 8 \ + +590 ? + `__py_sml + ( +de +, + `__py_gs + ( +c +), \ + +591 + ` + ( +c +) + 1) \ + +592 : ((*( +__mempy +( +de +, +c +, + ` + (src) + 1) \ + +594 : + `__py + ( +de +, +c +))) + + ) + +598  + #py +( +de +, +c + + `__py + (de, src) + + ) + +601 #i! +__GNUC_PREREQ + (3, 0|| +defed + +_FORCE_INLINES + + +602 #i +_STRING_ARCH_uligd + + +603 #ide +_FORCE_INLINES + + +604  + #__py_gs +( +c +) \ + +605 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 0), \ + +606 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 4), \ + +607 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 0), \ + +608 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 4) + + ) + +610 +__STRING_INLINE + * +__py_sml + (*, +__ut16_t +, __uint16_t, + +611 +__ut32_t +, __ut32_t, +size_t +); + +612 +__STRING_INLINE + * + +613 + $__py_sml + (* +__de +, + +614 +__ut16_t + +__c0_2 +, __ut16_ +__c4_2 +, + +615 +__ut32_t + +__c0_4 +, __ut32_ +__c4_4 +, + +616 +size_t + +__ +) + +619  +__ui +; + +620  +__usi +; + +621  +__uc +; + +622  +__c +; + +623 } * +__u + = (* +__de +; + +624 ( +__ +) + +627 +__u +-> +__uc + = '\0'; + +630 +__u +-> +__usi + = +__c0_2 +; + +631 +__u + = + `__exnsi__ + ((*) __u + 1); + +634 +__u +-> +__usi + = +__c0_2 +; + +635 +__u + = + `__exnsi__ + ((*) __u + 2); + +636 +__u +-> +__uc + = '\0'; + +639 +__u +-> +__ui + = +__c0_4 +; + +640 +__u + = + `__exnsi__ + ((*) __u + 3); + +643 +__u +-> +__ui + = +__c0_4 +; + +644 +__u + = + `__exnsi__ + ((*) __u + 4); + +645 +__u +-> +__uc + = '\0'; + +648 +__u +-> +__ui + = +__c0_4 +; + +649 +__u + = + `__exnsi__ + ((*) __u + 4); + +650 +__u +-> +__usi + = +__c4_2 +; + +651 +__u + = + `__exnsi__ + ((*) __u + 1); + +654 +__u +-> +__ui + = +__c0_4 +; + +655 +__u + = + `__exnsi__ + ((*) __u + 4); + +656 +__u +-> +__usi + = +__c4_2 +; + +657 +__u + = + `__exnsi__ + ((*) __u + 2); + +658 +__u +-> +__uc + = '\0'; + +661 +__u +-> +__ui + = +__c0_4 +; + +662 +__u + = + `__exnsi__ + ((*) __u + 4); + +663 +__u +-> +__ui + = +__c4_4 +; + +664 +__u + = + `__exnsi__ + ((*) __u + 3); + +667  & +__u +-> +__c +; + +668 + } +} + +670 #ide +_FORCE_INLINES + + +671  + #__py_gs +( +c +) \ + +672 + `__exnsi__ + (( +__STRING2_COPY_ARR2 +) \ + +673 { { (( +__cڡ + *( +c +))[0], '\0' } }), \ + +674 + `__exnsi__ + (( +__STRING2_COPY_ARR3 +) \ + +675 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +677 + `__exnsi__ + (( +__STRING2_COPY_ARR4 +) \ + +678 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +679 (( +__cڡ + *( +c +))[2], '\0' } }), \ + +680 + `__exnsi__ + (( +__STRING2_COPY_ARR5 +) \ + +681 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +682 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +684 + `__exnsi__ + (( +__STRING2_COPY_ARR6 +) \ + +685 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +686 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +687 (( +__cڡ + *( +c +))[4], '\0' } }), \ + +688 + `__exnsi__ + (( +__STRING2_COPY_ARR7 +) \ + +689 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +690 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +691 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +693 + `__exnsi__ + (( +__STRING2_COPY_ARR8 +) \ + +694 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +695 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +696 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +697 (( +__cڡ + *( +c +))[6], '\0' } }) + + ) + +699 +__STRING_INLINE + * +__py_sml + (*, +__STRING2_COPY_ARR2 +, + +700 +__STRING2_COPY_ARR3 +, + +701 +__STRING2_COPY_ARR4 +, + +702 +__STRING2_COPY_ARR5 +, + +703 +__STRING2_COPY_ARR6 +, + +704 +__STRING2_COPY_ARR7 +, + +705 +__STRING2_COPY_ARR8 +, +size_t +); + +706 +__STRING_INLINE + * + +707 + $__py_sml + (* +__de +, + +708 +__STRING2_COPY_ARR2 + +__c2 +, +__STRING2_COPY_ARR3 + +__c3 +, + +709 +__STRING2_COPY_ARR4 + +__c4 +, +__STRING2_COPY_ARR5 + +__c5 +, + +710 +__STRING2_COPY_ARR6 + +__c6 +, +__STRING2_COPY_ARR7 + +__c7 +, + +711 +__STRING2_COPY_ARR8 + +__c8 +, +size_t + +__ +) + +714  +__c +; + +715 +__STRING2_COPY_ARR2 + +__s2 +; + +716 +__STRING2_COPY_ARR3 + +__s3 +; + +717 +__STRING2_COPY_ARR4 + +__s4 +; + +718 +__STRING2_COPY_ARR5 + +__s5 +; + +719 +__STRING2_COPY_ARR6 + +__s6 +; + +720 +__STRING2_COPY_ARR7 + +__s7 +; + +721 +__STRING2_COPY_ARR8 + +__s8 +; + +722 } * +__u + = (* +__de +; + +723 ( +__ +) + +726 +__u +-> +__c + = '\0'; + +729 +__exnsi__ + +__u +-> +__s2 + = +__c2 +; + +732 +__exnsi__ + +__u +-> +__s3 + = +__c3 +; + +735 +__exnsi__ + +__u +-> +__s4 + = +__c4 +; + +738 +__exnsi__ + +__u +-> +__s5 + = +__c5 +; + +741 +__exnsi__ + +__u +-> +__s6 + = +__c6 +; + +744 +__exnsi__ + +__u +-> +__s7 + = +__c7 +; + +747 +__exnsi__ + +__u +-> +__s8 + = +__c8 +; + +750  +__de + + +__ + - 1; + +751 + } +} + +759 #ide +_HAVE_STRING_ARCH_y + + +760 #i +__GNUC_PREREQ + (3, 2) + +761  + #y +( +de +, +c +, +n + + `__but_y + (de, src,) + + ) + +763  + #y +( +de +, +c +, +n +) \ + +764 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +765 ? ( + ` + ( +c ++ 1 >(( +size_t +( +n +)) \ + +766 ? (* + `memy + ( +de +, +c +, +n +) \ + +767 : + `y + ( +de +, +c +, +n +)) \ + +768 : + `y + ( +de +, +c +, +n +))) + + ) + +774 #ide +_HAVE_STRING_ARCH_t + + +775 #ifde +_USE_STRING_ARCH_rchr + + +776  + #t +( +de +, +c +, +n +) \ + +777 ( + `__exnsi__ + ({ * +__de + = ( +de +); \ + +778 + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +779 ? ( + ` + ( +c +< (( +size_t +( +n +)) \ + +780 ? + `rt + ( +__de +, +c +) \ + +781 : (*((* + `__mempy + ( + `rchr + ( +__de +, '\0'), \ + +782 +c +, +n +)'\0', +__de +)) \ + +783 : + `t + ( +de +, +c +, +n +); })) + + ) + +784 #i +__GNUC_PREREQ + (3, 2) + +785  + #t +( +de +, +c +, +n + + `__but_t + (de, src,) + + ) + +787  + #t +( +de +, +c +, +n +) \ + +788 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +789 ? ( + ` + ( +c +< (( +size_t +( +n +)) \ + +790 ? + `rt + ( +de +, +c +) \ + +791 : + `t + ( +de +, +c +, +n +)) \ + +792 : + `t + ( +de +, +c +, +n +))) + + ) + +798 #ide +_HAVE_STRING_ARCH_rcmp + + +799 #i +__GNUC_PREREQ + (3, 2) + +800  + #rcmp +( +s1 +, +s2 +) \ + +801 +__exnsi__ + \ + +802 ({ +size_t + +__s1_n +, +__s2_n +; \ + +803 ( + `__but_cڡt_p + ( +s1 +&& __but_cڡt_( +s2 +) \ + +804 && ( +__s1_n + = + ` + ( +s1 +), +__s2_n + = s( +s2 +), \ + +805 (! + `__rg2_1br_p + ( +s1 +|| +__s1_n + >= 4) \ + +806 && (! + `__rg2_1br_p + ( +s2 +|| +__s2_n + >= 4)) \ + +807 ? + `__but_rcmp + ( +s1 +, +s2 +) \ + +808 : ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +809 && ( +__s1_n + = + ` + ( +s1 +), __s1_len < 4) \ + +810 ? ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +811 ? + `__but_rcmp + ( +s1 +, +s2 +) \ + +812 : + `__rcmp_cg + ( +s1 +, +s2 +, +__s1_n +)) \ + +813 : ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +814 && ( +__s2_n + = + ` + ( +s2 +), __s2_len < 4) \ + +815 ? ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +816 ? + `__but_rcmp + ( +s1 +, +s2 +) \ + +817 : + `__rcmp_gc + ( +s1 +, +s2 +, +__s2_n +)) \ + +818 : + `__but_rcmp + ( +s1 +, +s2 +)))); }) + + ) + +820  + #rcmp +( +s1 +, +s2 +) \ + +821 +__exnsi__ + \ + +822 ({ +size_t + +__s1_n +, +__s2_n +; \ + +823 ( + `__but_cڡt_p + ( +s1 +&& __but_cڡt_( +s2 +) \ + +824 && ( +__s1_n + = + ` + ( +s1 +), +__s2_n + = s( +s2 +), \ + +825 (! + `__rg2_1br_p + ( +s1 +|| +__s1_n + >= 4) \ + +826 && (! + `__rg2_1br_p + ( +s2 +|| +__s2_n + >= 4)) \ + +827 ? + `memcmp + (( +__cڡ + *( +s1 +), (__cڡ *( +s2 +), \ + +828 ( +__s1_n + < +__s2_n + ? __s1_len : __s2_len) + 1) \ + +829 : ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +830 && ( +__s1_n + = + ` + ( +s1 +), __s1_len < 4) \ + +831 ? ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +832 ? + `__rcmp_cc + ( +s1 +, +s2 +, +__s1_n +) \ + +833 : + `__rcmp_cg + ( +s1 +, +s2 +, +__s1_n +)) \ + +834 : ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +835 && ( +__s2_n + = + ` + ( +s2 +), __s2_len < 4) \ + +836 ? ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +837 ? + `__rcmp_cc + ( +s1 +, +s2 +, +__s2_n +) \ + +838 : + `__rcmp_gc + ( +s1 +, +s2 +, +__s2_n +)) \ + +839 : + `rcmp + ( +s1 +, +s2 +)))); }) + + ) + +842  + #__rcmp_cc +( +s1 +, +s2 +, +l +) \ + +843 ( + `__exnsi__ + ({  +__su + = \ + +844 ((( +__cڡ + *(__cڡ *( +s1 +))[0] \ + +845 - (( +__cڡ + *(__cڡ *)( +s2 +))[0]);\ + +846 i( +l + > 0 && +__su + == 0) \ + +848 +__su + = ((( +__cڡ + *) \ + +849 ( +__cڡ + *( +s1 +))[1] \ + +850 - (( +__cڡ + *) \ + +851 ( +__cڡ + *( +s2 +))[1]); \ + +852 i( +l + > 1 && +__su + == 0) \ + +854 +__su + = \ + +855 ((( +__cڡ + *) \ + +856 ( +__cڡ + *( +s1 +))[2] \ + +857 - (( +__cڡ + *) \ + +858 ( +__cڡ + *( +s2 +))[2]); \ + +859 i( +l + > 2 && +__su + == 0) \ + +860 +__su + = \ + +861 ((( +__cڡ + *) \ + +862 ( +__cڡ + *( +s1 +))[3] \ + +863 - (( +__cڡ + *) \ + +864 ( +__cڡ + *( +s2 +))[3]); \ + +867 +__su +; })) + + ) + +869  + #__rcmp_cg +( +s1 +, +s2 +, +l1 +) \ + +870 ( + `__exnsi__ + ({ +__cڡ + * +__s2 + = \ + +871 ( +__cڡ + *(__cڡ *( +s2 +); \ + +872  +__su + = \ + +873 ((( +__cڡ + *(__cڡ *( +s1 +))[0] \ + +874 - +__s2 +[0]); \ + +875 i( +l1 + > 0 && +__su + == 0) \ + +877 +__su + = ((( +__cڡ + *) \ + +878 ( +__cڡ + *( +s1 +))[1] - +__s2 +[1]); \ + +879 i( +l1 + > 1 && +__su + == 0) \ + +881 +__su + = ((( +__cڡ + *) \ + +882 ( +__cڡ + *( +s1 +))[2] - +__s2 +[2]);\ + +883 i( +l1 + > 2 && +__su + == 0) \ + +884 +__su + = ((( +__cڡ + *) \ + +885 ( +__cڡ + *( +s1 +))[3] \ + +886 - +__s2 +[3]); \ + +889 +__su +; })) + + ) + +891  + #__rcmp_gc +( +s1 +, +s2 +, +l2 +) \ + +892 ( + `__exnsi__ + ({ +__cڡ + * +__s1 + = \ + +893 ( +__cڡ + *(__cڡ *( +s1 +); \ + +894  +__su + = \ + +895 +__s1 +[0] - (( +__cڡ + *) \ + +896 ( +__cڡ + *( +s2 +))[0]; \ + +897 i( +l2 + > 0 && +__su + == 0) \ + +899 +__su + = ( +__s1 +[1] \ + +900 - (( +__cڡ + *) \ + +901 ( +__cڡ + *( +s2 +))[1]); \ + +902 i( +l2 + > 1 && +__su + == 0) \ + +904 +__su + = \ + +905 ( +__s1 +[2] - (( +__cڡ + *) \ + +906 ( +__cڡ + *( +s2 +))[2]); \ + +907 i( +l2 + > 2 && +__su + == 0) \ + +908 +__su + = \ + +909 ( +__s1 +[3] \ + +910 - (( +__cڡ + *) \ + +911 ( +__cڡ + *( +s2 +))[3]); \ + +914 +__su +; })) + + ) + +919 #ide +_HAVE_STRING_ARCH_cmp + + +920  + #cmp +( +s1 +, +s2 +, +n +) \ + +921 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +n +) \ + +922 && (( + `__but_cڡt_p + ( +s1 +) \ + +923 && + ` + ( +s1 +< (( +size_t +( +n +))) \ + +924 || ( + `__but_cڡt_p + ( +s2 +) \ + +925 && + ` + ( +s2 +< (( +size_t +( +n +)))) \ + +926 ? + `rcmp + ( +s1 +, +s2 +: + `cmp + (s1, s2, +n +))) + + ) + +932 #i! +defed + +_HAVE_STRING_ARCH_rcn + || defed +_FORCE_INLINES + + +933 #ide +_HAVE_STRING_ARCH_rcn + + +934 #i +__GNUC_PREREQ + (3, 2) + +935  + #rcn +( +s +, +je +) \ + +936 +__exnsi__ + \ + +937 ({  +__r0 +, +__r1 +, +__r2 +; \ + +938 ( + `__but_cڡt_p + ( +je +&& + `__rg2_1br_p + (reject) \ + +939 ? (( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s)) \ + +940 ? + `__but_rcn + ( +s +, +je +) \ + +941 : (( +__r0 + = (( +__cڡ + *( +je +))[0], __r0 == '\0') \ + +942 ? + ` + ( +s +) \ + +943 : (( +__r1 + = (( +__cڡ + *( +je +))[1], __r1 == '\0') \ + +944 ? + `__rcn_c1 + ( +s +, +__r0 +) \ + +945 : (( +__r2 + = (( +__cڡ + *( +je +))[2], __r2 == '\0') \ + +946 ? + `__rcn_c2 + ( +s +, +__r0 +, +__r1 +) \ + +947 : ((( +__cڡ + *( +je +))[3] == '\0' \ + +948 ? + `__rcn_c3 + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +949 : + `__but_rcn + ( +s +, +je +)))))) \ + +950 : + `__but_rcn + ( +s +, +je +)); }) + + ) + +952  + #rcn +( +s +, +je +) \ + +953 +__exnsi__ + \ + +954 ({  +__r0 +, +__r1 +, +__r2 +; \ + +955 ( + `__but_cڡt_p + ( +je +&& + `__rg2_1br_p + (reject) \ + +956 ? (( +__r0 + = (( +__cڡ + *( +je +))[0], __r0 == '\0') \ + +957 ? + ` + ( +s +) \ + +958 : (( +__r1 + = (( +__cڡ + *( +je +))[1], __r1 == '\0') \ + +959 ? + `__rcn_c1 + ( +s +, +__r0 +) \ + +960 : (( +__r2 + = (( +__cڡ + *( +je +))[2], __r2 == '\0') \ + +961 ? + `__rcn_c2 + ( +s +, +__r0 +, +__r1 +) \ + +962 : ((( +__cڡ + *( +je +))[3] == '\0' \ + +963 ? + `__rcn_c3 + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +964 : + `rcn + ( +s +, +je +))))) \ + +965 : + `rcn + ( +s +, +je +)); }) + + ) + +969 +__STRING_INLINE + +size_t + +__rcn_c1 + ( +__cڡ + * +__s +,  +__je +); + +970 +__STRING_INLINE + +size_t + + +971 + $__rcn_c1 + ( +__cڡ + * +__s +,  +__je +) + +973  +size_t + +__su + = 0; + +974  +__s +[ +__su +] !'\0' && __s[__su] ! +__je +) + +975 ++ +__su +; + +976  +__su +; + +977 + } +} + +979 +__STRING_INLINE + +size_t + +__rcn_c2 + ( +__cڡ + * +__s +,  +__je1 +, + +980  +__je2 +); + +981 +__STRING_INLINE + +size_t + + +982 + $__rcn_c2 + ( +__cڡ + * +__s +,  +__je1 +,  +__je2 +) + +984  +size_t + +__su + = 0; + +985  +__s +[ +__su +] !'\0' && __s[__su] ! +__je1 + + +986 && +__s +[ +__su +] ! +__je2 +) + +987 ++ +__su +; + +988  +__su +; + +989 + } +} + +991 +__STRING_INLINE + +size_t + +__rcn_c3 + ( +__cڡ + * +__s +,  +__je1 +, + +992  +__je2 +,  +__je3 +); + +993 +__STRING_INLINE + +size_t + + +994 + $__rcn_c3 + ( +__cڡ + * +__s +,  +__je1 +,  +__je2 +, + +995  +__je3 +) + +997  +size_t + +__su + = 0; + +998  +__s +[ +__su +] !'\0' && __s[__su] ! +__je1 + + +999 && +__s +[ +__su +] ! +__je2 + && __s[__su] ! +__je3 +) + +1000 ++ +__su +; + +1001  +__su +; + +1002 + } +} + +1008 #i! +defed + +_HAVE_STRING_ARCH_rn + || defed +_FORCE_INLINES + + +1009 #ide +_HAVE_STRING_ARCH_rn + + +1010 #i +__GNUC_PREREQ + (3, 2) + +1011  + #rn +( +s +, +ac +) \ + +1012 +__exnsi__ + \ + +1013 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1014 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1015 ? (( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s)) \ + +1016 ? + `__but_rn + ( +s +, +ac +) \ + +1017 : (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1018 ? ((( +s +), 0) \ + +1019 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1020 ? + `__rn_c1 + ( +s +, +__a0 +) \ + +1021 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1022 ? + `__rn_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1023 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1024 ? + `__rn_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1025 : + `__but_rn + ( +s +, +ac +)))))) \ + +1026 : + `__but_rn + ( +s +, +ac +)); }) + + ) + +1028  + #rn +( +s +, +ac +) \ + +1029 +__exnsi__ + \ + +1030 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1031 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1032 ? (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1033 ? ((( +s +), 0) \ + +1034 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1035 ? + `__rn_c1 + ( +s +, +__a0 +) \ + +1036 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1037 ? + `__rn_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1038 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1039 ? + `__rn_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1040 : + `rn + ( +s +, +ac +))))) \ + +1041 : + `rn + ( +s +, +ac +)); }) + + ) + +1045 +__STRING_INLINE + +size_t + +__rn_c1 + ( +__cڡ + * +__s +,  +__ac +); + +1046 +__STRING_INLINE + +size_t + + +1047 + $__rn_c1 + ( +__cڡ + * +__s +,  +__ac +) + +1049  +size_t + +__su + = 0; + +1051  +__s +[ +__su +] = +__ac +) + +1052 ++ +__su +; + +1053  +__su +; + +1054 + } +} + +1056 +__STRING_INLINE + +size_t + +__rn_c2 + ( +__cڡ + * +__s +,  +__ac1 +, + +1057  +__ac2 +); + +1058 +__STRING_INLINE + +size_t + + +1059 + $__rn_c2 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +) + +1061  +size_t + +__su + = 0; + +1063  +__s +[ +__su +] = +__ac1 + || __s[__su] = +__ac2 +) + +1064 ++ +__su +; + +1065  +__su +; + +1066 + } +} + +1068 +__STRING_INLINE + +size_t + +__rn_c3 + ( +__cڡ + * +__s +,  +__ac1 +, + +1069  +__ac2 +,  +__ac3 +); + +1070 +__STRING_INLINE + +size_t + + +1071 + $__rn_c3 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +,  +__ac3 +) + +1073  +size_t + +__su + = 0; + +1075  +__s +[ +__su +] = +__ac1 + || __s[__su] = +__ac2 + + +1076 || +__s +[ +__su +] = +__ac3 +) + +1077 ++ +__su +; + +1078  +__su +; + +1079 + } +} + +1084 #i! +defed + +_HAVE_STRING_ARCH_brk + || defed +_FORCE_INLINES + + +1085 #ide +_HAVE_STRING_ARCH_brk + + +1086 #i +__GNUC_PREREQ + (3, 2) + +1087  + #brk +( +s +, +ac +) \ + +1088 +__exnsi__ + \ + +1089 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1090 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1091 ? (( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s)) \ + +1092 ? + `__but_brk + ( +s +, +ac +) \ + +1093 : (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1094 ? ((( +s +), (* +NULL +) \ + +1095 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1096 ? + `__but_rchr + ( +s +, +__a0 +) \ + +1097 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1098 ? + `__brk_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1099 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1100 ? + `__brk_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1101 : + `__but_brk + ( +s +, +ac +)))))) \ + +1102 : + `__but_brk + ( +s +, +ac +)); }) + + ) + +1104  + #brk +( +s +, +ac +) \ + +1105 +__exnsi__ + \ + +1106 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1107 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1108 ? (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1109 ? ((( +s +), (* +NULL +) \ + +1110 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1111 ? + `rchr + ( +s +, +__a0 +) \ + +1112 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1113 ? + `__brk_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1114 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1115 ? + `__brk_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1116 : + `brk + ( +s +, +ac +))))) \ + +1117 : + `brk + ( +s +, +ac +)); }) + + ) + +1121 +__STRING_INLINE + * +__brk_c2 + ( +__cڡ + * +__s +,  +__ac1 +, + +1122  +__ac2 +); + +1123 +__STRING_INLINE + * + +1124 + $__brk_c2 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +) + +1127 * +__s + !'\0' && *__! +__ac1 + && *__! +__ac2 +) + +1128 ++ +__s +; + +1129  * +__s + ='\0' ? +NULL + : (*( +size_t +) __s; + +1130 + } +} + +1132 +__STRING_INLINE + * +__brk_c3 + ( +__cڡ + * +__s +,  +__ac1 +, + +1133  +__ac2 +,  +__ac3 +); + +1134 +__STRING_INLINE + * + +1135 + $__brk_c3 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +, + +1136  +__ac3 +) + +1139 * +__s + !'\0' && *__! +__ac1 + && *__! +__ac2 + + +1140 && * +__s + ! +__ac3 +) + +1141 ++ +__s +; + +1142  * +__s + ='\0' ? +NULL + : (*( +size_t +) __s; + +1143 + } +} + +1149 #i! +defed + +_HAVE_STRING_ARCH_rr + && ! +__GNUC_PREREQ + (2, 97) + +1150  + #rr +( +hayack +, +ed +) \ + +1151 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +ed +&& + `__rg2_1br_p + (needle) \ + +1152 ? ((( +__cڡ + *( +ed +))[0] == '\0' \ + +1153 ? (*( +size_t +( +hayack +) \ + +1154 : ((( +__cڡ + *( +ed +))[1] == '\0' \ + +1155 ? + `rchr + ( +hayack +, \ + +1156 (( +__cڡ + *( +ed +))[0]) \ + +1157 : + `rr + ( +hayack +, +ed +))) \ + +1158 : + `rr + ( +hayack +, +ed +))) + + ) + +1162 #i! +defed + +_HAVE_STRING_ARCH_ok_r + || defed +_FORCE_INLINES + + +1163 #ide +_HAVE_STRING_ARCH_ok_r + + +1164  + #__ok_r +( +s +, +p +, +x +) \ + +1165 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +p +&& + `__rg2_1br_p + (sep) \ + +1166 ? ((( +__cڡ + *( +p +))[0] != '\0' \ + +1167 && (( +__cڡ + *( +p +))[1] == '\0' \ + +1168 ? + `__ok_r_1c + ( +s +, (( +__cڡ + *( +p +))[0], +x +) \ + +1169 : + `__ok_r + ( +s +, +p +, +x +)) \ + +1170 : + `__ok_r + ( +s +, +p +, +x +))) + + ) + +1173 +__STRING_INLINE + * +__ok_r_1c + (* +__s +,  +__p +, ** +__x +); + +1174 +__STRING_INLINE + * + +1175 + $__ok_r_1c + (* +__s +,  +__p +, ** +__x +) + +1177 * +__su +; + +1178 i( +__s + = +NULL +) + +1179 +__s + = * +__x +; + +1180 * +__s + = +__p +) + +1181 ++ +__s +; + +1182 +__su + = +NULL +; + +1183 i(* +__s + != '\0') + +1185 +__su + = +__s +++; + +1186 * +__s + != '\0') + +1187 i(* +__s +++ = +__p +) + +1189 +__s +[-1] = '\0'; + +1192 * +__x + = +__s +; + +1194  +__su +; + +1195 + } +} + +1196 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +1197  + #ok_r +( +s +, +p +, +x + + `__ok_r + (s, s,ex) + + ) + +1202 #i! +defed + +_HAVE_STRING_ARCH_rp + || defed +_FORCE_INLINES + + +1203 #ide +_HAVE_STRING_ARCH_rp + + +1205 * +__rp_g + (** +__rgp +, +__cڡ + * +__dim +); + +1206  + #__rp +( +s +, +je +) \ + +1207 +__exnsi__ + \ + +1208 ({  +__r0 +, +__r1 +, +__r2 +; \ + +1209 ( + `__but_cڡt_p + ( +je +&& + `__rg2_1br_p + (reject) \ + +1210 && ( +__r0 + = (( +__cڡ + *( +je +))[0], \ + +1211 (( +__cڡ + *( +je +))[0] != '\0') \ + +1212 ? (( +__r1 + = (( +__cڡ + *( +je +))[1], \ + +1213 (( +__cڡ + *( +je +))[1] == '\0') \ + +1214 ? + `__rp_1c + ( +s +, +__r0 +) \ + +1215 : (( +__r2 + = (( +__cڡ + *( +je +))[2], __r2 == '\0') \ + +1216 ? + `__rp_2c + ( +s +, +__r0 +, +__r1 +) \ + +1217 : ((( +__cڡ + *( +je +))[3] == '\0' \ + +1218 ? + `__rp_3c + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +1219 : + `__rp_g + ( +s +, +je +)))) \ + +1220 : + `__rp_g + ( +s +, +je +)); }) + + ) + +1223 +__STRING_INLINE + * +__rp_1c + (** +__s +,  +__je +); + +1224 +__STRING_INLINE + * + +1225 + $__rp_1c + (** +__s +,  +__je +) + +1227 * +__tv + = * +__s +; + +1228 i( +__tv + ! +NULL + && (* +__s + = + `rchr + (__tv, +__je +)) != NULL) + +1229 *(* +__s +)++ = '\0'; + +1230  +__tv +; + +1231 + } +} + +1233 +__STRING_INLINE + * +__rp_2c + (** +__s +,  +__je1 +,  +__je2 +); + +1234 +__STRING_INLINE + * + +1235 + $__rp_2c + (** +__s +,  +__je1 +,  +__je2 +) + +1237 * +__tv + = * +__s +; + +1238 i( +__tv + ! +NULL +) + +1240 * +__ + = +__tv +; + +1243 i(* +__ + == '\0') + +1245 +__ + = +NULL +; + +1248 i(* +__ + = +__je1 + || *__ = +__je2 +) + +1250 * +__ +++ = '\0'; + +1253 ++ +__ +; + +1255 * +__s + = +__ +; + +1257  +__tv +; + +1258 + } +} + +1260 +__STRING_INLINE + * +__rp_3c + (** +__s +,  +__je1 +,  +__je2 +, + +1261  +__je3 +); + +1262 +__STRING_INLINE + * + +1263 + $__rp_3c + (** +__s +,  +__je1 +,  +__je2 +,  +__je3 +) + +1265 * +__tv + = * +__s +; + +1266 i( +__tv + ! +NULL +) + +1268 * +__ + = +__tv +; + +1271 i(* +__ + == '\0') + +1273 +__ + = +NULL +; + +1276 i(* +__ + = +__je1 + || *__ = +__je2 + || *__ = +__je3 +) + +1278 * +__ +++ = '\0'; + +1281 ++ +__ +; + +1283 * +__s + = +__ +; + +1285  +__tv +; + +1286 + } +} + +1287 #ifde +__USE_BSD + + +1288  + #rp +( +s +, +je + + `__rp + (s,eje) + + ) + +1295 #ifde +__USE_MISC + + +1297 #i! +defed + +_HAVE_STRING_ARCH_rdup + || !defed +_HAVE_STRING_ARCH_dup + + +1298  + #__ed_mloc_d_oc + + + ) + +1299  + ~ + +1302 #ide +_HAVE_STRING_ARCH_rdup + + +1304 * + $__rdup + ( +__cڡ + * +__rg + +__THROW + +__ibu_mloc__ +; + +1305  + #__rdup +( +s +) \ + +1306 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s) \ + +1307 ? ((( +__cڡ + *( +s +))[0] == '\0' \ + +1308 ? (* + `oc + (1, 1) \ + +1309 : ({ +size_t + +__n + = + ` + ( +s +) + 1; \ + +1310 * +__tv + = (* + `mloc + ( +__n +); \ + +1311 i( +__tv + ! +NULL +) \ + +1312 +__tv + = (* + `memy + (__tv, +s +, +__n +); \ + +1313 +__tv +; + } +})) \ + +1314 : + `__rdup + ( +s +))) + + ) + +1316 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +1317  + #rdup +( +s + + `__rdup + (s) + + ) + +1321 #ide +_HAVE_STRING_ARCH_dup + + +1323 * + $__dup + ( +__cڡ + * +__rg +, +size_t + +__n +) + +1324 +__THROW + +__ibu_mloc__ +; + +1325  + #__dup +( +s +, +n +) \ + +1326 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s) \ + +1327 ? ((( +__cڡ + *( +s +))[0] == '\0' \ + +1328 ? (* + `oc + (1, 1) \ + +1329 : ({ +size_t + +__n + = + ` + ( +s +) + 1; \ + +1330 +size_t + +__n + = ( +n +); \ + +1331 * +__tv +; \ + +1332 i( +__n + < +__n +) \ + +1333 +__n + = +__n + + 1; \ + +1334 +__tv + = (* + `mloc + ( +__n +); \ + +1335 i( +__tv + ! +NULL +) \ + +1337 +__tv +[ +__n + - 1] = '\0'; \ + +1338 +__tv + = (* + `memy + (__tv, +s +, \ + +1339 +__n + - 1); \ + +1341 +__tv +; + } +})) \ + +1342 : + `__dup + ( +s +, +n +))) + + ) + +1344 #ifde +__USE_GNU + + +1345  + #dup +( +s +, +n + + `__dup + (s,) + + ) + +1351 #ide +_FORCE_INLINES + + +1352 #unde +__STRING_INLINE + + + @/usr/include/bits/string3.h + +19 #ide +_STRING_H + + +26 #unde +memy + + +27 #unde +memmove + + +28 #unde +memt + + +29 #unde +rt + + +30 #unde +ry + + +31 #unde +t + + +32 #unde +y + + +33 #ifde +__USE_GNU + + +34 #unde +mempy + + +35 #unde +py + + +37 #ifde +__USE_BSD + + +38 #unde +bcy + + +39 #unde +bzo + + +43  + #memy +( +de +, +c +, +n +) \ + +44 (( + `__bos0 + ( +de +!( +size_t +) -1) \ + +45 ? + `__but___memy_chk + ( +de +, +c +, +n +, + `__bos0 + (dest)) \ + +46 : + `__memy_ichk + ( +de +, +c +, +n +)) + + ) + +47  +__le__ + * + +48 +__ibu__ + (( +__ways_le__ +)) + +49 + $__memy_ichk + (* +__ri + +__de +, cڡ *__ri +__c +, + +50 +size_t + +__n +) + +52  + `__but___memy_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +53 + } +} + +56  + #memmove +( +de +, +c +, +n +) \ + +57 (( + `__bos0 + ( +de +!( +size_t +) -1) \ + +58 ? + `__but___memmove_chk + ( +de +, +c +, +n +, + `__bos0 + (dest)) \ + +59 : + `__memmove_ichk + ( +de +, +c +, +n +)) + + ) + +60  +__le__ + * + +61 +__ibu__ + (( +__ways_le__ +)) + +62 + $__memmove_ichk + (* +__de +, cڡ * +__c +, +size_t + +__n +) + +64  + `__but___memmove_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +65 + } +} + +68 #ifde +__USE_GNU + + +69  + #mempy +( +de +, +c +, +n +) \ + +70 (( + `__bos0 + ( +de +!( +size_t +) -1) \ + +71 ? + `__but___mempy_chk + ( +de +, +c +, +n +, + `__bos0 + (dest)) \ + +72 : + `__mempy_ichk + ( +de +, +c +, +n +)) + + ) + +73  +__le__ + * + +74 +__ibu__ + (( +__ways_le__ +)) + +75 + $__mempy_ichk + (* +__ri + +__de +, cڡ *__ri +__c +, + +76 +size_t + +__n +) + +78  + `__but___mempy_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +79 + } +} + +83  + #memt +( +de +, +ch +, +n +) \ + +84 (( + `__bos0 + ( +de +!( +size_t +) -1) \ + +85 ? + `__but___memt_chk + ( +de +, +ch +, +n +, + `__bos0 + (dest)) \ + +86 : + `__memt_ichk + ( +de +, +ch +, +n +)) + + ) + +87  +__le__ + * + +88 +__ibu__ + (( +__ways_le__ +)) + +89 + $__memt_ichk + (* +__de +,  +__ch +, +size_t + +__n +) + +91  + `__but___memt_chk + ( +__de +, +__ch +, +__n +, + `__bos0 + (__dest)); + +92 + } +} + +94 #ifde +__USE_BSD + + +95  + #bcy +( +c +, +de +, +n +) (() \ + +96 (( + `__bos0 + ( +de +!( +size_t +) -1) \ + +97 ? + `__but___memmove_chk + ( +de +, +c +, +n +, + `__bos0 + (dest)) \ + +98 : + `__memmove_ichk + ( +de +, +c +, +n +))) + + ) + +99  + #bzo +( +de +, +n +) (() \ + +100 (( + `__bos0 + ( +de +!( +size_t +) -1) \ + +101 ? + `__but___memt_chk + ( +de +, '\0', +n +, + `__bos0 + (dest)) \ + +102 : + `__memt_ichk + ( +de +, '\0', +n +))) + + ) + +106  + #ry +( +de +, +c +) \ + +107 (( + `__bos + ( +de +!( +size_t +) -1) \ + +108 ? + `__but___ry_chk + ( +de +, +c +, + `__bos + (dest)) \ + +109 : + `__ry_ichk + ( +de +, +c +)) + + ) + +110  +__le__ + * + +111 +__ibu__ + (( +__ways_le__ +)) + +112 + $__ry_ichk + (* +__ri + +__de +, cڡ *__ri +__c +) + +114  + `__but___ry_chk + ( +__de +, +__c +, + `__bos + (__dest)); + +115 + } +} + +118 #ifde +__USE_GNU + + +119  + #py +( +de +, +c +) \ + +120 (( + `__bos + ( +de +!( +size_t +) -1) \ + +121 ? + `__but___py_chk + ( +de +, +c +, + `__bos + (dest)) \ + +122 : + `__py_ichk + ( +de +, +c +)) + + ) + +123  +__le__ + * + +124 +__ibu__ + (( +__ways_le__ +)) + +125 + $__py_ichk + (* +__ri + +__de +, cڡ *__ri +__c +) + +127  + `__but___py_chk + ( +__de +, +__c +, + `__bos + (__dest)); + +128 + } +} + +132  + #y +( +de +, +c +, +n +) \ + +133 (( + `__bos + ( +de +!( +size_t +) -1) \ + +134 ? + `__but___y_chk + ( +de +, +c +, +n +, + `__bos + (dest)) \ + +135 : + `__y_ichk + ( +de +, +c +, +n +)) + + ) + +136  +__le__ + * + +137 +__ibu__ + (( +__ways_le__ +)) + +138 + $__y_ichk + (* +__ri + +__de +, cڡ *__ri +__c +, + +139 +size_t + +__n +) + +141  + `__but___y_chk + ( +__de +, +__c +, +__n +, + `__bos + (__dest)); + +142 + } +} + +145  + #rt +( +de +, +c +) \ + +146 (( + `__bos + ( +de +!( +size_t +) -1) \ + +147 ? + `__but___rt_chk + ( +de +, +c +, + `__bos + (dest)) \ + +148 : + `__rt_ichk + ( +de +, +c +)) + + ) + +149  +__le__ + * + +150 +__ibu__ + (( +__ways_le__ +)) + +151 + $__rt_ichk + (* +__ri + +__de +, cڡ *__ri +__c +) + +153  + `__but___rt_chk + ( +__de +, +__c +, + `__bos + (__dest)); + +154 + } +} + +157  + #t +( +de +, +c +, +n +) \ + +158 (( + `__bos + ( +de +!( +size_t +) -1) \ + +159 ? + `__but___t_chk + ( +de +, +c +, +n +, + `__bos + (dest)) \ + +160 : + `__t_ichk + ( +de +, +c +, +n +)) + + ) + +161  +__le__ + * + +162 +__ibu__ + (( +__ways_le__ +)) + +163 + $__t_ichk + (* +__ri + +__de +, cڡ *__ri +__c +, + +164 +size_t + +__n +) + +166  + `__but___t_chk + ( +__de +, +__c +, +__n +, + `__bos + (__dest)); + +167 + } +} + + @/usr/include/bits/sys_errlist.h + +20 #ide +_STDIO_H + + +26 #ifde +__USE_BSD + + +27  +sys_ü +; + +28 +__cڡ + *__cڡ +sys_i +[]; + +30 #ifde +__USE_GNU + + +31  +_sys_ü +; + +32 +__cڡ + *__cڡ +_sys_i +[]; + + @/usr/include/bits/types.h + +24 #idef +_BITS_TYPES_H + + +25  + #_BITS_TYPES_H + 1 + + ) + +27  + ~ + +28  + ~ + +30  + #__ed_size_t + + + ) + +31  + ~ + +34  + t__u_ch +; + +35  + t__u_sht +; + +36  + t__u_t +; + +37  + t__u_lg +; + +40 sigd  + t__t8_t +; + +41  + t__ut8_t +; + +42 sigd  + t__t16_t +; + +43  + t__ut16_t +; + +44 sigd  + t__t32_t +; + +45  + t__ut32_t +; + +46 #i +__WORDSIZE + == 64 + +47 sigd  + t__t64_t +; + +48  + t__ut64_t +; + +49 #i +defed + +__GLIBC_HAVE_LONG_LONG + + +50 +__exnsi__ + sigd  + t__t64_t +; + +51 +__exnsi__ +  + t__ut64_t +; + +55 #i +__WORDSIZE + == 64 + +56  + t__quad_t +; + +57  + t__u_quad_t +; + +58 #i +defed + +__GLIBC_HAVE_LONG_LONG + + +59 +__exnsi__ +  + t__quad_t +; + +60 +__exnsi__ +  + t__u_quad_t +; + +64  + m__v +[2]; + +65 } + t__quad_t +; + +68 +__u_lg + + m__v +[2]; + +69 } + t__u_quad_t +; + +102  + #__S16_TYPE +  + + ) + +103  + #__U16_TYPE +  + + ) + +104  + #__S32_TYPE +  + + ) + +105  + #__U32_TYPE +  + + ) + +106  + #__SLONGWORD_TYPE +  + + ) + +107  + #__ULONGWORD_TYPE +  + + ) + +108 #i +__WORDSIZE + == 32 + +109  + #__SQUAD_TYPE + +__quad_t + + + ) + +110  + #__UQUAD_TYPE + +__u_quad_t + + + ) + +111  + #__SWORD_TYPE +  + + ) + +112  + #__UWORD_TYPE +  + + ) + +113  + #__SLONG32_TYPE +  + + ) + +114  + #__ULONG32_TYPE +  + + ) + +115  + #__S64_TYPE + +__quad_t + + + ) + +116  + #__U64_TYPE + +__u_quad_t + + + ) + +117 #i +__WORDSIZE + == 64 + +118  + #__SQUAD_TYPE +  + + ) + +119  + #__UQUAD_TYPE +  + + ) + +120  + #__SWORD_TYPE +  + + ) + +121  + #__UWORD_TYPE +  + + ) + +122  + #__SLONG32_TYPE +  + + ) + +123  + #__ULONG32_TYPE +  + + ) + +124  + #__S64_TYPE +  + + ) + +125  + #__U64_TYPE +  + + ) + +129  + ~ + +133  + #__STD_TYPE + +__exnsi__ +  + + ) + +136 +__STD_TYPE + + t__DEV_T_TYPE + + t__dev_t +; + +137 +__STD_TYPE + +__UID_T_TYPE + + g__uid_t +; + +138 +__STD_TYPE + +__GID_T_TYPE + + g__gid_t +; + +139 +__STD_TYPE + +__INO_T_TYPE + + g__o_t +; + +140 +__STD_TYPE + +__INO64_T_TYPE + + g__o64_t +; + +141 +__STD_TYPE + +__MODE_T_TYPE + + g__mode_t +; + +142 +__STD_TYPE + +__NLINK_T_TYPE + + g__ƚk_t +; + +143 +__STD_TYPE + +__OFF_T_TYPE + + g__off_t +; + +144 +__STD_TYPE + +__OFF64_T_TYPE + + g__off64_t +; + +145 +__STD_TYPE + +__PID_T_TYPE + + g__pid_t +; + +146 +__STD_TYPE + +__FSID_T_TYPE + + g__fsid_t +; + +147 +__STD_TYPE + +__CLOCK_T_TYPE + + g__ock_t +; + +148 +__STD_TYPE + +__RLIM_T_TYPE + + g__im_t +; + +149 +__STD_TYPE + +__RLIM64_T_TYPE + + g__im64_t +; + +150 +__STD_TYPE + +__ID_T_TYPE + + g__id_t +; + +151 +__STD_TYPE + +__TIME_T_TYPE + + g__time_t +; + +152 +__STD_TYPE + +__USECONDS_T_TYPE + + g__ucds_t +; + +153 +__STD_TYPE + +__SUSECONDS_T_TYPE + + g__sucds_t +; + +155 +__STD_TYPE + +__DADDR_T_TYPE + + g__daddr_t +; + +156 +__STD_TYPE + +__SWBLK_T_TYPE + + g__swblk_t +; + +157 +__STD_TYPE + +__KEY_T_TYPE + + g__key_t +; + +160 +__STD_TYPE + +__CLOCKID_T_TYPE + + g__ockid_t +; + +163 +__STD_TYPE + +__TIMER_T_TYPE + + g__tim_t +; + +166 +__STD_TYPE + +__BLKSIZE_T_TYPE + + g__blksize_t +; + +171 +__STD_TYPE + +__BLKCNT_T_TYPE + + g__blkt_t +; + +172 +__STD_TYPE + +__BLKCNT64_T_TYPE + + g__blkt64_t +; + +175 +__STD_TYPE + +__FSBLKCNT_T_TYPE + + g__fsblkt_t +; + +176 +__STD_TYPE + +__FSBLKCNT64_T_TYPE + + g__fsblkt64_t +; + +179 +__STD_TYPE + +__FSFILCNT_T_TYPE + + g__fsft_t +; + +180 +__STD_TYPE + +__FSFILCNT64_T_TYPE + + g__fsft64_t +; + +182 +__STD_TYPE + +__SSIZE_T_TYPE + + g__ssize_t +; + +186  +__off64_t + + t__loff_t +; + +187  +__quad_t + * + t__qaddr_t +; + +188 * + t__ddr_t +; + +191 +__STD_TYPE + +__SWORD_TYPE + + g___t +; + +194 +__STD_TYPE + +__U32_TYPE + + g__sockn_t +; + +197 #unde +__STD_TYPE + + + @/usr/include/bits/waitflags.h + +20 #i! +defed + +_SYS_WAIT_H + && !defed +_STDLIB_H + + +26  + #WNOHANG + 1 + + ) + +27  + #WUNTRACED + 2 + + ) + +30  + #WSTOPPED + 2 + + ) + +31  + #WEXITED + 4 + + ) + +32  + #WCONTINUED + 8 + + ) + +33  + #WNOWAIT + 0x01000000 + + ) + +35  + #__WALL + 0x40000000 + + ) + +36  + #__WCLONE + 0x80000000 + + ) + + @/usr/include/bits/waitstatus.h + +20 #i! +defed + +_SYS_WAIT_H + && !defed +_STDLIB_H + + +29  + #__WEXITSTATUS +( +us +(((us& 0xff00>> 8) + + ) + +32  + #__WTERMSIG +( +us +((us& 0x7f) + + ) + +35  + #__WSTOPSIG +( +us + + `__WEXITSTATUS +(us) + + ) + +38  + #__WIFEXITED +( +us +( + `__WTERMSIG +(us=0) + + ) + +41  + #__WIFSIGNALED +( +us +) \ + +42 (((sigd ((( +us +& 0x7f+ 1>> 1> 0) + + ) + +45  + #__WIFSTOPPED +( +us +(((us& 0xff=0x7f) + + ) + +49 #ifde +WCONTINUED + + +50  + #__WIFCONTINUED +( +us +((us= +__W_CONTINUED +) + + ) + +54  + #__WCOREDUMP +( +us +((us& +__WCOREFLAG +) + + ) + +57  + #__W_EXITCODE +( +t +, +sig +(ԑ<< 8 | (sig)) + + ) + +58  + #__W_STOPCODE +( +sig +((sig<< 8 | 0x7f) + + ) + +59  + #__W_CONTINUED + 0xffff + + ) + +60  + #__WCOREFLAG + 0x80 + + ) + +63 #ifdef +__USE_BSD + + +65  + ~ + +67  + uwa + + +69  + mw_us +; + +72 #if +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +73  + m__w_rmsig +:7; + +74  + m__w_cedump +:1; + +75  + m__w_tcode +:8; + +78 #if +__BYTE_ORDER + = +__BIG_ENDIAN + + +80  + m__w_tcode +:8; + +81  + m__w_cedump +:1; + +82  + m__w_rmsig +:7; + +84 } + m__wa_rmed +; + +87 #if +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +88  + m__w_v +:8; + +89  + m__w_sig +:8; + +92 #if +__BYTE_ORDER + = +__BIG_ENDIAN + + +94  + m__w_sig +:8; + +95  + m__w_v +:8; + +97 } + m__wa_ݳd +; + +100  + #w_rmsig + +__wa_rmed +. +__w_rmsig + + + ) + +101  + #w_cedump + +__wa_rmed +. +__w_cedump + + + ) + +102  + #w_tcode + +__wa_rmed +. +__w_tcode + + + ) + +103  + #w_sig + +__wa_ݳd +. +__w_sig + + + ) + +104  + #w_v + +__wa_ݳd +. +__w_v + + + ) + + @/usr/include/bits/wchar.h + +20 #ide +_BITS_WCHAR_H + + +21  + #_BITS_WCHAR_H + 1 + + ) + +23  + #__WCHAR_MIN + (-2147483647- 1l) + + ) + +24  + #__WCHAR_MAX + (2147483647l) + + ) + + @/usr/include/bits/wordsize.h + +19  + #__WORDSIZE + 32 + + ) + + @/usr/include/endian.h + +19 #idef +_ENDIAN_H + + +20  + #_ENDIAN_H + 1 + + ) + +22  + ~ + +32  + #__LITTLE_ENDIAN + 1234 + + ) + +33  + #__BIG_ENDIAN + 4321 + + ) + +34  + #__PDP_ENDIAN + 3412 + + ) + +37  + ~ + +41 #ide +__FLOAT_WORD_ORDER + + +42  + #__FLOAT_WORD_ORDER + +__BYTE_ORDER + + + ) + +45 #ifdef +__USE_BSD + + +46  + #LITTLE_ENDIAN + +__LITTLE_ENDIAN + + + ) + +47  + #BIG_ENDIAN + +__BIG_ENDIAN + + + ) + +48  + #PDP_ENDIAN + +__PDP_ENDIAN + + + ) + +49  + #BYTE_ORDER + +__BYTE_ORDER + + + ) + +52 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +53  + #__LONG_LONG_PAIR +( +HI +, +LO +LO, + ) +HI + +54 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +55  + #__LONG_LONG_PAIR +( +HI +, +LO +HI, + ) +LO + + @/usr/include/features.h + +19 #idef +_FEATURES_H + + +20  + #_FEATURES_H + 1 + + ) + +90 #unde +__USE_ISOC99 + + +91 #unde +__USE_POSIX + + +92 #unde +__USE_POSIX2 + + +93 #unde +__USE_POSIX199309 + + +94 #unde +__USE_POSIX199506 + + +95 #unde +__USE_XOPEN + + +96 #unde +__USE_XOPEN_EXTENDED + + +97 #unde +__USE_UNIX98 + + +98 #unde +__USE_XOPEN2K + + +99 #unde +__USE_LARGEFILE + + +100 #unde +__USE_LARGEFILE64 + + +101 #unde +__USE_FILE_OFFSET64 + + +102 #unde +__USE_BSD + + +103 #unde +__USE_SVID + + +104 #unde +__USE_MISC + + +105 #unde +__USE_GNU + + +106 #unde +__USE_REENTRANT + + +107 #unde +__USE_FORTIFY_LEVEL + + +108 #unde +__FAVOR_BSD + + +109 #unde +__KERNEL_STRICT_NAMES + + +113 #ide +_LOOSE_KERNEL_NAMES + + +114  + #__KERNEL_STRICT_NAMES + + + ) + +118  + #__USE_ANSI + 1 + + ) + +127 #i +defed + +__GNUC__ + && defed +__GNUC_MINOR__ + + +128  + #__GNUC_PREREQ +( +maj +, +m +) \ + +129 (( +__GNUC__ + << 16+ +__GNUC_MINOR__ + >(( +maj +<< 16+ ( +m +)) + + ) + +131  + #__GNUC_PREREQ +( +maj +, +m +0 + + ) + +136 #i +defed + +_BSD_SOURCE + && \ + +137 !( +defed + + g_POSIX_SOURCE + || defed + g_POSIX_C_SOURCE + || \ + +138 +defed + + g_XOPEN_SOURCE + || defed + g_XOPEN_SOURCE_EXTENDED + || \ + +139 +defed + + g_GNU_SOURCE + || defed + g_SVID_SOURCE +) + +140  + #__FAVOR_BSD + 1 + + ) + +144 #ifde +_GNU_SOURCE + + +145 #unde +_ISOC99_SOURCE + + +146  + #_ISOC99_SOURCE + 1 + + ) + +147 #unde +_POSIX_SOURCE + + +148  + #_POSIX_SOURCE + 1 + + ) + +149 #unde +_POSIX_C_SOURCE + + +150  + #_POSIX_C_SOURCE + 199506L + + ) + +151 #unde +_XOPEN_SOURCE + + +152  + #_XOPEN_SOURCE + 600 + + ) + +153 #unde +_XOPEN_SOURCE_EXTENDED + + +154  + #_XOPEN_SOURCE_EXTENDED + 1 + + ) + +155 #unde +_LARGEFILE64_SOURCE + + +156  + #_LARGEFILE64_SOURCE + 1 + + ) + +157 #unde +_BSD_SOURCE + + +158  + #_BSD_SOURCE + 1 + + ) + +159 #unde +_SVID_SOURCE + + +160  + #_SVID_SOURCE + 1 + + ) + +165 #i(! +defed + +__STRICT_ANSI__ + && !defed +_ISOC99_SOURCE + && \ + +166 ! +defed + + g_POSIX_SOURCE + && !defed + g_POSIX_C_SOURCE + && \ + +167 ! +defed + + g_XOPEN_SOURCE + && !defed + g_XOPEN_SOURCE_EXTENDED + && \ + +168 ! +defed + + g_BSD_SOURCE + && !defed + g_SVID_SOURCE +) + +169  + #_BSD_SOURCE + 1 + + ) + +170  + #_SVID_SOURCE + 1 + + ) + +177 #i( +defed + +_ISOC99_SOURCE + || defed +_ISOC9X_SOURCE + \ + +178 || ( +defed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L)) + +179  + #__USE_ISOC99 + 1 + + ) + +184 #i((! +defed + +__STRICT_ANSI__ + || ( +_XOPEN_SOURCE + - 0) >= 500) && \ + +185 ! +defed + +_POSIX_SOURCE + && !defed +_POSIX_C_SOURCE +) + +186  + #_POSIX_SOURCE + 1 + + ) + +187 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 500 + +188  + #_POSIX_C_SOURCE + 2 + + ) + +190  + #_POSIX_C_SOURCE + 199506L + + ) + +194 #i +defed + +_POSIX_SOURCE + || +_POSIX_C_SOURCE + >1 || defed +_XOPEN_SOURCE + + +195  + #__USE_POSIX + 1 + + ) + +198 #i +defed + +_POSIX_C_SOURCE + && _POSIX_C_SOURCE >2 || defed +_XOPEN_SOURCE + + +199  + #__USE_POSIX2 + 1 + + ) + +202 #i( +_POSIX_C_SOURCE + - 0) >= 199309L + +203  + #__USE_POSIX199309 + 1 + + ) + +206 #i( +_POSIX_C_SOURCE + - 0) >= 199506L + +207  + #__USE_POSIX199506 + 1 + + ) + +210 #i( +_POSIX_C_SOURCE + - 0) >= 200112L + +211  + #__USE_XOPEN2K + 1 + + ) + +214 #ifdef +_XOPEN_SOURCE + + +215  + #__USE_XOPEN + 1 + + ) + +216 #i( +_XOPEN_SOURCE + - 0) >= 500 + +217  + #__USE_XOPEN_EXTENDED + 1 + + ) + +218  + #__USE_UNIX98 + 1 + + ) + +219 #unde +_LARGEFILE_SOURCE + + +220  + #_LARGEFILE_SOURCE + 1 + + ) + +221 #i( +_XOPEN_SOURCE + - 0) >= 600 + +222  + #__USE_XOPEN2K + 1 + + ) + +223 #unde +__USE_ISOC99 + + +224  + #__USE_ISOC99 + 1 + + ) + +227 #ifde +_XOPEN_SOURCE_EXTENDED + + +228  + #__USE_XOPEN_EXTENDED + 1 + + ) + +233 #ifde +_LARGEFILE_SOURCE + + +234  + #__USE_LARGEFILE + 1 + + ) + +237 #ifde +_LARGEFILE64_SOURCE + + +238  + #__USE_LARGEFILE64 + 1 + + ) + +241 #i +defed + +_FILE_OFFSET_BITS + && _FILE_OFFSET_BITS == 64 + +242  + #__USE_FILE_OFFSET64 + 1 + + ) + +245 #i +defed + +_BSD_SOURCE + || defed +_SVID_SOURCE + + +246  + #__USE_MISC + 1 + + ) + +249 #ifdef +_BSD_SOURCE + + +250  + #__USE_BSD + 1 + + ) + +253 #ifdef +_SVID_SOURCE + + +254  + #__USE_SVID + 1 + + ) + +257 #ifdef +_GNU_SOURCE + + +258  + #__USE_GNU + 1 + + ) + +261 #i +defed + +_REENTRANT + || defed +_THREAD_SAFE + + +262  + #__USE_REENTRANT + 1 + + ) + +265 #i +_FORTIFY_SOURCE + > 0 && +__GNUC_PREREQ + (4, 1&& +__OPTIMIZE__ + > 0 + +266 #i +_FORTIFY_SOURCE + == 1 + +267  + #__USE_FORTIFY_LEVEL + 1 + + ) + +268 #i +_FORTIFY_SOURCE + > 1 + +269  + #__USE_FORTIFY_LEVEL + 2 + + ) + +274  + #__STDC_IEC_559__ + 1 + + ) + +275  + #__STDC_IEC_559_COMPLEX__ + 1 + + ) + +278  + #__STDC_ISO_10646__ + 200009L + + ) + +286 #unde +__GNU_LIBRARY__ + + +287  + #__GNU_LIBRARY__ + 6 + + ) + +291  + #__GLIBC__ + 2 + + ) + +292  + #__GLIBC_MINOR__ + 3 + + ) + +294  + #__GLIBC_PREREQ +( +maj +, +m +) \ + +295 (( +__GLIBC__ + << 16+ +__GLIBC_MINOR__ + >(( +maj +<< 16+ ( +m +)) + + ) + +298 #i +defed + +__GNUC__ + \ + +299 || ( +defed + + g__PGI + && defed + g__i386__ + ) \ + +300 || ( +defed + + g__INTEL_COMPILER + && (defed + g__i386__ + || defed + g__64__ +)) \ + +301 || ( +defed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L) + +302  + #__GLIBC_HAVE_LONG_LONG + 1 + + ) + +306 #ide +__ASSEMBLER__ + + +307 #ide +_SYS_CDEFS_H + + +308  + ~ + +313 #i +defed + +__USE_FILE_OFFSET64 + && !defed +__REDIRECT + + +314  + #__USE_LARGEFILE + 1 + + ) + +315  + #__USE_LARGEFILE64 + 1 + + ) + +321 #i +__GNUC_PREREQ + (2, 7&& +defed + +__OPTIMIZE__ + \ + +322 && ! +defed + + g__OPTIMIZE_SIZE__ + && !defed + g__NO_INLINE__ + + +323  + #__USE_EXTERN_INLINES + 1 + + ) + +331  + ~ + + @/usr/include/libio.h + +29 #ide +_IO_STDIO_H + + +30  + #_IO_STDIO_H + + + ) + +32  + ~<_G_cfig.h +> + +34  + #_IO_pos_t + +_G_os_t + + + ) + +35  + #_IO_os_t + +_G_os_t + + + ) + +36  + #_IO_os64_t + +_G_os64_t + + + ) + +37  + #_IO_size_t + +_G_size_t + + + ) + +38  + #_IO_ssize_t + +_G_ssize_t + + + ) + +39  + #_IO_off_t + +_G_off_t + + + ) + +40  + #_IO_off64_t + +_G_off64_t + + + ) + +41  + #_IO_pid_t + +_G_pid_t + + + ) + +42  + #_IO_uid_t + +_G_uid_t + + + ) + +43  + #_IO_icv_t + +_G_icv_t + + + ) + +44  + #_IO_HAVE_SYS_WAIT + +_G_HAVE_SYS_WAIT + + + ) + +45  + #_IO_HAVE_ST_BLKSIZE + +_G_HAVE_ST_BLKSIZE + + + ) + +46  + #_IO_BUFSIZ + +_G_BUFSIZ + + + ) + +47  + #_IO_va_li + +_G_va_li + + + ) + +48  + #_IO_wt_t + +_G_wt_t + + + ) + +50 #ifde +_G_NEED_STDARG_H + + +52  + #__ed___va_li + + + ) + +53  + ~ + +54 #ifde +__GNUC_VA_LIST + + +55 #unde +_IO_va_li + + +56  + #_IO_va_li + +__gnuc_va_li + + + ) + +60 #ide +__P + + +61 #i +_G_HAVE_SYS_CDEFS + + +62  + ~ + +64 #ifde +__STDC__ + + +65  + #__P +( +p + + ) +p + +66  + #__PMT +( +p + + ) +p + +68  + #__P +( +p +() + + ) + +69  + #__PMT +( +p +() + + ) + +75 #ide +_PARAMS + + +76  + #_PARAMS +( +os + + `__P +ros) + + ) + +79 #ide +__STDC__ + + +81 cڡ + + ) + +84  + #_IO_UNIFIED_JUMPTABLES + 1 + + ) + +85 #ide +_G_HAVE_PRINTF_FP + + +86  + #_IO_USE_DTOA + 1 + + ) + +89 #ide +EOF + + +90  + #EOF + (-1) + + ) + +92 #ide +NULL + + +93 #i +defed + +__GNUG__ + && \ + +94 ( + g__GNUC__ + > 2 || (__GNUC__ =2 && +__GNUC_MINOR__ + >= 8)) + +95  + #NULL + ( +__nu +) + + ) + +97 #i! +defed +( +__lulus +) + +98  + #NULL + ((*)0) + + ) + +100  + #NULL + (0) + + ) + +105  + #_IOS_INPUT + 1 + + ) + +106  + #_IOS_OUTPUT + 2 + + ) + +107  + #_IOS_ATEND + 4 + + ) + +108  + #_IOS_APPEND + 8 + + ) + +109  + #_IOS_TRUNC + 16 + + ) + +110  + #_IOS_NOCREATE + 32 + + ) + +111  + #_IOS_NOREPLACE + 64 + + ) + +112  + #_IOS_BIN + 128 + + ) + +120  + #_IO_MAGIC + 0xFBAD0000 + + ) + +121  + #_OLD_STDIO_MAGIC + 0xFABC0000 + + ) + +122  + #_IO_MAGIC_MASK + 0xFFFF0000 + + ) + +123  + #_IO_USER_BUF + 1 + + ) + +124  + #_IO_UNBUFFERED + 2 + + ) + +125  + #_IO_NO_READS + 4 + + ) + +126  + #_IO_NO_WRITES + 8 + + ) + +127  + #_IO_EOF_SEEN + 0x10 + + ) + +128  + #_IO_ERR_SEEN + 0x20 + + ) + +129  + #_IO_DELETE_DONT_CLOSE + 0x40 + + ) + +130  + #_IO_LINKED + 0x80 + + ) + +131  + #_IO_IN_BACKUP + 0x100 + + ) + +132  + #_IO_LINE_BUF + 0x200 + + ) + +133  + #_IO_TIED_PUT_GET + 0x400 + + ) + +134  + #_IO_CURRENTLY_PUTTING + 0x800 + + ) + +135  + #_IO_IS_APPENDING + 0x1000 + + ) + +136  + #_IO_IS_FILEBUF + 0x2000 + + ) + +137  + #_IO_BAD_SEEN + 0x4000 + + ) + +138  + #_IO_USER_LOCK + 0x8000 + + ) + +140  + #_IO_FLAGS2_MMAP + 1 + + ) + +141  + #_IO_FLAGS2_NOTCANCEL + 2 + + ) + +142 #ifde +_LIBC + + +143  + #_IO_FLAGS2_FORTIFY + 4 + + ) + +147  + #_IO_SKIPWS + 01 + + ) + +148  + #_IO_LEFT + 02 + + ) + +149  + #_IO_RIGHT + 04 + + ) + +150  + #_IO_INTERNAL + 010 + + ) + +151  + #_IO_DEC + 020 + + ) + +152  + #_IO_OCT + 040 + + ) + +153  + #_IO_HEX + 0100 + + ) + +154  + #_IO_SHOWBASE + 0200 + + ) + +155  + #_IO_SHOWPOINT + 0400 + + ) + +156  + #_IO_UPPERCASE + 01000 + + ) + +157  + #_IO_SHOWPOS + 02000 + + ) + +158  + #_IO_SCIENTIFIC + 04000 + + ) + +159  + #_IO_FIXED + 010000 + + ) + +160  + #_IO_UNITBUF + 020000 + + ) + +161  + #_IO_STDIO + 040000 + + ) + +162  + #_IO_DONT_CLOSE + 0100000 + + ) + +163  + #_IO_BOOLALPHA + 0200000 + + ) + +166  +_IO_jump_t +;  + g_IO_FILE +; + +169 #ifde +_IO_MTSAFE_IO + + +170 #i +defed + +__GLIBC__ + && __GLIBC__ >= 2 + +171  + ~ + +176  + t_IO_lock_t +; + +182  + s_IO_mk + { + +183  +_IO_mk + * + m_xt +; + +184  +_IO_FILE + * + m_sbuf +; + +188  + m_pos +; + +190  +t_ampos +( +ampos + + +{ + m_os + = sp; } + +191  +t_offt +( +offt +{ + m_pos + = offt; + m_os + = ( +ampos +)(-2); } + +192 + mpublic +: + +193 +ammk +( +ambuf + * +sb +); + +194 ~ +ammk +(); + +195  +vg +({  + m_os + == -2; } + +196  +d +( +ammk +&); + +197  +d +(); + +202 + e__codecvt_su + + +204 + m__codecvt_ok +, + +205 + m__codecvt_l +, + +206 + m__codecvt_r +, + +207 + m__codecvt_nocv + + +210 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +213  + s_IO_codecvt + + +215 (* + m__codecvt_der +( + m_IO_codecvt + *); + +216 +__codecvt_su + (* +__codecvt_do_out +( + m_IO_codecvt + *, + +217 + m__mbe_t + *, + +218 cڡ + mwch_t + *, + +219 cڡ + mwch_t + *, + +220 cڡ + mwch_t + **, *, + +222 +__codecvt_su + (* +__codecvt_do_unshi +( + m_IO_codecvt + *, + +223 + m__mbe_t + *, *, + +225 +__codecvt_su + (* +__codecvt_do_ +( + m_IO_codecvt + *, + +226 + m__mbe_t + *, + +228 cڡ **, + mwch_t + *, + +229 + mwch_t + *, wchar_t **); + +230 (* + m__codecvt_do_codg +( + m_IO_codecvt + *); + +231 (* + m__codecvt_do_ways_nocv +( + m_IO_codecvt + *); + +232 (* + m__codecvt_do_ngth +( + m_IO_codecvt + *, + m__mbe_t + *, + +233 cڡ *, cڡ *, + m_IO_size_t +); + +234 (* + m__codecvt_do_max_ngth +( + m_IO_codecvt + *); + +236 +_IO_icv_t + + m__cd_ +; + +237 +_IO_icv_t + + m__cd_out +; + +241  + s_IO_wide_da + + +243 +wch_t + * + m_IO_ad_r +; + +244 +wch_t + * + m_IO_ad_d +; + +245 +wch_t + * + m_IO_ad_ba +; + +246 +wch_t + * + m_IO_wre_ba +; + +247 +wch_t + * + m_IO_wre_r +; + +248 +wch_t + * + m_IO_wre_d +; + +249 +wch_t + * + m_IO_buf_ba +; + +250 +wch_t + * + m_IO_buf_d +; + +252 +wch_t + * + m_IO_ve_ba +; + +253 +wch_t + * + m_IO_backup_ba +; + +255 +wch_t + * + m_IO_ve_d +; + +257 +__mbe_t + + m_IO_e +; + +258 +__mbe_t + + m_IO_ϡ_e +; + +259  +_IO_codecvt + + m_codecvt +; + +261 +wch_t + + m_shtbuf +[1]; + +263 cڡ  +_IO_jump_t + * + m_wide_vb +; + +267  + s_IO_FILE + { + +268  + m_ags +; + +269  + #_IO_fe_ags + +_ags + + + ) + +273 * + m_IO_ad_r +; + +274 * + m_IO_ad_d +; + +275 * + m_IO_ad_ba +; + +276 * + m_IO_wre_ba +; + +277 * + m_IO_wre_r +; + +278 * + m_IO_wre_d +; + +279 * + m_IO_buf_ba +; + +280 * + m_IO_buf_d +; + +282 * + m_IO_ve_ba +; + +283 * + m_IO_backup_ba +; + +284 * + m_IO_ve_d +; + +286  +_IO_mk + * + m_mks +; + +288  +_IO_FILE + * + m_cha +; + +290  + m_fo +; + +292  + m_blksize +; + +294  + m_ags2 +; + +296 +_IO_off_t + + m_d_offt +; + +298  + #__HAVE_COLUMN + + + ) + +300  + m_cur_cumn +; + +301 sigd  + m_vb_offt +; + +302  + m_shtbuf +[1]; + +306 +_IO_lock_t + * + m_lock +; + +307 #ifde +_IO_USE_OLD_IO_FILE + + +310  + s_IO_FILE_come + + +312  +_IO_FILE + + m_fe +; + +314 #i +defed + +_G_IO_IO_FILE_VERSION + && _G_IO_IO_FILE_VERSION == 0x20001 + +315 +_IO_off64_t + + m_offt +; + +316 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +318  +_IO_codecvt + * + m_codecvt +; + +319  +_IO_wide_da + * + m_wide_da +; + +321 * + m__d1 +; + +322 * + m__d2 +; + +324  + m_mode +; + +326  + m_unud2 +[15 *  () - 2 *  (*)]; + +330 #ide +__lulus + + +331  +_IO_FILE + + t_IO_FILE +; + +334  + g_IO_FILE_us +; + +336  +_IO_FILE_us + +_IO_2_1_d_ +; + +337  +_IO_FILE_us + +_IO_2_1_dout_ +; + +338  +_IO_FILE_us + +_IO_2_1_dr_ +; + +339 #ide +_LIBC + + +340  + #_IO_d + (( +_IO_FILE +*)(& +_IO_2_1_d_ +)) + + ) + +341  + #_IO_dout + (( +_IO_FILE +*)(& +_IO_2_1_dout_ +)) + + ) + +342  + #_IO_dr + (( +_IO_FILE +*)(& +_IO_2_1_dr_ +)) + + ) + +344 +_IO_FILE + * +_IO_d + +ibu_hidd +; + +345 +_IO_FILE + * +_IO_dout + +ibu_hidd +; + +346 +_IO_FILE + * +_IO_dr + +ibu_hidd +; + +354  +__ssize_t + + t__io_ad_ + (* + t__cook +, * + t__buf +, + tsize_t + + t__nbys +); + +362  +__ssize_t + + t__io_wre_ + (* + t__cook +, + t__cڡ + * + t__buf +, + +363 + tsize_t + + t__n +); + +371  + t__io_ek_ + (* + t__cook +, + t_IO_off64_t + * + t__pos +,  + t__w +); + +374  + t__io_o_ + (* + t__cook +); + +377 #ifde +_GNU_SOURCE + + +379  +__io_ad_ + + tcook_ad_funi_t +; + +380  +__io_wre_ + + tcook_wre_funi_t +; + +381  +__io_ek_ + + tcook_ek_funi_t +; + +382  +__io_o_ + + tcook_o_funi_t +; + +387 +__io_ad_ + * + mad +; + +388 +__io_wre_ + * + mwre +; + +389 +__io_ek_ + * + mek +; + +390 +__io_o_ + * + mo +; + +391 } + t_IO_cook_io_funis_t +; + +392  +_IO_cook_io_funis_t + + tcook_io_funis_t +; + +394  + g_IO_cook_fe +; + +397  +_IO_cook_ + ( +_IO_cook_fe + * +__cfe +,  +__ad_wre +, + +398 * +__cook +, +_IO_cook_io_funis_t + +__s +); + +402 #ifde +__lulus + + +406  +__undow + ( +_IO_FILE + * +__THROW +; + +407  +__uow + ( +_IO_FILE + * +__THROW +; + +408  +__ovow + ( +_IO_FILE + *,  +__THROW +; + +409 +_IO_wt_t + +__wundow + ( +_IO_FILE + * +__THROW +; + +410 +_IO_wt_t + +__wuow + ( +_IO_FILE + * +__THROW +; + +411 +_IO_wt_t + +__wovow + ( +_IO_FILE + *, _IO_wt_t +__THROW +; + +413 #i +__GNUC__ + >= 3 + +414  + #_IO_BE +( +ex +, +s + + `__but_ex + (ex,es) + + ) + +416  + #_IO_BE +( +ex +, +s +x) + + ) + +419  + #_IO_gc_uocked +( +_ +) \ + +420 ( + `_IO_BE + (( +_ +)-> +_IO_ad_r + >(_)-> +_IO_ad_d +, 0) \ + +421 ? + `__uow + ( +_ +: *(*(_)-> +_IO_ad_r +++) + + ) + +422  + #_IO_ekc_uocked +( +_ +) \ + +423 ( + `_IO_BE + (( +_ +)-> +_IO_ad_r + >(_)-> +_IO_ad_d +, 0) \ + +424 && + `__undow + ( +_ += +EOF + ? EOF \ + +425 : *(*( +_ +)-> +_IO_ad_r +) + + ) + +426  + #_IO_putc_uocked +( +_ch +, +_ +) \ + +427 ( + `_IO_BE + (( +_ +)-> +_IO_wre_r + >(_)-> +_IO_wre_d +, 0) \ + +428 ? + `__ovow + ( +_ +, (( +_ch +)) \ + +429 : ((*( +_ +)-> +_IO_wre_r +++ = ( +_ch +))) + + ) + +431  + #_IO_gwc_uocked +( +_ +) \ + +432 ( + `_IO_BE + (( +_ +)-> +_wide_da +-> +_IO_ad_r + >(_)->_wide_da-> +_IO_ad_d +,\ + +434 ? + `__wuow + ( +_ +: ( +_IO_wt_t +*(_)-> +_wide_da +-> +_IO_ad_r +++) + + ) + +435  + #_IO_putwc_uocked +( +_wch +, +_ +) \ + +436 ( + `_IO_BE + (( +_ +)-> +_wide_da +-> +_IO_wre_r + \ + +437 >( +_ +)-> +_wide_da +-> +_IO_wre_d +, 0) \ + +438 ? + `__wovow + ( +_ +, +_wch +) \ + +439 : ( +_IO_wt_t +(*( +_ +)-> +_wide_da +-> +_IO_wre_r +++ = ( +_wch +))) + + ) + +441  + #_IO_of_uocked +( +__ +(((__)-> +_ags + & +_IO_EOF_SEEN +!0) + + ) + +442  + #_IO__uocked +( +__ +(((__)-> +_ags + & +_IO_ERR_SEEN +!0) + + ) + +444  +_IO_gc + ( +_IO_FILE + * +__ + +__THROW +; + +445  +_IO_putc + ( +__c +, +_IO_FILE + * +__ + +__THROW +; + +446  +_IO_of + ( +_IO_FILE + * +__ + +__THROW +; + +447  +_IO_ + ( +_IO_FILE + * +__ + +__THROW +; + +449  +_IO_ekc_locked + ( +_IO_FILE + * +__ + +__THROW +; + +452  + #_IO_PENDING_OUTPUT_COUNT +( +_ +) \ + +453 (( +_ +)-> +_IO_wre_r + - (_)-> +_IO_wre_ba +) + + ) + +455  +_IO_ockfe + ( +_IO_FILE + * +__THROW +; + +456  +_IO_fuockfe + ( +_IO_FILE + * +__THROW +; + +457  +_IO_rylockfe + ( +_IO_FILE + * +__THROW +; + +459 #ifde +_IO_MTSAFE_IO + + +460  + #_IO_ekc +( +_ + + `_IO_ekc_locked + (_) + + ) + +461  + #_IO_ockfe +( +_ +) \ + +462 i((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0 + `_IO_ockfe + (_) + + ) + +463  + #_IO_fuockfe +( +_ +) \ + +464 i((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0 + `_IO_fuockfe + (_) + + ) + +466  + #_IO_ekc +( +_ + + `_IO_ekc_uocked + (_) + + ) + +467  + #_IO_ockfe +( +_ + + + ) + +468  + #_IO_fuockfe +( +_ + + + ) + +469  + #_IO_rylockfe +( +_ + + + ) + +470  + #_IO_nup_gi_t +( +_f +, +_ + + + ) + +471  + #_IO_nup_gi_d +( +_Do + + + ) + +474  +_IO_vfsnf + ( +_IO_FILE + * +__ri +, const * __restrict, + +475 +_IO_va_li +, * +__ri + +__THROW +; + +476  +_IO_vrtf + ( +_IO_FILE + * +__ri +, const *__restrict, + +477 +_IO_va_li + +__THROW +; + +478 +_IO_ssize_t + +_IO_dn + ( +_IO_FILE + *, , _IO_ssize_t +__THROW +; + +479 +_IO_size_t + +_IO_sgn + ( +_IO_FILE + *, *, _IO_size_t +__THROW +; + +481 +_IO_off64_t + +_IO_ekoff + ( +_IO_FILE + *, _IO_off64_t, ,  +__THROW +; + +482 +_IO_off64_t + +_IO_ekpos + ( +_IO_FILE + *, _IO_off64_t,  +__THROW +; + +484  +_IO__backup_ + ( +_IO_FILE + * +__THROW +; + +486 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +487 +_IO_wt_t + +_IO_gwc + ( +_IO_FILE + * +__ + +__THROW +; + +488 +_IO_wt_t + +_IO_putwc + ( +wch_t + +__wc +, +_IO_FILE + * +__ + +__THROW +; + +489  +_IO_fwide + ( +_IO_FILE + * +__ +,  +__mode + +__THROW +; + +490 #i +__GNUC__ + >= 2 + +493 #i +defed + +_LIBC + && defed +SHARED + + +494  + ~ + +495 #i +SHLIB_COMPAT + ( +libc +, +GLIBC_2_0 +, +GLIBC_2_1 +) + +496  + #_IO_fwide_maybe_comtib + \ + +497 ( + `__but_ex + (& +_IO_d_ud + = +NULL +, 0)) + + ) + +498 cڡ  +_IO_d_ud +; + +499 +wk_ex + ( +_IO_d_ud +); + +502 #ide +_IO_fwide_maybe_comtib + + +503  + #_IO_fwide_maybe_comtib + (0) + + ) + +507  + #_IO_fwide +( +__ +, +__mode +) \ + +508 ({  +__su + = ( +__mode +); \ + +509 i( +__su + < 0 && ! +_IO_fwide_maybe_comtib +) \ + +511 i(( +__ +)-> +_mode + == 0) \ + +513 ( +__ +)-> +_mode + = -1; \ + +514 +__su + = ( +__ +)-> +_mode +; \ + +516 i( + `__but_cڡt_p + ( +__mode +) && (__mode) == 0) \ + +517 +__su + = +_IO_fwide_maybe_comtib + ? -1 : ( +__ +)-> +_mode +; \ + +519 +__su + = + `_IO_fwide + ( +__ +, __result); \ + +520 +__su +; }) + + ) + +523  +_IO_vfwsnf + ( +_IO_FILE + * +__ri +, cڡ +wch_t + * __restrict, + +524 +_IO_va_li +, * +__ri + +__THROW +; + +525  +_IO_vfwtf + ( +_IO_FILE + * +__ri +, cڡ +wch_t + *__restrict, + +526 +_IO_va_li + +__THROW +; + +527 +_IO_ssize_t + +_IO_wdn + ( +_IO_FILE + *, +wt_t +, _IO_ssize_t +__THROW +; + +528  +_IO__wbackup_ + ( +_IO_FILE + * +__THROW +; + +531 #ifde +__lulus + + + @/usr/include/linux/backing-dev.h + +8 #ide +_LINUX_BACKING_DEV_H + + +9  + #_LINUX_BACKING_DEV_H + + + ) + +15 + ebdi_e + { + +16 + mBDI_pdush +, + +17 + mBDI_wre_cgeed +, + +18 + mBDI_ad_cgeed +, + +19 + mBDI_unud +, + +22 ( + tcgeed_ +)(*, ); + +24  + sbackg_dev_fo + { + +25  +_ges +; + +26  +e +; + +27  +memy_backed +; + +28 +cgeed_ + *congested_fn; + +29 * +cgeed_da +; + +30 (* +ulug_io_ +)( +backg_dev_fo + *,  +ge + *); + +31 * +ulug_io_da +; + +34  +backg_dev_fo + +deu_backg_dev_fo +; + +35  + `deu_ulug_io_ +( +backg_dev_fo + * +bdi +,  +ge + *page); + +37  + `wreback_acque +( +backg_dev_fo + * +bdi +); + +38  + `wreback__ogss +( +backg_dev_fo + * +bdi +); + +39  + `wreback_a +( +backg_dev_fo + * +bdi +); + +41  +le +  + $bdi_cgeed +( +backg_dev_fo + * +bdi +,  +bdi_bs +) + +43 i( +bdi +-> +cgeed_ +) + +44  +bdi +-> + `cgeed_ +(bdi-> +cgeed_da +, +bdi_bs +); + +45  ( +bdi +-> +e + & +bdi_bs +); + +46 + } +} + +48  +le +  + $bdi_ad_cgeed +( +backg_dev_fo + * +bdi +) + +50  + `bdi_cgeed +( +bdi +, 1 << +BDI_ad_cgeed +); + +51 + } +} + +53  +le +  + $bdi_wre_cgeed +( +backg_dev_fo + * +bdi +) + +55  + `bdi_cgeed +( +bdi +, 1 << +BDI_wre_cgeed +); + +56 + } +} + +58  +le +  + $bdi_rw_cgeed +( +backg_dev_fo + * +bdi +) + +60  + `bdi_cgeed +( +bdi +, (1 << +BDI_ad_cgeed +)| + +61 (1 << +BDI_wre_cgeed +)); + +62 + } +} + + @/usr/include/linux/err_kernel_only.h + +1 #r +Kl + +ly + +hd + +uded + + + +ura + + + @/usr/include/linux/errno.h + +1 #ide +_LINUX_ERRNO_H + + +2  + #_LINUX_ERRNO_H + + + ) + +4  + #EPERM + 1 + + ) + +5  + #ENOENT + 2 + + ) + +6  + #ESRCH + 3 + + ) + +7  + #EINTR + 4 + + ) + +8  + #EIO + 5 + + ) + +9  + #ENXIO + 6 + + ) + +10  + #E2BIG + 7 + + ) + +11  + #ENOEXEC + 8 + + ) + +12  + #EBADF + 9 + + ) + +13  + #ECHILD + 10 + + ) + +14  + #EAGAIN + 11 + + ) + +15  + #ENOMEM + 12 + + ) + +16  + #EACCES + 13 + + ) + +17  + #EFAULT + 14 + + ) + +18  + #ENOTBLK + 15 + + ) + +19  + #EBUSY + 16 + + ) + +20  + #EEXIST + 17 + + ) + +21  + #EXDEV + 18 + + ) + +22  + #ENODEV + 19 + + ) + +23  + #ENOTDIR + 20 + + ) + +24  + #EISDIR + 21 + + ) + +25  + #EINVAL + 22 + + ) + +26  + #ENFILE + 23 + + ) + +27  + #EMFILE + 24 + + ) + +28  + #ENOTTY + 25 + + ) + +29  + #ETXTBSY + 26 + + ) + +30  + #EFBIG + 27 + + ) + +31  + #ENOSPC + 28 + + ) + +32  + #ESPIPE + 29 + + ) + +33  + #EROFS + 30 + + ) + +34  + #EMLINK + 31 + + ) + +35  + #EPIPE + 32 + + ) + +36  + #EDOM + 33 + + ) + +37  + #ERANGE + 34 + + ) + +38  + #EDEADLK + 35 + + ) + +40  + #ENAMETOOLONG + 36 + + ) + +41  + #ENOLCK + 37 + + ) + +42  + #ENOSYS + 38 + + ) + +43  + #ENOTEMPTY + 39 + + ) + +44  + #ELOOP + 40 + + ) + +45  + #EWOULDBLOCK + +EAGAIN + + + ) + +46  + #ENOMSG + 42 + + ) + +47  + #EIDRM + 43 + + ) + +48  + #ECHRNG + 44 + + ) + +49  + #EL2NSYNC + 45 + + ) + +50  + #EL3HLT + 46 + + ) + +51  + #EL3RST + 47 + + ) + +52  + #ELNRNG + 48 + + ) + +53  + #EUNATCH + 49 + + ) + +54  + #ENOCSI + 50 + + ) + +55  + #EL2HLT + 51 + + ) + +56  + #EBADE + 52 + + ) + +57  + #EBADR + 53 + + ) + +58  + #EXFULL + 54 + + ) + +59  + #ENOANO + 55 + + ) + +60  + #EBADRQC + 56 + + ) + +61  + #EBADSLT + 57 + + ) + +63  + #EDEADLOCK + +EDEADLK + + + ) + +65  + #EBFONT + 59 + + ) + +66  + #ENOSTR + 60 + + ) + +67  + #ENODATA + 61 + + ) + +68  + #ETIME + 62 + + ) + +69  + #ENOSR + 63 + + ) + +70  + #ENONET + 64 + + ) + +71  + #ENOPKG + 65 + + ) + +72  + #EREMOTE + 66 + + ) + +73  + #ENOLINK + 67 + + ) + +74  + #EADV + 68 + + ) + +75  + #ESRMNT + 69 + + ) + +76  + #ECOMM + 70 + + ) + +77  + #EPROTO + 71 + + ) + +78  + #EMULTIHOP + 72 + + ) + +79  + #EDOTDOT + 73 + + ) + +80  + #EBADMSG + 74 + + ) + +81  + #EOVERFLOW + 75 + + ) + +82  + #ENOTUNIQ + 76 + + ) + +83  + #EBADFD + 77 + + ) + +84  + #EREMCHG + 78 + + ) + +85  + #ELIBACC + 79 + + ) + +86  + #ELIBBAD + 80 + + ) + +87  + #ELIBSCN + 81 + + ) + +88  + #ELIBMAX + 82 + + ) + +89  + #ELIBEXEC + 83 + + ) + +90  + #EILSEQ + 84 + + ) + +91  + #ERESTART + 85 + + ) + +92  + #ESTRPIPE + 86 + + ) + +93  + #EUSERS + 87 + + ) + +94  + #ENOTSOCK + 88 + + ) + +95  + #EDESTADDRREQ + 89 + + ) + +96  + #EMSGSIZE + 90 + + ) + +97  + #EPROTOTYPE + 91 + + ) + +98  + #ENOPROTOOPT + 92 + + ) + +99  + #EPROTONOSUPPORT + 93 + + ) + +100  + #ESOCKTNOSUPPORT + 94 + + ) + +101  + #EOPNOTSUPP + 95 + + ) + +102  + #EPFNOSUPPORT + 96 + + ) + +103  + #EAFNOSUPPORT + 97 + + ) + +104  + #EADDRINUSE + 98 + + ) + +105  + #EADDRNOTAVAIL + 99 + + ) + +106  + #ENETDOWN + 100 + + ) + +107  + #ENETUNREACH + 101 + + ) + +108  + #ENETRESET + 102 + + ) + +109  + #ECONNABORTED + 103 + + ) + +110  + #ECONNRESET + 104 + + ) + +111  + #ENOBUFS + 105 + + ) + +112  + #EISCONN + 106 + + ) + +113  + #ENOTCONN + 107 + + ) + +114  + #ESHUTDOWN + 108 + + ) + +115  + #ETOOMANYREFS + 109 + + ) + +116  + #ETIMEDOUT + 110 + + ) + +117  + #ECONNREFUSED + 111 + + ) + +118  + #EHOSTDOWN + 112 + + ) + +119  + #EHOSTUNREACH + 113 + + ) + +120  + #EALREADY + 114 + + ) + +121  + #EINPROGRESS + 115 + + ) + +122  + #ESTALE + 116 + + ) + +123  + #EUCLEAN + 117 + + ) + +124  + #ENOTNAM + 118 + + ) + +125  + #ENAVAIL + 119 + + ) + +126  + #EISNAM + 120 + + ) + +127  + #EREMOTEIO + 121 + + ) + +128  + #EDQUOT + 122 + + ) + +130  + #ENOMEDIUM + 123 + + ) + +131  + #EMEDIUMTYPE + 124 + + ) + +132  + #ECANCELED + 125 + + ) + +133  + #ENOKEY + 126 + + ) + +134  + #EKEYEXPIRED + 127 + + ) + +135  + #EKEYREVOKED + 128 + + ) + +136  + #EKEYREJECTED + 129 + + ) + +139  + ~ + + @/usr/include/linux/fs.h + +1 #ide +_LINUX_FS_H + + +2  + #_LINUX_FS_H + + + ) + +9  + ~ + +10  + ~ + +11  + ~ + +24 #unde +NR_OPEN + + +25  + #NR_OPEN + (1024*1024 + + ) + +26  + #INR_OPEN + 1024 + + ) + +28  + #BLOCK_SIZE_BITS + 10 + + ) + +29  + #BLOCK_SIZE + (1<< +BLOCK_SIZE_BITS +) + + ) + +32  + sfes__ru + { + +33  + m_fes +; + +34  + m__fes +; + +35  + mmax_fes +; + +37  +fes__ru + +fes_ +; + +39  + sodes__t + { + +40  + m_odes +; + +41  + m_unud +; + +42  + mdummy +[5]; + +44  +odes__t + +odes_ +; + +46  +as_ab +, +a_bak_time +; + +48 #ifde +CONFIG_DNOTIFY + + +49  +d_nify_ab +; + +52  + #NR_FILE + 8192 + + ) + +54  + #MAY_EXEC + 1 + + ) + +55  + #MAY_WRITE + 2 + + ) + +56  + #MAY_READ + 4 + + ) + +57  + #MAY_APPEND + 8 + + ) + +59  + #FMODE_READ + 1 + + ) + +60  + #FMODE_WRITE + 2 + + ) + +63  + #FMODE_LSEEK + 4 + + ) + +64  + #FMODE_PREAD + 8 + + ) + +65  + #FMODE_PWRITE + +FMODE_PREAD + + + ) + +67  + #RW_MASK + 1 + + ) + +68  + #RWA_MASK + 2 + + ) + +69  + #READ + 0 + + ) + +70  + #WRITE + 1 + + ) + +71  + #READA + 2 + + ) + +72  + #SPECIAL + 4 + + ) + +73  + #READ_SYNC + ( +READ + | (1 << +BIO_RW_SYNC +)) + + ) + +74  + #WRITE_SYNC + ( +WRITE + | (1 << +BIO_RW_SYNC +)) + + ) + +75  + #WRITE_BARRIER + ((1 << +BIO_RW +| (1 << +BIO_RW_BARRIER +)) + + ) + +77  + #SEL_IN + 1 + + ) + +78  + #SEL_OUT + 2 + + ) + +79  + #SEL_EX + 4 + + ) + +82  + #FS_REQUIRES_DEV + 1 + + ) + +83  + #FS_BINARY_MOUNTDATA + 2 + + ) + +84  + #FS_REVAL_DOT + 16384 + + ) + +85  + #FS_ODD_RENAME + 32768 + + ) + +91  + #MS_RDONLY + 1 + + ) + +92  + #MS_NOSUID + 2 + + ) + +93  + #MS_NODEV + 4 + + ) + +94  + #MS_NOEXEC + 8 + + ) + +95  + #MS_SYNCHRONOUS + 16 + + ) + +96  + #MS_REMOUNT + 32 + + ) + +97  + #MS_MANDLOCK + 64 + + ) + +98  + #MS_DIRSYNC + 128 + + ) + +99  + #MS_NOATIME + 1024 + + ) + +100  + #MS_NODIRATIME + 2048 + + ) + +101  + #MS_BIND + 4096 + + ) + +102  + #MS_MOVE + 8192 + + ) + +103  + #MS_REC + 16384 + + ) + +104  + #MS_VERBOSE + 32768 + + ) + +105  + #MS_POSIXACL + (1<<16 + + ) + +106  + #MS_ACTIVE + (1<<30) + + ) + +107  + #MS_NOUSER + (1<<31) + + ) + +112  + #MS_RMT_MASK + ( +MS_RDONLY +| +MS_SYNCHRONOUS +| +MS_MANDLOCK +| +MS_NOATIME +|\ + +113 +MS_NODIRATIME +) + + ) + +118  + #MS_MGC_VAL + 0xC0ED0000 + + ) + +119  + #MS_MGC_MSK + 0xffff0000 + + ) + +123  + #S_SYNC + 1 + + ) + +124  + #S_NOATIME + 2 + + ) + +125  + #S_APPEND + 4 + + ) + +126  + #S_IMMUTABLE + 8 + + ) + +127  + #S_DEAD + 16 + + ) + +128  + #S_NOQUOTA + 32 + + ) + +129  + #S_DIRSYNC + 64 + + ) + +130  + #S_NOCMTIME + 128 + + ) + +131  + #S_SWAPFILE + 256 + + ) + +146  + #__IS_FLG +( +ode +, +g +((ode)-> +i_sb +-> +s_ags + & (g)) + + ) + +148  + #IS_RDONLY +( +ode +((ode)-> +i_sb +-> +s_ags + & +MS_RDONLY +) + + ) + +149  + #IS_SYNC +( +ode +( + `__IS_FLG +(ode, +MS_SYNCHRONOUS +) || \ + +150 (( +ode +)-> +i_ags + & +S_SYNC +)) + + ) + +151  + #IS_DIRSYNC +( +ode +( + `__IS_FLG +(ode, +MS_SYNCHRONOUS +| +MS_DIRSYNC +) || \ + +152 (( +ode +)-> +i_ags + & ( +S_SYNC +| +S_DIRSYNC +))) + + ) + +153  + #IS_MANDLOCK +( +ode + + `__IS_FLG +(ode, +MS_MANDLOCK +) + + ) + +155  + #IS_NOQUOTA +( +ode +((ode)-> +i_ags + & +S_NOQUOTA +) + + ) + +156  + #IS_APPEND +( +ode +((ode)-> +i_ags + & +S_APPEND +) + + ) + +157  + #IS_IMMUTABLE +( +ode +((ode)-> +i_ags + & +S_IMMUTABLE +) + + ) + +158  + #IS_NOATIME +( +ode +( + `__IS_FLG +(ode, +MS_NOATIME +|| ((ode)-> +i_ags + & +S_NOATIME +)) + + ) + +159  + #IS_NODIRATIME +( +ode + + `__IS_FLG +(ode, +MS_NODIRATIME +) + + ) + +160  + #IS_POSIXACL +( +ode + + `__IS_FLG +(ode, +MS_POSIXACL +) + + ) + +162  + #IS_DEADDIR +( +ode +((ode)-> +i_ags + & +S_DEAD +) + + ) + +163  + #IS_NOCMTIME +( +ode +((ode)-> +i_ags + & +S_NOCMTIME +) + + ) + +164  + #IS_SWAPFILE +( +ode +((ode)-> +i_ags + & +S_SWAPFILE +) + + ) + +169  + #BLKROSET + + `_IO +(0x12,93 + + ) + +170  + #BLKROGET + + `_IO +(0x12,94 + + ) + +171  + #BLKRRPART + + `_IO +(0x12,95 + + ) + +172  + #BLKGETSIZE + + `_IO +(0x12,96 + + ) + +173  + #BLKFLSBUF + + `_IO +(0x12,97 + + ) + +174  + #BLKRASET + + `_IO +(0x12,98 + + ) + +175  + #BLKRAGET + + `_IO +(0x12,99 + + ) + +176  + #BLKFRASET + + `_IO +(0x12,100) + + ) + +177  + #BLKFRAGET + + `_IO +(0x12,101) + + ) + +178  + #BLKSECTSET + + `_IO +(0x12,102) + + ) + +179  + #BLKSECTGET + + `_IO +(0x12,103) + + ) + +180  + #BLKSSZGET + + `_IO +(0x12,104) + + ) + +182  + #BLKPG + + `_IO +(0x12,105) + + ) + +186  + #BLKELVGET + + `_IOR +(0x12,106, +size_t +) + + ) + +187  + #BLKELVSET + + `_IOW +(0x12,107, +size_t +) + + ) + +192  + #BLKBSZGET + + `_IOR +(0x12,112, +size_t +) + + ) + +193  + #BLKBSZSET + + `_IOW +(0x12,113, +size_t +) + + ) + +194  + #BLKGETSIZE64 + + `_IOR +(0x12,114, +size_t + + + ) + +196  + #BMAP_IOCTL + 1 + + ) + +197  + #FIBMAP + + `_IO +(0x00,1 + + ) + +198  + #FIGETBSZ + + `_IO +(0x00,2 + + ) + + @/usr/include/linux/kernel.h + +1 #ide +_LINUX_KERNEL_H + + +2  + #_LINUX_KERNEL_H + + + ) + +8  + #SI_LOAD_SHIFT + 16 + + ) + +9  + ssysfo + { + +10  + muime +; + +11  + mlds +[3]; + +12  + mtٮm +; + +13  + m䓿m +; + +14  + mshedm +; + +15  + mbufam +; + +16  + mtٮsw +; + +17  + msw +; + +18  + mocs +; + +19  + md +; + +20  + mtٮhigh +; + +21  + mhigh +; + +22  + mmem_un +; + +23  + m_f +[20-2*()-()]; + +26  +BUILD_BUG +(); + +27  + #BUILD_BUG_ON +( +cdi +d{ i(cdi + `BUILD_BUG +(); } 0) + + ) + +30 #i +__GNUC__ + > 2 || +__GNUC_MINOR__ + >= 95 + +31  + #__FUNCTION__ + ( +__func__ +) + + ) + + @/usr/include/linux/nfs.h + +7 #ide +_LINUX_NFS_H + + +8  + #_LINUX_NFS_H + + + ) + +10  + #NFS_PROGRAM + 100003 + + ) + +11  + #NFS_PORT + 2049 + + ) + +12  + #NFS_MAXDATA + 8192 + + ) + +13  + #NFS_MAXPATHLEN + 1024 + + ) + +14  + #NFS_MAXNAMLEN + 255 + + ) + +15  + #NFS_MAXGROUPS + 16 + + ) + +16  + #NFS_FHSIZE + 32 + + ) + +17  + #NFS_COOKIESIZE + 4 + + ) + +18  + #NFS_FIFO_DEV + (-1) + + ) + +19  + #NFSMODE_FMT + 0170000 + + ) + +20  + #NFSMODE_DIR + 0040000 + + ) + +21  + #NFSMODE_CHR + 0020000 + + ) + +22  + #NFSMODE_BLK + 0060000 + + ) + +23  + #NFSMODE_REG + 0100000 + + ) + +24  + #NFSMODE_LNK + 0120000 + + ) + +25  + #NFSMODE_SOCK + 0140000 + + ) + +26  + #NFSMODE_FIFO + 0010000 + + ) + +28  + #NFS_MNT_PROGRAM + 100005 + + ) + +29  + #NFS_MNT_PORT + 627 + + ) + +39 + enfs_ + { + +40 + mNFS_OK + = 0, + +41 + mNFSERR_PERM + = 1, + +42 + mNFSERR_NOENT + = 2, + +43 + mNFSERR_IO + = 5, + +44 + mNFSERR_NXIO + = 6, + +45 + mNFSERR_EAGAIN + = 11, + +46 + mNFSERR_ACCES + = 13, + +47 + mNFSERR_EXIST + = 17, + +48 + mNFSERR_XDEV + = 18, + +49 + mNFSERR_NODEV + = 19, + +50 + mNFSERR_NOTDIR + = 20, + +51 + mNFSERR_ISDIR + = 21, + +52 + mNFSERR_INVAL + = 22, + +53 + mNFSERR_FBIG + = 27, + +54 + mNFSERR_NOSPC + = 28, + +55 + mNFSERR_ROFS + = 30, + +56 + mNFSERR_MLINK + = 31, + +57 + mNFSERR_OPNOTSUPP + = 45, + +58 + mNFSERR_NAMETOOLONG + = 63, + +59 + mNFSERR_NOTEMPTY + = 66, + +60 + mNFSERR_DQUOT + = 69, + +61 + mNFSERR_STALE + = 70, + +62 + mNFSERR_REMOTE + = 71, + +63 + mNFSERR_WFLUSH + = 99, + +64 + mNFSERR_BADHANDLE + = 10001, + +65 + mNFSERR_NOT_SYNC + = 10002, + +66 + mNFSERR_BAD_COOKIE + = 10003, + +67 + mNFSERR_NOTSUPP + = 10004, + +68 + mNFSERR_TOOSMALL + = 10005, + +69 + mNFSERR_SERVERFAULT + = 10006, + +70 + mNFSERR_BADTYPE + = 10007, + +71 + mNFSERR_JUKEBOX + = 10008, + +72 + mNFSERR_SAME + = 10009, + +73 + mNFSERR_DENIED + = 10010, + +74 + mNFSERR_EXPIRED + = 10011, + +75 + mNFSERR_LOCKED + = 10012, + +76 + mNFSERR_GRACE + = 10013, + +77 + mNFSERR_FHEXPIRED + = 10014, + +78 + mNFSERR_SHARE_DENIED + = 10015, + +79 + mNFSERR_WRONGSEC + = 10016, + +80 + mNFSERR_CLID_INUSE + = 10017, + +81 + mNFSERR_RESOURCE + = 10018, + +82 + mNFSERR_MOVED + = 10019, + +83 + mNFSERR_NOFILEHANDLE + = 10020, + +84 + mNFSERR_MINOR_VERS_MISMATCH + = 10021, + +85 + mNFSERR_STALE_CLIENTID + = 10022, + +86 + mNFSERR_STALE_STATEID + = 10023, + +87 + mNFSERR_OLD_STATEID + = 10024, + +88 + mNFSERR_BAD_STATEID + = 10025, + +89 + mNFSERR_BAD_SEQID + = 10026, + +90 + mNFSERR_NOT_SAME + = 10027, + +91 + mNFSERR_LOCK_RANGE + = 10028, + +92 + mNFSERR_SYMLINK + = 10029, + +93 + mNFSERR_RESTOREFH + = 10030, + +94 + mNFSERR_LEASE_MOVED + = 10031, + +95 + mNFSERR_ATTRNOTSUPP + = 10032, + +96 + mNFSERR_NO_GRACE + = 10033, + +97 + mNFSERR_RECLAIM_BAD + = 10034, + +98 + mNFSERR_RECLAIM_CONFLICT + = 10035, + +99 + mNFSERR_BAD_XDR + = 10036, + +100 + mNFSERR_LOCKS_HELD + = 10037, + +101 + mNFSERR_OPENMODE + = 10038, + +102 + mNFSERR_BADOWNER + = 10039, + +103 + mNFSERR_BADCHAR + = 10040, + +104 + mNFSERR_BADNAME + = 10041, + +105 + mNFSERR_BAD_RANGE + = 10042, + +106 + mNFSERR_LOCK_NOTSUPP + = 10043, + +107 + mNFSERR_OP_ILLEGAL + = 10044, + +108 + mNFSERR_DEADLOCK + = 10045, + +109 + mNFSERR_FILE_OPEN + = 10046, + +110 + mNFSERR_ADMIN_REVOKED + = 10047, + +111 + mNFSERR_CB_PATH_DOWN + = 10048, + +112 + mNFSERR_REPLAY_ME + = 10049 + +117 + enfs_y + { + +118 + mNFNON + = 0, + +119 + mNFREG + = 1, + +120 + mNFDIR + = 2, + +121 + mNFBLK + = 3, + +122 + mNFCHR + = 4, + +123 + mNFLNK + = 5, + +124 + mNFSOCK + = 6, + +125 + mNFBAD + = 7, + +126 + mNFFIFO + = 8 + + @/usr/include/linux/posix_types.h + +1 #ide +_LINUX_POSIX_TYPES_H + + +2  + #_LINUX_POSIX_TYPES_H + + + ) + +4  + ~ + +21 #unde +__NFDBITS + + +22  + #__NFDBITS + (8 * ()) + + ) + +24 #unde +__FD_SETSIZE + + +25  + #__FD_SETSIZE + 1024 + + ) + +27 #unde +__FDSET_LONGS + + +28  + #__FDSET_LONGS + ( +__FD_SETSIZE +/ +__NFDBITS +) + + ) + +30 #unde +__FDELT + + +31  + #__FDELT +( +d +((d/ +__NFDBITS +) + + ) + +33 #unde +__FDMASK + + +34  + #__FDMASK +( +d +(1UL << ((d% +__NFDBITS +)) + + ) + +37  + mfds_bs + [ +__FDSET_LONGS +]; + +38 } + t__kl_fd_t +; + +41 (* + t__kl_sighdr_t +)(); + +44  + t__kl_key_t +; + +45  + t__kl_mqd_t +; + +47  + ~ + + @/usr/include/sys/select.h + +22 #ide +_SYS_SELECT_H + + +23  + #_SYS_SELECT_H + 1 + + ) + +25  + ~ + +28  + ~ + +31  + ~ + +34  + ~ + +36 #ide +__sigt_t_defed + + +37  + #__sigt_t_defed + + + ) + +38  +__sigt_t + + tsigt_t +; + +42  + #__ed_time_t + + + ) + +43  + #__ed_timeec + + + ) + +44  + ~ + +45  + #__ed_timev + + + ) + +46  + ~ + +48 #ide +__sucds_t_defed + + +49  +__sucds_t + + tsucds_t +; + +50  + #__sucds_t_defed + + + ) + +55  + t__fd_mask +; + +58 #unde +__NFDBITS + + +59 #unde +__FDELT + + +60 #unde +__FDMASK + + +62  + #__NFDBITS + (8 *  ( +__fd_mask +)) + + ) + +63  + #__FDELT +( +d +((d/ +__NFDBITS +) + + ) + +64  + #__FDMASK +( +d +(( +__fd_mask +1 << ((d% +__NFDBITS +)) + + ) + +71 #ifde +__USE_XOPEN + + +72 +__fd_mask + + mfds_bs +[ +__FD_SETSIZE + / +__NFDBITS +]; + +73  + #__FDS_BITS +( +t +((t)-> +fds_bs +) + + ) + +75 +__fd_mask + + m__fds_bs +[ +__FD_SETSIZE + / +__NFDBITS +]; + +76  + #__FDS_BITS +( +t +((t)-> +__fds_bs +) + + ) + +78 } + tfd_t +; + +81  + #FD_SETSIZE + +__FD_SETSIZE + + + ) + +83 #ifde +__USE_MISC + + +85  +__fd_mask + + tfd_mask +; + +88  + #NFDBITS + +__NFDBITS + + + ) + +93  + #FD_SET +( +fd +, +fd + + `__FD_SET + (fd, fd) + + ) + +94  + #FD_CLR +( +fd +, +fd + + `__FD_CLR + (fd, fd) + + ) + +95  + #FD_ISSET +( +fd +, +fd + + `__FD_ISSET + (fd, fd) + + ) + +96  + #FD_ZERO +( +fd + + `__FD_ZERO + (fd) + + ) + +99 +__BEGIN_DECLS + + +109  + + ( +__nfds +, +fd_t + * +__ri + +__adfds +, + +110 +fd_t + * +__ri + +__wrefds +, + +111 +fd_t + * +__ri + +__exfds +, + +112  +timev + * +__ri + +__timeout +); + +114 #ifde +__USE_XOPEN2K + + +121  +p + ( +__nfds +, +fd_t + * +__ri + +__adfds +, + +122 +fd_t + * +__ri + +__wrefds +, + +123 +fd_t + * +__ri + +__exfds +, + +124 cڡ  +timeec + * +__ri + +__timeout +, + +125 cڡ +__sigt_t + * +__ri + +__sigmask +); + +128 + g__END_DECLS + + + @/usr/include/sys/stat.h + +23 #idef +_SYS_STAT_H + + +24  + #_SYS_STAT_H + 1 + + ) + +26  + ~ + +28  + ~ + +30 #i +defed + +__USE_XOPEN + || defed +__USE_MISC + + +31 #i +defed + +__USE_XOPEN + || defed +__USE_XOPEN2K + + +32  + #__ed_time_t + + + ) + +34 #ifde +__USE_MISC + + +35  + #__ed_timeec + + + ) + +37  + ~ + +40 #i +defed + +__USE_XOPEN + || defed +__USE_XOPEN2K + + +43 #ide +__dev_t_defed + + +44  +__dev_t + + tdev_t +; + +45  + #__dev_t_defed + + + ) + +48 #ide +__gid_t_defed + + +49  +__gid_t + + tgid_t +; + +50  + #__gid_t_defed + + + ) + +53 #ide +__o_t_defed + + +54 #ide +__USE_FILE_OFFSET64 + + +55  +__o_t + + to_t +; + +57  +__o64_t + + to_t +; + +59  + #__o_t_defed + + + ) + +62 #ide +__mode_t_defed + + +63  +__mode_t + + tmode_t +; + +64  + #__mode_t_defed + + + ) + +67 #ide +__ƚk_t_defed + + +68  +__ƚk_t + + tƚk_t +; + +69  + #__ƚk_t_defed + + + ) + +72 #ide +__off_t_defed + + +73 #ide +__USE_FILE_OFFSET64 + + +74  +__off_t + + toff_t +; + +76  +__off64_t + + toff_t +; + +78  + #__off_t_defed + + + ) + +81 #ide +__uid_t_defed + + +82  +__uid_t + + tuid_t +; + +83  + #__uid_t_defed + + + ) + +87 #ifde +__USE_UNIX98 + + +88 #ide +__blkt_t_defed + + +89 #ide +__USE_FILE_OFFSET64 + + +90  +__blkt_t + + tblkt_t +; + +92  +__blkt64_t + + tblkt_t +; + +94  + #__blkt_t_defed + + + ) + +97 #ide +__blksize_t_defed + + +98  +__blksize_t + + tblksize_t +; + +99  + #__blksize_t_defed + + + ) + +103 + g__BEGIN_DECLS + + +105  + ~ + +107 #i +defed + +__USE_BSD + || defed +__USE_MISC + || defed +__USE_XOPEN + + +108  + #S_IFMT + +__S_IFMT + + + ) + +109  + #S_IFDIR + +__S_IFDIR + + + ) + +110  + #S_IFCHR + +__S_IFCHR + + + ) + +111  + #S_IFBLK + +__S_IFBLK + + + ) + +112  + #S_IFREG + +__S_IFREG + + + ) + +113 #ifde +__S_IFIFO + + +114  + #S_IFIFO + +__S_IFIFO + + + ) + +116 #ifde +__S_IFLNK + + +117  + #S_IFLNK + +__S_IFLNK + + + ) + +119 #i( +defed + +__USE_BSD + || defed +__USE_MISC + || defed +__USE_UNIX98 +) \ + +120 && +defed + + g__S_IFSOCK + + +121  + #S_IFSOCK + +__S_IFSOCK + + + ) + +127  + #__S_ISTYPE +( +mode +, +mask +(((mode& +__S_IFMT +=(mask)) + + ) + +129  + #S_ISDIR +( +mode + + `__S_ISTYPE +((mode), +__S_IFDIR +) + + ) + +130  + #S_ISCHR +( +mode + + `__S_ISTYPE +((mode), +__S_IFCHR +) + + ) + +131  + #S_ISBLK +( +mode + + `__S_ISTYPE +((mode), +__S_IFBLK +) + + ) + +132  + #S_ISREG +( +mode + + `__S_ISTYPE +((mode), +__S_IFREG +) + + ) + +133 #ifde +__S_IFIFO + + +134  + #S_ISFIFO +( +mode + + `__S_ISTYPE +((mode), +__S_IFIFO +) + + ) + +136 #ifde +__S_IFLNK + + +137  + #S_ISLNK +( +mode + + `__S_ISTYPE +((mode), +__S_IFLNK +) + + ) + +140 #i +defed + +__USE_BSD + && !defed +__S_IFLNK + + +141  + #S_ISLNK +( +mode +0 + + ) + +144 #i( +defed + +__USE_BSD + || defed +__USE_UNIX98 +) \ + +145 && +defed + + g__S_IFSOCK + + +146  + #S_ISSOCK +( +mode + + `__S_ISTYPE +((mode), +__S_IFSOCK +) + + ) + +153 #ifdef +__USE_POSIX199309 + + +154  + #S_TYPEISMQ +( +buf + + `__S_TYPEISMQ +(buf) + + ) + +155  + #S_TYPEISSEM +( +buf + + `__S_TYPEISSEM +(buf) + + ) + +156  + #S_TYPEISSHM +( +buf + + `__S_TYPEISSHM +(buf) + + ) + +162  + #S_ISUID + +__S_ISUID + + + ) + +163  + #S_ISGID + +__S_ISGID + + + ) + +165 #i +defed + +__USE_BSD + || defed +__USE_MISC + || defed +__USE_XOPEN + + +167  + #S_ISVTX + +__S_ISVTX + + + ) + +170  + #S_IRUSR + +__S_IREAD + + + ) + +171  + #S_IWUSR + +__S_IWRITE + + + ) + +172  + #S_IXUSR + +__S_IEXEC + + + ) + +174  + #S_IRWXU + ( +__S_IREAD +| +__S_IWRITE +| +__S_IEXEC +) + + ) + +176 #i +defed + +__USE_MISC + && defed +__USE_BSD + + +177  + #S_IREAD + +S_IRUSR + + + ) + +178  + #S_IWRITE + +S_IWUSR + + + ) + +179  + #S_IEXEC + +S_IXUSR + + + ) + +182  + #S_IRGRP + ( +S_IRUSR + >> 3 + + ) + +183  + #S_IWGRP + ( +S_IWUSR + >> 3 + + ) + +184  + #S_IXGRP + ( +S_IXUSR + >> 3 + + ) + +186  + #S_IRWXG + ( +S_IRWXU + >> 3) + + ) + +188  + #S_IROTH + ( +S_IRGRP + >> 3 + + ) + +189  + #S_IWOTH + ( +S_IWGRP + >> 3 + + ) + +190  + #S_IXOTH + ( +S_IXGRP + >> 3 + + ) + +192  + #S_IRWXO + ( +S_IRWXG + >> 3) + + ) + +195 #ifdef +__USE_BSD + + +197  + #ACCESSPERMS + ( +S_IRWXU +| +S_IRWXG +| +S_IRWXO + + + ) + +198  + #ALLPERMS + ( +S_ISUID +| +S_ISGID +| +S_ISVTX +| +S_IRWXU +| +S_IRWXG +| +S_IRWXO +) + + ) + +199  + #DEFFILEMODE + ( +S_IRUSR +| +S_IWUSR +| +S_IRGRP +| +S_IWGRP +| +S_IROTH +| +S_IWOTH +) + + ) + +201  + #S_BLKSIZE + 512 + + ) + +205 #ide +__USE_FILE_OFFSET64 + + +207  + $ + ( +__cڡ + * +__ri + +__fe +, + +208  + + * +__ri + +__buf + +__THROW + + `__nnu + ((1, 2)); + +212  + $f + ( +__fd +,  + + * +__buf + +__THROW + + `__nnu + ((2)); + +214 #ifde +__REDIRECT_NTH + + +215  + `__REDIRECT_NTH + ( + +, ( +__cڡ + * +__ri + +__fe +, + +216  + + * +__ri + +__buf +), +64 +) + +217 + `__nnu + ((1, 2)); + +218  + `__REDIRECT_NTH + ( +f +, ( +__fd +,  + + * +__buf +), +f64 +) + +219 + `__nnu + ((2)); + +221  + # + +64 + + + ) + +222  + #f + +f64 + + + ) + +225 #ifde +__USE_LARGEFILE64 + + +226  + $64 + ( +__cڡ + * +__ri + +__fe +, + +227  +64 + * +__ri + +__buf + +__THROW + + `__nnu + ((1, 2)); + +228  + $f64 + ( +__fd +,  +64 + * +__buf + +__THROW + + `__nnu + ((2)); + +231 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +232 #ide +__USE_FILE_OFFSET64 + + +235  + $l + ( +__cڡ + * +__ri + +__fe +, + +236  + + * +__ri + +__buf + +__THROW + + `__nnu + ((1, 2)); + +238 #ifde +__REDIRECT_NTH + + +239  + `__REDIRECT_NTH + ( +l +, + +240 ( +__cڡ + * +__ri + +__fe +, + +241  + + * +__ri + +__buf +), +l64 +) + +242 + `__nnu + ((1, 2)); + +244  + #l + +l64 + + + ) + +247 #ifde +__USE_LARGEFILE64 + + +248  + $l64 + ( +__cڡ + * +__ri + +__fe +, + +249  +64 + * +__ri + +__buf +) + +250 +__THROW + + `__nnu + ((1, 2)); + +256  + $chmod + ( +__cڡ + * +__fe +, +__mode_t + +__mode +) + +257 +__THROW + + `__nnu + ((1)); + +259 #ifde +__USE_BSD + + +263  + $lchmod + ( +__cڡ + * +__fe +, +__mode_t + +__mode +) + +264 +__THROW + + `__nnu + ((1)); + +268 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +269  + $fchmod + ( +__fd +, +__mode_t + +__mode + +__THROW +; + +275 +__mode_t + + $umask + ( +__mode_t + +__mask + +__THROW +; + +277 #ifdef +__USE_GNU + + +280 +__mode_t + + $gumask + ( +__THROW +; + +284  + $mkd + ( +__cڡ + * +__th +, +__mode_t + +__mode +) + +285 +__THROW + + `__nnu + ((1)); + +290 #i +defed + +__USE_MISC + || defed +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +291  + $mknod + ( +__cڡ + * +__th +, +__mode_t + +__mode +, +__dev_t + +__dev +) + +292 +__THROW + + `__nnu + ((1)); + +297  + $mkfifo + ( +__cڡ + * +__th +, +__mode_t + +__mode +) + +298 +__THROW + + `__nnu + ((1)); + +315 #ide +_STAT_VER + + +316  + #_STAT_VER + 0 + + ) + +318 #ide +_MKNOD_VER + + +319  + #_MKNOD_VER + 0 + + ) + +323 #ide +__USE_FILE_OFFSET64 + + +324  + $__fx + ( +__v +,  +__fdes +,  + + * +___buf +) + +325 +__THROW + + `__nnu + ((3)); + +326  + $__x + ( +__v +, +__cڡ + * +__fame +, + +327  + + * +___buf + +__THROW + + `__nnu + ((2, 3)); + +328  + $__lx + ( +__v +, +__cڡ + * +__fame +, + +329  + + * +___buf + +__THROW + + `__nnu + ((2, 3)); + +331 #ifde +__REDIRECT_NTH + + +332  + `__REDIRECT_NTH + ( +__fx +, ( +__v +,  +__fdes +, + +333  + + * +___buf +), +__fx64 +) + +334 + `__nnu + ((3)); + +335  + `__REDIRECT_NTH + ( +__x +, ( +__v +, +__cڡ + * +__fame +, + +336  + + * +___buf +), +__x64 +) + +337 + `__nnu + ((2, 3)); + +338  + `__REDIRECT_NTH + ( +__lx +, ( +__v +, +__cڡ + * +__fame +, + +339  + + * +___buf +), +__lx64 +) + +340 + `__nnu + ((2, 3)); + +343  + #__fx + +__fx64 + + + ) + +344  + #__x + +__x64 + + + ) + +345  + #__lx + +__lx64 + + + ) + +349 #ifde +__USE_LARGEFILE64 + + +350  + $__fx64 + ( +__v +,  +__fdes +,  +64 + * +___buf +) + +351 +__THROW + + `__nnu + ((3)); + +352  + $__x64 + ( +__v +, +__cڡ + * +__fame +, + +353  +64 + * +___buf + +__THROW + + `__nnu + ((2, 3)); + +354  + $__lx64 + ( +__v +, +__cڡ + * +__fame +, + +355  +64 + * +___buf + +__THROW + + `__nnu + ((2, 3)); + +357  + $__xmknod + ( +__v +, +__cڡ + * +__th +, +__mode_t + +__mode +, + +358 +__dev_t + * +__dev + +__THROW + + `__nnu + ((2, 4)); + +360 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +363 +__le__ +  + +364 + `__NTH + ( + $ + ( +__cڡ + * +__th +,  + + * +__buf +)) + +366  + `__x + ( +_STAT_VER +, +__th +, +__buf +); + +367 + } +} + +369 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +370 +__le__ +  + +371 +__NTH + ( + $l + ( +__cڡ + * +__th +,  + + * +__buf +)) + +373  + `__lx + ( +_STAT_VER +, +__th +, +__buf +); + +374 + } +} + +377 +__le__ +  + +378 +__NTH + ( + $f + ( +__fd +,  + + * +__buf +)) + +380  + `__fx + ( +_STAT_VER +, +__fd +, +__buf +); + +381 + } +} + +383 #i +defed + +__USE_MISC + || defed +__USE_BSD + + +384 +__le__ +  + +385 +__NTH + ( + $mknod + ( +__cڡ + * +__th +, +__mode_t + +__mode +, +__dev_t + +__dev +)) + +387  + `__xmknod + ( +_MKNOD_VER +, +__th +, +__mode +, & +__dev +); + +388 + } +} + +391 #i +defed + +__USE_LARGEFILE64 + \ + +392 && (! +defed + +__USE_FILE_OFFSET64 + \ + +393 || ( +defed + +__REDIRECT_NTH + && defed +__OPTIMIZE__ +)) + +394 +__le__ +  + +395 +__NTH + ( + $64 + ( +__cڡ + * +__th +,  +64 + * +__buf +)) + +397  + `__x64 + ( +_STAT_VER +, +__th +, +__buf +); + +398 + } +} + +400 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +401 +__le__ +  + +402 +__NTH + ( + $l64 + ( +__cڡ + * +__th +,  +64 + * +__buf +)) + +404  + `__lx64 + ( +_STAT_VER +, +__th +, +__buf +); + +405 + } +} + +408 +__le__ +  + +409 +__NTH + ( + $f64 + ( +__fd +,  +64 + * +__buf +)) + +411  + `__fx64 + ( +_STAT_VER +, +__fd +, +__buf +); + +412 + } +} + +417 +__END_DECLS + + + @/usr/include/sys/sysmacros.h + +20 #ide +_SYS_SYSMACROS_H + + +21  + #_SYS_SYSMACROS_H + 1 + + ) + +23  + ~ + +28 #ifde +__GLIBC_HAVE_LONG_LONG + + +29 +__exnsi__ + + +30 +__le +  + $gnu_dev_maj + ( +__dev +) + +31 +__THROW +; + +32 +__exnsi__ + + +33 +__le +  + $gnu_dev_m + ( +__dev +) + +34 +__THROW +; + +35 +__exnsi__ + + +36 +__le +  + $gnu_dev_makedev + ( +__maj +, + +37  +__m +) + +38 +__THROW +; + +40 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +41 +__exnsi__ + +__le +  + +42 + `__NTH + ( + $gnu_dev_maj + ( +__dev +)) + +44  (( +__dev + >> 8) & 0xfff) | (() (__dev >> 32) & ~0xfff); + +45 + } +} + +47 +__exnsi__ + +__le +  + +48 +__NTH + ( + $gnu_dev_m + ( +__dev +)) + +50  ( +__dev + & 0xff) | (() (__dev >> 12) & ~0xff); + +51 + } +} + +53 +__exnsi__ + +__le +  + +54 +__NTH + ( + $gnu_dev_makedev + ( +__maj +,  +__m +)) + +56  (( +__m + & 0xff| (( +__maj + & 0xfff) << 8) + +57 | (((( +__m + & ~0xff)) << 12) + +58 | (((( +__maj + & ~0xfff)) << 32)); + +59 + } +} + +64  + #maj +( +dev + + `gnu_dev_maj + (dev) + + ) + +65  + #m +( +dev + + `gnu_dev_m + (dev) + + ) + +66  + #makedev +( +maj +, +m + + `gnu_dev_makedev + (maj, m) + + ) + + @/usr/include/sys/wait.h + +23 #idef +_SYS_WAIT_H + + +24  + #_SYS_WAIT_H + 1 + + ) + +26  + ~ + +28 + g__BEGIN_DECLS + + +30  + ~ + +31  + ~ + +34 #i! +defed + +_STDLIB_H + || !defed +__USE_XOPEN + + +37  + ~ + +39 #ifdef +__USE_BSD + + +44 #i +defed + +__GNUC__ + && !defed +__lulus + + +45  + #__WAIT_INT +( +us +) \ + +46 ( + `__exnsi__ + ({ uni { + `__tyof +( +us + +__ +;  +__i +; } +__u +; \ + +47 +__u +. +__ + = ( +us +); __u. +__i +; })) + + ) + +49  + #__WAIT_INT +( +us +(*(*&(us)) + + ) + +57 #i! +defed + +__GNUC__ + || __GNUC__ < 2 || defed +__lulus + + +58  + #__WAIT_STATUS + * + + ) + +59  + #__WAIT_STATUS_DEFN + * + + ) + +64  +wa + * + m__ur +; + +65 * + m__ +; + +66 } + t__WAIT_STATUS + + t__ibu__ + (( + t__t_uni__ +)); + +67  + #__WAIT_STATUS_DEFN + * + + ) + +72  + #__WAIT_INT +( +us +(us) + + ) + +73  + #__WAIT_STATUS + * + + ) + +74  + #__WAIT_STATUS_DEFN + * + + ) + +79  + ~ + +81  + #WEXITSTATUS +( +us + + `__WEXITSTATUS +( + `__WAIT_INT +(us)) + + ) + +82  + #WTERMSIG +( +us + + `__WTERMSIG +( + `__WAIT_INT +(us)) + + ) + +83  + #WSTOPSIG +( +us + + `__WSTOPSIG +( + `__WAIT_INT +(us)) + + ) + +84  + #WIFEXITED +( +us + + `__WIFEXITED +( + `__WAIT_INT +(us)) + + ) + +85  + #WIFSIGNALED +( +us + + `__WIFSIGNALED +( + `__WAIT_INT +(us)) + + ) + +86  + #WIFSTOPPED +( +us + + `__WIFSTOPPED +( + `__WAIT_INT +(us)) + + ) + +87 #ifde +__WIFCONTINUED + + +88  + #WIFCONTINUED +( +us + + `__WIFCONTINUED +( + `__WAIT_INT +(us)) + + ) + +92 #ifdef +__USE_BSD + + +93  + #WCOREFLAG + +__WCOREFLAG + + + ) + +94  + #WCOREDUMP +( +us + + `__WCOREDUMP +( + `__WAIT_INT +(us)) + + ) + +95  + #W_EXITCODE +( +t +, +sig + + `__W_EXITCODE +ԑ, sig) + + ) + +96  + #W_STOPCODE +( +sig + + `__W_STOPCODE +(sig) + + ) + +100 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +103 + mP_ALL +, + +104 + mP_PID +, + +105 + mP_PGID + + +106 } + tidty_t +; + +115 +__pid_t + +wa + ( +__WAIT_STATUS + +___loc +); + +117 #ifdef +__USE_BSD + + +119  + #WAIT_ANY + (-1 + + ) + +120  + #WAIT_MYPGRP + 0 + + ) + +138 +__pid_t + +wapid + (__pid_ +__pid +, * +___loc +,  +__tis +); + +140 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +141  + #__ed_sigfo_t + + + ) + +142  + ~ + +154  +waid + ( +idty_t + +__idty +, +__id_t + +__id +, +sigfo_t + * +__f +, + +155  +__tis +); + +158 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +161  + gruge +; + +168 +__pid_t + + $wa3 + ( +__WAIT_STATUS + +___loc +,  +__tis +, + +169  +ruge + * +__uge + +__THROW +; + +172 #ifde +__USE_BSD + + +175  +ruge +; + +178 +__pid_t + + $wa4 + ( +__pid_t + +__pid +, +__WAIT_STATUS + +___loc +,  +__tis +, + +179  +ruge + * +__uge + +__THROW +; + +183 +__END_DECLS + + + @/usr/include/time.h + +23 #idef +_TIME_H + + +25 #i(! +defed + +__ed_time_t + && !defed +__ed_ock_t + && \ + +26 ! +defed + + g__ed_timeec +) + +27  + #_TIME_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +34 #ifdef +_TIME_H + + +36  + #__ed_size_t + + + ) + +37  + #__ed_NULL + + + ) + +38  + ~ + +42  + ~ + +45 #i! +defed + +__STRICT_ANSI__ + && !defed +__USE_XOPEN2K + + +46 #ide +CLK_TCK + + +47  + #CLK_TCK + +CLOCKS_PER_SEC + + + ) + +53 #i! +defed + +__ock_t_defed + && (defed +_TIME_H + || defed +__ed_ock_t +) + +54  + #__ock_t_defed + 1 + + ) + +56  + ~ + +58 +__BEGIN_NAMESPACE_STD + + +60  +__ock_t + + tock_t +; + +61 + g__END_NAMESPACE_STD + + +62 #i +defed + +__USE_XOPEN + || defed +__USE_POSIX + || defed +__USE_MISC + + +63 + $__USING_NAMESPACE_STD +( +ock_t +) + +67 #unde +__ed_ock_t + + +69 #i! +defed + +__time_t_defed + && (defed +_TIME_H + || defed +__ed_time_t +) + +70  + #__time_t_defed + 1 + + ) + +72  + ~ + +74 +__BEGIN_NAMESPACE_STD + + +76  +__time_t + + ttime_t +; + +77 +__END_NAMESPACE_STD + + +78 #i +defed + +__USE_POSIX + || defed +__USE_MISC + || defed +__USE_SVID + + +79 + $__USING_NAMESPACE_STD +( +time_t +) + +83 #unde +__ed_time_t + + +85 #i! +defed + +__ockid_t_defed + && \ + +86 (( +defed + +_TIME_H + && defed +__USE_POSIX199309 +|| defed +__ed_ockid_t +) + +87  + #__ockid_t_defed + 1 + + ) + +89  + ~ + +92  +__ockid_t + + tockid_t +; + +95 #unde +__ockid_time_t + + +97 #i! +defed + +__tim_t_defed + && \ + +98 (( +defed + +_TIME_H + && defed +__USE_POSIX199309 +|| defed +__ed_tim_t +) + +99  + #__tim_t_defed + 1 + + ) + +101  + ~ + +104  +__tim_t + + ttim_t +; + +107 #unde +__ed_tim_t + + +110 #i! +defed + +__timeec_defed + && \ + +111 (( +defed + +_TIME_H + && \ + +112 ( +defed + +__USE_POSIX199309 + || defed +__USE_MISC +)) || \ + +113 +defed + +__ed_timeec +) + +114  + #__timeec_defed + 1 + + ) + +118  + stimeec + + +120 +__time_t + +tv_c +; + +121  +tv_nc +; + +125 #unde +__ed_timeec + + +128 #ifdef +_TIME_H + + +129 +__BEGIN_NAMESPACE_STD + + +131  + stm + + +133  +tm_c +; + +134  +tm_m +; + +135  +tm_hour +; + +136  +tm_mday +; + +137  +tm_m +; + +138  +tm_yr +; + +139  +tm_wday +; + +140  +tm_yday +; + +141  +tm_isd +; + +143 #ifdef +__USE_BSD + + +144  +tm_gmtoff +; + +145 +__cڡ + * +tm_ze +; + +147  +__tm_gmtoff +; + +148 +__cڡ + * +__tm_ze +; + +151 +__END_NAMESPACE_STD + + +152 #i +defed + +__USE_XOPEN + || defed +__USE_POSIX + || defed +__USE_MISC + + +153 + $__USING_NAMESPACE_STD +( +tm +) + +157 #ifde +__USE_POSIX199309 + + +159  + simec + + +161  +timeec + +_rv +; + +162  +timeec + +_vue +; + +166  +sigevt +; + +170 #ifde +__USE_XOPEN2K + + +171 #ide +__pid_t_defed + + +172  +__pid_t + + tpid_t +; + +173  + #__pid_t_defed + + + ) + +178 +__BEGIN_NAMESPACE_STD + + +181 +ock_t + + $ock + ( +__THROW +; + +184 +time_t + + $time + ( +time_t + * +__tim + +__THROW +; + +187  + $difime + ( +time_t + +__time1 +,ime_ +__time0 +) + +188 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +191 +time_t + + $mktime + ( +tm + * +__ + +__THROW +; + +197 +size_t + + $rime + (* +__ri + +__s +, +size_t + +__maxsize +, + +198 +__cڡ + * +__ri + +__fm +, + +199 +__cڡ +  +tm + * +__ri + +__ + +__THROW +; + +200 +__END_NAMESPACE_STD + + +202 #ifde +__USE_XOPEN + + +205 * + $time + ( +__cڡ + * +__ri + +__s +, + +206 +__cڡ + * +__ri + +__fmt +,  +tm + * +__ +) + +207 +__THROW +; + +210 #ifde +__USE_GNU + + +213  + ~ + +215 +size_t + + $rime_l + (* +__ri + +__s +, +size_t + +__maxsize +, + +216 +__cڡ + * +__ri + +__fm +, + +217 +__cڡ +  +tm + * +__ri + +__ +, + +218 +__lo_t + +__loc + +__THROW +; + +220 * + $time_l + ( +__cڡ + * +__ri + +__s +, + +221 +__cڡ + * +__ri + +__fmt +,  +tm + * +__ +, + +222 +__lo_t + +__loc + +__THROW +; + +226 +__BEGIN_NAMESPACE_STD + + +229  +tm + * + $gmtime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +233  +tm + * + $loime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +234 +__END_NAMESPACE_STD + + +236 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +239  +tm + * + $gmtime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +240  +tm + * +__ri + +__ + +__THROW +; + +244  +tm + * + $loime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +245  +tm + * +__ri + +__ + +__THROW +; + +248 +__BEGIN_NAMESPACE_STD + + +251 * + $asime + ( +__cڡ +  +tm + * +__ + +__THROW +; + +254 * + $ime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +255 +__END_NAMESPACE_STD + + +257 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +262 * + $asime_r + ( +__cڡ +  +tm + * +__ri + +__ +, + +263 * +__ri + +__buf + +__THROW +; + +266 * + $ime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +267 * +__ri + +__buf + +__THROW +; + +272 * +__tzme +[2]; + +273  +__daylight +; + +274  +__timeze +; + +277 #ifdef +__USE_POSIX + + +279 * +tzme +[2]; + +283  + $tzt + ( +__THROW +; + +286 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +287  +daylight +; + +288  +timeze +; + +291 #ifde +__USE_SVID + + +294  + $ime + ( +__cڡ + +time_t + * +__wh + +__THROW +; + +300  + #__ip +( +yr +) \ + +301 (( +yr +% 4 =0 && ((yr% 100 !0 || (yr% 400 =0)) + + ) + +304 #ifde +__USE_MISC + + +309 +time_t + + $timegm + ( +tm + * +__ + +__THROW +; + +312 +time_t + + $timol + ( +tm + * +__ + +__THROW +; + +315  + $dysize + ( +__yr + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +319 #ifde +__USE_POSIX199309 + + +324  + `nop + ( +__cڡ +  +timeec + * +__queed_time +, + +325  +timeec + * +__mag +); + +329  + $ock_gs + ( +ockid_t + +__ock_id +,  +timeec + * +__s + +__THROW +; + +332  + $ock_gtime + ( +ockid_t + +__ock_id +,  +timeec + * +__ + +__THROW +; + +335  + $ock_ime + ( +ockid_t + +__ock_id +, +__cڡ +  +timeec + * +__ +) + +336 +__THROW +; + +338 #ifde +__USE_XOPEN2K + + +343  + `ock_nop + ( +ockid_t + +__ock_id +,  +__ags +, + +344 +__cڡ +  +timeec + * +__q +, + +345  +timeec + * +__m +); + +348  + $ock_guockid + ( +pid_t + +__pid +, +ockid_t + * +__ock_id + +__THROW +; + +353  + $tim_ + ( +ockid_t + +__ock_id +, + +354  +sigevt + * +__ri + +__evp +, + +355 +tim_t + * +__ri + +__timid + +__THROW +; + +358  + $tim_de + ( +tim_t + +__timid + +__THROW +; + +361  + $tim_ime + ( +tim_t + +__timid +,  +__ags +, + +362 +__cڡ +  +imec + * +__ri + +__vue +, + +363  +imec + * +__ri + +__ovue + +__THROW +; + +366  + $tim_gtime + ( +tim_t + +__timid +,  +imec + * +__vue +) + +367 +__THROW +; + +370  + $tim_govrun + ( +tim_t + +__timid + +__THROW +; + +374 #ifde +__USE_XOPEN_EXTENDED + + +386  +gde_r +; + +395  +tm + * + `gde + ( +__cڡ + * +__rg +); + +398 #ifde +__USE_GNU + + +409  + `gde_r + ( +__cڡ + * +__ri + +__rg +, + +410  +tm + * +__ri + +__sbu +); + +413 +__END_DECLS + + + @/usr/include/xlocale.h + +21 #ide +_XLOCALE_H + + +22  + #_XLOCALE_H + 1 + + ) + +28  + s__lo_ru + + +31  +lo_da + * + m__los +[13]; + +34 cڡ * + m__y_b +; + +35 cڡ * + m__y_tow +; + +36 cڡ * + m__y_tou +; + +39 cڡ * + m__mes +[13]; + +40 } * + t__lo_t +; + + @/usr/include/_G_config.h + +4 #ide +_G_cfig_h + + +5  + #_G_cfig_h + 1 + + ) + +9  + ~ + +10  + #__ed_size_t + + + ) + +11  + #__ed_wch_t + + + ) + +12  + #__ed_wt_t + + + ) + +13  + #__ed_NULL + + + ) + +14  + ~ + +15 #ide +_WINT_T + + +20  + #_WINT_T + + + ) + +21  + twt_t +; + +23  + #__ed_mbe_t + + + ) + +24  + ~ + +25  + #_G_size_t + +size_t + + + ) + +28 +__off_t + + m__pos +; + +29 +__mbe_t + + m__e +; + +30 } + t_G_os_t +; + +33 +__off64_t + + m__pos +; + +34 +__mbe_t + + m__e +; + +35 } + t_G_os64_t +; + +36  + #_G_ssize_t + +__ssize_t + + + ) + +37  + #_G_off_t + +__off_t + + + ) + +38  + #_G_off64_t + +__off64_t + + + ) + +39  + #_G_pid_t + +__pid_t + + + ) + +40  + #_G_uid_t + +__uid_t + + + ) + +41  + #_G_wch_t + +wch_t + + + ) + +42  + #_G_wt_t + +wt_t + + + ) + +43  + #_G_64 + +64 + + + ) + +44  + ~ + +47  +__gcv_fo + + m__cd +; + +50  +__gcv_fo + + m__cd +; + +51  +__gcv__da + + m__da +; + +52 } + m__combed +; + +53 } + t_G_icv_t +; + +55  + t_G_t16_t + + t__ibu__ + (( + t__mode__ + ( + t__HI__ +))); + +56  + t_G_t32_t + + t__ibu__ + (( + t__mode__ + ( + t__SI__ +))); + +57  + t_G_ut16_t + + t__ibu__ + (( + t__mode__ + ( + t__HI__ +))); + +58  + t_G_ut32_t + + t__ibu__ + (( + t__mode__ + ( + t__SI__ +))); + +60  + #_G_HAVE_BOOL + 1 + + ) + +64  + #_G_HAVE_ATEXIT + 1 + + ) + +65  + #_G_HAVE_SYS_CDEFS + 1 + + ) + +66  + #_G_HAVE_SYS_WAIT + 1 + + ) + +67  + #_G_NEED_STDARG_H + 1 + + ) + +68  + #_G_va_li + +__gnuc_va_li + + + ) + +70  + #_G_HAVE_PRINTF_FP + 1 + + ) + +71  + #_G_HAVE_MMAP + 1 + + ) + +72  + #_G_HAVE_MREMAP + 1 + + ) + +73  + #_G_HAVE_LONG_DOUBLE_IO + 1 + + ) + +74  + #_G_HAVE_IO_FILE_OPEN + 1 + + ) + +75  + #_G_HAVE_IO_GETLINE_INFO + 1 + + ) + +77  + #_G_IO_IO_FILE_VERSION + 0x20001 + + ) + +79  + #_G_OPEN64 + +__ݒ64 + + + ) + +80  + #_G_LSEEK64 + +__lek64 + + + ) + +81  + #_G_MMAP64 + +__mm64 + + + ) + +82  + #_G_FSTAT64 +( +fd +, +buf + + `__fx64 + ( +_STAT_VER +, fd, buf) + + ) + +85  + #_G_HAVE_ST_BLKSIZE + + `defed + ( +_STATBUF_ST_BLKSIZE +) + + ) + +87  + #_G_BUFSIZ + 8192 + + ) + +90  + #_G_NAMES_HAVE_UNDERSCORE + 0 + + ) + +91  + #_G_VTABLE_LABEL_HAS_LENGTH + 1 + + ) + +92  + #_G_USING_THUNKS + 1 + + ) + +93  + #_G_VTABLE_LABEL_PREFIX + "__vt_" + + ) + +94  + #_G_VTABLE_LABEL_PREFIX_ID + +__vt_ + + + ) + +97 #i +defed + +__lulus + || defed +__STDC__ + + +98  + #_G_ARGS +( +ARGLIST + + ) +ARGLIST + +100  + #_G_ARGS +( +ARGLIST +() + + ) + + @/usr/include/asm-i386/cache.h + +4 #ide +__ARCH_I386_CACHE_H + + +5  + #__ARCH_I386_CACHE_H + + + ) + +9  + #L1_CACHE_SHIFT + ( +CONFIG_X86_L1_CACHE_SHIFT +) + + ) + +10  + #L1_CACHE_BYTES + (1 << +L1_CACHE_SHIFT +) + + ) + +12  + #L1_CACHE_SHIFT_MAX + 7 + + ) + + @/usr/include/asm-i386/fcntl.h + +1 #ide +_I386_FCNTL_H + + +2  + #_I386_FCNTL_H + + + ) + +6  + #O_ACCMODE + 0003 + + ) + +7  + #O_RDONLY + 00 + + ) + +8  + #O_WRONLY + 01 + + ) + +9  + #O_RDWR + 02 + + ) + +10  + #O_CREAT + 0100 + + ) + +11  + #O_EXCL + 0200 + + ) + +12  + #O_NOCTTY + 0400 + + ) + +13  + #O_TRUNC + 01000 + + ) + +14  + #O_APPEND + 02000 + + ) + +15  + #O_NONBLOCK + 04000 + + ) + +16  + #O_NDELAY + +O_NONBLOCK + + + ) + +17  + #O_SYNC + 010000 + + ) + +18  + #FASYNC + 020000 + + ) + +19  + #O_DIRECT + 040000 + + ) + +20  + #O_LARGEFILE + 0100000 + + ) + +21  + #O_DIRECTORY + 0200000 + + ) + +22  + #O_NOFOLLOW + 0400000 + + ) + +23  + #O_NOATIME + 01000000 + + ) + +25  + #F_DUPFD + 0 + + ) + +26  + #F_GETFD + 1 + + ) + +27  + #F_SETFD + 2 + + ) + +28  + #F_GETFL + 3 + + ) + +29  + #F_SETFL + 4 + + ) + +30  + #F_GETLK + 5 + + ) + +31  + #F_SETLK + 6 + + ) + +32  + #F_SETLKW + 7 + + ) + +34  + #F_SETOWN + 8 + + ) + +35  + #F_GETOWN + 9 + + ) + +36  + #F_SETSIG + 10 + + ) + +37  + #F_GETSIG + 11 + + ) + +39  + #F_GETLK64 + 12 + + ) + +40  + #F_SETLK64 + 13 + + ) + +41  + #F_SETLKW64 + 14 + + ) + +44  + #FD_CLOEXEC + 1 + + ) + +47  + #F_RDLCK + 0 + + ) + +48  + #F_WRLCK + 1 + + ) + +49  + #F_UNLCK + 2 + + ) + +52  + #F_EXLCK + 4 + + ) + +53  + #F_SHLCK + 8 + + ) + +56  + #F_INPROGRESS + 16 + + ) + +59  + #LOCK_SH + 1 + + ) + +60  + #LOCK_EX + 2 + + ) + +61  + #LOCK_NB + 4 + + ) + +63  + #LOCK_UN + 8 + + ) + +65  + #LOCK_MAND + 32 + + ) + +66  + #LOCK_READ + 64 + + ) + +67  + #LOCK_WRITE + 128 + + ) + +68  + #LOCK_RW + 192 + + ) + +70  + sock + { + +71  + ml_ty +; + +72  + ml_wh +; + +73 +off_t + + ml_t +; + +74 +off_t + + ml_n +; + +75 +pid_t + + ml_pid +; + +78  + sock64 + { + +79  + ml_ty +; + +80  + ml_wh +; + +81 +loff_t + + ml_t +; + +82 +loff_t + + ml_n +; + +83 +pid_t + + ml_pid +; + +86  + #F_LINUX_SPECIFIC_BASE + 1024 + + ) + + @/usr/include/asm-i386/ioctl.h + +6 #ide +_ASMI386_IOCTL_H + + +7  + #_ASMI386_IOCTL_H + + + ) + +27  + #_IOC_NRBITS + 8 + + ) + +28  + #_IOC_TYPEBITS + 8 + + ) + +29  + #_IOC_SIZEBITS + 14 + + ) + +30  + #_IOC_DIRBITS + 2 + + ) + +32  + #_IOC_NRMASK + ((1 << +_IOC_NRBITS +)-1) + + ) + +33  + #_IOC_TYPEMASK + ((1 << +_IOC_TYPEBITS +)-1) + + ) + +34  + #_IOC_SIZEMASK + ((1 << +_IOC_SIZEBITS +)-1) + + ) + +35  + #_IOC_DIRMASK + ((1 << +_IOC_DIRBITS +)-1) + + ) + +37  + #_IOC_NRSHIFT + 0 + + ) + +38  + #_IOC_TYPESHIFT + ( +_IOC_NRSHIFT ++ +_IOC_NRBITS +) + + ) + +39  + #_IOC_SIZESHIFT + ( +_IOC_TYPESHIFT ++ +_IOC_TYPEBITS +) + + ) + +40  + #_IOC_DIRSHIFT + ( +_IOC_SIZESHIFT ++ +_IOC_SIZEBITS +) + + ) + +45  + #_IOC_NONE + 0U + + ) + +46  + #_IOC_WRITE + 1U + + ) + +47  + #_IOC_READ + 2U + + ) + +49  + #_IOC +( +d +, +ty +, + +, +size +) \ + +50 ((( +d +<< +_IOC_DIRSHIFT +) | \ + +51 (( +ty +<< +_IOC_TYPESHIFT +) | \ + +52 (( + +<< +_IOC_NRSHIFT +) | \ + +53 (( +size +<< +_IOC_SIZESHIFT +)) + + ) + +57  + #_IOC_TYPECHECK +( +t +) + + ) + +60  + #_IO +( +ty +, + + + `_IOC +( +_IOC_NONE +,y),r),0) + + ) + +61  + #_IOR +( +ty +, + +, +size + + `_IOC +( +_IOC_READ +,y),r),( + `_IOC_TYPECHECK +(size))) + + ) + +62  + #_IOW +( +ty +, + +, +size + + `_IOC +( +_IOC_WRITE +,y),r),( + `_IOC_TYPECHECK +(size))) + + ) + +63  + #_IOWR +( +ty +, + +, +size + + `_IOC +( +_IOC_READ +| +_IOC_WRITE +,y),r),( + `_IOC_TYPECHECK +(size))) + + ) + +64  + #_IOR_BAD +( +ty +, + +, +size + + `_IOC +( +_IOC_READ +,y),r),(size)) + + ) + +65  + #_IOW_BAD +( +ty +, + +, +size + + `_IOC +( +_IOC_WRITE +,y),r),(size)) + + ) + +66  + #_IOWR_BAD +( +ty +, + +, +size + + `_IOC +( +_IOC_READ +| +_IOC_WRITE +,y),r),(size)) + + ) + +69  + #_IOC_DIR +( + +((r>> +_IOC_DIRSHIFT +& +_IOC_DIRMASK +) + + ) + +70  + #_IOC_TYPE +( + +((r>> +_IOC_TYPESHIFT +& +_IOC_TYPEMASK +) + + ) + +71  + #_IOC_NR +( + +((r>> +_IOC_NRSHIFT +& +_IOC_NRMASK +) + + ) + +72  + #_IOC_SIZE +( + +((r>> +_IOC_SIZESHIFT +& +_IOC_SIZEMASK +) + + ) + +76  + #IOC_IN + ( +_IOC_WRITE + << +_IOC_DIRSHIFT +) + + ) + +77  + #IOC_OUT + ( +_IOC_READ + << +_IOC_DIRSHIFT +) + + ) + +78  + #IOC_INOUT + (( +_IOC_WRITE +| +_IOC_READ +<< +_IOC_DIRSHIFT +) + + ) + +79  + #IOCSIZE_MASK + ( +_IOC_SIZEMASK + << +_IOC_SIZESHIFT +) + + ) + +80  + #IOCSIZE_SHIFT + ( +_IOC_SIZESHIFT +) + + ) + + @/usr/include/asm-i386/linkage.h + +1 #ide +__ASM_LINKAGE_H + + +2  + #__ASM_LINKAGE_H + + + ) + +4  + #asmlkage + +CPP_ASMLINKAGE + + `__ibu__ +(( + `grm +(0))) + + ) + +5  + #FASTCALL +( +x +x + `__ibu__ +(( + `grm +(3))) + + ) + +6  + # + + `__ibu__ +(( + `grm +(3))) + + ) + +8 #ifde +CONFIG_REGPARM + + +9  + #evt__ +( +t + + `__asm__ + ("" : "" (t: "0" (t)) + + ) + +12 #ifde +CONFIG_X86_ALIGNMENT_16 + + +13  + #__ALIGN + . +ign + 16,0x90 + + ) + +14  + #__ALIGN_STR + ".ig16,0x90" + + ) + + @/usr/include/asm-i386/types.h + +1 #ide +_I386_TYPES_H + + +2  + #_I386_TYPES_H + + + ) + +4 #ide +__ASSEMBLY__ + + +6  + tumode_t +; + +13  +__sigd__ +  + t__s8 +; + +14  + t__u8 +; + +16  +__sigd__ +  + t__s16 +; + +17  + t__u16 +; + +19  +__sigd__ +  + t__s32 +; + +20  + t__u32 +; + +22 #i( +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +)|| ( +__STDC_VERSION__ + >= 199901L) + +23  +__sigd__ +  + t__s64 +; + +24  + t__u64 +; + + @/usr/include/asm-x86_64/cache.h + +4 #ide +__ARCH_X8664_CACHE_H + + +5  + #__ARCH_X8664_CACHE_H + + + ) + +9  + #L1_CACHE_SHIFT + ( +CONFIG_X86_L1_CACHE_SHIFT +) + + ) + +10  + #L1_CACHE_BYTES + (1 << +L1_CACHE_SHIFT +) + + ) + +11  + #L1_CACHE_SHIFT_MAX + 6 + + ) + + @/usr/include/asm-x86_64/fcntl.h + +1 #ide +_X86_64_FCNTL_H + + +2  + #_X86_64_FCNTL_H + + + ) + +6  + #O_ACCMODE + 0003 + + ) + +7  + #O_RDONLY + 00 + + ) + +8  + #O_WRONLY + 01 + + ) + +9  + #O_RDWR + 02 + + ) + +10  + #O_CREAT + 0100 + + ) + +11  + #O_EXCL + 0200 + + ) + +12  + #O_NOCTTY + 0400 + + ) + +13  + #O_TRUNC + 01000 + + ) + +14  + #O_APPEND + 02000 + + ) + +15  + #O_NONBLOCK + 04000 + + ) + +16  + #O_NDELAY + +O_NONBLOCK + + + ) + +17  + #O_SYNC + 010000 + + ) + +18  + #FASYNC + 020000 + + ) + +19  + #O_DIRECT + 040000 + + ) + +20  + #O_LARGEFILE + 0100000 + + ) + +21  + #O_DIRECTORY + 0200000 + + ) + +22  + #O_NOFOLLOW + 0400000 + + ) + +23  + #O_NOATIME + 01000000 + + ) + +25  + #F_DUPFD + 0 + + ) + +26  + #F_GETFD + 1 + + ) + +27  + #F_SETFD + 2 + + ) + +28  + #F_GETFL + 3 + + ) + +29  + #F_SETFL + 4 + + ) + +30  + #F_GETLK + 5 + + ) + +31  + #F_SETLK + 6 + + ) + +32  + #F_SETLKW + 7 + + ) + +34  + #F_SETOWN + 8 + + ) + +35  + #F_GETOWN + 9 + + ) + +36  + #F_SETSIG + 10 + + ) + +37  + #F_GETSIG + 11 + + ) + +40  + #FD_CLOEXEC + 1 + + ) + +43  + #F_RDLCK + 0 + + ) + +44  + #F_WRLCK + 1 + + ) + +45  + #F_UNLCK + 2 + + ) + +48  + #F_EXLCK + 4 + + ) + +49  + #F_SHLCK + 8 + + ) + +52  + #F_INPROGRESS + 16 + + ) + +55  + #LOCK_SH + 1 + + ) + +56  + #LOCK_EX + 2 + + ) + +57  + #LOCK_NB + 4 + + ) + +59  + #LOCK_UN + 8 + + ) + +61  + #LOCK_MAND + 32 + + ) + +62  + #LOCK_READ + 64 + + ) + +63  + #LOCK_WRITE + 128 + + ) + +64  + #LOCK_RW + 192 + + ) + +66  + sock + { + +67  + ml_ty +; + +68  + ml_wh +; + +69 +off_t + + ml_t +; + +70 +off_t + + ml_n +; + +71 +pid_t + + ml_pid +; + +74  + #F_LINUX_SPECIFIC_BASE + 1024 + + ) + + @/usr/include/asm-x86_64/ioctl.h + +6 #ide +_ASMX8664_IOCTL_H + + +7  + #_ASMX8664_IOCTL_H + + + ) + +27  + #_IOC_NRBITS + 8 + + ) + +28  + #_IOC_TYPEBITS + 8 + + ) + +29  + #_IOC_SIZEBITS + 14 + + ) + +30  + #_IOC_DIRBITS + 2 + + ) + +32  + #_IOC_NRMASK + ((1 << +_IOC_NRBITS +)-1) + + ) + +33  + #_IOC_TYPEMASK + ((1 << +_IOC_TYPEBITS +)-1) + + ) + +34  + #_IOC_SIZEMASK + ((1 << +_IOC_SIZEBITS +)-1) + + ) + +35  + #_IOC_DIRMASK + ((1 << +_IOC_DIRBITS +)-1) + + ) + +37  + #_IOC_NRSHIFT + 0 + + ) + +38  + #_IOC_TYPESHIFT + ( +_IOC_NRSHIFT ++ +_IOC_NRBITS +) + + ) + +39  + #_IOC_SIZESHIFT + ( +_IOC_TYPESHIFT ++ +_IOC_TYPEBITS +) + + ) + +40  + #_IOC_DIRSHIFT + ( +_IOC_SIZESHIFT ++ +_IOC_SIZEBITS +) + + ) + +45  + #_IOC_NONE + 0U + + ) + +46  + #_IOC_WRITE + 1U + + ) + +47  + #_IOC_READ + 2U + + ) + +49  + #_IOC +( +d +, +ty +, + +, +size +) \ + +50 ((( +d +<< +_IOC_DIRSHIFT +) | \ + +51 (( +ty +<< +_IOC_TYPESHIFT +) | \ + +52 (( + +<< +_IOC_NRSHIFT +) | \ + +53 (( +size +<< +_IOC_SIZESHIFT +)) + + ) + +56  + #_IO +( +ty +, + + + `_IOC +( +_IOC_NONE +,y),r),0) + + ) + +57  + #_IOR +( +ty +, + +, +size + + `_IOC +( +_IOC_READ +,y),r),(size)) + + ) + +58  + #_IOW +( +ty +, + +, +size + + `_IOC +( +_IOC_WRITE +,y),r),(size)) + + ) + +59  + #_IOWR +( +ty +, + +, +size + + `_IOC +( +_IOC_READ +| +_IOC_WRITE +,y),r),(size)) + + ) + +62  + #_IOC_DIR +( + +((r>> +_IOC_DIRSHIFT +& +_IOC_DIRMASK +) + + ) + +63  + #_IOC_TYPE +( + +((r>> +_IOC_TYPESHIFT +& +_IOC_TYPEMASK +) + + ) + +64  + #_IOC_NR +( + +((r>> +_IOC_NRSHIFT +& +_IOC_NRMASK +) + + ) + +65  + #_IOC_SIZE +( + +((r>> +_IOC_SIZESHIFT +& +_IOC_SIZEMASK +) + + ) + +69  + #IOC_IN + ( +_IOC_WRITE + << +_IOC_DIRSHIFT +) + + ) + +70  + #IOC_OUT + ( +_IOC_READ + << +_IOC_DIRSHIFT +) + + ) + +71  + #IOC_INOUT + (( +_IOC_WRITE +| +_IOC_READ +<< +_IOC_DIRSHIFT +) + + ) + +72  + #IOCSIZE_MASK + ( +_IOC_SIZEMASK + << +_IOC_SIZESHIFT +) + + ) + +73  + #IOCSIZE_SHIFT + ( +_IOC_SIZESHIFT +) + + ) + + @/usr/include/asm-x86_64/linkage.h + +1 #ide +__ASM_LINKAGE_H + + +2  + #__ASM_LINKAGE_H + + + ) + + @/usr/include/asm-x86_64/types.h + +1 #ide +_X86_64_TYPES_H + + +2  + #_X86_64_TYPES_H + + + ) + +4 #ide +__ASSEMBLY__ + + +6  + tumode_t +; + +13  +__sigd__ +  + t__s8 +; + +14  + t__u8 +; + +16  +__sigd__ +  + t__s16 +; + +17  + t__u16 +; + +19  +__sigd__ +  + t__s32 +; + +20  + t__u32 +; + +22 #i( +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +)|| ( +__STDC_VERSION__ + >= 199901L) + +23  +__sigd__ +  + t__s64 +; + +24  + t__u64 +; + + @/usr/include/asm/errno.h + +5 #ide +__i386STUB__ERRNO_H__ + + +6  + #__i386STUB__ERRNO_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/asm/posix_types.h + +5 #ide +__i386STUB__POSIX_TYPES_H__ + + +6  + #__i386STUB__POSIX_TYPES_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/bits/endian.h + +3 #ide +_ENDIAN_H + + +7  + #__BYTE_ORDER + +__LITTLE_ENDIAN + + + ) + + @/usr/include/bits/local_lim.h + +25 #ide +NR_OPEN + + +26  + #__undef_NR_OPEN + + + ) + +28 #ide +LINK_MAX + + +29  + #__undef_LINK_MAX + + + ) + +31 #ide +OPEN_MAX + + +32  + #__undef_OPEN_MAX + + + ) + +36  + ~ + +39 #ifde +__undef_NR_OPEN + + +40 #unde +NR_OPEN + + +41 #unde +__undef_NR_OPEN + + +44 #ifde +__undef_LINK_MAX + + +45 #unde +LINK_MAX + + +46 #unde +__undef_LINK_MAX + + +49 #ifde +__undef_OPEN_MAX + + +50 #unde +OPEN_MAX + + +51 #unde +__undef_OPEN_MAX + + +55  + #_POSIX_THREAD_KEYS_MAX + 128 + + ) + +57  + #PTHREAD_KEYS_MAX + 1024 + + ) + +60  + #_POSIX_THREAD_DESTRUCTOR_ITERATIONS + 4 + + ) + +62  + #PTHREAD_DESTRUCTOR_ITERATIONS + +_POSIX_THREAD_DESTRUCTOR_ITERATIONS + + + ) + +65  + #_POSIX_THREAD_THREADS_MAX + 64 + + ) + +67  + #PTHREAD_THREADS_MAX + 16384 + + ) + +71  + #AIO_PRIO_DELTA_MAX + 20 + + ) + +74  + #PTHREAD_STACK_MIN + 16384 + + ) + +77  + #TIMER_MAX + 256 + + ) + +80  + #DELAYTIMER_MAX + 2147483647 + + ) + +83  + #TTY_NAME_MAX + 32 + + ) + +86  + #LOGIN_NAME_MAX + 256 + + ) + +89  + #HOST_NAME_MAX + 64 + + ) + +92  + #MQ_PRIO_MAX + 32768 + + ) + + @/usr/include/bits/sched.h + +21 #ide +__ed_schedm + + +23 #ide +_SCHED_H + + +29  + #SCHED_OTHER + 0 + + ) + +30  + #SCHED_FIFO + 1 + + ) + +31  + #SCHED_RR + 2 + + ) + +33 #ifde +__USE_MISC + + +35  + #CSIGNAL + 0x000000f + + ) + +36  + #CLONE_VM + 0x00000100 + + ) + +37  + #CLONE_FS + 0x00000200 + + ) + +38  + #CLONE_FILES + 0x00000400 + + ) + +39  + #CLONE_SIGHAND + 0x00000800 + + ) + +40  + #CLONE_PTRACE + 0x00002000 + + ) + +41  + #CLONE_VFORK + 0x00004000 + + ) + +43  + #CLONE_PARENT + 0x00008000 + + ) + +45  + #CLONE_THREAD + 0x00010000 + + ) + +46  + #CLONE_NEWNS + 0x00020000 + + ) + +47  + #CLONE_SYSVSEM + 0x00040000 + + ) + +48  + #CLONE_SETTLS + 0x00080000 + + ) + +49  + #CLONE_PARENT_SETTID + 0x00100000 + + ) + +51  + #CLONE_CHILD_CLEARTID + 0x00200000 + + ) + +53  + #CLONE_DETACHED + 0x00400000 + + ) + +54  + #CLONE_UNTRACED + 0x00800000 + + ) + +56  + #CLONE_CHILD_SETTID + 0x01000000 + + ) + +58  + #CLONE_STOPPED + 0x02000000 + + ) + +62  + ssched_m + + +64  + m__sched_iܙy +; + +67 + g__BEGIN_DECLS + + +70 #ifde +__USE_MISC + + +71  +e + ((* +__ +(* +__g +), * +__chd_ack +, + +72  +__ags +, * +__g + +__THROW +; + +75 +__END_DECLS + + +79 #i! +defed + +__defed_schedm + \ + +80 && ( +defed + +__ed_schedm + || defed +_SCHED_H +) + +81  + #__defed_schedm + 1 + + ) + +83  + s__sched_m + + +85  +__sched_iܙy +; + +87 #unde +__ed_schedm + + +91 #i +defed + +_SCHED_H + && !defed +__u_t_t_defed + + +92  + #__u_t_t_defed + + + ) + +94  + #__CPU_SETSIZE + 1024 + + ) + +95  + #__NCPUBITS + (8 *  ( +__u_mask +)) + + ) + +98  + t__u_mask +; + +101  + #__CPUELT +( +u +((u/ +__NCPUBITS +) + + ) + +102  + #__CPUMASK +( +u +(( +__u_mask +1 << ((u% +__NCPUBITS +)) + + ) + +107 +__u_mask + +__bs +[ +__CPU_SETSIZE + / +__NCPUBITS +]; + +108 } + tu_t_t +; + +111  + #__CPU_ZERO +( +u +) \ + +113  +__i +; \ + +114 +u_t_t + * +__r + = ( +u +); \ + +115  +__i + = 0; __<  ( +u_t_t +/  ( +__u_mask +); ++__i) \ + +116 +__r +-> +__bs +[ +__i +] = 0; \ + +117 + } +} 0) + + ) + +118  + #__CPU_SET +( +u +, +u +) \ + +119 (( +u +)-> +__bs +[ + `__CPUELT + ( +u +)] | + `__CPUMASK + (u)) + + ) + +120  + #__CPU_CLR +( +u +, +u +) \ + +121 (( +u +)-> +__bs +[ + `__CPUELT + ( +u +)] &~ + `__CPUMASK + (u)) + + ) + +122  + #__CPU_ISSET +( +u +, +u +) \ + +123 ((( +u +)-> +__bs +[ + `__CPUELT + ( +u +)] & + `__CPUMASK + (u)!0) + + ) + + @/usr/include/bits/select.h + +19 #ide +_SYS_SELECT_H + + +24 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +26  + #__FD_ZERO +( +fd +) \ + +28  +__d0 +, +__d1 +; \ + +29 +__asm__ + + `__vީe__ + ("cld;ep; stosl" \ + +30 : "=c" ( +__d0 +), "=D" ( +__d1 +) \ + +31 : "a" (0), "0" ( ( +fd_t +) \ + +32 /  ( +__fd_mask +)), \ + +33 "1" (& + `__FDS_BITS + ( +fd +)[0]) \ + +35 } 0) + + ) + +37  + #__FD_SET +( +fd +, +fd +) \ + +38 +__asm__ + + `__vީe__ + ("btsl %1,%0" \ + +39 : "=m" ( + `__FDS_BITS + ( +fd +)[ + `__FDELT + ( +fd +)]) \ + +40 : "r" (((( +fd +)% +__NFDBITS +) \ + +41 : "cc","memy") + + ) + +42  + #__FD_CLR +( +fd +, +fd +) \ + +43 +__asm__ + + `__vީe__ + ("btrl %1,%0" \ + +44 : "=m" ( + `__FDS_BITS + ( +fd +)[ + `__FDELT + ( +fd +)]) \ + +45 : "r" (((( +fd +)% +__NFDBITS +) \ + +46 : "cc","memy") + + ) + +47  + #__FD_ISSET +( +fd +, +fd +) \ + +48 ( +__exnsi__ + \ + +49 ({ +__su +; \ + +50 +__asm__ + + `__vީe__ + ("btl %1,%2 ; setcb %b0" \ + +51 : "=q" ( +__su +) \ + +52 : "r" (((( +fd +)% +__NFDBITS +), \ + +53 "m" ( + `__FDS_BITS + ( +fd +)[ + `__FDELT + ( +fd +)]) \ + +55 +__su +; })) + + ) + +61  + #__FD_ZERO +( +t +) \ + +63  +__i +; \ + +64 +fd_t + * +__r + = ( +t +); \ + +65  +__i + = 0; __<  ( +fd_t +/  ( +__fd_mask +); ++__i) \ + +66 + `__FDS_BITS + ( +__r +)[ +__i +] = 0; \ + +67 } 0) + + ) + +68  + #__FD_SET +( +d +, +t +( + `__FDS_BITS + (t)[ + `__FDELT + (d)] | + `__FDMASK + (d)) + + ) + +69  + #__FD_CLR +( +d +, +t +( + `__FDS_BITS + (t)[ + `__FDELT + (d)] &~ + `__FDMASK + (d)) + + ) + +70  + #__FD_ISSET +( +d +, +t +( + `__FDS_BITS + (t)[ + `__FDELT + (d)] & + `__FDMASK + (d)) + + ) + + @/usr/include/bits/siginfo.h + +20 #i! +defed + +_SIGNAL_H + && !defed +__ed_sigfo_t + \ + +21 && ! +defed + + g__ed_sigevt_t + + +25  + ~ + +27 #i(! +defed + +__have_sigv_t + \ + +28 && ( +defed + + g_SIGNAL_H + || defed + g__ed_sigfo_t + \ + +29 || +defed + + g__ed_sigevt_t +)) + +30  + #__have_sigv_t + 1 + + ) + +33  + usigv + + +35  + msiv_t +; + +36 * + msiv_r +; + +37 } + tsigv_t +; + +40 #i(! +defed + +__have_sigfo_t + \ + +41 && ( +defed + + g_SIGNAL_H + || defed + g__ed_sigfo_t +)) + +42  + #__have_sigfo_t + 1 + + ) + +44  + #__SI_MAX_SIZE + 128 + + ) + +45 #i +__WORDSIZE + == 64 + +46  + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + /  ()- 4) + + ) + +48  + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + /  ()- 3) + + ) + +51  + ssigfo + + +53  + msi_signo +; + +54  + msi_o +; + +56  + msi_code +; + +60  + m_d +[ +__SI_PAD_SIZE +]; + +65 +__pid_t + + msi_pid +; + +66 +__uid_t + + msi_uid +; + +67 } + m_kl +; + +72  + msi_tid +; + +73  + msi_ovrun +; + +74 +sigv_t + + msi_sigv +; + +75 } + m_tim +; + +80 +__pid_t + + msi_pid +; + +81 +__uid_t + + msi_uid +; + +82 +sigv_t + + msi_sigv +; + +83 } + m_ +; + +88 +__pid_t + + msi_pid +; + +89 +__uid_t + + msi_uid +; + +90  + msi_us +; + +91 +__ock_t + + msi_utime +; + +92 +__ock_t + + msi_ime +; + +93 } + m_sigchld +; + +98 * + msi_addr +; + +99 } + m_sigu +; + +104  + msi_bd +; + +105  + msi_fd +; + +106 } + m_sigpl +; + +107 } + m_siflds +; + +108 } + tsigfo_t +; + +112  + #si_pid + +_siflds +. +_kl +. +si_pid + + + ) + +113  + #si_uid + +_siflds +. +_kl +. +si_uid + + + ) + +114  + #si_timid + +_siflds +. +_tim +. +si_tid + + + ) + +115  + #si_ovrun + +_siflds +. +_tim +. +si_ovrun + + + ) + +116  + #si_us + +_siflds +. +_sigchld +. +si_us + + + ) + +117  + #si_utime + +_siflds +. +_sigchld +. +si_utime + + + ) + +118  + #si_ime + +_siflds +. +_sigchld +. +si_ime + + + ) + +119  + #si_vue + +_siflds +. +_ +. +si_sigv + + + ) + +120  + #si_t + +_siflds +. +_ +. +si_sigv +. +siv_t + + + ) + +121  + #si_r + +_siflds +. +_ +. +si_sigv +. +siv_r + + + ) + +122  + #si_addr + +_siflds +. +_sigu +. +si_addr + + + ) + +123  + #si_bd + +_siflds +. +_sigpl +. +si_bd + + + ) + +124  + #si_fd + +_siflds +. +_sigpl +. +si_fd + + + ) + +131 + mSI_ASYNCNL + = -60, + +132  + #SI_ASYNCNL + +SI_ASYNCNL + + + ) + +133 + mSI_TKILL + = -6, + +134  + #SI_TKILL + +SI_TKILL + + + ) + +135 + mSI_SIGIO +, + +136  + #SI_SIGIO + +SI_SIGIO + + + ) + +137 + mSI_ASYNCIO +, + +138  + #SI_ASYNCIO + +SI_ASYNCIO + + + ) + +139 + mSI_MESGQ +, + +140  + #SI_MESGQ + +SI_MESGQ + + + ) + +141 + mSI_TIMER +, + +142  + #SI_TIMER + +SI_TIMER + + + ) + +143 + mSI_QUEUE +, + +144  + #SI_QUEUE + +SI_QUEUE + + + ) + +145 + mSI_USER +, + +146  + #SI_USER + +SI_USER + + + ) + +147 + mSI_KERNEL + = 0x80 + +148  + #SI_KERNEL + +SI_KERNEL + + + ) + +155 + mILL_ILLOPC + = 1, + +156  + #ILL_ILLOPC + +ILL_ILLOPC + + + ) + +157 + mILL_ILLOPN +, + +158  + #ILL_ILLOPN + +ILL_ILLOPN + + + ) + +159 + mILL_ILLADR +, + +160  + #ILL_ILLADR + +ILL_ILLADR + + + ) + +161 + mILL_ILLTRP +, + +162  + #ILL_ILLTRP + +ILL_ILLTRP + + + ) + +163 + mILL_PRVOPC +, + +164  + #ILL_PRVOPC + +ILL_PRVOPC + + + ) + +165 + mILL_PRVREG +, + +166  + #ILL_PRVREG + +ILL_PRVREG + + + ) + +167 + mILL_COPROC +, + +168  + #ILL_COPROC + +ILL_COPROC + + + ) + +169 + mILL_BADSTK + + +170  + #ILL_BADSTK + +ILL_BADSTK + + + ) + +176 + mFPE_INTDIV + = 1, + +177  + #FPE_INTDIV + +FPE_INTDIV + + + ) + +178 + mFPE_INTOVF +, + +179  + #FPE_INTOVF + +FPE_INTOVF + + + ) + +180 + mFPE_FLTDIV +, + +181  + #FPE_FLTDIV + +FPE_FLTDIV + + + ) + +182 + mFPE_FLTOVF +, + +183  + #FPE_FLTOVF + +FPE_FLTOVF + + + ) + +184 + mFPE_FLTUND +, + +185  + #FPE_FLTUND + +FPE_FLTUND + + + ) + +186 + mFPE_FLTRES +, + +187  + #FPE_FLTRES + +FPE_FLTRES + + + ) + +188 + mFPE_FLTINV +, + +189  + #FPE_FLTINV + +FPE_FLTINV + + + ) + +190 + mFPE_FLTSUB + + +191  + #FPE_FLTSUB + +FPE_FLTSUB + + + ) + +197 + mSEGV_MAPERR + = 1, + +198  + #SEGV_MAPERR + +SEGV_MAPERR + + + ) + +199 + mSEGV_ACCERR + + +200  + #SEGV_ACCERR + +SEGV_ACCERR + + + ) + +206 + mBUS_ADRALN + = 1, + +207  + #BUS_ADRALN + +BUS_ADRALN + + + ) + +208 + mBUS_ADRERR +, + +209  + #BUS_ADRERR + +BUS_ADRERR + + + ) + +210 + mBUS_OBJERR + + +211  + #BUS_OBJERR + +BUS_OBJERR + + + ) + +217 + mTRAP_BRKPT + = 1, + +218  + #TRAP_BRKPT + +TRAP_BRKPT + + + ) + +219 + mTRAP_TRACE + + +220  + #TRAP_TRACE + +TRAP_TRACE + + + ) + +226 + mCLD_EXITED + = 1, + +227  + #CLD_EXITED + +CLD_EXITED + + + ) + +228 + mCLD_KILLED +, + +229  + #CLD_KILLED + +CLD_KILLED + + + ) + +230 + mCLD_DUMPED +, + +231  + #CLD_DUMPED + +CLD_DUMPED + + + ) + +232 + mCLD_TRAPPED +, + +233  + #CLD_TRAPPED + +CLD_TRAPPED + + + ) + +234 + mCLD_STOPPED +, + +235  + #CLD_STOPPED + +CLD_STOPPED + + + ) + +236 + mCLD_CONTINUED + + +237  + #CLD_CONTINUED + +CLD_CONTINUED + + + ) + +243 + mPOLL_IN + = 1, + +244  + #POLL_IN + +POLL_IN + + + ) + +245 + mPOLL_OUT +, + +246  + #POLL_OUT + +POLL_OUT + + + ) + +247 + mPOLL_MSG +, + +248  + #POLL_MSG + +POLL_MSG + + + ) + +249 + mPOLL_ERR +, + +250  + #POLL_ERR + +POLL_ERR + + + ) + +251 + mPOLL_PRI +, + +252  + #POLL_PRI + +POLL_PRI + + + ) + +253 + mPOLL_HUP + + +254  + #POLL_HUP + +POLL_HUP + + + ) + +257 #unde +__ed_sigfo_t + + +261 #i( +defed + +_SIGNAL_H + || defed +__ed_sigevt_t +) \ + +262 && ! +defed + + g__have_sigevt_t + + +263  + #__have_sigevt_t + 1 + + ) + +266  + #__SIGEV_MAX_SIZE + 64 + + ) + +267 #i +__WORDSIZE + == 64 + +268  + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + /  ()- 4) + + ) + +270  + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + /  ()- 3) + + ) + +273  + ssigevt + + +275 +sigv_t + + msigev_vue +; + +276  + msigev_signo +; + +277  + msigev_nify +; + +281  + m_d +[ +__SIGEV_PAD_SIZE +]; + +285 +__pid_t + + m_tid +; + +289 (* + m_funi +( + msigv_t +); + +290 * + m_ibu +; + +291 } + m_sigev_thad +; + +292 } + m_sigev_un +; + +293 } + tsigevt_t +; + +296  + #sigev_nify_funi + +_sigev_un +. +_sigev_thad +. +_funi + + + ) + +297  + #sigev_nify_ibus + +_sigev_un +. +_sigev_thad +. +_ibu + + + ) + +302 + mSIGEV_SIGNAL + = 0, + +303  + #SIGEV_SIGNAL + +SIGEV_SIGNAL + + + ) + +304 + mSIGEV_NONE +, + +305  + #SIGEV_NONE + +SIGEV_NONE + + + ) + +306 + mSIGEV_THREAD +, + +307  + #SIGEV_THREAD + +SIGEV_THREAD + + + ) + +309 + mSIGEV_THREAD_ID + = 4 + +310  + #SIGEV_THREAD_ID + +SIGEV_THREAD_ID + + + ) + + @/usr/include/bits/stat.h + +19 #ide +_SYS_STAT_H + + +24  + #_STAT_VER_LINUX_OLD + 1 + + ) + +25  + #_STAT_VER_KERNEL + 1 + + ) + +26  + #_STAT_VER_SVR4 + 2 + + ) + +27  + #_STAT_VER_LINUX + 3 + + ) + +28  + #_STAT_VER + +_STAT_VER_LINUX + + + ) + +31  + #_MKNOD_VER_LINUX + 1 + + ) + +32  + #_MKNOD_VER_SVR4 + 2 + + ) + +33  + #_MKNOD_VER + +_MKNOD_VER_LINUX + + + ) + +36  + s + + +38 +__dev_t + + m_dev +; + +39  + m__d1 +; + +40 #ide +__USE_FILE_OFFSET64 + + +41 +__o_t + + m_o +; + +43 +__o_t + + m___o +; + +45 +__mode_t + + m_mode +; + +46 +__ƚk_t + + m_ƚk +; + +47 +__uid_t + + m_uid +; + +48 +__gid_t + + m_gid +; + +49 +__dev_t + + m_rdev +; + +50  + m__d2 +; + +51 #ide +__USE_FILE_OFFSET64 + + +52 +__off_t + + m_size +; + +54 +__off64_t + + m_size +; + +56 +__blksize_t + + m_blksize +; + +58 #ide +__USE_FILE_OFFSET64 + + +59 +__blkt_t + + m_blocks +; + +61 +__blkt64_t + + m_blocks +; + +63 #ifde +__USE_MISC + + +70  +timeec + + m_im +; + +71  +timeec + + m_mtim +; + +72  +timeec + + m_im +; + +73  + #_ime + +_im +. +tv_c + + + ) + +74  + #_mtime + +_mtim +. +tv_c + + + ) + +75  + #_ime + +_im +. +tv_c + + + ) + +77 +__time_t + + m_ime +; + +78  + m_imc +; + +79 +__time_t + + m_mtime +; + +80  + m_mtimc +; + +81 +__time_t + + m_ime +; + +82  + m_imc +; + +84 #ide +__USE_FILE_OFFSET64 + + +85  + m__unud4 +; + +86  + m__unud5 +; + +88 +__o64_t + + m_o +; + +92 #ifde +__USE_LARGEFILE64 + + +93  + s64 + + +95 +__dev_t + + m_dev +; + +96  + m__d1 +; + +98 +__o_t + + m___o +; + +99 +__mode_t + + m_mode +; + +100 +__ƚk_t + + m_ƚk +; + +101 +__uid_t + + m_uid +; + +102 +__gid_t + + m_gid +; + +103 +__dev_t + + m_rdev +; + +104  + m__d2 +; + +105 +__off64_t + + m_size +; + +106 +__blksize_t + + m_blksize +; + +108 +__blkt64_t + + m_blocks +; + +109 #ifde +__USE_MISC + + +116  +timeec + + m_im +; + +117  +timeec + + m_mtim +; + +118  +timeec + + m_im +; + +120 +__time_t + + m_ime +; + +121  + m_imc +; + +122 +__time_t + + m_mtime +; + +123  + m_mtimc +; + +124 +__time_t + + m_ime +; + +125  + m_imc +; + +127 +__o64_t + + m_o +; + +132  + #_STATBUF_ST_BLKSIZE + + + ) + +133  + #_STATBUF_ST_RDEV + + + ) + +135  + #_STATBUF_ST_NSEC + + + ) + +139  + #__S_IFMT + 0170000 + + ) + +142  + #__S_IFDIR + 0040000 + + ) + +143  + #__S_IFCHR + 0020000 + + ) + +144  + #__S_IFBLK + 0060000 + + ) + +145  + #__S_IFREG + 0100000 + + ) + +146  + #__S_IFIFO + 0010000 + + ) + +147  + #__S_IFLNK + 0120000 + + ) + +148  + #__S_IFSOCK + 0140000 + + ) + +152  + #__S_TYPEISMQ +( +buf +((buf)-> +_mode + - (buf)->_mode) + + ) + +153  + #__S_TYPEISSEM +( +buf +((buf)-> +_mode + - (buf)->_mode) + + ) + +154  + #__S_TYPEISSHM +( +buf +((buf)-> +_mode + - (buf)->_mode) + + ) + +158  + #__S_ISUID + 04000 + + ) + +159  + #__S_ISGID + 02000 + + ) + +160  + #__S_ISVTX + 01000 + + ) + +161  + #__S_IREAD + 0400 + + ) + +162  + #__S_IWRITE + 0200 + + ) + +163  + #__S_IEXEC + 0100 + + ) + + @/usr/include/bits/stdio-lock.h + +20 #ide +_BITS_STDIO_LOCK_H + + +21  + #_BITS_STDIO_LOCK_H + 1 + + ) + +23  + ~ + +25 + $__libc_lock_defe_cursive + (, +_IO_lock_t +) + +28 #ifde + t_LIBC_LOCK_RECURSIVE_INITIALIZER + + +29  + t_IO_lock_liz + + t_LIBC_LOCK_RECURSIVE_INITIALIZER + + + ) + +30 #i + t_IO_MTSAFE_IO + + +31 #r + tlibio + + teds + + tcursive + + tmuxes +  + t_IO_MTSAFE_IO + + +34  + t_IO_lock_ +( + t_me + + t__libc_lock__cursive + (_me) + + ) + +35  + t_IO_lock_fi +( + t_me + + t__libc_lock_fi_cursive + (_me) + + ) + +36  + t_IO_lock_lock +( + t_me + + t__libc_lock_lock_cursive + (_me) + + ) + +37  + t_IO_lock_ylock +( + t_me + + t__libc_lock_ylock_cursive + (_me) + + ) + +38  + t_IO_lock_uock +( + t_me + + t__libc_lock_uock_cursive + (_me) + + ) + +41  + t_IO_nup_gi_t +( + t_f +, + t_ +) \ + +42 + t__libc_nup_gi_t + ((( + t_ +)-> + t_ags + & + t_IO_USER_LOCK +=0, + t_f +, _) + + ) + +43  + t_IO_nup_gi_t_nrg +( + t_f +) \ + +44 + t__libc_nup_gi_t + (1, + t_f +, + tNULL +) + + ) + +45  + t_IO_nup_gi_d +( + t_do +) \ + +46 + t__libc_nup_gi_d + ( + t_do +) + + ) + +48 #i + tdefed + + t_LIBC + && !defed + tNOT_IN_libc + + +49  + t_IO_acque_lock +( + t_ +) \ + +50 + t_IO_nup_gi_t + (((*(*) + t_IO_fuockfe +, ( + t_ +)); \ + +51 + `_IO_ockfe + ( +_ +) + + ) + +53  + #_IO_a_lock +( +_ +) \ + +54 + `_IO_fuockfe + ( +_ +); \ + +55 + `_IO_nup_gi_d + (0) + + ) + + @/usr/include/bits/time.h + +24 #ide +__ed_timev + + +25 #ide +_BITS_TIME_H + + +26  + #_BITS_TIME_H + 1 + + ) + +34  + #CLOCKS_PER_SEC + 1000000l + + ) + +36 #i! +defed + +__STRICT_ANSI__ + && !defed +__USE_XOPEN2K + + +39  + ~ + +40  +__syscf + (); + +41  + #CLK_TCK + (( +__ock_t + + `__syscf + (2) + + ) + +44 #ifde +__USE_POSIX199309 + + +46  + #CLOCK_REALTIME + 0 + + ) + +48  + #CLOCK_MONOTONIC + 1 + + ) + +50  + #CLOCK_PROCESS_CPUTIME_ID + 2 + + ) + +52  + #CLOCK_THREAD_CPUTIME_ID + 3 + + ) + +55  + #TIMER_ABSTIME + 1 + + ) + +61 #ifde +__ed_timev + + +62 #unde +__ed_timev + + +63 #ide +_STRUCT_TIMEVAL + + +64  + #_STRUCT_TIMEVAL + 1 + + ) + +65  + ~ + +69  + stimev + + +71 +__time_t + + mtv_c +; + +72 +__sucds_t + + mtv_uc +; + + @/usr/include/bits/typesizes.h + +20 #ide +_BITS_TYPES_H + + +24 #idef +_BITS_TYPESIZES_H + + +25  + #_BITS_TYPESIZES_H + 1 + + ) + +30  + #__DEV_T_TYPE + +__UQUAD_TYPE + + + ) + +31  + #__UID_T_TYPE + +__U32_TYPE + + + ) + +32  + #__GID_T_TYPE + +__U32_TYPE + + + ) + +33  + #__INO_T_TYPE + +__ULONGWORD_TYPE + + + ) + +34  + #__INO64_T_TYPE + +__UQUAD_TYPE + + + ) + +35  + #__MODE_T_TYPE + +__U32_TYPE + + + ) + +36  + #__NLINK_T_TYPE + +__UWORD_TYPE + + + ) + +37  + #__OFF_T_TYPE + +__SLONGWORD_TYPE + + + ) + +38  + #__OFF64_T_TYPE + +__SQUAD_TYPE + + + ) + +39  + #__PID_T_TYPE + +__S32_TYPE + + + ) + +40  + #__RLIM_T_TYPE + +__ULONGWORD_TYPE + + + ) + +41  + #__RLIM64_T_TYPE + +__UQUAD_TYPE + + + ) + +42  + #__BLKCNT_T_TYPE + +__SLONGWORD_TYPE + + + ) + +43  + #__BLKCNT64_T_TYPE + +__SQUAD_TYPE + + + ) + +44  + #__FSBLKCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +45  + #__FSBLKCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +46  + #__FSFILCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +47  + #__FSFILCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +48  + #__ID_T_TYPE + +__U32_TYPE + + + ) + +49  + #__CLOCK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +50  + #__TIME_T_TYPE + +__SLONGWORD_TYPE + + + ) + +51  + #__USECONDS_T_TYPE + +__U32_TYPE + + + ) + +52  + #__SUSECONDS_T_TYPE + +__SLONGWORD_TYPE + + + ) + +53  + #__DADDR_T_TYPE + +__S32_TYPE + + + ) + +54  + #__SWBLK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +55  + #__KEY_T_TYPE + +__S32_TYPE + + + ) + +56  + #__CLOCKID_T_TYPE + +__S32_TYPE + + + ) + +57  + #__TIMER_T_TYPE + +__S32_TYPE + + + ) + +58  + #__BLKSIZE_T_TYPE + +__SLONGWORD_TYPE + + + ) + +59  + #__FSID_T_TYPE + su {  +__v +[2]; } + + ) + +60  + #__SSIZE_T_TYPE + +__SWORD_TYPE + + + ) + +63  + #__FD_SETSIZE + 1024 + + ) + + @/usr/include/gnu/stubs.h + +6 #ifde +_LIBC + + +7 #r +Alitis + +may + +n + +defe + +the + +mao + +_LIBC + + +10  + #__ub___kl_co + + + ) + +11  + #__ub___kl_sl + + + ) + +12  + #__ub___kl_ + + + ) + +13  + #__ub_chags + + + ) + +14  + #__ub_ach + + + ) + +15  + #__ub_fchags + + + ) + +16  + #__ub_fdach + + + ) + +17  + #__ub_gy + + + ) + +18  + #__ub_lchmod + + + ) + +19  + #__ub_lutimes + + + ) + +20  + #__ub_voke + + + ) + +21  + #__ub_og + + + ) + +22  + #__ub_sk + + + ) + +23  + #__ub_ty + + + ) + + @/usr/include/linux/byteorder/little_endian.h + +1 #ide +_LINUX_BYTEORDER_LITTLE_ENDIAN_H + + +2  + #_LINUX_BYTEORDER_LITTLE_ENDIAN_H + + + ) + +4 #ide +__LITTLE_ENDIAN + + +5  + #__LITTLE_ENDIAN + 1234 + + ) + +7 #ide +__LITTLE_ENDIAN_BITFIELD + + +8  + #__LITTLE_ENDIAN_BITFIELD + + + ) + +11  + ~ + +12  + ~ + +14  + #__cڡt_htl +( +x + + `___cڡt_swab32 +((x)) + + ) + +15  + #__cڡt_ohl +( +x + + `___cڡt_swab32 +((x)) + + ) + +16  + #__cڡt_hts +( +x + + `___cڡt_swab16 +((x)) + + ) + +17  + #__cڡt_ohs +( +x + + `___cڡt_swab16 +((x)) + + ) + +18  + #__cڡt_u_to_64 +( +x +(( +__u64 +)(x)) + + ) + +19  + #__cڡt_64_to_u +( +x +(( +__u64 +)(x)) + + ) + +20  + #__cڡt_u_to_32 +( +x +(( +__u32 +)(x)) + + ) + +21  + #__cڡt_32_to_u +( +x +(( +__u32 +)(x)) + + ) + +22  + #__cڡt_u_to_16 +( +x +(( +__u16 +)(x)) + + ) + +23  + #__cڡt_16_to_u +( +x +(( +__u16 +)(x)) + + ) + +24  + #__cڡt_u_to_be64 +( +x + + `___cڡt_swab64 +((x)) + + ) + +25  + #__cڡt_be64_to_u +( +x + + `___cڡt_swab64 +((x)) + + ) + +26  + #__cڡt_u_to_be32 +( +x + + `___cڡt_swab32 +((x)) + + ) + +27  + #__cڡt_be32_to_u +( +x + + `___cڡt_swab32 +((x)) + + ) + +28  + #__cڡt_u_to_be16 +( +x + + `___cڡt_swab16 +((x)) + + ) + +29  + #__cڡt_be16_to_u +( +x + + `___cڡt_swab16 +((x)) + + ) + +30  + #__u_to_64 +( +x +(( +__u64 +)(x)) + + ) + +31  + #__64_to_u +( +x +(( +__u64 +)(x)) + + ) + +32  + #__u_to_32 +( +x +(( +__u32 +)(x)) + + ) + +33  + #__32_to_u +( +x +(( +__u32 +)(x)) + + ) + +34  + #__u_to_16 +( +x +(( +__u16 +)(x)) + + ) + +35  + #__16_to_u +( +x +(( +__u16 +)(x)) + + ) + +36  + #__u_to_be64 +( +x + + `__swab64 +((x)) + + ) + +37  + #__be64_to_u +( +x + + `__swab64 +((x)) + + ) + +38  + #__u_to_be32 +( +x + + `__swab32 +((x)) + + ) + +39  + #__be32_to_u +( +x + + `__swab32 +((x)) + + ) + +40  + #__u_to_be16 +( +x + + `__swab16 +((x)) + + ) + +41  + #__be16_to_u +( +x + + `__swab16 +((x)) + + ) + +42  + #__u_to_64p +( +x +(*( +__u64 +*)(x)) + + ) + +43  + #__64_to_up +( +x +(*( +__u64 +*)(x)) + + ) + +44  + #__u_to_32p +( +x +(*( +__u32 +*)(x)) + + ) + +45  + #__32_to_up +( +x +(*( +__u32 +*)(x)) + + ) + +46  + #__u_to_16p +( +x +(*( +__u16 +*)(x)) + + ) + +47  + #__16_to_up +( +x +(*( +__u16 +*)(x)) + + ) + +48  + #__u_to_be64p +( +x + + `__swab64p +((x)) + + ) + +49  + #__be64_to_up +( +x + + `__swab64p +((x)) + + ) + +50  + #__u_to_be32p +( +x + + `__swab32p +((x)) + + ) + +51  + #__be32_to_up +( +x + + `__swab32p +((x)) + + ) + +52  + #__u_to_be16p +( +x + + `__swab16p +((x)) + + ) + +53  + #__be16_to_up +( +x + + `__swab16p +((x)) + + ) + +54  + #__u_to_64s +( +x +d{} 0) + + ) + +55  + #__64_to_us +( +x +d{} 0) + + ) + +56  + #__u_to_32s +( +x +d{} 0) + + ) + +57  + #__32_to_us +( +x +d{} 0) + + ) + +58  + #__u_to_16s +( +x +d{} 0) + + ) + +59  + #__16_to_us +( +x +d{} 0) + + ) + +60  + #__u_to_be64s +( +x + + `__swab64s +((x)) + + ) + +61  + #__be64_to_us +( +x + + `__swab64s +((x)) + + ) + +62  + #__u_to_be32s +( +x + + `__swab32s +((x)) + + ) + +63  + #__be32_to_us +( +x + + `__swab32s +((x)) + + ) + +64  + #__u_to_be16s +( +x + + `__swab16s +((x)) + + ) + +65  + #__be16_to_us +( +x + + `__swab16s +((x)) + + ) + +67  + ~ + + @/usr/include/signal.h + +23 #idef +_SIGNAL_H + + +25 #i! +defed + +__ed_sig_omic_t + && !defed +__ed_sigt_t + + +26  + #_SIGNAL_H + + + ) + +29  + ~ + +31 + g__BEGIN_DECLS + + +33  + ~ + +37 #i +defed + +__ed_sig_omic_t + || defed +_SIGNAL_H + + +38 #ide +__sig_omic_t_defed + + +39  + #__sig_omic_t_defed + + + ) + +40 +__BEGIN_NAMESPACE_STD + + +41  +__sig_omic_t + + tsig_omic_t +; + +42 + g__END_NAMESPACE_STD + + +44 #unde +__ed_sig_omic_t + + +47 #i +defed + +__ed_sigt_t + || (defed +_SIGNAL_H + && defed +__USE_POSIX +) + +48 #ide +__sigt_t_defed + + +49  + #__sigt_t_defed + + + ) + +50  +__sigt_t + + tsigt_t +; + +52 #unde +__ed_sigt_t + + +55 #ifde +_SIGNAL_H + + +57  + ~ + +58  + ~ + +60 #i +defed + +__USE_XOPEN + || defed +__USE_XOPEN2K + + +61 #ide +__pid_t_defed + + +62  +__pid_t + + tpid_t +; + +63  + #__pid_t_defed + + + ) + +65 #ifde +__USE_XOPEN + + +67 #ide +__uid_t_defed + + +68  +__uid_t + + tuid_t +; + +69  + #__uid_t_defed + + + ) + +75 (* + t__sighdr_t +) (); + +80 +__sighdr_t + + $__sysv_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +81 +__THROW +; + +82 #ifde +__USE_GNU + + +83 +__sighdr_t + + $sysv_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +84 +__THROW +; + +90 +__BEGIN_NAMESPACE_STD + + +91 #ifde +__USE_BSD + + +92 +__sighdr_t + + $sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +93 +__THROW +; + +96 #ifde +__REDIRECT_NTH + + +97 +__sighdr_t + + `__REDIRECT_NTH + ( +sigl +, + +98 ( +__sig +, +__sighdr_t + +__hdr +), + +99 +__sysv_sigl +); + +101  + #sigl + +__sysv_sigl + + + ) + +104 +__END_NAMESPACE_STD + + +106 #ifde +__USE_XOPEN + + +109 +__sighdr_t + + $bsd_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +110 +__THROW +; + +116 #ifde +__USE_POSIX + + +117  + $kl + ( +__pid_t + +__pid +,  +__sig + +__THROW +; + +120 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +124  + $kg + ( +__pid_t + +__pg +,  +__sig + +__THROW +; + +127 +__BEGIN_NAMESPACE_STD + + +129  + $i + ( +__sig + +__THROW +; + +130 +__END_NAMESPACE_STD + + +132 #ifde +__USE_SVID + + +134 +__sighdr_t + + $ssigl + ( +__sig +, +__sighdr_t + +__hdr +) + +135 +__THROW +; + +136  + $gsigl + ( +__sig + +__THROW +; + +139 #ifde +__USE_MISC + + +141  + `psigl + ( +__sig +, +__cڡ + * +__s +); + +153  + `__sigu + ( +__sig__mask +,  +__is_sig +); + +155 #ifde +__FAVOR_BSD + + +158  + $sigu + ( +__mask + +__THROW + +__ibu_dd__ +; + +160 #ifde +__USE_XOPEN + + +161 #ifde +__GNUC__ + + +162  + $sigu + ( +__sig + + `__asm__ + ("__xpg_sigpause"); + +165  + #sigu +( +sig + + `__sigu + ((sig), 1) + + ) + +171 #ifde +__USE_BSD + + +178  + #sigmask +( +sig + + `__sigmask +(sig) + + ) + +181  + $sigblock + ( +__mask + +__THROW + +__ibu_dd__ +; + +184  + $sigtmask + ( +__mask + +__THROW + +__ibu_dd__ +; + +187  + $siggmask + ( +__THROW + +__ibu_dd__ +; + +191 #ifde +__USE_MISC + + +192  + #NSIG + +_NSIG + + + ) + +195 #ifde +__USE_GNU + + +196  +__sighdr_t + + tsighdr_t +; + +200 #ifde +__USE_BSD + + +201  +__sighdr_t + + tsig_t +; + +204 #ifde +__USE_POSIX + + +206 #ifde +__USE_POSIX199309 + + +208  + #__ed_timeec + + + ) + +209  + ~ + +212  + ~ + +216  + $sigemyt + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +219  + $sigflt + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +222  + $sigaddt + ( +sigt_t + * +__t +,  +__signo + +__THROW + + `__nnu + ((1)); + +225  + $sigdt + ( +sigt_t + * +__t +,  +__signo + +__THROW + + `__nnu + ((1)); + +228  + $sigismemb + ( +__cڡ + +sigt_t + * +__t +,  +__signo +) + +229 +__THROW + + `__nnu + ((1)); + +231 #ifde +__USE_GNU + + +233  + $sigimyt + ( +__cڡ + +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +236  + $sigdt + ( +sigt_t + * +__t +, +__cڡ + sigt_* +__ +, + +237 +__cڡ + +sigt_t + * +__right + +__THROW + + `__nnu + ((1, 2, 3)); + +240  + $sigܣt + ( +sigt_t + * +__t +, +__cڡ + sigt_* +__ +, + +241 +__cڡ + +sigt_t + * +__right + +__THROW + + `__nnu + ((1, 2, 3)); + +246  + ~ + +249  + $sigocmask + ( +__how +, +__cڡ + +sigt_t + * +__ri + +__t +, + +250 +sigt_t + * +__ri + +__ot + +__THROW +; + +257  + $sigsud + ( +__cڡ + +sigt_t + * +__t + + `__nnu + ((1)); + +260  + $sigai + ( +__sig +, +__cڡ +  +sigai + * +__ri + +__a +, + +261  +sigai + * +__ri + +__ + +__THROW +; + +264  + $signdg + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +271  + $sigwa + ( +__cڡ + +sigt_t + * +__ri + +__t +, *__ri +__sig +) + +272 + `__nnu + ((1, 2)); + +274 #ifde +__USE_POSIX199309 + + +279  + $sigwafo + ( +__cڡ + +sigt_t + * +__ri + +__t +, + +280 +sigfo_t + * +__ri + +__fo + + `__nnu + ((1)); + +287  + $sigtimedwa + ( +__cڡ + +sigt_t + * +__ri + +__t +, + +288 +sigfo_t + * +__ri + +__fo +, + +289 +__cڡ +  +timeec + * +__ri + +__timeout +) + +290 + `__nnu + ((1)); + +294  + $sigqueue + ( +__pid_t + +__pid +,  +__sig +, +__cڡ +  +sigv + +__v +) + +295 +__THROW +; + +300 #ifde +__USE_BSD + + +304 +__cڡ + *__cڡ +_sys_sigli +[ +_NSIG +]; + +305 +__cڡ + *__cڡ +sys_sigli +[ +_NSIG +]; + +308  + ssigvec + + +310 +__sighdr_t + +sv_hdr +; + +311  +sv_mask +; + +313  +sv_ags +; + +314  + #sv_ڡack + +sv_ags + + + ) + +318  + #SV_ONSTACK + (1 << 0) + + ) + +319  + #SV_INTERRUPT + (1 << 1) + + ) + +320  + #SV_RESETHAND + (1 << 2) + + ) + +328  + $sigvec + ( +__sig +, +__cڡ +  +sigvec + * +__vec +, + +329  +sigvec + * +__ovec + +__THROW +; + +333  + ~ + +336  + $sigtu + ( +sigcڋxt + * +__s + +__THROW +; + +341 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +346  + $sigu + ( +__sig +,  +__u + +__THROW +; + +348  + ~ + +349 #ifde +__USE_XOPEN + + +351  + ~ + +357  + $sigack + ( +sigack + * +__ss +, sigack * +__oss +) + +358 +__THROW + +__ibu_dd__ +; + +362  + $sigtack + ( +__cڡ +  +sigtack + * +__ri + +__ss +, + +363  +sigtack + * +__ri + +__oss + +__THROW +; + +367 #ifde +__USE_XOPEN_EXTENDED + + +371  + $sighd + ( +__sig + +__THROW +; + +374  + $sigl + ( +__sig + +__THROW +; + +377  + $sigigne + ( +__sig + +__THROW +; + +380 +__sighdr_t + + $sigt + ( +__sig +, +__sighdr_t + +__di + +__THROW +; + +383 #i +defed + +__USE_POSIX199506 + || defed +__USE_UNIX98 + + +386  + ~ + +387  + ~ + +394  + $__libc_cut_sigm + ( +__THROW +; + +396  + $__libc_cut_sigmax + ( +__THROW +; + +400 +__END_DECLS + + + @/usr/include/sys/cdefs.h + +19 #idef +_SYS_CDEFS_H + + +20  + #_SYS_CDEFS_H + 1 + + ) + +23 #ide +_FEATURES_H + + +24  + ~ + +30 #i +defed + +__GNUC__ + && !defed +__STDC__ + + +35 #unde +__P + + +36 #unde +__PMT + + +38 #ifde +__GNUC__ + + +45 #i! +defed + +__lulus + && +__GNUC_PREREQ + (3, 3) + +46  + #__THROW + + `__ibu__ + (( +__nhrow__ +)) + + ) + +47  + #__NTH +( +f + + `__ibu__ + (( +__nhrow__ +) + ) +fct + +49 #i +defed + +__lulus + && +__GNUC_PREREQ + (2,8) + +50  + #__THROW + + `throw + () + + ) + +51  + #__NTH +( +f +f + `throw + () + + ) + +53  + #__THROW + + + ) + +54  + #__NTH +( +f + + ) +fct + +60  + #__le + + + ) + +62  + #__THROW + + + ) + +63  + #__NTH +( +f + + ) +fct + +65  + #__cڡ + cڡ + + ) + +66  + #__sigd + sigd + + ) + +67  + #__vީe + vީe + + ) + +73  + #__P +( +gs + + ) +args + +74  + #__PMT +( +gs + + ) +args + +79  + #__CONCAT +( +x +, +y +x ## + ) +y + +80  + #__STRING +( +x +#x + + ) + +83  + #__r_t + * + + ) + +84  + #__lg_doub_t +  + + ) + +88 #ifdef +__lulus + + +89  + #__BEGIN_DECLS + "C" { + + ) + +90  + #__END_DECLS + } + + ) + +92  + #__BEGIN_DECLS + + + ) + +93  + #__END_DECLS + + + ) + +102 #i +defed + +__lulus + && defed +_GLIBCPP_USE_NAMESPACES + + +103  + #__BEGIN_NAMESPACE_STD + +mea + +d + { + + ) + +104  + #__END_NAMESPACE_STD + } + + ) + +105  + #__USING_NAMESPACE_STD +( +me + +usg + +d +::me; + + ) + +106  + #__BEGIN_NAMESPACE_C99 + +mea + +__c99 + { + + ) + +107  + #__END_NAMESPACE_C99 + } + + ) + +108  + #__USING_NAMESPACE_C99 +( +me + +usg + +__c99 +::me; + + ) + +113  + #__BEGIN_NAMESPACE_STD + + + ) + +114  + #__END_NAMESPACE_STD + + + ) + +115  + #__USING_NAMESPACE_STD +( +me +) + + ) + +116  + #__BEGIN_NAMESPACE_C99 + + + ) + +117  + #__END_NAMESPACE_C99 + + + ) + +118  + #__USING_NAMESPACE_C99 +( +me +) + + ) + +123 #ide +__BOUNDED_POINTERS__ + + +124  + #__bounded + + + ) + +125  + #__unbounded + + + ) + +126  + #__rvue + + + ) + +131  + #__bos +( +r + + `__but_obje_size + (r, +__USE_FORTIFY_LEVEL + > 1) + + ) + +132  + #__bos0 +( +r + + `__but_obje_size + (r, 0) + + ) + +136 #i +__GNUC_PREREQ + (2,97) + +138  + #__exr + [] + + ) + +140 #ifde +__GNUC__ + + +141  + #__exr + [0] + + ) + +143 #i +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +144  + #__exr + [] + + ) + +147  + #__exr + [1] + + ) + +163 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +165  + #__REDIRECT +( +me +, +o +, +s +m + `__asm__ + ( + `__ASMNAME + (#s)) + + ) + +166 #ifde +__lulus + + +167  + #__REDIRECT_NTH +( +me +, +o +, +s +) \ + +168 +me + +o + +__THROW + + `__asm__ + ( + `__ASMNAME + (#s)) + + ) + +170  + #__REDIRECT_NTH +( +me +, +o +, +s +) \ + +171 +me + +o + + `__asm__ + ( + `__ASMNAME + (#s) +__THROW + + + ) + +173  + #__ASMNAME +( +ame + + `__ASMNAME2 + ( +__USER_LABEL_PREFIX__ +, cme) + + ) + +174  + #__ASMNAME2 +( +efix +, +ame + + `__STRING + (efix + ) +cname + +187 #i! +defed + +__GNUC__ + || __GNUC__ < 2 + +188  + #__ibu__ +( +xyz + + + ) + +194 #i +__GNUC_PREREQ + (2,96) + +195  + #__ibu_mloc__ + + `__ibu__ + (( +__mloc__ +)) + + ) + +197  + #__ibu_mloc__ + + + ) + +203 #i +__GNUC_PREREQ + (2,96) + +204  + #__ibu_pu__ + + `__ibu__ + (( +__pu__ +)) + + ) + +206  + #__ibu_pu__ + + + ) + +212 #i +__GNUC_PREREQ + (3,1) + +213  + #__ibu_ud__ + + `__ibu__ + (( +__ud__ +)) + + ) + +214  + #__ibu_nole__ + + `__ibu__ + (( +__nole__ +)) + + ) + +216  + #__ibu_ud__ + + `__ibu__ + (( +__unud__ +)) + + ) + +217  + #__ibu_nole__ + + + ) + +221 #i +__GNUC_PREREQ + (3,2) + +222  + #__ibu_dd__ + + `__ibu__ + (( +__dd__ +)) + + ) + +224  + #__ibu_dd__ + + + ) + +233 #i +__GNUC_PREREQ + (2,8) + +234  + #__ibu_fm_g__ +( +x + + `__ibu__ + (( + `__fm_g__ + (x))) + + ) + +236  + #__ibu_fm_g__ +( +x + + + ) + +243 #i +__GNUC_PREREQ + (2,97) + +244  + #__ibu_fm_rfm__ +( +a +, +b +) \ + +245 + `__ibu__ + (( + `__fm__ + ( +__rfm__ +, +a +, +b +))) + + ) + +247  + #__ibu_fm_rfm__ +( +a +, +b + + + ) + +252 #i +__GNUC_PREREQ + (3,3) + +253  + #__nnu +( +ms + + `__ibu__ + (( +__nnu__ +ams)) + + ) + +255  + #__nnu +( +ms +) + + ) + +262 #i! +__GNUC_PREREQ + (2,8) + +263  + #__exnsi__ + + + ) + +267 #i! +__GNUC_PREREQ + (2,92) + +268  + #__ri + + + ) + +274 #i +__GNUC_PREREQ + (3,1&& ! +defed + +__GNUG__ + + +275  + #__ri_r + +__ri + + + ) + +277 #ifde +__GNUC__ + + +278  + #__ri_r + + + ) + +280 #i +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +281  + #__ri_r + +ri + + + ) + +284  + #__ri_r + + + ) + + @/usr/include/sys/resource.h + +19 #idef +_SYS_RESOURCE_H + + +20  + #_SYS_RESOURCE_H + 1 + + ) + +22  + ~ + +25  + ~ + +27 #ide +__id_t_defed + + +28  +__id_t + + tid_t +; + +29  + #__id_t_defed + + + ) + +32 + g__BEGIN_DECLS + + +38 #i +defed + +__USE_GNU + && !defed +__lulus + + +39  +__im_sour + + t__im_sour_t +; + +40  +__ruge_who + + t__ruge_who_t +; + +41  +__iܙy_which + + t__iܙy_which_t +; + +43  + t__im_sour_t +; + +44  + t__ruge_who_t +; + +45  + t__iܙy_which_t +; + +50 #ide +__USE_FILE_OFFSET64 + + +51  + $gim + ( +__im_sour_t + +__sour +, + +52  +im + * +__ims + +__THROW +; + +54 #ifde +__REDIRECT_NTH + + +55  + `__REDIRECT_NTH + ( +gim +, ( +__im_sour_t + +__sour +, + +56  +im + * +__ims +), +gim64 +); + +58  + #gim + +gim64 + + + ) + +61 #ifde +__USE_LARGEFILE64 + + +62  + $gim64 + ( +__im_sour_t + +__sour +, + +63  +im64 + * +__ims + +__THROW +; + +69 #ide +__USE_FILE_OFFSET64 + + +70  + $lim + ( +__im_sour_t + +__sour +, + +71 +__cڡ +  +im + * +__ims + +__THROW +; + +73 #ifde +__REDIRECT_NTH + + +74  + `__REDIRECT_NTH + ( +lim +, ( +__im_sour_t + +__sour +, + +75 +__cڡ +  +im + * +__ims +), + +76 +lim64 +); + +78  + #lim + +lim64 + + + ) + +81 #ifde +__USE_LARGEFILE64 + + +82  + $lim64 + ( +__im_sour_t + +__sour +, + +83 +__cڡ +  +im64 + * +__ims + +__THROW +; + +88  + $gruge + ( +__ruge_who_t + +__who +,  +ruge + * +__uge + +__THROW +; + +94  + $giܙy + ( +__iܙy_which_t + +__which +, +id_t + +__who + +__THROW +; + +98  + $riܙy + ( +__iܙy_which_t + +__which +, +id_t + +__who +,  +__io +) + +99 +__THROW +; + +101 +__END_DECLS + + + @/usr/include/asm-i386/errno.h + +1 #ide +_I386_ERRNO_H + + +2  + #_I386_ERRNO_H + + + ) + +4 #ide +_LINUX_ERRNO_H + + +5  + ~ + + @/usr/include/asm-i386/posix_types.h + +1 #ide +__ARCH_I386_POSIX_TYPES_H + + +2  + #__ARCH_I386_POSIX_TYPES_H + + + ) + +10  + t__kl_o_t +; + +11  + t__kl_mode_t +; + +12  + t__kl_ƚk_t +; + +13  + t__kl_off_t +; + +14  + t__kl_pid_t +; + +15  + t__kl_c_pid_t +; + +16  + t__kl_uid_t +; + +17  + t__kl_gid_t +; + +18  + t__kl_size_t +; + +19  + t__kl_ssize_t +; + +20  + t__kl_rdiff_t +; + +21  + t__kl_time_t +; + +22  + t__kl_sucds_t +; + +23  + t__kl_ock_t +; + +24  + t__kl_tim_t +; + +25  + t__kl_ockid_t +; + +26  + t__kl_daddr_t +; + +27 * + t__kl_ddr_t +; + +28  + t__kl_uid16_t +; + +29  + t__kl_gid16_t +; + +30  + t__kl_uid32_t +; + +31  + t__kl_gid32_t +; + +33  + t__kl_d_uid_t +; + +34  + t__kl_d_gid_t +; + +35  + t__kl_d_dev_t +; + +37 #i( +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +)|| ( +__STDC_VERSION__ + >= 199901L) + +38  + t__kl_loff_t +; + +42 #i +defed +( +__KERNEL__ +|| defed( +__USE_ALL +) + +43  + mv +[2]; + +45  + m__v +[2]; + +47 } + t__kl_fsid_t +; + +49 #i +defed +( +__KERNEL__ +|| !defed( +__GLIBC__ +) || (__GLIBC__ < 2) + +51 #unde +__FD_SET + + +52  + #__FD_SET +( +fd +, +fd +) \ + +53 +__asm__ + + `__vީe__ +("btsl %1,%0": \ + +54 "=m" (*( +__kl_fd_t + *( +fd +)):"r" ((( +fd +))) + + ) + +56 #unde +__FD_CLR + + +57  + #__FD_CLR +( +fd +, +fd +) \ + +58 +__asm__ + + `__vީe__ +("btrl %1,%0": \ + +59 "=m" (*( +__kl_fd_t + *( +fd +)):"r" ((( +fd +))) + + ) + +61 #unde +__FD_ISSET + + +62  + #__FD_ISSET +( +fd +, +fd +( + `__exnsi__ + ({ \ + +63  +__su +; \ + +64 +__asm__ + + `__vީe__ +("btl %1,%2 ; setb %0" \ + +65 :"=q" ( +__su +:"r" ((( +fd +)), \ + +66 "m" (*( +__kl_fd_t + *( +fd +))); \ + +67 +__su +; })) + + ) + +69 #unde +__FD_ZERO + + +70  + #__FD_ZERO +( +fd +) \ + +72  +__d0 +, +__d1 +; \ + +73 +__asm__ + + `__vީe__ +("cld ;ep ; stosl" \ + +74 :"=m" (*( +__kl_fd_t + *( +fd +)), \ + +75 "=&c" ( +__d0 +), "=&D" ( +__d1 +) \ + +76 :"a" (0), "1" ( +__FDSET_LONGS +), \ + +77 "2" (( +__kl_fd_t + *( +fd +)) : "memory"); \ + +78 } 0) + + ) + + @/usr/include/asm-x86_64/errno.h + +1 #ide +_X8664_ERRNO_H + + +2  + #_X8664_ERRNO_H + + + ) + +4 #ide +_LINUX_ERRNO_H + + +5  + ~ + + @/usr/include/asm-x86_64/posix_types.h + +1 #ide +_ASM_X86_64_POSIX_TYPES_H + + +2  + #_ASM_X86_64_POSIX_TYPES_H + + + ) + +10  + t__kl_o_t +; + +11  + t__kl_mode_t +; + +12  + t__kl_ƚk_t +; + +13  + t__kl_off_t +; + +14  + t__kl_pid_t +; + +15  + t__kl_c_pid_t +; + +16  + t__kl_uid_t +; + +17  + t__kl_gid_t +; + +18  + t__kl_size_t +; + +19  + t__kl_ssize_t +; + +20  + t__kl_rdiff_t +; + +21  + t__kl_time_t +; + +22  + t__kl_sucds_t +; + +23  + t__kl_ock_t +; + +24  + t__kl_tim_t +; + +25  + t__kl_ockid_t +; + +26  + t__kl_daddr_t +; + +27 * + t__kl_ddr_t +; + +28  + t__kl_uid16_t +; + +29  + t__kl_gid16_t +; + +31 #i( +defed +( +__GNUC__ +&& !defed( +__STRICT_ANSI__ +)|| ( +__STDC_VERSION__ + >= 199901L) + +32  + t__kl_loff_t +; + +36  + mv +[2]; + +37 } + t__kl_fsid_t +; + +39  + t__kl_d_uid_t +; + +40  + t__kl_d_gid_t +; + +41  +__kl_uid_t + + t__kl_uid32_t +; + +42  +__kl_gid_t + + t__kl_gid32_t +; + +44  + t__kl_d_dev_t +; + + @/usr/include/bits/libc-lock.h + +21 #ide +_BITS_LIBC_LOCK_H + + +22  + #_BITS_LIBC_LOCK_H + 1 + + ) + +24  + ~ + +26 #i +defed + +_LIBC + && !defed +NOT_IN_libc + + +27  + ~ + +31 #i +defed +( +_LIBC +|| defed( +_IO_MTSAFE_IO +) + +32  +had_mux_t + + t__libc_lock_t +; + +33 ru { +had_mux_t + + mmux +; } + t__libc_lock_cursive_t +; + +34 #ifde +__USE_UNIX98 + + +35  +had_rwlock_t + + t__libc_rwlock_t +; + +37  +__libc_rwlock_aque__ + + t__libc_rwlock_t +; + +39  +__libc_lock_cursive_t + + t__ld_lock_cursive_t +; + +41  +__libc_lock_aque__ + + t__libc_lock_t +; + +42  +__libc_lock_cursive_aque__ + + t__libc_lock_cursive_t +; + +43  +__libc_rwlock_aque__ + + t__libc_rwlock_t +; + +47  +had_key_t + + t__libc_key_t +; + +56  + #__libc_lock_defe +( +CLASS +, +NAME +) \ + +57 +CLASS + +__libc_lock_t + +NAME +; + + ) + +58  + #__libc_rwlock_defe +( +CLASS +, +NAME +) \ + +59 +CLASS + +__libc_rwlock_t + +NAME +; + + ) + +60  + #__libc_lock_defe_cursive +( +CLASS +, +NAME +) \ + +61 +CLASS + +__libc_lock_cursive_t + +NAME +; + + ) + +62  + #__ld_lock_defe_cursive +( +CLASS +, +NAME +) \ + +63 +CLASS + +__ld_lock_cursive_t + +NAME +; + + ) + +74 #ifde +__LT_INITIALIZER_NOT_ZERO + + +75  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +76 +CLASS + +__libc_lock_t + +NAME + = +PTHREAD_MUTEX_INITIALIZER +; + + ) + +78  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +79 +CLASS + +__libc_lock_t + +NAME +; + + ) + +82  + #__libc_rwlock_defe_lized +( +CLASS +, +NAME +) \ + +83 +CLASS + +__libc_rwlock_t + +NAME + = +PTHREAD_RWLOCK_INITIALIZER +; + + ) + +87  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +88 +CLASS + +__libc_lock_cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +89  + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +90 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +92  + #__ld_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +93 +CLASS + +__ld_lock_cursive_t + +NAME + = +_RTLD_LOCK_RECURSIVE_INITIALIZER +; + + ) + +94  + #_RTLD_LOCK_RECURSIVE_INITIALIZER + \ + +95 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +97 #i +defed + +_LIBC + && defed +IS_IN_libhad + + +98  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +FUNC + ) +ARGS + +100 #i +defed + +__PIC__ + || (defed +_LIBC + && defed +SHARED +) + +101  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +) \ + +102 ( + `__exnsi__ + ({ + `__tyof + ( +FUNC +* +_ + = (FUNC); \ + +103 +_ + ! +NULL + ? (*_ +ARGS + : +ELSE +; })) + + ) + +105  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +) \ + +106 ( +FUNC + ! +NULL + ? FUNC +ARGS + : +ELSE +) + + ) + +109 #i +defed + +_LIBC + && !defed +NOT_IN_libc + && defed +SHARED + + +110  + #__libc_maybe_2 +( +FUNC +, +ARGS +, +ELSE +) \ + +111 ({ + `__but_ex + ( +__libc_had_funis +. +r_ +## +FUNC + ! +NULL +, 0) \ + +112 ? +__libc_had_funis +. +r_ +## +FUNC + +ARGS + : +ELSE +; }) + + ) + +114  + #__libc_maybe_2 +( +FUNC +, +ARGS +, +ELSE + + `__libc_maybe_ + ( +__ +##FUNC, ARGS, ELSE) + + ) + +119 #i +defed + +_LIBC + && !defed +NOT_IN_libc + && defed +SHARED + + +120  + #__libc_lock_ +( +NAME +) \ + +122 ( +NAME +). +__m_cou + = 0; \ + +123 ( +NAME +). +__m_owr + = +NULL +; \ + +124 ( +NAME +). +__m_kd + = +PTHREAD_MUTEX_TIMED_NP +; \ + +125 ( +NAME +). +__m_lock +. +__us + = 0; \ + +126 ( +NAME +). +__m_lock +. +__lock + = +__LT_SPINLOCK_INIT +; \ + +127 0; }) + + ) + +129  + #__libc_lock_ +( +NAME +) \ + +130 ( + `__libc_maybe_2 + ( +had_mux_ +, (&( +NAME +), +NULL +), 0)) + + ) + +132  + #__libc_rwlock_ +( +NAME +) \ + +133 ( + `__libc_maybe_ + ( +__had_rwlock_ +, (&( +NAME +), +NULL +), 0)); + + ) + +136 #i +defed + +_LIBC + && !defed +NOT_IN_libc + && defed +SHARED + + +137  + #__libc_lock__cursive +( +NAME +) \ + +139 ( +NAME +). +mux +. +__m_cou + = 0; \ + +140 ( +NAME +). +mux +. +__m_owr + = +NULL +; \ + +141 ( +NAME +). +mux +. +__m_kd + = +PTHREAD_MUTEX_RECURSIVE_NP +; \ + +142 ( +NAME +). +mux +. +__m_lock +. +__us + = 0; \ + +143 ( +NAME +). +mux +. +__m_lock +. +__lock + = +__LT_SPINLOCK_INIT +; \ + +144 0; }) + + ) + +146  + #__libc_lock__cursive +( +NAME +) \ + +148 i( +__had_mux_ + ! +NULL +) \ + +150 +had_mux_t + +__ +; \ + +151 + `__had_mux_ + (& +__ +); \ + +152 + `__had_mux_y + (& +__ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +153 + `__had_mux_ + (&( +NAME +). +mux +, & +__ +); \ + +154 + `__had_mux_deroy + (& +__ +); \ + +156 } 0); + + ) + +158  + #__ld_lock__cursive +( +NAME +) \ + +159 + `__libc_lock__cursive + ( +NAME +) + + ) + +164  + #__libc_lock_fi +( +NAME +) \ + +165 ( + `__libc_maybe_2 + ( +had_mux_deroy +, (&( +NAME +)), 0)); + + ) + +166  + #__libc_rwlock_fi +( +NAME +) \ + +167 ( + `__libc_maybe_ + ( +__had_rwlock_deroy +, (&( +NAME +)), 0)); + + ) + +170  + #__libc_lock_fi_cursive +( +NAME + + `__libc_lock_fi + ((NAME). +mux +) + + ) + +171  + #__ld_lock_fi_cursive +( +NAME + + `__libc_lock_fi_cursive + (NAME) + + ) + +174  + #__libc_lock_lock +( +NAME +) \ + +175 ( + `__libc_maybe_2 + ( +had_mux_lock +, (&( +NAME +)), 0)); + + ) + +176  + #__libc_rwlock_rdlock +( +NAME +) \ + +177 ( + `__libc_maybe_ + ( +__had_rwlock_rdlock +, (&( +NAME +)), 0)); + + ) + +178  + #__libc_rwlock_wock +( +NAME +) \ + +179 ( + `__libc_maybe_ + ( +__had_rwlock_wock +, (&( +NAME +)), 0)); + + ) + +182  + #__libc_lock_lock_cursive +( +NAME + + `__libc_lock_lock + ((NAME). +mux +) + + ) + +185  + #__libc_lock_ylock +( +NAME +) \ + +186 ( + `__libc_maybe_2 + ( +had_mux_ylock +, (&( +NAME +)), 0)) + + ) + +187  + #__libc_rwlock_yrdlock +( +NAME +) \ + +188 ( + `__libc_maybe_ + ( +__had_rwlock_yrdlock +, (&( +NAME +)), 0)) + + ) + +189  + #__libc_rwlock_ywock +( +NAME +) \ + +190 ( + `__libc_maybe_ + ( +__had_rwlock_ywock +, (&( +NAME +)), 0)) + + ) + +193  + #__libc_lock_ylock_cursive +( +NAME + + `__libc_lock_ylock + ((NAME). +mux +) + + ) + +194  + #__ld_lock_ylock_cursive +( +NAME +) \ + +195 + `__libc_lock_ylock_cursive + ( +NAME +) + + ) + +198  + #__libc_lock_uock +( +NAME +) \ + +199 ( + `__libc_maybe_2 + ( +had_mux_uock +, (&( +NAME +)), 0)); + + ) + +200  + #__libc_rwlock_uock +( +NAME +) \ + +201 ( + `__libc_maybe_ + ( +__had_rwlock_uock +, (&( +NAME +)), 0)); + + ) + +204  + #__libc_lock_uock_cursive +( +NAME + + `__libc_lock_uock + ((NAME). +mux +) + + ) + +206 #i +defed + +_LIBC + && defed +SHARED + + +207  + #__ld_lock_deu_lock_cursive +( +lock +) \ + +208 ++(( +had_mux_t + *)( +lock +))-> +__m_cou +; + + ) + +210  + #__ld_lock_deu_uock_cursive +( +lock +) \ + +211 --(( +had_mux_t + *)( +lock +))-> +__m_cou +; + + ) + +213  + #__ld_lock_lock_cursive +( +NAME +) \ + +214 + `GL +( +dl_ld_lock_cursive +(&( +NAME +). +mux +) + + ) + +216  + #__ld_lock_uock_cursive +( +NAME +) \ + +217 + `GL +( +dl_ld_uock_cursive +(&( +NAME +). +mux +) + + ) + +219  + #__ld_lock_lock_cursive +( +NAME + + `__libc_lock_lock_cursive + (NAME) + + ) + +220  + #__ld_lock_uock_cursive +( +NAME + + `__libc_lock_uock_cursive + (NAME) + + ) + +224 #i +PTHREAD_ONCE_INIT + == 0 + +227  + #__libc__defe +( +CLASS +, +NAME +) \ + +228 +CLASS + +had__t + +NAME + + + ) + +230  + #__libc__defe +( +CLASS +, +NAME +) \ + +231 +CLASS + +had__t + +NAME + = +PTHREAD_ONCE_INIT + + + ) + +235  + #__libc_ +( +ONCE_CONTROL +, +INIT_FUNCTION +) \ + +237 i( +__had_ + ! +NULL +) \ + +238 + `__had_ + (&( +ONCE_CONTROL +), ( +INIT_FUNCTION +)); \ + +239 i(( +ONCE_CONTROL += +PTHREAD_ONCE_INIT +) { \ + +240 + `INIT_FUNCTION + (); \ + +241 ( +ONCE_CONTROL +) = 2; \ + +243 } 0) + + ) + +247  + #__libc_nup_gi_t +( +DOIT +, +FCT +, +ARG +) \ + +248 {  +_had_nup_bufr + +_bufr +; \ + +249  +_ava + = ( +DOIT +&& +_had_nup_push_der + ! +NULL +; \ + +250 i( +_ava +) { \ + +251 + `_had_nup_push_der + (& +_bufr +, ( +FCT +), ( +ARG +)); \ + +252 } + + ) + +255  + #__libc_nup_gi_d +( +DOIT +) \ + +256 i( +_ava +) { \ + +257 + `_had_nup_p_e + (& +_bufr +, ( +DOIT +)); \ + +259 } + + ) + +262  + #__libc_nup_d +( +DOIT +) \ + +263 i( +_ava +) { \ + +264 + `_had_nup_p_e + (& +_bufr +, ( +DOIT +)); \ + +265 } + + ) + +267  + #__libc_nup_push +( +f +, +g +) \ + +268 {  +_had_nup_bufr + +_bufr +; \ + +269 + `__libc_maybe_ + ( +_had_nup_push +, (& +_bufr +, ( +f +), ( +g +)), 0) + + ) + +271  + #__libc_nup_p +( +execu +) \ + +272 + `__libc_maybe_ + ( +_had_nup_p +, (& +_bufr +, +execu +), 0); \ + +273 } + + ) + +276  + #__libc_key_ +( +KEY +, +DESTRUCTOR +) \ + +277 ( + `__libc_maybe_ + ( +__had_key_ +, ( +KEY +, +DESTRUCTOR +), 1)) + + ) + +280  + #__libc_gecific +( +KEY +) \ + +281 ( + `__libc_maybe_ + ( +__had_gecific +, ( +KEY +), +NULL +)) + + ) + +284  + #__libc_tecific +( +KEY +, +VALUE +) \ + +285 ( + `__libc_maybe_ + ( +__had_tecific +, ( +KEY +, +VALUE +), 0)) + + ) + +289  + #__libc_fk +( +PREPARE +, +PARENT +, +CHILD +) \ + +290 ( + `__libc_maybe_ + ( +__had_fk +, ( +PREPARE +, +PARENT +, +CHILD +), 0)) + + ) + +295  +__had_mux_ + ( +had_mux_t + * +__mux +, + +296 +__cڡ + +had_mux_t + * +__mux_ +); + +298  +__had_mux_deroy + ( +had_mux_t + * +__mux +); + +300  +__had_mux_ylock + ( +had_mux_t + * +__mux +); + +302  +__had_mux_lock + ( +had_mux_t + * +__mux +); + +304  +__had_mux_uock + ( +had_mux_t + * +__mux +); + +306  +__had_mux_ + ( +had_mux_t + * +__ +); + +308  +__had_mux_deroy + ( +had_mux_t + * +__ +); + +310  +__had_mux_y + ( +had_mux_t + * +__ +, + +311  +__kd +); + +313 #ifde +__USE_UNIX98 + + +314  +__had_rwlock_ + ( +had_rwlock_t + * +__rwlock +, + +315 +__cڡ + +had_rwlock_t + * +__ +); + +317  +__had_rwlock_deroy + ( +had_rwlock_t + * +__rwlock +); + +319  +__had_rwlock_rdlock + ( +had_rwlock_t + * +__rwlock +); + +321  +__had_rwlock_yrdlock + ( +had_rwlock_t + * +__rwlock +); + +323  +__had_rwlock_wock + ( +had_rwlock_t + * +__rwlock +); + +325  +__had_rwlock_ywock + ( +had_rwlock_t + * +__rwlock +); + +327  +__had_rwlock_uock + ( +had_rwlock_t + * +__rwlock +); + +330  +__had_key_ + ( +had_key_t + * +__key +, + +331 (* +__der_funi +) (*)); + +333  + `__had_tecific + ( +had_key_t + +__key +, + +334 +__cڡ + * +__por +); + +336 * + `__had_gecific + ( +had_key_t + +__key +); + +338  + `__had_ + ( +had__t + * +___cڌ +, + +339 (* +___route +) ()); + +341  + `__had_fk + ((* +__e +) (), + +342 (* +__ +) (), + +343 (* +__chd +) ()); + +349 #ide +__NO_WEAK_PTHREAD_ALIASES + + +350 #ifde +wk_ex + + +351 #i +_LIBC + + +352  + ~ + +354  + #BP_SYM + ( +sym + + ) +sym + +356 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ +)) + +357 + `wk_ex + ( + $BP_SYM + ( +__had_mux_deroy +)) + +358 + `wk_ex + ( + $BP_SYM + ( +__had_mux_lock +)) + +359 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ylock +)) + +360 + `wk_ex + ( + $BP_SYM + ( +__had_mux_uock +)) + +361 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ +)) + +362 + `wk_ex + ( + $BP_SYM + ( +__had_mux_deroy +)) + +363 + `wk_ex + ( + $BP_SYM + ( +__had_mux_y +)) + +364 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_ +)) + +365 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_deroy +)) + +366 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_rdlock +)) + +367 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_yrdlock +)) + +368 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_wock +)) + +369 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_ywock +)) + +370 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_uock +)) + +371 + `wk_ex + ( + $BP_SYM + ( +__had_key_ +)) + +372 + `wk_ex + ( + $BP_SYM + ( +__had_tecific +)) + +373 + `wk_ex + ( + $BP_SYM + ( +__had_gecific +)) + +374 + `wk_ex + ( + $BP_SYM + ( +__had_ +)) + +375 + $wk_ex + ( +__had_lize +) + +376 + $wk_ex + ( +__had_fk +) + +377 + `wk_ex + ( + $BP_SYM + ( +_had_nup_push +)) + +378 + `wk_ex + ( + $BP_SYM + ( +_had_nup_p +)) + +379 + `wk_ex + ( + $BP_SYM + ( +_had_nup_push_der +)) + +380 + `wk_ex + ( + $BP_SYM + ( +_had_nup_p_e +)) + +382 #agm +wk + +__had_mux_ + + +383 #agm +wk + +__had_mux_deroy + + +384 #agm +wk + +__had_mux_lock + + +385 #agm +wk + +__had_mux_ylock + + +386 #agm +wk + +__had_mux_uock + + +387 #agm +wk + +__had_mux_ + + +388 #agm +wk + +__had_mux_deroy + + +389 #agm +wk + +__had_mux_y + + +390 #agm +wk + +__had_rwlock_deroy + + +391 #agm +wk + +__had_rwlock_rdlock + + +392 #agm +wk + +__had_rwlock_yrdlock + + +393 #agm +wk + +__had_rwlock_wock + + +394 #agm +wk + +__had_rwlock_ywock + + +395 #agm +wk + +__had_rwlock_uock + + +396 #agm +wk + +__had_key_ + + +397 #agm +wk + +__had_tecific + + +398 #agm +wk + +__had_gecific + + +399 #agm +wk + +__had_ + + +400 #agm +wk + +__had_lize + + +401 #agm +wk + +__had_fk + + +402 #agm +wk + +_had_nup_push_der + + +403 #agm +wk + +_had_nup_p_e + + +404 #agm +wk + +_had_nup_push + + +405 #agm +wk + +_had_nup_p + + +411  + #__libc_mux_uock + +__had_mux_uock + + + ) + + @/usr/include/bits/resource.h + +21 #ide +_SYS_RESOURCE_H + + +25  + ~ + +33 + e__im_sour + + +36 + mRLIMIT_CPU + = 0, + +37  + #RLIMIT_CPU + +RLIMIT_CPU + + + ) + +40 + mRLIMIT_FSIZE + = 1, + +41  + #RLIMIT_FSIZE + +RLIMIT_FSIZE + + + ) + +44 + mRLIMIT_DATA + = 2, + +45  + #RLIMIT_DATA + +RLIMIT_DATA + + + ) + +48 + mRLIMIT_STACK + = 3, + +49  + #RLIMIT_STACK + +RLIMIT_STACK + + + ) + +52 + mRLIMIT_CORE + = 4, + +53  + #RLIMIT_CORE + +RLIMIT_CORE + + + ) + +59 + m__RLIMIT_RSS + = 5, + +60  + #RLIMIT_RSS + +__RLIMIT_RSS + + + ) + +63 + mRLIMIT_NOFILE + = 7, + +64 + m__RLIMIT_OFILE + = +RLIMIT_NOFILE +, + +65  + #RLIMIT_NOFILE + +RLIMIT_NOFILE + + + ) + +66  + #RLIMIT_OFILE + +__RLIMIT_OFILE + + + ) + +69 + mRLIMIT_AS + = 9, + +70  + #RLIMIT_AS + +RLIMIT_AS + + + ) + +73 + m__RLIMIT_NPROC + = 6, + +74  + #RLIMIT_NPROC + +__RLIMIT_NPROC + + + ) + +77 + m__RLIMIT_MEMLOCK + = 8, + +78  + #RLIMIT_MEMLOCK + +__RLIMIT_MEMLOCK + + + ) + +81 + m__RLIMIT_LOCKS + = 10, + +82  + #RLIMIT_LOCKS + +__RLIMIT_LOCKS + + + ) + +85 + m__RLIMIT_SIGPENDING + = 11, + +86  + #RLIMIT_SIGPENDING + +__RLIMIT_SIGPENDING + + + ) + +89 + m__RLIMIT_MSGQUEUE + = 12, + +90  + #RLIMIT_MSGQUEUE + +__RLIMIT_MSGQUEUE + + + ) + +95 + m__RLIMIT_NICE + = 13, + +96  + #RLIMIT_NICE + +__RLIMIT_NICE + + + ) + +100 + m__RLIMIT_RTPRIO + = 14, + +101  + #RLIMIT_RTPRIO + +__RLIMIT_RTPRIO + + + ) + +103 + m__RLIMIT_NLIMITS + = 15, + +104 + m__RLIM_NLIMITS + = +__RLIMIT_NLIMITS + + +105  + #RLIMIT_NLIMITS + +__RLIMIT_NLIMITS + + + ) + +106  + #RLIM_NLIMITS + +__RLIM_NLIMITS + + + ) + +110 #ide +__USE_FILE_OFFSET64 + + +111  + #RLIM_INFINITY + (()(~0UL)) + + ) + +113  + #RLIM_INFINITY + 0xffffffffffffffffuLL + + ) + +116 #ifde +__USE_LARGEFILE64 + + +117  + #RLIM64_INFINITY + 0xffffffffffffffffuLL + + ) + +121  + #RLIM_SAVED_MAX + +RLIM_INFINITY + + + ) + +122  + #RLIM_SAVED_CUR + +RLIM_INFINITY + + + ) + +126 #ide +__USE_FILE_OFFSET64 + + +127  +__im_t + + tim_t +; + +129  +__im64_t + + tim_t +; + +131 #ifde +__USE_LARGEFILE64 + + +132  +__im64_t + + tim64_t +; + +135  + sim + + +138 +im_t + + mim_cur +; + +140 +im_t + + mim_max +; + +143 #ifde +__USE_LARGEFILE64 + + +144  + sim64 + + +147 +im64_t + + mim_cur +; + +149 +im64_t + + mim_max +; + +154 + e__ruge_who + + +157 + mRUSAGE_SELF + = 0, + +158  + #RUSAGE_SELF + +RUSAGE_SELF + + + ) + +161 + mRUSAGE_CHILDREN + = -1 + +162  + #RUSAGE_CHILDREN + +RUSAGE_CHILDREN + + + ) + +165  + #__ed_timev + + + ) + +166  + ~ + +169  + sruge + + +172  +timev + + mru_utime +; + +174  +timev + + mru_ime +; + +176  + mru_maxrss +; + +179  + mru_ixrss +; + +181  + mru_idrss +; + +183  + mru_iss +; + +186  + mru_mt +; + +188  + mru_majt +; + +190  + mru_nsw +; + +193  + mru_block +; + +195  + mru_oublock +; + +197  + mru_msgd +; + +199  + mru_msgrcv +; + +201  + mru_nsigls +; + +205  + mru_nvcsw +; + +208  + mru_nivcsw +; + +212  + #PRIO_MIN + -20 + + ) + +213  + #PRIO_MAX + 20 + + ) + +217 + e__iܙy_which + + +219 + mPRIO_PROCESS + = 0, + +220  + #PRIO_PROCESS + +PRIO_PROCESS + + + ) + +221 + mPRIO_PGRP + = 1, + +222  + #PRIO_PGRP + +PRIO_PGRP + + + ) + +223 + mPRIO_USER + = 2 + +224  + #PRIO_USER + +PRIO_USER + + + ) + + @/usr/include/bits/sigaction.h + +20 #ide +_SIGNAL_H + + +25  + ssigai + + +28 #ifde +__USE_POSIX199309 + + +32 +__sighdr_t + + m_hdr +; + +34 (* + m_sigai +(, + msigfo_t + *, *); + +36 + m__sigai_hdr +; + +37  + #_hdr + +__sigai_hdr +. +_hdr + + + ) + +38  + #_sigai + +__sigai_hdr +. +_sigai + + + ) + +40 +__sighdr_t + + m_hdr +; + +44 +__sigt_t + + m_mask +; + +47  + m_ags +; + +50 (* + m_ܔ +) (); + +54  + #SA_NOCLDSTOP + 1 + + ) + +55  + #SA_NOCLDWAIT + 2 + + ) + +56  + #SA_SIGINFO + 4 + + ) + +58 #i +defed + +__USE_UNIX98 + || defed +__USE_MISC + + +59  + #SA_ONSTACK + 0x08000000 + + ) + +60  + #SA_RESTART + 0x10000000 + + ) + +61  + #SA_NODEFER + 0x40000000 + + ) + +63  + #SA_RESETHAND + 0x80000000 + + ) + +65 #ifde +__USE_MISC + + +66  + #SA_INTERRUPT + 0x20000000 + + ) + +69  + #SA_NOMASK + +SA_NODEFER + + + ) + +70  + #SA_ONESHOT + +SA_RESETHAND + + + ) + +71  + #SA_STACK + +SA_ONSTACK + + + ) + +75  + #SIG_BLOCK + 0 + + ) + +76  + #SIG_UNBLOCK + 1 + + ) + +77  + #SIG_SETMASK + 2 + + ) + + @/usr/include/bits/sigcontext.h + +19 #i! +defed + +_SIGNAL_H + && !defed +_SYS_UCONTEXT_H + + +23 #ide +sigcڋxt_ru + + +26  + #sigcڋxt_ru + +sigcڋxt + + + ) + +28  + ~ + + @/usr/include/bits/signum.h + +20 #ifdef +_SIGNAL_H + + +23  + #SIG_ERR + (( +__sighdr_t +-1 + + ) + +24  + #SIG_DFL + (( +__sighdr_t +0 + + ) + +25  + #SIG_IGN + (( +__sighdr_t +1 + + ) + +27 #ifde +__USE_UNIX98 + + +28  + #SIG_HOLD + (( +__sighdr_t +2 + + ) + +33  + #SIGHUP + 1 + + ) + +34  + #SIGINT + 2 + + ) + +35  + #SIGQUIT + 3 + + ) + +36  + #SIGILL + 4 + + ) + +37  + #SIGTRAP + 5 + + ) + +38  + #SIGABRT + 6 + + ) + +39  + #SIGIOT + 6 + + ) + +40  + #SIGBUS + 7 + + ) + +41  + #SIGFPE + 8 + + ) + +42  + #SIGKILL + 9 + + ) + +43  + #SIGUSR1 + 10 + + ) + +44  + #SIGSEGV + 11 + + ) + +45  + #SIGUSR2 + 12 + + ) + +46  + #SIGPIPE + 13 + + ) + +47  + #SIGALRM + 14 + + ) + +48  + #SIGTERM + 15 + + ) + +49  + #SIGSTKFLT + 16 + + ) + +50  + #SIGCLD + +SIGCHLD + + + ) + +51  + #SIGCHLD + 17 + + ) + +52  + #SIGCONT + 18 + + ) + +53  + #SIGSTOP + 19 + + ) + +54  + #SIGTSTP + 20 + + ) + +55  + #SIGTTIN + 21 + + ) + +56  + #SIGTTOU + 22 + + ) + +57  + #SIGURG + 23 + + ) + +58  + #SIGXCPU + 24 + + ) + +59  + #SIGXFSZ + 25 + + ) + +60  + #SIGVTALRM + 26 + + ) + +61  + #SIGPROF + 27 + + ) + +62  + #SIGWINCH + 28 + + ) + +63  + #SIGPOLL + +SIGIO + + + ) + +64  + #SIGIO + 29 + + ) + +65  + #SIGPWR + 30 + + ) + +66  + #SIGSYS + 31 + + ) + +67  + #SIGUNUSED + 31 + + ) + +69  + #_NSIG + 65 + + ) + +72  + #SIGRTMIN + ( + `__libc_cut_sigm + ()) + + ) + +73  + #SIGRTMAX + ( + `__libc_cut_sigmax + ()) + + ) + +77  + #__SIGRTMIN + 32 + + ) + +78  + #__SIGRTMAX + ( +_NSIG + - 1) + + ) + + @/usr/include/bits/sigstack.h + +20 #ide +_SIGNAL_H + + +26  + ssigack + + +28 * + mss_ +; + +29  + mss_ڡack +; + +36 + mSS_ONSTACK + = 1, + +37  + #SS_ONSTACK + +SS_ONSTACK + + + ) + +38 + mSS_DISABLE + + +39  + #SS_DISABLE + +SS_DISABLE + + + ) + +43  + #MINSIGSTKSZ + 2048 + + ) + +46  + #SIGSTKSZ + 8192 + + ) + +50  + ssigtack + + +52 * + mss_ +; + +53  + mss_ags +; + +54 +size_t + + mss_size +; + +55 } + tack_t +; + + @/usr/include/bits/sigthread.h + +20 #ide +_BITS_SIGTHREAD_H + + +21  + #_BITS_SIGTHREAD_H + 1 + + ) + +23 #i! +defed + +_SIGNAL_H + && !defed +_PTHREAD_H + + +31  + $had_sigmask + ( +__how +, + +32 +__cڡ + +__sigt_t + * +__ri + +__wmask +, + +33 +__sigt_t + * +__ri + +__dmask +) +__THROW +; + +36  + $had_kl + ( +had_t + +__thadid +,  +__signo + +__THROW +; + + @/usr/include/gconv.h + +23 #ide +_GCONV_H + + +24  + #_GCONV_H + 1 + + ) + +26  + ~ + +27  + #__ed_mbe_t + + + ) + +28  + ~ + +29  + #__ed_size_t + + + ) + +30  + #__ed_wch_t + + + ) + +31  + ~ + +34  + #__UNKNOWN_10646_CHAR + (( +wch_t +0xfffd) + + ) + +39 + m__GCONV_OK + = 0, + +40 + m__GCONV_NOCONV +, + +41 + m__GCONV_NODB +, + +42 + m__GCONV_NOMEM +, + +44 + m__GCONV_EMPTY_INPUT +, + +45 + m__GCONV_FULL_OUTPUT +, + +46 + m__GCONV_ILLEGAL_INPUT +, + +47 + m__GCONV_INCOMPLETE_INPUT +, + +49 + m__GCONV_ILLEGAL_DESCRIPTOR +, + +50 + m__GCONV_INTERNAL_ERROR + + +57 + m__GCONV_IS_LAST + = 0x0001, + +58 + m__GCONV_IGNORE_ERRORS + = 0x0002 + +63  + g__gcv_ +; + +64  + g__gcv__da +; + +65  + g__gcv_lded_obje +; + +66  + g__gcv_s_da +; + +70 (* + t__gcv_f +( + t__gcv_ + *,  + t__gcv__da + *, + +71 + t__cڡ + **, __const *, + +72 **, + tsize_t + *, , ); + +75  + $wt_t + (* + t__gcv_btowc_f +( + t__gcv_ + *, ); + +78 (* + t__gcv__f +( + t__gcv_ + *); + +79 (* + t__gcv_d_f +( + t__gcv_ + *); + +83 (* + t__gcv_s_f +( + t__gcv_ + *, + +84  + t__gcv__da + *, *, + +85 + t__cڡ + *, + +86 + t__cڡ + **, + +87 + t__cڡ + *, **, + +88 + tsize_t + *); + +91 (* + t__gcv_s_cڋxt_f +(*, + t__cڡ + *, + +92 + t__cڡ + *, + +96 (* + t__gcv_s_quy_f +( + t__cڡ + *, __const ***, + +97 + tsize_t + *); + +100 (* + t__gcv_s__f +) (**, const *); + +101 (* + t__gcv_s_d_f +) (*); + +103  + s__gcv_s_da + + +106 +__gcv_s_f + +__s_f +; + +107 +__gcv_s_cڋxt_f + +__s_cڋxt_f +; + +108 +__gcv_s_d_f + +__s_d_f +; + +109 * +__da +; + +110  +__gcv_s_da + * +__xt +; + +115  + s__gcv_ + + +117  +__gcv_lded_obje + * +__shlib_hd +; + +118 +__cڡ + * +__modme +; + +120  +__cou +; + +122 * +__om_me +; + +123 * +__to_me +; + +125 +__gcv_f + +__f +; + +126 +__gcv_btowc_f + +__btowc_f +; + +127 +__gcv__f + +___f +; + +128 +__gcv_d_f + +__d_f +; + +132  +__m_eded_om +; + +133  +__max_eded_om +; + +134  +__m_eded_to +; + +135  +__max_eded_to +; + +138  +__eful +; + +140 * +__da +; + +145  + s__gcv__da + + +147 * +__outbuf +; + +148 * +__outbund +; + +152  +__ags +; + +156  +__voti_cou +; + +160  +___u +; + +162 +__mbe_t + * +__ +; + +163 +__mbe_t + +__e +; + +167  +__gcv_s_da + * +__s +; + +172  + s__gcv_fo + + +174 +size_t + +__ns +; + +175  +__gcv_ + * +__s +; + +176 +__exnsi__ +  +__gcv__da + +__da + +__exr +; + +177 } * + t__gcv_t +; + + @/usr/include/linux/byteorder/generic.h + +1 #ide +_LINUX_BYTEORDER_GENERIC_H + + +2  + #_LINUX_BYTEORDER_GENERIC_H + + + ) + + @/usr/include/linux/byteorder/swab.h + +1 #ide +_LINUX_BYTEORDER_SWAB_H + + +2  + #_LINUX_BYTEORDER_SWAB_H + + + ) + +18 #i +defed +( +__GLIBC__ +) + +22  + ~ + +26 #ide +__bsw_cڡt_16 + + +27  + #__bsw_cڡt_16 +( +x +) \ + +28 (((( +x +>> 8& 0xff| (((x& 0xff<< 8)) + + ) + +30 #ide +__bsw_cڡt_32 + + +31  + #__bsw_cڡt_32 +( +x +) \ + +32 (((( +x +) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + +33 ((( +x +& 0x0000ff00<< 8| (((x& 0x000000ff<< 24)) + + ) + +35 #i(! +defed +( +__bsw_cڡt_64 +)&& defed +__GNUC__ + && __GNUC__ >= 2 + +37  + #__bsw_cڡt_64 +( +x +) \ + +38 (((( +x +) & 0xff00000000000000ull) >> 56) \ + +39 | ((( +x +) & 0x00ff000000000000ull) >> 40) \ + +40 | ((( +x +) & 0x0000ff0000000000ull) >> 24) \ + +41 | ((( +x +) & 0x000000ff00000000ull) >> 8) \ + +42 | ((( +x +) & 0x00000000ff000000ull) << 8) \ + +43 | ((( +x +) & 0x0000000000ff0000ull) << 24) \ + +44 | ((( +x +) & 0x000000000000ff00ull) << 40) \ + +45 | ((( +x +& 0x00000000000000ffu<< 56)) + + ) + +48  + #___cڡt_swab16 +( +x + + `__bsw_cڡt_16 +(x) + + ) + +49  + #___cڡt_swab32 +( +x + + `__bsw_cڡt_32 +(x) + + ) + +50  + #___cڡt_swab64 +( +x + + `__bsw_cڡt_64 +(x) + + ) + +52  + #__swab16 +( +x + + `bsw_16 +(x) + + ) + +53  + #__swab32 +( +x + + `bsw_32 +(x) + + ) + +54  + #__swab64 +( +x + + `bsw_64 +(x) + + ) + +56  + #__swab16p +( +x + + `__swab16 +(*(x)) + + ) + +57  + #__swab32p +( +x + + `__swab32 +(*(x)) + + ) + +58  + #__swab64p +( +x + + `__swab64 +(*(x)) + + ) + +60  + #__swab16s +( +x +d{ *(x + `__swab16p +((x)); } 0) + + ) + +61  + #__swab32s +( +x +d{ *(x + `__swab32p +((x)); } 0) + + ) + +62  + #__swab64s +( +x +d{ *(x + `__swab64p +((x)); } 0) + + ) + + @/usr/include/sys/ucontext.h + +19 #ide +_SYS_UCONTEXT_H + + +20  + #_SYS_UCONTEXT_H + 1 + + ) + +22  + ~ + +23  + ~ + +27  + ~ + +31  + tgg_t +; + +34  + #NGREG + 19 + + ) + +37  +gg_t + + tggt_t +[ +NGREG +]; + +39 #ifde +__USE_GNU + + +43 + mREG_GS + = 0, + +44  + #REG_GS + +REG_GS + + + ) + +45 + mREG_FS +, + +46  + #REG_FS + +REG_FS + + + ) + +47 + mREG_ES +, + +48  + #REG_ES + +REG_ES + + + ) + +49 + mREG_DS +, + +50  + #REG_DS + +REG_DS + + + ) + +51 + mREG_EDI +, + +52  + #REG_EDI + +REG_EDI + + + ) + +53 + mREG_ESI +, + +54  + #REG_ESI + +REG_ESI + + + ) + +55 + mREG_EBP +, + +56  + #REG_EBP + +REG_EBP + + + ) + +57 + mREG_ESP +, + +58  + #REG_ESP + +REG_ESP + + + ) + +59 + mREG_EBX +, + +60  + #REG_EBX + +REG_EBX + + + ) + +61 + mREG_EDX +, + +62  + #REG_EDX + +REG_EDX + + + ) + +63 + mREG_ECX +, + +64  + #REG_ECX + +REG_ECX + + + ) + +65 + mREG_EAX +, + +66  + #REG_EAX + +REG_EAX + + + ) + +67 + mREG_TRAPNO +, + +68  + #REG_TRAPNO + +REG_TRAPNO + + + ) + +69 + mREG_ERR +, + +70  + #REG_ERR + +REG_ERR + + + ) + +71 + mREG_EIP +, + +72  + #REG_EIP + +REG_EIP + + + ) + +73 + mREG_CS +, + +74  + #REG_CS + +REG_CS + + + ) + +75 + mREG_EFL +, + +76  + #REG_EFL + +REG_EFL + + + ) + +77 + mREG_UESP +, + +78  + #REG_UESP + +REG_UESP + + + ) + +79 + mREG_SS + + +80  + #REG_SS + +REG_SS + + + ) + +85  + s_libc_g + + +87  + msignifind +[4]; + +88  + mexpڒt +; + +91  + s_libc_塩e + + +93  + mcw +; + +94  + msw +; + +95  + mg +; + +96  + moff +; + +97  + mcsl +; + +98  + mdaoff +; + +99  + mdal +; + +100  +_libc_g + + m_ +[8]; + +101  + mus +; + +105  +_libc_塩e + * + tgt_t +; + +110 +ggt_t + + mggs +; + +113 +gt_t + + mgs +; + +114  + mdmask +; + +115  + m2 +; + +116 } + tmcڋxt_t +; + +119  + sucڋxt + + +121  + muc_ags +; + +122  +ucڋxt + * + muc_lk +; + +123 +ack_t + + muc_ack +; + +124 +mcڋxt_t + + muc_mcڋxt +; + +125 +__sigt_t + + muc_sigmask +; + +126  +_libc_塩e + + m__gs_mem +; + +127 } + tucڋxt_t +; + + @/usr/include/wchar.h + +24 #ide +_WCHAR_H + + +26 #ide +__ed_mbe_t + + +27  + #_WCHAR_H + 1 + + ) + +28  + ~ + +31 #ifde +_WCHAR_H + + +33  + #__ed___FILE + + + ) + +34 #ifde +__USE_UNIX98 + + +35  + #__ed_FILE + + + ) + +37  + ~ + +39  + #__ed___va_li + + + ) + +40  + ~ + +43  + #__ed_size_t + + + ) + +44  + #__ed_wch_t + + + ) + +45  + #__ed_NULL + + + ) + +47  + #__ed_wt_t + + + ) + +48  + ~ + +50  + ~ + +54 #ide +_WINT_T + + +59  + #_WINT_T + + + ) + +60  + twt_t +; + +64 #i +defed + +__lulus + && defed +_GLIBCPP_USE_NAMESPACES + \ + +65 && +defed + +__WINT_TYPE__ + + +66 +__BEGIN_NAMESPACE_STD + + +67  +__WINT_TYPE__ + + twt_t +; + +68 + g__END_NAMESPACE_STD + + +73 #ide +__mbe_t_defed + + +74  + #__mbe_t_defed + 1 + + ) + +78  + m__cou +; + +81 +wt_t + + m__wch +; + +82  + m__wchb +[4]; + +83 } + m__vue +; + +84 } + t__mbe_t +; + +86 #unde +__ed_mbe_t + + +91 #ifde +_WCHAR_H + + +93 +__BEGIN_NAMESPACE_C99 + + +95  +__mbe_t + + tmbe_t +; + +96 + g__END_NAMESPACE_C99 + + +97 #ifde +__USE_GNU + + +98 + $__USING_NAMESPACE_C99 +( +mbe_t +) + +101 #ide +WCHAR_MIN + + +103  + #WCHAR_MIN + +__WCHAR_MIN + + + ) + +104  + #WCHAR_MAX + +__WCHAR_MAX + + + ) + +107 #ide +WEOF + + +108  + #WEOF + (0xffffffffu) + + ) + +113 #i +defed + +__USE_XOPEN + && !defed +__USE_UNIX98 + + +114  + ~ + +118 +__BEGIN_DECLS + + +120 +__BEGIN_NAMESPACE_STD + + +123  +tm +; + +127 + $__USING_NAMESPACE_STD +( +tm +) + +128 +__END_NAMESPACE_STD + + +131 +__BEGIN_NAMESPACE_C99 + + +133 +wch_t + * + $wcsy + ( +wch_t + * +__ri + +__de +, + +134 +__cڡ + +wch_t + * +__ri + +__c + +__THROW +; + +136 +wch_t + * + $wcy + ( +wch_t + * +__ri + +__de +, + +137 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +) + +138 +__THROW +; + +141 +wch_t + * + $wcst + ( +wch_t + * +__ri + +__de +, + +142 +__cڡ + +wch_t + * +__ri + +__c + +__THROW +; + +144 +wch_t + * + $wct + ( +wch_t + * +__ri + +__de +, + +145 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +) + +146 +__THROW +; + +149  + $wcscmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +) + +150 +__THROW + +__ibu_pu__ +; + +152  + $wccmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, +size_t + +__n +) + +153 +__THROW + +__ibu_pu__ +; + +154 +__END_NAMESPACE_C99 + + +156 #ifde +__USE_GNU + + +158  + $wcscmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 + +__THROW +; + +161  + $wccmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +162 +size_t + +__n + +__THROW +; + +166  + ~ + +168  + $wcscmp_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +169 +__lo_t + +__loc + +__THROW +; + +171  + $wccmp_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +172 +size_t + +__n +, +__lo_t + +__loc + +__THROW +; + +175 +__BEGIN_NAMESPACE_C99 + + +178  + $wcscl + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 + +__THROW +; + +182 +size_t + + $wcsxm + ( +wch_t + * +__ri + +__s1 +, + +183 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n + +__THROW +; + +184 +__END_NAMESPACE_C99 + + +186 #ifde +__USE_GNU + + +192  + $wcscl_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +193 +__lo_t + +__loc + +__THROW +; + +198 +size_t + + $wcsxm_l + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, + +199 +size_t + +__n +, +__lo_t + +__loc + +__THROW +; + +202 +wch_t + * + $wcsdup + ( +__cڡ + +wch_t + * +__s + +__THROW + +__ibu_mloc__ +; + +205 +__BEGIN_NAMESPACE_C99 + + +207 +wch_t + * + $wcschr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +208 +__THROW + +__ibu_pu__ +; + +210 +wch_t + * + $wcchr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +211 +__THROW + +__ibu_pu__ +; + +212 +__END_NAMESPACE_C99 + + +214 #ifde +__USE_GNU + + +217 +wch_t + * + $wcschul + ( +__cڡ + +wch_t + * +__s +, wch_ +__wc +) + +218 +__THROW + +__ibu_pu__ +; + +221 +__BEGIN_NAMESPACE_C99 + + +224 +size_t + + $wcscn + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__je +) + +225 +__THROW + +__ibu_pu__ +; + +228 +size_t + + $wcsn + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__ac +) + +229 +__THROW + +__ibu_pu__ +; + +231 +wch_t + * + $wcbrk + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__ac +) + +232 +__THROW + +__ibu_pu__ +; + +234 +wch_t + * + $wcsr + ( +__cڡ + +wch_t + * +__hayack +, __cڡ wch_* +__ed +) + +235 +__THROW + +__ibu_pu__ +; + +238 +wch_t + * + $wcok + ( +wch_t + * +__ri + +__s +, + +239 +__cڡ + +wch_t + * +__ri + +__dim +, + +240 +wch_t + ** +__ri + +__r + +__THROW +; + +243 +size_t + + $wc + ( +__cڡ + +wch_t + * +__s + +__THROW + +__ibu_pu__ +; + +244 +__END_NAMESPACE_C99 + + +246 #ifde +__USE_XOPEN + + +248 +wch_t + * + $wcswcs + ( +__cڡ + +wch_t + * +__hayack +, __cڡ wch_* +__ed +) + +249 +__THROW + +__ibu_pu__ +; + +252 #ifde +__USE_GNU + + +254 +size_t + + $wcn + ( +__cڡ + +wch_t + * +__s +, +size_t + +__maxn +) + +255 +__THROW + +__ibu_pu__ +; + +259 +__BEGIN_NAMESPACE_C99 + + +261 +wch_t + * + $wmemchr + ( +__cڡ + +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +) + +262 +__THROW + +__ibu_pu__ +; + +265  + $wmemcmp + ( +__cڡ + +wch_t + * +__ri + +__s1 +, + +266 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +) + +267 +__THROW + +__ibu_pu__ +; + +270 +wch_t + * + $wmemy + ( +wch_t + * +__ri + +__s1 +, + +271 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n + +__THROW +; + +275 +wch_t + * + $wmemmove + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, +size_t + +__n +) + +276 +__THROW +; + +279 +wch_t + * + $wmemt + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n + +__THROW +; + +280 +__END_NAMESPACE_C99 + + +282 #ifde +__USE_GNU + + +285 +wch_t + * + $wmempy + ( +wch_t + * +__ri + +__s1 +, + +286 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +) + +287 +__THROW +; + +291 +__BEGIN_NAMESPACE_C99 + + +294 +wt_t + + $btowc + ( +__c + +__THROW +; + +298  + $wob + ( +wt_t + +__c + +__THROW +; + +302  + $mbs + ( +__cڡ + +mbe_t + * +__ps + +__THROW + +__ibu_pu__ +; + +306 +size_t + + $mbowc + ( +wch_t + * +__ri + +__pwc +, + +307 +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +308 +mbe_t + * +__p + +__THROW +; + +311 +size_t + + $wtomb + (* +__ri + +__s +, +wch_t + +__wc +, + +312 +mbe_t + * +__ri + +__ps + +__THROW +; + +315 +size_t + + $__mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +316 +mbe_t + * +__ri + +__ps + +__THROW +; + +317 +size_t + + $mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +318 +mbe_t + * +__ri + +__ps + +__THROW +; + +319 +__END_NAMESPACE_C99 + + +321 #ifde +__USE_EXTERN_INLINES + + +323 +__le + +size_t + + +324 + `__NTH + ( + $mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +325 +mbe_t + * +__ri + +__ps +)) + +326 {  ( +__ps + ! +NULL + + +327 ? + `mbowc + ( +NULL +, +__s +, +__n +, +__ps +: + `__mb + (__s, __n, NULL)); + } +} + +330 +__BEGIN_NAMESPACE_C99 + + +333 +size_t + + $mbtowcs + ( +wch_t + * +__ri + +__d +, + +334 +__cڡ + ** +__ri + +__c +, +size_t + +__n +, + +335 +mbe_t + * +__ri + +__ps + +__THROW +; + +339 +size_t + + $wctombs + (* +__ri + +__d +, + +340 +__cڡ + +wch_t + ** +__ri + +__c +, +size_t + +__n +, + +341 +mbe_t + * +__ri + +__ps + +__THROW +; + +342 +__END_NAMESPACE_C99 + + +345 #ifdef +__USE_GNU + + +348 +size_t + + $mbowcs + ( +wch_t + * +__ri + +__d +, + +349 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +350 +size_t + +__n +, +mbe_t + * +__ri + +__ps + +__THROW +; + +354 +size_t + + $wcombs + (* +__ri + +__d +, + +355 +__cڡ + +wch_t + ** +__ri + +__c +, + +356 +size_t + +__nwc +, size_ +__n +, + +357 +mbe_t + * +__ri + +__ps + +__THROW +; + +362 #ifde +__USE_XOPEN + + +364  + $wcwidth + ( +wch_t + +__c + +__THROW +; + +368  + $wcswidth + ( +__cڡ + +wch_t + * +__s +, +size_t + +__n + +__THROW +; + +372 +__BEGIN_NAMESPACE_C99 + + +375  + $wcod + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +376 +wch_t + ** +__ri + +__dr + +__THROW +; + +378 #ifde +__USE_ISOC99 + + +380  + $wcof + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +381 +wch_t + ** +__ri + +__dr + +__THROW +; + +382  + $wcd + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +383 +wch_t + ** +__ri + +__dr + +__THROW +; + +389  + $wc + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +390 +wch_t + ** +__ri + +__dr +,  +__ba + +__THROW +; + +394  + $wcoul + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +395 +wch_t + ** +__ri + +__dr +,  +__ba +) + +396 +__THROW +; + +398 #i +defed + +__USE_ISOC99 + || (defed +__GNUC__ + && defed +__USE_GNU +) + +401 +__exnsi__ + + +402  + $wcl + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +403 +wch_t + ** +__ri + +__dr +,  +__ba +) + +404 +__THROW +; + +408 +__exnsi__ + + +409  + $wcou + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +410 +wch_t + ** +__ri + +__dr +, + +411  +__ba + +__THROW +; + +413 +__END_NAMESPACE_C99 + + +415 #i +defed + +__GNUC__ + && defed +__USE_GNU + + +418 +__exnsi__ + + +419  + $wcoq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +420 +wch_t + ** +__ri + +__dr +,  +__ba +) + +421 +__THROW +; + +425 +__exnsi__ + + +426  + $wcouq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +427 +wch_t + ** +__ri + +__dr +, + +428  +__ba + +__THROW +; + +431 #ifde +__USE_GNU + + +445  + ~ + +449  + $wc_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +450 +wch_t + ** +__ri + +__dr +,  +__ba +, + +451 +__lo_t + +__loc + +__THROW +; + +453  + $wcoul_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +454 +wch_t + ** +__ri + +__dr +, + +455  +__ba +, +__lo_t + +__loc + +__THROW +; + +457 +__exnsi__ + + +458  + $wcl_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +459 +wch_t + ** +__ri + +__dr +, + +460  +__ba +, +__lo_t + +__loc + +__THROW +; + +462 +__exnsi__ + + +463  + $wcou_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +464 +wch_t + ** +__ri + +__dr +, + +465  +__ba +, +__lo_t + +__loc +) + +466 +__THROW +; + +468  + $wcod_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +469 +wch_t + ** +__ri + +__dr +, +__lo_t + +__loc +) + +470 +__THROW +; + +472  + $wcof_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +473 +wch_t + ** +__ri + +__dr +, +__lo_t + +__loc +) + +474 +__THROW +; + +476  + $wcd_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +477 +wch_t + ** +__ri + +__dr +, + +478 +__lo_t + +__loc + +__THROW +; + +484  + $__wcod_ + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +485 +wch_t + ** +__ri + +__dr +,  +__group +) + +486 +__THROW +; + +487  + $__wcof_ + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +488 +wch_t + ** +__ri + +__dr +,  +__group +) + +489 +__THROW +; + +490  + $__wcd_ + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +491 +wch_t + ** +__ri + +__dr +, + +492  +__group + +__THROW +; + +494 #ide +__wc__defed + + +495  + $__wc_ + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +496 +wch_t + ** +__ri + +__dr +, + +497  +__ba +,  +__group + +__THROW +; + +498  + #__wc__defed + 1 + + ) + +500 #ide +__wcoul__defed + + +501  + $__wcoul_ + ( +__cڡ + +wch_t + * +__ri + +__t +, + +502 +wch_t + ** +__ri + +__dr +, + +503  +__ba +,  +__group + +__THROW +; + +504  + #__wcoul__defed + 1 + + ) + +506 #ide +__wcl__defed + + +507 +__exnsi__ + + +508  + $__wcl_ + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +509 +wch_t + ** +__ri + +__dr +, + +510  +__ba +,  +__group + +__THROW +; + +511  + #__wcl__defed + 1 + + ) + +513 #ide +__wcou__defed + + +514 +__exnsi__ + + +515  + $__wcou_ + ( +__cڡ + +wch_t + * + +516 +__ri + +__Ō +, + +517 +wch_t + ** + +518 +__ri + +__dr +, + +519  +__ba +, + +520  +__group + +__THROW +; + +521  + #__wcou__defed + 1 + + ) + +525 #i +defed + +__OPTIMIZE__ + && +__GNUC__ + >= 2 + +527 +__BEGIN_NAMESPACE_C99 + + +529 +__le +  + +530 + `__NTH + ( + $wcod + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +531 +wch_t + ** +__ri + +__dr +)) + +532 {  + `__wcod_ + ( +__Ō +, +__dr +, 0); + } +} + +533 +__le +  + +534 +__NTH + ( + $wc + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +535 +wch_t + ** +__ri + +__dr +,  +__ba +)) + +536 {  + `__wc_ + ( +__Ō +, +__dr +, +__ba +, 0); + } +} + +537 +__le +  + +538 +__NTH + ( + $wcoul + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +539 +wch_t + ** +__ri + +__dr +,  +__ba +)) + +540 {  + `__wcoul_ + ( +__Ō +, +__dr +, +__ba +, 0); + } +} + +541 +__END_NAMESPACE_C99 + + +543 #ifde +__USE_GNU + + +544 +__le +  + +545 +__NTH + ( + $wcof + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +546 +wch_t + ** +__ri + +__dr +)) + +547 {  + `__wcof_ + ( +__Ō +, +__dr +, 0); + } +} + +548 +__le +  + +549 +__NTH + ( + $wcd + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +550 +wch_t + ** +__ri + +__dr +)) + +551 {  + `__wcd_ + ( +__Ō +, +__dr +, 0); + } +} + +554 +__exnsi__ + + +555 +__le +  + +556 +__NTH + ( + $wcoq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +557 +wch_t + ** +__ri + +__dr +,  +__ba +)) + +558 {  + `__wcl_ + ( +__Ō +, +__dr +, +__ba +, 0); + } +} + +559 +__exnsi__ + + +560 +__le +  + +561 +__NTH + ( + $wcouq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +562 +wch_t + ** +__ri + +__dr +,  +__ba +)) + +563 {  + `__wcou_ + ( +__Ō +, +__dr +, +__ba +, 0); + } +} + +568 #ifdef +__USE_GNU + + +571 +wch_t + * + $wy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c + +__THROW +; + +575 +wch_t + * + $wny + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +) + +576 +__THROW +; + +581 #i +defed + +__USE_ISOC99 + || defed +__USE_UNIX98 + + +582 +__BEGIN_NAMESPACE_C99 + + +585  + $fwide + ( +__FILE + * +__ +,  +__mode + +__THROW +; + +592  + `fwtf + ( +__FILE + * +__ri + +__am +, + +593 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +599  + `wtf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +602  + $swtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +603 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +604 +__THROW + ; + +610  + `vfwtf + ( +__FILE + * +__ri + +__s +, + +611 +__cڡ + +wch_t + * +__ri + +__fm +, + +612 +__gnuc_va_li + +__g +) + +618  + `vwtf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +619 +__gnuc_va_li + +__g +) + +623  + $vswtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +624 +__cڡ + +wch_t + * +__ri + +__fm +, + +625 +__gnuc_va_li + +__g +) + +626 +__THROW + ; + +633  + `fwsnf + ( +__FILE + * +__ri + +__am +, + +634 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +640  + `wsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +643  + $swsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +644 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +645 +__THROW + ; + +647 +__END_NAMESPACE_C99 + + +650 #ifde +__USE_ISOC99 + + +651 +__BEGIN_NAMESPACE_C99 + + +657  + `vfwsnf + ( +__FILE + * +__ri + +__s +, + +658 +__cڡ + +wch_t + * +__ri + +__fm +, + +659 +__gnuc_va_li + +__g +) + +665  + `vwsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +666 +__gnuc_va_li + +__g +) + +669  + $vswsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +670 +__cڡ + +wch_t + * +__ri + +__fm +, + +671 +__gnuc_va_li + +__g +) + +672 +__THROW + ; + +674 +__END_NAMESPACE_C99 + + +678 +__BEGIN_NAMESPACE_C99 + + +683 +wt_t + + `fgwc + ( +__FILE + * +__am +); + +684 +wt_t + + `gwc + ( +__FILE + * +__am +); + +690 +wt_t + + `gwch + (); + +697 +wt_t + + `utwc + ( +wch_t + +__wc +, +__FILE + * +__am +); + +698 +wt_t + + `putwc + ( +wch_t + +__wc +, +__FILE + * +__am +); + +704 +wt_t + + `putwch + ( +wch_t + +__wc +); + +712 +wch_t + * + `fgws + (wch_* +__ri + +__ws +,  +__n +, + +713 +__FILE + * +__ri + +__am +); + +719  + `utws + ( +__cڡ + +wch_t + * +__ri + +__ws +, + +720 +__FILE + * +__ri + +__am +); + +727 +wt_t + + `ungwc + (wt_ +__wc +, +__FILE + * +__am +); + +728 +__END_NAMESPACE_C99 + + +731 #ifde +__USE_GNU + + +739 +wt_t + + `gwc_uocked + ( +__FILE + * +__am +); + +740 +wt_t + + `gwch_uocked + (); + +748 +wt_t + + `fgwc_uocked + ( +__FILE + * +__am +); + +756 +wt_t + + `utwc_uocked + ( +wch_t + +__wc +, +__FILE + * +__am +); + +765 +wt_t + + `putwc_uocked + ( +wch_t + +__wc +, +__FILE + * +__am +); + +766 +wt_t + + `putwch_uocked + ( +wch_t + +__wc +); + +775 +wch_t + * + `fgws_uocked + (wch_* +__ri + +__ws +,  +__n +, + +776 +__FILE + * +__ri + +__am +); + +784  + `utws_uocked + ( +__cڡ + +wch_t + * +__ri + +__ws +, + +785 +__FILE + * +__ri + +__am +); + +789 +__BEGIN_NAMESPACE_C99 + + +793 +size_t + + $wcsime + ( +wch_t + * +__ri + +__s +, +size_t + +__maxsize +, + +794 +__cڡ + +wch_t + * +__ri + +__fm +, + +795 +__cڡ +  +tm + * +__ri + +__ + +__THROW +; + +796 +__END_NAMESPACE_C99 + + +798 #ifde +__USE_GNU + + +799  + ~ + +803 +size_t + + $wcsime_l + ( +wch_t + * +__ri + +__s +, +size_t + +__maxsize +, + +804 +__cڡ + +wch_t + * +__ri + +__fm +, + +805 +__cڡ +  +tm + * +__ri + +__ +, + +806 +__lo_t + +__loc + +__THROW +; + +815 #i +defed + +__USE_UNIX98 + && !defed +__USE_GNU + + +816  + #__ed_iswxxx + + + ) + +817  + ~ + +820 +__END_DECLS + + + @/usr/include/asm/sigcontext.h + +5 #ide +__i386STUB__SIGCONTEXT_H__ + + +6  + #__i386STUB__SIGCONTEXT_H__ + + + ) + +8 #ifde +__x86_64__ + + +9  + ~ + +11  + ~ + + @/usr/include/byteswap.h + +19 #ide +_BYTESWAP_H + + +20  + #_BYTESWAP_H + 1 + + ) + +23  + ~ + +30  + #bsw_16 +( +x + + `__bsw_16 + (x) + + ) + +33  + #bsw_32 +( +x + + `__bsw_32 + (x) + + ) + +35 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +37  + #bsw_64 +( +x + + `__bsw_64 + (x) + + ) + + @/usr/include/pthread.h + +15 #ide +_PTHREAD_H + + +16  + #_PTHREAD_H + 1 + + ) + +18  + ~ + +20  + ~ + +21  + ~ + +23  + #__ed_sigt_t + + + ) + +24  + ~ + +25  + ~ + +26  + ~ + +29 + g__BEGIN_DECLS + + +33  + #PTHREAD_MUTEX_INITIALIZER + \ + +34 {0, 0, 0, +PTHREAD_MUTEX_TIMED_NP +, +__LOCK_ALT_INITIALIZER +} + + ) + +35 #ifde +__USE_GNU + + +36  + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +37 {0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, +__LOCK_ALT_INITIALIZER +} + + ) + +38  + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +39 {0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, +__LOCK_ALT_INITIALIZER +} + + ) + +40  + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +41 {0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, +__LOCK_ALT_INITIALIZER +} + + ) + +44  + #PTHREAD_COND_INITIALIZER + { +__LOCK_ALT_INITIALIZER +, 0, "", 0} + + ) + +46 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +47  + #PTHREAD_RWLOCK_INITIALIZER + \ + +48 { +__LOCK_ALT_INITIALIZER +, 0, +NULL +, NULL, NULL, \ + +49 +PTHREAD_RWLOCK_DEFAULT_NP +, +PTHREAD_PROCESS_PRIVATE + } + + ) + +51 #ifde +__USE_GNU + + +52  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +53 { +__LOCK_ALT_INITIALIZER +, 0, +NULL +, NULL, NULL, \ + +54 +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, +PTHREAD_PROCESS_PRIVATE + } + + ) + +61 + mPTHREAD_CREATE_JOINABLE +, + +62  + #PTHREAD_CREATE_JOINABLE + +PTHREAD_CREATE_JOINABLE + + + ) + +63 + mPTHREAD_CREATE_DETACHED + + +64  + #PTHREAD_CREATE_DETACHED + +PTHREAD_CREATE_DETACHED + + + ) + +69 + mPTHREAD_INHERIT_SCHED +, + +70  + #PTHREAD_INHERIT_SCHED + +PTHREAD_INHERIT_SCHED + + + ) + +71 + mPTHREAD_EXPLICIT_SCHED + + +72  + #PTHREAD_EXPLICIT_SCHED + +PTHREAD_EXPLICIT_SCHED + + + ) + +77 + mPTHREAD_SCOPE_SYSTEM +, + +78  + #PTHREAD_SCOPE_SYSTEM + +PTHREAD_SCOPE_SYSTEM + + + ) + +79 + mPTHREAD_SCOPE_PROCESS + + +80  + #PTHREAD_SCOPE_PROCESS + +PTHREAD_SCOPE_PROCESS + + + ) + +85 + mPTHREAD_MUTEX_TIMED_NP +, + +86 + mPTHREAD_MUTEX_RECURSIVE_NP +, + +87 + mPTHREAD_MUTEX_ERRORCHECK_NP +, + +88 + mPTHREAD_MUTEX_ADAPTIVE_NP + + +89 #ifde +__USE_UNIX98 + + +91 + mPTHREAD_MUTEX_NORMAL + = +PTHREAD_MUTEX_TIMED_NP +, + +92 + mPTHREAD_MUTEX_RECURSIVE + = +PTHREAD_MUTEX_RECURSIVE_NP +, + +93 + mPTHREAD_MUTEX_ERRORCHECK + = +PTHREAD_MUTEX_ERRORCHECK_NP +, + +94 + mPTHREAD_MUTEX_DEFAULT + = +PTHREAD_MUTEX_NORMAL + + +96 #ifde +__USE_GNU + + +98 , + mPTHREAD_MUTEX_FAST_NP + = +PTHREAD_MUTEX_ADAPTIVE_NP + + +104 + mPTHREAD_PROCESS_PRIVATE +, + +105  + #PTHREAD_PROCESS_PRIVATE + +PTHREAD_PROCESS_PRIVATE + + + ) + +106 + mPTHREAD_PROCESS_SHARED + + +107  + #PTHREAD_PROCESS_SHARED + +PTHREAD_PROCESS_SHARED + + + ) + +110 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +113 + mPTHREAD_RWLOCK_PREFER_READER_NP +, + +114 + mPTHREAD_RWLOCK_PREFER_WRITER_NP +, + +115 + mPTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, + +116 + mPTHREAD_RWLOCK_DEFAULT_NP + = +PTHREAD_RWLOCK_PREFER_WRITER_NP + + +120  + #PTHREAD_ONCE_INIT + 0 + + ) + +124 #ifde +__USE_XOPEN2K + + +126  + #PTHREAD_BARRIER_SERIAL_THREAD + -1 + + ) + +131  + s_had_nup_bufr + + +133 (* + m__route +) (*); + +134 * + m__g +; + +135  + m__ny +; + +136  +_had_nup_bufr + * + m__ev +; + +143 + mPTHREAD_CANCEL_ENABLE +, + +144  + #PTHREAD_CANCEL_ENABLE + +PTHREAD_CANCEL_ENABLE + + + ) + +145 + mPTHREAD_CANCEL_DISABLE + + +146  + #PTHREAD_CANCEL_DISABLE + +PTHREAD_CANCEL_DISABLE + + + ) + +150 + mPTHREAD_CANCEL_DEFERRED +, + +151  + #PTHREAD_CANCEL_DEFERRED + +PTHREAD_CANCEL_DEFERRED + + + ) + +152 + mPTHREAD_CANCEL_ASYNCHRONOUS + + +153  + #PTHREAD_CANCEL_ASYNCHRONOUS + +PTHREAD_CANCEL_ASYNCHRONOUS + + + ) + +155  + #PTHREAD_CANCELED + ((*-1) + + ) + +163  +had_ + ( +had_t + * +__ri + +__thadp +, + +164 +__cڡ + +had__t + * +__ri + +__ +, + +165 *(* +__t_route +) (*), + +166 * +__ri + +__g + +__THROW +; + +169 +had_t + + $had_lf + ( +__THROW +; + +172  + $had_equ + ( +had_t + +__thad1 +,thad_ +__thad2 + +__THROW +; + +175  + $had_ex + (* +__tv + + `__ibu__ + (( +__nܑu__ +)); + +180  + `had_jo + ( +had_t + +__th +, ** +__thad_tu +); + +186  + $had_dach + ( +had_t + +__th + +__THROW +; + +194  + $had__ + ( +had__t + * +__ + +__THROW +; + +197  + $had__deroy + ( +had__t + * +__ + +__THROW +; + +200  + $had__tdache + ( +had__t + * +__ +, + +201  +__dache + +__THROW +; + +204  + $had__gdache + ( +__cڡ + +had__t + * +__ +, + +205 * +__dache + +__THROW +; + +208  + $had__tschedm + ( +had__t + * +__ri + +__ +, + +209 +__cڡ +  +sched_m + * +__ri + + +210 +__m + +__THROW +; + +213  + $had__gschedm + ( +__cڡ + +had__t + * +__ri + + +214 +__ +, + +215  +sched_m + * +__ri + +__m +) + +216 +__THROW +; + +219  + $had__tschedpicy + ( +had__t + * +__ +,  +__picy +) + +220 +__THROW +; + +223  + $had__gschedpicy + ( +__cڡ + +had__t + * +__ri + + +224 +__ +, * +__ri + +__picy +) + +225 +__THROW +; + +228  + $had__thsched + ( +had__t + * +__ +, + +229  +__h + +__THROW +; + +232  + $had__ghsched + ( +__cڡ + +had__t + * +__ri + + +233 +__ +, * +__ri + +__h +) + +234 +__THROW +; + +237  + $had__tsce + ( +had__t + * +__ +,  +__sce +) + +238 +__THROW +; + +241  + $had__gsce + ( +__cڡ + +had__t + * +__ri + +__ +, + +242 * +__ri + +__sce + +__THROW +; + +244 #ifde +__USE_UNIX98 + + +246  + $had__tgudsize + ( +had__t + * +__ +, + +247 +size_t + +__gudsize + +__THROW +; + +250  + $had__ggudsize + ( +__cڡ + +had__t + * +__ri + + +251 +__ +, +size_t + * +__ri + +__gudsize +) + +252 +__THROW +; + +259  + $had__tackaddr + ( +had__t + * +__ +, + +260 * +__ackaddr + +__THROW +; + +263  + $had__gackaddr + ( +__cڡ + +had__t + * +__ri + + +264 +__ +, ** +__ri + +__ackaddr +) + +265 +__THROW +; + +267 #ifde +__USE_XOPEN2K + + +271  + $had__tack + ( +had__t + * +__ +, * +__ackaddr +, + +272 +size_t + +__acksize + +__THROW +; + +275  + $had__gack + ( +__cڡ + +had__t + * +__ri + +__ +, + +276 ** +__ri + +__ackaddr +, + +277 +size_t + * +__ri + +__acksize + +__THROW +; + +283  + $had__tacksize + ( +had__t + * +__ +, + +284 +size_t + +__acksize + +__THROW +; + +287  + $had__gacksize + ( +__cڡ + +had__t + * +__ri + + +288 +__ +, +size_t + * +__ri + +__acksize +) + +289 +__THROW +; + +291 #ifde +__USE_GNU + + +295  + $had_g_ + ( +had_t + +__th +, +had__t + * +__ + +__THROW +; + +302  + $had_tschedm + ( +had_t + +__rg_thad +,  +__picy +, + +303 +__cڡ +  +sched_m + * +__m +) + +304 +__THROW +; + +307  + $had_gschedm + ( +had_t + +__rg_thad +, + +308 * +__ri + +__picy +, + +309  +sched_m + * +__ri + +__m +) + +310 +__THROW +; + +312 #ifde +__USE_UNIX98 + + +314  + $had_gccucy + ( +__THROW +; + +317  + $had_tccucy + ( +__v + +__THROW +; + +320 #ifde +__USE_GNU + + +325  + $had_yld + ( +__THROW +; + +332  + $had_mux_ + ( +had_mux_t + * +__ri + +__mux +, + +333 +__cڡ + +had_mux_t + * +__ri + + +334 +__mux_ + +__THROW +; + +337  + $had_mux_deroy + ( +had_mux_t + * +__mux + +__THROW +; + +340  + $had_mux_ylock + ( +had_mux_t + * +__mux + +__THROW +; + +343  + $had_mux_lock + ( +had_mux_t + * +__mux + +__THROW +; + +345 #ifde +__USE_XOPEN2K + + +347  + $had_mux_timedlock + ( +had_mux_t + * +__ri + +__mux +, + +348 +__cڡ +  +timeec + * +__ri + + +349 +__abime + +__THROW +; + +353  + $had_mux_uock + ( +had_mux_t + * +__mux + +__THROW +; + +360  + $had_mux_ + ( +had_mux_t + * +__ + +__THROW +; + +363  + $had_mux_deroy + ( +had_mux_t + * +__ + +__THROW +; + +366  + $had_mux_gpshed + ( +__cڡ + +had_mux_t + * + +367 +__ri + +__ +, + +368 * +__ri + +__pshed + +__THROW +; + +371  + $had_mux_shed + ( +had_mux_t + * +__ +, + +372  +__pshed + +__THROW +; + +374 #ifde +__USE_UNIX98 + + +378  + $had_mux_y + ( +had_mux_t + * +__ +,  +__kd +) + +379 +__THROW +; + +382  + $had_mux_gty + ( +__cڡ + +had_mux_t + * +__ri + + +383 +__ +, * +__ri + +__kd + +__THROW +; + +391  + $had_cd_ + ( +had_cd_t + * +__ri + +__cd +, + +392 +__cڡ + +had_cd_t + * +__ri + + +393 +__cd_ + +__THROW +; + +396  + $had_cd_deroy + ( +had_cd_t + * +__cd + +__THROW +; + +399  + $had_cd_sigl + ( +had_cd_t + * +__cd + +__THROW +; + +402  + $had_cd_brd + ( +had_cd_t + * +__cd + +__THROW +; + +406  + `had_cd_wa + ( +had_cd_t + * +__ri + +__cd +, + +407 +had_mux_t + * +__ri + +__mux +); + +413  + `had_cd_timedwa + ( +had_cd_t + * +__ri + +__cd +, + +414 +had_mux_t + * +__ri + +__mux +, + +415 +__cڡ +  +timeec + * +__ri + + +416 +__abime +); + +421  + $had_cd_ + ( +had_cd_t + * +__ + +__THROW +; + +424  + $had_cd_deroy + ( +had_cd_t + * +__ + +__THROW +; + +427  + $had_cd_gpshed + ( +__cڡ + +had_cd_t + * + +428 +__ri + +__ +, + +429 * +__ri + +__pshed + +__THROW +; + +432  + $had_cd_shed + ( +had_cd_t + * +__ +, + +433  +__pshed + +__THROW +; + +436 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +441  + $had_rwlock_ + ( +had_rwlock_t + * +__ri + +__rwlock +, + +442 +__cڡ + +had_rwlock_t + * +__ri + + +443 +__ + +__THROW +; + +446  + $had_rwlock_deroy + ( +had_rwlock_t + * +__rwlock + +__THROW +; + +449  + $had_rwlock_rdlock + ( +had_rwlock_t + * +__rwlock + +__THROW +; + +452  + $had_rwlock_yrdlock + ( +had_rwlock_t + * +__rwlock + +__THROW +; + +454 #ifde +__USE_XOPEN2K + + +456  + $had_rwlock_timedrdlock + ( +had_rwlock_t + * +__ri + +__rwlock +, + +457 +__cڡ +  +timeec + * +__ri + + +458 +__abime + +__THROW +; + +462  + $had_rwlock_wock + ( +had_rwlock_t + * +__rwlock + +__THROW +; + +465  + $had_rwlock_ywock + ( +had_rwlock_t + * +__rwlock + +__THROW +; + +467 #ifde +__USE_XOPEN2K + + +469  + $had_rwlock_timedwock + ( +had_rwlock_t + * +__ri + +__rwlock +, + +470 +__cڡ +  +timeec + * +__ri + + +471 +__abime + +__THROW +; + +475  + $had_rwlock_uock + ( +had_rwlock_t + * +__rwlock + +__THROW +; + +481  + $had_rwlock_ + ( +had_rwlock_t + * +__ + +__THROW +; + +484  + $had_rwlock_deroy + ( +had_rwlock_t + * +__ + +__THROW +; + +487  + $had_rwlock_gpshed + ( +__cڡ + +had_rwlock_t + * + +488 +__ri + +__ +, + +489 * +__ri + +__pshed + +__THROW +; + +492  + $had_rwlock_shed + ( +had_rwlock_t + * +__ +, + +493  +__pshed + +__THROW +; + +496  + $had_rwlock_gkd_ + ( +__cڡ + +had_rwlock_t + * +__ +, + +497 * +__ef + +__THROW +; + +500  + $had_rwlock_tkd_ + ( +had_rwlock_t + * +__ +, + +501  +__ef + +__THROW +; + +504 #ifde +__USE_XOPEN2K + + +510  + $had__ + ( +had_lock_t + * +__lock +,  +__pshed +) + +511 +__THROW +; + +514  + $had__deroy + ( +had_lock_t + * +__lock + +__THROW +; + +517  + $had__lock + ( +had_lock_t + * +__lock + +__THROW +; + +520  + $had__ylock + ( +had_lock_t + * +__lock + +__THROW +; + +523  + $had__uock + ( +had_lock_t + * +__lock + +__THROW +; + +528  + $had_brr_ + ( +had_brr_t + * +__ri + +__brr +, + +529 +__cڡ + +had_brr_t + * +__ri + + +530 +__ +,  +__cou + +__THROW +; + +532  + $had_brr_deroy + ( +had_brr_t + * +__brr + +__THROW +; + +534  + $had_brr_ + ( +had_brr_t + * +__ + +__THROW +; + +536  + $had_brr_deroy + ( +had_brr_t + * +__ + +__THROW +; + +538  + $had_brr_gpshed + ( +__cڡ + +had_brr_t + * + +539 +__ri + +__ +, + +540 * +__ri + +__pshed + +__THROW +; + +542  + $had_brr_shed + ( +had_brr_t + * +__ +, + +543  +__pshed + +__THROW +; + +545  + $had_brr_wa + ( +had_brr_t + * +__brr + +__THROW +; + +557  + `had_key_ + ( +had_key_t + * +__key +, + +558 (* +__der_funi +(*) +__THROW +; + +561  + $had_key_de + ( +had_key_t + +__key + +__THROW +; + +564  + $had_tecific + ( +had_key_t + +__key +, + +565 +__cڡ + * +__por + +__THROW +; + +568 * + $had_gecific + ( +had_key_t + +__key + +__THROW +; + +580  + `had_ + ( +had__t + * +___cڌ +, + +581 (* +___route +) ()); + +588  + `had_tnle + ( +__e +, * +__de +); + +592  + `had_tny + ( +__ty +, * +__dty +); + +595  + `had_nl + ( +had_t + +__nhad +); + +600  + `had_nl + (); + +610  + #had_nup_push +( +route +, +g +) \ + +611 {  +_had_nup_bufr + +_bufr +; \ + +612 + `_had_nup_push + (& +_bufr +, ( +route +), ( +g +)); + + ) + +614  + `_had_nup_push + ( +_had_nup_bufr + * +__bufr +, + +615 (* +__route +) (*), + +616 * +__g + +__THROW +; + +621  + #had_nup_p +( +execu +) \ + +622 + `_had_nup_p + (& +_bufr +, ( +execu +)); + } + + ) +} + +624  + $_had_nup_p + ( +_had_nup_bufr + * +__bufr +, + +625  +__execu + +__THROW +; + +630 #ifde +__USE_GNU + + +631  + #had_nup_push_der_ +( +route +, +g +) \ + +632 {  +_had_nup_bufr + +_bufr +; \ + +633 + `_had_nup_push_der + (& +_bufr +, ( +route +), ( +g +)); + + ) + +635  + `_had_nup_push_der + ( +_had_nup_bufr + * +__bufr +, + +636 (* +__route +) (*), + +637 * +__g + +__THROW +; + +643  + #had_nup_p_e_ +( +execu +) \ + +644 + `_had_nup_p_e + (& +_bufr +, ( +execu +)); + } + + ) +} + +646  + $_had_nup_p_e + ( +_had_nup_bufr + * +__bufr +, + +647  +__execu + +__THROW +; + +651 #ifde +__USE_XOPEN2K + + +653  + $had_guockid + ( +had_t + +__thad_id +, + +654 +__ockid_t + * +__ock_id + +__THROW +; + +659  + ~ + +675  + `had_fk + ((* +__e +) (), + +676 (* +__ +) (), + +677 (* +__chd +() +__THROW +; + +682  + $had_kl_h_thads_ + ( +__THROW +; + +684 +__END_DECLS + + + @/usr/include/wctype.h + +24 #ide +_WCTYPE_H + + +26  + ~ + +27  + ~ + +29 #ide +__ed_iswxxx + + +30  + #_WCTYPE_H + 1 + + ) + +34  + #__ed_wt_t + + + ) + +35  + ~ + +36 #ide +_WINT_T + + +41  + #_WINT_T + + + ) + +42  + twt_t +; + +44 #ifde +__USE_ISOC99 + + +45 + $__USING_NAMESPACE_C99 +( +wt_t +) + +47 +__END_NAMESPACE_C99 + + +52 #ide +WEOF + + +53  + #WEOF + (0xffffffffu) + + ) + +56 #unde +__ed_iswxxx + + +61 #ide +__iswxxx_defed + + +62  + #__iswxxx_defed + 1 + + ) + +64 +__BEGIN_NAMESPACE_C99 + + +67  + twy_t +; + +68 +__END_NAMESPACE_C99 + + +70 #ide +_ISwb + + +75  + ~ + +76 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +77  + #_ISwb +( +b +(1 << (b)) + + ) + +79  + #_ISwb +( +b +) \ + +80 (( +b +) < 8 ? () ((1UL << (bit)) << 24) \ + +81 : (( +b +) < 16 ? () ((1UL << (bit)) << 8) \ + +82 : (( +b +) < 24 ? () ((1UL << (bit)) >> 8) \ + +83 : (((1UL << ( +b +)>> 24)))) + + ) + +88 +__ISwu + = 0, + +89 +__ISwlow + = 1, + +90 +__ISwpha + = 2, + +91 +__ISwdig + = 3, + +92 +__ISwxdig + = 4, + +93 +__ISwa + = 5, + +94 +__ISwt + = 6, + +95 +__ISwgph + = 7, + +96 +__ISwbnk + = 8, + +97 +__ISwl + = 9, + +98 +__ISwpun + = 10, + +99 +__ISwnum + = 11, + +101 +_ISwu + = + `_ISwb + ( +__ISwu +), + +102 +_ISwlow + = + `_ISwb + ( +__ISwlow +), + +103 +_ISwpha + = + `_ISwb + ( +__ISwpha +), + +104 +_ISwdig + = + `_ISwb + ( +__ISwdig +), + +105 +_ISwxdig + = + `_ISwb + ( +__ISwxdig +), + +106 +_ISwa + = + `_ISwb + ( +__ISwa +), + +107 +_ISwt + = + `_ISwb + ( +__ISwt +), + +108 +_ISwgph + = + `_ISwb + ( +__ISwgph +), + +109 +_ISwbnk + = + `_ISwb + ( +__ISwbnk +), + +110 +_ISwl + = + `_ISwb + ( +__ISwl +), + +111 +_ISwpun + = + `_ISwb + ( +__ISwpun +), + +112 +_ISwnum + = + `_ISwb + ( +__ISwnum +) + +117 +__BEGIN_DECLS + + +119 +__BEGIN_NAMESPACE_C99 + + +126  + $iswnum + ( +wt_t + +__wc + +__THROW +; + +132  + $iswpha + ( +wt_t + +__wc + +__THROW +; + +135  + $iswl + ( +wt_t + +__wc + +__THROW +; + +139  + $iswdig + ( +wt_t + +__wc + +__THROW +; + +143  + $iswgph + ( +wt_t + +__wc + +__THROW +; + +148  + $iswlow + ( +wt_t + +__wc + +__THROW +; + +151  + $iswt + ( +wt_t + +__wc + +__THROW +; + +156  + $iswpun + ( +wt_t + +__wc + +__THROW +; + +161  + $iswa + ( +wt_t + +__wc + +__THROW +; + +166  + $iswu + ( +wt_t + +__wc + +__THROW +; + +171  + $iswxdig + ( +wt_t + +__wc + +__THROW +; + +176 #ifde +__USE_ISOC99 + + +177  + $iswbnk + ( +wt_t + +__wc + +__THROW +; + +186 +wy_t + + $wy + ( +__cڡ + * +__ݔty + +__THROW +; + +190  + $iswy + ( +wt_t + +__wc +, +wy_t + +__desc + +__THROW +; + +191 +__END_NAMESPACE_C99 + + +198 +__BEGIN_NAMESPACE_C99 + + +201  +__cڡ + + t__t32_t + * + twns_t +; + +202 +__END_NAMESPACE_C99 + + +203 #ifde +__USE_GNU + + +204 + $__USING_NAMESPACE_C99 +( +wns_t +) + +207 +__BEGIN_NAMESPACE_C99 + + +209 +wt_t + + $towlow + ( +wt_t + +__wc + +__THROW +; + +212 +wt_t + + $towu + ( +wt_t + +__wc + +__THROW +; + +213 +__END_NAMESPACE_C99 + + +215 +__END_DECLS + + +222 #ifde +_WCTYPE_H + + +228 +__BEGIN_DECLS + + +230 +__BEGIN_NAMESPACE_C99 + + +233 +wns_t + + $wns + ( +__cڡ + * +__ݔty + +__THROW +; + +236 +wt_t + + $towns + ( +wt_t + +__wc +, +wns_t + +__desc + +__THROW +; + +237 +__END_NAMESPACE_C99 + + +239 #ifde +__USE_GNU + + +241  + ~ + +245  + $iswnum_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +251  + $iswpha_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +254  + $iswl_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +258  + $iswdig_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +262  + $iswgph_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +267  + $iswlow_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +270  + $iswt_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +275  + $iswpun_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +280  + $iswa_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +285  + $iswu_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +290  + $iswxdig_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +295  + $iswbnk_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +299 +wy_t + + $wy_l + ( +__cڡ + * +__ݔty +, +__lo_t + +__lo +) + +300 +__THROW +; + +304  + $iswy_l + ( +wt_t + +__wc +, +wy_t + +__desc +, +__lo_t + +__lo +) + +305 +__THROW +; + +313 +wt_t + + $towlow_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +316 +wt_t + + $towu_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +320 +wns_t + + $wns_l + ( +__cڡ + * +__ݔty +, +__lo_t + +__lo +) + +321 +__THROW +; + +324 +wt_t + + $towns_l + ( +wt_t + +__wc +, +wns_t + +__desc +, + +325 +__lo_t + +__lo + +__THROW +; + +329 +__END_DECLS + + + @/usr/include/asm-i386/sigcontext.h + +1 #ide +_ASMi386_SIGCONTEXT_H + + +2  + #_ASMi386_SIGCONTEXT_H + + + ) + +19  + s_g + { + +20  + msignifind +[4]; + +21  + mexpڒt +; + +24  + s_xg + { + +25  + msignifind +[4]; + +26  + mexpڒt +; + +27  + mddg +[3]; + +30  + s_xmmg + { + +31  + memt +[4]; + +34  + s_塩e + { + +36  + mcw +; + +37  + msw +; + +38  + mg +; + +39  + moff +; + +40  + mcsl +; + +41  + mdaoff +; + +42  + mdal +; + +43  +_g + + m_ +[8]; + +44  + mus +; + +45  + mmagic +; + +48  + m_fx_v +[6]; + +49  + mmxc +; + +50  + mrved +; + +51  +_xg + + m_fx_ +[8]; + +52  +_xmmg + + m_xmm +[8]; + +53  + mddg +[56]; + +56  + #X86_FXSR_MAGIC + 0x0000 + + ) + +58  + ssigcڋxt + { + +59  + mgs +, + m__gsh +; + +60  + mfs +, + m__fsh +; + +61  + mes +, + m__esh +; + +62  + mds +, + m__dsh +; + +63  + medi +; + +64  + mesi +; + +65  + mebp +; + +66  + me +; + +67  + mebx +; + +68  + medx +; + +69  + mecx +; + +70  + mx +; + +71  + mno +; + +72  + mr +; + +73  + me +; + +74  + mcs +, + m__csh +; + +75  + meags +; + +76  + me__sigl +; + +77  + mss +, + m__ssh +; + +78  +_塩e + * + m塩e +; + +79  + mdmask +; + +80  + m2 +; + + @/usr/include/asm-x86_64/sigcontext.h + +1 #ide +_ASM_X86_64_SIGCONTEXT_H + + +2  + #_ASM_X86_64_SIGCONTEXT_H + + + ) + +4  + ~ + +6 #ide +_BITS_SIGCONTEXT_H + + +11  + s_塩e + { + +12 +__u16 + + mcwd +; + +13 +__u16 + + mswd +; + +14 +__u16 + + mtwd +; + +15 +__u16 + + mf +; + +16 +__u64 + + mr +; + +17 +__u64 + + mrdp +; + +18 +__u32 + + mmxc +; + +19 +__u32 + + mmxc_mask +; + +20 +__u32 + + m_a +[32]; + +21 +__u32 + + mxmm_a +[64]; + +22 +__u32 + + mrved2 +[24]; + +25  + ssigcڋxt + { + +26  + mr8 +; + +27  + mr9 +; + +28  + mr10 +; + +29  + mr11 +; + +30  + mr12 +; + +31  + mr13 +; + +32  + mr14 +; + +33  + mr15 +; + +34  + mrdi +; + +35  + mrsi +; + +36  + mrbp +; + +37  + mrbx +; + +38  + mrdx +; + +39  + mx +; + +40  + mrcx +; + +41  + mr +; + +42  + mr +; + +43  + meags +; + +44  + mcs +; + +45  + mgs +; + +46  + mfs +; + +47  + m__d0 +; + +48  + mr +; + +49  + mno +; + +50  + mdmask +; + +51  + m2 +; + +52  +_塩e + * + m塩e +; + +53  + mrved1 +[8]; + + @/usr/include/bits/byteswap.h + +20 #i! +defed + +_BYTESWAP_H + && !defed +_NETINET_IN_H + + +24 #ide +_BITS_BYTESWAP_H + + +25  + #_BITS_BYTESWAP_H + 1 + + ) + +28  + #__bsw_cڡt_16 +( +x +) \ + +29 (((( +x +>> 8& 0xff| (((x& 0xff<< 8)) + + ) + +31 #ifde +__GNUC__ + + +32 #i +__GNUC__ + >= 2 + +33  + #__bsw_16 +( +x +) \ + +34 ( +__exnsi__ + \ + +35 ({  +__v +, +__x + = ( +x +); \ + +36 i( + `__but_cڡt_p + ( +__x +)) \ + +37 +__v + = + `__bsw_cڡt_16 + ( +__x +); \ + +39 + `__asm__ + ("rorw $8, %w0" \ + +40 : "" ( +__v +) \ + +41 : "0" ( +__x +) \ + +43 +__v +; })) + + ) + +46  + #__bsw_16 +( +x +) \ + +47 ( +__exnsi__ + \ + +48 ({  +__x + = ( +x +); + `__bsw_cڡt_16 + (__x); })) + + ) + +51  +__le +  + +52 + $__bsw_16 + ( +__bsx +) + +54  + `__bsw_cڡt_16 + ( +__bsx +); + +55 + } +} + +59  + #__bsw_cڡt_32 +( +x +) \ + +60 (((( +x +) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + +61 ((( +x +& 0x0000ff00<< 8| (((x& 0x000000ff<< 24)) + + ) + +63 #ifde +__GNUC__ + + +64 #i +__GNUC__ + >= 2 + +67 #i! +defed + +__i486__ + && !defed +__ium__ + && !defed +__iumo__ + \ + +68 && ! +defed + + g__ium4__ + + +69  + #__bsw_32 +( +x +) \ + +70 ( +__exnsi__ + \ + +71 ({  +__v +, +__x + = ( +x +); \ + +72 i( + `__but_cڡt_p + ( +__x +)) \ + +73 +__v + = + `__bsw_cڡt_32 + ( +__x +); \ + +75 + `__asm__ + ("rorw $8, %w0;" \ + +78 : "" ( +__v +) \ + +79 : "0" ( +__x +) \ + +81 +__v +; })) + + ) + +83  + #__bsw_32 +( +x +) \ + +84 ( +__exnsi__ + \ + +85 ({  +__v +, +__x + = ( +x +); \ + +86 i( + `__but_cڡt_p + ( +__x +)) \ + +87 +__v + = + `__bsw_cڡt_32 + ( +__x +); \ + +89 + `__asm__ + ("bsw %0" : "" ( +__v +: "0" ( +__x +)); \ + +90 +__v +; })) + + ) + +93  + #__bsw_32 +( +x +) \ + +94 ( +__exnsi__ + \ + +95 ({  +__x + = ( +x +); + `__bsw_cڡt_32 + (__x); })) + + ) + +98  +__le +  + +99 + $__bsw_32 + ( +__bsx +) + +101  + `__bsw_cڡt_32 + ( +__bsx +); + +102 + } +} + +106 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +108  + #__bsw_cڡt_64 +( +x +) \ + +109 (((( +x +) & 0xff00000000000000ull) >> 56) \ + +110 | ((( +x +) & 0x00ff000000000000ull) >> 40) \ + +111 | ((( +x +) & 0x0000ff0000000000ull) >> 24) \ + +112 | ((( +x +) & 0x000000ff00000000ull) >> 8) \ + +113 | ((( +x +) & 0x00000000ff000000ull) << 8) \ + +114 | ((( +x +) & 0x0000000000ff0000ull) << 24) \ + +115 | ((( +x +) & 0x000000000000ff00ull) << 40) \ + +116 | ((( +x +& 0x00000000000000ffu<< 56)) + + ) + +118  + #__bsw_64 +( +x +) \ + +119 ( +__exnsi__ + \ + +120 ({ uni { +__exnsi__ +  +__ +; \ + +121  +__l +[2]; } +__w +, +__r +; \ + +122 i( + `__but_cڡt_p + ( +x +)) \ + +123 +__r +. +__ + = + `__bsw_cڡt_64 + ( +x +); \ + +126 +__w +. +__ + = ( +x +); \ + +127 +__r +. +__l +[0] = + `__bsw_32 + ( +__w +.__l[1]); \ + +128 +__r +. +__l +[1] = + `__bsw_32 + ( +__w +.__l[0]); \ + +130 +__r +. +__ +; })) + + ) + + @/usr/include/bits/initspin.h + +23  + #__LT_SPINLOCK_INIT + 0 + + ) + +26  + #__LOCK_INITIALIZER + (( +_had_lock +){ 0, +__LT_SPINLOCK_INIT + }) + + ) + +27  + #__LOCK_ALT_INITIALIZER + { 0, +__LT_SPINLOCK_INIT + } + + ) + +28  + #__ALT_LOCK_INITIALIZER + { 0, +__LT_SPINLOCK_INIT + } + + ) + +29  + #__ATOMIC_INITIALIZER + { 0, +__LT_SPINLOCK_INIT + } + + ) + + @/usr/include/sched.h + +20 #idef +_SCHED_H + + +21  + #_SCHED_H + 1 + + ) + +23  + ~ + +26  + ~ + +28  + #__ed_timeec + + + ) + +29  + ~ + +32  + ~ + +34  + #sched_iܙy + +__sched_iܙy + + + ) + +37 +__BEGIN_DECLS + + +40  + $sched_am + ( +__pid_t + +__pid +, +__cڡ +  +sched_m + * +__m +) + +41 +__THROW +; + +44  + $sched_gm + ( +__pid_t + +__pid +,  +sched_m + * +__m + +__THROW +; + +47  + $sched_tschedur + ( +__pid_t + +__pid +,  +__picy +, + +48 +__cڡ +  +sched_m + * +__m + +__THROW +; + +51  + $sched_gschedur + ( +__pid_t + +__pid + +__THROW +; + +54  + $sched_yld + ( +__THROW +; + +57  + $sched_g_iܙy_max + ( +__gܙhm + +__THROW +; + +60  + $sched_g_iܙy_m + ( +__gܙhm + +__THROW +; + +63  + $sched__g_rv + ( +__pid_t + +__pid +,  +timeec + * +__t + +__THROW +; + +66 #ifde +__USE_GNU + + +68  + #CPU_SETSIZE + +__CPU_SETSIZE + + + ) + +69  + #CPU_SET +( +u +, +u + + `__CPU_SET + (u, cpu) + + ) + +70  + #CPU_CLR +( +u +, +u + + `__CPU_CLR + (u, cpu) + + ) + +71  + #CPU_ISSET +( +u +, +u + + `__CPU_ISSET + (u, cpu) + + ) + +72  + #CPU_ZERO +( +u + + `__CPU_ZERO + (u) + + ) + +76  + $sched_ffy + ( +__pid_t + +__pid +, +size_t + +__utsize +, + +77 +__cڡ + +u_t_t + * +__ut + +__THROW +; + +80  + $sched_gaffy + ( +__pid_t + +__pid +, +size_t + +__utsize +, + +81 +u_t_t + * +__ut + +__THROW +; + +84 +__END_DECLS + + + @ +1 +. +1 +/usr/include +211 +4897 +alloc.c +alternate.c +bootparams.c +chooser.c +chooser.h +choosers/simple.c +choosers/simple.h +choosers/textmenu.c +choosers/textmenu.h +config.c +config.h +devschemes/simple.c +elf.h +elilo.c +elilo.h +elilo_debug.h +fileops.c +fileops.h +fs/ext2_fs.h +fs/ext2_fs_i.h +fs/ext2_fs_sb.h +fs/ext2_private.h +fs/ext2fs.c +fs/ext2fs.h +fs/fs.h +fs/localfs.c +fs/localfs.h +fs/netfs.c +fs/netfs.h +getopt.c +getopt.h +glue_ext2fs.c +glue_ext2fs.h +glue_localfs.c +glue_localfs.h +glue_netfs.c +glue_netfs.h +gunzip.c +gzip.h +ia32/bin_to_h.c +ia32/bzimage.c +ia32/config.c +ia32/gzip.c +ia32/gzip_loader.c +ia32/plain_loader.c +ia32/private.h +ia32/sysdeps.h +ia32/system.c +ia64/config.c +ia64/fpswa.c +ia64/gzip.c +ia64/gzip_loader.c +ia64/plain_loader.c +ia64/private.h +ia64/setjmp.h +ia64/sysdeps.h +ia64/system.c +inflate.c +initrd.c +loader.c +loader.h +strops.c +strops.h +sysdeps.h +tools/eliloalt.c +util.c +vars.c +vars.h +/usr/include/asm/atomic.h +/usr/include/asm/bitops.h +/usr/include/asm/byteorder.h +/usr/include/asm/semaphore.h +/usr/include/dirent.h +/usr/include/errno.h +/usr/include/fcntl.h +/usr/include/linux/adfs_fs_sb.h +/usr/include/linux/cache.h +/usr/include/linux/config.h +/usr/include/linux/efs_fs_i.h +/usr/include/linux/efs_fs_sb.h +/usr/include/linux/fcntl.h +/usr/include/linux/ioctl.h +/usr/include/linux/iso_fs_i.h +/usr/include/linux/iso_fs_sb.h +/usr/include/linux/kdev_t.h +/usr/include/linux/limits.h +/usr/include/linux/linkage.h +/usr/include/linux/list.h +/usr/include/linux/mount.h +/usr/include/linux/net.h +/usr/include/linux/nfs_fs_i.h +/usr/include/linux/nfs_fs_sb.h +/usr/include/linux/pipe_fs_i.h +/usr/include/linux/quota.h +/usr/include/linux/stat.h +/usr/include/linux/stddef.h +/usr/include/linux/types.h +/usr/include/linux/udf_fs_i.h +/usr/include/linux/udf_fs_sb.h +/usr/include/linux/wait.h +/usr/include/setjmp.h +/usr/include/stdint.h +/usr/include/stdio.h +/usr/include/stdlib.h +/usr/include/string.h +/usr/include/sys/types.h +/usr/include/unistd.h +/usr/include/alloca.h +/usr/include/asm-i386/atomic.h +/usr/include/asm-i386/bitops.h +/usr/include/asm-i386/byteorder.h +/usr/include/asm-i386/semaphore.h +/usr/include/asm-x86_64/atomic.h +/usr/include/asm-x86_64/bitops.h +/usr/include/asm-x86_64/byteorder.h +/usr/include/asm-x86_64/semaphore.h +/usr/include/asm/cache.h +/usr/include/asm/fcntl.h +/usr/include/asm/ioctl.h +/usr/include/asm/linkage.h +/usr/include/asm/types.h +/usr/include/bits/confname.h +/usr/include/bits/dirent.h +/usr/include/bits/environments.h +/usr/include/bits/errno.h +/usr/include/bits/fcntl.h +/usr/include/bits/posix1_lim.h +/usr/include/bits/posix_opt.h +/usr/include/bits/pthreadtypes.h +/usr/include/bits/setjmp.h +/usr/include/bits/sigset.h +/usr/include/bits/stdio.h +/usr/include/bits/stdio2.h +/usr/include/bits/stdio_lim.h +/usr/include/bits/string.h +/usr/include/bits/string2.h +/usr/include/bits/string3.h +/usr/include/bits/sys_errlist.h +/usr/include/bits/types.h +/usr/include/bits/waitflags.h +/usr/include/bits/waitstatus.h +/usr/include/bits/wchar.h +/usr/include/bits/wordsize.h +/usr/include/endian.h +/usr/include/features.h +/usr/include/libio.h +/usr/include/linux/backing-dev.h +/usr/include/linux/err_kernel_only.h +/usr/include/linux/errno.h +/usr/include/linux/fs.h +/usr/include/linux/kernel.h +/usr/include/linux/nfs.h +/usr/include/linux/posix_types.h +/usr/include/sys/select.h +/usr/include/sys/stat.h +/usr/include/sys/sysmacros.h +/usr/include/sys/wait.h +/usr/include/time.h +/usr/include/xlocale.h +/usr/include/_G_config.h +/usr/include/asm-i386/cache.h +/usr/include/asm-i386/fcntl.h +/usr/include/asm-i386/ioctl.h +/usr/include/asm-i386/linkage.h +/usr/include/asm-i386/types.h +/usr/include/asm-x86_64/cache.h +/usr/include/asm-x86_64/fcntl.h +/usr/include/asm-x86_64/ioctl.h +/usr/include/asm-x86_64/linkage.h +/usr/include/asm-x86_64/types.h +/usr/include/asm/errno.h +/usr/include/asm/posix_types.h +/usr/include/bits/endian.h +/usr/include/bits/local_lim.h +/usr/include/bits/sched.h +/usr/include/bits/select.h +/usr/include/bits/siginfo.h +/usr/include/bits/stat.h +/usr/include/bits/stdio-lock.h +/usr/include/bits/time.h +/usr/include/bits/typesizes.h +/usr/include/gnu/stubs.h +/usr/include/linux/byteorder/little_endian.h +/usr/include/signal.h +/usr/include/sys/cdefs.h +/usr/include/sys/resource.h +/usr/include/asm-i386/errno.h +/usr/include/asm-i386/posix_types.h +/usr/include/asm-x86_64/errno.h +/usr/include/asm-x86_64/posix_types.h +/usr/include/bits/libc-lock.h +/usr/include/bits/resource.h +/usr/include/bits/sigaction.h +/usr/include/bits/sigcontext.h +/usr/include/bits/signum.h +/usr/include/bits/sigstack.h +/usr/include/bits/sigthread.h +/usr/include/gconv.h +/usr/include/linux/byteorder/generic.h +/usr/include/linux/byteorder/swab.h +/usr/include/sys/ucontext.h +/usr/include/wchar.h +/usr/include/asm/sigcontext.h +/usr/include/byteswap.h +/usr/include/pthread.h +/usr/include/wctype.h +/usr/include/asm-i386/sigcontext.h +/usr/include/asm-x86_64/sigcontext.h +/usr/include/bits/byteswap.h +/usr/include/bits/initspin.h +/usr/include/sched.h diff --git a/docs/elilo.txt b/docs/elilo.txt index fdc1131..3de7501 100644 --- a/docs/elilo.txt +++ b/docs/elilo.txt @@ -1,18 +1,20 @@ -------------------------------------------------------------------- - ELILO.EFI: Linux boot loader for EFI/IA-64 and EFI/IA-32 based systems + ELILO.EFI: Linux boot loader for + EFI/IA-64,EFI/IA-32 and EFI/x86_64 based systems -------------------------------------------------------------------- Stephane Eranian August 2003 Copyright (C) 2000-2003 Hewlett-Packard Co. + Copyright (C) 2006-2010 Intel Co. I/ Introduction ------------ -This document describes how to use ELILO on for both IA-64 and IA-32 EFI-based platforms. -This document describes ELILO version 3.4. +This document describes how to use ELILO on for IA-64, IA-32 and x86_64 EFI-based platforms. +This document describes ELILO version 3.7. II/ Command line options -------------------- @@ -81,6 +83,9 @@ II/ Command line options for more information on device naming schemes. The slash character '/' can be used as a directory separator on any file systems including the EFI file system (FAT32). + For x86_64: + ---------- + No new options. III/ Configuration File ------------------ @@ -94,7 +99,7 @@ III/ Configuration File where AABBCCDD is the hexadecimal representation of the IP address assigned during the DHCP phase. - 2/ elilo-ia64.conf or elilo-ia32.conf + 2/ elilo-ia64.conf or elilo-ia32.conf or elilo-x86_64.conf The choice depends on the client platform. This step allows the same DHCP/PXE server to provide files for both types of clients. @@ -236,6 +241,9 @@ III/ Configuration File the user can also specify a kernel file that is not specified in the config file. In any case, some of the global options (such as append) are always concatenated to whatever the user type. + x86_64 specific options: + ----------------------- + None yet. IV/ Booting from the local system ----------------------------- @@ -447,6 +455,29 @@ XII/ Booting on EFI/ia32 platforms be booted (plain vmlinux will not work). Similarly, existing initial ramdisks can be used without modifications. +XIII/ Booting on EFI/x86_64 platforms + ----------------------------- + + To use elilo on x86_64, you can put it on a floppy and + on a FAT32 partition (msdos partition). You can also + netboot if your network adapter has support for UNDI/PXE. + + Elilo/x86_64 requires efi64 enabled linux kernel (> 2.6.21). + You need to compile the kernel with CONFIG_EFI option. + x86_64 platforms with UEFI 2.0 firmware deprecate UGA protocol + and therefore only the Graphics Output Protocol (GOP) is supported. For + such platforms, the kernel must be configured with EFI_FB option. This + will enable early boot messages on the console. The elilo for x86_64 + attempts to query the firmware for GOP and if it fails it defaults to + text mode. Elilo ONLY takes compressed kernel image which are + typically obtained via a 'make bzImage'. Plain elf/x86_64 kernel can't + be booted (plain vmlinux will not work). Similarly, existing initial + ramdisks can be used without modifications. + + The x86_64 implementation converts the EFI memory map into E820 map and + passes it in the bootparameter supplied to the OS. For details on + bootparameter, see x86_64/sysdeps.h. + IX/ Credits ------- @@ -457,6 +488,9 @@ IX/ Credits Richard Hirst Chris Ahna Mike Johnston + Fenghua Yu + Bibo Mao + Chandramouli Narayanan X/ Bug reports ----------- @@ -468,6 +502,10 @@ X/ Bug reports XIII/ Reference --------- + UEFI 2.0 specifications are available from the following web site: + + http://www.uefi.org/home + EFI v1.02 specifications are available from the following web site: http://developer.intel.com/technology/efi/ diff --git a/elf.h b/elf.h index ad367f5..8289e0d 100644 --- a/elf.h +++ b/elf.h @@ -103,6 +103,7 @@ typedef UINT64 Elf64_Word; #define EM_IA_64 50 /* HP/Intel IA-64 */ +#define EM_X86_64 62 /* Intel/AMD x86-64 */ /* * This is an interim value that we will use until the committee comes * up with a final number. diff --git a/elilo-ia32.efi b/elilo-ia32.efi index e3b1fd6..7bc2175 100644 Binary files a/elilo-ia32.efi and b/elilo-ia32.efi differ diff --git a/elilo-ia64.efi b/elilo-ia64.efi index 3880d59..399b0e2 100644 Binary files a/elilo-ia64.efi and b/elilo-ia64.efi differ diff --git a/elilo-x86_64.efi b/elilo-x86_64.efi new file mode 100644 index 0000000..a7cc11c Binary files /dev/null and b/elilo-x86_64.efi differ diff --git a/elilo.c b/elilo.c index 6bdd6bd..2773f3f 100644 --- a/elilo.c +++ b/elilo.c @@ -1,5 +1,5 @@ /* - * elilo.c - IA-64/IA-32 EFI Linux loader + * elilo.c - IA-64/IA-32/x86_64 EFI Linux loader * * Copyright (C) 1999-2003 Hewlett-Packard Co. * Contributed by David Mosberger . @@ -8,6 +8,11 @@ * Copyright (C) 1999-2000 VA Linux Systems * Contributed by Johannes Erdfelt . * + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * * This file is part of the ELILO, the EFI Linux boot loader. * * ELILO is free software; you can redistribute it and/or modify @@ -41,7 +46,7 @@ #include "loader.h" #include "config.h" /* for config_init() */ -#define ELILO_VERSION L"3.4" +#define ELILO_VERSION L"3.7" #define ELILO_SHARED_CMDLINE_OPTS L"pPMC:aDhd:i:vVc:E" elilo_config_t elilo_opt; @@ -244,7 +249,7 @@ do_launch: if ((bp=create_boot_params(cmdline, &imem, &mmem, &cookie)) == 0) goto error; /* terminate bootservices */ - status = BS->ExitBootServices(image, cookie); + status = uefi_call_wrapper(BS->ExitBootServices, 2, image, cookie); if (EFI_ERROR(status)) goto bad_exit; start_kernel(kd.kentry, bp); @@ -307,7 +312,7 @@ fixupargs(EFI_LOADED_IMAGE *info) #define FAKE_ELILONAME L"elilo-forced" - status = BS->HandleProtocol (info->DeviceHandle, &PxeBaseCodeProtocol, (VOID **)&pxe); + status = uefi_call_wrapper(BS->HandleProtocol, 3, info->DeviceHandle, &PxeBaseCodeProtocol, (VOID **)&pxe); if (EFI_ERROR(status)) return; default_load_options = info->LoadOptions; @@ -365,7 +370,7 @@ check_edd30(VOID) UINT8 bool = FALSE; INTN ret = -1; - status = RT->GetVariable(L"EDD30", &edd30_guid, NULL, &l, &bool); + status = uefi_call_wrapper(RT->GetVariable, 5, L"EDD30", &edd30_guid, NULL, &l, &bool); if (status == EFI_BUFFER_TOO_SMALL || (bool != TRUE && bool != FALSE)) { ERR_PRT((L"Warning: EDD30 EFI variable is not boolean value: forcing it to TRUE")); return -1; @@ -395,7 +400,7 @@ force_edd30(VOID) UINT8 bool; bool = TRUE; - status = RT->SetVariable(L"EDD30", &edd30_guid, EDD30_ATTR, l, &bool); + status = uefi_call_wrapper(RT->SetVariable, 5, L"EDD30", &edd30_guid, EDD30_ATTR, l, &bool); if (EFI_ERROR(status)) { ERR_PRT((L"can't set EDD30 variable: ignoring it")); return -1; @@ -439,19 +444,18 @@ efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *system_tab) * mode. * XXX: clean this up ! */ - BS->SetWatchdogTimer(0, 0x0, 0, NULL); + uefi_call_wrapper(BS->SetWatchdogTimer, 4, 0, 0x0, 0, NULL); /* initialize memory allocator */ if (alloc_init() == -1) return EFI_LOAD_ERROR; - status = BS->HandleProtocol(image, &LoadedImageProtocol, (VOID **) &info); + status = uefi_call_wrapper(BS->HandleProtocol, 3, image, &LoadedImageProtocol, (VOID **) &info); if (EFI_ERROR(status)) { ERR_PRT((L"image handle does not support LOADED_IMAGE protocol")); return EFI_LOAD_ERROR; } VERB_PRT(5,Print(L"Loaded at 0x%lx size=%d bytes code=%d data=%d\n", info->ImageBase, info->ImageSize, info->ImageCodeType, info->ImageDataType)); - /* * verify EDD3.0 status. Users may have to reboot */ diff --git a/fileops.c b/fileops.c index 85f3485..1a43479 100644 --- a/fileops.c +++ b/fileops.c @@ -1,6 +1,9 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -135,7 +138,7 @@ glue_filesystem(EFI_GUID *proto, EFI_HANDLE dev, fops_fs_glue_t glue) VOID *intf = NULL; EFI_STATUS status; - status = BS->HandleProtocol(dev, proto, &intf); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, proto, &intf); if (EFI_ERROR(status)) { ERR_PRT((L"unable to locate %g: should not happen", proto)); return NULL; /* should not happen */ @@ -358,6 +361,8 @@ fops_setdefaults(struct config_file *defconf, CHAR16 *kname, UINTN maxlen, CHAR1 #define FILEOPS_ARCH_DEFAULT_CONFIG L"elilo-ia64.conf" #elif defined (CONFIG_ia32) #define FILEOPS_ARCH_DEFAULT_CONFIG L"elilo-ia32.conf" +#elif defined (CONFIG_x86_64) +#define FILEOPS_ARCH_DEFAULT_CONFIG L"elilo-x86_64.conf" #else #error "You need to specfy your default arch config file" #endif @@ -455,7 +460,7 @@ add_dev_tab(EFI_GUID *proto, EFI_HANDLE boot_handle, UINTN size, fops_fs_glue_t /* * get the actual device handles now */ - status = BS->LocateHandle(ByProtocol, proto, NULL, &size, tab); + status = uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, proto, NULL, &size, tab); if (status != EFI_SUCCESS) { ERR_PRT((L"failed to get handles for proto %g size=%d: %r", proto, size, status)); free(tab); @@ -536,7 +541,7 @@ find_filesystems(EFI_HANDLE boot_handle) */ for(fs = fs_tab; *fs; fs++) { size = 0; - BS->LocateHandle(ByProtocol, &(*fs)->proto, NULL, &size, NULL); + uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &(*fs)->proto, NULL, &size, NULL); total += size; } if (total == 0) { @@ -560,7 +565,7 @@ find_filesystems(EFI_HANDLE boot_handle) for(fs = fs_tab; *fs; fs++) { size = 0; - BS->LocateHandle(ByProtocol, &(*fs)->proto, NULL, &size, NULL); + uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &(*fs)->proto, NULL, &size, NULL); if (size == 0) continue; add_dev_tab(&(*fs)->proto, boot_handle, size, (*fs)->glue); diff --git a/fs/ext2fs.c b/fs/ext2fs.c index 4eaea27..bec47fe 100644 --- a/fs/ext2fs.c +++ b/fs/ext2fs.c @@ -144,7 +144,7 @@ read_bytes(EFI_BLOCK_IO *blkio, UINT32 mediaid, UINTN offset, VOID *addr, UINTN DBG_PRT((L"readblock(%x, %d, %d, %d, %x)", blkio, mediaid, base, buffer_size, buffer)); - status = blkio->ReadBlocks(blkio, mediaid, base, buffer_size, buffer); + status = uefi_call_wrapper(blkio->ReadBlocks, 5, blkio, mediaid, base, buffer_size, buffer); if (EFI_ERROR(status)) { ERR_PRT((L"readblock(%d,%d)=%r", base, buffer_size, status)); goto error; @@ -866,13 +866,13 @@ ext2fs_install_one(EFI_HANDLE dev, VOID **intf) EFI_BLOCK_IO *blkio; ext2fs_t *ext2fs; - status = BS->HandleProtocol (dev, &Ext2FsProtocol, (VOID **)&ext2fs); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, &Ext2FsProtocol, (VOID **)&ext2fs); if (status == EFI_SUCCESS) { ERR_PRT((L"Warning: found existing %s protocol on device", FS_NAME)); goto found; } - status = BS->HandleProtocol(dev, &BlockIoProtocol, (VOID **)&blkio); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, &BlockIoProtocol, (VOID **)&blkio); if (EFI_ERROR(status)) return EFI_INVALID_PARAMETER; VERB_PRT(5, @@ -944,7 +944,7 @@ ext2fs_install(VOID) EFI_STATUS status; VOID *intf; - BS->LocateHandle(ByProtocol, &BlockIoProtocol, NULL, &size, NULL); + uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &BlockIoProtocol, NULL, &size, NULL); if (size == 0) return EFI_UNSUPPORTED; /* no device found, oh well */ DBG_PRT((L"size=%d", size)); @@ -955,7 +955,8 @@ ext2fs_install(VOID) return EFI_OUT_OF_RESOURCES; } - status = BS->LocateHandle(ByProtocol, &BlockIoProtocol, NULL, &size, (VOID **)dev_tab); + status = uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &BlockIoProtocol, NULL, + &size, (VOID **)dev_tab); if (status != EFI_SUCCESS) { ERR_PRT((L"failed to get handles: %r", status)); free(dev_tab); @@ -984,7 +985,7 @@ ext2fs_uninstall(VOID) for(i=0; i < ndev; i++) { if (dev_tab[i].intf == NULL) continue; e2fs = FS_PRIVATE(dev_tab[i].intf); - status = BS->UninstallProtocolInterface(e2fs->dev, &Ext2FsProtocol, dev_tab[i].intf); + status = uefi_call_wrapper(BS->UninstallProtocolInterface, 3, e2fs->dev, &Ext2FsProtocol, dev_tab[i].intf); if (EFI_ERROR(status)) { ERR_PRT((L"Uninstall %s error: %r", FS_NAME, status)); continue; diff --git a/fs/localfs.c b/fs/localfs.c index 4fdc99f..fe1333f 100644 --- a/fs/localfs.c +++ b/fs/localfs.c @@ -1,6 +1,10 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -61,7 +65,7 @@ static EFI_GUID LocalFsProtocol = LOCALFS_PROTOCOL; * let's be clean here */ typedef union { - EFI_HANDLE *dev; + EFI_HANDLE dev; localfs_t *intf; } dev_tab_t; @@ -94,7 +98,7 @@ localfs_open(localfs_interface_t *this, CHAR16 *name, UINTN *fd) DBG_PRT((L"localfs_open on %s\n", name)); - status = lfs->volume->Open(lfs->volume, &fh, name, EFI_FILE_MODE_READ, 0); + status = uefi_call_wrapper(lfs->volume->Open, 5, lfs->volume, &fh, name, EFI_FILE_MODE_READ, 0); if (status == EFI_SUCCESS) { *fd = LOCALFS_F2FD(fh); } @@ -110,7 +114,7 @@ localfs_read(localfs_interface_t *this, UINTN fd, VOID *buf, UINTN *size) lfs = FS_PRIVATE(this); - return lfs->volume->Read(LOCALFS_FD2F(fd), size, buf); + return uefi_call_wrapper(lfs->volume->Read, 3, LOCALFS_FD2F(fd), size, buf); } static EFI_STATUS @@ -122,7 +126,7 @@ localfs_close(localfs_interface_t *this, UINTN fd) lfs = FS_PRIVATE(this); - return lfs->volume->Close(LOCALFS_FD2F(fd)); + return uefi_call_wrapper(lfs->volume->Close, 1, LOCALFS_FD2F(fd)); } static EFI_STATUS @@ -140,7 +144,7 @@ localfs_infosize(localfs_interface_t *this, UINTN fd, UINT64 *sz) *sz = info->FileSize; - FreePool(info); + uefi_call_wrapper(BS->FreePool, 1, info); return EFI_SUCCESS; } @@ -154,7 +158,7 @@ localfs_seek(localfs_interface_t *this, UINTN fd, UINT64 newpos) lfs = FS_PRIVATE(this); - return lfs->volume->SetPosition(LOCALFS_FD2F(fd), newpos); + return uefi_call_wrapper(lfs->volume->SetPosition, 2, LOCALFS_FD2F(fd), newpos); } static VOID @@ -185,16 +189,16 @@ localfs_install_one(EFI_HANDLE dev, VOID **intf) EFI_FILE_IO_INTERFACE *volume; EFI_FILE_HANDLE volume_fh; - status = BS->HandleProtocol (dev, &LocalFsProtocol, (VOID **)&localfs); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, &LocalFsProtocol, (VOID **)&localfs); if (status == EFI_SUCCESS) { ERR_PRT((L"Warning: found existing %s protocol on device", FS_NAME)); goto found; } - status = BS->HandleProtocol (dev, &FileSystemProtocol, (VOID **)&volume); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, &FileSystemProtocol, (VOID **)&volume); if (EFI_ERROR(status)) return EFI_INVALID_PARAMETER; - status = volume->OpenVolume(volume, &volume_fh); + status = uefi_call_wrapper(volume->OpenVolume, 2, volume, &volume_fh); if (EFI_ERROR(status)) { ERR_PRT((L"cannot open volume")); return status; @@ -221,7 +225,7 @@ found: dp = DevicePathFromHandle(dev); str = DevicePathToStr(dp); Print(L"attached %s to %s\n", FS_NAME, str); - FreePool(str); + uefi_call_wrapper(BS->FreePool, 1, str); }); return EFI_SUCCESS; @@ -235,7 +239,7 @@ localfs_install(VOID) EFI_STATUS status; VOID *intf; - BS->LocateHandle(ByProtocol, &FileSystemProtocol, NULL, &size, NULL); + uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &FileSystemProtocol, NULL, &size, NULL); if (size == 0) return EFI_UNSUPPORTED; /* no device found, oh well */ DBG_PRT((L"size=%d", size)); @@ -245,8 +249,7 @@ localfs_install(VOID) ERR_PRT((L"failed to allocate handle table")); return EFI_OUT_OF_RESOURCES; } - - status = BS->LocateHandle(ByProtocol, &FileSystemProtocol, NULL, &size, (VOID **)dev_tab); + status = uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &FileSystemProtocol, NULL, &size, (VOID **)dev_tab); if (status != EFI_SUCCESS) { ERR_PRT((L"failed to get handles: %r", status)); free(dev_tab); @@ -275,7 +278,7 @@ localfs_uninstall(VOID) for(i=0; i < ndev; i++) { if (dev_tab[i].intf == NULL) continue; lfs = FS_PRIVATE(dev_tab[i].intf); - status = BS->UninstallProtocolInterface(lfs->dev, &LocalFsProtocol, dev_tab[i].intf); + status = uefi_call_wrapper(BS->UninstallProtocolInterface, 3, lfs->dev, &LocalFsProtocol, dev_tab[i].intf); if (EFI_ERROR(status)) { ERR_PRT((L"Uninstall %s error: %r", FS_NAME, status)); continue; @@ -285,7 +288,7 @@ localfs_uninstall(VOID) dp = DevicePathFromHandle(lfs->dev); str = DevicePathToStr(dp); Print(L"uninstalled %s on %s\n", FS_NAME, str); - FreePool(str); + uefi_call_wrapper(BS->FreePool, 1, str); }); free(dev_tab[i].intf); } diff --git a/fs/netfs.c b/fs/netfs.c index 4913785..063f4e5 100644 --- a/fs/netfs.c +++ b/fs/netfs.c @@ -1,6 +1,10 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -262,7 +266,7 @@ netfs_start(EFI_PXE_BASE_CODE *pxe) { EFI_STATUS status; - status = pxe->Start(pxe, FALSE); + status = uefi_call_wrapper(pxe->Start, 2, pxe, FALSE); if (EFI_ERROR(status)) return status; return pxe->Dhcp(pxe, FALSE); @@ -337,7 +341,7 @@ retry: */ prev_netbufsize = f->netbuf_size; - status = nfs->pxe->Mtftp(nfs->pxe, EFI_PXE_BASE_CODE_TFTP_READ_FILE, f->netbuf, FALSE, + status = uefi_call_wrapper(nfs->pxe->Mtftp, 10, nfs->pxe, EFI_PXE_BASE_CODE_TFTP_READ_FILE, f->netbuf, FALSE, &(f->netbuf_size), blocksize > 0 ? &blocksize : NULL, &nfs->srv_ip, @@ -627,7 +631,7 @@ netfs_query_layer(netfs_interface_t *this, UINT16 server_type, UINT16 layer, UIN if (server_type == 0) server_type = find_pxe_server_type(nfs->pxe); - status = nfs->pxe->Discover(nfs->pxe, server_type, &layer, FALSE, 0); + status = uefi_call_wrapper(nfs->pxe->Discover, 5, nfs->pxe, server_type, &layer, FALSE, 0); if(status == EFI_SUCCESS) { ascii2U(nfs->pxe->Mode->PxeReply.Dhcpv4.BootpBootFile, str, maxlen); } @@ -680,13 +684,13 @@ netfs_install_one(EFI_HANDLE dev, VOID **intf) netfs_t *netfs; EFI_PXE_BASE_CODE *pxe; - status = BS->HandleProtocol (dev, &NetFsProtocol, (VOID **)&netfs); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, &NetFsProtocol, (VOID **)&netfs); if (status == EFI_SUCCESS) { ERR_PRT((L"Warning: found existing %s protocol on device", FS_NAME)); goto found; } - status = BS->HandleProtocol (dev, &PxeBaseCodeProtocol, (VOID **)&pxe); + status = uefi_call_wrapper(BS->HandleProtocol, 3, dev, &PxeBaseCodeProtocol, (VOID **)&pxe); if (EFI_ERROR(status)) return EFI_INVALID_PARAMETER; @@ -727,7 +731,7 @@ netfs_install(VOID) EFI_STATUS status; VOID *intf; - BS->LocateHandle(ByProtocol, &PxeBaseCodeProtocol, NULL, &size, NULL); + uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &PxeBaseCodeProtocol, NULL, &size, NULL); if (size == 0) return EFI_UNSUPPORTED; /* no device found, oh well */ DBG_PRT((L"size=%d", size)); @@ -738,7 +742,7 @@ netfs_install(VOID) return EFI_OUT_OF_RESOURCES; } - status = BS->LocateHandle(ByProtocol, &PxeBaseCodeProtocol, NULL, &size, (VOID **)dev_tab); + status = uefi_call_wrapper(BS->LocateHandle, 5, ByProtocol, &PxeBaseCodeProtocol, NULL, &size, (VOID **)dev_tab); if (status != EFI_SUCCESS) { ERR_PRT((L"failed to get handles: %r", status)); free(dev_tab); @@ -767,7 +771,7 @@ netfs_uninstall(VOID) for(i=0; i < ndev; i++) { if (dev_tab[i].intf == NULL) continue; nfs = FS_PRIVATE(dev_tab[i].intf); - status = BS->UninstallProtocolInterface(nfs->dev, &NetFsProtocol, dev_tab[i].intf); + status = uefi_call_wrapper(BS->UninstallProtocolInterface, 3, nfs->dev, &NetFsProtocol, dev_tab[i].intf); if (EFI_ERROR(status)) { ERR_PRT((L"Uninstall %s error: %r", FS_NAME, status)); continue; @@ -780,7 +784,8 @@ netfs_uninstall(VOID) FreePool(str); }); - if (nfs->pxe->Mode->Started == TRUE) nfs->pxe->Stop(nfs->pxe); + if (nfs->pxe->Mode->Started == TRUE) + uefi_call_wrapper(nfs->pxe->Stop, 1, nfs->pxe); free(dev_tab[i].intf); } diff --git a/getopt.c b/getopt.c index 8a70616..03a17d8 100644 --- a/getopt.c +++ b/getopt.c @@ -25,7 +25,6 @@ * 02111-1307, USA. */ - #include #include @@ -36,7 +35,7 @@ #define BADCH (INTN)'?' #define BADARG (INTN)':' -extern CHAR16 * StrChr(IN const CHAR16 *s, INT16 c); +extern CHAR16 * StrChr(IN const CHAR16 *s, CHAR16 c); CHAR16 *Optarg; INTN Optind = 1; diff --git a/glue_netfs.c b/glue_netfs.c index 5de3629..51a38ce 100644 --- a/glue_netfs.c +++ b/glue_netfs.c @@ -1,6 +1,10 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -167,6 +171,8 @@ netfs_setdefaults(VOID *intf, config_file_t *config, CHAR16 *kname, UINTN maxlen # define CONFIG_ARCH_EXTENSION L"-ia64.conf\0" # elif defined (CONFIG_ia32) # define CONFIG_ARCH_EXTENSION L"-ia64.conf\0" +# elif defined (CONFIG_x86_64) +# define CONFIG_ARCH_EXTENSION L"-x86_64.conf\0" # else # error "You need to specfy your default arch config file" # endif diff --git a/sysdeps.h b/sysdeps.h index b72d106..898854f 100644 --- a/sysdeps.h +++ b/sysdeps.h @@ -1,6 +1,10 @@ /* * Copyright (C) 2001-2003 Hewlett-Packard Co. * Contributed by Stephane Eranian + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan * * This file is part of the ELILO, the EFI Linux boot loader. * @@ -30,6 +34,8 @@ #include "ia64/sysdeps.h" #elif defined CONFIG_ia32 #include "ia32/sysdeps.h" +#elif defined CONFIG_x86_64 +#include "x86_64/sysdeps.h" #endif #endif /* __ELILO_SYSDEPS_H__ */ diff --git a/util.c b/util.c index 85babf4..84e76cc 100644 --- a/util.c +++ b/util.c @@ -5,6 +5,11 @@ * Copyright (C) 2001 Silicon Graphics, Inc. * Contributed by Brent Casavant * + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * * This file is part of the ELILO, the EFI Linux boot loader. * * ELILO is free software; you can redistribute it and/or modify @@ -40,7 +45,10 @@ static INTN read_keypress(EFI_INPUT_KEY *key) { - return systab->ConIn->ReadKeyStroke(systab->ConIn, key); + return uefi_call_wrapper(systab->ConIn->ReadKeyStroke, + 2, + systab->ConIn, + key); } @@ -55,7 +63,10 @@ check_abort(VOID) inline VOID reset_input(VOID) { - systab->ConIn->Reset(systab->ConIn, 1); + uefi_call_wrapper(systab->ConIn->Reset, + 2, + systab->ConIn, + 1); } #if 0 @@ -71,9 +82,9 @@ wait_keypress_abort(VOID) Print(L"Hit ENTER to continue or ANY other key to cancel"); /* cleanup buffer first */ - while (conin->ReadKeyStroke(conin, &key) == EFI_SUCCESS); + while (uefi_call_wrapper(conin->ReadKeyStroke, 2, conin, &key) == EFI_SUCCESS); - while ((status=conin->ReadKeyStroke(conin, &key)) == EFI_NOT_READY ); + while ((status=uefi_call_wrapper(conin->ReadKeyStroke,2, conin, &key)) == EFI_NOT_READY ); if (EFI_ERROR(status)) return ELILO_LOAD_ERROR; @@ -102,13 +113,13 @@ wait_timeout(UINTN timeout) if (timeout == 0) return 0; /* Create a timeout timer */ - status = BS->CreateEvent(EVT_TIMER, 0, NULL, NULL, &timer); + status = uefi_call_wrapper(BS->CreateEvent, 5, EVT_TIMER, 0, NULL, NULL, &timer); if (EFI_ERROR(status)) { ERR_PRT((L" waitkey CreateEvent failed %r", status)); return -1; } /* In 100ns increments */ - status = BS->SetTimer(timer, TimerPeriodic, TENTH_SEC); + status = uefi_call_wrapper(BS->SetTimer, 3, timer, TimerPeriodic, TENTH_SEC); if (EFI_ERROR(status)) { ERR_PRT((L"waitkey SetTimer failed %r", status)); return -1; @@ -118,7 +129,7 @@ wait_timeout(UINTN timeout) list[1] = systab->ConIn->WaitForKey; do { - status = BS->WaitForEvent(2, list, &idx); + status = uefi_call_wrapper(BS->WaitForEvent, 3, 2, list, &idx); if (EFI_ERROR(status)) { ERR_PRT((L"waitkey WaitForEvent failed %r", status)); return -1; @@ -130,13 +141,13 @@ wait_timeout(UINTN timeout) * SetTimer(timer, TimerCancel, 0) is causing problems on IA-32 and gcc3 * I do not know why it dies with EFI12.35. So let's fake a key stroke. */ - status = BS->SetTimer(timer, TimerCancel, 0); + status = uefi_call_wrapper(BS->SetTimer, 3, timer, TimerCancel, 0); if (EFI_ERROR(status)) { ERR_PRT((L"waitkey SetTimer(TimerCancel) failed %r", status)); return -1; } - BS->CloseEvent(timer); + uefi_call_wrapper(BS->CloseEvent, 1, timer); return idx ? 1 : 0; } @@ -278,7 +289,7 @@ read_file(UINTN fd, UINTN total_size, CHAR8 *buffer) INTN get_memmap(mmap_desc_t *desc) { -#define ELILO_MEMMAP_SIZE_DEFAULT EFI_PAGE_SIZE +#define ELILO_MEMMAP_SIZE_DEFAULT (EFI_PAGE_SIZE*2) #define ELILO_MEMMAP_INC (sizeof(EFI_MEMORY_DESCRIPTOR)<<1) EFI_STATUS status; @@ -292,7 +303,8 @@ get_memmap(mmap_desc_t *desc) ERR_PRT((L"failed to allocate memory map buffer")); return -1; } - status = (*BS->GetMemoryMap)(&desc->map_size, desc->md, &desc->cookie, &desc->desc_size, &desc->desc_version); + status = uefi_call_wrapper(BS->GetMemoryMap, 5, &desc->map_size, desc->md, + &desc->cookie, &desc->desc_size, &desc->desc_version); if (status == EFI_SUCCESS) break; free(desc->md); diff --git a/x86_64/Makefile b/x86_64/Makefile new file mode 100644 index 0000000..4af4b8d --- /dev/null +++ b/x86_64/Makefile @@ -0,0 +1,52 @@ +# +# Copyright (C) 2001-2003 Hewlett-Packard Co. +# Contributed by Stephane Eranian +# +# This file is part of the ELILO, the EFI Linux boot loader. +# +# ELILO is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# ELILO is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with ELILO; see the file COPYING. If not, write to the Free +# Software Foundation, 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA. +# +# Please check out the elilo.txt for complete documentation on how +# to use this program. +# + +include ../Make.defaults +include ../Make.rules + +TOPDIR=$(CDIR)/.. + +FILES=system.o config.o bzimage.o plain_loader.o gzip_loader.o gzip.o +#FILES=system.o config.o plain_loader.o + +TARGET=sysdeps.o + +all: $(TARGET) + +system.o: rmswitch.h + +rmswitch.h: bin_to_h.c rmswitch.S + $(CC) -o bin_to_h bin_to_h.c + $(AS) -o rmswitch.o rmswitch.S + $(LD) -Ttext 0x0 -s --oformat binary -o rmswitch rmswitch.o + ./bin_to_h rmswitch.h + +$(TARGET): $(FILES) + $(LD) -r -o $@ $(FILES) + +clean: + $(RM) -f $(TARGET) $(FILES) + $(RM) -f bin_to_h.o bin_to_h + $(RM) -f rmswitch.h rmswitch.o rmswitch diff --git a/x86_64/bin_to_h.c b/x86_64/bin_to_h.c new file mode 100644 index 0000000..2d1dd1b --- /dev/null +++ b/x86_64/bin_to_h.c @@ -0,0 +1,27 @@ +#include +#include + +int +main(void) +{ + unsigned n = 0; + int c; + + printf("UINT8 rmswitch_image[] = {\n"); + + while ((c = getchar()) != EOF) { + printf("0x%02x,%s", + c & 0xFF, + (++n & 0x07) ? " " : "\n"); + } + + if (n & 0x07) { + printf("\n"); + } + + printf( + "};\n" + "UINTN rmswitch_size = sizeof rmswitch_image;\n"); + + return 0; +} diff --git a/x86_64/bzimage.c b/x86_64/bzimage.c new file mode 100644 index 0000000..2eb4f46 --- /dev/null +++ b/x86_64/bzimage.c @@ -0,0 +1,224 @@ +/* + * Copyright (C) 2001-2003 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * Contributed by Mike Johnston + * Contributed by Chris Ahna + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#include +#include + +#include "elilo.h" +#include "loader.h" + +boot_params_t *param_start = NULL; +UINTN param_size = 0; + +UINTN kernel_size = 0x400000; /* 4M (largest x86 bzImage kernel image) */ + +static INTN +bzImage_probe(CHAR16 *kname) +{ + EFI_STATUS efi_status; + UINTN size; + fops_fd_t fd; + UINT8 bootsect[512]; + + DBG_PRT((L"probe_bzImage_boot()\n")); + + if (!kname) { + ERR_PRT((L"kname == %xh", kname)); + free_kmem(); + return -1; + } + + /* + * Open kernel image. + */ + DBG_PRT((L"opening %s...\n", kname)); + + efi_status = fops_open(kname, &fd); + if (EFI_ERROR(efi_status)) { + ERR_PRT((L"Could not open %s.", kname)); + free_kmem(); + return -1; + } + /* + * Read boot sector. + */ + + DBG_PRT((L"\nreading boot sector...\n")); + + size = sizeof bootsect; + efi_status = fops_read(fd, bootsect, &size); + if (EFI_ERROR(efi_status) || size != sizeof bootsect) { + ERR_PRT((L"Could not read boot sector from %s.", kname)); + fops_close(fd); + free_kmem(); + return -1; + } + /* + * Verify boot sector signature. + */ + + if (bootsect[0x1FE] != 0x55 || bootsect[0x1FF] != 0xAA) { + ERR_PRT((L"%s is not a bzImage kernel image.\n", kname)); + fops_close(fd); + free_kmem(); + return -1; + } + /* + * Check for out of range setup data size. + * Will almost always be 7, but we will accept 1 to 64. + */ + + DBG_PRT((L"bootsect[1F1h] == %d setup sectors\n", bootsect[0x1F1])); + + if (bootsect[0x1F1] < 1 || bootsect[0x1F1] > 64) { + ERR_PRT((L"%s is not a valid bzImage kernel image.", + kname)); + fops_close(fd); + free_kmem(); + return -1; + } + /* + * Allocate and read setup data. + */ + + DBG_PRT((L"reading setup data...\n")); + + param_size = (bootsect[0x1F1] + 1) * 512; + param_start = alloc(param_size, EfiLoaderData); + + DBG_PRT((L"param_size=%d param_start=%x", param_size, param_start)); + + if (!param_start) { + ERR_PRT((L"Could not allocate %d bytes of setup data.", + param_size)); + fops_close(fd); + free_kmem(); + return -1; + } + + CopyMem(param_start, bootsect, sizeof bootsect); + + size = param_size - 512; + efi_status = fops_read(fd, ((UINT8 *)param_start) + 512, &size); + + if (EFI_ERROR(efi_status) || size != param_size - 512) { + ERR_PRT((L"Could not read %d bytes of setup data.", + param_size - 512)); + free(param_start); + param_start = NULL; + param_size = 0; + fops_close(fd); + free_kmem(); + return -1; + } + /* + * Check for setup data signature. + */ + + { + UINT8 *c = ((UINT8 *)param_start)+514; + DBG_PRT((L"param_start(c=%x): %c-%c-%c-%c", + c, (CHAR16)c[0],(CHAR16) c[1], (CHAR16)c[2], (CHAR16)c[3])); + } + if (CompareMem(((UINT8 *)param_start) + 514, "HdrS", 4)) { + ERR_PRT((L"%s does not have a setup signature.", + kname)); + free(param_start); + param_start = NULL; + param_size = 0; + fops_close(fd); + free_kmem(); + return -1; + } + /* + * Allocate memory for kernel. + */ + + if (alloc_kmem(kernel_start, EFI_SIZE_TO_PAGES(kernel_size))) { + ERR_PRT((L"Could not allocate kernel memory.")); + return -1; + } else { + VERB_PRT(3, Print(L"kernel_start: 0x%x kernel_size: %d\n", + kernel_start, kernel_size)); + } + /* + * Now read the rest of the kernel image into memory. + */ + + DBG_PRT((L"reading kernel image...\n")); + + size = kernel_size; + efi_status = fops_read(fd, kernel_start, &size); + if (EFI_ERROR(efi_status) || size < 0x10000) { + ERR_PRT((L"Error reading kernel image %s.", kname)); + free(param_start); + param_start = NULL; + param_size = 0; + fops_close(fd); + free_kmem(); + return -1; + } + + DBG_PRT((L"kernel image read: %d bytes, %d Kbytes\n", size, size / 1024)); + + /* + * Boot sector, setup data and kernel image loaded. + */ + + fops_close(fd); + return 0; +} + +/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ +static INTN +bzImage_load(CHAR16 *kname, kdesc_t *kd) +{ + DBG_PRT((L"load_bzImage_boot()\n")); + + if (!kname || !kd) { + ERR_PRT((L"kname=0x%x kd=0x%x", kname, kd)); + free(param_start); + param_start = NULL; + param_size = 0; + free_kmem(); + return -1; + } + kd->kstart = kd->kentry = kernel_start; + kd->kend = ((UINT8 *)kd->kstart) + kernel_size; + + DBG_PRT((L"kstart=0x%x kentry=0x%x kend=0x%x\n", kd->kstart, kd->kentry, kd->kend)); + + return 0; +} + +/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ +loader_ops_t bzimage_loader = { + NULL, + L"bzImage_loader", + &bzImage_probe, + &bzImage_load +}; diff --git a/x86_64/config.c b/x86_64/config.c new file mode 100644 index 0000000..e8d4620 --- /dev/null +++ b/x86_64/config.c @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2001-2003 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * Contributed by Chris Ahna + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#include +#include + +#include "elilo.h" +#include "config.h" +#include "private.h" + +typedef struct { + UINTN legacy_free_boot; +} x86_64_global_config_t; + + +static x86_64_global_config_t x86_64_gconf; + +static config_option_t sysdeps_global_options[]={ + {OPT_BOOL, OPT_GLOBAL, L"legacy-free", NULL, NULL, &x86_64_gconf.legacy_free_boot} +}; + +/* + * X86_64 operations that need to be done only once and just before + * entering the main loop of the loader + * Return: + * 0 if sucessful + * -1 otherwise (will abort execution) + */ +INTN +sysdeps_preloop_actions(EFI_HANDLE dev, CHAR16 **argv, INTN argc, INTN index, EFI_HANDLE image) +{ + return 0; +} + +#define X86_64_CMDLINE_OPTIONS L"" + +CHAR16 * +sysdeps_get_cmdline_opts(VOID) +{ + return X86_64_CMDLINE_OPTIONS; +} + +INTN +sysdeps_getopt(INTN c, INTN optind, CHAR16 *optarg) +{ + return -1; +} + +VOID +sysdeps_print_cmdline_opts(VOID) +{ +} + + +INTN +x86_64_use_legacy_free_boot(VOID) +{ + return x86_64_gconf.legacy_free_boot ? 1 : 0; +} + +INTN +sysdeps_register_options(VOID) +{ + INTN ret; + + ret = register_config_options(sysdeps_global_options, + sizeof(sysdeps_global_options)/sizeof(config_option_t), + OPTIONS_GROUP_GLOBAL); +#if 0 + /* no per image options yet */ + if (ret == -1 ) return ret; + + ret = register_config_options(sysdeps_image_options, + sizeof(sysdeps_image_options)/sizeof(config_option_t), + OPTIONS_GROUP_IMAGE); +#endif + + return ret; +} diff --git a/x86_64/gzip.c b/x86_64/gzip.c new file mode 100644 index 0000000..fdac155 --- /dev/null +++ b/x86_64/gzip.c @@ -0,0 +1,557 @@ +/* + * Copyright (C) 2001-2002 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * + * Copyright (C) 2001 Silicon Graphics, Inc. + * Contributed by Brent Casavant + * + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#include +#include + +#include "elf.h" +#include "elilo.h" +#include "gzip.h" +#include "private.h" + +#define memzero(s, n) Memset((VOID *)(s), 0, (n)) +#define memcpy(a,b,n) Memcpy((VOID *)(a),(b),(n)) + +/* size of output buffer */ +#define WSIZE 0x8000 /* Window size must be at least 32k, */ + /* and a power of two */ +/* size of input buffer */ +#define INBUFSIZE 0x8000 + +/* + * gzip declarations + */ + +#define OF(args) args +#define FUNC_STATIC static + +typedef unsigned char uch; +typedef unsigned short ush; +typedef unsigned long ulg; + + +typedef struct segment { + unsigned long addr; /* start address */ + unsigned long offset; /* file offset */ + unsigned long size; /* file size */ + unsigned long bss_sz; /* BSS size */ + UINT8 flags; /* indicates whether to load or not */ +} segment_t; + +#define CHUNK_FL_VALID 0x1 +#define CHUNK_FL_LOAD 0x2 + +#define CHUNK_CAN_LOAD(n) chunks[(n)].flags |= CHUNK_FL_LOAD +#define CHUNK_NO_LOAD(n) chunks[(n)].flags &= ~CHUNK_FL_LOAD +#define CHUNK_IS_LOAD(n) (chunks[(n)].flags & CHUNK_FL_LOAD) + +#define CHUNK_VALIDATE(n) chunks[(n)].flags |= CHUNK_FL_VALID +#define CHUNK_INVALIDATE(n) chunks[(n)].flags = 0 +#define CHUNK_IS_VALID(n) (chunks[(n)].flags & CHUNK_FL_VALID) + +/* + * static parameters to gzip helper functions + * we cannot use paramters because API was not + * designed that way + */ +static segment_t *chunks; /* holds the list of segments */ +static segment_t *cur_chunk; +static UINTN nchunks; +static UINTN chunk; /* current segment */ +static UINTN input_fd; +static VOID *kernel_entry, *kernel_base, *kernel_end; + +static uch *inbuf; /* input buffer (compressed data) */ +static uch *window; /* output buffer (uncompressed data) */ +static unsigned long file_offset; /* position in the file */ + +static unsigned insize = 0; /* valid bytes in inbuf */ +static unsigned inptr = 0; /* index of next byte to be processed in inbuf */ +static unsigned outcnt = 0; /* bytes in output buffer */ + +/* gzip flag byte */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */ +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ +#define RESERVED 0xC0 /* bit 6,7: reserved */ + +#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf()) + +/* Diagnostic functions */ +#ifdef INFLATE_DEBUG +# define Assert(cond,msg) {if(!(cond)) error(msg);} +int stderr; +# define Trace(x) Print(L"line %d:\n", __LINE__); +# define Tracev(x) {if (verbose) Print(L"line %d:\n", __LINE__) ;} +# define Tracevv(x) {if (verbose>1) Print(L"line %d:\n", __LINE__) ;} +# define Tracec(c,x) {if (verbose && (c)) Print(L"line %d:\n", __LINE__) ;} +# define Tracecv(c,x) {if (verbose>1 && (c)) Print(L"line %d:\n", __LINE__) ;} +#else +# define Assert(cond,msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c,x) +# define Tracecv(c,x) +#endif + +static int fill_inbuf(void); +static void flush_window(void); +static void error(char *m); +static long bytes_out; +static void error(char *m); +static int error_return; + +static void * +gzip_malloc(int size) +{ + return (void *)alloc(size, 0); +} + +static void +gzip_free(void *where) +{ + return free(where); +} + +#include "inflate.c" + +/* + * Fill the input buffer and return the first byte in it. This is called + * only when the buffer is empty and at least one byte is really needed. + */ +int +fill_inbuf(void) +{ + INTN expected, nread; + EFI_STATUS status; + + expected = nread = INBUFSIZE; + + status = fops_read(input_fd, inbuf, &nread); + if (EFI_ERROR(status)) { + error("elilo: Read failed"); + } + DBG_PRT((L"%s : read %d bytes of %d bytes\n", LD_NAME, nread, expected)); + + insize = nread; + inptr = 1; + + return inbuf[0]; +} + +/* =========================================================================== + * Write the output window window[0..outcnt-1] and update crc and bytes_out. + * (Used for the decompressed data only.) + */ + +/* + * Run a set of bytes through the crc shift register. If s is a NULL + * pointer, then initialize the crc shift register contents instead. + * Return the current crc in either case. + * + * Input: + * S pointer to bytes to pump through. + * N number of bytes in S[]. + */ +unsigned long +updcrc(unsigned char *s, unsigned n) +{ + register unsigned long c; + /* crc is defined in inflate.c */ + + if (!s) { + c = 0xffffffffL; + } else { + c = crc; + while (n--) { + c = crc_32_tab[((int)c ^ (*s++)) & 0xff] ^ (c >> 8); + } + } + crc = c; + return c ^ 0xffffffffUL; /* (instead of ~c for 64-bit machines) */ +} + + +/* + * Clear input and output buffers + */ +void +clear_bufs(void) +{ + outcnt = 0; + inptr = 0; + chunk = 0; + cur_chunk = NULL; + file_offset = 0; +} + + +static INTN +is_valid_header(Elf64_Ehdr *ehdr) +{ + UINT16 type, machine; + + type = ehdr->e_type; + machine = ehdr->e_machine; + + VERB_PRT(3, Print(L"class=%d type=%d data=%d machine=%d\n", + ehdr->e_ident[EI_CLASS], + type, + ehdr->e_ident[EI_DATA], + machine)); + + return ehdr->e_ident[EI_MAG0] == 0x7f + && ehdr->e_ident[EI_MAG1] == 'E' + && ehdr->e_ident[EI_MAG2] == 'L' + && ehdr->e_ident[EI_MAG3] == 'F' + && ehdr->e_ident[EI_CLASS] == ELFCLASS64 + && type == ET_EXEC /* must be executable */ + && machine == EM_X86_64 ? 0 : -1; +} + +/* + * will invalidate loadble segments which overlap with others + */ +void +check_overlap(int i) +{ + int j; + unsigned long iend = chunks[i].addr + chunks[i].size; + + for(j=0; j < nchunks; j++) { + if (j ==i) continue; + if (chunks[i].addr >= chunks[j].addr && iend < (chunks[j].addr + chunks[j].size)) { + DBG_PRT((L"%s : segment %d fully included in segment %d\n", LD_NAME, i, j)); + CHUNK_INVALIDATE(i); /* nullyify segment */ + break; + } + } +} + +void +analyze_chunks(void) +{ + INTN i; + + for (i=0; i < nchunks; i++) { + if (CHUNK_IS_VALID(i) && !CHUNK_IS_LOAD(i)) + check_overlap(i); + } +} + + +/* + * The decompression code calls this function after decompressing the + * first block of the object file. The first block must contain all + * the relevant header information. + */ +int +first_block (const char *buf, long blocksize) +{ + Elf64_Ehdr *elf; + Elf64_Phdr *phdrs; + UINTN total_size, pages; + UINTN low_addr, max_addr; + UINTN offs = 0; + UINT16 phnum; + UINTN paddr, memsz; + INTN i; + + elf = (Elf64_Ehdr *)buf; + + if (is_valid_header(elf) == -1) + return -1; + + offs = elf->e_phoff; + phnum = elf->e_phnum; + + VERB_PRT(3, { + Print(L"Entry point 0x%lx\n", elf->e_entry); + Print(L"%d program headers\n", phnum); + Print(L"%d segment headers\n", elf->e_shnum); + }); + + if (offs + phnum * sizeof(*phdrs) > (unsigned) blocksize) { + ERR_PRT((L"%s : ELF program headers not in first block (%ld)\n", LD_NAME, offs)); + return -1; + } + + kernel_entry = (VOID *)(elf->e_entry & PADDR_MASK); + + phdrs = (Elf64_Phdr *) (buf + offs); + low_addr = ~0; + max_addr = 0; + + /* + * allocate chunk table + * Convention: a segment that does not need loading will + * have chunk[].addr = 0. + */ + chunks = (void *)alloc(sizeof(struct segment)*phnum, 0); + if (chunks == NULL) { + ERR_PRT((L"%s : failed alloc chunks %r\n", LD_NAME)); + return -1; + } + nchunks = phnum; + /* + * find lowest and higest virtual addresses + * don't assume FULLY sorted ! + */ + for (i = 0; i < phnum; ++i) { + /* + * record chunk no matter what because no load may happen + * anywhere in archive, not just as the last segment + */ + paddr = (phdrs[i].p_paddr & PADDR_MASK); + memsz = phdrs[i].p_memsz, + + chunks[i].addr = paddr; + chunks[i].offset = phdrs[i].p_offset; + chunks[i].size = phdrs[i].p_filesz; + chunks[i].bss_sz = phdrs[i].p_memsz - phdrs[i].p_filesz; + + CHUNK_VALIDATE(i); + + if (phdrs[i].p_type != PT_LOAD) { + CHUNK_NO_LOAD(i); /* mark no load chunk */ + DBG_PRT((L"%s : skipping segment %ld\n", LD_NAME, i)); + continue; + } + + CHUNK_CAN_LOAD(i); /* mark no load chunk */ + + VERB_PRT(3, + Print(L"\n%s : segment %ld vaddr [0x%lx-0x%lx] offset %ld filesz %ld " + "memsz=%ld bss_sz=%ld\n", + LD_NAME, 1+i, chunks[i].addr, chunks[i].addr+phdrs[i].p_filesz, + chunks[i].offset, chunks[i].size, memsz, chunks[i].bss_sz)); + + if (paddr < low_addr) + low_addr = paddr; + if (paddr + memsz > max_addr) + max_addr = paddr + memsz; + } + + if (low_addr & (EFI_PAGE_SIZE - 1)) { + ERR_PRT((L"%s : low_addr not page aligned 0x%lx\n", LD_NAME, low_addr)); + goto error; + } + analyze_chunks(); + + DBG_PRT((L"%s : %d program headers entry=0x%lx\nlowest_addr=0x%lx highest_addr=0x%lx\n", + LD_NAME, + phnum, kernel_entry, low_addr, max_addr)); + + total_size = (UINTN)max_addr - (UINTN)low_addr; + pages = EFI_SIZE_TO_PAGES(total_size); + + /* + * Record end of kernel for initrd + */ + kernel_base = (void *)low_addr; + kernel_end = (void *)(low_addr + (pages << EFI_PAGE_SHIFT)); + + /* allocate memory for the kernel */ + if (alloc_kmem((void *)low_addr, pages) == -1) { + ERR_PRT((L"%s : AllocatePages(%d, 0x%lx) for kernel failed\n", + LD_NAME, pages, low_addr)); + ERR_PRT((L"%s : Could not load kernel at 0x%lx\n", LD_NAME, low_addr)); + ERR_PRT((L"%s : Bailing\n", LD_NAME)); + goto error; + } + return 0; +error: + if (chunks) + free(chunks); + return -1; +} + +/* + * Determine which chunk in the Elf file will be coming out of the expand + * code next. + */ +static void +nextchunk(void) +{ + int i; + segment_t *cp; + + cp = NULL; + for(i=0; i < nchunks; i++) { + + if (!CHUNK_IS_VALID(i) || !CHUNK_IS_LOAD(i)) continue; + + if (file_offset > chunks[i].offset) continue; + + if (cp == NULL || chunks[i].offset < cp->offset) cp = &chunks[i]; + } + cur_chunk = cp; +} + + +/* + * Write the output window window[0..outcnt-1] holding uncompressed + * data and update crc. + */ +void +flush_window(void) +{ + static const CHAR8 helicopter[4] = { '|' , '/' , '-' , '\\' }; + static UINTN heli_count; + struct segment *cp; + char *src, *dst; + long cnt; + + if (!outcnt) return; + + DBG_PRT((L"%s : flush_window outnct=%d file_offset=%ld\n", LD_NAME, outcnt, file_offset)); + + Print(L"%c\b",helicopter[heli_count++%4]); + + updcrc(window, outcnt); + + /* first time, we extract the headers */ + if (!bytes_out) { + if (first_block(window, outcnt) < 0) + error("invalid exec header"); + nextchunk(); + } + + bytes_out += outcnt; + src = window; +tail: + /* check if user wants to abort */ + if (check_abort() == EFI_SUCCESS) goto load_abort; + + cp = cur_chunk; + if (cp == NULL || file_offset + outcnt <= cp->offset) { + file_offset += outcnt; + return; + } + + /* Does this window begin before the current chunk? */ + if (file_offset < cp->offset) { + unsigned long skip = cp->offset - file_offset; + + src += skip; + file_offset += skip; + outcnt -= skip; + } + dst = (char *)cp->addr + (file_offset - cp->offset); + cnt = cp->offset + cp->size - file_offset; + if (cnt > outcnt) + cnt = outcnt; + + Memcpy(dst, src, cnt); + + file_offset += cnt; + outcnt -= cnt; + src += cnt; + + /* See if we are at the end of this chunk */ + if (file_offset == cp->offset + cp->size) { + if (cp->bss_sz) { + dst = (char *)cp->addr + cp->size; + Memset(dst, 0, cp->bss_sz); + } + nextchunk(); + /* handle remaining bytes */ + if (outcnt) + goto tail; + } + return; +load_abort: + free_kmem(); + error_return = ELILO_LOAD_ABORTED; +} + +static void +error(char *x) +{ + ERR_PRT((L"%s : %a", LD_NAME, x)); + /* will eventually exit with error from gunzip() */ +} + +INT32 +decompress_kernel(VOID) +{ + INT32 ret; + + clear_bufs(); + makecrc(); + Print(L"Uncompressing Linux... "); + ret = gunzip(); + if (ret == 0) + Print(L"done\n"); + return ret == 0 ? 0 : -1; +} + +int +gunzip_kernel(fops_fd_t fd, kdesc_t *kd) +{ + int ret = -1; + + error_return = ELILO_LOAD_ERROR; + + window = (void *)alloc(WSIZE, 0); + if (window == NULL) { + ERR_PRT((L"%s : allocate output window failed\n", LD_NAME)); + return -1; + } + + inbuf = (void *)alloc(INBUFSIZE, 0); + if (inbuf == NULL) { + ERR_PRT((L"%s : allocate input window failedr\n", LD_NAME)); + goto error; + } + input_fd = fd; + insize = 0; + bytes_out = 0; + + ret = decompress_kernel(); +error: + if (window) free(window); + if (inbuf) free(inbuf); + + if (ret == 0) { + kd->kentry = kernel_entry; + kd->kend = kernel_end; + kd->kstart = kernel_base; + error_return = ELILO_LOAD_SUCCESS; + } + return error_return; +} diff --git a/x86_64/gzip.h b/x86_64/gzip.h new file mode 100644 index 0000000..cdf4614 --- /dev/null +++ b/x86_64/gzip.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2001-2002 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#ifndef __GZIP_H__ +#define __GZIP_H__ + + +int gzip_probe(unsigned char *, unsigned long); +int gunzip_kernel(fops_fd_t, kdesc_t *); + +#define LD_NAME L"gzip_x86_64" + +#endif /* __GZIP_H__ */ diff --git a/x86_64/gzip_loader.c b/x86_64/gzip_loader.c new file mode 100644 index 0000000..5bf97c7 --- /dev/null +++ b/x86_64/gzip_loader.c @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2001-2002 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#include +#include + +#include "elilo.h" +#include "loader.h" +#include "gzip.h" + +static INTN +gzip_probe_format(CHAR16 *kname) +{ + UINT8 buf[4]; + EFI_STATUS status; + INTN ret = -1; + UINTN size; + fops_fd_t fd; + + status = fops_open(kname, &fd); + if (EFI_ERROR(status)) return -1; + + size = sizeof(buf); + status = fops_read(fd, buf, &size); + + if (EFI_ERROR(status) || size != sizeof(buf)) goto error; + + ret = gzip_probe(buf, sizeof(buf)); +error: + fops_close(fd); + return ret; +} + + +static INTN +gzip_load_kernel(CHAR16 *kname, kdesc_t *kd) +{ + EFI_STATUS status; + INT32 ret; + fops_fd_t fd; + + status = fops_open(kname, &fd); + if (EFI_ERROR(status)) return ELILO_LOAD_ERROR; + + ret = gunzip_kernel(fd, kd); + + fops_close(fd); + + return ret; /* could be success, error, or abort */ +} + +loader_ops_t gzip_loader={ + NULL, + LD_NAME, + gzip_probe_format, + gzip_load_kernel +}; diff --git a/x86_64/inflate.c b/x86_64/inflate.c new file mode 100644 index 0000000..5532250 --- /dev/null +++ b/x86_64/inflate.c @@ -0,0 +1,1205 @@ +#define DEBG(x) +#define DEBG1(x) +/* inflate.c -- Not copyrighted 1992 by Mark Adler + version c10p1, 10 January 1993 */ + +/* + * Adapted for booting Linux by Hannu Savolainen 1993 + * based on gzip-1.0.3 + * + * Nicolas Pitre , 1999/04/14 : + * Little mods for all variable to reside either into rodata or bss segments + * by marking constant variables with 'const' and initializing all the others + * at run-time only. This allows for the kernel uncompressor to run + * directly from Flash or ROM memory on embeded systems. + */ + +/* + Inflate deflated (PKZIP's method 8 compressed) data. The compression + method searches for as much of the current string of bytes (up to a + length of 258) in the previous 32 K bytes. If it doesn't find any + matches (of at least length 3), it codes the next byte. Otherwise, it + codes the length of the matched string and its distance backwards from + the current position. There is a single Huffman code that codes both + single bytes (called "literals") and match lengths. A second Huffman + code codes the distance information, which follows a length code. Each + length or distance code actually represents a base value and a number + of "extra" (sometimes zero) bits to get to add to the base value. At + the end of each deflated block is a special end-of-block (EOB) literal/ + length code. The decoding process is basically: get a literal/length + code; if EOB then done; if a literal, emit the decoded byte; if a + length then get the distance and emit the referred-to bytes from the + sliding window of previously emitted data. + + There are (currently) three kinds of inflate blocks: stored, fixed, and + dynamic. The compressor deals with some chunk of data at a time, and + decides which method to use on a chunk-by-chunk basis. A chunk might + typically be 32 K or 64 K. If the chunk is incompressible, then the + "stored" method is used. In this case, the bytes are simply stored as + is, eight bits per byte, with none of the above coding. The bytes are + preceded by a count, since there is no longer an EOB code. + + If the data is compressible, then either the fixed or dynamic methods + are used. In the dynamic method, the compressed data is preceded by + an encoding of the literal/length and distance Huffman codes that are + to be used to decode this block. The representation is itself Huffman + coded, and so is preceded by a description of that code. These code + descriptions take up a little space, and so for small blocks, there is + a predefined set of codes, called the fixed codes. The fixed method is + used if the block codes up smaller that way (usually for quite small + chunks), otherwise the dynamic method is used. In the latter case, the + codes are customized to the probabilities in the current block, and so + can code it much better than the pre-determined fixed codes. + + The Huffman codes themselves are decoded using a multi-level table + lookup, in order to maximize the speed of decoding plus the speed of + building the decoding tables. See the comments below that precede the + lbits and dbits tuning parameters. + */ + + +/* + Notes beyond the 1.93a appnote.txt: + + 1. Distance pointers never point before the beginning of the output + stream. + 2. Distance pointers can point back across blocks, up to 32k away. + 3. There is an implied maximum of 7 bits for the bit length table and + 15 bits for the actual data. + 4. If only one code exists, then it is encoded using one bit. (Zero + would be more efficient, but perhaps a little confusing.) If two + codes exist, they are coded using one bit each (0 and 1). + 5. There is no way of sending zero distance codes--a dummy must be + sent if there are none. (History: a pre 2.0 version of PKZIP would + store blocks with no distance codes, but this was discovered to be + too harsh a criterion.) Valid only for 1.93a. 2.04c does allow + zero distance codes, which is sent as one code of zero bits in + length. + 6. There are up to 286 literal/length codes. Code 256 represents the + end-of-block. Note however that the static length tree defines + 288 codes just to fill out the Huffman codes. Codes 286 and 287 + cannot be used though, since there is no length base or extra bits + defined for them. Similarly, there are up to 30 distance codes. + However, static trees define 32 codes (all 5 bits) to fill out the + Huffman codes, but the last two had better not show up in the data. + 7. Unzip can check dynamic Huffman blocks for complete code sets. + The exception is that a single code would not be complete (see #4). + 8. The five bits following the block type is really the number of + literal codes sent minus 257. + 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits + (1+6+6). Therefore, to output three times the length, you output + three codes (1+1+1), whereas to output four times the same length, + you only need two codes (1+3). Hmm. + 10. In the tree reconstruction algorithm, Code = Code + Increment + only if BitLength(i) is not zero. (Pretty obvious.) + 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) + 12. Note: length code 284 can represent 227-258, but length code 285 + really is 258. The last length deserves its own, short code + since it gets used a lot in very redundant files. The length + 258 is special since 258 - 3 (the min match length) is 255. + 13. The literal/length and distance code bit lengths are read as a + single stream of lengths. It is possible (and advantageous) for + a repeat code (16, 17, or 18) to go across the boundary between + the two sets of lengths. + */ + +#ifdef RCSID +static char rcsid[] = "#Id: inflate.c,v 0.14 1993/06/10 13:27:04 jloup Exp #"; +#endif + +#ifndef FUNC_STATIC + +#if defined(STDC_HEADERS) || defined(HAVE_STDLIB_H) +# include +# include +#endif + +#include "gzip.h" +#define FUNC_STATIC +#endif /* !FUNC_STATIC */ + +#define slide window + +/* Huffman code lookup table entry--this entry is four bytes for machines + that have 16-bit pointers (e.g. PC's in the small or medium model). + Valid extra bits are 0..13. e == 15 is EOB (end of block), e == 16 + means that v is a literal, 16 < e < 32 means that v is a pointer to + the next table, which codes e - 16 bits, and lastly e == 99 indicates + an unused code. If a code with e == 99 is looked up, this implies an + error in the data. */ +struct huft { + uch e; /* number of extra bits or operation */ + uch b; /* number of bits in this code or subcode */ + union { + ush n; /* literal, length base, or distance base */ + struct huft *t; /* pointer to next level of table */ + } v; +}; + + +/* Function prototypes */ +FUNC_STATIC int huft_build OF((unsigned *, unsigned, unsigned, + const ush *, const ush *, struct huft **, int *)); +FUNC_STATIC int huft_free OF((struct huft *)); +FUNC_STATIC int inflate_codes OF((struct huft *, struct huft *, int, int)); +FUNC_STATIC int inflate_stored OF((void)); +FUNC_STATIC int inflate_fixed OF((void)); +FUNC_STATIC int inflate_dynamic OF((void)); +FUNC_STATIC int inflate_block OF((int *)); +FUNC_STATIC int inflate OF((void)); + + +/* The inflate algorithm uses a sliding 32 K byte window on the uncompressed + stream to find repeated byte strings. This is implemented here as a + circular buffer. The index is updated simply by incrementing and then + ANDing with 0x7fff (32K-1). */ +/* It is left to other modules to supply the 32 K area. It is assumed + to be usable as if it were declared "uch slide[32768];" or as just + "uch *slide;" and then malloc'ed in the latter case. The definition + must be in unzip.h, included above. */ +/* unsigned wp; current position in slide */ +#define wp outcnt +#define flush_output(w) (wp=(w),flush_window()) + +/* Tables for deflate from PKZIP's appnote.txt. */ +static const unsigned border[] = { /* Order of the bit length code lengths */ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; +static const ush cplens[] = { /* Copy lengths for literal codes 257..285 */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + /* note: see note #13 above about the 258 in this list. */ +static const ush cplext[] = { /* Extra bits for literal codes 257..285 */ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */ +static const ush cpdist[] = { /* Copy offsets for distance codes 0..29 */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577}; +static const ush cpdext[] = { /* Extra bits for distance codes */ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, + 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, + 12, 12, 13, 13}; + + + +/* Macros for inflate() bit peeking and grabbing. + The usage is: + + NEEDBITS(j) + x = b & mask_bits[j]; + DUMPBITS(j) + + where NEEDBITS makes sure that b has at least j bits in it, and + DUMPBITS removes the bits from b. The macros use the variable k + for the number of bits in b. Normally, b and k are register + variables for speed, and are initialized at the beginning of a + routine that uses these macros from a global bit buffer and count. + + If we assume that EOB will be the longest code, then we will never + ask for bits with NEEDBITS that are beyond the end of the stream. + So, NEEDBITS should not read any more bytes than are needed to + meet the request. Then no bytes need to be "returned" to the buffer + at the end of the last block. + + However, this assumption is not true for fixed blocks--the EOB code + is 7 bits, but the other literal/length codes can be 8 or 9 bits. + (The EOB code is shorter than other codes because fixed blocks are + generally short. So, while a block always has an EOB, many other + literal/length codes have a significantly lower probability of + showing up at all.) However, by making the first table have a + lookup of seven bits, the EOB code will be found in that first + lookup, and so will not require that too many bits be pulled from + the stream. + */ + +FUNC_STATIC ulg bb; /* bit buffer */ +FUNC_STATIC unsigned bk; /* bits in bit buffer */ + +FUNC_STATIC const ush mask_bits[] = { + 0x0000, + 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, + 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff +}; + +#define NEXTBYTE() (uch)get_byte() +#define NEEDBITS(n) {while(k<(n)){b|=((ulg)NEXTBYTE())<>=(n);k-=(n);} + + +/* + Huffman code decoding is performed using a multi-level table lookup. + The fastest way to decode is to simply build a lookup table whose + size is determined by the longest code. However, the time it takes + to build this table can also be a factor if the data being decoded + is not very long. The most common codes are necessarily the + shortest codes, so those codes dominate the decoding time, and hence + the speed. The idea is you can have a shorter table that decodes the + shorter, more probable codes, and then point to subsidiary tables for + the longer codes. The time it costs to decode the longer codes is + then traded against the time it takes to make longer tables. + + This results of this trade are in the variables lbits and dbits + below. lbits is the number of bits the first level table for literal/ + length codes can decode in one step, and dbits is the same thing for + the distance codes. Subsequent tables are also less than or equal to + those sizes. These values may be adjusted either when all of the + codes are shorter than that, in which case the longest code length in + bits is used, or when the shortest code is *longer* than the requested + table size, in which case the length of the shortest code in bits is + used. + + There are two different values for the two tables, since they code a + different number of possibilities each. The literal/length table + codes 286 possible values, or in a flat code, a little over eight + bits. The distance table codes 30 possible values, or a little less + than five bits, flat. The optimum values for speed end up being + about one bit more than those, so lbits is 8+1 and dbits is 5+1. + The optimum values may differ though from machine to machine, and + possibly even between compilers. Your mileage may vary. + */ + + +FUNC_STATIC const int lbits = 9; /* bits in base literal/length lookup table */ +FUNC_STATIC const int dbits = 6; /* bits in base distance lookup table */ + + +/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */ +#define BMAX 16 /* maximum bit length of any code (16 for explode) */ +#define N_MAX 288 /* maximum number of codes in any set */ + + +FUNC_STATIC unsigned hufts; /* track memory usage */ + + +FUNC_STATIC int huft_build(b, n, s, d, e, t, m) +unsigned *b; /* code lengths in bits (all assumed <= BMAX) */ +unsigned n; /* number of codes (assumed <= N_MAX) */ +unsigned s; /* number of simple-valued codes (0..s-1) */ +const ush *d; /* list of base values for non-simple codes */ +const ush *e; /* list of extra bits for non-simple codes */ +struct huft **t; /* result: starting table */ +int *m; /* maximum lookup bits, returns actual */ +/* Given a list of code lengths and a maximum table size, make a set of + tables to decode that set of codes. Return zero on success, one if + the given code set is incomplete (the tables are still built in this + case), two if the input is invalid (all zero length codes or an + oversubscribed set of lengths), and three if not enough memory. */ +{ + unsigned a; /* counter for codes of length k */ + unsigned c[BMAX+1]; /* bit length count table */ + unsigned f; /* i repeats in table every f entries */ + int g; /* maximum code length */ + int h; /* table level */ + register unsigned i; /* counter, current code */ + register unsigned j; /* counter */ + register int k; /* number of bits in current code */ + int l; /* bits per table (returned in m) */ + register unsigned *p; /* pointer into c[], b[], or v[] */ + register struct huft *q; /* points to current table */ + struct huft r; /* table entry for structure assignment */ + struct huft *u[BMAX]; /* table stack */ + unsigned v[N_MAX]; /* values in order of bit length */ + register int w; /* bits before this table == (l * h) */ + unsigned x[BMAX+1]; /* bit offsets, then code stack */ + unsigned *xp; /* pointer into x */ + int y; /* number of dummy codes added */ + unsigned z; /* number of entries in current table */ + +DEBG("huft1 "); + + /* Generate counts for each bit length */ + memzero(c, sizeof(c)); + + p = b; i = n; + do { + Tracecv(*p, (stderr, (n-i >= ' ' && n-i <= '~' ? "%c %d\n" : "0x%x %d\n"), + n-i, *p)); + c[*p]++; /* assume all entries <= BMAX */ + p++; /* Can't combine with above line (Solaris bug) */ + } while (--i); + if (c[0] == n) /* null input--all zero length codes */ + { + *t = (struct huft *)NULL; + *m = 0; + return 0; + } + +DEBG("huft2 "); + + /* Find minimum and maximum length, bound *m by those */ + l = *m; + for (j = 1; j <= BMAX; j++) + if (c[j]) + break; + k = j; /* minimum code length */ + if ((unsigned)l < j) + l = j; + for (i = BMAX; i; i--) + if (c[i]) + break; + g = i; /* maximum code length */ + if ((unsigned)l > i) + l = i; + *m = l; + +DEBG("huft3 "); + + /* Adjust last length count to fill out codes, if needed */ + for (y = 1 << j; j < i; j++, y <<= 1) + if ((y -= c[j]) < 0) + return 2; /* bad input: more codes than bits */ + if ((y -= c[i]) < 0) + return 2; + c[i] += y; + +DEBG("huft4 "); + + /* Generate starting offsets into the value table for each length */ + x[1] = j = 0; + p = c + 1; xp = x + 2; + while (--i) { /* note that i == g from above */ + *xp++ = (j += *p++); + } + +DEBG("huft5 "); + + /* Make a table of values in order of bit lengths */ + p = b; i = 0; + do { + if ((j = *p++) != 0) + v[x[j]++] = i; + } while (++i < n); + +DEBG("h6 "); + + /* Generate the Huffman codes and for each, make the table entries */ + x[0] = i = 0; /* first Huffman code is zero */ + p = v; /* grab values in bit order */ + h = -1; /* no tables yet--level -1 */ + w = -l; /* bits decoded == (l * h) */ + u[0] = (struct huft *)NULL; /* just to keep compilers happy */ + q = (struct huft *)NULL; /* ditto */ + z = 0; /* ditto */ +DEBG("h6a "); + + /* go through the bit lengths (k already is bits in shortest code) */ + for (; k <= g; k++) + { +DEBG("h6b "); + a = c[k]; + while (a--) + { +DEBG("h6b1 "); + /* here i is the Huffman code of length k bits for value *p */ + /* make tables up to required level */ + while (k > w + l) + { +DEBG1("1 "); + h++; + w += l; /* previous table always l bits */ + + /* compute minimum size table less than or equal to l bits */ + z = (z = g - w) > (unsigned)l ? l : z; /* upper limit on table size */ + if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ + { /* too few codes for k-w bit table */ +DEBG1("2 "); + f -= a + 1; /* deduct codes from patterns left */ + xp = c + k; + while (++j < z) /* try smaller tables up to z bits */ + { + if ((f <<= 1) <= *++xp) + break; /* enough codes to use up j bits */ + f -= *xp; /* else deduct codes from patterns */ + } + } +DEBG1("3 "); + z = 1 << j; /* table entries for j-bit table */ + + /* allocate and link in new table */ + if ((q = (struct huft *)gzip_malloc((z + 1)*sizeof(struct huft))) == + (struct huft *)NULL) + { + if (h) + huft_free(u[0]); + return 3; /* not enough memory */ + } +DEBG1("4 "); + hufts += z + 1; /* track memory usage */ + *t = q + 1; /* link to list for huft_free() */ + *(t = &(q->v.t)) = (struct huft *)NULL; + u[h] = ++q; /* table starts after link */ + +DEBG1("5 "); + /* connect to last table, if there is one */ + if (h) + { + x[h] = i; /* save pattern for backing up */ + r.b = (uch)l; /* bits to dump before this table */ + r.e = (uch)(16 + j); /* bits in this table */ + r.v.t = q; /* pointer to this table */ + j = i >> (w - l); /* (get around Turbo C bug) */ + u[h-1][j] = r; /* connect to last table */ + } +DEBG1("6 "); + } +DEBG("h6c "); + + /* set up table entry in r */ + r.b = (uch)(k - w); + if (p >= v + n) + r.e = 99; /* out of values--invalid code */ + else if (*p < s) + { + r.e = (uch)(*p < 256 ? 16 : 15); /* 256 is end-of-block code */ + r.v.n = (ush)(*p); /* simple code is just the value */ + p++; /* one compiler does not like *p++ */ + } + else + { + r.e = (uch)e[*p - s]; /* non-simple--look up in lists */ + r.v.n = d[*p++ - s]; + } +DEBG("h6d "); + + /* fill code-like entries with r */ + f = 1 << (k - w); + for (j = i >> w; j < z; j += f) + q[j] = r; + + /* backwards increment the k-bit code i */ + for (j = 1 << (k - 1); i & j; j >>= 1) + i ^= j; + i ^= j; + + /* backup over finished tables */ + while ((i & ((1 << w) - 1)) != x[h]) + { + h--; /* don't need to update q */ + w -= l; + } +DEBG("h6e "); + } +DEBG("h6f "); + } + +DEBG("huft7 "); + + /* Return true (1) if we were given an incomplete table */ + return y != 0 && g != 1; +} + + + +FUNC_STATIC int huft_free(t) +struct huft *t; /* table to free */ +/* Free the malloc'ed tables built by huft_build(), which makes a linked + list of the tables it made, with the links in a dummy first entry of + each table. */ +{ + register struct huft *p, *q; + + + /* Go through linked list, freeing from the malloced (t[-1]) address. */ + p = t; + while (p != (struct huft *)NULL) + { + q = (--p)->v.t; + gzip_free((char*)p); + p = q; + } + return 0; +} + + +FUNC_STATIC int inflate_codes(tl, td, bl, bd) +struct huft *tl, *td; /* literal/length and distance decoder tables */ +int bl, bd; /* number of bits decoded by tl[] and td[] */ +/* inflate (decompress) the codes in a deflated (compressed) block. + Return an error code or zero if it all goes ok. */ +{ + register unsigned e; /* table entry flag/number of extra bits */ + unsigned n, d; /* length and index for copy */ + unsigned w; /* current window position */ + struct huft *t; /* pointer to table entry */ + unsigned ml, md; /* masks for bl and bd bits */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + + /* make local copies of globals */ + b = bb; /* initialize bit buffer */ + k = bk; + w = wp; /* initialize window position */ + + /* inflate the coded data */ + ml = mask_bits[bl]; /* precompute masks for speed */ + md = mask_bits[bd]; + for (;;) /* do until end of block */ + { + NEEDBITS((unsigned)bl) + if ((e = (t = tl + ((unsigned)b & ml))->e) > 16) + do { + if (e == 99) + return 1; + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16); + DUMPBITS(t->b) + if (e == 16) /* then it's a literal */ + { + slide[w++] = (uch)t->v.n; + Tracevv((stderr, "%c", slide[w-1])); + if (w == WSIZE) + { + flush_output(w); + w = 0; + } + } + else /* it's an EOB or a length */ + { + /* exit if end of block */ + if (e == 15) + break; + + /* get length of block to copy */ + NEEDBITS(e) + n = t->v.n + ((unsigned)b & mask_bits[e]); + DUMPBITS(e); + + /* decode distance of block to copy */ + NEEDBITS((unsigned)bd) + if ((e = (t = td + ((unsigned)b & md))->e) > 16) + do { + if (e == 99) + return 1; + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16); + DUMPBITS(t->b) + NEEDBITS(e) + d = w - t->v.n - ((unsigned)b & mask_bits[e]); + DUMPBITS(e) + Tracevv((stderr,"\\[%d,%d]", w-d, n)); + + /* do the copy */ + do { + n -= (e = (e = WSIZE - ((d &= WSIZE-1) > w ? d : w)) > n ? n : e); +#if !defined(NOMEMCPY) && !defined(INFLATE_DEBUG) + if (w - d >= e) /* (this test assumes unsigned comparison) */ + { + memcpy(slide + w, slide + d, e); + w += e; + d += e; + } + else /* do it slow to avoid memcpy() overlap */ +#endif /* !NOMEMCPY */ + do { + slide[w++] = slide[d++]; + Tracevv((stderr, "%c", slide[w-1])); + } while (--e); + if (w == WSIZE) + { + flush_output(w); + w = 0; + } + } while (n); + } + } + + + /* restore the globals from the locals */ + wp = w; /* restore global window pointer */ + bb = b; /* restore global bit buffer */ + bk = k; + + /* done */ + return 0; +} + + + +FUNC_STATIC int inflate_stored() +/* "decompress" an inflated type 0 (stored) block. */ +{ + unsigned n; /* number of bytes in block */ + unsigned w; /* current window position */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + +DEBG(""); + return 0; +} + + + +FUNC_STATIC int inflate_fixed() +/* decompress an inflated type 1 (fixed Huffman codes) block. We should + either replace this with a custom decoder, or at least precompute the + Huffman tables. */ +{ + int i; /* temporary variable */ + struct huft *tl; /* literal/length code table */ + struct huft *td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned l[288]; /* length list for huft_build */ + +DEBG(" 1) + { + huft_free(tl); + + DEBG(">"); + return i; + } + + + /* decompress until an end-of-block code */ + if (inflate_codes(tl, td, bl, bd)) + return 1; + + + /* free the decoding tables, return */ + huft_free(tl); + huft_free(td); + return 0; +} + + + +FUNC_STATIC int inflate_dynamic() +/* decompress an inflated type 2 (dynamic Huffman codes) block. */ +{ + int i; /* temporary variables */ + unsigned j; + unsigned l; /* last length */ + unsigned m; /* mask for bit lengths table */ + unsigned n; /* number of lengths to get */ + struct huft *tl; /* literal/length code table */ + struct huft *td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned nb; /* number of bit length codes */ + unsigned nl; /* number of literal/length codes */ + unsigned nd; /* number of distance codes */ +#ifdef PKZIP_BUG_WORKAROUND + unsigned ll[288+32]; /* literal/length and distance code lengths */ +#else + unsigned ll[286+30]; /* literal/length and distance code lengths */ +#endif + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + +DEBG(" 288 || nd > 32) +#else + if (nl > 286 || nd > 30) +#endif + return 1; /* bad lengths */ + +DEBG("dyn1 "); + + /* read in bit-length-code lengths */ + for (j = 0; j < nb; j++) + { + NEEDBITS(3) + ll[border[j]] = (unsigned)b & 7; + DUMPBITS(3) + } + for (; j < 19; j++) + ll[border[j]] = 0; + +DEBG("dyn2 "); + + /* build decoding table for trees--single level, 7 bit lookup */ + bl = 7; + if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) + { + if (i == 1) + huft_free(tl); + return i; /* incomplete code set */ + } + +DEBG("dyn3 "); + + /* read in literal and distance code lengths */ + n = nl + nd; + m = mask_bits[bl]; + i = l = 0; + while ((unsigned)i < n) + { + NEEDBITS((unsigned)bl) + j = (td = tl + ((unsigned)b & m))->b; + DUMPBITS(j) + j = td->v.n; + if (j < 16) /* length of code in bits (0..15) */ + ll[i++] = l = j; /* save last length in l */ + else if (j == 16) /* repeat last length 3 to 6 times */ + { + NEEDBITS(2) + j = 3 + ((unsigned)b & 3); + DUMPBITS(2) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = l; + } + else if (j == 17) /* 3 to 10 zero length codes */ + { + NEEDBITS(3) + j = 3 + ((unsigned)b & 7); + DUMPBITS(3) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = 0; + l = 0; + } + else /* j == 18: 11 to 138 zero length codes */ + { + NEEDBITS(7) + j = 11 + ((unsigned)b & 0x7f); + DUMPBITS(7) + if ((unsigned)i + j > n) + return 1; + while (j--) + ll[i++] = 0; + l = 0; + } + } + +DEBG("dyn4 "); + + /* free decoding table for trees */ + huft_free(tl); + +DEBG("dyn5 "); + + /* restore the global bit buffer */ + bb = b; + bk = k; + +DEBG("dyn5a "); + + /* build the decoding tables for literal/length and distance codes */ + bl = lbits; + if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) + { +DEBG("dyn5b "); + if (i == 1) { + error(" incomplete literal tree\n"); + huft_free(tl); + } + return i; /* incomplete code set */ + } +DEBG("dyn5c "); + bd = dbits; + if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) + { +DEBG("dyn5d "); + if (i == 1) { + error(" incomplete distance tree\n"); +#ifdef PKZIP_BUG_WORKAROUND + i = 0; + } +#else + huft_free(td); + } + huft_free(tl); + return i; /* incomplete code set */ +#endif + } + +DEBG("dyn6 "); + + /* decompress until an end-of-block code */ + if (inflate_codes(tl, td, bl, bd)) + return 1; + +DEBG("dyn7 "); + + /* free the decoding tables, return */ + huft_free(tl); + huft_free(td); + + DEBG(">"); + return 0; +} + + + +FUNC_STATIC int inflate_block(e) +int *e; /* last block flag */ +/* decompress an inflated block */ +{ + unsigned t; /* block type */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + DEBG(""); + + /* bad block type */ + return 2; +} + + + +FUNC_STATIC int inflate() +/* decompress an inflated entry */ +{ + int e; /* last block flag */ + int r; /* result code */ + unsigned h; /* maximum struct huft's malloc'ed */ + + /* initialize window, bit buffer */ + wp = 0; + bk = 0; + bb = 0; + + + /* decompress until the last block */ + h = 0; + do { + hufts = 0; + if ((r = inflate_block(&e)) != 0) { + return r; + } + if (hufts > h) + h = hufts; + } while (!e); + + /* Undo too much lookahead. The next read will be byte aligned so we + * can discard unused bits in the last meaningful byte. + */ + while (bk >= 8) { + bk -= 8; + inptr--; + } + + /* flush out slide */ + flush_output(wp); + + + /* return success */ +#ifdef INFLATE_DEBUG +#ifdef EFI_COMPILE + Print(L"<%d> ", h); +#else + printf("<%d> ", h); +#endif +#endif /* INFLATE_DEBUG */ + return 0; +} + +/********************************************************************** + * + * The following are support routines for inflate.c + * + **********************************************************************/ + +static ulg crc_32_tab[256]; +static ulg crc; /* initialized in makecrc() so it'll reside in bss */ +#define CRC_VALUE (crc ^ 0xffffffffUL) + +/* + * Code to compute the CRC-32 table. Borrowed from + * gzip-1.0.3/makecrc.c. + */ + +static void +makecrc(void) +{ +/* Not copyrighted 1990 Mark Adler */ + + unsigned long c; /* crc shift register */ + unsigned long e; /* polynomial exclusive-or pattern */ + int i; /* counter for all possible eight bit values */ + int k; /* byte being shifted into crc apparatus */ + + /* terms of polynomial defining this crc (except x^32): */ + static const int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* Make exclusive-or pattern from polynomial */ + e = 0; + for (i = 0; i < sizeof(p)/sizeof(int); i++) + e |= 1L << (31 - p[i]); + + crc_32_tab[0] = 0; + + for (i = 1; i < 256; i++) + { + c = 0; + for (k = i | 256; k != 1; k >>= 1) + { + c = c & 1 ? (c >> 1) ^ e : c >> 1; + if (k & 1) + c ^= e; + } + crc_32_tab[i] = c; + } + + /* this is initialized here so this code could reside in ROM */ + crc = (ulg)0xffffffffUL; /* shift register contents */ +} + +/* gzip flag byte */ +#define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */ +#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */ +#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ +#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ +#define COMMENT 0x10 /* bit 4 set: file comment present */ +#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ +#define RESERVED 0xC0 /* bit 6,7: reserved */ + +/* + * check for valid gzip signature + * return: + * 0 : valid gzip archive + * -1: invalid gzip archive + */ +int +gzip_probe(uch *buf, unsigned long size) +{ + /* FIXME this is wrong here! FIXME!!!!*/ + if (size < 4) return -1; + + if (buf[0] != 037 || + ((buf[1] != 0213) && (buf[1] != 0236))) return -1; + + /* We only support method #8, DEFLATED */ + if (buf[2] != 8) return -1; + + if ((buf[3] & ENCRYPTED) != 0) return -1; + + if ((buf[3] & CONTINUATION) != 0) return -1; + + if ((buf[3] & RESERVED) != 0) return -1; + + return 0; +} + + +/* + * Do the uncompression! + */ +static int gunzip(void) +{ + uch flags; + unsigned char magic[2]; /* magic header */ + char method; + ulg orig_crc = 0; /* original crc */ + ulg orig_len = 0; /* original uncompressed length */ + int res; + + magic[0] = (unsigned char)get_byte(); + magic[1] = (unsigned char)get_byte(); + method = (unsigned char)get_byte(); + + if (magic[0] != 037 || + ((magic[1] != 0213) && (magic[1] != 0236))) { + error("bad gzip magic numbers"); + return -1; + } + + /* We only support method #8, DEFLATED */ + if (method != 8) { + error("internal error, invalid method"); + return -1; + } + + flags = (uch)get_byte(); + if ((flags & ENCRYPTED) != 0) { + error("Input is encrypted\n"); + return -1; + } + if ((flags & CONTINUATION) != 0) { + error("Multi part input\n"); + return -1; + } + if ((flags & RESERVED) != 0) { + error("Input has invalid flags\n"); + return -1; + } + (ulg)get_byte(); /* Get timestamp */ + ((ulg)get_byte()) << 8; + ((ulg)get_byte()) << 16; + ((ulg)get_byte()) << 24; + + (void)get_byte(); /* Ignore extra flags for the moment */ + (void)get_byte(); /* Ignore OS type for the moment */ + + if ((flags & EXTRA_FIELD) != 0) { + unsigned len = (unsigned)get_byte(); + len |= ((unsigned)get_byte())<<8; + while (len--) (void)get_byte(); + } + + /* Get original file name if it was truncated */ + if ((flags & ORIG_NAME) != 0) { + /* Discard the old name */ + while (get_byte() != 0) /* null */ ; + } + + /* Discard file comment if any */ + if ((flags & COMMENT) != 0) { + while (get_byte() != 0) /* null */ ; + } + + /* Decompress */ + if ((res = inflate())) { + switch (res) { + case 0: + break; + case 1: + error("invalid compressed format (err=1)"); + break; + case 2: + error("invalid compressed format (err=2)"); + break; + case 3: + error("out of memory"); + break; + default: + error("invalid compressed format (other)"); + } + return -1; + } + + /* Get the crc and original length */ + /* crc32 (see algorithm.doc) + * uncompressed input size modulo 2^32 + */ + orig_crc = (ulg) get_byte(); + orig_crc |= (ulg) get_byte() << 8; + orig_crc |= (ulg) get_byte() << 16; + orig_crc |= (ulg) get_byte() << 24; + + orig_len = (ulg) get_byte(); + orig_len |= (ulg) get_byte() << 8; + orig_len |= (ulg) get_byte() << 16; + orig_len |= (ulg) get_byte() << 24; + + /* Validate decompression */ + if (orig_crc != CRC_VALUE) { + error("crc error"); + return -1; + } + if (orig_len != bytes_out) { + error("length error"); + return -1; + } + return 0; +} + + diff --git a/x86_64/plain_loader.c b/x86_64/plain_loader.c new file mode 100644 index 0000000..13cc9e5 --- /dev/null +++ b/x86_64/plain_loader.c @@ -0,0 +1,302 @@ +/* + * Copyright (C) 2001-2002 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * + * Copyright (C) 2001 Silicon Graphics, Inc. + * Contributed by Brent Casavant + * + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#include +#include + +#include "elilo.h" +#include "loader.h" +#include "elf.h" +#include "private.h" + +#define LD_NAME L"plain_elf64" + +static INTN +is_valid_header(Elf64_Ehdr *ehdr) +{ + UINT16 type, machine; + + type = ehdr->e_type; + machine = ehdr->e_machine; + + DBG_PRT((L"class=%d type=%d data=%d machine=%d\n", + ehdr->e_ident[EI_CLASS], + type, + ehdr->e_ident[EI_DATA], + machine)); + + return ehdr->e_ident[EI_MAG0] == 0x7f + && ehdr->e_ident[EI_MAG1] == 'E' + && ehdr->e_ident[EI_MAG2] == 'L' + && ehdr->e_ident[EI_MAG3] == 'F' + && ehdr->e_ident[EI_CLASS] == ELFCLASS64 + && type == ET_EXEC /* must be executable */ + && machine == EM_X86_64? 0 : -1; +} + +static INTN +plain_probe(CHAR16 *kname) +{ + Elf64_Ehdr ehdr; + EFI_STATUS status; + INTN ret = -1; + fops_fd_t fd; + UINTN size = sizeof(ehdr); + + status = fops_open(kname, &fd); + if (EFI_ERROR(status)) + return -1; + + VERB_PRT(3, { + Print(L"plain_probe: kname=%s\n", kname); + }); + status = fops_read(fd, &ehdr, &size); + if (EFI_ERROR(status) || size != sizeof(ehdr)) + goto error; + + ret = is_valid_header(&ehdr); +error: + fops_close(fd); + return ret; +} + + +static INTN +load_elf(fops_fd_t fd, kdesc_t *kd) +{ + Elf64_Ehdr ehdr; + Elf64_Phdr *phdrs; + EFI_STATUS status; + INTN ret = ELILO_LOAD_ERROR; + UINTN i, total_size = 0; + UINTN pages, size, bss_sz, osize; + VOID *low_addr = (VOID *)~0; + VOID *max_addr = (VOID *)0; + UINTN paddr, memsz, filesz; + UINT16 phnum; + + Print(L"Loading Linux... "); + + size = sizeof(ehdr); + + status = fops_read(fd, &ehdr, &size); + if (EFI_ERROR(status) || size < sizeof(ehdr)) + return ELILO_LOAD_ERROR; + + if (is_valid_header(&ehdr) == -1) { + ERR_PRT((L"%s : not a 64-bit ELF image\n", LD_NAME)); + return ELILO_LOAD_ERROR; + } + VERB_PRT(3, { + Print(L"ELF Header information: \n"); + Print(L"\tEntry point 0x%x\n", (ehdr.e_entry & PADDR_MASK)); + Print(L"\t%d program headers\n", ehdr.e_phnum); + Print(L"\t%d segment headers\n", ehdr.e_shnum); + }); + + phnum = ehdr.e_phnum; + + if (fops_seek(fd, ehdr.e_phoff) < 0) { + ERR_PRT((L"%s : seek to %d for phdrs failed", LD_NAME, ehdr.e_phoff)); + return ELILO_LOAD_ERROR; + } + size = osize = (phnum * sizeof(Elf64_Phdr)); + + DBG_PRT((L"%s : allocate %d bytes for %d pheaders each of size:%d phentsize=%d\n", + LD_NAME, size, phnum, sizeof(Elf64_Phdr), ehdr.e_phentsize)); + + phdrs = (Elf64_Phdr *)alloc(size, 0); + if (phdrs == NULL) { + ERR_PRT((L"%s : allocate for phdrs failed", LD_NAME)); + return ELILO_LOAD_ERROR; + } + status = fops_read(fd, phdrs, &size); + if (EFI_ERROR(status) || size != osize) { + ERR_PRT((L"%s : phdr load failed", LD_NAME, status)); + goto out; + } + /* + * First pass to figure out total memory footprint + */ + for (i = 0; i < phnum; i++) { + + paddr = (phdrs[i].p_paddr & PADDR_MASK); + memsz = phdrs[i].p_memsz; + + DBG_PRT((L"Phdr %d paddr [0x%x-0x%x] offset 0x%x" + " filesz 0x%x memsz=0x%x bss_sz=0x%x p_type=0x%x\n", + 1+i, paddr, paddr+phdrs[i].p_filesz, phdrs[i].p_offset, + phdrs[i].p_filesz, memsz, + (memsz - phdrs[i].p_filesz), phdrs[i].p_type)); + + if (phdrs[i].p_type != PT_LOAD) + continue; + if (paddr < (UINTN)low_addr) + low_addr = (VOID *)paddr; + if (paddr + memsz > (UINTN)max_addr) + max_addr = (VOID *)paddr + memsz; + } + + if ((UINTN)low_addr & (EFI_PAGE_SIZE - 1)) { + ERR_PRT((L"%s : kernel low address 0x%x not page aligned\n", + LD_NAME, low_addr)); + goto out; + } + /* how many bytes are needed to hold the kernel? */ + total_size = (UINTN)max_addr - (UINTN)low_addr; + + /* round up to get required number of pages */ + pages = EFI_SIZE_TO_PAGES(total_size); + + /* keep track of location where kernel starts and ends */ + kd->kstart = low_addr; + kd->kend = (low_addr + (pages << EFI_PAGE_SHIFT)); + kd->kentry = (VOID *)(ehdr.e_entry & PADDR_MASK); + + VERB_PRT(3, { + Print(L"Lowest PhysAddr: 0x%x\nTotalMemSize:%d bytes (%d pages)\n", + low_addr, total_size, pages); + Print(L"Kernel entry @ 0x%x\n", kd->kentry); + }); + + /* now allocate memory for the kernel at the exact requested spot */ + if (alloc_kmem(low_addr, pages) == -1) { + ERR_PRT((L"%s : AllocatePages(%d, 0x%lx) for kernel failed\n", + LD_NAME, pages, low_addr)); + ERR_PRT((L"%s : Could not alloc %d pages for the kernel at 0x%lx " + " and relocation is not not been implemented!\n", + LD_NAME, pages, low_addr)); + goto load_abort; + } + /* Pure paranoia. Clear the memory first. Just in case... */ + Memset(low_addr, 0, (pages << EFI_PAGE_SHIFT)); + + VERB_PRT(1, Print(L"Press any key to interrupt\n")); + + /* + * Walk through the program headers + * and actually load data into physical memory + */ + + for (i = 0; i < phnum; i++) { + /* Check for pure loadable segment; ignore if not loadable */ + if (phdrs[i].p_type != PT_LOAD) + continue; + + VERB_PRT(3, Print(L"poffs: 0x%x (phdrs[%d].p_offset)\n", + phdrs[i].p_offset, i)); + + filesz = phdrs[i].p_filesz; + low_addr = (VOID *)((UINTN) phdrs[i].p_paddr & PADDR_MASK); + + /* Move to the right position */ + if (fops_seek(fd, phdrs[i].p_offset) < 0) + goto out_kernel; + + /* How many BSS bytes to clear */ + bss_sz = phdrs[i].p_memsz - filesz; + + VERB_PRT(4, { + Print(L"\nHeader #%d\n", i); + Print(L"Offset in file 0x%x\n", phdrs[i].p_offset); + Print(L"Physical addr 0x%x\n", low_addr); + Print(L"BSS size 0x%x bytes\n", bss_sz); + }); + + /* + * Read actual segment into memory + */ + ret = fops_read(fd, low_addr, &filesz); + if (ret == ELILO_LOAD_ABORTED) goto load_abort; + if (ret == ELILO_LOAD_ERROR) goto out; + + /* + * Clear bss section + */ + if (bss_sz) + Memset((VOID *)low_addr+filesz, 0, bss_sz); + } + + free(phdrs); + return ELILO_LOAD_SUCCESS; + +load_abort: + Print(L"..Aborted\n"); + ret = ELILO_LOAD_ABORTED; +out_kernel: + /* free kernel memory */ + free_kmem(); +out: + free(phdrs); + return ret; +} + +static INTN +plain_load_kernel(CHAR16 *kname, kdesc_t *kd) +{ + INTN ret; + fops_fd_t fd; + EFI_STATUS status; + + /* + * Moving the open here simplifies the load_elf() error handling + */ + status = fops_open(kname, &fd); + if (EFI_ERROR(status)) return ELILO_LOAD_ERROR; + + Print(L"Loading %s...", kname); + + ret = load_elf(fd, kd); + + fops_close(fd); + return ret; +} + +loader_ops_t plain_loader={ + NULL, + LD_NAME, + plain_probe, + plain_load_kernel +}; + +/*void plain_loader_init() +{ + loader_ops_t plain={ + NULL, + LD_NAME, + plain_probe, + plain_load_kernel + }; + *plain_loader=*plain; +}*/ + diff --git a/x86_64/private.h b/x86_64/private.h new file mode 100644 index 0000000..ddb1d52 --- /dev/null +++ b/x86_64/private.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2001-2003 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * + * Copyright (C) 2006-2009 Intel Corporation + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +#ifndef __ELILO_PRIVATE_X86_64_H__ +#define __ELILO_PRIVATE_X86_64_H__ + +#endif /* __ELILO_PRIVATE_X86_64_H__ */ + diff --git a/x86_64/rmswitch.S b/x86_64/rmswitch.S new file mode 100644 index 0000000..24fd402 --- /dev/null +++ b/x86_64/rmswitch.S @@ -0,0 +1,118 @@ +# +# Switch from protected mode to real mode and jump to setup.S +# image located at %cx:0. +# +# This module must be placed into physical memory at 0:7C00h. +# EFI has some real mode thunking code at 2000:0h. +# +# Processor and non-maskable interrupts should be disabled +# before control is passed to this module. +# + +.global _start + +.code32 +.text +_start: + # + # Load identity mapped GDT & real mode IDT. + # Add 7C00h to the addresses since this is linked to start + # at 0h and it is being placed at 7C00h. + # + + lgdt %cs:gdt_48 + 0x7C00 + lidt %cs:idt_48 + 0x7C00 + + # + # Turn off PG bit in CR0 and set CR3 to zero. + # + + movl %cr0, %eax + andl $0x7FFFFFFF, %eax + movl %eax, %cr0 + + xorl %eax, %eax + movl %eax, %cr3 + + # + # Reload CS. + # Now we add 7B00h because we need to force the segment + # address and selector to be the same. + # + + .byte 0xEA + .long pm_reload + 0x7B00 + .word 0x10 + +pm_reload: + +.code16 + + # + # Reload DS, ES, FS, GS & SS. + # + + movw $0x18, %ax + movw %ax, %ds + movw %ax, %es + movw %ax, %fs + movw %ax, %gs + movw %ax, %ss + + # + # Switch to real mode. Clear PE bit in CR0. + # + + movl %cr0, %eax + andl $0xFFFFFFFE, %eax + movl %eax, %cr0 + + # + # Reload CS. + # + + .byte 0xEA + .word rm_reload + 0x7C00 + .word 0 + +rm_reload: + + # + # Reload SS & SP. + # + + xorw %ax, %ax + movw %ax, %ss + movw $0x7BFE, %sp + + # + # Start running setup.S + # + + .byte 0xEA + .word 0 + .word 0x9020 + + # + # GDT & IDT stuff for switching into real mode. + # + +gdt: .word 0, 0, 0, 0 # unused (00h) + .word 0, 0, 0, 0 # dummy (08h) + .word 0xFFFF, 0x100 # code (10h) + .word 0x9A00, 0 + .word 0xFFFF, 0x180 # data (18h) + .word 0x9200, 0 + +gdt_48: .word 0x08 * 0x400 + .long gdt + 0x7C00 + +idt_48: .word 0x400 + .long 0 + + # + # Be careful not to exceed 1F0h or the the bootsect.S + # parameters will be lost! + # + +.end diff --git a/x86_64/sysdeps.h b/x86_64/sysdeps.h new file mode 100644 index 0000000..df86f44 --- /dev/null +++ b/x86_64/sysdeps.h @@ -0,0 +1,451 @@ +/* + * Copyright (C) 2001-2003 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * Contributed by Mike Johnston + * Contributed by Chris Ahna + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by Chandramouli Narayanan + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +/* + * This file is used to define all the x86_64-specific data structures + * and constant used by the generic ELILO + */ +#ifndef __ELILO_SYSDEPS_X86_64_H__ +#define __ELILO_SYSDEPS_X86_64_H__ + +#define ELILO_ARCH "x86_64" /* ASCII string */ +#define PADDR_MASK 0xfffffff + +/* for now use library versions */ +#define Memset(a,v,n) SetMem((a),(n),(v)) +#define Memcpy(a,b,n) CopyMem((a),(b),(n)) + +/* Put initrd to far away from kernel image to avoid conflict. + * May need to adjust this number if it is not big enough. + */ +#define INITRD_START (50*1024*1024) + +/* + * This version must match the one in the kernel. + * + * This table was put together using information from the + * following Linux kernel source files: + * linux/include/tty.h + * linux/arch/i386/kernel/setup.c + * linux/arch/i386/boot/bootsect.S + * linux/arch/i386/boot/setup.S + * linux/arch/i386/boot/video.S + * + * New fields in this structure for EFI and ELILO are: + * efi_loader_sig + * efi_st_addr + * + * A new bit, LDRFLAG_BOOT_PARAM_RELOC, in the loader_flags + * field is also defined in this file. + */ + +#pragma pack(1) + +/* Definitions for converting EFI memory map to E820 map for Linux + * These definitions are from include/linux/asm-x86_64/e820.h + * The structure x86_64_boot_params below is updated to accommodate E820 map + * EFI memory map is converted to E820 map in this structure and passed + * to Linux. This way the OS does not need to do the conversion. + */ +#define E820_RAM 1 +#define E820_RESERVED 2 +#define E820_ACPI 3 +#define E820_NVS 4 +#define E820_EXEC_CODE 5 +#define E820_MAX 128 + +struct e820entry { + UINT64 addr; /* start of memory segment */ + UINT64 size; /* size of memory segment */ + UINT32 type; /* type of memory segment */ +} __attribute__((packed)); + + +typedef union x86_64_boot_params { + UINT8 raw[0x2000]; + struct { +/* Cursor position before passing control to kernel. */ +/* 0x00 */ UINT8 orig_cursor_col; /* LDR */ +/* 0x01 */ UINT8 orig_cursor_row; /* LDR */ + +/* Available contiguous extended memory in KB. */ +/* 0x02 */ UINT16 ext_mem_k; /* LDR */ + +/* Video page, mode and screen width before passing control to kernel. */ +/* 0x04 */ UINT16 orig_video_page; /* LDR */ +/* 0x06 */ UINT8 orig_video_mode; /* LDR */ +/* 0x07 */ UINT8 orig_video_cols; /* LDR */ + +/* 0x08 */ UINT16 unused_1; /* unused */ + +/* %%TBD */ +/* 0x0A */ UINT16 orig_ega_bx; /* LDR */ + +/* 0x0C */ UINT16 unused_2; /* unused */ + +/* Screen height before passing control to kernel. */ +/* 0x0E */ UINT8 orig_video_rows; /* LDR */ + +/* %%TBD */ +/* 0x0F */ UINT8 is_vga; /* LDR */ +/* 0x10 */ UINT16 orig_video_points; /* LDR */ + +/* %%TBD */ +/* 0x12 */ UINT16 lfb_width; /* LDR */ +/* 0x14 */ UINT16 lfb_height; /* LDR */ +/* 0x16 */ UINT16 lfb_depth; /* LDR */ +/* 0x18 */ UINT32 lfb_base; /* LDR */ +/* 0x1C */ UINT32 lfb_size; /* LDR */ + +/* Offset of command line (from start of ia32_boot_param struct). */ +/* The command line magik number must be set for the kernel setup */ +/* code to use the command line offset. */ +/* 0x20 */ UINT16 cmdline_magik; /* LDR */ +#define CMDLINE_MAGIK 0xA33F +/* 0x22 */ UINT16 cmdline_offset; /* LDR */ + +/* %%TBD */ +/* 0x24 */ UINT16 lfb_line_len; /* LDR */ + +/* %%TBD */ +/* 0x26 */ UINT8 lfb_red_size; /* LDR */ +/* 0x27 */ UINT8 lfb_red_pos; /* LDR */ +/* 0x28 */ UINT8 lfb_green_size; /* LDR */ +/* 0x29 */ UINT8 lfb_green_pos; /* LDR */ +/* 0x2A */ UINT8 lfb_blue_size; /* LDR */ +/* 0x2B */ UINT8 lfb_blue_pos; /* LDR */ +/* 0x2C */ UINT8 lfb_rsvd_size; /* LDR */ +/* 0x2D */ UINT8 lfb_rsvd_pos; /* LDR */ + +/* %%TBD */ +/* 0x2E */ UINT16 vesa_seg; /* LDR */ +/* 0x30 */ UINT16 vesa_off; /* LDR */ + +/* %%TBD */ +/* 0x32 */ UINT16 lfb_pages; /* LDR */ +/* 0x34 */ UINT8 lfb_reserved[0x0C]; /* reserved */ + +/* %%TBD */ +/* 0x40 */ UINT16 apm_bios_ver; /* LDR */ +#define NO_APM_BIOS 0x0000 + +/* %%TBD */ +/* 0x42 */ UINT16 bios_code_seg; /* LDR */ +/* 0x44 */ UINT32 bios_entry_point; /* LDR */ +/* 0x48 */ UINT16 bios_code_seg16; /* LDR */ +/* 0x4A */ UINT16 bios_data_seg; /* LDR */ + +/* %%TBD */ +/* 0x4C */ UINT16 apm_bios_flags; /* LDR */ +#define NO_32BIT_APM_MASK 0xFFFD + +/* %%TBD */ +/* 0x4E */ UINT32 bios_code_len; /* LDR */ +/* 0x52 */ UINT16 bios_data_len; /* LDR */ + +/* 0x54 */ UINT8 unused_3[0x2C]; /* unused */ + +/* %%TBD */ +/* 0x80 */ UINT8 hd0_info[0x10]; /* LDR */ +/* 0x90 */ UINT8 hd1_info[0x10]; /* LDR */ + +/* %%TBD */ +/* 0xA0 */ UINT16 mca_info_len; /* LDR */ +/* 0xA2 */ UINT8 mca_info_buf[0x10]; /* LDR */ + +/* 0xB2 */ UINT8 unused_4[0x106]; /* unused */ + +/* Address of the EFI system table. */ +/* 0x1B8 */ UINT64 efi_sys_tbl; /* LDR */ + +/* EFI boot loader signature. */ +/* 0x1C0 */ UINT8 efi_loader_sig[4]; /* LDR */ +#define EFI_LOADER_SIG "EFIL" + +/* EFI memory descriptor size. */ +/* 0x1C4 */ UINT32 efi_mem_desc_size; /* LDR */ + +/* EFI memory descriptor version. */ +/* 0x1C8 */ UINT32 efi_mem_desc_ver; /* LDR */ + +/* Address & size of EFI memory map. */ +/* 0x1CC */ UINT32 efi_mem_map_size; /* LDR */ +/* 0x1D0 */ UINT64 efi_mem_map; /* LDR */ + +/* Address & size of loader. */ +/* 0x1D8 */ UINT32 loader_start; /* LDR */ +/* 0x1DC */ UINT32 loader_size; /* LDR */ + +/* Available contiguous extended memory in KB. */ +/* 0x1E0 */ UINT32 alt_mem_k; /* LDR */ + +/* 0x1E4 */ UINT32 unused_51; /* unused */ +/* 0x1E8 */ UINT8 e820_nrmap; +/* 0x1E9 */ UINT32 unused_52[2]; /* unused */ + +/* Size of setup code in sectors (1 sector == 512 bytes). */ +/* 0x1F1 */ UINT8 setup_sectors; /* BLD */ + +/* %%TBD */ +/* 0x1F2 */ UINT16 mount_root_rdonly; /* BLD */ + +/* %%TBD */ +/* 0x1F4 */ UINT16 sys_size; /* BLD */ + +/* %%TBD */ +/* 0x1F6 */ UINT16 swap_dev; /* BLD */ + +/* %%TBD */ +/* 0x1F8 */ UINT16 ramdisk_flags; /* BLD */ +#define RAMDISK_PROMPT 0x8000 +#define RAMDISK_LOAD 0x4000 + +/* %%TBD */ +/* 0x1FA */ UINT16 video_mode_flag; /* BLD */ + +/* %%TBD */ +/* 0x1FC */ UINT16 orig_root_dev; /* BLD */ + +/* 0x1FE */ UINT8 unused_6; /* unused */ + +/* %%TBD */ +/* 0x1FF */ UINT8 aux_dev_info; /* LDR */ +#define NO_MOUSE 0x00 +#define FOUND_MOUSE 0xAA + +/* Jump past setup data (not used in EFI). */ +/* 0x200 */ UINT16 jump; /* BLD */ + +/* Setup data signature. */ +/* 0x202 */ UINT8 setup_sig[4]; /* BLD */ +#define SETUP_SIG "HdrS" + +/* %%TBD */ +/* 0x206 */ UINT8 hdr_minor; /* BLD */ +/* 0x207 */ UINT8 hdr_major; /* BLD */ + +/* %%TBD */ +/* 0x208 */ UINT32 rm_switch; /* LDD */ + +/* %%TBD */ +/* 0x20C */ UINT16 start_sys_seg; /* BLD */ + +/* %%TBD */ +/* 0x20E */ UINT16 kernel_verstr_offset; /* BLD */ + +/* Loader type & version. */ +/* 0x210 */ UINT8 loader_type; /* LDR */ +#define LDRTYPE_ELILO 0x50 /* 5?h == elilo */ + /* ?0h == revision */ + +/* 0x211 */ UINT8 loader_flags; /* BLD and LDR */ +#define LDRFLAG_CAN_USE_HEAP 0x80 +#define LDRFLAG_BOOT_PARAM_RELOC 0x40 + +/* %%TBD */ +/* 0x212 */ UINT16 setup_move_size; /* BLD */ + +/* %%TBD */ +/* 0x214 */ UINT32 kernel_start; /* LDR */ + +/* %%TBD */ +/* 0x218 */ UINT32 initrd_start; /* LDR */ +/* 0x21C */ UINT32 initrd_size; /* LDR */ + +/* %%TBD */ +/* 0x220 */ UINT32 bootsect_helper; /* BLD */ + +/* %%TBD */ +/* 0x224 */ UINT16 heap_end_ptr; /* LDR */ + +/* %%TBD */ +/* 0x226 */ UINT16 unused_7; /* LDR */ + +/* 0x228 */ UINT32 cmdline_addr; /* LDR */ +/* 0x22C */ UINT32 unused_8[41]; +/* 0x2D0 */ UINT8 e820_map[2560]; + } s; +} boot_params_t; +#pragma pack() + +/* + * The stuff below here is for jumping to the kernel. + */ + +/* + * Some macros to copy and set memory after EFI has been + * stopped. + */ + +#define MEMCPY(to, from, cnt) { \ + UINT8 *t = (UINT8 *)(to); \ + UINT8 *f = (UINT8 *)(from); \ + UINTN n = cnt; \ + if (t && f && n) { \ + while (n--) { \ + *t++ = *f++; \ + } \ + } \ +} + +#define MEMSET(ptr, size, val) { \ + UINT8 *p = (UINT8 *)(ptr); \ + UINTN n = (UINTN)(size); \ + UINT8 v = (UINT8)(val); \ + if (p && n) { \ + while (n--) { \ + *p++ = v; \ + } \ + } \ +} + +/* + * Descriptor table pointer format. + */ +#pragma pack(1) +typedef struct { + UINT16 limit; + UINT64 base; +} dt_addr_t; +#pragma pack() + +extern UINTN high_base_mem; +extern UINTN high_ext_mem; + +extern boot_params_t *param_start; +extern UINTN param_size; + +extern VOID *kernel_start; +extern UINTN kernel_size; + +extern VOID *initrd_start; +extern UINTN initrd_size; + +extern dt_addr_t gdt_addr; +extern dt_addr_t idt_addr; + +extern UINT16 init_gdt[]; +extern UINTN sizeof_init_gdt; + +extern UINT8 rmswitch_image[]; +extern UINTN rmswitch_size; + +extern INTN x86_64_use_legacy_free_boot(); + +/* + * How to jump to kernel code + */ + + +static inline void +start_kernel(VOID *kentry, boot_params_t *bp) +{ + struct { + UINT32 kernel_entry; + UINT16 kernel_cs; + } jumpvector; + UINTN njump; + VOID *jump_start; + + /* + * Disable interrupts. + */ + asm volatile ( "cli" : : ); + + /* + * Relocate initrd, if present. + */ + + if (bp->s.initrd_start) { + MEMCPY(INITRD_START, bp->s.initrd_start, bp->s.initrd_size); + bp->s.initrd_start = INITRD_START; + } + /* + * Copy boot sector, setup data and command line + * to final resting place. We need to copy + * BOOT_PARAM_MEMSIZE bytes. + */ + + MEMCPY(high_base_mem, bp, 0x4000); + + /* + * Initialize Linux GDT. + */ + + MEMSET(gdt_addr.base, gdt_addr.limit, 0); + MEMCPY(gdt_addr.base, init_gdt, sizeof_init_gdt); + +// fixme: why x86_64_use_legacy_free_boot() goes to _relocate? +#if 0 + if (! x86_64_use_legacy_free_boot()) { + + /* + * Copy our real mode transition code to 0x7C00. + */ + + MEMCPY(0x7C00, rmswitch_image, rmswitch_size); + + asm volatile ( "mov $0x7C00, %%rbx" : : ); + asm volatile ( "jmp *%%rbx" : : ); + } +#endif + + /* + * Load descriptor table pointers. + */ + + asm volatile ( "lidt %0" : : "m" (idt_addr) ); + asm volatile ( "lgdt %0" : : "m" (gdt_addr) ); + + /* + * rsi := address of boot sector and setup data + */ + + asm volatile ( "mov %0, %%rsi" : : "m" (high_base_mem) ); + + /* + * Jump to kernel entry point. + */ + jumpvector.kernel_entry=kentry; + jumpvector.kernel_cs=0x10; + njump = &jumpvector; + jump_start = (VOID *)&jumpvector; + //asm volatile ( "mov %0, %%rcx" : : "m" (&jumpvector) ); + asm volatile ( "mov %0, %%rcx" : : "m" (jump_start) ); + //asm volatile ( "mov %0, %%rcx" : : "m" (njump) ); + asm volatile ( "ljmp *(%%rcx)" : :); + /* Never come back to here. */ +} + +typedef struct sys_img_options { + UINT8 nothing_yet; +} sys_img_options_t; + +#endif /* __ELILO_SYSDEPS_X86_64_H__ */ diff --git a/x86_64/system.c b/x86_64/system.c new file mode 100644 index 0000000..0755ff4 --- /dev/null +++ b/x86_64/system.c @@ -0,0 +1,772 @@ +/* + * Copyright (C) 2001-2003 Hewlett-Packard Co. + * Contributed by Stephane Eranian + * Contributed by Mike Johnston + * Contributed by Chris Ahna + * Contributed by Fenghua Yu + * Contributed by Bibo Mao + * Contributed by chandramouli narayanan + * Edgar Hucek + * + * Updated with code to fill bootparam converting EFI memory map to E820 + * based on a Linux kernel patch provided by Edgar Hucek + * - mouli 06/20/2007 + * + * This file is part of the ELILO, the EFI Linux boot loader. + * + * ELILO is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * ELILO is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ELILO; see the file COPYING. If not, write to the Free + * Software Foundation, 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Please check out the elilo.txt for complete documentation on how + * to use this program. + */ + +/* + * This file contains all the x86_64 specific code expected by generic loader + */ +#include +#include + +#include "elilo.h" +#include "loader.h" +#include "rmswitch.h" + +extern loader_ops_t bzimage_loader, plain_loader, gzip_loader; + +/* + * Descriptor table base addresses & limits for Linux startup. + */ + +dt_addr_t gdt_addr = { 0x800, 0x94000 }; +dt_addr_t idt_addr = { 0, 0 }; + +/* + * Initial GDT layout for Linux startup. + */ + +UINT16 init_gdt[] = { + /* gdt[0]: dummy */ + 0, 0, 0, 0, + + /* gdt[1]: unused */ + 0, 0, 0, 0, + + /* gdt[2]: code */ + 0xFFFF, /* 4Gb - (0x100000*0x1000 = 4Gb) */ + 0x0000, /* base address=0 */ + 0x9A00, /* code read/exec */ + 0x00CF, /* granularity=4096, 386 (+5th nibble of limit) */ + + /* gdt[3]: data */ + 0xFFFF, /* 4Gb - (0x100000*0x1000 = 4Gb) */ + 0x0000, /* base address=0 */ + 0x9200, /* data read/write */ + 0x00CF, /* granularity=4096, 386 (+5th nibble of limit) */ +}; + +UINTN sizeof_init_gdt = sizeof init_gdt; + +/* + * Highest available base memory address. + * + * For traditional kernels and loaders this is always at 0x90000. + * For updated kernels and loaders this is computed by taking the + * highest available base memory address and rounding down to the + * nearest 64 kB boundary and then subtracting 64 kB. + * + * A non-compressed kernel is automatically assumed to be an updated + * kernel. A compressed kernel that has bit 6 (0x40) set in the + * loader_flags field is also assumed to be an updated kernel. + */ + +UINTN high_base_mem = 0x90000; + +/* + * Highest available extended memory address. + * + * This is computed by taking the highest available extended memory + * address and rounding down to the nearest EFI_PAGE_SIZE (usually + * 4 kB) boundary. + * This is only used for backward compatibility. + */ + +UINTN high_ext_mem = 32 * 1024 * 1024; + +/* This starting address will hold true for all of the loader types for now */ +VOID *kernel_start = (VOID *)0x100000; /* 1M */ + +VOID *initrd_start = NULL; +UINTN initrd_size = 0; + +INTN +sysdeps_init(EFI_HANDLE dev) +{ + DBG_PRT((L"sysdeps_init()\n")); + + /* + * Register our loader(s)... + */ + + loader_register(&bzimage_loader); + loader_register(&plain_loader); + loader_register(&gzip_loader); + return 0; +} + +/* + * initrd_get_addr() + * Compute a starting address for the initial RAMdisk image. + * For now, this image is placed immediately after the end of + * the kernel memory. Inside the start_kernel() code, the + * RAMdisk image will be relocated to the top of available + * extended memory. + */ +INTN +sysdeps_initrd_get_addr(kdesc_t *kd, memdesc_t *imem) +{ + DBG_PRT((L"initrd_get_addr()\n")); + + if (!kd || !imem) { + ERR_PRT((L"kd=0x%x imem=0x%x", kd, imem)); + return -1; + } + + VERB_PRT(3, Print(L"kstart=0x%x kentry=0x%x kend=0x%x\n", + kd->kstart, kd->kentry, kd->kend)); + + imem->start_addr = kd->kend; + + VERB_PRT(3, Print(L"initrd start_addr=0x%x pgcnt=%d\n", + imem->start_addr, imem->pgcnt)); + + return 0; +} + +VOID +sysdeps_free_boot_params(boot_params_t *bp) +{ + mmap_desc_t md; + + ZeroMem(&md, sizeof md); + md.md = (VOID *)bp->s.efi_mem_map; + free_memmap(&md); +} + +static VOID find_bits(unsigned long mask, UINT8 *first, UINT8* len) { + unsigned char bit_pos = 0, bit_len = 0; + *first =0; + *len = 0; + if (mask == 0) + return; + while (!(mask & 0x1)) { + mask = mask >> 1; + bit_pos++; + } + while (mask & 0x1) { + mask = mask >> 1; + bit_len++; + } + *first = bit_pos; + *len = bit_len; +} + +/* + * Get video information. + */ +static INTN get_video_info(boot_params_t * bp) { + EFI_GUID GopProtocol = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID; + EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop_interface; + EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Gop_info; + EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *Gop_mode; + EFI_HANDLE *Gop_handle; + EFI_STATUS efi_status; + UINTN size, size1; + UINT8 i; + + efi_status = uefi_call_wrapper( + BS->LocateHandle, + 5, + ByProtocol, + &GopProtocol, + NULL, + &size, + (VOID **)Gop_handle); + + if (EFI_ERROR(efi_status) && efi_status != EFI_BUFFER_TOO_SMALL) { + ERR_PRT((L"LocateHandle GopProtocol failed.")); + return -1; + } + Gop_handle = alloc(size, 0); + efi_status = uefi_call_wrapper( + BS->LocateHandle, + 5, + ByProtocol, + &GopProtocol, + NULL, + &size, + (VOID **)Gop_handle); + if (EFI_ERROR(efi_status)) { + ERR_PRT((L"LocateHandle GopProtocol failed.")); + free(Gop_handle); + return -1; + } + + for (i=0; i < size/sizeof(EFI_HANDLE); i++) { + Gop_handle += i; + efi_status = uefi_call_wrapper( + BS->HandleProtocol, + 3, + *Gop_handle, + &GopProtocol, + &Gop_interface); + + if (EFI_ERROR(efi_status)) { + continue; + } + Gop_mode = Gop_interface->Mode; + efi_status = uefi_call_wrapper( + Gop_interface->QueryMode, + 4, + Gop_interface, + Gop_mode->Mode, + &size1, + &Gop_info); + if (!EFI_ERROR(efi_status)) + break; + if (EFI_ERROR(efi_status)) { + continue; + } + } + if (EFI_ERROR(efi_status) || i > (size/sizeof(EFI_HANDLE))) { + ERR_PRT((L"HandleProtocol GopProtocol failed.")); + free(Gop_handle); + return -1; + } + + bp->s.is_vga = 0x24; + bp->s.orig_cursor_col = 0; + bp->s.orig_cursor_row = 0; + bp->s.orig_video_page = 0; + bp->s.orig_video_mode = 0; + bp->s.orig_video_cols = 0; + bp->s.orig_video_rows = 0; + bp->s.orig_ega_bx = 0; + bp->s.orig_video_points = 0; + + bp->s.lfb_width = Gop_info->HorizontalResolution; + bp->s.lfb_height = Gop_info->VerticalResolution; + bp->s.lfb_base = Gop_mode->FrameBufferBase; + bp->s.lfb_size = Gop_mode->FrameBufferSize; + bp->s.lfb_pages = 1; + bp->s.vesa_seg = 0; + bp->s.vesa_off = 0; + if (Gop_info->PixelFormat == PixelRedGreenBlueReserved8BitPerColor) { + bp->s.lfb_depth = 32; + bp->s.lfb_red_size = 8; + bp->s.lfb_red_pos = 0; + bp->s.lfb_green_size = 8; + bp->s.lfb_green_pos = 8; + bp->s.lfb_blue_size = 8; + bp->s.lfb_blue_pos = 16; + bp->s.lfb_rsvd_size = 8; + bp->s.lfb_rsvd_pos = 24; + bp->s.lfb_line_len = Gop_info->PixelsPerScanLine * 4; + + } else if (Gop_info->PixelFormat == PixelBlueGreenRedReserved8BitPerColor) { + bp->s.lfb_depth = 32; + bp->s.lfb_red_size = 8; + bp->s.lfb_red_pos = 16; + bp->s.lfb_green_size = 8; + bp->s.lfb_green_pos = 8; + bp->s.lfb_blue_size = 8; + bp->s.lfb_blue_pos = 0; + bp->s.lfb_rsvd_size = 8; + bp->s.lfb_rsvd_pos = 24; + bp->s.lfb_line_len = Gop_info->PixelsPerScanLine * 4; + } else if (Gop_info->PixelFormat == PixelBitMask) { + find_bits(Gop_info->PixelInformation.RedMask, + &bp->s.lfb_red_pos, &bp->s.lfb_red_size); + find_bits(Gop_info->PixelInformation.GreenMask, + &bp->s.lfb_green_pos, &bp->s.lfb_green_size); + find_bits(Gop_info->PixelInformation.BlueMask, + &bp->s.lfb_blue_pos, &bp->s.lfb_blue_size); + find_bits(Gop_info->PixelInformation.ReservedMask, + &bp->s.lfb_rsvd_pos, &bp->s.lfb_rsvd_size); + bp->s.lfb_depth = bp->s.lfb_red_size + bp->s.lfb_green_size + + bp->s.lfb_blue_size + bp->s.lfb_rsvd_size; + bp->s.lfb_line_len = (Gop_info->PixelsPerScanLine * bp->s.lfb_depth) / 8; + } else { + bp->s.lfb_depth = 4; + bp->s.lfb_red_size = 0; + bp->s.lfb_red_pos = 0; + bp->s.lfb_green_size = 0; + bp->s.lfb_green_pos = 0; + bp->s.lfb_blue_size = 0; + bp->s.lfb_blue_pos = 0; + bp->s.lfb_rsvd_size = 0; + bp->s.lfb_rsvd_pos = 0; + bp->s.lfb_line_len = bp->s.lfb_width / 2; + } + return 0; +} + +/* Convert EFI memory map to E820 map for the operating system + * This code is based on a Linux kernel patch submitted by Edgar Hucek + */ + +void fill_e820map(boot_params_t *bp, mmap_desc_t *mdesc) +{ + int nr_map, i; + UINT64 start, end, size; + EFI_MEMORY_DESCRIPTOR *md, *p; + struct e820entry *e820_map; + + nr_map = mdesc->map_size/mdesc->desc_size; + e820_map = (struct e820entry *)bp->s.e820_map; + bp->s.e820_nrmap = nr_map; + + for (i = 0, p = mdesc->md; i < nr_map; i++) + { + md = p; + switch (md->Type) { + case EfiACPIReclaimMemory: + e820_map->addr = md->PhysicalStart; + e820_map->size = md->NumberOfPages << EFI_PAGE_SHIFT; + e820_map->type = E820_ACPI; + break; + case EfiRuntimeServicesCode: + e820_map->addr = md->PhysicalStart; + e820_map->size = md->NumberOfPages << EFI_PAGE_SHIFT; + e820_map->type = E820_EXEC_CODE; + break; + case EfiRuntimeServicesData: + case EfiReservedMemoryType: + case EfiMemoryMappedIO: + case EfiMemoryMappedIOPortSpace: + case EfiUnusableMemory: + case EfiPalCode: + e820_map->addr = md->PhysicalStart; + e820_map->size = md->NumberOfPages << EFI_PAGE_SHIFT; + e820_map->type = E820_RESERVED; + break; + case EfiLoaderCode: + case EfiLoaderData: + case EfiBootServicesCode: + case EfiBootServicesData: + case EfiConventionalMemory: + start = md->PhysicalStart; + size = md->NumberOfPages << EFI_PAGE_SHIFT; + end = start + size; + /* Fix up for BIOS that claims RAM in 640K-1MB region */ + if (start < 0x100000ULL && end > 0xA0000ULL) { + if (start < 0xA0000ULL) { + /* start < 640K + * set memory map from start to 640K + */ + e820_map->addr = start; + e820_map->size = 0xA0000ULL-start; + e820_map->type = E820_RAM; + e820_map++; + } + if (end <= 0x100000ULL) + continue; + /* end > 1MB + * set memory map avoiding 640K to 1MB hole + */ + start = 0x100000ULL; + size = end - start; + } + e820_map->addr = start; + e820_map->size = size; + e820_map->type = E820_RAM; + break; + case EfiACPIMemoryNVS: + e820_map->addr = md->PhysicalStart; + e820_map->size = md->NumberOfPages << EFI_PAGE_SHIFT; + e820_map->type = E820_NVS; + break; + default: + /* We should not hit this case */ + e820_map->addr = md->PhysicalStart; + size = md->NumberOfPages << EFI_PAGE_SHIFT; + e820_map->type = E820_RESERVED; + break; + } + e820_map++; + p = NextMemoryDescriptor(p, mdesc->desc_size); + } + +} +/* + * x86_64 specific boot parameters initialization routine + */ +INTN +sysdeps_create_boot_params( + boot_params_t *bp, + CHAR8 *cmdline, + memdesc_t *initrd, + memdesc_t *vmcode, + UINTN *cookie) +{ + mmap_desc_t mdesc; + EFI_STATUS efi_status; + UINTN rows, cols; + UINT8 row, col; + UINT8 mode; + UINT16 hdr_version; + + DBG_PRT((L"fill_boot_params()\n")); + + if (!bp || !cmdline || !initrd || !cookie) { + ERR_PRT((L"bp=0x%x cmdline=0x%x initrd=0x%x cookie=0x%x", + bp, cmdline, initrd, cookie)); + + if (param_start != NULL) { + free(param_start); + param_start = NULL; + param_size = 0; + } + free_kmem(); + return -1; + } + + /* + * Copy temporary boot sector and setup data storage to + * elilo allocated boot parameter storage. We only need + * the first two sectors (1K). The rest of the storage + * can be used by the command line. + */ + if (param_start != NULL) { + CopyMem(bp, param_start, 0x2000); + free(param_start); + param_start = NULL; + param_size = 0; + } + /* + * Save off our header revision information. + */ + hdr_version = (bp->s.hdr_major << 8) | bp->s.hdr_minor; + + /* + * Clear out unused memory in boot sector image. + */ + bp->s.unused_1 = 0; + bp->s.unused_2 = 0; + ZeroMem(bp->s.unused_3, sizeof bp->s.unused_3); + ZeroMem(bp->s.unused_4, sizeof bp->s.unused_4); + ZeroMem(bp->s.unused_51, sizeof bp->s.unused_51); + ZeroMem(bp->s.unused_52, sizeof bp->s.unused_52); + bp->s.unused_6 = 0; + bp->s.unused_7 = 0; + ZeroMem(bp->s.unused_8, sizeof bp->s.unused_8); + + /* + * Tell kernel this was loaded by an advanced loader type. + * If this field is zero, the initrd_start and initrd_size + * fields are ignored by the kernel. + */ + + bp->s.loader_type = LDRTYPE_ELILO; + + /* + * Setup command line information. + */ + + bp->s.cmdline_magik = CMDLINE_MAGIK; + bp->s.cmdline_offset = (UINT8 *)cmdline - (UINT8 *)bp; + + /* + * Clear out the cmdline_addr field so the kernel can find + * the cmdline. + */ + bp->s.cmdline_addr = 0x0; + + /* + * Setup hard drive parameters. + * %%TBD - It should be okay to zero fill the hard drive + * info buffers. The kernel should do its own detection. + */ + + ZeroMem(bp->s.hd0_info, sizeof bp->s.hd0_info); + ZeroMem(bp->s.hd1_info, sizeof bp->s.hd1_info); + + /* + * Memory info. + */ + + bp->s.alt_mem_k = high_ext_mem / 1024; + + if (bp->s.alt_mem_k <= 65535) + bp->s.ext_mem_k = (UINT16)bp->s.alt_mem_k; + else + bp->s.ext_mem_k = 65535; + + /* + * Initial RAMdisk and root device stuff. + */ + + DBG_PRT((L"initrd->start_addr=0x%x initrd->pgcnt=%d\n", + initrd->start_addr, initrd->pgcnt)); + + /* These RAMdisk flags are not needed, just zero them. */ + bp->s.ramdisk_flags = 0; + + if (initrd->start_addr && initrd->pgcnt) { + /* %%TBD - This will probably have to be changed. */ + bp->s.initrd_start = (UINT32)initrd->start_addr; + bp->s.initrd_size = (UINT32)(initrd->size); + /* + * This is the RAMdisk root device for RedHat 2.2.x + * kernels (major 0x01, minor 0x00). + */ + + bp->s.orig_root_dev = 0x0100; + } else { + bp->s.initrd_start = 0; + bp->s.initrd_size = 0; + } + + /* + * APM BIOS info. + */ + bp->s.apm_bios_ver = NO_APM_BIOS; + bp->s.bios_code_seg = 0; + bp->s.bios_entry_point = 0; + bp->s.bios_code_seg16 = 0; + bp->s.bios_data_seg = 0; + bp->s.apm_bios_flags = 0; + bp->s.bios_code_len = 0; + bp->s.bios_data_len = 0; + + /* + * MCA BIOS info (misnomer). + */ + bp->s.mca_info_len = 0; + ZeroMem(bp->s.mca_info_buf, sizeof bp->s.mca_info_buf); + + /* + * Pointing device presence. The kernel will detect this. + */ + bp->s.aux_dev_info = NO_MOUSE; + + /* + * EFI loader signature + */ + CopyMem(bp->s.efi_loader_sig, EFI_LOADER_SIG, 4); + + /* + * Kernel entry point. + */ + bp->s.kernel_start = (UINT32)kernel_start; + + /* + * When changing stuff in the parameter structure compare + * the offsets of the fields with the offsets used in the + * boot sector and setup source files. + * arch/x86_64/boot/bootsect.S + * arch/x86_64/boot/setup.S + * arch/x86_64/kernel/setup.c + * include/asm-x86_64/setup.h (2.5/2.6) + */ + +#define CHECK_OFFSET(n, o, f) \ +{ \ + UINTN p = (UINT8 *)&bp->s.n - (UINT8 *)bp; \ + UINTN q = (UINTN)(o); \ + if (p != q) { \ + test |= 1; \ + Print(L"%20a: %3xh %3xh ", #n, p, q); \ + if (*f) { \ + Print(f, bp->s.n); \ + } \ + Print(L"\n"); \ + } \ +} + +#define WAIT_FOR_KEY() \ +{ \ + EFI_INPUT_KEY key; \ + while (uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn, &key) != EFI_SUCCESS) { \ + ; \ + } \ +} + { + UINTN test = 0; + + CHECK_OFFSET(orig_cursor_col, 0x00, L"%xh"); + CHECK_OFFSET(orig_cursor_row, 0x01, L"%xh"); + CHECK_OFFSET(ext_mem_k, 0x02, L"%xh"); + CHECK_OFFSET(orig_video_page, 0x04, L"%xh"); + CHECK_OFFSET(orig_video_mode, 0x06, L"%xh"); + CHECK_OFFSET(orig_video_cols, 0x07, L"%xh"); + CHECK_OFFSET(orig_ega_bx, 0x0A, L"%xh"); + CHECK_OFFSET(orig_video_rows, 0x0E, L"%xh"); + CHECK_OFFSET(is_vga, 0x0F, L"%xh"); + CHECK_OFFSET(orig_video_points, 0x10, L"%xh"); + CHECK_OFFSET(lfb_width, 0x12, L"%xh"); + CHECK_OFFSET(lfb_height, 0x14, L"%xh"); + CHECK_OFFSET(lfb_depth, 0x16, L"%xh"); + CHECK_OFFSET(lfb_base, 0x18, L"%xh"); + CHECK_OFFSET(lfb_size, 0x1C, L"%xh"); + CHECK_OFFSET(cmdline_magik, 0x20, L"%xh"); + CHECK_OFFSET(cmdline_offset, 0x22, L"%xh"); + CHECK_OFFSET(lfb_line_len, 0x24, L"%xh"); + CHECK_OFFSET(lfb_red_size, 0x26, L"%xh"); + CHECK_OFFSET(lfb_red_pos, 0x27, L"%xh"); + CHECK_OFFSET(lfb_green_size, 0x28, L"%xh"); + CHECK_OFFSET(lfb_green_pos, 0x29, L"%xh"); + CHECK_OFFSET(lfb_blue_size, 0x2A, L"%xh"); + CHECK_OFFSET(lfb_blue_pos, 0x2B, L"%xh"); + CHECK_OFFSET(lfb_rsvd_size, 0x2C, L"%xh"); + CHECK_OFFSET(lfb_rsvd_pos, 0x2D, L"%xh"); + CHECK_OFFSET(vesa_seg, 0x2E, L"%xh"); + CHECK_OFFSET(vesa_off, 0x30, L"%xh"); + CHECK_OFFSET(lfb_pages, 0x32, L"%xh"); + CHECK_OFFSET(lfb_reserved, 0x34, L""); + CHECK_OFFSET(apm_bios_ver, 0x40, L"%xh"); + CHECK_OFFSET(bios_code_seg, 0x42, L"%xh"); + CHECK_OFFSET(bios_entry_point, 0x44, L"%xh"); + CHECK_OFFSET(bios_code_seg16, 0x48, L"%xh"); + CHECK_OFFSET(bios_data_seg, 0x4A, L"%xh"); + CHECK_OFFSET(apm_bios_flags, 0x4C, L"%xh"); + CHECK_OFFSET(bios_code_len, 0x4E, L"%xh"); + CHECK_OFFSET(bios_data_len, 0x52, L"%xh"); + CHECK_OFFSET(hd0_info, 0x80, L""); + CHECK_OFFSET(hd1_info, 0x90, L""); + CHECK_OFFSET(mca_info_len, 0xA0, L"%xh"); + CHECK_OFFSET(mca_info_buf, 0xA2, L""); + CHECK_OFFSET(efi_sys_tbl, 0x1B8, L"%xh"); + CHECK_OFFSET(efi_loader_sig, 0x1C0, L"'%-4.4a'"); + CHECK_OFFSET(efi_mem_desc_size, 0x1C4, L"%xh"); + CHECK_OFFSET(efi_mem_desc_ver, 0x1C8, L"%xh"); + CHECK_OFFSET(efi_mem_map_size, 0x1CC, L"%xh"); + CHECK_OFFSET(efi_mem_map, 0x1D0, L"%xh"); + CHECK_OFFSET(loader_start, 0x1D8, L"%xh"); + CHECK_OFFSET(loader_size, 0x1DC, L"%xh"); + CHECK_OFFSET(alt_mem_k, 0x1E0, L"%xh"); + CHECK_OFFSET(setup_sectors, 0x1F1, L"%xh"); + CHECK_OFFSET(mount_root_rdonly, 0x1F2, L"%xh"); + CHECK_OFFSET(sys_size, 0x1F4, L"%xh"); + CHECK_OFFSET(swap_dev, 0x1F6, L"%xh"); + CHECK_OFFSET(ramdisk_flags, 0x1F8, L"%xh"); + CHECK_OFFSET(video_mode_flag, 0x1FA, L"%xh"); + CHECK_OFFSET(orig_root_dev, 0x1FC, L"%xh"); + CHECK_OFFSET(aux_dev_info, 0x1FF, L"%xh"); + CHECK_OFFSET(jump, 0x200, L"%xh"); + CHECK_OFFSET(setup_sig, 0x202, L"'%-4.4a'"); + CHECK_OFFSET(hdr_minor, 0x206, L"%xh"); + CHECK_OFFSET(hdr_major, 0x207, L"%xh"); + CHECK_OFFSET(rm_switch, 0x208, L"%xh"); + CHECK_OFFSET(start_sys_seg, 0x20C, L"%xh"); + CHECK_OFFSET(kernel_verstr_offset, 0x20E, L"%xh"); + CHECK_OFFSET(loader_type, 0x210, L"%xh"); + CHECK_OFFSET(loader_flags, 0x211, L"%xh"); + CHECK_OFFSET(setup_move_size, 0x212, L"%xh"); + CHECK_OFFSET(kernel_start, 0x214, L"%xh"); + CHECK_OFFSET(initrd_start, 0x218, L"%xh"); + CHECK_OFFSET(initrd_size, 0x21C, L"%xh"); + CHECK_OFFSET(bootsect_helper, 0x220, L"%xh"); + CHECK_OFFSET(heap_end_ptr, 0x224, L"%xh"); + CHECK_OFFSET(cmdline_addr, 0x228, L"%xh"); + + if (test) { + ERR_PRT((L"Boot sector and/or setup parameter alignment error.")); + free_kmem(); + return -1; + } + } + + /* + * Get video information. + * Do this last so that any other cursor positioning done + * in the fill routine gets accounted for. + */ + + if (!get_video_info(bp)) goto do_memmap; + + /* Do the old text mode */ + efi_status = uefi_call_wrapper( + ST->ConOut->QueryMode, + 4, + ST->ConOut, + ST->ConOut->Mode->Mode, + &cols, + &rows); + + if (EFI_ERROR(efi_status)) { + ERR_PRT((L"QueryMode failed. Fake it.")); + mode = 3; + rows = 25; + cols = 80; + row = 24; + col = 0; + } else { + mode = (UINT8)ST->ConOut->Mode->Mode; + col = (UINT8)ST->ConOut->Mode->CursorColumn; + row = (UINT8)ST->ConOut->Mode->CursorRow; + } + + bp->s.orig_cursor_col = col; + bp->s.orig_cursor_row = row; + bp->s.orig_video_page = 0; + bp->s.orig_video_mode = mode; + bp->s.orig_video_cols = (UINT8)cols; + bp->s.orig_video_rows = (UINT8)rows; + + bp->s.orig_ega_bx = 0; + bp->s.is_vga = 0; + bp->s.orig_video_points = 16; + + bp->s.lfb_width = 0; + bp->s.lfb_height = 0; + bp->s.lfb_depth = 0; + bp->s.lfb_base = 0; + bp->s.lfb_size = 0; + bp->s.lfb_line_len = 0; + bp->s.lfb_red_size = 0; + bp->s.lfb_red_pos = 0; + bp->s.lfb_green_size = 0; + bp->s.lfb_green_pos = 0; + bp->s.lfb_blue_size = 0; + bp->s.lfb_blue_pos = 0; + bp->s.lfb_rsvd_size = 0; + bp->s.lfb_rsvd_pos = 0; + bp->s.lfb_pages = 0; + bp->s.vesa_seg = 0; + bp->s.vesa_off = 0; + +do_memmap: + /* + * Get memory map description and cookie for ExitBootServices() + */ + + if (get_memmap(&mdesc)) { + ERR_PRT((L"Could not get memory map.")); + free_kmem(); + return -1; + } + *cookie = mdesc.cookie; + bp->s.efi_mem_map = (UINTN)mdesc.md; + bp->s.efi_mem_map_size = mdesc.map_size; + bp->s.efi_mem_desc_size = mdesc.desc_size; + bp->s.efi_mem_desc_ver = mdesc.desc_version; + bp->s.efi_sys_tbl = (UINTN)systab; + /* Now that we have EFI memory map, convert it to E820 map + * and update the bootparam accordingly + */ + fill_e820map(bp, &mdesc); + + return 0; +}