From 97b2a7df25b918c7279cd8de59ed272684d5c336 Mon Sep 17 00:00:00 2001 From: Stephane Eranian Date: Fri, 20 Jul 2007 09:30:47 -0400 Subject: [PATCH] release 3.7 https://sourceforge.net/projects/elilo/files/elilo/3.7/ --- ChangeLog | 74 + Make.defaults | 11 +- Make.rules | 3 + Makefile | 6 + README | 15 +- README.gnu-efi | 34 + alloc.c | 19 +- alternate.c | 7 +- bootparams.c | 2 +- choosers/simple.c | 11 +- choosers/textmenu.c | 15 +- config.c | 13 +- cscope.out | 135421 +++++++++++++++++++++++++++++++++++++++ docs/elilo.txt | 46 +- elf.h | 1 + elilo-ia32.efi | Bin 203222 -> 202915 bytes elilo-ia64.efi | Bin 374212 -> 355910 bytes elilo-x86_64.efi | Bin 0 -> 221529 bytes elilo.c | 22 +- fileops.c | 13 +- fs/ext2fs.c | 13 +- fs/localfs.c | 33 +- fs/netfs.c | 23 +- getopt.c | 3 +- glue_netfs.c | 6 + sysdeps.h | 6 + util.c | 34 +- x86_64/Makefile | 52 + x86_64/bin_to_h.c | 27 + x86_64/bzimage.c | 224 + x86_64/config.c | 102 + x86_64/gzip.c | 557 + x86_64/gzip.h | 40 + x86_64/gzip_loader.c | 83 + x86_64/inflate.c | 1205 + x86_64/plain_loader.c | 302 + x86_64/private.h | 35 + x86_64/rmswitch.S | 118 + x86_64/sysdeps.h | 451 + x86_64/system.c | 772 + 40 files changed, 139707 insertions(+), 92 deletions(-) create mode 100644 cscope.out create mode 100644 elilo-x86_64.efi create mode 100644 x86_64/Makefile create mode 100644 x86_64/bin_to_h.c create mode 100644 x86_64/bzimage.c create mode 100644 x86_64/config.c create mode 100644 x86_64/gzip.c create mode 100644 x86_64/gzip.h create mode 100644 x86_64/gzip_loader.c create mode 100644 x86_64/inflate.c create mode 100644 x86_64/plain_loader.c create mode 100644 x86_64/private.h create mode 100644 x86_64/rmswitch.S create mode 100644 x86_64/sysdeps.h create mode 100644 x86_64/system.c 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 e3b1fd66eed0685c20b20cc3d355cfc5c7eb9523..7bc217593750bdc1c2f8f8c5c1b214abc0eaadd2 100644 GIT binary patch literal 202915 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 -$2 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­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 Owq2}s^zz@6_J0B~58&4T literal 203222 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�s2x+mOHrWTGY_PX)v?)`;Y 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
R+IA(Y+Yoj`)ksb+@bW(GGnQ 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%0DxVj@l}SxkNWjkugnC;dUDbSyfo(Di+V8FU&L@* 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�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 DOQ=q6 literal 374212 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%0DGMy_< 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 z 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. @@ -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; +}