From owner-freebsd-mips@FreeBSD.ORG Mon Jun 14 11:06:55 2010 Return-Path: Delivered-To: freebsd-mips@FreeBSD.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 4AE45106566C for ; Mon, 14 Jun 2010 11:06:55 +0000 (UTC) (envelope-from owner-bugmaster@FreeBSD.org) Received: from freefall.freebsd.org (freefall.freebsd.org [IPv6:2001:4f8:fff6::28]) by mx1.freebsd.org (Postfix) with ESMTP id 1FC638FC0C for ; Mon, 14 Jun 2010 11:06:55 +0000 (UTC) Received: from freefall.freebsd.org (localhost [127.0.0.1]) by freefall.freebsd.org (8.14.4/8.14.4) with ESMTP id o5EB6tLD078572 for ; Mon, 14 Jun 2010 11:06:55 GMT (envelope-from owner-bugmaster@FreeBSD.org) Received: (from gnats@localhost) by freefall.freebsd.org (8.14.4/8.14.4/Submit) id o5EB6sfg078570 for freebsd-mips@FreeBSD.org; Mon, 14 Jun 2010 11:06:54 GMT (envelope-from owner-bugmaster@FreeBSD.org) Date: Mon, 14 Jun 2010 11:06:54 GMT Message-Id: <201006141106.o5EB6sfg078570@freefall.freebsd.org> X-Authentication-Warning: freefall.freebsd.org: gnats set sender to owner-bugmaster@FreeBSD.org using -f From: FreeBSD bugmaster To: freebsd-mips@FreeBSD.org Cc: Subject: Current problem reports assigned to freebsd-mips@FreeBSD.org X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 14 Jun 2010 11:06:55 -0000 Note: to view an individual PR, use: http://www.freebsd.org/cgi/query-pr.cgi?pr=(number). The following is a listing of current problems submitted by FreeBSD users. These represent problem reports covering all versions including experimental development code and obsolete releases. S Tracker Resp. Description -------------------------------------------------------------------------------- o misc/147471 mips [includes] [patch] whitespace discrepancy in sys/mips/ 1 problem total. From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 11:22:38 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 6F8381065675 for ; Tue, 15 Jun 2010 11:22:38 +0000 (UTC) (envelope-from sg@sg.org.ua) Received: from mail.redtram.com (mail.redtram.com [213.186.114.162]) by mx1.freebsd.org (Postfix) with ESMTP id 8D0768FC14 for ; Tue, 15 Jun 2010 11:22:36 +0000 (UTC) Received: from mail.tbilisi.kiev.ua ([193.254.217.230] helo=sg.intra) by mail.redtram.com with esmtpsa (TLSv1:AES128-SHA:128) (Exim 4.71 (FreeBSD)) (envelope-from ) id 1OOUDy-0001z7-7o; Tue, 15 Jun 2010 14:22:34 +0300 Mime-Version: 1.0 (Apple Message framework v1078) Content-Type: multipart/mixed; boundary=Apple-Mail-6--206473323 From: Alexander Mogilny In-Reply-To: Date: Tue, 15 Jun 2010 14:22:33 +0300 Message-Id: <0EFED95F-1B59-4A34-B518-E49A6ACD7D64@sg.org.ua> References: <9C6B899F-0361-4E20-A9C4-20C002A3CA1D@sg.org.ua> <2D2B1168-4E11-4353-8856-FD2728413F1B@bluezbox.com> To: Luiz Otavio O Souza X-Mailer: Apple Mail (2.1078) Cc: freebsd-mips@freebsd.org Subject: Re: RouterBOARD RB450G X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 11:22:38 -0000 --Apple-Mail-6--206473323 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset=us-ascii On Jun 12, 2010, at 2:36 PM, Luiz Otavio O Souza wrote: > Gonzo, >=20 > I 've most of the trivial fixes for routerboards, just give me a few = days to extract the current patches. >=20 > My old stuff can be found on: http://loos.no-ip.org:280/routerboard/ >=20 > The missing bits are: nand (the driver is ported, but i need more = -free- time to sort out the FS layer), sd/mmc card slot (connected to = spi bus) and the ethernet switch (useful on RG450(g) which have 4 ports = connected to switch). >=20 Hi again! I confirm that this "old stuff" :) works on RB450G. Web document should = be corrected to use port 280 for downloading patches from = http://loos.no-ip.org. I also made some corrections to gpio.diff as world failed to build = because of warnings in gpioctl.c . You may see corrected diff attached. I will now make some tests on the board and give you feedback if = everything is fine. Here is my dmesg.boot: RouterBOOT booter 2.23 RouterBoard 450G CPU frequency: 680 MHz Memory size: 256 MB Press any key within 2 seconds to enter setup.. Please, check ethernet cable... trying bootp protocol... OK Got IP address: 172.16.0.40 resolved mac address 00:E0:81:49:87:F7 Gateway: 172.16.0.1 transfer started .................................. transfer ok, = time=3D2.75s setting up elf image... OK jumping to kernel code platform frequency: 680000000 arguments:=20 a0 =3D 00000008 a1 =3D a0861c00 a2 =3D 00000000 a3 =3D 00000000 Cmd line: console=3DttyS0,115200 gpio=3D1983 HZ=3D340000000 mem=3D256M = kmac=3D00:0C:42:59:30:FF board=3D450G boot=3D1 mlc=3D2 Environment: envp is invalid Cache info: picache_stride =3D 4096 picache_loopcount =3D 16 pdcache_stride =3D 4096 pdcache_loopcount =3D 8 cpu0: MIPS Technologies processor v116.147 MMU: Standard TLB, 16 entries L1 i-cache: 4 ways of 512 sets, 32 bytes per line L1 d-cache: 4 ways of 256 sets, 32 bytes per line Config1=3D0x9ee3519e Config3=3D0x20 Copyright (c) 1992-2010 The FreeBSD Project. Copyright (c) 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994 The Regents of the University of California. All rights = reserved. FreeBSD is a registered trademark of The FreeBSD Foundation. FreeBSD 9.0-CURRENT #3: Tue Jun 15 14:00:59 EEST 2010 root@tbilisi.intra:/usr/obj/mips/mips/usr/src.mips/sys/RB4XX mips real memory =3D 268435456 (262144K bytes) avail memory =3D 257089536 (245MB) nexus0: clock0: on nexus0 clock0: [FILTER] apb0 at irq 4 on nexus0 apb0: [FILTER] uart0: <16550 or compatible> on apb0 uart0: [FILTER] uart0: console (115200,n,8,1) gpio0: on apb0 gpio0: [GIANT-LOCKED] gpio0: [FILTER+ITHREAD] gpioc0: on gpio0 gpiobus0: on gpio0 gpioled0: at pin(s) 4 on gpiobus0 ehci0: at mem = 0x1b000000-0x1bffffff irq 1 on nexus0 ehci0: [ITHREAD] usbus0: set host controller mode usbus0: EHCI version 1.0 usbus0: set host controller mode usbus0: on ehci0 arge0: at mem = 0x19000000-0x19000fff irq 2 on nexus0 arge0: Ethernet address: 00:0c:42:59:30:00 arge0: [FILTER+ITHREAD] arge1: at mem = 0x1a000000-0x1a000fff irq 3 on nexus0 miibus0: on arge1 ukphy0: PHY 4 on miibus0 ukphy0: 10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, 1000baseT-FDX, = auto arge1: Ethernet address: 00:0c:42:59:30:ff arge1: [FILTER+ITHREAD] ar71xx_wdog0: on nexus0 spi0: at mem 0x1f000000-0x1f00000f on nexus0 spibus0: on spi0 Timecounter "MIPS32" frequency 340000000 Hz quality 800 Timecounters tick every 1.000 msec bootpc_init: wired to interface 'arge1' Sending DHCP Discover packet from interface arge1 (00:0c:42:59:30:ff) arge1: link state changed to DOWN usbus0: 480Mbps High Speed USB v2.0 ugen0.1: at usbus0 uhub0: on = usbus0 uhub0: 2 ports with 2 removable, self powered DHCP/BOOTP timeout for server 255.255.255.255 arge1: link state changed to UP DHCP/BOOTP timeout for server 255.255.255.255 Received DHCP Offer packet on arge1 from 172.16.0.100 (accepted) (no = root path) Received DHCP Offer packet on arge1 from 172.16.0.100 (ignored) (no root = path) Received DHCP Offer packet on arge1 from 172.16.0.100 (ignored) (no root = path) Sending DHCP Request packet from interface arge1 (00:0c:42:59:30:ff) DHCP/BOOTP timeout for server 255.255.255.255 Received DHCP Ack packet on arge1 from 172.16.0.100 (accepted) (got root = path) Received DHCP Ack packet on arge1 from 172.16.0.100 via 172.16.0.1 = (accepted) (got root path) arge1 at 172.16.0.40 server 172.16.0.100 via gateway 172.16.0.1 boot = file boot/kernel/kernel subnet mask 255.255.255.0 router 172.16.0.1 rootfs = 172.16.0.100:/home/nfs hostname mk-40=20 Adjusted interface arge1 Trying to mount root from nfs: NFS ROOT: 172.16.0.100:/home/nfs <...> Now, tell me how can I help you with writing some code for ethernet = switch etc? As I need to get it working :). --Apple-Mail-6--206473323 Content-Disposition: attachment; filename=gpio.diff Content-Type: application/octet-stream; name="gpio.diff" Content-Transfer-Encoding: 7bit diff --git a/sys/conf/files b/sys/conf/files index b5a6f8c..7afc80b 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -935,6 +935,13 @@ dev/fxp/if_fxp.c optional fxp inet dev/gem/if_gem.c optional gem dev/gem/if_gem_pci.c optional gem pci dev/gem/if_gem_sbus.c optional gem sbus +dev/gpio/gpiobus.c optional gpio \ + dependency "gpiobus_if.h" +dev/gpio/gpioc.c optional gpio \ + dependency "gpio_if.h" +dev/gpio/gpioled.c optional gpioled +dev/gpio/gpio_if.m optional gpio +dev/gpio/gpiobus_if.m optional gpio dev/hatm/if_hatm.c optional hatm pci dev/hatm/if_hatm_intr.c optional hatm pci dev/hatm/if_hatm_ioctl.c optional hatm pci diff --git a/sys/dev/gpio/gpio_if.m b/sys/dev/gpio/gpio_if.m new file mode 100644 index 0000000..8e29607 --- /dev/null +++ b/sys/dev/gpio/gpio_if.m @@ -0,0 +1,102 @@ +#- +# Copyright (c) 2009 Oleksandr Tymoshenko +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +# SUCH DAMAGE. +# +# $FreeBSD$ +# + +#include +#include + +INTERFACE gpio; + +# +# Get total number of pins +# +METHOD int pin_max { + device_t dev; + int *npins; +}; + +# +# Set value of pin specifed by pin_num +# +METHOD int pin_set { + device_t dev; + uint32_t pin_num; + uint32_t pin_value; +}; + +# +# Get value of pin specifed by pin_num +# +METHOD int pin_get { + device_t dev; + uint32_t pin_num; + uint32_t *pin_value; +}; + +# +# Toggle value of pin specifed by pin_num +# +METHOD int pin_toggle { + device_t dev; + uint32_t pin_num; +}; + +# +# Get pin capabilities +# +METHOD int pin_getcaps { + device_t dev; + uint32_t pin_num; + uint32_t *caps; +}; + +# +# Get pin flags +# +METHOD int pin_getflags { + device_t dev; + uint32_t pin_num; + uint32_t *flags; +}; + +# +# Get pin name +# +METHOD int pin_getname { + device_t dev; + uint32_t pin_num; + char *name; +}; + +# +# Set current configuration and capabilities +# +METHOD int pin_setflags { + device_t dev; + uint32_t pin_num; + uint32_t flags; +}; diff --git a/sys/dev/gpio/gpiobus.c b/sys/dev/gpio/gpiobus.c new file mode 100644 index 0000000..05c558f --- /dev/null +++ b/sys/dev/gpio/gpiobus.c @@ -0,0 +1,390 @@ +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include "gpio_if.h" +#include "gpiobus_if.h" + +static void gpiobus_print_pins(struct gpiobus_ivar *); +static int gpiobus_parse_pins(struct gpiobus_softc *, device_t, int); +static int gpiobus_probe(device_t); +static int gpiobus_attach(device_t); +static int gpiobus_detach(device_t); +static int gpiobus_suspend(device_t); +static int gpiobus_resume(device_t); +static int gpiobus_print_child(device_t, device_t); +static int gpiobus_child_location_str(device_t, device_t, char *, size_t); +static int gpiobus_child_pnpinfo_str(device_t, device_t, char *, size_t); +static device_t gpiobus_add_child(device_t, int, const char *, int); +static void gpiobus_hinted_child(device_t, const char *, int); + +/* + * GPIOBUS interface + */ +static int gpiobus_pin_setflags(device_t, device_t, uint32_t, uint32_t); +static int gpiobus_pin_getflags(device_t, device_t, uint32_t, uint32_t*); +static int gpiobus_pin_getcaps(device_t, device_t, uint32_t, uint32_t*); +static int gpiobus_pin_set(device_t, device_t, uint32_t, unsigned int); +static int gpiobus_pin_get(device_t, device_t, uint32_t, unsigned int*); +static int gpiobus_pin_toggle(device_t, device_t, uint32_t); + +static void +gpiobus_print_pins(struct gpiobus_ivar *devi) +{ + int range_start, range_stop, need_coma; + int i; + + if (devi->npins == 0) + return; + + need_coma = 0; + range_start = range_stop = devi->pins[0]; + for(i = 1; i < devi->npins-1; i++) { + if (devi->pins[i] != (range_stop + 1)) { + if (need_coma) + printf(","); + if (range_start != range_stop) + printf("%d-%d", range_start, range_stop); + else + printf("%d", range_start); + + range_start = range_stop = devi->pins[i]; + need_coma = 1; + } + else + range_stop++; + } + + if (need_coma) + printf(","); + if (range_start != range_stop) + printf("%d-%d", range_start, range_stop); + else + printf("%d", range_start); +} + +static int +gpiobus_parse_pins(struct gpiobus_softc *sc, device_t child, int mask) +{ + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + int i, npins; + + npins = 0; + for (i = 0; i < 32; i++) { + if (mask & (1 << i)) + npins++; + } + + if (npins == 0) { + device_printf(child, "empty pin mask"); + return (EINVAL); + } + + devi->npins = npins; + devi->pins = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF, + M_NOWAIT | M_ZERO); + + if (!devi->pins) + return (ENOMEM); + + npins = 0; + for (i = 0; i < 32; i++) { + + if ((mask & (1 << i)) == 0) + continue; + + if (i >= sc->npins) { + device_printf(child, + "invalid pin %d, max: %d\n", i, sc->npins - 1); + return (EINVAL); + } + + devi->pins[npins++] = i; + /* + * Mark pin as mapped and give warning if it's already mapped + */ + if (sc->pins_mapped[i]) { + device_printf(child, + "warning: pin %d is already mapped\n", i); + return (EINVAL); + } + sc->pins_mapped[i] = 1; + } + + return (0); +} + +static int +gpiobus_probe(device_t dev) +{ + device_set_desc(dev, "GPIO bus"); + return (0); +} + +static int +gpiobus_attach(device_t dev) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + int res; + + sc->dev = dev; + sc->pdev = device_get_parent(dev); + res = GPIO_PIN_MAX(sc->pdev, &sc->npins); + if (res) + return (ENXIO); + + /* + * Increase to get number of pins + */ + sc->npins++; + + KASSERT(sc->npins != 0, ("GPIO device with no pins")); + + sc->pins_mapped = malloc(sizeof(int) * sc->npins, M_DEVBUF, + M_NOWAIT | M_ZERO); + + if (!sc->pins_mapped) + return (ENOMEM); + + /* + * Get parent's pins and mark them as unmapped + */ + bus_enumerate_hinted_children(dev); + return (bus_generic_attach(dev)); +} + +/* + * Since this is not a self-enumerating bus, and since we always add + * children in attach, we have to always delete children here. + */ +static int +gpiobus_detach(device_t dev) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + int err, ndevs, i; + device_t *devlist; + + if ((err = bus_generic_detach(dev)) != 0) + return (err); + if ((err = device_get_children(dev, &devlist, &ndevs)) != 0) + return (err); + for (i = 0; i < ndevs; i++) + device_delete_child(dev, devlist[i]); + + if (sc->pins_mapped) { + free(sc->pins_mapped, M_DEVBUF); + sc->pins_mapped = NULL; + } + free(devlist, M_TEMP); + + return (0); +} + +static int +gpiobus_suspend(device_t dev) +{ + return (bus_generic_suspend(dev)); +} + +static int +gpiobus_resume(device_t dev) +{ + return (bus_generic_resume(dev)); +} + +static int +gpiobus_print_child(device_t dev, device_t child) +{ + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + int retval = 0; + + retval += bus_print_child_header(dev, child); + retval += printf(" at pin(s) "); + gpiobus_print_pins(devi); + retval += bus_print_child_footer(dev, child); + + return (retval); +} + +static int +gpiobus_child_location_str(device_t bus, device_t child, char *buf, + size_t buflen) +{ + // struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + snprintf(buf, buflen, "pins=?"); + return (0); +} + +static int +gpiobus_child_pnpinfo_str(device_t bus, device_t child, char *buf, + size_t buflen) +{ + *buf = '\0'; + return (0); +} + +static device_t +gpiobus_add_child(device_t dev, int order, const char *name, int unit) +{ + device_t child; + struct gpiobus_ivar *devi; + + child = device_add_child_ordered(dev, order, name, unit); + if (child == NULL) + return (child); + devi = malloc(sizeof(struct gpiobus_ivar), M_DEVBUF, M_NOWAIT | M_ZERO); + if (devi == NULL) { + device_delete_child(dev, child); + return (0); + } + device_set_ivars(child, devi); + return (child); +} + +static void +gpiobus_hinted_child(device_t bus, const char *dname, int dunit) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(bus); + struct gpiobus_ivar *devi; + device_t child; + int pins; + + + child = BUS_ADD_CHILD(bus, 0, dname, dunit); + devi = GPIOBUS_IVAR(child); + resource_int_value(dname, dunit, "pins", &pins); + if (gpiobus_parse_pins(sc, child, pins)) + device_delete_child(bus, child); +} + +static int +gpiobus_pin_setflags(device_t dev, device_t child, uint32_t pin, + uint32_t flags) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + if (pin >= devi->npins) + return (EINVAL); + + return GPIO_PIN_SETFLAGS(sc->pdev, devi->pins[pin], flags); +} + +static int +gpiobus_pin_getflags(device_t dev, device_t child, uint32_t pin, + uint32_t *flags) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + if (pin >= devi->npins) + return (EINVAL); + + return GPIO_PIN_GETFLAGS(sc->pdev, devi->pins[pin], flags); +} + +static int +gpiobus_pin_getcaps(device_t dev, device_t child, uint32_t pin, + uint32_t *caps) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + if (pin >= devi->npins) + return (EINVAL); + + return GPIO_PIN_GETCAPS(sc->pdev, devi->pins[pin], caps); +} + +static int +gpiobus_pin_set(device_t dev, device_t child, uint32_t pin, + unsigned int value) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + if (pin >= devi->npins) + return (EINVAL); + + return GPIO_PIN_SET(sc->pdev, devi->pins[pin], value); +} + +static int +gpiobus_pin_get(device_t dev, device_t child, uint32_t pin, + unsigned int *value) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + if (pin >= devi->npins) + return (EINVAL); + + return GPIO_PIN_GET(sc->pdev, devi->pins[pin], value); +} + +static int +gpiobus_pin_toggle(device_t dev, device_t child, uint32_t pin) +{ + struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); + struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); + + if (pin >= devi->npins) + return (EINVAL); + + return GPIO_PIN_TOGGLE(sc->pdev, devi->pins[pin]); +} + +static device_method_t gpiobus_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, gpiobus_probe), + DEVMETHOD(device_attach, gpiobus_attach), + DEVMETHOD(device_detach, gpiobus_detach), + DEVMETHOD(device_shutdown, bus_generic_shutdown), + DEVMETHOD(device_suspend, gpiobus_suspend), + DEVMETHOD(device_resume, gpiobus_resume), + + /* Bus interface */ + DEVMETHOD(bus_add_child, gpiobus_add_child), + DEVMETHOD(bus_print_child, gpiobus_print_child), + DEVMETHOD(bus_driver_added, bus_generic_driver_added), + DEVMETHOD(bus_child_pnpinfo_str, gpiobus_child_pnpinfo_str), + DEVMETHOD(bus_child_location_str, gpiobus_child_location_str), + DEVMETHOD(bus_hinted_child, gpiobus_hinted_child), + + /* GPIO protocol */ + DEVMETHOD(gpiobus_pin_getflags, gpiobus_pin_getflags), + DEVMETHOD(gpiobus_pin_getcaps, gpiobus_pin_getcaps), + DEVMETHOD(gpiobus_pin_setflags, gpiobus_pin_setflags), + DEVMETHOD(gpiobus_pin_get, gpiobus_pin_get), + DEVMETHOD(gpiobus_pin_set, gpiobus_pin_set), + DEVMETHOD(gpiobus_pin_toggle, gpiobus_pin_toggle), + + { 0, 0 } +}; + +static driver_t gpiobus_driver = { + "gpiobus", + gpiobus_methods, + sizeof(struct gpiobus_softc) +}; + +devclass_t gpiobus_devclass; + +DRIVER_MODULE(gpiobus, gpio, gpiobus_driver, gpiobus_devclass, 0, 0); +MODULE_VERSION(gpiobus, 1); diff --git a/sys/dev/gpio/gpiobus_if.m b/sys/dev/gpio/gpiobus_if.m new file mode 100644 index 0000000..a406e01 --- /dev/null +++ b/sys/dev/gpio/gpiobus_if.m @@ -0,0 +1,91 @@ +#- +# Copyright (c) 2009 Oleksandr Tymoshenko +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +# SUCH DAMAGE. +# +# $FreeBSD$ +# + +#include +#include + +INTERFACE gpiobus; + +# +# Set value of pin specifed by pin_num +# +METHOD int pin_set { + device_t dev; + device_t child; + uint32_t pin_num; + uint32_t pin_value; +}; + +# +# Get value of pin specifed by pin_num +# +METHOD int pin_get { + device_t dev; + device_t child; + uint32_t pin_num; + uint32_t *pin_value; +}; + +# +# Toggle value of pin specifed by pin_num +# +METHOD int pin_toggle { + device_t dev; + device_t child; + uint32_t pin_num; +}; + +# +# Get pin capabilities +# +METHOD int pin_getcaps { + device_t dev; + device_t child; + uint32_t pin_num; + uint32_t *caps; +}; + +# +# Get pin flags +# +METHOD int pin_getflags { + device_t dev; + device_t child; + uint32_t pin_num; + uint32_t *flags; +}; + +# +# Set current configuration and capabilities +# +METHOD int pin_setflags { + device_t dev; + device_t child; + uint32_t pin_num; + uint32_t flags; +}; diff --git a/sys/dev/gpio/gpiobusvar.h b/sys/dev/gpio/gpiobusvar.h new file mode 100644 index 0000000..f1a290f --- /dev/null +++ b/sys/dev/gpio/gpiobusvar.h @@ -0,0 +1,22 @@ +#ifndef __GPIOBUS_H__ +#define __GPIOBUS_H__ + +#define GPIOBUS_IVAR(d) (struct gpiobus_ivar *) device_get_ivars(d) +#define GPIOBUS_SOFTC(d) (struct gpiobus_softc *) device_get_softc(d) + +struct gpiobus_softc +{ + device_t pdev; /* bus device */ + device_t dev; + int npins; /* total pins on bus */ + int *pins_mapped; /* mark mapped pins */ +}; + + +struct gpiobus_ivar +{ + uint32_t npins; /* pins total */ + uint32_t *pins; /* pins map */ +}; + +#endif /* __GPIOBUS_H__ */ diff --git a/sys/dev/gpio/gpioc.c b/sys/dev/gpio/gpioc.c new file mode 100644 index 0000000..e507a73 --- /dev/null +++ b/sys/dev/gpio/gpioc.c @@ -0,0 +1,174 @@ +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "gpio_if.h" + +#undef GPIOC_DEBUG +#ifdef GPIOC_DEBUG +#define dprintf printf +#else +#define dprintf(x, arg...) +#endif + +static int gpioc_probe(device_t dev); +static int gpioc_attach(device_t dev); +static int gpioc_detach(device_t dev); + +static d_ioctl_t gpioc_ioctl; + +static struct cdevsw gpioc_cdevsw = { + .d_version = D_VERSION, + .d_ioctl = gpioc_ioctl, + .d_name = "gpioc", +#if __FreeBSD_version >= 800039 + .d_flags = D_PSEUDO | D_NEEDMINOR +#endif +}; + +struct gpioc_softc { + device_t sc_dev; /* gpiocX dev */ + device_t sc_pdev; /* gpioX dev */ + struct cdev *sc_ctl_dev; /* controller device */ + int sc_unit; +}; + +static int +gpioc_probe(device_t dev) +{ + device_set_desc(dev, "GPIO controller"); + return (0); +} + +static int +gpioc_attach(device_t dev) +{ + struct gpioc_softc *sc = device_get_softc(dev); + + sc->sc_dev = dev; + sc->sc_pdev = device_get_parent(dev); + sc->sc_unit = device_get_unit(dev); + sc->sc_ctl_dev = make_dev(&gpioc_cdevsw, sc->sc_unit, + UID_ROOT, GID_WHEEL, 0600, "gpioc%d", sc->sc_unit); + if (!sc->sc_ctl_dev) { + printf("Failed to create gpioc%d", sc->sc_unit); + return (ENXIO); + } + sc->sc_ctl_dev->si_drv1 = sc; + + return (0); +} + +static int +gpioc_detach(device_t dev) +{ + struct gpioc_softc *sc = device_get_softc(dev); + int err; + + if (sc->sc_ctl_dev); + destroy_dev(sc->sc_ctl_dev); + + if ((err = bus_generic_detach(dev)) != 0) + return (err); + + return (0); +} + +static int +gpioc_ioctl(struct cdev *cdev, u_long cmd, caddr_t arg, int fflag, + struct thread *td) +{ + int max_pin, res; + struct gpioc_softc *sc = cdev->si_drv1; + struct gpio_pin pin; + struct gpio_req req; + + switch (cmd) { + case GPIOMAXPIN: + max_pin = -1; + res = GPIO_PIN_MAX(sc->sc_pdev, &max_pin); + bcopy(&max_pin, arg, sizeof(max_pin)); + break; + case GPIOGETCONFIG: + bcopy(arg, &pin, sizeof(pin)); + dprintf("get config pin %d\n", pin.gp_pin); + res = GPIO_PIN_GETFLAGS(sc->sc_pdev, pin.gp_pin, + &pin.gp_flags); + /* Fail early */ + if (res) + break; + GPIO_PIN_GETCAPS(sc->sc_pdev, pin.gp_pin, &pin.gp_caps); + GPIO_PIN_GETNAME(sc->sc_pdev, pin.gp_pin, pin.gp_name); + bcopy(&pin, arg, sizeof(pin)); + break; + case GPIOSETCONFIG: + bcopy(arg, &pin, sizeof(pin)); + dprintf("set config pin %d\n", pin.gp_pin); + res = GPIO_PIN_SETFLAGS(sc->sc_pdev, pin.gp_pin, + pin.gp_flags); + break; + case GPIOGET: + bcopy(arg, &req, sizeof(req)); + res = GPIO_PIN_GET(sc->sc_pdev, req.gp_pin, + &req.gp_value); + dprintf("read pin %d -> %d\n", + req.gp_pin, req.gp_value); + bcopy(&req, arg, sizeof(req)); + break; + case GPIOSET: + bcopy(arg, &req, sizeof(req)); + res = GPIO_PIN_SET(sc->sc_pdev, req.gp_pin, + req.gp_value); + dprintf("write pin %d -> %d\n", + req.gp_pin, req.gp_value); + break; + case GPIOTOGGLE: + bcopy(arg, &req, sizeof(req)); + dprintf("toggle pin %d\n", + req.gp_pin); + res = GPIO_PIN_TOGGLE(sc->sc_pdev, req.gp_pin); + break; + default: + return (ENOTTY); + break; + } + + return (res); +} + +static device_method_t gpioc_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, gpioc_probe), + DEVMETHOD(device_attach, gpioc_attach), + DEVMETHOD(device_detach, gpioc_detach), + DEVMETHOD(device_shutdown, bus_generic_shutdown), + DEVMETHOD(device_suspend, bus_generic_suspend), + DEVMETHOD(device_resume, bus_generic_resume), + + { 0, 0 } +}; + +static driver_t gpioc_driver = { + "gpioc", + gpioc_methods, + sizeof(struct gpioc_softc) +}; + +devclass_t gpioc_devclass; + +DRIVER_MODULE(gpioc, gpio, gpioc_driver, gpioc_devclass, 0, 0); +MODULE_VERSION(gpioc, 1); diff --git a/sys/dev/gpio/gpioled.c b/sys/dev/gpio/gpioled.c new file mode 100644 index 0000000..082d5e8 --- /dev/null +++ b/sys/dev/gpio/gpioled.c @@ -0,0 +1,137 @@ +/*- + * Copyright (c) 2009 Oleksandr Tymoshenko. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include "gpiobus_if.h" + +/* + * Only one pin for led + */ +#define GPIOLED_PIN 0 + +#define GPIOLED_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) +#define GPIOLED_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) +#define GPIOLED_LOCK_INIT(_sc) \ + mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->sc_dev), \ + "gpioled", MTX_DEF) +#define GPIOLED_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx); + +struct gpioled_softc +{ + device_t sc_dev; + device_t sc_busdev; + struct mtx sc_mtx; + struct cdev *sc_leddev; +}; + +static void gpioled_control(void *, int); +static int gpioled_probe(device_t); +static int gpioled_attach(device_t); +static int gpioled_detach(device_t); + +static void +gpioled_control(void *priv, int onoff) +{ + struct gpioled_softc *sc = priv; + GPIOLED_LOCK(sc); + GPIOBUS_PIN_SET(sc->sc_busdev, sc->sc_dev, GPIOLED_PIN, + onoff ? GPIO_PIN_HIGH : GPIO_PIN_LOW); + GPIOLED_UNLOCK(sc); +} + +static int +gpioled_probe(device_t dev) +{ + device_set_desc(dev, "GPIO led"); + return (0); +} + +static int +gpioled_attach(device_t dev) +{ + struct gpioled_softc *sc; + const char *name; + + sc = device_get_softc(dev); + sc->sc_dev = dev; + sc->sc_busdev = device_get_parent(dev); + GPIOLED_LOCK_INIT(sc); + if (resource_string_value(device_get_name(dev), + device_get_unit(dev), "name", &name)) + name = NULL; + + sc->sc_leddev = led_create(gpioled_control, sc, name ? name : + device_get_nameunit(dev)); + + return (0); +} + +static int +gpioled_detach(device_t dev) +{ + struct gpioled_softc *sc; + + sc = device_get_softc(dev); + if (sc->sc_leddev) { + led_destroy(sc->sc_leddev); + sc->sc_leddev = NULL; + } + GPIOLED_LOCK_DESTROY(sc); + return (0); +} + +static devclass_t gpioled_devclass; + +static device_method_t gpioled_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, gpioled_probe), + DEVMETHOD(device_attach, gpioled_attach), + DEVMETHOD(device_detach, gpioled_detach), + + { 0, 0 } +}; + +static driver_t gpioled_driver = { + "gpioled", + gpioled_methods, + sizeof(struct gpioled_softc), +}; + +DRIVER_MODULE(gpioled, gpiobus, gpioled_driver, gpioled_devclass, 0, 0); diff --git a/sys/mips/atheros/ar71xx_gpio.c b/sys/mips/atheros/ar71xx_gpio.c new file mode 100644 index 0000000..c66266e --- /dev/null +++ b/sys/mips/atheros/ar71xx_gpio.c @@ -0,0 +1,446 @@ +/*- + * Copyright (c) 2009, Oleksandr Tymoshenko + * Copyright (c) 2009, Luiz Otavio O Souza. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * GPIO driver for AR71xx + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "gpio_if.h" + +#define DEFAULT_CAPS (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT) + +struct ar71xx_gpio_pin { + const char *name; + int pin; + int flags; +}; + +static struct ar71xx_gpio_pin ar71xx_gpio_pins[] = { + { "RFled", 2, GPIO_PIN_OUTPUT}, + { "SW4", 8, GPIO_PIN_INPUT}, + { NULL, 0, 0}, +}; + +/* + * Helpers + */ +static void ar71xx_gpio_function_enable(struct ar71xx_gpio_softc *sc, + uint32_t mask); +static void ar71xx_gpio_function_disable(struct ar71xx_gpio_softc *sc, + uint32_t mask); +static void ar71xx_gpio_pin_configure(struct ar71xx_gpio_softc *sc, + struct gpio_pin *pin, uint32_t flags); + +/* + * Driver stuff + */ +static int ar71xx_gpio_probe(device_t dev); +static int ar71xx_gpio_attach(device_t dev); +static int ar71xx_gpio_detach(device_t dev); +static int ar71xx_gpio_filter(void *arg); +static void ar71xx_gpio_intr(void *arg); + +/* + * GPIO interface + */ +static int ar71xx_gpio_pin_max(device_t dev, int *maxpin); +static int ar71xx_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps); +static int ar71xx_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t + *flags); +static int ar71xx_gpio_pin_getname(device_t dev, uint32_t pin, char *name); +static int ar71xx_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags); +static int ar71xx_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value); +static int ar71xx_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val); +static int ar71xx_gpio_pin_toggle(device_t dev, uint32_t pin); + +static void +ar71xx_gpio_function_enable(struct ar71xx_gpio_softc *sc, uint32_t mask) +{ + GPIO_LOCK(sc); + GPIO_SET_BITS(sc, AR71XX_GPIO_FUNCTION, mask); + GPIO_UNLOCK(sc); +} + +static void +ar71xx_gpio_function_disable(struct ar71xx_gpio_softc *sc, uint32_t mask) +{ + GPIO_LOCK(sc); + GPIO_CLEAR_BITS(sc, AR71XX_GPIO_FUNCTION, mask); + GPIO_UNLOCK(sc); +} + +static void +ar71xx_gpio_pin_configure(struct ar71xx_gpio_softc *sc, struct gpio_pin *pin, + unsigned int flags) +{ + uint32_t mask; + + mask = 1 << pin->gp_pin; + GPIO_LOCK(sc); + + /* + * Manage input/output + */ + if (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) { + pin->gp_flags &= ~(GPIO_PIN_INPUT|GPIO_PIN_OUTPUT); + if (flags & GPIO_PIN_OUTPUT) { + pin->gp_flags |= GPIO_PIN_OUTPUT; + GPIO_SET_BITS(sc, AR71XX_GPIO_OE, mask); + } + else { + pin->gp_flags |= GPIO_PIN_INPUT; + GPIO_CLEAR_BITS(sc, AR71XX_GPIO_OE, mask); + } + } + + GPIO_UNLOCK(sc); +} + +static int +ar71xx_gpio_pin_max(device_t dev, int *maxpin) +{ + + *maxpin = AR71XX_GPIO_PINS - 1; + return (0); +} + +static int +ar71xx_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + int i; + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + GPIO_LOCK(sc); + *caps = sc->gpio_pins[i].gp_caps; + GPIO_UNLOCK(sc); + + return (0); +} + +static int +ar71xx_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + int i; + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + GPIO_LOCK(sc); + *flags = sc->gpio_pins[i].gp_flags; + GPIO_UNLOCK(sc); + + return (0); +} + +static int +ar71xx_gpio_pin_getname(device_t dev, uint32_t pin, char *name) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + int i; + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + GPIO_LOCK(sc); + memcpy(name, sc->gpio_pins[i].gp_name, GPIOMAXNAME); + GPIO_UNLOCK(sc); + + return (0); +} + +static int +ar71xx_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags) +{ + int i; + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + /* Filter out unwanted flags */ + if ((flags &= sc->gpio_pins[i].gp_caps) != flags) + return (EINVAL); + + /* Can't mix input/output together */ + if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) == + (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) + return (EINVAL); + + ar71xx_gpio_pin_configure(sc, &sc->gpio_pins[i], flags); + return (0); +} + +static int +ar71xx_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + int i; + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + GPIO_LOCK(sc); + if (value) + GPIO_WRITE(sc, AR71XX_GPIO_SET, (1 << pin)); + else + GPIO_WRITE(sc, AR71XX_GPIO_CLEAR, (1 << pin)); + GPIO_UNLOCK(sc); + + return (0); +} + +static int +ar71xx_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + int i; + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + GPIO_LOCK(sc); + *val = (GPIO_READ(sc, AR71XX_GPIO_IN) & (1 << pin)) ? 1 : 0; + GPIO_UNLOCK(sc); + + return (0); +} + +static int +ar71xx_gpio_pin_toggle(device_t dev, uint32_t pin) +{ + int res, i; + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + + for (i = 0; i < sc->gpio_npins; i++) { + if (sc->gpio_pins[i].gp_pin == pin) + break; + } + + if (i >= sc->gpio_npins) + return (EINVAL); + + GPIO_LOCK(sc); + res = (GPIO_READ(sc, AR71XX_GPIO_IN) & (1 << pin)) ? 1 : 0; + if (res) + GPIO_WRITE(sc, AR71XX_GPIO_CLEAR, (1 << pin)); + else + GPIO_WRITE(sc, AR71XX_GPIO_SET, (1 << pin)); + GPIO_UNLOCK(sc); + + return (0); +} + +static int +ar71xx_gpio_filter(void *arg) +{ + + /* TODO: something useful */ + return (FILTER_STRAY); +} + + + +static void +ar71xx_gpio_intr(void *arg) +{ + struct ar71xx_gpio_softc *sc = arg; + GPIO_LOCK(sc); + /* TODO: something useful */ + GPIO_UNLOCK(sc); +} + +static int +ar71xx_gpio_probe(device_t dev) +{ + + device_set_desc(dev, "Atheros AR71XX GPIO driver"); + return (0); +} + +static int +ar71xx_gpio_attach(device_t dev) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + int error = 0; + struct ar71xx_gpio_pin *pinp; + int i; + + KASSERT((device_get_unit(dev) == 0), + ("ar71xx_gpio: Only one gpio module supported")); + + mtx_init(&sc->gpio_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, + MTX_DEF); + + /* Map control/status registers. */ + sc->gpio_mem_rid = 0; + sc->gpio_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, + &sc->gpio_mem_rid, RF_ACTIVE); + + if (sc->gpio_mem_res == NULL) { + device_printf(dev, "couldn't map memory\n"); + error = ENXIO; + ar71xx_gpio_detach(dev); + return(error); + } + + if ((sc->gpio_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, + &sc->gpio_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) { + device_printf(dev, "unable to allocate IRQ resource\n"); + return (ENXIO); + } + + if ((bus_setup_intr(dev, sc->gpio_irq_res, INTR_TYPE_MISC, + ar71xx_gpio_filter, ar71xx_gpio_intr, sc, &sc->gpio_ih))) { + device_printf(dev, + "WARNING: unable to register interrupt handler\n"); + return (ENXIO); + } + + sc->dev = dev; + ar71xx_gpio_function_enable(sc, GPIO_SPI_CS1_EN); + ar71xx_gpio_function_enable(sc, GPIO_SPI_CS2_EN); + /* Configure all pins as input */ + /* disable interrupts for all pins */ + GPIO_WRITE(sc, AR71XX_GPIO_INT_MASK, 0); + pinp = ar71xx_gpio_pins; + i = 0; + while (pinp->name) { + strncpy(sc->gpio_pins[i].gp_name, pinp->name, GPIOMAXNAME); + sc->gpio_pins[i].gp_pin = pinp->pin; + sc->gpio_pins[i].gp_caps = DEFAULT_CAPS; + sc->gpio_pins[i].gp_flags = 0; + ar71xx_gpio_pin_configure(sc, &sc->gpio_pins[i], pinp->flags); + pinp++; + i++; + } + + sc->gpio_npins = i; + + device_add_child(dev, "gpioc", device_get_unit(dev)); + device_add_child(dev, "gpiobus", device_get_unit(dev)); + return (bus_generic_attach(dev)); +} + +static int +ar71xx_gpio_detach(device_t dev) +{ + struct ar71xx_gpio_softc *sc = device_get_softc(dev); + + KASSERT(mtx_initialized(&sc->gpio_mtx), ("gpio mutex not initialized")); + + ar71xx_gpio_function_disable(sc, GPIO_SPI_CS1_EN); + ar71xx_gpio_function_disable(sc, GPIO_SPI_CS2_EN); + bus_generic_detach(dev); + + if (sc->gpio_mem_res) + bus_release_resource(dev, SYS_RES_MEMORY, sc->gpio_mem_rid, + sc->gpio_mem_res); + + mtx_destroy(&sc->gpio_mtx); + + return(0); +} + +static device_method_t ar71xx_gpio_methods[] = { + DEVMETHOD(device_probe, ar71xx_gpio_probe), + DEVMETHOD(device_attach, ar71xx_gpio_attach), + DEVMETHOD(device_detach, ar71xx_gpio_detach), + + /* GPIO protocol */ + DEVMETHOD(gpio_pin_max, ar71xx_gpio_pin_max), + DEVMETHOD(gpio_pin_getname, ar71xx_gpio_pin_getname), + DEVMETHOD(gpio_pin_getflags, ar71xx_gpio_pin_getflags), + DEVMETHOD(gpio_pin_getcaps, ar71xx_gpio_pin_getcaps), + DEVMETHOD(gpio_pin_setflags, ar71xx_gpio_pin_setflags), + DEVMETHOD(gpio_pin_get, ar71xx_gpio_pin_get), + DEVMETHOD(gpio_pin_set, ar71xx_gpio_pin_set), + DEVMETHOD(gpio_pin_toggle, ar71xx_gpio_pin_toggle), + {0, 0}, +}; + +static driver_t ar71xx_gpio_driver = { + "gpio", + ar71xx_gpio_methods, + sizeof(struct ar71xx_gpio_softc), +}; +static devclass_t ar71xx_gpio_devclass; + +DRIVER_MODULE(ar71xx_gpio, apb, ar71xx_gpio_driver, ar71xx_gpio_devclass, 0, 0); diff --git a/sys/mips/atheros/ar71xx_gpiovar.h b/sys/mips/atheros/ar71xx_gpiovar.h new file mode 100644 index 0000000..9cbea65 --- /dev/null +++ b/sys/mips/atheros/ar71xx_gpiovar.h @@ -0,0 +1,65 @@ +/*- + * Copyright (c) 2009, Oleksandr Tymoshenko + * Copyright (c) 2009, Luiz Otavio O Souza. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef __AR71XX_GPIOVAR_H__ +#define __AR71XX_GPIOVAR_H__ + +#define GPIO_LOCK(_sc) mtx_lock(&(_sc)->gpio_mtx) +#define GPIO_UNLOCK(_sc) mtx_unlock(&(_sc)->gpio_mtx) +#define GPIO_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->gpio_mtx, MA_OWNED) + +/* + * register space access macros + */ +#define GPIO_WRITE(sc, reg, val) do { \ + bus_write_4(sc->gpio_mem_res, (reg), (val)); \ + } while (0) + +#define GPIO_READ(sc, reg) bus_read_4(sc->gpio_mem_res, (reg)) + +#define GPIO_SET_BITS(sc, reg, bits) \ + GPIO_WRITE(sc, reg, GPIO_READ(sc, (reg)) | (bits)) + +#define GPIO_CLEAR_BITS(sc, reg, bits) \ + GPIO_WRITE(sc, reg, GPIO_READ(sc, (reg)) & ~(bits)) + +#define AR71XX_GPIO_PINS 12 + +struct ar71xx_gpio_softc { + device_t dev; + struct mtx gpio_mtx; + struct resource *gpio_mem_res; + int gpio_mem_rid; + struct resource *gpio_irq_res; + int gpio_irq_rid; + void *gpio_ih; + int gpio_npins; + struct gpio_pin gpio_pins[AR71XX_GPIO_PINS]; +}; + +#endif /* __AR71XX_GPIOVAR_H__ */ diff --git a/sys/mips/atheros/ar71xxreg.h b/sys/mips/atheros/ar71xxreg.h index 5677a4e..5d36a67 100644 --- a/sys/mips/atheros/ar71xxreg.h +++ b/sys/mips/atheros/ar71xxreg.h @@ -134,6 +134,21 @@ #define USB_CTRL_CONFIG_RESUME_UTMI_PLS_DIS (1 << 1) #define USB_CTRL_CONFIG_UTMI_BACKWARD_ENB (1 << 0) +#define AR71XX_GPIO_BASE 0x18040000 +#define AR71XX_GPIO_OE 0x00 +#define AR71XX_GPIO_IN 0x04 +#define AR71XX_GPIO_OUT 0x08 +#define AR71XX_GPIO_SET 0x0c +#define AR71XX_GPIO_CLEAR 0x10 +#define AR71XX_GPIO_INT 0x14 +#define AR71XX_GPIO_INT_TYPE 0x18 +#define AR71XX_GPIO_INT_POLARITY 0x1c +#define AR71XX_GPIO_INT_PENDING 0x20 +#define AR71XX_GPIO_INT_MASK 0x24 +#define AR71XX_GPIO_FUNCTION 0x28 +#define GPIO_SPI_CS2_EN (1 << 13) +#define GPIO_SPI_CS1_EN (1 << 12) + #define AR71XX_BASE_FREQ 40000000 #define AR71XX_PLL_CPU_CONFIG 0x18050000 #define PLL_SW_UPDATE (1 << 31) diff --git a/sys/mips/atheros/files.ar71xx b/sys/mips/atheros/files.ar71xx index 29add2e..ee2ad87 100644 --- a/sys/mips/atheros/files.ar71xx +++ b/sys/mips/atheros/files.ar71xx @@ -1,6 +1,7 @@ # $FreeBSD$ mips/atheros/apb.c standard +mips/atheros/ar71xx_gpio.c optional gpio mips/atheros/ar71xx_machdep.c standard mips/atheros/ar71xx_ehci.c optional ehci mips/atheros/ar71xx_ohci.c optional ohci diff --git a/sys/mips/conf/AR71XX b/sys/mips/conf/AR71XX index cfdd82d..4cb3f23 100644 --- a/sys/mips/conf/AR71XX +++ b/sys/mips/conf/AR71XX @@ -69,6 +69,9 @@ device arge # options USB_DEBUG # device ehci +device gpio +device gpioled + device spibus device ar71xx_spi device mx25l diff --git a/sys/mips/conf/AR71XX.hints b/sys/mips/conf/AR71XX.hints index 0593dc0..2b7bac0 100644 --- a/sys/mips/conf/AR71XX.hints +++ b/sys/mips/conf/AR71XX.hints @@ -48,5 +48,17 @@ hint.spi.0.msize=0x10 hint.mx25l.0.at="spibus0" hint.mx25l.0.cs=0 +# GPIO +hint.gpio.0.at="apb0" +hint.gpio.0.maddr=0x18040000 +hint.gpio.0.msize=0x1000 +hint.gpio.0.irq=2 + +# RF led +hint.gpioled.0.at="gpiobus0" +hint.gpioled.0.name="rf" +# pin 2 +hint.gpioled.0.pins=0x0004 + # Watchdog hint.ar71xx_wdog.0.at="nexus0" diff --git a/sys/sys/gpio.h b/sys/sys/gpio.h new file mode 100644 index 0000000..3222aed --- /dev/null +++ b/sys/sys/gpio.h @@ -0,0 +1,94 @@ +/* $NetBSD: gpio.h,v 1.7 2009/09/25 20:27:50 mbalmer Exp $ */ +/* $OpenBSD: gpio.h,v 1.7 2008/11/26 14:51:20 mbalmer Exp $ */ +/*- + * Copyright (c) 2009, Oleksandr Tymoshenko + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ +/* + * Copyright (c) 2009 Marc Balmer + * Copyright (c) 2004 Alexander Yurchenko + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __GPIO_H__ +#define __GPIO_H__ + +#include + +/* GPIO pin states */ +#define GPIO_PIN_LOW 0x00 /* low level (logical 0) */ +#define GPIO_PIN_HIGH 0x01 /* high level (logical 1) */ + +/* Max name length of a pin */ +#define GPIOMAXNAME 64 + +/* GPIO pin configuration flags */ +#define GPIO_PIN_INPUT 0x0001 /* input direction */ +#define GPIO_PIN_OUTPUT 0x0002 /* output direction */ +#define GPIO_PIN_OPENDRAIN 0x0004 /* open-drain output */ +#define GPIO_PIN_PUSHPULL 0x0008 /* push-pull output */ +#define GPIO_PIN_TRISTATE 0x0010 /* output disabled */ +#define GPIO_PIN_PULLUP 0x0020 /* internal pull-up enabled */ +#define GPIO_PIN_PULLDOWN 0x0040 /* internal pull-down enabled */ +#define GPIO_PIN_INVIN 0x0080 /* invert input */ +#define GPIO_PIN_INVOUT 0x0100 /* invert output */ +#define GPIO_PIN_PULSATE 0x0200 /* pulsate in hardware */ + +struct gpio_pin { + uint32_t gp_pin; /* pin number */ + char gp_name[GPIOMAXNAME]; /* human-readable name */ + uint32_t gp_caps; /* capabilities */ + uint32_t gp_flags; /* current flags */ +}; + +/* GPIO pin request (read/write/toggle) */ +struct gpio_req { + uint32_t gp_pin; /* pin number */ + uint32_t gp_value; /* value */ +}; + + +/* + * ioctls + */ +#define GPIOMAXPIN _IOR('G', 0, int) +#define GPIOGETCONFIG _IOWR('G', 1, struct gpio_pin) +#define GPIOSETCONFIG _IOW('G', 2, struct gpio_pin) +#define GPIOGET _IOWR('G', 3, struct gpio_req) +#define GPIOSET _IOW('G', 4, struct gpio_req) +#define GPIOTOGGLE _IOWR('G', 5, struct gpio_req) + +#endif /* __GPIO_H__ */ diff --git a/usr.bin/Makefile b/usr.bin/Makefile index 6497743..37581b8 100644 --- a/usr.bin/Makefile +++ b/usr.bin/Makefile @@ -75,6 +75,7 @@ SUBDIR= alias \ getconf \ getent \ getopt \ + gpioctl \ ${_gprof} \ gzip \ head \ diff --git a/usr.bin/gpioctl/Makefile b/usr.bin/gpioctl/Makefile new file mode 100644 index 0000000..1daf641 --- /dev/null +++ b/usr.bin/gpioctl/Makefile @@ -0,0 +1,6 @@ +# @(#)Makefile 8.1 (Berkeley) 6/9/93 +# $FreeBSD$ + +PROG= gpioctl + +.include diff --git a/usr.bin/gpioctl/gpioctl.1 b/usr.bin/gpioctl/gpioctl.1 new file mode 100644 index 0000000..116e471 --- /dev/null +++ b/usr.bin/gpioctl/gpioctl.1 @@ -0,0 +1,47 @@ +.\" Copyright (c) 1980, 1991, 1993 +.\" The Regents of the University of California. All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" 3. All advertising materials mentioning features or use of this software +.\" must display the following acknowledgement: +.\" This product includes software developed by the University of +.\" California, Berkeley and its contributors. +.\" 4. Neither the name of the University nor the names of its contributors +.\" may be used to endorse or promote products derived from this software +.\" without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $FreeBSD$ +.\" +.Dd November 18, 2009 +.Dt GPIOCTL 1 +.Os +.Sh NAME +.Nm gpioctl +.Nd manage GPIO devices +.Sh SYNOPSIS +.Nm +.Sh DESCRIPTION +The +.Nm +utility manages GPIO devices +.Sh HISTORY +None diff --git a/usr.bin/gpioctl/gpioctl.c b/usr.bin/gpioctl/gpioctl.c new file mode 100644 index 0000000..abbe95d --- /dev/null +++ b/usr.bin/gpioctl/gpioctl.c @@ -0,0 +1,327 @@ +/*- + * Copyright (c) 2009, Oleksandr Tymoshenko + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +struct flag_desc { + const char *name; + uint32_t flag; +}; + +struct flag_desc gpio_flags[] = { + { "IN", GPIO_PIN_INPUT }, + { "OUT", GPIO_PIN_OUTPUT }, + { "OD", GPIO_PIN_OPENDRAIN }, + { "PP", GPIO_PIN_PUSHPULL }, + { "TS", GPIO_PIN_TRISTATE }, + { "PU", GPIO_PIN_PULLUP }, + { "PD", GPIO_PIN_PULLDOWN }, + { "II", GPIO_PIN_INVIN }, + { "IO", GPIO_PIN_INVOUT }, + { "PULSE", GPIO_PIN_PULSATE }, + { NULL, 0 }, +}; + +static void usage(void); +static const char* cap2str(uint32_t); +int str2cap(const char*); +static int str2int(const char*, int*); +static void print_caps(int); +static void dump_pins(int, int); +static void fail(const char*, ...); + +int +main(int argc, char **argv) +{ + int i; + struct gpio_pin pin; + struct gpio_req req; + char *ctlfile = NULL; + int pinn, pinv, fd, ch; + int flags, flag, ok; + int config, toggle, verbose, list; + + pinn = config = toggle = verbose = list = 0; + + while ((ch = getopt(argc, argv, "c:f:lt:v")) != -1) { + switch (ch) { + case 'c': + config = 1; + pinn = str2int(optarg, &ok); + if (!ok) + fail("Invalid pin number: %s\n", optarg); + break; + case 'f': + ctlfile = optarg; + break; + case 'l': + list = 1; + break; + case 't': + toggle = 1; + pinn = str2int(optarg, &ok); + if (!ok) + fail("Invalid pin number: %s\n", optarg); + break; + case 'v': + verbose = 1; + break; + default: + usage(); + break; + } + } + argv += optind; + argc -= optind; + for (i = 0; i < argc; i++) + printf("%d/%s\n", i, argv[i]); + + if (ctlfile == NULL) + fail("No gpioctl device provided\n"); + + fd = open(ctlfile, O_RDONLY); + if (fd < 0) { + perror("open"); + exit(1); + } + + if (list) { + dump_pins(fd, verbose); + close(fd); + exit(0); + } + + if (toggle) { + /* + * -t pin assumes no additional arguments + */ + if(argc > 0) { + usage(); + exit(1); + } + + req.gp_pin = pinn; + if (ioctl(fd, GPIOTOGGLE, &req) < 0) { + perror("ioctl(GPIOTOGGLE)"); + exit(1); + } + + close(fd); + exit (0); + } + + if (config) { + flags = 0; + for (i = 0; i < argc; i++) { + flag = str2cap(argv[i]); + if (flag < 0) + fail("Invalid flag: %s\n", argv[i]); + flags |= flag; + } + + pin.gp_pin = pinn; + pin.gp_flags = flags; + if (ioctl(fd, GPIOSETCONFIG, &pin) < 0) { + perror("ioctl(GPIOSETCONFIG)"); + exit(1); + } + + exit(0); + } + + /* + * Last two cases - set value or print value + */ + if ((argc == 0) || (argc > 2)) { + usage(); + exit(1); + } + + pinn = str2int(argv[0], &ok); + if (!ok) + fail("Invalid pin number: %s\n", argv[0]); + + /* + * Read pin value + */ + if (argc == 1) { + req.gp_pin = pinn; + if (ioctl(fd, GPIOGET, &req) < 0) { + perror("ioctl(GPIOGET)"); + exit(1); + } + printf("%d\n", req.gp_value); + exit (0); + } + + /* + * Set pin value + */ + + /* Is it valid number and 0 or 1? */ + pinv = str2int(argv[0], &ok); + if (!ok || ((pinv != 0) && (pinv != 1))) + fail("Invalid pin value: %s\n", argv[0]); + + req.gp_pin = pinn; + req.gp_pin = pinv; + if (ioctl(fd, GPIOSET, &req) < 0) { + perror("ioctl(GPIOSET)"); + exit(1); + } + + close(fd); + exit(0); +} + +static void +usage() +{ + fprintf(stderr, "Usage:\n"); + fprintf(stderr, "\tgpioctl -f ctldev -l [-v]\n"); + fprintf(stderr, "\tgpioctl -f ctldev -t pin\n"); + fprintf(stderr, "\tgpioctl -f ctldev -c pin flag ...\n"); + fprintf(stderr, "\tgpioctl -f ctldev pin [0|1]\n"); + exit(1); +} + +static const char * +cap2str(uint32_t cap) +{ + struct flag_desc * pdesc = gpio_flags; + while (pdesc->name) { + if (pdesc->flag == cap) + return pdesc->name; + pdesc++; + } + + return "UNKNOWN"; +} + +int +str2cap(const char *str) +{ + struct flag_desc * pdesc = gpio_flags; + while (pdesc->name) { + if (strcasecmp(str, pdesc->name)) + return pdesc->flag; + pdesc++; + } + + return (-1); +} + +/* + * Our handmade function for converting string to number + */ +static int +str2int(const char *s, int *ok) +{ + char *endptr; + int res = strtod(s, &endptr); + if (endptr != s + strlen(s) ) + *ok = 0; + else + *ok = 1; + + return res; +} + +static void +print_caps(int caps) +{ + int i, need_coma; + + need_coma = 0; + printf("<"); + for (i = 0; i < 32; i++) { + if (caps & (1 << i)) { + if (need_coma) + printf(","); + printf("%s", cap2str(1 << i)); + need_coma = 1; + } + } + printf(">"); +} + +static void +dump_pins(int fd, int verbose) +{ + int i, maxpin; + struct gpio_pin pin; + struct gpio_req req; + + if (ioctl(fd, GPIOMAXPIN, &maxpin) < 0) { + perror("ioctl(GPIOMAXPIN)"); + exit(1); + } + + for (i = 0; i <= maxpin; i++) { + pin.gp_pin = i; + if (ioctl(fd, GPIOGETCONFIG, &pin) < 0) + /* For some reason this pin is inaccessible */ + continue; + + req.gp_pin = i; + if (ioctl(fd, GPIOGET, &req) < 0) { + /* Now, that's wrong */ + perror("ioctl(GPIOGET)"); + exit(1); + } + + printf("pin %02d:\t%d\t%s", pin.gp_pin, req.gp_value, + pin.gp_name); + + print_caps(pin.gp_flags); + + if (verbose) { + printf(", caps:"); + print_caps(pin.gp_caps); + } + printf("\n"); + } +} + +static void +fail(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + exit(1); +} --Apple-Mail-6--206473323 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset=us-ascii --Apple-Mail-6--206473323 Content-Disposition: attachment; filename=gpioctl.c Content-Type: application/octet-stream; name="gpioctl.c" Content-Transfer-Encoding: 7bit /*- * Copyright (c) 2009, Oleksandr Tymoshenko * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice unmodified, this list of conditions, and the following * disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include struct flag_desc { const char *name; uint32_t flag; }; struct flag_desc gpio_flags[] = { { "IN", GPIO_PIN_INPUT }, { "OUT", GPIO_PIN_OUTPUT }, { "OD", GPIO_PIN_OPENDRAIN }, { "PP", GPIO_PIN_PUSHPULL }, { "TS", GPIO_PIN_TRISTATE }, { "PU", GPIO_PIN_PULLUP }, { "PD", GPIO_PIN_PULLDOWN }, { "II", GPIO_PIN_INVIN }, { "IO", GPIO_PIN_INVOUT }, { "PULSE", GPIO_PIN_PULSATE }, { NULL, 0 }, }; static void usage(void); static const char* cap2str(uint32_t); int str2cap(const char*); static int str2int(const char*, int*); static void print_caps(int); static void dump_pins(int, int); static void fail(const char*, ...); int main(int argc, char **argv) { int i; struct gpio_pin pin; struct gpio_req req; char *ctlfile = NULL; int pinn, pinv, fd, ch; int flags, flag, ok; int config, toggle, verbose, list; pinn = config = toggle = verbose = list = 0; while ((ch = getopt(argc, argv, "c:f:lt:v")) != -1) { switch (ch) { case 'c': config = 1; pinn = str2int(optarg, &ok); if (!ok) fail("Invalid pin number: %s\n", optarg); break; case 'f': ctlfile = optarg; break; case 'l': list = 1; break; case 't': toggle = 1; pinn = str2int(optarg, &ok); if (!ok) fail("Invalid pin number: %s\n", optarg); break; case 'v': verbose = 1; break; default: usage(); break; } } argv += optind; argc -= optind; for (i = 0; i < argc; i++) printf("%d/%s\n", i, argv[i]); if (ctlfile == NULL) fail("No gpioctl device provided\n"); fd = open(ctlfile, O_RDONLY); if (fd < 0) { perror("open"); exit(1); } if (list) { dump_pins(fd, verbose); close(fd); exit(0); } if (toggle) { /* * -t pin assumes no additional arguments */ if(argc > 0) { usage(); exit(1); } req.gp_pin = pinn; if (ioctl(fd, GPIOTOGGLE, &req) < 0) { perror("ioctl(GPIOTOGGLE)"); exit(1); } close(fd); exit (0); } if (config) { flags = 0; for (i = 0; i < argc; i++) { flag = str2cap(argv[i]); if (flag < 0) fail("Invalid flag: %s\n", argv[i]); flags |= flag; } pin.gp_pin = pinn; pin.gp_flags = flags; if (ioctl(fd, GPIOSETCONFIG, &pin) < 0) { perror("ioctl(GPIOSETCONFIG)"); exit(1); } exit(0); } /* * Last two cases - set value or print value */ if ((argc == 0) || (argc > 2)) { usage(); exit(1); } pinn = str2int(argv[0], &ok); if (!ok) fail("Invalid pin number: %s\n", argv[0]); /* * Read pin value */ if (argc == 1) { req.gp_pin = pinn; if (ioctl(fd, GPIOGET, &req) < 0) { perror("ioctl(GPIOGET)"); exit(1); } printf("%d\n", req.gp_value); exit (0); } /* * Set pin value */ /* Is it valid number and 0 or 1? */ pinv = str2int(argv[0], &ok); if (!ok || ((pinv != 0) && (pinv != 1))) fail("Invalid pin value: %s\n", argv[0]); req.gp_pin = pinn; req.gp_pin = pinv; if (ioctl(fd, GPIOSET, &req) < 0) { perror("ioctl(GPIOSET)"); exit(1); } close(fd); exit(0); } static void usage(void) { fprintf(stderr, "Usage:\n"); fprintf(stderr, "\tgpioctl -f ctldev -l [-v]\n"); fprintf(stderr, "\tgpioctl -f ctldev -t pin\n"); fprintf(stderr, "\tgpioctl -f ctldev -c pin flag ...\n"); fprintf(stderr, "\tgpioctl -f ctldev pin [0|1]\n"); exit(1); } static const char * cap2str(uint32_t cap) { struct flag_desc * pdesc = gpio_flags; while (pdesc->name) { if (pdesc->flag == cap) return pdesc->name; pdesc++; } return "UNKNOWN"; } int str2cap(const char *str) { struct flag_desc * pdesc = gpio_flags; while (pdesc->name) { if (strcasecmp(str, pdesc->name)) return pdesc->flag; pdesc++; } return (-1); } /* * Our handmade function for converting string to number */ static int str2int(const char *s, int *ok) { char *endptr; int res = strtod(s, &endptr); if (endptr != s + strlen(s) ) *ok = 0; else *ok = 1; return res; } static void print_caps(int caps) { int i, need_coma; need_coma = 0; printf("<"); for (i = 0; i < 32; i++) { if (caps & (1 << i)) { if (need_coma) printf(","); printf("%s", cap2str(1 << i)); need_coma = 1; } } printf(">"); } static void dump_pins(int fd, int verbose) { int i, maxpin; struct gpio_pin pin; struct gpio_req req; if (ioctl(fd, GPIOMAXPIN, &maxpin) < 0) { perror("ioctl(GPIOMAXPIN)"); exit(1); } for (i = 0; i <= maxpin; i++) { pin.gp_pin = i; if (ioctl(fd, GPIOGETCONFIG, &pin) < 0) /* For some reason this pin is inaccessible */ continue; req.gp_pin = i; if (ioctl(fd, GPIOGET, &req) < 0) { /* Now, that's wrong */ perror("ioctl(GPIOGET)"); exit(1); } printf("pin %02d:\t%d\t%s", pin.gp_pin, req.gp_value, pin.gp_name); print_caps(pin.gp_flags); if (verbose) { printf(", caps:"); print_caps(pin.gp_caps); } printf("\n"); } } static void fail(const char *fmt, ...) { va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap); exit(1); } --Apple-Mail-6--206473323 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset=us-ascii --Apple-Mail-6--206473323 Content-Disposition: attachment; filename=RB4XX Content-Type: application/octet-stream; name="RB4XX" Content-Transfer-Encoding: 7bit # # $FreeBSD$ # ident RB4XX cpu CPU_MIPS4KC options ISA_MIPS32 makeoptions TARGET_BIG_ENDIAN makeoptions KERNLOADADDR=0x80050000 options HZ=1000 files "../atheros/files.ar71xx" hints "RB450.hints" #makeoptions DEBUG=-g #Build kernel with gdb(1) debug symbols makeoptions MODULES_OVERRIDE="" #options DDB #options KDB options SCHED_4BSD #4BSD scheduler options INET #InterNETworking options NFSCLIENT #Network Filesystem Client options NFS_ROOT #NFS usable as /, requires NFSCLIENT options PSEUDOFS #Pseudo-filesystem framework options _KPOSIX_PRIORITY_SCHEDULING #Posix P1003_1B real-time extensions # options NFS_LEGACYRPC # Debugging for use in -current # options INVARIANTS # options INVARIANT_SUPPORT # options WITNESS # options WITNESS_SKIPSPIN options FFS #Berkeley Fast Filesystem options SOFTUPDATES #Enable FFS soft updates support options UFS_ACL #Support for access control lists options UFS_DIRHASH #Improve performance on big directories options BOOTP options BOOTP_NFSROOT options BOOTP_NFSV3 options BOOTP_WIRED_TO=arge1 options BOOTP_COMPAT options ROOTDEVNAME=\"nfs:192.168.10.1:/mnt/bsd\" device pci #device ath # Atheros pci/cardbus NIC's #options ATH_DEBUG #device ath_hal #option AH_SUPPORT_AR5416 #device ath_rate_sample device mii device arge device usb options USB_EHCI_BIG_ENDIAN_DESC # handle big-endian byte order options USB_DEBUG device ehci device gpio device gpioled device spibus device ar71xx_spi #device nand # Generic NAND disk support #device rb_nand # RouterBoard NAND Support #device geom_nand # NAND slices support #options YAFFS device ar71xx_wdog device uart device loop device ether device md device bpf device random device if_bridge device pf device pfsync device pflog options RB_GPIO_PINS options FIX_RB_MAC_ADDRESS --Apple-Mail-6--206473323 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset=us-ascii --Apple-Mail-6--206473323 Content-Disposition: attachment; filename=RB450.hints Content-Type: application/octet-stream; name="RB450.hints" Content-Transfer-Encoding: 7bit # $FreeBSD$ hint.apb.0.at="nexus0" hint.apb.0.irq=4 # uart0 hint.uart.0.at="apb0" # see atheros/uart_cpu_ar71xx.c why +3 hint.uart.0.maddr=0x18020003 hint.uart.0.msize=0x18 hint.uart.0.irq=3 #ohci #hint.ohci.0.at="apb0" #hint.ohci.0.maddr=0x1c000000 #hint.ohci.0.msize=0x01000000 #hint.ohci.0.irq=6 # ehci hint.ehci.0.at="nexus0" hint.ehci.0.maddr=0x1b000000 hint.ehci.0.msize=0x01000000 hint.ehci.0.irq=1 # pci #hint.pcib.0.at="nexus0" #hint.pcib.0.irq=0 hint.arge.0.at="nexus0" hint.arge.0.maddr=0x19000000 hint.arge.0.msize=0x1000 hint.arge.0.irq=2 # PHY0, PHY1, PHY2, PHY3 hint.arge.0.phymask=0x0f hint.arge.1.at="nexus0" hint.arge.1.maddr=0x1A000000 hint.arge.1.msize=0x1000 hint.arge.1.irq=3 # PHY4 hint.arge.1.phymask=0x10 # Watchdog hint.ar71xx_wdog.0.at="nexus0" # GPIO hint.gpio.0.at="apb0" hint.gpio.0.maddr=0x18040000 hint.gpio.0.msize=0x1000 hint.gpio.0.irq=2 # User led hint.gpioled.0.at="gpiobus0" hint.gpioled.0.name="user" # pin 4 hint.gpioled.0.pins=0x0010 # SPI flash hint.spi.0.at="nexus0" hint.spi.0.maddr=0x1f000000 hint.spi.0.msize=0x10 # RB Flash #hint.rb_nand.0.at="spibus0" #hint.rb_nand.0.cs=0 # NAND slices for RouterBoard hint.nand_slice.0.size="0x40000" hint.nand_slice.0.offset="0" hint.nand_slice.0.name="bootloader" hint.nand_slice.1.size="0x3c0000" hint.nand_slice.1.offset="0x40000" hint.nand_slice.1.name="kernelfs" hint.nand_slice.2.size="0" hint.nand_slice.2.offset="0x400000" hint.nand_slice.2.name="rootfs" --Apple-Mail-6--206473323-- From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 13:36:18 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id C099B106567A; Tue, 15 Jun 2010 13:36:18 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-vw0-f54.google.com (mail-vw0-f54.google.com [209.85.212.54]) by mx1.freebsd.org (Postfix) with ESMTP id 02E658FC14; Tue, 15 Jun 2010 13:36:17 +0000 (UTC) Received: by vws20 with SMTP id 20so6823203vws.13 for ; Tue, 15 Jun 2010 06:36:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:date:message-id :subject:from:to:content-type; bh=7KTjS7H2rU6skPM2R1BDUOvgUaOLHZNqiFpm4V6DN4E=; b=R83s5I+yAeDAZ7eYFO/IsziC9ObIqk1UkcnTVTAI7Mgcs9k6guTZo/aoUFi5bOEFCZ wmoMXr80HWA7F+1zR2NDi8Vwd1sM4ny2qJgxYHy6iaRG1Xf1osqbdpBviIujtT7D3pAw dUX3RM+2sktpCGiaVfg+8aHnhcfz7gXknOKBg= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:date:message-id:subject:from:to:content-type; b=tUphv+5dBBpBTxpaXvtWCP94KBsxxd2Rz8Z3K4VIDJY1WqHl1g8dHkIV63XtI9+jjY m4bchoYKdG4a2pL4iwdBFdDx4U7sknHSC5VqS9LwqLGklCFagLemctWr0N39/xuYpBVH vPjyz1D2pu8k9rFxsGu+7PGmns7OGVgemR4Xc= MIME-Version: 1.0 Received: by 10.220.63.136 with SMTP id b8mr3927460vci.109.1276608977023; Tue, 15 Jun 2010 06:36:17 -0700 (PDT) Received: by 10.220.199.136 with HTTP; Tue, 15 Jun 2010 06:36:16 -0700 (PDT) Date: Tue, 15 Jun 2010 19:06:16 +0530 Message-ID: From: "Jayachandran C." To: Randall Stewart , Juli Mallett , "M. Warner Losh" , freebsd-mips@freebsd.org Content-Type: multipart/mixed; boundary=e0cb4e88758397b495048911b0d9 Cc: Subject: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 13:36:18 -0000 --e0cb4e88758397b495048911b0d9 Content-Type: text/plain; charset=ISO-8859-1 I have volunteered to merge Juli's 64-bit work into HEAD, and hopefully get it to work on XLR too. The tree (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of changes, so I would like to do this over multiple changesets and without breaking the current o32 code. The first batch of changes are attached (also at http://people.freebsd.org/~jchandra/jmallett-merge/), the patches are: libc-asm.patch - change libc assembly code to use macros which work on o32/n64 libc-other.patch - makecontext implemenation, and other cleanup ld.so.patch - change dynamic loader assembly code to use macros tlb-to-c.patch - move TLB operations to C, update TLB operations API I've tested this on XLR, but there is a chance that this might break other platforms. So please let me know your comments on both the patches and the merge process. The future patches (if everything goes well), will do the PTE_ flag to PG_ flag renaming in Juli's tree, then the actual n32/n64 changes. Thanks, JC. --e0cb4e88758397b495048911b0d9 Content-Type: text/x-patch; charset=US-ASCII; name="libc-asm.patch" Content-Disposition: attachment; filename="libc-asm.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gagrfoy80 SW5kZXg6IGxpYi9saWJjL21pcHMvU1lTLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9T WVMuaAkocmV2aXNpb24gMjA5MDQwKQorKysgbGliL2xpYmMvbWlwcy9TWVMuaAkod29ya2luZyBj b3B5KQpAQCAtMSw0ICsxLDQgQEAKLS8qCSROZXRCU0Q6IFNZUy5oLHYgMS4xOCAyMDAzLzEwLzI5 IDEyOjI4OjMzIHBvb2thIEV4cCAkICovCisvKgkkTmV0QlNEOiBTWVMuaCx2IDEuMTkgMjAwOS8x Mi8xNCAwMTowNzo0MSBtYXR0IEV4cCAkICovCiAvKiAkRnJlZUJTRCQgKi8KIAogLyotCkBAIC03 OSwxNCArNzksMjIgQEAKICAqLwogI2lmZGVmIF9fQUJJQ0FMTFNfXwogCS5hYmljYWxscwotIyBk ZWZpbmUgUElDX1BST0xPR1VFKHgsc3IpCS5zZXQgbm9yZW9yZGVyOyAuY3Bsb2FkIHNyOyAuc2V0 IHJlb3JkZXIKLSMgZGVmaW5lIFBJQ19DQUxMKGwsc3IpCQlsYSBzciwgX0NfTEFCRUwobCk7IGpy IHNyCisjIGlmIGRlZmluZWQoX19taXBzX28zMikgfHwgZGVmaW5lZChfX21pcHNfbzY0KQorIyAg ZGVmaW5lIFBJQ19QUk9MT0dVRSh4KQlTRVRVUF9HUAorIyAgZGVmaW5lIFBJQ19UQUlMQ0FMTChs KQlQVFJfTEEgdDksIF9DX0xBQkVMKGwpOyBqciB0OQorIyAgZGVmaW5lIFBJQ19SRVRVUk4oKQkJ aiByYQorIyBlbHNlCisjICBkZWZpbmUgUElDX1BST0xPR1VFKHgpCVNFVFVQX0dQNjQodDMsIHgp CisjICBkZWZpbmUgUElDX1RBSUxDQUxMKGwpCVBUUl9MQSB0OSwgX0NfTEFCRUwobCk7IFJFU1RP UkVfR1A2NDsganIgdDkKKyMgIGRlZmluZSBQSUNfUkVUVVJOKCkJCVJFU1RPUkVfR1A2NDsgaiBy YQorIyBlbmRpZgogI2Vsc2UKLSMgZGVmaW5lIFBJQ19QUk9MT0dVRSh4LHNyKQotIyBkZWZpbmUg UElDX0NBTEwobCxzcikJCWogIF9DX0xBQkVMKGwpCi0jZW5kaWYKKyMgZGVmaW5lIFBJQ19QUk9M T0dVRSh4KQorIyBkZWZpbmUgUElDX1RBSUxDQUxMKGwpCWogIF9DX0xBQkVMKGwpCisjIGRlZmlu ZSBQSUNfUkVUVVJOKCkKKyNlbmRpZiAvKiBfX0FCSUNBTExTX18gKi8KIAotIyBkZWZpbmUgU1lT VFJBUCh4KQlsaSB2MCwgU1lTXyAjIyB4OyBzeXNjYWxsOworIyBkZWZpbmUgU1lTVFJBUCh4KQls aSB2MCxTWVNfICMjIHg7IHN5c2NhbGw7CiAKIC8qCiAgKiBEbyBhIHN5c2NhbGwgdGhhdCBjYW5u b3QgZmFpbCAoc3luYywgZ2V0e3AsdSxnLGV1LGVnKWlkKQpAQCAtMTA2LDcgKzExNCw3IEBACiAg Ki8KICNkZWZpbmUgUFNFVURPX05PRVJST1IoeCkJCQkJCQlcCiBMRUFGKF9fc3lzXyAjIyB4KTsJ CQkJCQkJXAotICAgICAgICAud2VhayBfQ19MQUJFTCh4KTsJCQkJCQlcCisJLndlYWsgX0NfTEFC RUwoeCk7CQkJCQkJXAogCV9DX0xBQkVMKHgpID0gX0NfTEFCRUwoX19DT05DQVQoX19zeXNfLHgp KTsJCQlcCiAJLndlYWsgX0NfTEFCRUwoX19DT05DQVQoXyx4KSk7CQkJCQlcCiAJX0NfTEFCRUwo X19DT05DQVQoXyx4KSkgPSBfQ19MQUJFTChfX0NPTkNBVChfX3N5c18seCkpOwkJXApAQCAtMTE2 LDE0ICsxMjQsMTQgQEAKIAogI2RlZmluZSBQU0VVRE8oeCkJCQkJCQkJXAogTEVBRihfX3N5c18g IyMgeCk7CQkJCQkJCVwKLSAgICAgICAgLndlYWsgX0NfTEFCRUwoeCk7CQkJCQkJXAorCS53ZWFr IF9DX0xBQkVMKHgpOwkJCQkJCVwKIAlfQ19MQUJFTCh4KSA9IF9DX0xBQkVMKF9fQ09OQ0FUKF9f c3lzXyx4KSk7CQkJXAogCS53ZWFrIF9DX0xBQkVMKF9fQ09OQ0FUKF8seCkpOwkJCQkJXAogCV9D X0xBQkVMKF9fQ09OQ0FUKF8seCkpID0gX0NfTEFCRUwoX19DT05DQVQoX19zeXNfLHgpKTsJCVwK LQlQSUNfUFJPTE9HVUUoeCx0OSk7CQkJCQkJXAorCVBJQ19QUk9MT0dVRShfX3N5c18gIyMgeCk7 CQkJCQlcCiAJU1lTVFJBUCh4KTsJCQkJCQkJXAogCWJuZSBhMyx6ZXJvLGVycjsJCQkJCQlcCi0J aiByYTsJCQkJCQkJCVwKKwlQSUNfUkVUVVJOKCk7CQkJCQkJCVwKIGVycjoJCQkJCQkJCQlcCi0J UElDX0NBTEwoX19jZXJyb3IsdDkpOwkJCQkJCVwKLQlFTkQoX19zeXNfICMjIHgpCisJUElDX1RB SUxDQUxMKF9fY2Vycm9yKTsJCQkJCQlcCitFTkQoX19zeXNfICMjIHgpCkluZGV4OiBsaWIvbGli Yy9taXBzL3N0cmluZy9mZnMuUwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL3N0cmluZy9m ZnMuUwkocmV2aXNpb24gMjA5MDQwKQorKysgbGliL2xpYmMvbWlwcy9zdHJpbmcvZmZzLlMJKHdv cmtpbmcgY29weSkKQEAgLTEsNCArMSw0IEBACi0vKgkkTmV0QlNEOiBmZnMuUyx2IDEuMSAyMDA1 LzEyLzIwIDE5OjI4OjQ5IGNocmlzdG9zIEV4cCAkCSovCisvKgkkTmV0QlNEOiBmZnMuUyx2IDEu MiAyMDA5LzEyLzE0IDAwOjM5OjAwIG1hdHQgRXhwICQJKi8KIAogLyotCiAgKiBDb3B5cmlnaHQg KGMpIDE5OTEsIDE5OTMKQEAgLTM3LDcgKzM3LDcgQEAKIAogI2lmIGRlZmluZWQoTElCQ19TQ0NT KSAmJiAhZGVmaW5lZChsaW50KQogCUFTTVNUUigiZnJvbTogQCgjKWZmcy5zCTguMSAoQmVya2Vs ZXkpIDYvNC85MyIpCi0JQVNNU1RSKCIkTmV0QlNEOiBmZnMuUyx2IDEuMSAyMDA1LzEyLzIwIDE5 OjI4OjQ5IGNocmlzdG9zIEV4cCAkIikKKwlBU01TVFIoIiROZXRCU0Q6IGZmcy5TLHYgMS4yIDIw MDkvMTIvMTQgMDA6Mzk6MDAgbWF0dCBFeHAgJCIpCiAjZW5kaWYgLyogTElCQ19TQ0NTIGFuZCBu b3QgbGludCAqLwogCiAjaWZkZWYgX19BQklDQUxMU19fCkluZGV4OiBsaWIvbGliYy9taXBzL3N0 cmluZy9iY21wLlMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9zdHJpbmcvYmNtcC5TCShy ZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBzL3N0cmluZy9iY21wLlMJKHdvcmtpbmcg Y29weSkKQEAgLTEsNCArMSw0IEBACi0vKgkkTmV0QlNEOiBiY21wLlMsdiAxLjggMjAwMy8wOC8w NyAxNjo0MjoxNiBhZ2MgRXhwICQJKi8KKy8qCSROZXRCU0Q6IGJjbXAuUyx2IDEuOSAyMDA5LzEy LzE0IDAxOjA3OjQyIG1hdHQgRXhwICQJKi8KIAogLyotCiAgKiBDb3B5cmlnaHQgKGMpIDE5OTEs IDE5OTMKQEAgLTM1LDkgKzM1LDE1IEBACiAjaW5jbHVkZSA8bWFjaGluZS9hc20uaD4KIF9fRkJT RElEKCIkRnJlZUJTRCQiKTsKIAorI2RlZmluZSBfTE9DT1JFCQkvKiBYWFggbm90IHJlYWxseSwg anVzdCBhc3NlbWJseS1jb2RlIHNvdXJjZSAqLworI2luY2x1ZGUgPG1hY2hpbmUvZW5kaWFuLmg+ CS8qIExXTE8vTFdISSwgU1dMTy9TV0hJICovCisKICNpZiBkZWZpbmVkKExJQkNfU0NDUykgJiYg IWRlZmluZWQobGludCkKKyNpZiAwCiAJQVNNU1RSKCJmcm9tOiBAKCMpYmNtcC5zCTguMSAoQmVy a2VsZXkpIDYvNC85MyIpCi0JQVNNU1RSKCIkTmV0QlNEOiBiY21wLlMsdiAxLjggMjAwMy8wOC8w NyAxNjo0MjoxNiBhZ2MgRXhwICQiKQorI2Vsc2UKKwlBU01TVFIoIiROZXRCU0Q6IGJjbXAuUyx2 IDEuOSAyMDA5LzEyLzE0IDAxOjA3OjQyIG1hdHQgRXhwICQiKQorI2VuZGlmCiAjZW5kaWYgLyog TElCQ19TQ0NTIGFuZCBub3QgbGludCAqLwogCiAjaWZkZWYgX19BQklDQUxMU19fCkBAIC00OSw4 NiArNTUsNzYgQEAKIAogTEVBRihiY21wKQogCS5zZXQJbm9yZW9yZGVyCi0JYmx0CWEyLCAxNiwg c21hbGwJCSMgaXMgaXQgd29ydGggYW55IHRyb3VibGU/Ci0JeG9yCXYwLCBhMCwgYTEJCSMgY29t cGFyZSBsb3cgdHdvIGJpdHMgb2YgYWRkcmVzc2VzCi0JYW5kCXYwLCB2MCwgMwotCXN1YnUJYTMs IHplcm8sIGExCQkjIGNvbXB1dGUgIyBieXRlcyB0byB3b3JkIGFsaWduIGFkZHJlc3MKLQlibmUJ djAsIHplcm8sIHVuYWxpZ25lZAkjIG5vdCBwb3NzaWJsZSB0byBhbGlnbiBhZGRyZXNzZXMKLQlh bmQJYTMsIGEzLCAzCisJYmx0CQlhMiwgMTYsIHNtYWxsCSMgaXMgaXQgd29ydGggYW55IHRyb3Vi bGU/CisJeG9yCQl2MCwgYTAsIGExCSMgY29tcGFyZSBsb3cgdHdvIGJpdHMgb2YgYWRkcmVzc2Vz CisJYW5kCQl2MCwgdjAsIDMKKwlQVFJfU1VCVQlhMywgemVybywgYTEJIyBjb21wdXRlICMgYnl0 ZXMgdG8gd29yZCBhbGlnbiBhZGRyZXNzCisJYm5lCQl2MCwgemVybywgdW5hbGlnbmVkICMgbm90 IHBvc3NpYmxlIHRvIGFsaWduIGFkZHJlc3NlcworCWFuZAkJYTMsIGEzLCAzCiAKLQliZXEJYTMs IHplcm8sIDFmCi0Jc3VidQlhMiwgYTIsIGEzCQkjIHN1YnRyYWN0IGZyb20gcmVtYWluaW5nIGNv dW50Ci0JbW92ZQl2MCwgdjEJCQkjIGluaXQgdjAsdjEgc28gdW5tb2RpZmllZCBieXRlcyBtYXRj aAotI2lmZGVmIF9fTUlQU0VCX18KLQlsd2wJdjAsIDAoYTApCQkjIHJlYWQgMSwgMiwgb3IgMyBi eXRlcwotCWx3bAl2MSwgMChhMSkKLSNlbHNlCi0JbHdyCXYwLCAwKGEwKQkJIyByZWFkIDEsIDIs IG9yIDMgYnl0ZXMKLQlsd3IJdjEsIDAoYTEpCi0jZW5kaWYKLQlhZGR1CWExLCBhMSwgYTMKLQli bmUJdjAsIHYxLCBub21hdGNoCi0JYWRkdQlhMCwgYTAsIGEzCisJYmVxCQlhMywgemVybywgMWYK KwlQVFJfU1VCVQlhMiwgYTIsIGEzCSMgc3VidHJhY3QgZnJvbSByZW1haW5pbmcgY291bnQKKwlt b3ZlCQl2MCwgdjEJCSMgaW5pdCB2MCx2MSBzbyB1bm1vZGlmaWVkIGJ5dGVzIG1hdGNoCisJTFdI SQkJdjAsIDAoYTApCSMgcmVhZCAxLCAyLCBvciAzIGJ5dGVzCisJTFdISQkJdjEsIDAoYTEpCisJ UFRSX0FERFUJYTEsIGExLCBhMworCWJuZQkJdjAsIHYxLCBub21hdGNoCisJUFRSX0FERFUJYTAs IGEwLCBhMwogMToKLQlhbmQJYTMsIGEyLCB+MwkJIyBjb21wdXRlIG51bWJlciBvZiB3aG9sZSB3 b3JkcyBsZWZ0Ci0Jc3VidQlhMiwgYTIsIGEzCQkjICAgd2hpY2ggaGFzIHRvIGJlID49ICgxNi0z KSAmIH4zCi0JYWRkdQlhMywgYTMsIGEwCQkjIGNvbXB1dGUgZW5kaW5nIGFkZHJlc3MKKwlhbmQJ CWEzLCBhMiwgfjMJIyBjb21wdXRlIG51bWJlciBvZiB3aG9sZSB3b3JkcyBsZWZ0CisJUFRSX1NV QlUJYTIsIGEyLCBhMwkjICAgd2hpY2ggaGFzIHRvIGJlID49ICgxNi0zKSAmIH4zCisJUFRSX0FE RFUJYTMsIGEzLCBhMAkjIGNvbXB1dGUgZW5kaW5nIGFkZHJlc3MKIDI6Ci0JbHcJdjAsIDAoYTAp CQkjIGNvbXBhcmUgd29yZHMKLQlsdwl2MSwgMChhMSkKLQlhZGR1CWEwLCBhMCwgNAotCWJuZQl2 MCwgdjEsIG5vbWF0Y2gKLQlhZGR1CWExLCBhMSwgNAotCWJuZQlhMCwgYTMsIDJiCisJbHcJCXYw LCAwKGEwKQkjIGNvbXBhcmUgd29yZHMKKwlsdwkJdjEsIDAoYTEpCisJUFRSX0FERFUJYTAsIGEw LCA0CisJYm5lCQl2MCwgdjEsIG5vbWF0Y2gKKwlQVFJfQUREVQlhMSwgYTEsIDQKKwlibmUJCWEw LCBhMywgMmIKIAlub3AKLQliCXNtYWxsCQkJIyBmaW5pc2ggcmVtYWluZGVyCisJYgkJc21hbGwJ CSMgZmluaXNoIHJlbWFpbmRlcgogCW5vcAogdW5hbGlnbmVkOgotCWJlcQlhMywgemVybywgMmYK LQlzdWJ1CWEyLCBhMiwgYTMJCSMgc3VidHJhY3QgZnJvbSByZW1haW5pbmcgY291bnQKLQlhZGR1 CWEzLCBhMywgYTAJCSMgY29tcHV0ZSBlbmRpbmcgYWRkcmVzcworCWJlcQkJYTMsIHplcm8sIDJm CisJUFRSX1NVQlUJYTIsIGEyLCBhMwkjIHN1YnRyYWN0IGZyb20gcmVtYWluaW5nIGNvdW50CisJ UFRSX0FERFUJYTMsIGEzLCBhMAkjIGNvbXB1dGUgZW5kaW5nIGFkZHJlc3MKIDE6Ci0JbGJ1CXYw LCAwKGEwKQkJIyBjb21wYXJlIGJ5dGVzIHVudGlsIGExIHdvcmQgYWxpZ25lZAotCWxidQl2MSwg MChhMSkKLQlhZGR1CWEwLCBhMCwgMQotCWJuZQl2MCwgdjEsIG5vbWF0Y2gKLQlhZGR1CWExLCBh MSwgMQotCWJuZQlhMCwgYTMsIDFiCisJbGJ1CQl2MCwgMChhMCkJIyBjb21wYXJlIGJ5dGVzIHVu dGlsIGExIHdvcmQgYWxpZ25lZAorCWxidQkJdjEsIDAoYTEpCisJUFRSX0FERFUJYTAsIGEwLCAx CisJYm5lCQl2MCwgdjEsIG5vbWF0Y2gKKwlQVFJfQUREVQlhMSwgYTEsIDEKKwlibmUJCWEwLCBh MywgMWIKIAlub3AKIDI6Ci0JYW5kCWEzLCBhMiwgfjMJCSMgY29tcHV0ZSBudW1iZXIgb2Ygd2hv bGUgd29yZHMgbGVmdAotCXN1YnUJYTIsIGEyLCBhMwkJIyAgIHdoaWNoIGhhcyB0byBiZSA+PSAo MTYtMykgJiB+MwotCWFkZHUJYTMsIGEzLCBhMAkJIyBjb21wdXRlIGVuZGluZyBhZGRyZXNzCisJ YW5kCQlhMywgYTIsIH4zCSMgY29tcHV0ZSBudW1iZXIgb2Ygd2hvbGUgd29yZHMgbGVmdAorCVBU Ul9TVUJVCWEyLCBhMiwgYTMJIyAgIHdoaWNoIGhhcyB0byBiZSA+PSAoMTYtMykgJiB+MworCVBU Ul9BRERVCWEzLCBhMywgYTAJIyBjb21wdXRlIGVuZGluZyBhZGRyZXNzCiAzOgotI2lmZGVmIF9f TUlQU0VCX18KLQlsd2wJdjAsIDAoYTApCQkjIGNvbXBhcmUgd29yZHMgYTAgdW5hbGlnbmVkLCBh MSBhbGlnbmVkCi0JbHdyCXYwLCAzKGEwKQotI2Vsc2UKLQlsd3IJdjAsIDAoYTApCQkjIGNvbXBh cmUgd29yZHMgYTAgdW5hbGlnbmVkLCBhMSBhbGlnbmVkCi0JbHdsCXYwLCAzKGEwKQotI2VuZGlm Ci0JbHcJdjEsIDAoYTEpCi0JYWRkdQlhMCwgYTAsIDQKLQlibmUJdjAsIHYxLCBub21hdGNoCi0J YWRkdQlhMSwgYTEsIDQKLQlibmUJYTAsIGEzLCAzYgorCUxXSEkJCXYwLCAwKGEwKQkjIGNvbXBh cmUgd29yZHMgYTAgdW5hbGlnbmVkLCBhMSBhbGlnbmVkCisJTFdMTwkJdjAsIDMoYTApCisJbHcJ CXYxLCAwKGExKQorCVBUUl9BRERVCWEwLCBhMCwgNAorCWJuZQkJdjAsIHYxLCBub21hdGNoCisJ UFRSX0FERFUJYTEsIGExLCA0CisJYm5lCQlhMCwgYTMsIDNiCiAJbm9wCiBzbWFsbDoKLQlibGUJ YTIsIHplcm8sIG1hdGNoCi0JYWRkdQlhMywgYTIsIGEwCQkjIGNvbXB1dGUgZW5kaW5nIGFkZHJl c3MKKwlibGUJCWEyLCB6ZXJvLCBtYXRjaAorCVBUUl9BRERVCWEzLCBhMiwgYTAJCSMgY29tcHV0 ZSBlbmRpbmcgYWRkcmVzcwogMToKLQlsYnUJdjAsIDAoYTApCi0JbGJ1CXYxLCAwKGExKQotCWFk ZHUJYTAsIGEwLCAxCi0JYm5lCXYwLCB2MSwgbm9tYXRjaAotCWFkZHUJYTEsIGExLCAxCi0JYm5l CWEwLCBhMywgMWIKKwlsYnUJCXYwLCAwKGEwKQorCWxidQkJdjEsIDAoYTEpCisJUFRSX0FERFUJ YTAsIGEwLCAxCisJYm5lCQl2MCwgdjEsIG5vbWF0Y2gKKwlQVFJfQUREVQlhMSwgYTEsIDEKKwli bmUJCWEwLCBhMywgMWIKIAlub3AKIG1hdGNoOgotCWoJcmEKLQltb3ZlCXYwLCB6ZXJvCisJagkJ cmEKKwltb3ZlCQl2MCwgemVybwogbm9tYXRjaDoKLQlqCXJhCi0JbGkJdjAsIDEKKwlqCQlyYQor CWxpCQl2MCwgMQogCS5zZXQJcmVvcmRlcgogRU5EKGJjbXApCkluZGV4OiBsaWIvbGliYy9taXBz L3N0cmluZy9iemVyby5TCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGxpYi9saWJjL21pcHMvc3RyaW5nL2J6ZXJv LlMJKHJldmlzaW9uIDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvc3RyaW5nL2J6ZXJvLlMJKHdv cmtpbmcgY29weSkKQEAgLTEsNCArMSw0IEBACi0vKgkkTmV0QlNEOiBiemVyby5TLHYgMS44IDIw MDMvMDgvMDcgMTY6NDI6MTYgYWdjIEV4cCAkCSovCisvKgkkTmV0QlNEOiBiemVyby5TLHYgMS4x MCAyMDA5LzEyLzE0IDAyOjUzOjUyIG1hdHQgRXhwICQJKi8KIAogLyotCiAgKiBDb3B5cmlnaHQg KGMpIDE5OTEsIDE5OTMKQEAgLTM2LDEwICszNiwxNSBAQAogX19GQlNESUQoIiRGcmVlQlNEJCIp OwogCiAjaWYgZGVmaW5lZChMSUJDX1NDQ1MpICYmICFkZWZpbmVkKGxpbnQpCisjaWYgMAogCUFT TVNUUigiZnJvbTogQCgjKWJ6ZXJvLnMJOC4xIChCZXJrZWxleSkgNi80LzkzIikKLQlBU01TVFIo IiROZXRCU0Q6IGJ6ZXJvLlMsdiAxLjggMjAwMy8wOC8wNyAxNjo0MjoxNiBhZ2MgRXhwICQiKQor I2Vsc2UKKwlBU01TVFIoIiROZXRCU0Q6IGJ6ZXJvLlMsdiAxLjEwIDIwMDkvMTIvMTQgMDI6NTM6 NTIgbWF0dCBFeHAgJCIpCisjZW5kaWYKICNlbmRpZiAvKiBMSUJDX1NDQ1MgYW5kIG5vdCBsaW50 ICovCiAKKyNkZWZpbmUgX0xPQ09SRQkJLyogWFhYIG5vdCByZWFsbHksIGp1c3QgYXNzZW1ibHkt Y29kZSBzb3VyY2UgKi8KKyNpbmNsdWRlIDxtYWNoaW5lL2VuZGlhbi5oPgogCiAjaWZkZWYgX19B QklDQUxMU19fCiAJLmFiaWNhbGxzCkBAIC00OSwzNCArNTQsNDggQEAKIAogTEVBRihiemVybykK IAkuc2V0CW5vcmVvcmRlcgotCWJsdAlhMSwgMTIsIHNtYWxsY2xyCSMgc21hbGwgYW1vdW50IHRv IGNsZWFyPwotCXN1YnUJYTMsIHplcm8sIGEwCQkjIGNvbXB1dGUgIyBieXRlcyB0byB3b3JkIGFs aWduIGFkZHJlc3MKLQlhbmQJYTMsIGEzLCAzCi0JYmVxCWEzLCB6ZXJvLCAxZgkJIyBza2lwIGlm IHdvcmQgYWxpZ25lZAotCXN1YnUJYTEsIGExLCBhMwkJIyBzdWJ0cmFjdCBmcm9tIHJlbWFpbmlu ZyBjb3VudAotI2lmZGVmIF9fTUlQU0VCX18KLQlzd2wJemVybywgMChhMCkJCSMgY2xlYXIgMSwg Miwgb3IgMyBieXRlcyB0byBhbGlnbgotI2Vsc2UKLQlzd3IJemVybywgMChhMCkJCSMgY2xlYXIg MSwgMiwgb3IgMyBieXRlcyB0byBhbGlnbgorCWJsdAkJYTEsIDMqU1pSRUcsIHNtYWxsY2xyICMg c21hbGwgYW1vdW50IHRvIGNsZWFyPworCVBUUl9TVUJVCWEzLCB6ZXJvLCBhMAkjIGNvbXB1dGUg IyBieXRlcyB0byB3b3JkIGFsaWduIGFkZHJlc3MKKwlhbmQJCWEzLCBhMywgU1pSRUctMQorCWJl cQkJYTMsIHplcm8sIDFmCSMgc2tpcCBpZiB3b3JkIGFsaWduZWQKKyNpZiBTWlJFRyA9PSA0CisJ UFRSX1NVQlUJYTEsIGExLCBhMwkjIHN1YnRyYWN0IGZyb20gcmVtYWluaW5nIGNvdW50CisJU1dI SQkJemVybywgMChhMCkJIyBjbGVhciAxLCAyLCBvciAzIGJ5dGVzIHRvIGFsaWduCisJUFRSX0FE RFUJYTAsIGEwLCBhMwogI2VuZGlmCi0JYWRkdQlhMCwgYTAsIGEzCisjaWYgU1pSRUcgPT0gOAor CVBUUl9TVUJVCWExLCBhMSwgYTMJIyBzdWJ0cmFjdCBmcm9tIHJlbWFpbmluZyBjb3VudAorCVBU Ul9BRERVCWEwLCBhMCwgYTMJIyBhbGlnbiBkc3QgdG8gbmV4dCB3b3JkCisJc2xsCQlhMywgYTMs IDMJIyBiaXRzIHRvIGJ5dGVzCisJbGkJCWEyLCAtMQkJIyBtYWtlIGEgbWFzaworI2lmIF9CWVRF X09SREVSID09IF9CSUdfRU5ESUFOCisJUkVHX1NSTFYJYTIsIGEyLCBhMwkjIHdlIHdhbnQgdG8g a2VlcCB0aGUgTVNCIGJ5dGVzCisjZW5kaWYKKyNpZiBfQllURV9PUkRFUiA9PSBfTElUVExFX0VO RElBTgorCVJFR19TTExWCWEyLCBhMiwgYTMJIyB3ZSB3YW50IHRvIGtlZXAgdGhlIExTQiBieXRl cworI2VuZGlmCisJbm9yCQlhMiwgemVybywgYTIJIyBjb21wbGVtZW50IHRoZSBtYXNrCisJUkVH X0wJCXYwLCAtU1pSRUcoYTApCSMgbG9hZCB0aGUgd29yZCB0byBwYXJ0aWFsbHkgY2xlYXIKKwlh bmQJCXYwLCB2MCwgYTIJIyBjbGVhciB0aGUgYnl0ZXMKKwlSRUdfUwkJdjAsIC1TWlJFRyhhMCkJ IyBzdG9yZSBpdCBiYWNrCisjZW5kaWYKIDE6Ci0JYW5kCXYwLCBhMSwgMwkJIyBjb21wdXRlIG51 bWJlciBvZiB3b3JkcyBsZWZ0Ci0Jc3VidQlhMywgYTEsIHYwCi0JbW92ZQlhMSwgdjAKLQlhZGR1 CWEzLCBhMywgYTAJCSMgY29tcHV0ZSBlbmRpbmcgYWRkcmVzcworCWFuZAkJdjAsIGExLCBTWlJF Ry0xCSMgY29tcHV0ZSBudW1iZXIgb2Ygd29yZHMgbGVmdAorCVBUUl9TVUJVCWEzLCBhMSwgdjAK Kwltb3ZlCQlhMSwgdjAKKwlQVFJfQUREVQlhMywgYTMsIGEwCSMgY29tcHV0ZSBlbmRpbmcgYWRk cmVzcwogMjoKLQlhZGR1CWEwLCBhMCwgNAkJIyBjbGVhciB3b3JkcwotCWJuZQlhMCwgYTMsIDJi CQkjICAgdW5yb2xsaW5nIGxvb3AgZG9lc250IGhlbHAKLQlzdwl6ZXJvLCAtNChhMCkJCSMgICBz aW5jZSB3ZSBhcmUgbGltaXRlZCBieSBtZW1vcnkgc3BlZWQKKwlQVFJfQUREVQlhMCwgYTAsIFNa UkVHCSMgY2xlYXIgd29yZHMKKwlibmUJCWEwLCBhMywgMmIJIyAgdW5yb2xsaW5nIGxvb3AgZG9l c250IGhlbHAKKwlSRUdfUwkJemVybywgLVNaUkVHKGEwKSAjIHNpbmNlIHdlIGFyZSBsaW1pdGVk IGJ5IG1lbW9yeSBzcGVlZAogc21hbGxjbHI6Ci0JYmxlCWExLCB6ZXJvLCAyZgotCWFkZHUJYTMs IGExLCBhMAkJIyBjb21wdXRlIGVuZGluZyBhZGRyZXNzCisJYmxlCQlhMSwgemVybywgMmYKKwlQ VFJfQUREVQlhMywgYTEsIGEwCSMgY29tcHV0ZSBlbmRpbmcgYWRkcmVzcwogMToKLQlhZGR1CWEw LCBhMCwgMQkJIyBjbGVhciBieXRlcwotCWJuZQlhMCwgYTMsIDFiCi0Jc2IJemVybywgLTEoYTAp CisJUFRSX0FERFUJYTAsIGEwLCAxCSMgY2xlYXIgYnl0ZXMKKwlibmUJCWEwLCBhMywgMWIKKwlz YgkJemVybywgLTEoYTApCiAyOgotCWoJcmEKKwlqCQlyYQogCW5vcAogRU5EKGJ6ZXJvKQpJbmRl eDogbGliL2xpYmMvbWlwcy9zdHJpbmcvaW5kZXguUwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9t aXBzL3N0cmluZy9pbmRleC5TCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBzL3N0 cmluZy9pbmRleC5TCSh3b3JraW5nIGNvcHkpCkBAIC00NiwxNCArNDYsMTQgQEAKIAogTEVBRihp bmRleCkKIDE6Ci0JbGJ1CWEyLCAwKGEwKQkJIyBnZXQgYSBieXRlCi0JYWRkdQlhMCwgYTAsIDEK LQliZXEJYTIsIGExLCBmbmQKLQlibmUJYTIsIHplcm8sIDFiCisJbGJ1CQlhMiwgMChhMCkJCSMg Z2V0IGEgYnl0ZQorCVBUUl9BRERVCWEwLCBhMCwgMQorCWJlcQkJYTIsIGExLCBmbmQKKwlibmUJ CWEyLCB6ZXJvLCAxYgogbm90Zm5kOgotCW1vdmUJdjAsIHplcm8KLQlqCXJhCisJbW92ZQkJdjAs IHplcm8KKwlqCQlyYQogZm5kOgotCXN1YnUJdjAsIGEwLCAxCi0JaglyYQorCVBUUl9TVUJVCXYw LCBhMCwgMQorCWoJCXJhCiBFTkQoaW5kZXgpCkluZGV4OiBsaWIvbGliYy9taXBzL3N0cmluZy9z dHJsZW4uUwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL3N0cmluZy9zdHJsZW4uUwkocmV2 aXNpb24gMjA5MDQwKQorKysgbGliL2xpYmMvbWlwcy9zdHJpbmcvc3RybGVuLlMJKHdvcmtpbmcg Y29weSkKQEAgLTEsNCArMSw0IEBACi0vKgkkTmV0QlNEOiBzdHJsZW4uUyx2IDEuMSAyMDA1LzEy LzIwIDE5OjI4OjUwIGNocmlzdG9zIEV4cCAkCSovCisvKgkkTmV0QlNEOiBzdHJsZW4uUyx2IDEu MiAyMDA5LzEyLzE0IDAwOjM5OjAwIG1hdHQgRXhwICQJKi8KIAogLyotCiAgKiBDb3B5cmlnaHQg KGMpIDE5OTEsIDE5OTMKQEAgLTM3LDcgKzM3LDcgQEAKIAogI2lmIGRlZmluZWQoTElCQ19TQ0NT KSAmJiAhZGVmaW5lZChsaW50KQogCUFTTVNUUigiZnJvbTogQCgjKXN0cmxlbi5zCTguMSAoQmVy a2VsZXkpIDYvNC85MyIpCi0JQVNNU1RSKCIkTmV0QlNEOiBzdHJsZW4uUyx2IDEuMSAyMDA1LzEy LzIwIDE5OjI4OjUwIGNocmlzdG9zIEV4cCAkIikKKwlBU01TVFIoIiROZXRCU0Q6IHN0cmxlbi5T LHYgMS4yIDIwMDkvMTIvMTQgMDA6Mzk6MDAgbWF0dCBFeHAgJCIpCiAjZW5kaWYgLyogTElCQ19T Q0NTIGFuZCBub3QgbGludCAqLwogCiAjaWZkZWYgX19BQklDQUxMU19fCkBAIC00NSwxMSArNDUs MTEgQEAKICNlbmRpZgogCiBMRUFGKHN0cmxlbikKLQlhZGR1CXYxLCBhMCwgMQorCVBUUl9BRERV CXYxLCBhMCwgMQogMToKLQlsYgl2MCwgMChhMCkJCSMgZ2V0IGJ5dGUgZnJvbSBzdHJpbmcKLQlh ZGR1CWEwLCBhMCwgMQkJIyBpbmNyZW1lbnQgcG9pbnRlcgotCWJuZQl2MCwgemVybywgMWIJCSMg Y29udGludWUgaWYgbm90IGVuZAotCXN1YnUJdjAsIGEwLCB2MQkJIyBjb21wdXRlIGxlbmd0aCAt IDEgZm9yICdcMCcgY2hhcgotCWoJcmEKKwlsYgkJdjAsIDAoYTApCSMgZ2V0IGJ5dGUgZnJvbSBz dHJpbmcKKwlQVFJfQUREVQlhMCwgYTAsIDEJIyBpbmNyZW1lbnQgcG9pbnRlcgorCWJuZQkJdjAs IHplcm8sIDFiCSMgY29udGludWUgaWYgbm90IGVuZAorCVBUUl9TVUJVIAl2MCwgYTAsIHYxCSMg Y29tcHV0ZSBsZW5ndGggLSAxIGZvciAnXDAnIGNoYXIKKwlqCQlyYQogRU5EKHN0cmxlbikKSW5k ZXg6IGxpYi9saWJjL21pcHMvc3RyaW5nL3N0cmNtcC5TCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGxpYi9saWJj L21pcHMvc3RyaW5nL3N0cmNtcC5TCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBz L3N0cmluZy9zdHJjbXAuUwkod29ya2luZyBjb3B5KQpAQCAtMSw0ICsxLDQgQEAKLS8qCSROZXRC U0Q6IHN0cmNtcC5TLHYgMS4xIDIwMDUvMTIvMjAgMTk6Mjg6NTAgY2hyaXN0b3MgRXhwICQJKi8K Ky8qCSROZXRCU0Q6IHN0cmNtcC5TLHYgMS4yIDIwMDkvMTIvMTQgMDA6Mzk6MDAgbWF0dCBFeHAg JAkqLwogCiAvKi0KICAqIENvcHlyaWdodCAoYykgMTk5MSwgMTk5MwpAQCAtMzcsNyArMzcsNyBA QAogCiAjaWYgZGVmaW5lZChMSUJDX1NDQ1MpICYmICFkZWZpbmVkKGxpbnQpCiAJQVNNU1RSKCJm cm9tOiBAKCMpc3RyY21wLnMJOC4xIChCZXJrZWxleSkgNi80LzkzIikKLQlBU01TVFIoIiROZXRC U0Q6IHN0cmNtcC5TLHYgMS4xIDIwMDUvMTIvMjAgMTk6Mjg6NTAgY2hyaXN0b3MgRXhwICQiKQor CUFTTVNUUigiJE5ldEJTRDogc3RyY21wLlMsdiAxLjIgMjAwOS8xMi8xNCAwMDozOTowMCBtYXR0 IEV4cCAkIikKICNlbmRpZiAvKiBMSUJDX1NDQ1MgYW5kIG5vdCBsaW50ICovCiAKICNpZmRlZiBf X0FCSUNBTExTX18KQEAgLTU1LDkgKzU1LDkgQEAKIAlibmUJdDAsIHQxLCBOb3RFcQogCWxidQl0 MCwgMShhMCkJCSMgdW5yb2xsIGxvb3AKIAlsYnUJdDEsIDEoYTEpCi0JYWRkCWEwLCBhMCwgMgor CVBUUl9BREQJYTAsIGEwLCAyCiAJYmVxCXQwLCB6ZXJvLCBMZXNzT3JFcQkjIGVuZCBvZiBmaXJz dCBzdHJpbmc/Ci0JYWRkCWExLCBhMSwgMgorCVBUUl9BREQJYTEsIGExLCAyCiAJYmVxCXQwLCB0 MSwgMWIKIE5vdEVxOgogCXN1YnUJdjAsIHQwLCB0MQpJbmRleDogbGliL2xpYmMvbWlwcy9zdHJp bmcvcmluZGV4LlMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9zdHJpbmcvcmluZGV4LlMJ KHJldmlzaW9uIDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvc3RyaW5nL3JpbmRleC5TCSh3b3Jr aW5nIGNvcHkpCkBAIC00NSwxMyArNDUsMTMgQEAKICNlbmRpZgogCiBMRUFGKHJpbmRleCkKLQlt b3ZlCXYwLCB6ZXJvCQkjIGRlZmF1bHQgaWYgbm90IGZvdW5kCisJbW92ZQkJdjAsIHplcm8JCSMg ZGVmYXVsdCBpZiBub3QgZm91bmQKIDE6Ci0JbGJ1CWEzLCAwKGEwKQkJIyBnZXQgYSBieXRlCi0J YWRkdQlhMCwgYTAsIDEKLQlibmUJYTMsIGExLCAyZgotCXN1YnUJdjAsIGEwLCAxCQkjIHNhdmUg YWRkcmVzcyBvZiBsYXN0IG1hdGNoCisJbGJ1CQlhMywgMChhMCkJCSMgZ2V0IGEgYnl0ZQorCVBU Ul9BRERVCWEwLCBhMCwgMQorCWJuZQkJYTMsIGExLCAyZgorCVBUUl9TVUJVCXYwLCBhMCwgMQkJ IyBzYXZlIGFkZHJlc3Mgb2YgbGFzdCBtYXRjaAogMjoKLQlibmUJYTMsIHplcm8sIDFiCQkjIGNv bnRpbnVlIGlmIG5vdCBlbmQKLQlqCXJhCisJYm5lCQlhMywgemVybywgMWIJCSMgY29udGludWUg aWYgbm90IGVuZAorCWoJCXJhCiBFTkQocmluZGV4KQpJbmRleDogbGliL2xpYmMvbWlwcy9zdHJp bmcvYmNvcHkuUwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL3N0cmluZy9iY29weS5TCShy ZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBzL3N0cmluZy9iY29weS5TCSh3b3JraW5n IGNvcHkpCkBAIC0xLDQgKzEsNCBAQAotLyoJJE5ldEJTRDogYmNvcHkuUyx2IDEuMiAyMDA1LzEy LzI3IDExOjIzOjUzIHRzdXRzdWkgRXhwICQJKi8KKy8qCSROZXRCU0Q6IGJjb3B5LlMsdiAxLjMg MjAwOS8xMi8xNCAwMDozOTowMCBtYXR0IEV4cCAkCSovCiAKIC8qCiAgKiBNYWNoIE9wZXJhdGlu ZyBTeXN0ZW0KQEAgLTM4LDkgKzM4LDE1IEBACiAjaW5jbHVkZSA8bWFjaGluZS9hc20uaD4KIF9f RkJTRElEKCIkRnJlZUJTRCQiKTsKIAorI2RlZmluZSBfTE9DT1JFCQkvKiBYWFggbm90IHJlYWxs eSwganVzdCBhc3NlbWJseS1jb2RlIHNvdXJjZSAqLworI2luY2x1ZGUgPG1hY2hpbmUvZW5kaWFu Lmg+CisKICNpZiBkZWZpbmVkKExJQkNfU0NDUykgJiYgIWRlZmluZWQobGludCkKKyNpZiAwCiAJ QVNNU1RSKCJmcm9tOiBAKCMpbWlwc19iY29weS5zCTIuMiBDTVUgMTgvMDYvOTMiKQotCUFTTVNU UigiJE5ldEJTRDogYmNvcHkuUyx2IDEuMiAyMDA1LzEyLzI3IDExOjIzOjUzIHRzdXRzdWkgRXhw ICQiKQorI2Vsc2UKKwlBU01TVFIoIiROZXRCU0Q6IGJjb3B5LlMsdiAxLjMgMjAwOS8xMi8xNCAw MDozOTowMCBtYXR0IEV4cCAkIikKKyNlbmRpZgogI2VuZGlmIC8qIExJQkNfU0NDUyBhbmQgbm90 IGxpbnQgKi8KIAogI2lmZGVmIF9fQUJJQ0FMTFNfXwpAQCAtOTksNzEgKzEwNSw3MiBAQAogCSAq CWNvcHkgaXMgYWxpZ25hYmxlLiAgZWcgaWYgc3JjIGFuZCBkZXN0IGFyZSBib3RoCiAJICoJb24g YSBoYWxmd29yZCBib3VuZGFyeS4KIAkgKi8KLQlhbmRpCXQxLERTVFJFRywzCQkjIGdldCBsYXN0 IDMgYml0cyBvZiBkZXN0Ci0JYm5lCXQxLHplcm8sM2YKLQlhbmRpCXQwLFNSQ1JFRywzCQkjIGdl dCBsYXN0IDMgYml0cyBvZiBzcmMKLQlibmUJdDAsemVybyw1ZgorCWFuZGkJCXQxLERTVFJFRywo U1pSRUctMSkJIyBnZXQgbGFzdCBiaXRzIG9mIGRlc3QKKwlibmUJCXQxLHplcm8sM2YJCSMgZGVz dCB1bmFsaWduZWQKKwlhbmRpCQl0MCxTUkNSRUcsKFNaUkVHLTEpCSMgZ2V0IGxhc3QgYml0cyBv ZiBzcmMKKwlibmUJCXQwLHplcm8sNWYKIAogCS8qCi0JICoJRm9yd2FyZCBhbGlnbmVkLT5hbGln bmVkIGNvcHksIDgqNCBieXRlcyBhdCBhIHRpbWUuCisJICoJRm9yd2FyZCBhbGlnbmVkLT5hbGln bmVkIGNvcHksIDggd29yZHMgYXQgYSB0aW1lLgogCSAqLwotCWxpCUFULC0zMgotCWFuZAl0MCxT SVpFUkVHLEFUCQkjIGNvdW50IHRydW5jYXRlZCB0byBtdWx0aXBsZSBvZiAzMiAqLwotCWFkZHUJ YTMsU1JDUkVHLHQwCQkjIHJ1biBmYXN0IGxvb3AgdXAgdG8gdGhpcyBhZGRyZXNzCi0Jc2x0dQlB VCxTUkNSRUcsYTMJCSMgYW55IHdvcmsgdG8gZG8/Ci0JYmVxCUFULHplcm8sMmYKLQlzdWJ1CVNJ WkVSRUcsdDAKKzk4OgorCWxpCQlBVCwtKFNaUkVHKjgpCisJYW5kCQl0MCxTSVpFUkVHLEFUCQkj IGNvdW50IHRydW5jYXRlZCB0byBtdWx0aXBsZXMKKwlQVFJfQUREVQlhMyxTUkNSRUcsdDAJCSMg cnVuIGZhc3QgbG9vcCB1cCB0byB0aGlzIGFkZHIKKwlzbHR1CQlBVCxTUkNSRUcsYTMJCSMgYW55 IHdvcmsgdG8gZG8/CisJYmVxCQlBVCx6ZXJvLDJmCisJUFRSX1NVQlUJU0laRVJFRyx0MAogCiAJ LyoKIAkgKglsb29wIGJvZHkKIAkgKi8KIDE6CSMgY3AKLQlsdwl0MywwKFNSQ1JFRykKLQlsdwl2 MSw0KFNSQ1JFRykKLQlsdwl0MCw4KFNSQ1JFRykKLQlsdwl0MSwxMihTUkNSRUcpCi0JYWRkdQlT UkNSRUcsMzIKLQlzdwl0MywwKERTVFJFRykKLQlzdwl2MSw0KERTVFJFRykKLQlzdwl0MCw4KERT VFJFRykKLQlzdwl0MSwxMihEU1RSRUcpCi0JbHcJdDEsLTQoU1JDUkVHKQotCWx3CXQwLC04KFNS Q1JFRykKLQlsdwl2MSwtMTIoU1JDUkVHKQotCWx3CXQzLC0xNihTUkNSRUcpCi0JYWRkdQlEU1RS RUcsMzIKLQlzdwl0MSwtNChEU1RSRUcpCi0Jc3cJdDAsLTgoRFNUUkVHKQotCXN3CXYxLC0xMihE U1RSRUcpCi0JYm5lCVNSQ1JFRyxhMywxYgotCXN3CXQzLC0xNihEU1RSRUcpCisJUkVHX0wJCXQz LCgwKlNaUkVHKShTUkNSRUcpCisJUkVHX0wJCXYxLCgxKlNaUkVHKShTUkNSRUcpCisJUkVHX0wJ CXQwLCgyKlNaUkVHKShTUkNSRUcpCisJUkVHX0wJCXQxLCgzKlNaUkVHKShTUkNSRUcpCisJUFRS X0FERFUJU1JDUkVHLFNaUkVHKjgKKwlSRUdfUwkJdDMsKDAqU1pSRUcpKERTVFJFRykKKwlSRUdf UwkJdjEsKDEqU1pSRUcpKERTVFJFRykKKwlSRUdfUwkJdDAsKDIqU1pSRUcpKERTVFJFRykKKwlS RUdfUwkJdDEsKDMqU1pSRUcpKERTVFJFRykKKwlSRUdfTAkJdDEsKC0xKlNaUkVHKShTUkNSRUcp CisJUkVHX0wJCXQwLCgtMipTWlJFRykoU1JDUkVHKQorCVJFR19MCQl2MSwoLTMqU1pSRUcpKFNS Q1JFRykKKwlSRUdfTAkJdDMsKC00KlNaUkVHKShTUkNSRUcpCisJUFRSX0FERFUJRFNUUkVHLFNa UkVHKjgKKwlSRUdfUwkJdDEsKC0xKlNaUkVHKShEU1RSRUcpCisJUkVHX1MJCXQwLCgtMipTWlJF RykoRFNUUkVHKQorCVJFR19TCQl2MSwoLTMqU1pSRUcpKERTVFJFRykKKwlibmUJCVNSQ1JFRyxh MywxYgorCVJFR19TCQl0MywoLTQqU1pSRUcpKERTVFJFRykKIAogCS8qCiAJICoJQ29weSBhIHdv cmQgYXQgYSB0aW1lLCBubyBsb29wIHVucm9sbGluZy4KIAkgKi8KIDI6CSMgd29yZGNvcHkKLQlh bmRpCXQyLFNJWkVSRUcsMwkJIyBnZXQgYnl0ZSBjb3VudCAvIDQKLQlzdWJ1CXQyLFNJWkVSRUcs dDIJCSMgdDIgPSBudW1iZXIgb2Ygd29yZHMgdG8gY29weSAqIDQKLQliZXEJdDIsemVybywzZgot CWFkZHUJdDAsU1JDUkVHLHQyCQkjIHN0b3AgYXQgdDAKLQlzdWJ1CVNJWkVSRUcsU0laRVJFRyx0 MgorCWFuZGkJCXQyLFNJWkVSRUcsKFNaUkVHLTEpCSMgZ2V0IGJ5dGUgY291bnQgLyBTWlJFRwor CVBUUl9TVUJVCXQyLFNJWkVSRUcsdDIJCSMgdDIgPSB3b3JkcyB0byBjb3B5ICogU1pSRUcKKwli ZXEJCXQyLHplcm8sM2YKKwlQVFJfQUREVQl0MCxTUkNSRUcsdDIJCSMgc3RvcCBhdCB0MAorCVBU Ul9TVUJVCVNJWkVSRUcsU0laRVJFRyx0MgogMToKLQlsdwl0MywwKFNSQ1JFRykKLQlhZGR1CVNS Q1JFRyw0Ci0Jc3cJdDMsMChEU1RSRUcpCi0JYm5lCVNSQ1JFRyx0MCwxYgotCWFkZHUJRFNUUkVH LDQKKwlSRUdfTAkJdDMsMChTUkNSRUcpCisJUFRSX0FERFUJU1JDUkVHLFNaUkVHCisJUkVHX1MJ CXQzLDAoRFNUUkVHKQorCWJuZQkJU1JDUkVHLHQwLDFiCisJUFRSX0FERFUJRFNUUkVHLFNaUkVH CiAKIDM6CSMgYnl0ZWNvcHkKLQliZXEJU0laRVJFRyx6ZXJvLDRmCSMgbm90aGluZyBsZWZ0IHRv IGRvPworCWJlcQkJU0laRVJFRyx6ZXJvLDRmCQkjIG5vdGhpbmcgbGVmdCB0byBkbz8KIAlub3AK IDE6Ci0JbGIJdDMsMChTUkNSRUcpCi0JYWRkdQlTUkNSRUcsMQotCXNiCXQzLDAoRFNUUkVHKQot CXN1YnUJU0laRVJFRywxCi0JYmd0eglTSVpFUkVHLDFiCi0JYWRkdQlEU1RSRUcsMQorCWxiCQl0 MywwKFNSQ1JFRykKKwlQVFJfQUREVQlTUkNSRUcsMQorCXNiCQl0MywwKERTVFJFRykKKwlQVFJf U1VCVQlTSVpFUkVHLDEKKwliZ3R6CQlTSVpFUkVHLDFiCisJUFRSX0FERFUJRFNUUkVHLDEKIAog NDoJIyBjb3B5ZG9uZQogCWoJcmEKQEAgLTE3Myw5NiArMTgwLDkxIEBACiAJICoJQ29weSBmcm9t IHVuYWxpZ25lZCBzb3VyY2UgdG8gYWxpZ25lZCBkZXN0LgogCSAqLwogNToJIyBkZXN0YWxpZ25l ZAotCWFuZGkJdDAsU0laRVJFRywzCQkjIHQwID0gYnl0ZWNvdW50IG1vZCA0Ci0Jc3VidQlhMyxT SVpFUkVHLHQwCQkjIG51bWJlciBvZiB3b3JkcyB0byB0cmFuc2ZlcgotCWJlcQlhMyx6ZXJvLDNi CisJYW5kaQkJdDAsU0laRVJFRywoU1pSRUctMSkJIyB0MCA9IGJ5dGVjb3VudCBtb2QgU1pSRUcK KwlQVFJfU1VCVQlhMyxTSVpFUkVHLHQwCQkjIG51bWJlciBvZiB3b3JkcyB0byB0cmFuc2Zlcgor CWJlcQkJYTMsemVybywzYgogCW5vcAotCW1vdmUJU0laRVJFRyx0MAkJIyB0aGlzIG1hbnkgdG8g ZG8gYWZ0ZXIgd2UgYXJlIGRvbmUKLQlhZGR1CWEzLFNSQ1JFRyxhMwkJIyBzdG9wIHBvaW50CisJ bW92ZQkJU0laRVJFRyx0MAkJIyB0aGlzIG1hbnkgdG8gZG8gYWZ0ZXIgd2UgYXJlIGRvbmUKKwlQ VFJfQUREVQlhMyxTUkNSRUcsYTMJCSMgc3RvcCBwb2ludAogCiAxOgotI2lmZGVmIF9fTUlQU0VC X18KLQlsd2wJdDMsMChTUkNSRUcpCi0JbHdyCXQzLDMoU1JDUkVHKQotI2Vsc2UKLQlsd3IJdDMs MChTUkNSRUcpCi0JbHdsCXQzLDMoU1JDUkVHKQotI2VuZGlmCi0JYWRkaQlTUkNSRUcsNAotCXN3 CXQzLDAoRFNUUkVHKQotCWJuZQlTUkNSRUcsYTMsMWIKLQlhZGRpCURTVFJFRyw0CisJUkVHX0xI SQkJdDMsMChTUkNSRUcpCisJUkVHX0xMTwkJdDMsU1pSRUctMShTUkNSRUcpCisJUFRSX0FEREkJ U1JDUkVHLFNaUkVHCisJUkVHX1MJCXQzLDAoRFNUUkVHKQorCWJuZQkJU1JDUkVHLGEzLDFiCisJ UFRSX0FEREkJRFNUUkVHLFNaUkVHCiAKLQlqCTNiCisJYgkJM2IKIAlub3AKIAogNjoJIyBiYWNr Y29weSAtLSBiYXNlZCBvbiBhYm92ZQotCWFkZHUJU1JDUkVHLFNJWkVSRUcKLQlhZGR1CURTVFJF RyxTSVpFUkVHCi0JYW5kaQl0MSxEU1RSRUcsMwkJIyBnZXQgbGFzdCAzIGJpdHMgb2YgZGVzdAot CWJuZQl0MSx6ZXJvLDNmCi0JYW5kaQl0MCxTUkNSRUcsMwkJIyBnZXQgbGFzdCAzIGJpdHMgb2Yg c3JjCi0JYm5lCXQwLHplcm8sNWYKKwlQVFJfQUREVQlTUkNSRUcsU0laRVJFRworCVBUUl9BRERV CURTVFJFRyxTSVpFUkVHCisJYW5kaQkJdDEsRFNUUkVHLFNaUkVHLTEJIyBnZXQgbGFzdCAzIGJp dHMgb2YgZGVzdAorCWJuZQkJdDEsemVybywzZgorCWFuZGkJCXQwLFNSQ1JFRyxTWlJFRy0xCSMg Z2V0IGxhc3QgMyBiaXRzIG9mIHNyYworCWJuZQkJdDAsemVybyw1ZgogCiAJLyoKIAkgKglGb3J3 YXJkIGFsaWduZWQtPmFsaWduZWQgY29weSwgOCo0IGJ5dGVzIGF0IGEgdGltZS4KIAkgKi8KLQls aQlBVCwtMzIKLQlhbmQJdDAsU0laRVJFRyxBVAkJIyBjb3VudCB0cnVuY2F0ZWQgdG8gbXVsdGlw bGUgb2YgMzIKLQliZXEJdDAsemVybywyZgkJIyBhbnkgd29yayB0byBkbz8KLQlzdWJ1CVNJWkVS RUcsdDAKLQlzdWJ1CWEzLFNSQ1JFRyx0MAorCWxpCQlBVCwoLTgqU1pSRUcpCisJYW5kCQl0MCxT SVpFUkVHLEFUCQkjIGNvdW50IHRydW5jYXRlZCB0byBtdWx0aXBsZSBvZiAzMgorCWJlcQkJdDAs emVybywyZgkJIyBhbnkgd29yayB0byBkbz8KKwlQVFJfU1VCVQlTSVpFUkVHLHQwCisJUFRSX1NV QlUJYTMsU1JDUkVHLHQwCiAKIAkvKgogCSAqCWxvb3AgYm9keQogCSAqLwogMToJIyBjcAotCWx3 CXQzLC0xNihTUkNSRUcpCi0JbHcJdjEsLTEyKFNSQ1JFRykKLQlsdwl0MCwtOChTUkNSRUcpCi0J bHcJdDEsLTQoU1JDUkVHKQotCXN1YnUJU1JDUkVHLDMyCi0Jc3cJdDMsLTE2KERTVFJFRykKLQlz dwl2MSwtMTIoRFNUUkVHKQotCXN3CXQwLC04KERTVFJFRykKLQlzdwl0MSwtNChEU1RSRUcpCi0J bHcJdDEsMTIoU1JDUkVHKQotCWx3CXQwLDgoU1JDUkVHKQotCWx3CXYxLDQoU1JDUkVHKQotCWx3 CXQzLDAoU1JDUkVHKQotCXN1YnUJRFNUUkVHLDMyCi0Jc3cJdDEsMTIoRFNUUkVHKQotCXN3CXQw LDgoRFNUUkVHKQotCXN3CXYxLDQoRFNUUkVHKQotCWJuZQlTUkNSRUcsYTMsMWIKLQlzdwl0Myww KERTVFJFRykKKwlSRUdfTAkJdDMsKC00KlNaUkVHKShTUkNSRUcpCisJUkVHX0wJCXYxLCgtMypT WlJFRykoU1JDUkVHKQorCVJFR19MCQl0MCwoLTIqU1pSRUcpKFNSQ1JFRykKKwlSRUdfTAkJdDEs KC0xKlNaUkVHKShTUkNSRUcpCisJUFRSX1NVQlUJU1JDUkVHLDgqU1pSRUcKKwlSRUdfUwkJdDMs KC00KlNaUkVHKShEU1RSRUcpCisJUkVHX1MJCXYxLCgtMypTWlJFRykoRFNUUkVHKQorCVJFR19T CQl0MCwoLTIqU1pSRUcpKERTVFJFRykKKwlSRUdfUwkJdDEsKC0xKlNaUkVHKShEU1RSRUcpCisJ UkVHX0wJCXQxLCgzKlNaUkVHKShTUkNSRUcpCisJUkVHX0wJCXQwLCgyKlNaUkVHKShTUkNSRUcp CisJUkVHX0wJCXYxLCgxKlNaUkVHKShTUkNSRUcpCisJUkVHX0wJCXQzLCgwKlNaUkVHKShTUkNS RUcpCisJUFRSX1NVQlUJRFNUUkVHLDgqU1pSRUcKKwlSRUdfUwkJdDEsKDMqU1pSRUcpKERTVFJF RykKKwlSRUdfUwkJdDAsKDIqU1pSRUcpKERTVFJFRykKKwlSRUdfUwkJdjEsKDEqU1pSRUcpKERT VFJFRykKKwlibmUJCVNSQ1JFRyxhMywxYgorCVJFR19TCQl0MywoMCpTWlJFRykoRFNUUkVHKQog CiAJLyoKIAkgKglDb3B5IGEgd29yZCBhdCBhIHRpbWUsIG5vIGxvb3AgdW5yb2xsaW5nLgogCSAq LwogMjoJIyB3b3JkY29weQotCWFuZGkJdDIsU0laRVJFRywzCQkjIGdldCBieXRlIGNvdW50IC8g NAotCXN1YnUJdDIsU0laRVJFRyx0MgkJIyB0MiA9IG51bWJlciBvZiB3b3JkcyB0byBjb3B5ICog NAotCWJlcQl0Mix6ZXJvLDNmCi0Jc3VidQl0MCxTUkNSRUcsdDIJCSMgc3RvcCBhdCB0MAotCXN1 YnUJU0laRVJFRyxTSVpFUkVHLHQyCisJYW5kaQkJdDIsU0laRVJFRyxTWlJFRy0xCSMgZ2V0IGJ5 dGUgY291bnQgLyA0CisJUFRSX1NVQlUJdDIsU0laRVJFRyx0MgkJIyB0MiA9IG51bWJlciBvZiB3 b3JkcyB0byBjb3B5CisJYmVxCQl0Mix6ZXJvLDNmCisJUFRSX1NVQlUJdDAsU1JDUkVHLHQyCQkj IHN0b3AgYXQgdDAKKwlQVFJfU1VCVQlTSVpFUkVHLFNJWkVSRUcsdDIKIDE6Ci0JbHcJdDMsLTQo U1JDUkVHKQotCXN1YnUJU1JDUkVHLDQKLQlzdwl0MywtNChEU1RSRUcpCi0JYm5lCVNSQ1JFRyx0 MCwxYgotCXN1YnUJRFNUUkVHLDQKKwlSRUdfTAkJdDMsLVNaUkVHKFNSQ1JFRykKKwlQVFJfU1VC VQlTUkNSRUcsU1pSRUcKKwlSRUdfUwkJdDMsLVNaUkVHKERTVFJFRykKKwlibmUJCVNSQ1JFRyx0 MCwxYgorCVBUUl9TVUJVCURTVFJFRyxTWlJFRwogCiAzOgkjIGJ5dGVjb3B5Ci0JYmVxCVNJWkVS RUcsemVybyw0ZgkJIyBub3RoaW5nIGxlZnQgdG8gZG8/CisJYmVxCQlTSVpFUkVHLHplcm8sNGYJ CSMgbm90aGluZyBsZWZ0IHRvIGRvPwogCW5vcAogMToKLQlsYgl0MywtMShTUkNSRUcpCi0Jc3Vi dQlTUkNSRUcsMQotCXNiCXQzLC0xKERTVFJFRykKLQlzdWJ1CVNJWkVSRUcsMQotCWJndHoJU0la RVJFRywxYgotCXN1YnUJRFNUUkVHLDEKKwlsYgkJdDMsLTEoU1JDUkVHKQorCVBUUl9TVUJVCVNS Q1JFRywxCisJc2IJCXQzLC0xKERTVFJFRykKKwlQVFJfU1VCVQlTSVpFUkVHLDEKKwliZ3R6CQlT SVpFUkVHLDFiCisJUFRSX1NVQlUJRFNUUkVHLDEKIAogNDoJIyBjb3B5ZG9uZQogCWoJcmEKQEAg LTI3MiwyNyArMjc0LDIyIEBACiAJICoJQ29weSBmcm9tIHVuYWxpZ25lZCBzb3VyY2UgdG8gYWxp Z25lZCBkZXN0LgogCSAqLwogNToJIyBkZXN0YWxpZ25lZAotCWFuZGkJdDAsU0laRVJFRywzCQkj IHQwID0gYnl0ZWNvdW50IG1vZCA0Ci0Jc3VidQlhMyxTSVpFUkVHLHQwCQkjIG51bWJlciBvZiB3 b3JkcyB0byB0cmFuc2ZlcgotCWJlcQlhMyx6ZXJvLDNiCisJYW5kaQkJdDAsU0laRVJFRyxTWlJF Ry0xCSMgdDAgPSBieXRlY291bnQgbW9kIDQKKwlQVFJfU1VCVQlhMyxTSVpFUkVHLHQwCQkjIG51 bWJlciBvZiB3b3JkcyB0byB0cmFuc2ZlcgorCWJlcQkJYTMsemVybywzYgogCW5vcAotCW1vdmUJ U0laRVJFRyx0MAkJIyB0aGlzIG1hbnkgdG8gZG8gYWZ0ZXIgd2UgYXJlIGRvbmUKLQlzdWJ1CWEz LFNSQ1JFRyxhMwkJIyBzdG9wIHBvaW50CisJbW92ZQkJU0laRVJFRyx0MAkJIyB0aGlzIG1hbnkg dG8gZG8gYWZ0ZXIgd2UgYXJlIGRvbmUKKwlQVFJfU1VCVQlhMyxTUkNSRUcsYTMJCSMgc3RvcCBw b2ludAogCiAxOgotI2lmZGVmIF9fTUlQU0VCX18KLQlsd2wJdDMsLTQoU1JDUkVHKQotCWx3cgl0 MywtMShTUkNSRUcpCi0jZWxzZQotCWx3cgl0MywtNChTUkNSRUcpCi0JbHdsCXQzLC0xKFNSQ1JF RykKLSNlbmRpZgotCXN1YnUJU1JDUkVHLDQKLQlzdwl0MywtNChEU1RSRUcpCi0JYm5lCVNSQ1JF RyxhMywxYgotCXN1YnUJRFNUUkVHLDQKKwlSRUdfTEhJCQl0MywtU1pSRUcoU1JDUkVHKQorCVJF R19MTE8JCXQzLC0xKFNSQ1JFRykKKwlQVFJfU1VCVQlTUkNSRUcsU1pSRUcKKwlSRUdfUwkJdDMs LVNaUkVHKERTVFJFRykKKwlibmUJCVNSQ1JFRyxhMywxYgorCVBUUl9TVUJVCURTVFJFRyxTWlJF RwogCi0JagkzYgorCWIJCTNiCiAJbm9wCiAKIAkuc2V0CXJlb3JkZXIKSW5kZXg6IGxpYi9saWJj L21pcHMvZ2VuL19zZXRqbXAuUwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL2dlbi9fc2V0 am1wLlMJKHJldmlzaW9uIDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvZ2VuL19zZXRqbXAuUwko d29ya2luZyBjb3B5KQpAQCAtMSw0ICsxLDQgQEAKLS8qCSROZXRCU0Q6IF9zZXRqbXAuUyx2IDEu MjAgMjAwNS8xMC8wNyAxNzoxNjo0MCB0c3V0c3VpIEV4cCAkCSovCisvKgkkTmV0QlNEOiBfc2V0 am1wLlMsdiAxLjIwLjM0LjUgMjAxMC8wMi8wMyAyMzo0Njo0NyBtYXR0IEV4cCAkCSovCiAKIC8q LQogICogQ29weXJpZ2h0IChjKSAxOTkxLCAxOTkzCkBAIC0zNiwxNSArMzYsMTYgQEAKIF9fRkJT RElEKCIkRnJlZUJTRCQiKTsKICNpbmNsdWRlIDxtYWNoaW5lL3JlZ251bS5oPgogCisjaW5jbHVk ZSAiU1lTLmgiCisKICNpZiBkZWZpbmVkKExJQkNfU0NDUykgJiYgIWRlZmluZWQobGludCkKLQlB U01TVFIoImZyb206IEAoIylfc2V0am1wLnMJOC4xIChCZXJrZWxleSkgNi80LzkzIikKLQlBU01T VFIoIiROZXRCU0Q6IF9zZXRqbXAuUyx2IDEuMjAgMjAwNS8xMC8wNyAxNzoxNjo0MCB0c3V0c3Vp IEV4cCAkIikKKyNpZiAwCisJUkNTSUQoImZyb206IEAoIylfc2V0am1wLnMJOC4xIChCZXJrZWxl eSkgNi80LzkzIikKKyNlbHNlCisJUkNTSUQoIiROZXRCU0Q6IF9zZXRqbXAuUyx2IDEuMjAuMzQu NSAyMDEwLzAyLzAzIDIzOjQ2OjQ3IG1hdHQgRXhwICQiKQorI2VuZGlmCiAjZW5kaWYgLyogTElC Q19TQ0NTIGFuZCBub3QgbGludCAqLwogCi0jaWZkZWYgX19BQklDQUxMU19fCi0JLmFiaWNhbGxz Ci0jZW5kaWYKLQogLyoKICAqIEMgbGlicmFyeSAtLSBfc2V0am1wLCBfbG9uZ2ptcAogICoKQEAg LTU2LDYyICs1Nyw3MCBAQAogICogVGhlIHByZXZpb3VzIHNpZ25hbCBzdGF0ZSBpcyBOT1QgcmVz dG9yZWQuCiAgKi8KIAorCS5zZXQJbm9yZW9yZGVyCiAKIExFQUYoX3NldGptcCkKLSNpZmRlZiBf X0FCSUNBTExTX18gCi0JLnNldAlub3Jlb3JkZXIKLQkuY3Bsb2FkIHQ5Ci0Jc3VidQlzcCwgc3As IENBTExGUkFNRV9TSVoJIyBhbGxvY2F0ZSBzdGFjayBmcmFtZQotCS5jcHJlc3RvcmUgMTYKKwlS RUdfUFJPTE9HVUUKKwlSRUdfTEkJdjAsIF9KQl9NQUdJQ19fU0VUSk1QCisJUkVHX1MJdjAsIChf SkJfTUFHSUMgICogU1pSRUcpKGEwKQorCVJFR19TCXJhLCAoX0pCX1JFR19SQSAqIFNaUkVHKShh MCkKKwlSRUdfUwlzMCwgKF9KQl9SRUdfUzAgKiBTWlJFRykoYTApCisJUkVHX1MJczEsIChfSkJf UkVHX1MxICogU1pSRUcpKGEwKQorCVJFR19TCXMyLCAoX0pCX1JFR19TMiAqIFNaUkVHKShhMCkK KwlSRUdfUwlzMywgKF9KQl9SRUdfUzMgKiBTWlJFRykoYTApCisJUkVHX1MJczQsIChfSkJfUkVH X1M0ICogU1pSRUcpKGEwKQorCVJFR19TCXM1LCAoX0pCX1JFR19TNSAqIFNaUkVHKShhMCkKKwlS RUdfUwlzNiwgKF9KQl9SRUdfUzYgKiBTWlJFRykoYTApCisJUkVHX1MJczcsIChfSkJfUkVHX1M3 ICogU1pSRUcpKGEwKQorCVJFR19TCXM4LCAoX0pCX1JFR19TOCAqIFNaUkVHKShhMCkKKyNpZiBk ZWZpbmVkKF9fbWlwc19uMzIpIHx8IGRlZmluZWQoX19taXBzX242NCkKKwlSRUdfUwlncCwgKF9K Ql9SRUdfR1AgKiBTWlJFRykoYTApCSMgbmV3YWJpIGdwIGlzIGNhbGxlZS1zYXZlZAogI2VuZGlm Ci0JbGkJdjAsIF9KQl9NQUdJQ19fU0VUSk1QCi0Jc3cJdjAsIChfSkJfTUFHSUMgICogU1pSRUcp KGEwKQotCXN3CXJhLCAoX0pCX1JFR19SQSAqIFNaUkVHKShhMCkKLQlzdwlzMCwgKF9KQl9SRUdf UzAgKiBTWlJFRykoYTApCi0Jc3cJczEsIChfSkJfUkVHX1MxICogU1pSRUcpKGEwKQotCXN3CXMy LCAoX0pCX1JFR19TMiAqIFNaUkVHKShhMCkKLQlzdwlzMywgKF9KQl9SRUdfUzMgKiBTWlJFRyko YTApCi0Jc3cJczQsIChfSkJfUkVHX1M0ICogU1pSRUcpKGEwKQotCXN3CXM1LCAoX0pCX1JFR19T NSAqIFNaUkVHKShhMCkKLQlzdwlzNiwgKF9KQl9SRUdfUzYgKiBTWlJFRykoYTApCi0Jc3cJczcs IChfSkJfUkVHX1M3ICogU1pSRUcpKGEwKQotCXN3CXM4LCAoX0pCX1JFR19TOCAqIFNaUkVHKShh MCkKLSNpZmRlZiBfX0FCSUNBTExTX18KLQlhZGR1CXNwLCBzcCwgQ0FMTEZSQU1FX1NJWgkjIHVu LWFsbG9jYXRlIHRoZSBzdGFjayBmcmFtZQotI2VuZGlmCQotCXN3CXNwLCAoX0pCX1JFR19TUCAq IFNaUkVHKShhMCkKKwlSRUdfUwlzcCwgKF9KQl9SRUdfU1AgKiBTWlJFRykoYTApCisJUkVHX0VQ SUxPR1VFCisKIAlqCXJhCiAJbW92ZQl2MCwgemVybwogRU5EKF9zZXRqbXApCiAKIExFQUYoX2xv bmdqbXApCi0jaWZkZWYgX19BQklDQUxMU19fIAotCS5zZXQJbm9yZW9yZGVyCi0JLmNwbG9hZCB0 OQotCXN1YnUJc3AsIHNwLCBDQUxMRlJBTUVfU0laCSMgYWxsb2NhdGUgc3RhY2sgZnJhbWUKLQku Y3ByZXN0b3JlIDE2Ci0jZW5kaWYgIAotCWx3CXYwLCAoX0pCX01BR0lDICAqIFNaUkVHKShhMCkK LQlsdwlyYSwgKF9KQl9SRUdfUkEgKiBTWlJFRykoYTApCi0JbGkJdDAsIF9KQl9NQUdJQ19fU0VU Sk1QCi0JYm5lCXYwLCB0MCwgYm90Y2gJCSMganVtcCBpZiBlcnJvcgotCWx3CXMwLCAoX0pCX1JF R19TMCAqIFNaUkVHKShhMCkKLQlsdwlzMSwgKF9KQl9SRUdfUzEgKiBTWlJFRykoYTApCi0JbHcJ czIsIChfSkJfUkVHX1MyICogU1pSRUcpKGEwKQotCWx3CXMzLCAoX0pCX1JFR19TMyAqIFNaUkVH KShhMCkKLQlsdwlzNCwgKF9KQl9SRUdfUzQgKiBTWlJFRykoYTApCi0JbHcJczUsIChfSkJfUkVH X1M1ICogU1pSRUcpKGEwKQotCWx3CXM2LCAoX0pCX1JFR19TNiAqIFNaUkVHKShhMCkKLQlsdwlz NywgKF9KQl9SRUdfUzcgKiBTWlJFRykoYTApCi0JbHcJc3AsIChfSkJfUkVHX1NQICogU1pSRUcp KGEwKQotCWx3CXM4LCAoX0pCX1JFR19TOCAqIFNaUkVHKShhMCkKKwlQSUNfUFJPTE9HVUUoX2xv bmdqbXApCisJUFRSX1NVQlUJc3AsIHNwLCBDQUxMRlJBTUVfU0laCisJU0FWRV9HUChDQUxMRlJB TUVfR1ApCiAKKwlSRUdfUFJPTE9HVUUKKwlSRUdfTAkJdjAsIChfSkJfTUFHSUMgICogU1pSRUcp KGEwKQkjIGdldCBtYWdpYyBudW1iZXIKKwlSRUdfTAkJcmEsIChfSkJfUkVHX1JBICogU1pSRUcp KGEwKQorCVJFR19MSQkJdDAsIF9KQl9NQUdJQ19fU0VUSk1QCisJYm5lCQl2MCwgdDAsIGJvdGNo CQkjIGp1bXAgaWYgZXJyb3IKKwlQVFJfQUREVQlzcCwgc3AsIENBTExGUkFNRV9TSVoJIyBkb2Vz IG5vdCBtYXR0ZXIsIHNhbml0eQorCVJFR19MCQlzMCwgKF9KQl9SRUdfUzAgKiBTWlJFRykoYTAp CisJUkVHX0wJCXMxLCAoX0pCX1JFR19TMSAqIFNaUkVHKShhMCkKKwlSRUdfTAkJczIsIChfSkJf UkVHX1MyICogU1pSRUcpKGEwKQorCVJFR19MCQlzMywgKF9KQl9SRUdfUzMgKiBTWlJFRykoYTAp CisJUkVHX0wJCXM0LCAoX0pCX1JFR19TNCAqIFNaUkVHKShhMCkKKwlSRUdfTAkJczUsIChfSkJf UkVHX1M1ICogU1pSRUcpKGEwKQorCVJFR19MCQlzNiwgKF9KQl9SRUdfUzYgKiBTWlJFRykoYTAp CisJUkVHX0wJCXM3LCAoX0pCX1JFR19TNyAqIFNaUkVHKShhMCkKKyNpZiBkZWZpbmVkKF9fbWlw c19uMzIpIHx8IGRlZmluZWQoX19taXBzX242NCkKKwlSRUdfTAkJZ3AsIChfSkJfUkVHX0dQICog U1pSRUcpKGEwKQorI2VuZGlmCisJUkVHX0wJCXNwLCAoX0pCX1JFR19TUCAqIFNaUkVHKShhMCkK KwlSRUdfTAkJczgsIChfSkJfUkVHX1M4ICogU1pSRUcpKGEwKQorCisJUkVHX0VQSUxPR1VFCisJ bW92ZQl2MCwgYTEJCQkjIGdldCByZXR1cm4gdmFsdWUgaW4gMXN0IGFyZwogCWoJcmEKLQltb3Zl CXYwLCBhMQorCW5vcAogCiBib3RjaDoKLQlqYWwJX0NfTEFCRUwobG9uZ2ptcGVycm9yKQorCS8q CisJICogV2Uga25vdyB3ZSBhcmVuJ3QgcmV0dXJuaW5nIHNvIHdlIGRvbid0IGNhcmUgYWJvdXQg cmVzdG9yaW5nCisJICogb3VyIGNhbGxlcidzIEdQLgorCSAqLworCVBUUl9MQQl0OSwgX0NfTEFC RUwobG9uZ2ptcGVycm9yKQorCWphbHIJdDkKIAlub3AKLQlqYWwJX0NfTEFCRUwoYWJvcnQpCi0J bm9wCisKKwlQSUNfVEFJTENBTEwoYWJvcnQpCiBFTkQoX2xvbmdqbXApCkluZGV4OiBsaWIvbGli Yy9taXBzL2dlbi9zZXRqbXAuUwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL2dlbi9zZXRq bXAuUwkocmV2aXNpb24gMjA5MDQwKQorKysgbGliL2xpYmMvbWlwcy9nZW4vc2V0am1wLlMJKHdv cmtpbmcgY29weSkKQEAgLTQxLDYgKzQxLDggQEAKIAlBU01TVFIoIiROZXRCU0Q6IHNldGptcC5T LHYgMS4xNyAyMDA1LzA5LzE3IDExOjQ5OjM5IHRzdXRzdWkgRXhwICQiKQogI2VuZGlmIC8qIExJ QkNfU0NDUyBhbmQgbm90IGxpbnQgKi8KIAorI2luY2x1ZGUgIlNZUy5oIgorCiAjaWZkZWYgX19B QklDQUxMU19fCiAJLmFiaWNhbGxzCiAjZW5kaWYKQEAgLTYxLDEwMCArNjMsMTAyIEBACiAKIE5F U1RFRChzZXRqbXAsIFNFVEpNUF9GUkFNRV9TSVpFLCByYSkKIAkubWFzawkweDgwMDAwMDAwLCAo Q0FMTEZSQU1FX1JBIC0gQ0FMTEZSQU1FX1NJWikKLQkuc2V0CW5vcmVvcmRlcgotI2lmZGVmIF9f QUJJQ0FMTFNfXwotCS5jcGxvYWQJdDkKLSNlbmRpZgotCXN1YnUJc3AsIHNwLCBTRVRKTVBfRlJB TUVfU0laRQkjIGFsbG9jYXRlIHN0YWNrIGZyYW1lCi0jaWZkZWYgX19BQklDQUxMU19fCi0JLmNw cmVzdG9yZSAxNgotI2VuZGlmCi0Jc3cJcmEsIENBTExGUkFNRV9SQShzcCkJCSMgc2F2ZSBSQQot CXN3CWEwLCBDQUxMRlJBTUVfU0laKHNwKQkJIyBzdG9yZSBlbnYKKwlTRVRVUF9HUAorCVBUUl9T VUJVIHNwLCBzcCwgU0VUSk1QX0ZSQU1FX1NJWkUJIyBhbGxvY2F0ZSBzdGFjayBmcmFtZQorCVNB VkVfR1AoQ0FMTEZSQU1FX0dQKQorCVNFVFVQX0dQNjQoQ0FMTEZSQU1FX0dQLCBzZXRqbXApCiAK KwlSRUdfUwlyYSwgQ0FMTEZSQU1FX1JBKHNwKQkJIyBzYXZlIFJBCisJUkVHX1MJYTAsIENBTExG UkFNRV9TSVooc3ApCQkjIHN0b3JlIGVudgorCiAJLyogR2V0IHRoZSBzaWduYWwgbWFzay4gKi8K LQlhZGR1CWEyLCBhMCwgX0pCX1NJR01BU0sgKiBTWlJFRwkjICZvZW52CisJUFRSX0FERFUgYTIs IGEwLCBfSkJfU0lHTUFTSyAqIFNaUkVHCSMgJm9lbnYKIAlsaQlhMCwgMQkJCQkjIFNJR19TRVRC TE9DSwogCW1vdmUJYTEsIHplcm8JCQkjICZlbnYgPT0gMAotCWxhCXQ5LCBfQ19MQUJFTChzaWdw cm9jbWFzaykJIyBnZXQgY3VycmVudCBzaWduYWwgbWFzawotCWphbAl0OQotCW5vcAorCVBUUl9M QQl0OSwgX0NfTEFCRUwoc2lncHJvY21hc2spCSMgZ2V0IGN1cnJlbnQgc2lnbmFsIG1hc2sKKwlq YWxyCXQ5CiAKLQlsdwlhMCwgQ0FMTEZSQU1FX1NJWihzcCkJCSMgcmVzdG9yZSBlbnYgcG9pbnRl cgotCWx3CXJhLCBDQUxMRlJBTUVfUkEoc3ApCQkjIHJlc3RvcmUgUkEKLQlhZGR1CXNwLCBzcCwg U0VUSk1QX0ZSQU1FX1NJWkUJIyBwb3Agc3RhY2sgZnJhbWUKKwlSRVNUT1JFX0dQNjQKKwlSRUdf TAlhMCwgQ0FMTEZSQU1FX1NJWihzcCkJCSMgcmVzdG9yZSBlbnYgcG9pbnRlcgorCVJFR19MCXJh LCBDQUxMRlJBTUVfUkEoc3ApCQkjIHJlc3RvcmUgUkEKKwlQVFJfQUREVSBzcCwgc3AsIFNFVEpN UF9GUkFNRV9TSVpFCSMgcG9wIHN0YWNrIGZyYW1lCiAKLQlsaQl2MCwgX0pCX01BR0lDX1NFVEpN UAotCXN3CXYwLCAoX0pCX01BR0lDICAqIFNaUkVHKShhMCkKLQlzdwlyYSwgKF9KQl9SRUdfUkEg KiBTWlJFRykoYTApCi0Jc3cJczAsIChfSkJfUkVHX1MwICogU1pSRUcpKGEwKQotCXN3CXMxLCAo X0pCX1JFR19TMSAqIFNaUkVHKShhMCkKLQlzdwlzMiwgKF9KQl9SRUdfUzIgKiBTWlJFRykoYTAp Ci0Jc3cJczMsIChfSkJfUkVHX1MzICogU1pSRUcpKGEwKQotCXN3CXM0LCAoX0pCX1JFR19TNCAq IFNaUkVHKShhMCkKLQlzdwlzNSwgKF9KQl9SRUdfUzUgKiBTWlJFRykoYTApCi0Jc3cJczYsIChf SkJfUkVHX1M2ICogU1pSRUcpKGEwKQotCXN3CXM3LCAoX0pCX1JFR19TNyAqIFNaUkVHKShhMCkK LQlzdwlzcCwgKF9KQl9SRUdfU1AgKiBTWlJFRykoYTApCi0Jc3cJczgsIChfSkJfUkVHX1M4ICog U1pSRUcpKGEwKQorCVJFR19MSQl2MCwgX0pCX01BR0lDX1NFVEpNUAorCVJFR19TCXYwLCAoX0pC X01BR0lDICAqIFNaUkVHKShhMCkKKwlSRUdfUwlyYSwgKF9KQl9SRUdfUkEgKiBTWlJFRykoYTAp CisJUkVHX1MJczAsIChfSkJfUkVHX1MwICogU1pSRUcpKGEwKQorCVJFR19TCXMxLCAoX0pCX1JF R19TMSAqIFNaUkVHKShhMCkKKwlSRUdfUwlzMiwgKF9KQl9SRUdfUzIgKiBTWlJFRykoYTApCisJ UkVHX1MJczMsIChfSkJfUkVHX1MzICogU1pSRUcpKGEwKQorCVJFR19TCXM0LCAoX0pCX1JFR19T NCAqIFNaUkVHKShhMCkKKwlSRUdfUwlzNSwgKF9KQl9SRUdfUzUgKiBTWlJFRykoYTApCisJUkVH X1MJczYsIChfSkJfUkVHX1M2ICogU1pSRUcpKGEwKQorCVJFR19TCXM3LCAoX0pCX1JFR19TNyAq IFNaUkVHKShhMCkKKwlSRUdfUwlzcCwgKF9KQl9SRUdfU1AgKiBTWlJFRykoYTApCisJUkVHX1MJ czgsIChfSkJfUkVHX1M4ICogU1pSRUcpKGEwKQorI2lmIGRlZmluZWQoX19taXBzX24zMikgfHwg ZGVmaW5lZChfX21pcHNfbjY0KQorCVJFR19TCWdwLCAoX0pCX1JFR19HUCAqIFNaUkVHKShhMCkK KyNlbmRpZgogCiAJbW92ZQl2MCwgemVybwotCWoJcmEKKwlqcglyYQogRU5EKHNldGptcCkKIAog I2RlZmluZSBMT05HSk1QX0ZSQU1FX1NJWkUJKENBTExGUkFNRV9TSVogKyAoU1pSRUcgKiAyKSkK IAogTkVTVEVEKGxvbmdqbXAsIExPTkdKTVBfRlJBTUVfU0laRSwgcmEpCiAJLm1hc2sJMHg4MDAw MDAwMCwgKENBTExGUkFNRV9SQSAtIENBTExGUkFNRV9TSVopCi0JLnNldAlub3Jlb3JkZXIKLSNp ZmRlZiBfX0FCSUNBTExTX18KLQkuY3Bsb2FkCXQ5Ci0jZW5kaWYKLQlzdWJ1CXNwLCBzcCwgTE9O R0pNUF9GUkFNRV9TSVpFCSMgYWxsb2NhdGUgc3RhY2sgZnJhbWUKLSNpZmRlZiBfX0FCSUNBTExT X18KLQkuY3ByZXN0b3JlIDE2Ci0jZW5kaWYKLQlzdwlyYSwgQ0FMTEZSQU1FX1JBKHNwKQkJIyBz YXZlIFJBCi0JbHcJdjAsIChfSkJfTUFHSUMgICogU1pSRUcpKGEwKQotCWxpCXQwLCBfSkJfTUFH SUNfU0VUSk1QCisJUElDX1BST0xPR1VFKGxvbmdqbXApCisJUFRSX1NVQlUgc3AsIHNwLCBMT05H Sk1QX0ZSQU1FX1NJWkUJIyBhbGxvY2F0ZSBzdGFjayBmcmFtZQorCVNBVkVfR1AoQ0FMTEZSQU1F X0dQKQorCisJUkVHX1MJcmEsIENBTExGUkFNRV9SQShzcCkJCSMgc2F2ZSBSQQorCVJFR19MCXYw LCAoX0pCX01BR0lDICAqIFNaUkVHKShhMCkKKwlSRUdfTEkJdDAsIF9KQl9NQUdJQ19TRVRKTVAK IAlibmUJdjAsIHQwLCBib3RjaAkJIyBqdW1wIGlmIGVycm9yCiAJbm9wCiAKLQlzdwlhMCwgQ0FM TEZSQU1FX1NJWihzcCkJCSMgc2F2ZSBlbnYKLQlzdwlhMSwgKENBTExGUkFNRV9TSVogKyBTWlJF Rykoc3ApCSMgc2F2ZSByZXR1cm4gdmFsdWUKKwlSRUdfUwlhMCwgQ0FMTEZSQU1FX1NJWihzcCkJ CSMgc2F2ZSBlbnYKKwlSRUdfUwlhMSwgKENBTExGUkFNRV9TSVogKyBTWlJFRykoc3ApCSMgc2F2 ZSByZXR1cm4gdmFsdWUKIAogCSMgc2V0IHNpZ21hc2sKLQlhZGR1CWExLCBhMCwgX0pCX1NJR01B U0sgKiBTWlJFRwkjICZzZXQKKwlQVFJfQUREVSBhMSwgYTAsIF9KQl9TSUdNQVNLICogU1pSRUcJ IyAmc2V0CiAJbW92ZQlhMiwgemVybwkJCSMgJm9zZXQgPT0gTlVMTAogCWxpCWEwLCAzCQkJCSMg U0lHX1NFVE1BU0sKLQlsYQl0OSxfQ19MQUJFTChzaWdwcm9jbWFzaykJIyBzZXQgY3VycmVudCBz aWduYWwgbWFzaworCVBUUl9MQQl0OSxfQ19MQUJFTChzaWdwcm9jbWFzaykJIyBzZXQgY3VycmVu dCBzaWduYWwgbWFzawogCWphbAl0OQogCW5vcAogCi0JbHcJYTAsIENBTExGUkFNRV9TSVooc3Ap CQkjIHJlc3RvcmUgZW52Ci0JbHcJYTEsIChDQUxMRlJBTUVfU0laICsgU1pSRUcpKHNwKQkjIHJl c3RvcmUgcmV0dXJuIHZhbHVlCisJUkVHX0wJYTAsIENBTExGUkFNRV9TSVooc3ApCQkjIHJlc3Rv cmUgZW52CisJUkVHX0wJYTEsIChDQUxMRlJBTUVfU0laICsgU1pSRUcpKHNwKQkjIHJlc3RvcmUg cmV0dXJuIHZhbHVlCiAKLQlsdwlyYSwgKF9KQl9SRUdfUkEgKiBTWlJFRykoYTApCi0JbHcJczAs IChfSkJfUkVHX1MwICogU1pSRUcpKGEwKQotCWx3CXMxLCAoX0pCX1JFR19TMSAqIFNaUkVHKShh MCkKLQlsdwlzMiwgKF9KQl9SRUdfUzIgKiBTWlJFRykoYTApCi0JbHcJczMsIChfSkJfUkVHX1Mz ICogU1pSRUcpKGEwKQotCWx3CXM0LCAoX0pCX1JFR19TNCAqIFNaUkVHKShhMCkKLQlsdwlzNSwg KF9KQl9SRUdfUzUgKiBTWlJFRykoYTApCi0JbHcJczYsIChfSkJfUkVHX1M2ICogU1pSRUcpKGEw KQotCWx3CXM3LCAoX0pCX1JFR19TNyAqIFNaUkVHKShhMCkKLQlsdwlzcCwgKF9KQl9SRUdfU1Ag KiBTWlJFRykoYTApCi0JbHcJczgsIChfSkJfUkVHX1M4ICogU1pSRUcpKGEwKQorCVJFR19MCXJh LCAoX0pCX1JFR19SQSAqIFNaUkVHKShhMCkKKwlSRUdfTAlzMCwgKF9KQl9SRUdfUzAgKiBTWlJF RykoYTApCisJUkVHX0wJczEsIChfSkJfUkVHX1MxICogU1pSRUcpKGEwKQorCVJFR19MCXMyLCAo X0pCX1JFR19TMiAqIFNaUkVHKShhMCkKKwlSRUdfTAlzMywgKF9KQl9SRUdfUzMgKiBTWlJFRyko YTApCisJUkVHX0wJczQsIChfSkJfUkVHX1M0ICogU1pSRUcpKGEwKQorCVJFR19MCXM1LCAoX0pC X1JFR19TNSAqIFNaUkVHKShhMCkKKwlSRUdfTAlzNiwgKF9KQl9SRUdfUzYgKiBTWlJFRykoYTAp CisJUkVHX0wJczcsIChfSkJfUkVHX1M3ICogU1pSRUcpKGEwKQorCVJFR19MCXNwLCAoX0pCX1JF R19TUCAqIFNaUkVHKShhMCkKKwlSRUdfTAlzOCwgKF9KQl9SRUdfUzggKiBTWlJFRykoYTApCisj aWYgZGVmaW5lZChfX21pcHNfbjMyKSB8fCBkZWZpbmVkKF9fbWlwc19uNjQpCisJUkVHX0wJZ3As IChfSkJfUkVHX0dQICogU1pSRUcpKGEwKQorI2VuZGlmCisKIAltb3ZlCXYwLCBhMQogCWoJcmEK IAlub3AKIAogYm90Y2g6Ci0JbGEJdDksIF9DX0xBQkVMKGxvbmdqbXBlcnJvcikKLQlqYWwJdDkK KwkvKgorCSAqIFdlIGtub3cgd2UgYXJlbid0IHJldHVybmluZyBzbyB3ZSBkb24ndCBjYXJlIGFi b3V0IHJlc3RvcmluZworCSAqIG91ciBjYWxsZXIncyBHUC4KKwkgKi8KKwlQVFJfTEEJdDksIF9D X0xBQkVMKGxvbmdqbXBlcnJvcikKKwlqYWxyCXQ5CiAJbm9wCiAKLQlsYQl0OSwgX0NfTEFCRUwo YWJvcnQpCi0JamFsCXQ5Ci0Jbm9wCisJUElDX1RBSUxDQUxMKGFib3J0KQogRU5EKGxvbmdqbXAp CkluZGV4OiBsaWIvbGliYy9taXBzL2dlbi9zaWdzZXRqbXAuUwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIv bGliYy9taXBzL2dlbi9zaWdzZXRqbXAuUwkocmV2aXNpb24gMjA5MDQwKQorKysgbGliL2xpYmMv bWlwcy9nZW4vc2lnc2V0am1wLlMJKHdvcmtpbmcgY29weSkKQEAgLTQwLDYgKzQwLDggQEAKIAlB U01TVFIoIiROZXRCU0Q6IHNpZ3NldGptcC5TLHYgMS44IDIwMDUvMDkvMTcgMTE6NDk6MzkgdHN1 dHN1aSBFeHAgJCIpCiAjZW5kaWYgLyogTElCQ19TQ0NTIGFuZCBub3QgbGludCAqLwogCisjaW5j bHVkZSAiU1lTLmgiCisKICNpZmRlZiBfX0FCSUNBTExTX18KIAkuYWJpY2FsbHMKICNlbmRpZgpA QCAtNTcsMzAgKzU5LDE5IEBACiAgKi8KIAogTEVBRihzaWdzZXRqbXApCi0jaWZkZWYgX19BQklD QUxMU19fCi0JLnNldAlub3Jlb3JkZXIKLQkuY3Bsb2FkCXQ5Ci0JLnNldAlyZW9yZGVyCi0jZW5k aWYKKwlQSUNfUFJPTE9HVUUoc2lnc2V0am1wKQorCiAJYm5lCWExLCAweDAsIDFmCQkJIyBkbyBz YXZpbmcgb2Ygc2lnbmFsIG1hc2s/Ci0JbGEJdDksIF9zZXRqbXAKLQlqciB0OQorCVBJQ19UQUlM Q0FMTChfc2V0am1wKQogCi0xOglsYQl0OSwgc2V0am1wCi0JanIgdDkKKzE6CVBJQ19UQUlMQ0FM TChzZXRqbXApCiBFTkQoc2lnc2V0am1wKQogCiBMRUFGKHNpZ2xvbmdqbXApCi0jaWZkZWYgX19B QklDQUxMU19fCi0JLnNldAlub3Jlb3JkZXIKLQkuY3Bsb2FkCXQ5Ci0JLnNldAlyZW9yZGVyCi0j ZW5kaWYKLQlsdwl0MCwgKF9KQl9NQUdJQyAgKiBTWlJFRykoYTApCi0JbGkJdDEsIF9KQl9NQUdJ Q19fU0VUSk1QCisJUElDX1BST0xPR1VFKHNpZ2xvbmdqbXApCisJUkVHX0wJdDAsIChfSkJfTUFH SUMgICogU1pSRUcpKGEwKQorCVJFR19MSQl0MSwgX0pCX01BR0lDX19TRVRKTVAKIAlibmUJdDAs IHQxLCAxZgkJCSMgc2V0am1wIG9yIF9zZXRqbXAgbWFnaWM/Ci0JbGEJdDksIF9sb25nam1wCi0J anIJdDkKLTE6CWxhCXQ5LCBsb25nam1wCi0JanIJdDkKKwlQSUNfVEFJTENBTEwoX2xvbmdqbXAp CisxOglQSUNfVEFJTENBTEwobG9uZ2ptcCkKIEVORChzaWdsb25nam1wKQpJbmRleDogbGliL2xp YmMvbWlwcy9zeXMvYnJrLlMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9zeXMvYnJrLlMJ KHJldmlzaW9uIDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvc3lzL2Jyay5TCSh3b3JraW5nIGNv cHkpCkBAIC00OSwyNSArNDksMjMgQEAKIF9DX0xBQkVMKG1pbmJyayk6CiAJLndvcmQJX0NfTEFC RUwoX2VuZCkKIAorCS50ZXh0CiBMRUFGKF9fc3lzX2JyaykKIAlXRUFLX0FMSUFTKGJyaywgX19z eXNfYnJrKQogCVdFQUtfQUxJQVMoX2JyaywgX19zeXNfYnJrKQotI2lmZGVmIF9fQUJJQ0FMTFNf XwotCS5zZXQJbm9yZW9yZGVyCi0JLmNwbG9hZAl0OQotCS5zZXQJcmVvcmRlcgotI2VuZGlmCi0J bHcJdjAsIF9DX0xBQkVMKG1pbmJyaykKKwlQSUNfUFJPTE9HVUUoX19zeXNfYnJrKQorCVBUUl9M QQl2MCwgX0NfTEFCRUwobWluYnJrKQorCVBUUl9MCXYwLCAwKHYwKQogCWJnZXUJYTAsIHYwLCAx ZgogCW1vdmUJYTAsIHYwCQkjIGRvbnQgYWxsb3cgYnJlYWsgPCBtaW5icmsKIDE6CiAJbGkJdjAs IFNZU19icmVhawogCXN5c2NhbGwKIAlibmUJYTMsIHplcm8sIDJmCi0Jc3cJYTAsIF9DX0xBQkVM KF9fY3VyYnJrKQorCVBUUl9MQQl0MCwgX0NfTEFCRUwoX19jdXJicmspCisJUFRSX1MJYTAsIDAo dDApCiAJbW92ZQl2MCwgemVybwotCWoJcmEKKwlQSUNfUkVUVVJOKCkKIDI6Ci0JbGEJdDksIF9D X0xBQkVMKF9fY2Vycm9yKQotCWpyCXQ5CisJUElDX1RBSUxDQUxMKF9fY2Vycm9yKQogRU5EKF9f c3lzX2JyaykKSW5kZXg6IGxpYi9saWJjL21pcHMvc3lzL3B0cmFjZS5TCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IGxpYi9saWJjL21pcHMvc3lzL3B0cmFjZS5TCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGli Yy9taXBzL3N5cy9wdHJhY2UuUwkod29ya2luZyBjb3B5KQpAQCAtNDEsMzIgKzQxLDMxIEBACiAJ QVNNU1RSKCIkTmV0QlNEOiBwdHJhY2UuUyx2IDEuOSAyMDAzLzA4LzA3IDE2OjQyOjE3IGFnYyBF eHAgJCIpCiAjZW5kaWYgLyogTElCQ19TQ0NTIGFuZCBub3QgbGludCAqLwogCi1MRUFGKHB0cmFj ZSkKLQkuZnJhbWUJc3AsIDQwLCByYQotCS5tYXNrCTB4ODAwMDAwMDAsIC04Ci0jaWZkZWYgX19B QklDQUxMU19fCi0JLnNldCAgICBub3Jlb3JkZXIKLQkuY3Bsb2FkIHQ5Ci0JLnNldCAgICByZW9y ZGVyCi0jZW5kaWYKLQlzdWJ1CXNwLCBzcCwgNDAKLQlzdwlyYSwgIDMyKHNwKQotI2lmZGVmIF9f QUJJQ0FMTFNfXwotCS5jcHJlc3RvcmUgMTYKLSNlbmRpZgotCWxhCXQ5LCBfQ19MQUJFTChfX2Vy cm9yKQkjIGxvY2F0ZSBhZGRyZXNzIG9mIGVycm5vCi0JamFscgl0OQotI2lmZGVmIF9fQUJJQ0FM TFNfXwotCWx3CWdwLCAxNihzcCkKLSNlbmRpZgotCXN3CXplcm8sIDAodjApCi0JbHcJcmEsIDMy KHNwKQotCWFkZHUJc3AsIHNwLCA0MAotCWxpCXYwLCBTWVNfcHRyYWNlCitORVNURURfTk9QUk9G SUxFKHB0cmFjZSwgQ0FMTEZSQU1FX1NJWiwgcmEpCisJLm1hc2sJMHg4MDAwMDAwMCwgKENBTExG UkFNRV9SQSAtIENBTExGUkFNRV9TSVopCisJU0VUVVBfR1AKKwlQVFJfU1VCVQlzcCwgc3AsIENB TExGUkFNRV9TSVoKKwlTRVRVUF9HUDY0KENBTExGUkFNRV9HUCwgcHRyYWNlKQorCVNBVkVfR1Ao Q0FMTEZSQU1FX0dQKQorCisJUFRSX1MJCXJhLCBDQUxMRlJBTUVfUkEoc3ApCisKKwlQVFJfTEEJ CXQ5LCBfQ19MQUJFTChfX2Vycm9yKQkjIGxvY2F0ZSBhZGRyZXNzIG9mIGVycm5vCisJamFscgkJ dDkKKworCVBUUl9MCQlyYSwgQ0FMTEZSQU1FX1JBKHNwKQorCUlOVF9TCQl6ZXJvLCAwKHYwKQkJ IyB1cGRhdGUgZXJybm8gdmFsdWUKKworCWxpCQl2MCwgU1lTX3B0cmFjZQogCXN5c2NhbGwKLQli bmUJYTMsIHplcm8sIDFmCi0JaglyYQotMToKLQlsYQl0OSwgX0NfTEFCRUwoX19jZXJyb3IpCi0J anIJdDkKKworCSMgTG9hZCBfX2NlcnJvcidzIGFkZHJlc3MgdXNpbmcgb3VyIGdwLCB0aGVuIHJl c3RvcmUgaXQuCisJUFRSX0xBCQl0OSwgX19jZXJyb3IKKwlSRVNUT1JFX0dQNjQKKwlQVFJfQURE VQlzcCwgc3AsIENBTExGUkFNRV9TSVoKKworCWJuZQkJYTMsIHplcm8sIDFmCisKKwlqCQlyYQor MToJagkJdDkKIEVORChwdHJhY2UpCkluZGV4OiBsaWIvbGliYy9taXBzL3N5cy9mb3JrLlMKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9zeXMvZm9yay5TCShyZXZpc2lvbiAyMDkwNDApCisr KyBsaWIvbGliYy9taXBzL3N5cy9mb3JrLlMJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDIwICs0NCwx NCBAQAogTEVBRihfX3N5c19mb3JrKQogCVdFQUtfQUxJQVMoZm9yaywgX19zeXNfZm9yaykKIAlX RUFLX0FMSUFTKF9mb3JrLCBfX3N5c19mb3JrKQotI2lmZGVmIF9fQUJJQ0FMTFNfXwotCS5zZXQg ICAgbm9yZW9yZGVyCi0JLmNwbG9hZCB0OQotCS5zZXQgICAgcmVvcmRlcgotI2VuZGlmCi0JZm9y ayA9IF9fc3lzX2ZvcmsKKwlQSUNfUFJPTE9HVUUoX19zeXNfZm9yaykKIAlsaQl2MCwgU1lTX2Zv cmsJIyBwaWQgPSBmb3JrKCkKIAlzeXNjYWxsCiAJYm5lCWEzLCB6ZXJvLCAyZgogCWJlcQl2MSwg emVybywgMWYJIyB2MSA9PSAwIGluIHBhcmVudCwgMSBpbiBjaGlsZAogCW1vdmUJdjAsIHplcm8K IDE6Ci0JaglyYQorCVBJQ19SRVRVUk4oKQogMjoKLQlsYQl0OSwgX0NfTEFCRUwoX19jZXJyb3Ip Ci0JanIJdDkKKwlQSUNfVEFJTENBTEwoX19jZXJyb3IpCiBFTkQoX19zeXNfZm9yaykKSW5kZXg6 IGxpYi9saWJjL21pcHMvc3lzL3NicmsuUwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL3N5 cy9zYnJrLlMJKHJldmlzaW9uIDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvc3lzL3NicmsuUwko d29ya2luZyBjb3B5KQpAQCAtNTIsMzQgKzUyLDIyIEBACiBMRUFGKF9fc3lzX3NicmspCiAJV0VB S19BTElBUyhzYnJrLCBfX3N5c19zYnJrKQogCVdFQUtfQUxJQVMoX3NicmssIF9fc3lzX3Nicmsp Ci0jaWZkZWYgX19BQklDQUxMU19fCi0JLnNldAlub3Jlb3JkZXIKLQkuY3Bsb2FkCXQ5Ci0JLnNl dAlyZW9yZGVyCi0jZW5kaWYKLQlhZGR1CXNwLCBzcCwgLTE2Ci0Jc3cJczAsIDAoc3ApCQkjIFBy ZXNlcnZlIHMwIHZhbHVlIGluIHN0YWNrCi0JCQkJCSMgaXQgc2hvdWxkIGJlIHRoZSBzYW1lIG9u IHJldHVybgotCQkJCQkjIFdlIGNhbid0IHVzZSB2MSBhcyB0ZW1wb3JhcnkKLQkJCQkJIyByZWdp c3RlciBzaW5jZSBzeXNjYWxsIHVzZXMgaXQKLQkJCQkJIyB0byByZXR1cm4gNjQtYml0IHZhbHVl cwotCWx3CXMwLCBfQ19MQUJFTChfX2N1cmJyaykKLQlsaQl2MCwgU1lTX2JyZWFrCi0JYWRkdQlh MCwgYTAsIHMwCQkjIGNvbXB1dGUgY3VycmVudCBicmVhaworCVBJQ19QUk9MT0dVRShfX3N5c19z YnJrKQorCVBUUl9MQQl0MCwgX0NfTEFCRUwoX19jdXJicmspCisJUFRSX0wJdDAsIDAodDApCisJ UFRSX0FERFUgYTAsIGEwLCB0MAogCisJbGkJdjAsIFNZU19icmVhawogCXN5c2NhbGwKIAogCWJu ZQlhMywgemVybywgMWYKIAlub3AKLQltb3ZlCXYwLCBzMAkJCSMgcmV0dXJuIG9sZCB2YWwgb2Yg Y3VyYnJrIGZyb20gYWJvdmUKLQlsdwlzMCwgMChzcCkKLQlhZGR1CXNwLCBzcCwgMTYKLQlzdwlh MCwgX0NfTEFCRUwoX19jdXJicmspCSMgc2F2ZSBjdXJyZW50IHZhbCBvZiBjdXJicmsgZnJvbSBh Ym92ZQorCW1vdmUJdjAsIHQwCQkJIyByZXR1cm4gb2xkIHZhbCBvZiBjdXJicmsgZnJvbSBhYm92 ZQorCVBUUl9MQQl0MCwgX0NfTEFCRUwoX19jdXJicmspCisJUFRSX1MJYTAsIDAodDApCQkjIHNh dmUgY3VycmVudCB2YWwgb2YgY3VyYnJrIGZyb20gYWJvdmUKKwlQSUNfUkVUVVJOKCkKIAlqCXJh CiAKIDE6Ci0JbHcJczAsIDAoc3ApCi0JYWRkdQlzcCwgc3AsIDE2Ci0JbGEJdDksIF9DX0xBQkVM KF9fY2Vycm9yKQotCWpyCXQ5CisJUElDX1RBSUxDQUxMKF9fY2Vycm9yKQogRU5EKF9fc3lzX3Ni cmspCkluZGV4OiBsaWIvbGliYy9taXBzL3N5cy9PdmZvcmsuUwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIv bGliYy9taXBzL3N5cy9PdmZvcmsuUwkocmV2aXNpb24gMjA5MDQwKQorKysgbGliL2xpYmMvbWlw cy9zeXMvT3Zmb3JrLlMJKHdvcmtpbmcgY29weSkKQEAgLTQ5LDIxICs0OSwxNiBAQAogICovCiAK IExFQUYoX19zeXNfdmZvcmspCi0jaWZkZWYgX19BQklDQUxMU19fCi0JLnNldAlub3Jlb3JkZXIK LQkuY3Bsb2FkCXQ5Ci0JLnNldAlyZW9yZGVyCi0jZW5kaWYKIAlXRUFLX0FMSUFTKHZmb3JrLCBf X3N5c192Zm9yaykKIAlXRUFLX0FMSUFTKF92Zm9yaywgX19zeXNfdmZvcmspCisJUElDX1BST0xP R1VFKF9fc3lzX3Zmb3JrKQogCWxpCXYwLCBTWVNfdmZvcmsJCSMgc3lzdGVtIGNhbGwgbnVtYmVy IGZvciB2Zm9yawogCXN5c2NhbGwKIAliZXEJYTMsIHplcm8sIDFmCQkjIGp1bXAgaWYgbm8gZXJy b3JzCi0JbGEJdDksIF9fY2Vycm9yCi0JanIJdDkKKwlQSUNfVEFJTENBTEwoX19jZXJyb3IpCiAx OgogCWJlcQl2MSwgemVybywgMmYJCSMgcGFyZW50IHByb2Nlc3MgPwogCW1vdmUJdjAsIHplcm8J CSMgcmV0dXJuIHplcm8gaW4gY2hpbGQKIDI6Ci0JaglyYQorCVBJQ19SRVRVUk4oKQogRU5EKF9f c3lzX3Zmb3JrKQpJbmRleDogbGliL2xpYmMvbWlwcy9zeXMvZXhlY3QuUwo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBsaWIvbGliYy9taXBzL3N5cy9leGVjdC5TCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGli Yy9taXBzL3N5cy9leGVjdC5TCSh3b3JraW5nIGNvcHkpCkBAIC00MSwxNiArNDEsMTEgQEAKICNl bmRpZiAvKiBMSUJDX1NDQ1MgYW5kIG5vdCBsaW50ICovCiAKIExFQUYoZXhlY3QpCi0jaWZkZWYg X19BQklDQUxMU19fCi0JLnNldCAgICBub3Jlb3JkZXIKLQkuY3Bsb2FkIHQ5Ci0JLnNldCAgICBy ZW9yZGVyCi0jZW5kaWYKKwlQSUNfUFJPTE9HVUUoZXhlY3QpCiAJbGkJdjAsIFNZU19leGVjdmUK IAlzeXNjYWxsCiAJYm5lCWEzLCB6ZXJvLCAxZgotCWoJcmEKKwlQSUNfUkVUVVJOKCkKIDE6Ci0J bGEgICAgICB0OSwgX0NfTEFCRUwoX19jZXJyb3IpCi0JanIgICAgICB0OQorCVBJQ19UQUlMQ0FM TChfX2NlcnJvcikKIEVORChleGVjdCkKSW5kZXg6IGxpYi9saWJjL21pcHMvc3lzL2NlcnJvci5T Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIGxpYi9saWJjL21pcHMvc3lzL2NlcnJvci5TCShyZXZpc2lvbiAyMDkw NDApCisrKyBsaWIvbGliYy9taXBzL3N5cy9jZXJyb3IuUwkod29ya2luZyBjb3B5KQpAQCAtMSw0 ICsxLDQgQEAKLS8qCSROZXRCU0Q6IGNlcnJvci5TLHYgMS4xMyAyMDAzLzA4LzA3IDE2OjQyOjE3 IGFnYyBFeHAgJAkqLworLyoJJE5ldEJTRDogY2Vycm9yLlMsdiAxLjE0IDIwMDkvMTIvMTQgMDE6 MDc6NDIgbWF0dCBFeHAgJAkqLwogCiAvKi0KICAqIENvcHlyaWdodCAoYykgMTk5MSwgMTk5MwpA QCAtMzcsMzUgKzM3LDM2IEBACiAjaW5jbHVkZSAiU1lTLmgiCiAKICNpZiBkZWZpbmVkKExJQkNf U0NDUykgJiYgIWRlZmluZWQobGludCkKLQlBU01TVFIoImZyb206IEAoIyljZXJyb3Iucwk4LjEg KEJlcmtlbGV5KSA2LzE2LzkzIikKLQlBU01TVFIoIiROZXRCU0Q6IGNlcnJvci5TLHYgMS4xMyAy MDAzLzA4LzA3IDE2OjQyOjE3IGFnYyBFeHAgJCIpCisjaWYgMAorCVJDU0lEKCJmcm9tOiBAKCMp Y2Vycm9yLnMJOC4xIChCZXJrZWxleSkgNi8xNi85MyIpCisjZWxzZQorCVJDU0lEKCIkTmV0QlNE OiBjZXJyb3IuUyx2IDEuMTQgMjAwOS8xMi8xNCAwMTowNzo0MiBtYXR0IEV4cCAkIikKKyNlbmRp ZgogI2VuZGlmIC8qIExJQkNfU0NDUyBhbmQgbm90IGxpbnQgKi8KIAorCS5nbG9ibAlfQ19MQUJF TChfX2Vycm9yKQorTkVTVEVEX05PUFJPRklMRShfX2NlcnJvciwgQ0FMTEZSQU1FX1NJWiwgcmEp CisJLm1hc2sJMHg4MDAwMDAwMCwgKENBTExGUkFNRV9SQSAtIENBTExGUkFNRV9TSVopCisJU0VU VVBfR1AKKwlQVFJfU1VCVQlzcCwgc3AsIENBTExGUkFNRV9TSVoKKwlTRVRVUF9HUDY0KENBTExG UkFNRV9HUCwgX19jZXJyb3IpCisJU0FWRV9HUChDQUxMRlJBTUVfR1ApCiAKLQkvKgotCSAqIFRo ZSBfX2Vycm9yKCkgZnVuY3Rpb24gaXMgdGhyZWFkIGF3YXJlLiBGb3Igbm9uLXRocmVhZGVkCi0J ICogcHJvZ3JhbXMgYW5kIHRoZSBpbml0aWFsIHRocmVhZGVkIGluIHRocmVhZGVkIHByb2dyYW1z LAotCSAqIGl0IHJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBnbG9iYWwgZXJybm8gdmFyaWFibGUu Ci0JICovCi0JLmdsb2JsICBfQ19MQUJFTChfX2Vycm9yKQotCS50eXBlICAgX0NfTEFCRUwoX19l cnJvciksJWZ1bmN0aW9uCisJUFRSX1MJCXJhLCBDQUxMRlJBTUVfUkEoc3ApCisJUkVHX1MJCXYw LCBDQUxMRlJBTUVfUzAoc3ApCSMgc2F2ZSBlcnJubyB2YWx1ZQogCi1MRUFGKF9fY2Vycm9yKQot CS5mcmFtZSBzcCwgQ0FMTEZSQU1FX1NJWiwgcmEKLQlQSUNfUFJPTE9HVUUoX19jZXJyb3IsIHQ5 KQotCXN1YnUJc3AsIHNwLCBDQUxMRlJBTUVfU0laCi0JLm1hc2sJMHg4MDAwMDAwMCwgKENBTExG UkFNRV9SQSAtIENBTExGUkFNRV9TSVopCi0Jc3cJcmEsIENBTExGUkFNRV9SQShzcCkKLQlzdwl2 MCwgMTIoc3ApCQkjIHNhdmUgZXJybm8gdmFsdWUKKwlQVFJfTEEJCXQ5LCBfQ19MQUJFTChfX2Vy cm9yKQkjIGxvY2F0ZSBhZGRyZXNzIG9mIGVycm5vCisJamFscgkJdDkKIAotCWxhCXQ5LCBfQ19M QUJFTChfX2Vycm9yKQkjIGxvY2F0ZSBhZGRyZXNzIG9mIGVycm5vCi0JamFscgl0OQorCVJFR19M CQl0MCwgQ0FMTEZSQU1FX1MwKHNwKQorCVBUUl9MCQlyYSwgQ0FMTEZSQU1FX1JBKHNwKQorCUlO VF9TCQl0MCwgMCh2MCkJCSMgdXBkYXRlIGVycm5vIHZhbHVlCiAKLQlsdwl0MCwgMTIoc3ApCi0J bHcJcmEsIENBTExGUkFNRV9SQShzcCkKLQlzdwl0MCwgMCh2MCkJCSMgdXBkYXRlIGVycm5vIHZh bHVlCi0JYWRkaXUJc3AsIHNwLCBDQUxMRlJBTUVfU0laCi0JbGkJdjAsIC0xCi0JbGkJdjEsIC0x Ci0JaglyYQorCVJFU1RPUkVfR1A2NAorCVBUUl9BRERVCXNwLCBzcCwgQ0FMTEZSQU1FX1NJWgor CisJbGkJCXYwLCAtMQorCWxpCQl2MSwgLTEKKworCWoJCXJhCiBFTkQoX19jZXJyb3IpCkluZGV4 OiBsaWIvbGliYy9taXBzL3N5cy9waXBlLlMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9z eXMvcGlwZS5TCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBzL3N5cy9waXBlLlMJ KHdvcmtpbmcgY29weSkKQEAgLTQ0LDE5ICs0NCwxNCBAQAogTEVBRihfX3N5c19waXBlKQogCVdF QUtfQUxJQVMocGlwZSwgX19zeXNfcGlwZSkKIAlXRUFLX0FMSUFTKF9waXBlLCBfX3N5c19waXBl KQotI2lmZGVmIF9fQUJJQ0FMTFNfXwotCS5zZXQgICAgbm9yZW9yZGVyCi0JLmNwbG9hZCB0OQot CS5zZXQgICAgcmVvcmRlcgotI2VuZGlmCisJUElDX1BST0xPR1VFKF9fc3lzX3BpcGUpCiAJbGkJ djAsIFNZU19waXBlCSMgcGlwZShmaWxkZXMpIGludCBmaWxkZXNbMl07CiAJc3lzY2FsbAogCWJu ZQlhMywgemVybywgMWYKIAlzdwl2MCwgMChhMCkJIyBzdG9yZSB0aGUgdHdvIGZpbGUgZGVzY3Jp cHRvcnMKIAlzdwl2MSwgNChhMCkKIAltb3ZlCXYwLCB6ZXJvCi0JaglyYQorCVBJQ19SRVRVUk4o KQogMToKLQlsYQl0OSwgX0NfTEFCRUwoX19jZXJyb3IpCi0JanIJdDkKKwlQSUNfVEFJTENBTEwo X19jZXJyb3IpCiBFTkQoX19zeXNfcGlwZSkK --e0cb4e88758397b495048911b0d9 Content-Type: text/x-patch; charset=US-ASCII; name="libc-other.patch" Content-Disposition: attachment; filename="libc-other.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gagrg8vx1 SW5kZXg6IGxpYi9saWJjL21pcHMvU3ltYm9sLm1hcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9t aXBzL1N5bWJvbC5tYXAJKHJldmlzaW9uIDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvU3ltYm9s Lm1hcAkod29ya2luZyBjb3B5KQpAQCAtMjQsMTMgKzI0LDkgQEAKIAlzaWdzZXRqbXA7CiAJc2ln bG9uZ2ptcDsKIAlodG9ubDsKLQlfX2h0b25sOwogCWh0b25zOwotCV9faHRvbnM7CiAJbnRvaGw7 Ci0JX19udG9obDsKIAludG9oczsKLQlfX250b2hzOwogCXZmb3JrOwogCWJyazsKIAljZXJyb3I7 CQkvKiBYWFggLSBTaG91bGQgdGhpcyBiZSAuY2Vycm9yIChzZWUgc3lzL2NlcnJvci5TKT8gKi8K SW5kZXg6IGxpYi9saWJjL21pcHMvTWFrZWZpbGUuaW5jCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGxpYi9saWJj L21pcHMvTWFrZWZpbGUuaW5jCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBzL01h a2VmaWxlLmluYwkod29ya2luZyBjb3B5KQpAQCAtMSw4ICsxLDYgQEAKICMJJE5ldEJTRDogTWFr ZWZpbGUuaW5jLHYgMS43IDIwMDUvMDkvMTcgMTE6NDk6MzkgdHN1dHN1aSBFeHAgJAogIyAkRnJl ZUJTRCQKIAotU09GVEZMT0FUX0JJVFM9MzIKLQogQ0ZMQUdTKz0tRFNPRlRGTE9BVAogCiBNRFNS Q1MrPSBtYWNoZGVwX2xkaXNkLmMKSW5kZXg6IGxpYi9saWJjL21pcHMvZ2VuL01ha2VmaWxlLmlu Ywo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBsaWIvbGliYy9taXBzL2dlbi9NYWtlZmlsZS5pbmMJKHJldmlzaW9u IDIwOTA0MCkKKysrIGxpYi9saWJjL21pcHMvZ2VuL01ha2VmaWxlLmluYwkod29ya2luZyBjb3B5 KQpAQCAtNiw0ICs2LDQgQEAKICMgU1JDUys9CWZsdF9yb3VuZHMuYyBmcGdldG1hc2suYyBmcGdl dHJvdW5kLmMgZnBnZXRzdGlja3kuYyBmcHNldG1hc2suYyBcCiAjCWZwc2V0cm91bmQuYyBmcHNl dHN0aWNreS5jCiAKLVNSQ1MrPQlfc2V0X3RwLmMgX3NldGptcC5TIG1ha2Vjb250ZXh0LmMgc2V0 am1wLlMgc2lnbmFsY29udGV4dC5jIHNpZ3NldGptcC5TCitTUkNTKz0JX2N0eF9zdGFydC5TIF9z ZXRfdHAuYyBfc2V0am1wLlMgbWFrZWNvbnRleHQuYyBzZXRqbXAuUyBzaWduYWxjb250ZXh0LmMg c2lnc2V0am1wLlMKSW5kZXg6IGxpYi9saWJjL21pcHMvZ2VuL21ha2Vjb250ZXh0LmMKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gbGliL2xpYmMvbWlwcy9nZW4vbWFrZWNvbnRleHQuYwkocmV2aXNpb24gMjA5MDQw KQorKysgbGliL2xpYmMvbWlwcy9nZW4vbWFrZWNvbnRleHQuYwkod29ya2luZyBjb3B5KQpAQCAt MSw0ICsxLDQgQEAKLS8qCSROZXRCU0Q6IG1ha2Vjb250ZXh0LmMsdiAxLjMgMjAwMy8wMS8xOSAw ODo1MzozNiBtYXR0IEV4cCAkCSovCisvKgkkTmV0QlNEOiBtYWtlY29udGV4dC5jLHYgMS41IDIw MDkvMTIvMTQgMDE6MDc6NDIgbWF0dCBFeHAgJAkqLwogCiAvKi0KICAqIENvcHlyaWdodCAoYykg MjAwMSBUaGUgTmV0QlNEIEZvdW5kYXRpb24sIEluYy4KQEAgLTE1LDEzICsxNSw2IEBACiAgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAogICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQogICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KLSAqIDMuIEFs bCBhZHZlcnRpc2luZyBtYXRlcmlhbHMgbWVudGlvbmluZyBmZWF0dXJlcyBvciB1c2Ugb2YgdGhp cyBzb2Z0d2FyZQotICogICAgbXVzdCBkaXNwbGF5IHRoZSBmb2xsb3dpbmcgYWNrbm93bGVkZ2Vt ZW50OgotICogICAgICAgIFRoaXMgcHJvZHVjdCBpbmNsdWRlcyBzb2Z0d2FyZSBkZXZlbG9wZWQg YnkgdGhlIE5ldEJTRAotICogICAgICAgIEZvdW5kYXRpb24sIEluYy4gYW5kIGl0cyBjb250cmli dXRvcnMuCi0gKiA0LiBOZWl0aGVyIHRoZSBuYW1lIG9mIFRoZSBOZXRCU0QgRm91bmRhdGlvbiBu b3IgdGhlIG5hbWVzIG9mIGl0cwotICogICAgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCi0gKiAgICBmcm9tIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCiAgKgogICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgTkVUQlNEIEZPVU5EQVRJT04sIElOQy4gQU5E IENPTlRSSUJVVE9SUwogICogYGBBUyBJUycnIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVECkBAIC0zOSw0OCArMzIsOTIgQEAK ICNpbmNsdWRlIDxzeXMvY2RlZnMuaD4KIF9fRkJTRElEKCIkRnJlZUJTRCQiKTsKICNpZiBkZWZp bmVkKExJQkNfU0NDUykgJiYgIWRlZmluZWQobGludCkKLV9fUkNTSUQoIiROZXRCU0Q6IG1ha2Vj b250ZXh0LmMsdiAxLjMgMjAwMy8wMS8xOSAwODo1MzozNiBtYXR0IEV4cCAkIik7CitfX1JDU0lE KCIkTmV0QlNEOiBtYWtlY29udGV4dC5jLHYgMS41IDIwMDkvMTIvMTQgMDE6MDc6NDIgbWF0dCBF eHAgJCIpOwogI2VuZGlmCiAKLSNpbmNsdWRlIDxzeXMvdHlwZXMuaD4KKyNpbmNsdWRlIDxzeXMv cGFyYW0uaD4KKyNpbmNsdWRlIDxtYWNoaW5lL3JlZ251bS5oPgorCisjaW5jbHVkZSA8c3RkYXJn Lmg+CisjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisjaW5jbHVkZSA8 c3RkaW8uaD4KICNpbmNsdWRlIDx1Y29udGV4dC5oPgotI2luY2x1ZGUgPHN0ZGFyZy5oPgogCitf X3dlYWtfcmVmZXJlbmNlKF9fbWFrZWNvbnRleHQsIG1ha2Vjb250ZXh0KTsKKwordm9pZCBfY3R4 X2RvbmUodWNvbnRleHRfdCAqKTsKK3ZvaWQgX2N0eF9zdGFydCh2b2lkKTsKKwogdm9pZAotbWFr ZWNvbnRleHQodWNvbnRleHRfdCAqdWNwLCB2b2lkICgqZnVuYykodm9pZCksIGludCBhcmdjLCAu Li4pCitfX21ha2Vjb250ZXh0KHVjb250ZXh0X3QgKnVjcCwgdm9pZCAoKmZ1bmMpKHZvaWQpLCBp bnQgYXJnYywgLi4uKQogewotCS8qIFhYWE1JUFM6IEltcGxlbWVudCBtZSAqLwotI2lmIDAKLQlf X2dyZWdfdCAqZ3IgPSB1Y3AtPnVjX21jb250ZXh0Ll9fZ3JlZ3M7Ci0JdWludHB0cl90ICpzcDsK KwltY29udGV4dF90ICptYzsKKwlyZWdpc3Rlcl90ICpzcDsKIAlpbnQgaTsKIAl2YV9saXN0IGFw OwogCi0Jdm9pZCBfX3Jlc3VtZWNvbnRleHQodm9pZCk7CisJLyoKKwkgKiBYWFgvanVsaQorCSAq IFdlIG5lZWQgYW4gbWNfbGVuIG9yIG1jX2ZsYWdzIGxpa2Ugb3RoZXIgYXJjaGl0ZWN0dXJlcwor CSAqIHNvIHRoYXQgd2UgY2FuIG1hcmsgYSBjb250ZXh0IGFzIGludmFsaWQuICBTdG9yZSBpdCBp bgorCSAqIG1jLT5tY19yZWdzW1pFUk9dIHBlcmhhcHM/CisJICovCisJaWYgKGFyZ2MgPCAwIHx8 IGFyZ2MgPiA2IHx8IHVjcCA9PSBOVUxMIHx8CisJICAgIHVjcC0+dWNfc3RhY2suc3Nfc3AgPT0g TlVMTCB8fAorCSAgICB1Y3AtPnVjX3N0YWNrLnNzX3NpemUgPCBNSU5TSUdTVEtTWikKKwkJcmV0 dXJuOworCW1jID0gJnVjcC0+dWNfbWNvbnRleHQ7CiAKLQkvKiBMSU5URUQgdWludHB0cl90IGlz IHNhZmUgKi8KLQlzcCAgPSAodWludHB0cl90ICopCisJc3AgID0gKHJlZ2lzdGVyX3QgKikKIAkg ICAgKCh1aW50cHRyX3QpdWNwLT51Y19zdGFjay5zc19zcCArIHVjcC0+dWNfc3RhY2suc3Nfc2l6 ZSk7Ci0JLyogTElOVEVEIHVpbnRwdHJfdCBpcyBzYWZlICovCisjaWYgZGVmaW5lZChfX21pcHNf bzMyKSB8fCBkZWZpbmVkKF9fbWlwc19vNjQpCiAJc3AgLT0gKGFyZ2MgPj0gNCA/IGFyZ2MgOiA0 KTsJLyogTWFrZSByb29tIGZvciA+PTQgYXJndW1lbnRzLiAqLwotCXNwICA9ICh1aW50cHRyX3Qg KikKLQkgICAgICAoKHVpbnRwdHJfdClzcCAmIH4weDcpOwkvKiBBbGlnbiBvbiBkb3VibGUtd29y ZCBib3VuZGFyeS4gKi8KKwlzcCAgPSAocmVnaXN0ZXJfdCAqKQorCSAgICAoKHVpbnRwdHJfdClz cCAmIH4weDcpOwkvKiBBbGlnbiBvbiBkb3VibGUtd29yZCBib3VuZGFyeS4gKi8KKyNlbGlmIGRl ZmluZWQoX19taXBzX24zMikgfHwgZGVmaW5lZChfX21pcHNfbjY0KQorCXNwIC09IChhcmdjID4g OCA/IGFyZ2MgLSA4IDogMCk7IC8qIE1ha2Ugcm9vbSBmb3IgPiA4IGFyZ3VtZW50cy4gKi8KKwlz cCAgPSAocmVnaXN0ZXJfdCAqKQorCSAgICAoKHVpbnRwdHJfdClzcCAmIH4weGYpOwkvKiBBbGln biBvbiBxdWFkLXdvcmQgYm91bmRhcnkuICovCisjZW5kaWYKIAotCWdyW19SRUdfU1BdICA9IChf X2dyZWdfdClzcDsKLQlncltfUkVHX1JBXSAgPSAoX19ncmVnX3QpX19yZXN1bWVjb250ZXh0Owot CWdyW19SRUdfVDldICA9IChfX2dyZWdfdClmdW5jOwkvKiByZXF1aXJlZCBmb3IgLmFiaWNhbGxz ICovCi0JZ3JbX1JFR19FUENdID0gKF9fZ3JlZ190KWZ1bmM7CisJbWMtPm1jX3JlZ3NbU1BdID0g KGludHB0cl90KXNwOworCW1jLT5tY19yZWdzW1MwXSA9IChpbnRwdHJfdCl1Y3A7CisJbWMtPm1j X3JlZ3NbVDldID0gKGludHB0cl90KWZ1bmM7CisJbWMtPm1jX3BjID0gKGludHB0cl90KV9jdHhf c3RhcnQ7CiAKIAkvKiBDb25zdHJ1Y3QgYXJndW1lbnQgbGlzdC4gKi8KIAl2YV9zdGFydChhcCwg YXJnYyk7CisjaWYgZGVmaW5lZChfX21pcHNfbzMyKSB8fCBkZWZpbmVkKF9fbWlwc19vNjQpCiAJ LyogVXAgdG8gdGhlIGZpcnN0IGZvdXIgYXJndW1lbnRzIGFyZSBwYXNzZWQgaW4gJGEwLTMuICov CiAJZm9yIChpID0gMDsgaSA8IGFyZ2MgJiYgaSA8IDQ7IGkrKykKLQkJLyogTElOVEVEIHVpbnRw dHJfdCBpcyBzYWZlICovCi0JCWdyW19SRUdfQTAgKyBpXSA9IHZhX2FyZyhhcCwgdWludHB0cl90 KTsKKwkJLyogTElOVEVEIHJlZ2lzdGVyX3QgaXMgc2FmZSAqLworCQltYy0+bWNfcmVnc1tBMCAr IGldID0gdmFfYXJnKGFwLCByZWdpc3Rlcl90KTsKIAkvKiBQYXNzIHJlbWFpbmluZyBhcmd1bWVu dHMgb24gdGhlIHN0YWNrIGFib3ZlIHRoZSAkYTAtMyBnYXAuICovCi0JZm9yIChzcCArPSA0OyBp IDwgYXJnYzsgaSsrKQorCXNwICs9IGk7CisjZW5kaWYKKyNpZiBkZWZpbmVkKF9fbWlwc19uMzIp IHx8IGRlZmluZWQoX19taXBzX242NCkKKwkvKiBVcCB0byB0aGUgZmlyc3QgOCBhcmd1bWVudHMg YXJlIHBhc3NlZCBpbiAkYTAtNy4gKi8KKwlmb3IgKGkgPSAwOyBpIDwgYXJnYyAmJiBpIDwgODsg aSsrKQorCQkvKiBMSU5URUQgcmVnaXN0ZXJfdCBpcyBzYWZlICovCisJCW1jLT5tY19yZWdzW0Ew ICsgaV0gPSB2YV9hcmcoYXAsIHJlZ2lzdGVyX3QpOworCS8qIFBhc3MgcmVtYWluaW5nIGFyZ3Vt ZW50cyBvbiB0aGUgc3RhY2sgYWJvdmUgdGhlICRhMC0zIGdhcC4gKi8KKyNlbmRpZgorCS8qIFBh c3MgcmVtYWluaW5nIGFyZ3VtZW50cyBvbiB0aGUgc3RhY2sgYWJvdmUgdGhlICRhMC0zIGdhcC4g Ki8KKwlmb3IgKDsgaSA8IGFyZ2M7IGkrKykKIAkJLyogTElOVEVEIHVpbnRwdHJfdCBpcyBzYWZl ICovCi0JCSpzcCsrID0gdmFfYXJnKGFwLCB1aW50cHRyX3QpOworCQkqc3ArKyA9IHZhX2FyZyhh cCwgcmVnaXN0ZXJfdCk7CiAJdmFfZW5kKGFwKTsKLSNlbmRpZgogfQorCit2b2lkCitfY3R4X2Rv bmUodWNvbnRleHRfdCAqdWNwKQoreworCisJaWYgKHVjcC0+dWNfbGluayA9PSBOVUxMKQorCQll eGl0KDApOworCWVsc2UgeworCQlzZXRjb250ZXh0KChjb25zdCB1Y29udGV4dF90ICopdWNwLT51 Y19saW5rKTsKKwkJYWJvcnQoKTsKKwl9Cit9CkluZGV4OiBsaWIvbGliYy9taXBzL3N5cy9NYWtl ZmlsZS5pbmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gbGliL2xpYmMvbWlwcy9zeXMvTWFrZWZpbGUuaW5jCShy ZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9taXBzL3N5cy9NYWtlZmlsZS5pbmMJKHdvcmtp bmcgY29weSkKQEAgLTEsNyArMSw3IEBACiAjICRGcmVlQlNEJAogCiBNREFTTT0gIE92Zm9yay5T IGJyay5TIGNlcnJvci5TIGV4ZWN0LlMgXAotCWZvcmsuUyBwaXBlLlMgcHRyYWNlLlMgc2Jyay5T IHNobWF0LlMgc3lzY2FsbC5TCisJZm9yay5TIHBpcGUuUyBwdHJhY2UuUyBzYnJrLlMgc3lzY2Fs bC5TCiAKICMgRG9uJ3QgZ2VuZXJhdGUgZGVmYXVsdCBjb2RlIGZvciB0aGVzZSBzeXNjYWxsczoK IE5PQVNNPQlicmVhay5vIGV4aXQubyBmdHJ1bmNhdGUubyBnZXRsb2dpbi5vIGxzZWVrLm8gbW1h cC5vIFwKSW5kZXg6IGxpYi9saWJjL01ha2VmaWxlCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGxpYi9saWJjL01h a2VmaWxlCShyZXZpc2lvbiAyMDkwNDApCisrKyBsaWIvbGliYy9NYWtlZmlsZQkod29ya2luZyBj b3B5KQpAQCAtNTEsOSArNTEsMTQgQEAKIC5pbmNsdWRlICIkey5DVVJESVJ9L3Bvc2l4MWUvTWFr ZWZpbGUuaW5jIgogLmlmICR7TUFDSElORV9BUkNIfSAhPSAiYW1kNjQiICYmIFwKICAgICAke01B Q0hJTkVfQVJDSH0gIT0gImlhNjQiICYmIFwKLSAgICAke01BQ0hJTkVfQVJDSH0gIT0gInNwYXJj NjQiCisgICAgJHtNQUNISU5FX0FSQ0h9ICE9ICJzcGFyYzY0IiAmJiBcCisgICAgJHtNQUNISU5F X0FSQ0h9ICE9ICJtaXBzIgogLmluY2x1ZGUgIiR7LkNVUkRJUn0vcXVhZC9NYWtlZmlsZS5pbmMi CiAuZW5kaWYKKy5pZiAke01BQ0hJTkVfQVJDSH0gPT0gIm1pcHMiICYmIFwKKyAgICAoIWRlZmlu ZWQoVEFSR0VUX0FCSSkgfHwgJHtUQVJHRVRfQUJJfSA9PSAibzMyIikKKy5pbmNsdWRlICIkey5D VVJESVJ9L3F1YWQvTWFrZWZpbGUuaW5jIgorLmVuZGlmCiAuaW5jbHVkZSAiJHsuQ1VSRElSfS9y ZWdleC9NYWtlZmlsZS5pbmMiCiAuaW5jbHVkZSAiJHsuQ1VSRElSfS9yZXNvbHYvTWFrZWZpbGUu aW5jIgogLmluY2x1ZGUgIiR7LkNVUkRJUn0vc3RkaW8vTWFrZWZpbGUuaW5jIgo= --e0cb4e88758397b495048911b0d9 Content-Type: text/x-patch; charset=US-ASCII; name="ld.so.patch" Content-Disposition: attachment; filename="ld.so.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gagrgebk2 SW5kZXg6IGxpYmV4ZWMvcnRsZC1lbGYvbWlwcy9ydGxkX3N0YXJ0LlMKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g bGliZXhlYy9ydGxkLWVsZi9taXBzL3J0bGRfc3RhcnQuUwkocmV2aXNpb24gMjA5MTkzKQorKysg bGliZXhlYy9ydGxkLWVsZi9taXBzL3J0bGRfc3RhcnQuUwkod29ya2luZyBjb3B5KQpAQCAtNjgs NyArNjgsOCBAQAogCW1vdmUJYTAsIHMwCQkJLyogc3AgKi8KIAlQVFJfQUREVSBhMSwgc3AsIDIq UFRSX1NJWkUJLyogJm91ciBhdGV4aXQgZnVuY3Rpb24gKi8KIAlQVFJfQUREVSBhMiwgc3AsIDMq UFRSX1NJWkUJLyogb2JqX21haW4gZW50cnkgKi8KLQlqYWwJX0NfTEFCRUwoX3J0bGQpCQkvKiB2 MCA9IF9ydGxkKHNwLCBjbGVhbnVwLCBvYmpwKSAqLworCVBUUl9MQQl0OSwgX0NfTEFCRUwoX3J0 bGQpCisJamFscgl0OQkJCS8qIHYwID0gX3J0bGQoc3AsIGNsZWFudXAsIG9ianApICovCiAJIG5v cAogCiAJUFRSX0wJYTEsIDIqUFRSX1NJWkUoc3ApCS8qIG91ciBhdGV4aXQgZnVuY3Rpb24gKi8K QEAgLTEyMyw3ICsxMjQsNyBAQAogCW1vdmUJczAsIHNwCiAKIAltb3ZlCWEwLCB2MQkJCS8qIG9s ZCBHUCAqLwotCXN1YnUJYTAsIGEwLCAweDdmZjAJCS8qIFRoZSBvZmZzZXQgb2YgJGdwIGZyb20g dGhlCSovCisJUFRSX1NVQlUJYTAsIGEwLCAweDdmZjAJCS8qIFRoZSBvZmZzZXQgb2YgJGdwIGZy b20gdGhlCSovCiAgICAgICAgCQkJCQkvKiBiZWdpbm5pbmcgb2YgdGhlIC5nb3Qgc2VjdGlvbjog Ki8KIAkJCQkJLyogJGdwID0gLmdvdCArIDB4N2ZmMCwgc28JKi8KIAkJCQkJLyogLmdvdCA9ICRn cCAtIDB4N2ZmMAkJKi8KQEAgLTEzNiw3ICsxMzcsOCBAQAogCWFuZAlhMCwgYTAsIDB4N2ZmZmZm ZmYKIAltb3ZlCWExLCB0OAkJCS8qIHN5bWJvbCBpbmRleCAqLwogCi0JamFsCV9DX0xBQkVMKF9t aXBzX3J0bGRfYmluZCkKKwlQVFJfTEEJdDksIF9DX0xBQkVMKF9taXBzX3J0bGRfYmluZCkKKwlq YWxyCXQ5CiAJIG5vcAogCiAJbW92ZQlzcCwgczAK --e0cb4e88758397b495048911b0d9 Content-Type: text/x-patch; charset=US-ASCII; name="tlb-to-c.patch" Content-Disposition: attachment; filename="tlb-to-c.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gagrgmb13 SW5kZXg6IHN5cy9jb25mL2ZpbGVzLm1pcHMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL2NvbmYvZmlsZXMu bWlwcwkocmV2aXNpb24gMjA5MTkzKQorKysgc3lzL2NvbmYvZmlsZXMubWlwcwkod29ya2luZyBj b3B5KQpAQCAtNDQsNyArNDQsNyBAQAogbWlwcy9taXBzL2ZwLlMJCQlzdGFuZGFyZAogbWlwcy9t aXBzL3BtX21hY2hkZXAuYwkJc3RhbmRhcmQKIG1pcHMvbWlwcy9zd3RjaC5TCQlzdGFuZGFyZAot bWlwcy9taXBzL3RsYi5TCQkJc3RhbmRhcmQKK21pcHMvbWlwcy90bGIuYwkJCXN0YW5kYXJkCiAK IG1pcHMvbWlwcy9idXNfc3BhY2VfZ2VuZXJpYy5jIAlzdGFuZGFyZAogbWlwcy9taXBzL2J1c2Rt YV9tYWNoZGVwLmMgCXN0YW5kYXJkCkluZGV4OiBzeXMvbWlwcy9pbmNsdWRlL3RsYi5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHN5cy9taXBzL2luY2x1ZGUvdGxiLmgJKHJldmlzaW9uIDApCisrKyBzeXMvbWlw cy9pbmNsdWRlL3RsYi5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM5IEBACisvKi0KKyAqIENv cHlyaWdodCAoYykgMjAwNC0yMDEwIEp1bGkgTWFsbGV0dCA8am1hbGxldHRARnJlZUJTRC5vcmc+ CisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgVEhFIEFVVEhPUiBBTkQgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQK KyAqIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UKKyAqIEFSRSBESVNDTEFJTUVE LiAgSU4gTk8gRVZFTlQgU0hBTEwgVEhFIEFVVEhPUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxF CisgKiBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTAorICogREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMKKyAqIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KQorICogSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QKKyAqIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkKKyAqIE9VVCBPRiBU SEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YKKyAqIFNVQ0ggREFNQUdFLgorICoKKyAqICRGcmVlQlNEJAorICovCisKKyNpZm5kZWYJ X01BQ0hJTkVfVExCX0hfCisjZGVmaW5lCV9NQUNISU5FX1RMQl9IXworCit2b2lkIHRsYl9pbnNl cnRfd2lyZWQodW5zaWduZWQsIHZtX29mZnNldF90LCBwdF9lbnRyeV90LCBwdF9lbnRyeV90KTsK K3ZvaWQgdGxiX2ludmFsaWRhdGVfYWRkcmVzcyhzdHJ1Y3QgcG1hcCAqLCB2bV9vZmZzZXRfdCk7 Cit2b2lkIHRsYl9pbnZhbGlkYXRlX2FsbCh2b2lkKTsKK3ZvaWQgdGxiX2ludmFsaWRhdGVfYWxs X3VzZXIoc3RydWN0IHBtYXAgKik7Cit2b2lkIHRsYl9zYXZlKHZvaWQpOwordm9pZCB0bGJfdXBk YXRlKHN0cnVjdCBwbWFwICosIHZtX29mZnNldF90LCBwdF9lbnRyeV90KTsKKworI2VuZGlmIC8q ICFfTUFDSElORV9UTEJfSF8gKi8KSW5kZXg6IHN5cy9taXBzL2luY2x1ZGUvY3B1LmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gc3lzL21pcHMvaW5jbHVkZS9jcHUuaAkocmV2aXNpb24gMjA5MTkzKQorKysgc3lz L21pcHMvaW5jbHVkZS9jcHUuaAkod29ya2luZyBjb3B5KQpAQCAtMjc0LDI3ICsyNzQsNiBAQAog I2RlZmluZQlPUENPREVfQzEJCTB4MTEKIAogLyoKLSAqIFRoZSBsb3cgcGFydCBvZiB0aGUgVExC IGVudHJ5LgotICovCi0jZGVmaW5lCVZNVExCX1BGX05VTQkJMHgzZmZmZmZjMAotI2RlZmluZQlW TVRMQl9BVFRSX01BU0sJCTB4MDAwMDAwMzgKLSNkZWZpbmUJVk1UTEJfTU9EX0JJVAkJMHgwMDAw MDAwNAotI2RlZmluZQlWTVRMQl9WQUxJRF9CSVQJCTB4MDAwMDAwMDIKLSNkZWZpbmUJVk1UTEJf R0xPQkFMX0JJVAkweDAwMDAwMDAxCi0KLSNkZWZpbmUJVk1UTEJfUEhZU19QQUdFX1NISUZUCTYK LQotLyoKLSAqIFRoZSBoaWdoIHBhcnQgb2YgdGhlIFRMQiBlbnRyeS4KLSAqLwotI2RlZmluZQlW TVRMQl9WSVJUX1BBR0VfTlVNCQkweGZmZmZlMDAwCi0jZGVmaW5lCVZNVExCX1BJRAkJCTB4MDAw MDAwZmYKLSNkZWZpbmUJVk1UTEJfUElEX1I5SwkJCTB4MDAwMDBmZmYKLSNkZWZpbmUJVk1UTEJf UElEX1NISUZUCQkJMAotI2RlZmluZQlWTVRMQl9WSVJUX1BBR0VfU0hJRlQJCTEyCi0jZGVmaW5l CVZNVExCX1ZJUlRfUEFHRV9TSElGVF9SOUsJMTMKLQotLyoKICAqIFRoZSBmaXJzdCBUTEIgZW50 cnkgdGhhdCB3cml0ZSByYW5kb20gaGl0cy4KICAqIFRMQiBlbnRyeSAwIG1hcHMgdGhlIGtlcm5l bCBzdGFjayBvZiB0aGUgY3VycmVudGx5IHJ1bm5pbmcgdGhyZWFkCiAgKiBUTEIgZW50cnkgMSBt YXBzIHRoZSBwY3B1IGFyZWEgb2YgcHJvY2Vzc29yIChvbmx5IGZvciBTTVAgYnVpbGRzKQpAQCAt MzEzLDE0ICsyOTIsNiBAQAogI2RlZmluZQlWTU5VTV9QSURTCQkyNTYKIAogLyoKLSAqIFRMQiBw cm9iZSByZXR1cm4gY29kZXMuCi0gKi8KLSNkZWZpbmUJVk1UTEJfTk9UX0ZPVU5ECQkwCi0jZGVm aW5lCVZNVExCX0ZPVU5ECQkxCi0jZGVmaW5lCVZNVExCX0ZPVU5EX1dJVEhfUEFUQ0gJMgotI2Rl ZmluZQlWTVRMQl9QUk9CRV9FUlJPUgkzCi0KLS8qCiAgKiBFeHBvcnRlZCBkZWZpbml0aW9ucyB1 bmlxdWUgdG8gbWlwcyBjcHUgc3VwcG9ydC4KICAqLwogCkBAIC0zMzUsNiArMzA2LDcgQEAKICNp Zm5kZWYgX0xPQ09SRQogI2luY2x1ZGUgPG1hY2hpbmUvY3B1ZnVuYy5oPgogI2luY2x1ZGUgPG1h Y2hpbmUvZnJhbWUuaD4KKwogLyoKICAqIEFyZ3VtZW50cyB0byBoYXJkY2xvY2sgYW5kIGdhdGhl cnN0YXRzIGVuY2Fwc3VsYXRlIHRoZSBwcmV2aW91cwogICogbWFjaGluZSBzdGF0ZSBpbiBhbiBv cGFxdWUgY2xvY2tmcmFtZS4KQEAgLTQ1NSwxMiArNDI3LDkgQEAKICNpZiBkZWZpbmVkKF9LRVJO RUwpICYmICFkZWZpbmVkKF9MT0NPUkUpCiBleHRlcm4gdW5pb24gY3B1cHJpZCBmcHVfaWQ7CiAK LXN0cnVjdCB0bGI7CiBzdHJ1Y3QgdXNlcjsKIAogaW50IE1pcHNfQ29uZmlnQ2FjaGUodm9pZCk7 Ci12b2lkIE1pcHNfU2V0V0lSRUQoaW50KTsKLXZvaWQgTWlwc19TZXRQSUQoaW50KTsKIAogdm9p ZCBNaXBzX1N5bmNDYWNoZSh2b2lkKTsKIHZvaWQgTWlwc19TeW5jRENhY2hlKHZtX29mZnNldF90 LCBpbnQpOwpAQCAtNDcxLDEyICs0NDAsNiBAQAogdm9pZCBNaXBzX1N5bmNJQ2FjaGUodm1fb2Zm c2V0X3QsIGludCk7CiB2b2lkIE1pcHNfSW52YWxpZGF0ZUlDYWNoZSh2bV9vZmZzZXRfdCwgaW50 KTsKIAotdm9pZCBNaXBzX1RMQkZsdXNoKGludCk7Ci12b2lkIE1pcHNfVExCRmx1c2hBZGRyKHZt X29mZnNldF90KTsKLXZvaWQgTWlwc19UTEJXcml0ZUluZGV4ZWQoaW50LCBzdHJ1Y3QgdGxiICop Owotdm9pZCBNaXBzX1RMQlVwZGF0ZSh2bV9vZmZzZXRfdCwgdW5zaWduZWQpOwotdm9pZCBNaXBz X1RMQlJlYWQoaW50LCBzdHJ1Y3QgdGxiICopOwotdm9pZCBtaXBzX1RCSUFQKGludCk7CiB2b2lk IHdiZmx1c2godm9pZCk7CiAKIGV4dGVybiB1X2ludDMyX3QgY3B1X2NvdW50ZXJfaW50ZXJ2YWw7 CS8qIE51bWJlciBvZiBjb3VudGVyIHRpY2tzL3RpY2sgKi8KQEAgLTUxNiwxNiArNDc5LDYgQEAK IAkJCTogInIiIChmdW5jKSwgInIiIChhcmcwKSwgInIiIChhcmcxKSwgInIiIChhcmcyKSAgLyog aW5wdXRzICovIFwKIAkJCTogIiQzMSIsICIkNCIsICIkNSIsICIkNiIpOwogCi0jZGVmaW5lCU1h Y2hTZXRQSUQJCQlNaXBzX1NldFBJRAotI2RlZmluZQlNYWNoVExCVXBkYXRlICAgCQlNaXBzX1RM QlVwZGF0ZQotI2RlZmluZQltaXBzX1RCSVMJCQlNaXBzX1RMQkZsdXNoQWRkcgotI2RlZmluZQlN SVBTX1RCSUFQKCkJCQltaXBzX1RCSUFQKG51bV90bGJlbnRyaWVzKQotI2RlZmluZQlNYWNoU2V0 V0lSRUQoaW5kZXgpCQlNaXBzX1NldFdJUkVEKGluZGV4KQotI2RlZmluZQlNYWNoVExCRmx1c2go Y291bnQpCQlNaXBzX1RMQkZsdXNoKGNvdW50KQotI2RlZmluZQlNYWNoVExCR2V0UElEKHBpZCkJ CShwaWQgPSBNaXBzX1RMQkdldFBJRCgpKQotI2RlZmluZQlNYWNoVExCUmVhZCh0bGJubywgdGxi cCkJTWlwc19UTEJSZWFkKHRsYm5vLCB0bGJwKQotI2RlZmluZQlNYWNoRlBUcmFwKHNyLCBjYXVz ZSwgcGMpCU1pcHNGUFRyYXAoc3IsIGNhdXNlLCBwYykKLQogLyoKICAqIEVuYWJsZSByZWFsdGlt ZSBjbG9jayAoYWx3YXlzIGVuYWJsZWQpLgogICovCkBAIC01NDIsOCArNDk1LDYgQEAKICAqICBM b3cgbGV2ZWwgYWNjZXNzIHJvdXRpbmVzIHRvIENQVSByZWdpc3RlcnMKICAqLwogCi1pbnQgTWlw c19UTEJHZXRQSUQodm9pZCk7Ci0KIHZvaWQgc3dpX3ZtKHZvaWQgKik7CiB2b2lkIGNwdV9oYWx0 KHZvaWQpOwogdm9pZCBjcHVfcmVzZXQodm9pZCk7CkluZGV4OiBzeXMvbWlwcy9pbmNsdWRlL3B0 ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIHN5cy9taXBzL2luY2x1ZGUvcHRlLmgJKHJldmlzaW9uIDIwOTE5 MykKKysrIHN5cy9taXBzL2luY2x1ZGUvcHRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEsMTQgKzEs NyBAQAotLyoJJE9wZW5CU0Q6IHB0ZS5oLHYgMS40IDE5OTgvMDEvMjggMTM6NDY6MjUgcGVmbyBF eHAgJAkqLwotCiAvKi0KLSAqIENvcHlyaWdodCAoYykgMTk4OCBVbml2ZXJzaXR5IG9mIFV0YWgu Ci0gKiBDb3B5cmlnaHQgKGMpIDE5OTIsIDE5OTMKLSAqCVRoZSBSZWdlbnRzIG9mIHRoZSBVbml2 ZXJzaXR5IG9mIENhbGlmb3JuaWEuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQ29weXJpZ2h0 IChjKSAyMDA0LTIwMTAgSnVsaSBNYWxsZXR0IDxqbWFsbGV0dEBGcmVlQlNELm9yZz4KKyAqIEFs bCByaWdodHMgcmVzZXJ2ZWQuCiAgKgotICogVGhpcyBjb2RlIGlzIGRlcml2ZWQgZnJvbSBzb2Z0 d2FyZSBjb250cmlidXRlZCB0byBCZXJrZWxleSBieQotICogdGhlIFN5c3RlbXMgUHJvZ3JhbW1p bmcgR3JvdXAgb2YgdGhlIFVuaXZlcnNpdHkgb2YgVXRhaCBDb21wdXRlcgotICogU2NpZW5jZSBE ZXBhcnRtZW50IGFuZCBSYWxwaCBDYW1wYmVsbC4KLSAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucwogICogYXJlIG1ldDoKQEAgLTE3LDE4ICsxMCwxMSBAQAogICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKICAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKICAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKiAzLiBBbGwgYWR2ZXJ0aXNpbmcg bWF0ZXJpYWxzIG1lbnRpb25pbmcgZmVhdHVyZXMgb3IgdXNlIG9mIHRoaXMgc29mdHdhcmUKLSAq ICAgIG11c3QgZGlzcGxheSB0aGUgZm9sbG93aW5nIGFja25vd2xlZGdlbWVudDoKLSAqCVRoaXMg cHJvZHVjdCBpbmNsdWRlcyBzb2Z0d2FyZSBkZXZlbG9wZWQgYnkgdGhlIFVuaXZlcnNpdHkgb2YK LSAqCUNhbGlmb3JuaWEsIEJlcmtlbGV5IGFuZCBpdHMgY29udHJpYnV0b3JzLgotICogNC4gTmVp dGhlciB0aGUgbmFtZSBvZiB0aGUgVW5pdmVyc2l0eSBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250 cmlidXRvcnMKLSAqICAgIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0 cyBkZXJpdmVkIGZyb20gdGhpcyBzb2Z0d2FyZQotICogICAgd2l0aG91dCBzcGVjaWZpYyBwcmlv ciB3cml0dGVuIHBlcm1pc3Npb24uCiAgKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgUkVHRU5UUyBBTkQgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIEFVVEhPUiBBTkQgQ09OVFJJQlVUT1JTIGBgQVMgSVMn JyBBTkQKICAqIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFRIRQogICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UKLSAqIEFSRSBESVND TEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgVEhFIFJFR0VOVFMgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRQorICogQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQVVUSE9S IE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUKICAqIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCiAgKiBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUwogICogT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRT OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pCkBAIC0zNyw2MCArMjMsNjYgQEAKICAqIE9VVCBP RiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YKICAqIFNVQ0ggREFNQUdFLgogICoKLSAqCWZyb206IFV0YWggSGRyOiBwdGUuaCAx LjExIDg5LzA5LzAzCi0gKglmcm9tOiBAKCMpcHRlLmggOC4xIChCZXJrZWxleSkgNi8xMC85Mwot ICoJSk5QUjogcHRlLmgsdiAxLjEuNC4xIDIwMDcvMDkvMTAgMDY6MjA6MTkgZ2lyaXNoCiAgKiAk RnJlZUJTRCQKICAqLwogCi0jaWZuZGVmIF9NQUNISU5FX1BURV9IXworI2lmbmRlZglfTUFDSElO RV9QVEVfSF8KICNkZWZpbmUJX01BQ0hJTkVfUFRFX0hfCiAKLSNpbmNsdWRlIDxtYWNoaW5lL2Vu ZGlhbi5oPgorLyoKKyAqIFRMQiBhbmQgUFRFIG1hbmFnZW1lbnQuICBNb3N0IHRoaW5ncyBvcGVy YXRlIHdpdGhpbiB0aGUgY29udGV4dCBvZgorICogRW50cnlMbzAsMSwgYW5kIGJlZ2luIHdpdGgg VExCTE9fLiAgVGhpbmdzIHdoaWNoIHdvcmsgd2l0aCBFbnRyeUhpCisgKiBzdGFydCB3aXRoIFRM QkhJXy4gIFBURSBiaXRzIGJlZ2luIHdpdGggUEdfLgorICoKKyAqIE5vdGUgdGhhdCB3ZSB1c2Ug dGhlIHNhbWUgc2l6ZSBWTSBhbmQgVExCIHBhZ2VzLgorICovCisjZGVmaW5lCVRMQl9QQUdFX1NI SUZUCShQQUdFX1NISUZUKQorI2RlZmluZQlUTEJfUEFHRV9TSVpFCSgxIDw8IFRMQl9QQUdFX1NI SUZUKQorI2RlZmluZQlUTEJfUEFHRV9NQVNLCShUTEJfUEFHRV9TSVpFIC0gMSkKIAogLyoKLSAq IE1JUFMgaGFyZHdhcmUgcGFnZSB0YWJsZSBlbnRyeQorICogVExCIFBhZ2VNYXNrIHJlZ2lzdGVy LiAgSGFzIG1hc2sgYml0cyBzZXQgYWJvdmUgdGhlIGRlZmF1bHQsIDRLLCBwYWdlIG1hc2suCiAg Ki8KKyNkZWZpbmUJVExCTUFTS19TSElGVAkoMTMpCisjZGVmaW5lCVRMQk1BU0tfTUFTSwkoKFBB R0VfTUFTSyA+PiBUTEJNQVNLX1NISUZUKSA8PCBUTEJNQVNLX1NISUZUKQogCi0jaWZuZGVmIF9M T0NPUkUKLXN0cnVjdCBwdGUgewotI2lmIEJZVEVfT1JERVIgPT0gQklHX0VORElBTgotdW5zaWdu ZWQgaW50CXBnX3Byb3Q6MiwJCS8qIFNXOiBhY2Nlc3MgY29udHJvbCAqLwotCQlwZ19wZm51bToy NCwJCS8qIEhXOiBjb3JlIHBhZ2UgZnJhbWUgbnVtYmVyIG9yIDAgKi8KLQkJcGdfYXR0cjozLAkJ LyogSFc6IGNhY2hlIGF0dHJpYnV0ZSAqLwotCQlwZ19tOjEsCQkJLyogSFc6IG1vZGlmaWVkIChk aXJ0eSkgYml0ICovCi0JCXBnX3Y6MSwJCQkvKiBIVzogdmFsaWQgYml0ICovCi0JCXBnX2c6MTsJ CQkvKiBIVzogaWdub3JlIHBpZCBiaXQgKi8KLSNlbmRpZgotI2lmIEJZVEVfT1JERVIgPT0gTElU VExFX0VORElBTgotdW5zaWduZWQgaW50CXBnX2c6MSwJCQkvKiBIVzogaWdub3JlIHBpZCBiaXQg Ki8KLQkJcGdfdjoxLAkJCS8qIEhXOiB2YWxpZCBiaXQgKi8KLQkJcGdfbToxLAkJCS8qIEhXOiBt b2RpZmllZCAoZGlydHkpIGJpdCAqLwotCQlwZ19hdHRyOjMsCQkvKiBIVzogY2FjaGUgYXR0cmli dXRlICovCi0JCXBnX3BmbnVtOjI0LAkJLyogSFc6IGNvcmUgcGFnZSBmcmFtZSBudW1iZXIgb3Ig MCAqLwotCQlwZ19wcm90OjI7CQkvKiBTVzogYWNjZXNzIGNvbnRyb2wgKi8KLSNlbmRpZgotfTsK LQogLyoKLSAqIFN0cnVjdHVyZSBkZWZpbmluZyBhbiB0bGIgZW50cnkgZGF0YSBzZXQuCisgKiBQ Rk4gZm9yIEVudHJ5TG8gcmVnaXN0ZXIuICBVcHBlciBiaXRzIGFyZSAwLCB3aGljaCBpcyB0byBz YXkgdGhhdAorICogYml0IDI5IGlzIHRoZSBsYXN0IGhhcmR3YXJlIGJpdDsgIEJpdHMgMzAgYW5k IHVwd2FyZHMgKEVudHJ5TG8gaXMKKyAqIDY0IGJpdCB0aG91Z2ggaXQgY2FuIGJlIHJlZmVycmVk IHRvIGluIDMyLWJpdHMgcHJvdmlkaW5nIDIgc29mdHdhcmUKKyAqIGJpdHMgc2FmZWx5LiAgV2Ug dXNlIGl0IGFzIDY0IGJpdHMgdG8gZ2V0IG1hbnkgc29mdHdhcmUgYml0cywgYW5kCisgKiBnb2Qg a25vd3Mgd2hhdCBlbHNlLikgYXJlIHVuYWNrbm93bGVkZ2VkIGJ5IGhhcmR3YXJlLiAgVGhleSBt YXkgYmUKKyAqIHdyaXR0ZW4gYXMgYW55dGhpbmcsIGJ1dCBvdGhlcndpc2UgdGhleSBoYXZlIGFz IG11Y2ggbWVhbmluZyBhcworICogb3RoZXIgMCBmaWVsZHMuCiAgKi8KKyNkZWZpbmUJVExCTE9f U1dCSVRTX1NISUZUCSgzMCkKKyNkZWZpbmUJVExCTE9fU1dCSVRTX01BU0sJKDB4M1UgPDwgVExC TE9fU1dCSVRTX1NISUZUKQorI2RlZmluZQlUTEJMT19QRk5fU0hJRlQJCSg2KQorI2RlZmluZQlU TEJMT19QRk5fTUFTSwkJKDB4M0ZGRkZGQzApCisjZGVmaW5lCVRMQkxPX1BBX1RPX1BGTihwYSkJ KCgoKHBhKSA+PiBUTEJfUEFHRV9TSElGVCkgPDwgVExCTE9fUEZOX1NISUZUKSAmIFRMQkxPX1BG Tl9NQVNLKQorI2RlZmluZQlUTEJMT19QRk5fVE9fUEEocGZuKQkoKHZtX3BhZGRyX3QpKChwZm4p ID4+IFRMQkxPX1BGTl9TSElGVCkgPDwgVExCX1BBR0VfU0hJRlQpCisjZGVmaW5lCVRMQkxPX1BU RV9UT19QRk4ocHRlKQkoKHB0ZSkgJiBUTEJMT19QRk5fTUFTSykKKyNkZWZpbmUJVExCTE9fUFRF X1RPX1BBKHB0ZSkJKFRMQkxPX1BGTl9UT19QQShUTEJMT19QVEVfVE9fUEZOKChwdGUpKSkpCisg IAorLyoKKyAqIFZQTiBmb3IgRW50cnlIaSByZWdpc3Rlci4gIFVwcGVyIHR3byBiaXRzIHNlbGVj dCB1c2VyLCBzdXBlcnZpc29yLAorICogb3Iga2VybmVsLiAgQml0cyA2MSB0byA0MCBjb3B5IGJp dCA2My4gIFZQTjIgaXMgYml0cyAzOSBhbmQgZG93biB0bworICogYXMgbG93IGFzIDEzLCBkb3du IHRvIFBBR0VfU0hJRlQsIHRvIGluZGV4IDIgVExCIHBhZ2VzKi4gIEZyb20gYml0IDEyCisgKiB0 byBiaXQgOCB0aGVyZSBpcyBhIDUtYml0IDAgZmllbGQuICBMb3cgYnl0ZSBpcyBBU0lELgorICoK KyAqIE5vdGUgdGhhdCBpbiBGcmVlQlNELCB3ZSBtYXAgMiBUTEIgcGFnZXMgaXMgZXF1YWwgdG8g MSBWTSBwYWdlLgorICovCisjZGVmaW5lCVRMQkhJX0FTSURfTUFTSwkJKDB4ZmYpCisjZGVmaW5l CVRMQkhJX0VOVFJZKHZhLCBhc2lkKQkoKCh2YSkgJiB+UEFHRV9NQVNLKSB8ICgoYXNpZCkgJiBU TEJISV9BU0lEX01BU0spKQogCi1zdHJ1Y3QgdGxiIHsKLQlpbnQJdGxiX21hc2s7Ci0JaW50CXRs Yl9oaTsKLQlpbnQJdGxiX2xvMDsKLQlpbnQJdGxiX2xvMTsKLX07Ci0KKyNpZm5kZWYgX0xPQ09S RQogdHlwZWRlZiB1bnNpZ25lZCBpbnQgcHRfZW50cnlfdDsKIHR5cGVkZWYgcHRfZW50cnlfdCAq cGRfZW50cnlfdDsKKyNlbmRpZgogCiAjZGVmaW5lCVBERVNJWkUJCXNpemVvZihwZF9lbnRyeV90 KQkvKiBmb3IgYXNzZW1ibHkgZmlsZXMgKi8KICNkZWZpbmUJUFRFU0laRQkJc2l6ZW9mKHB0X2Vu dHJ5X3QpCS8qIGZvciBhc3NlbWJseSBmaWxlcyAqLwogCi0jZW5kaWYgLyogX0xPQ09SRSAqLwot CiAjZGVmaW5lCVBUX0VOVFJZX05VTEwJKChwdF9lbnRyeV90ICopIDApCiAKICNkZWZpbmUJUFRF X1dJUkVECTB4ODAwMDAwMDAJLyogU1cgKi8KQEAgLTExOSwxMSArMTExLDYgQEAKICNkZWZpbmUg UFRFX0hWUE4gICAgICAgIDB4ZmZmZmUwMDAgICAgICAvKiBIYXJkd2FyZSBwYWdlIG5vIG1hc2sg Ki8KICNkZWZpbmUgUFRFX0FTSUQgICAgICAgIDB4MDAwMDAwZmYgICAgICAvKiBBZGRyZXNzIHNw YWNlIElEICovCiAKLSNkZWZpbmUJUFRFX1NISUZUCTYKLSNkZWZpbmUJcGZuX2lzX2V4dCh4KQko KHgpICYgMHgzYzAwMDAwMCkKLSNkZWZpbmUJdmFkX3RvX3Bmbih4KQkoKCh1bnNpZ25lZCkoeCkg Pj4gUFRFX1NISUZUKSAmIFBURV9GUkFNRSkKLSNkZWZpbmUJdmFkX3RvX3BmbjY0KHgpCSgocXVh ZF90KSh4KSA+PiBQVEVfU0hJRlQpICYgUFRFX0ZSQU1FKQotI2RlZmluZQlwZm5fdG9fdmFkKHgp CSgoKHgpICYgUFRFX0ZSQU1FKSA8PCBQVEVfU0hJRlQpCiAKIC8qIFVzZXIgdmlydHVhbCB0byBw dGUgb2Zmc2V0IGluIHBhZ2UgdGFibGUgKi8KICNkZWZpbmUJdmFkX3RvX3B0ZV9vZmZzZXQoYWRy KQkoKChhZHIpID4+IFBBR0VfU0hJRlQpICYgKE5QVEVQRyAtMSkpCkBAIC0xMzgsMTYgKzEyNSw1 IEBACiAjZGVmaW5lCW1pcHNfcGdfY3dwYWdlX2JpdCgpCShQVEVfQ1dQQUdFKQogI2RlZmluZQlt aXBzX3BnX2dsb2JhbF9iaXQoKQkoUFRFX0cpCiAjZGVmaW5lCW1pcHNfcGdfd2lyZWRfYml0KCkJ KFBURV9XSVJFRCkKLSNkZWZpbmUJbWlwc190bGJwZm5fdG9fcGFkZHIoeCkJcGZuX3RvX3ZhZCgo eCkpCi0jZGVmaW5lCW1pcHNfcGFkZHJfdG9fdGxicGZuKHgpCXZhZF90b19wZm4oKHgpKQogCi0v KiBUaGVzZSBhcmUgbm90IHVzZWQgKi8KLSNkZWZpbmUJUFRFX1NJWkVfNEsJMHgwMDAwMDAwMAot I2RlZmluZQlQVEVfU0laRV8xNksJMHgwMDAwNjAwMAotI2RlZmluZQlQVEVfU0laRV82NEsJMHgw MDAxZTAwMAotI2RlZmluZQlQVEVfU0laRV8yNTZLCTB4MDAwN2UwMDAKLSNkZWZpbmUJUFRFX1NJ WkVfMU0JMHgwMDFmZTAwMAotI2RlZmluZQlQVEVfU0laRV80TQkweDAwN2ZlMDAwCi0jZGVmaW5l CVBURV9TSVpFXzE2TQkweDAxZmZlMDAwCi0KLSNlbmRpZgkvKiAhX01BQ0hJTkVfUFRFX0hfICov CisjZW5kaWYgLyogIV9NQUNISU5FX1BURV9IXyAqLwpJbmRleDogc3lzL21pcHMvaW5jbHVkZS9w bWFwLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMvaW5jbHVkZS9wbWFwLmgJKHJldmlzaW9uIDIw OTE5MykKKysrIHN5cy9taXBzL2luY2x1ZGUvcG1hcC5oCSh3b3JraW5nIGNvcHkpCkBAIC00OSwx NSArNDksNyBAQAogI2luY2x1ZGUgPG1hY2hpbmUvdm1wYXJhbS5oPgogI2luY2x1ZGUgPG1hY2hp bmUvcHRlLmg+CiAKLSNkZWZpbmUJVkFERFIocGRpLCBwdGkpCSgodm1fb2Zmc2V0X3QpKCgocGRp KTw8UERSU0hJRlQpfCgocHRpKTw8UEFHRV9TSElGVCkpKQotCiAjZGVmaW5lCU5LUFQJCTEyMAkv KiBhY3R1YWwgbnVtYmVyIG9mIGtlcm5lbCBwYWdlIHRhYmxlcyAqLwotCi0jaWZuZGVmIE5LUERF Ci0jZGVmaW5lCU5LUERFCQkyNTUJLyogYWRkcmVzc2FibGUgbnVtYmVyIG9mIHBhZ2UgdGFibGVz L3BkZSdzICovCi0jZW5kaWYKLQotI2RlZmluZQlLUFRESQkJKFZNX01JTl9LRVJORUxfQUREUkVT UyA+PiBTRUdTSElGVCkKICNkZWZpbmUJTlVTRVJQR1RCTFMJKFZNX01BWFVTRVJfQUREUkVTUyA+ PiBTRUdTSElGVCkKIAogI2lmbmRlZiBMT0NPUkUKQEAgLTEwOSw2ICsxMDEsNyBAQAogdm1fb2Zm c2V0X3QgcG1hcF9rZXh0cmFjdCh2bV9vZmZzZXRfdCB2YSk7CiAKICNkZWZpbmUJdnRvcGh5cyh2 YSkJcG1hcF9rZXh0cmFjdCgoKHZtX29mZnNldF90KSAodmEpKSkKKyNkZWZpbmUJcG1hcF9hc2lk KHBtYXApCShwbWFwKS0+cG1fYXNpZFtQQ1BVX0dFVChjcHVpZCldLmFzaWQKIAogZXh0ZXJuIHN0 cnVjdCBwbWFwCWtlcm5lbF9wbWFwX3N0b3JlOwogI2RlZmluZSBrZXJuZWxfcG1hcAkoJmtlcm5l bF9wbWFwX3N0b3JlKQpAQCAtMTIyLDkgKzExNSw4IEBACiAjZGVmaW5lCVBNQVBfTVRYKHBtYXAp CQkoJihwbWFwKS0+cG1fbXR4KQogI2RlZmluZQlQTUFQX1RSWUxPQ0socG1hcCkJbXR4X3RyeWxv Y2soJihwbWFwKS0+cG1fbXR4KQogI2RlZmluZQlQTUFQX1VOTE9DSyhwbWFwKQltdHhfdW5sb2Nr KCYocG1hcCktPnBtX210eCkKLQogI2RlZmluZSBQTUFQX0xHTUVNX0xPQ0tfSU5JVChzeXNtYXAp IG10eF9pbml0KCYoc3lzbWFwKS0+bG9jaywgInBtYXAtbGdtZW0iLCBcCi0JCQkJICAgICJwZXIt Y3B1LW1hcCIsIChNVFhfREVGfCBNVFhfRFVQT0spKQorCQkJICAgICAicGVyLWNwdS1tYXAiLCAo TVRYX0RFRnwgTVRYX0RVUE9LKSkKICNkZWZpbmUgUE1BUF9MR01FTV9MT0NLKHN5c21hcCkgbXR4 X2xvY2soJihzeXNtYXApLT5sb2NrKQogI2RlZmluZSBQTUFQX0xHTUVNX1VOTE9DSyhzeXNtYXAp IG10eF91bmxvY2soJihzeXNtYXApLT5sb2NrKQogI2RlZmluZSBQTUFQX0xHTUVNX0RFU1RST1ko c3lzbWFwKSBtdHhfZGVzdHJveSgmKHN5c21hcCktPmxvY2spCkBAIC0xODMsMTEgKzE3NSw2IEBA CiB2b2lkIHBtYXBfdXBkYXRlX3BhZ2UocG1hcF90IHBtYXAsIHZtX29mZnNldF90IHZhLCBwdF9l bnRyeV90IHB0ZSk7CiB2b2lkIHBtYXBfZmx1c2hfcHZjYWNoZSh2bV9wYWdlX3QgbSk7CiAKLS8q Ci0gKiBGdW5jdGlvbiB0byBzYXZlIFRMQiBjb250ZW50cyBzbyB0aGF0IHRoZXkgbWF5IGJlIGlu c3BlY3RlZCBpbiB0aGUgZGVidWdnZXIuCi0gKi8KLWV4dGVybiB2b2lkIHBtYXBfc2F2ZV90bGIo dm9pZCk7Ci0KICNlbmRpZgkJCQkvKiBfS0VSTkVMICovCiAKICNlbmRpZgkJCQkvKiAhTE9DT1JF ICovCkluZGV4OiBzeXMvbWlwcy9taXBzL3RsYi5jCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9taXBzL21p cHMvdGxiLmMJKHJldmlzaW9uIDApCisrKyBzeXMvbWlwcy9taXBzL3RsYi5jCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDMxMSBAQAorLyotCisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMCBKdWxp IE1hbGxldHQgPGptYWxsZXR0QEZyZWVCU0Qub3JnPgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBBVVRIT1Ig QU5EIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5ECisgKiBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFCisgKiBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBB VVRIT1IgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRQorICogRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwKKyAq IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBT VUJTVElUVVRFIEdPT0RTCisgKiBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikKKyAqIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUCisg KiBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkg QVJJU0lORyBJTiBBTlkgV0FZCisgKiBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GCisgKiBTVUNIIERBTUFHRS4KKyAq CisgKiAkRnJlZUJTRCQKKyAqLworCisjaW5jbHVkZSAib3B0X2RkYi5oIgorCisjaW5jbHVkZSA8 c3lzL3BhcmFtLmg+CisjaW5jbHVkZSA8c3lzL2tlcm5lbC5oPgorI2luY2x1ZGUgPHN5cy9zeXN0 bS5oPgorI2luY2x1ZGUgPHN5cy9wY3B1Lmg+CisjaW5jbHVkZSA8c3lzL3NtcC5oPgorCisjaW5j bHVkZSA8dm0vdm0uaD4KKyNpbmNsdWRlIDx2bS92bV9wYWdlLmg+CisKKyNpbmNsdWRlIDxtYWNo aW5lL3B0ZS5oPgorI2luY2x1ZGUgPG1hY2hpbmUvdGxiLmg+CisKK3N0cnVjdCB0bGJfc3RhdGUg eworCXVuc2lnbmVkIHdpcmVkOworCXN0cnVjdCB0bGJfZW50cnkgeworCQlyZWdpc3Rlcl90IGVu dHJ5aGk7CisJCXJlZ2lzdGVyX3QgZW50cnlsbzA7CisJCXJlZ2lzdGVyX3QgZW50cnlsbzE7CisJ fSBlbnRyeVtNSVBTX01BWF9UTEJfRU5UUklFU107Cit9OworCitzdGF0aWMgc3RydWN0IHRsYl9z dGF0ZSB0bGJfc3RhdGVbTUFYQ1BVXTsKKworI2lmIDAKKy8qCisgKiBQYWdlTWFzayBtdXN0IGlu Y3JlbWVudCBpbiBzdGVwcyBvZiAyIGJpdHMuCisgKi8KK0NPTVBJTEVfVElNRV9BU1NFUlQoUE9Q Q05UKFRMQk1BU0tfTUFTSykgJSAyID09IDApOworI2VuZGlmCisKK3N0YXRpYyBpbmxpbmUgdm9p ZAordGxiX3Byb2JlKHZvaWQpCit7CisJX19hc20gX192b2xhdGlsZSAoInRsYnAiIDogOiA6ICJt ZW1vcnkiKTsKKwltaXBzX2NwMF9zeW5jKCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordGxi X3JlYWQodm9pZCkKK3sKKwlfX2FzbSBfX3ZvbGF0aWxlICgidGxiciIgOiA6IDogIm1lbW9yeSIp OworCW1pcHNfY3AwX3N5bmMoKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkCit0bGJfd3JpdGVf aW5kZXhlZCh2b2lkKQoreworCV9fYXNtIF9fdm9sYXRpbGUgKCJ0bGJ3aSIgOiA6IDogIm1lbW9y eSIpOworCW1pcHNfY3AwX3N5bmMoKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkCit0bGJfd3Jp dGVfcmFuZG9tKHZvaWQpCit7CisJX19hc20gX192b2xhdGlsZSAoInRsYndyIiA6IDogOiAibWVt b3J5Iik7CisJbWlwc19jcDBfc3luYygpOworfQorCitzdGF0aWMgdm9pZCB0bGJfaW52YWxpZGF0 ZV9vbmUodW5zaWduZWQpOworCit2b2lkCit0bGJfaW5zZXJ0X3dpcmVkKHVuc2lnbmVkIGksIHZt X29mZnNldF90IHZhLCBwdF9lbnRyeV90IHB0ZTAsIHB0X2VudHJ5X3QgcHRlMSkKK3sKKwlyZWdp c3Rlcl90IG1hc2ssIGFzaWQ7CisJcmVnaXN0ZXJfdCBzOworCisJdmEgJj0gflBBR0VfTUFTSzsK KworCXMgPSBpbnRyX2Rpc2FibGUoKTsKKwltYXNrID0gbWlwc19yZF9wYWdlbWFzaygpOworCWFz aWQgPSBtaXBzX3JkX2VudHJ5aGkoKSAmIFRMQkhJX0FTSURfTUFTSzsKKworCW1pcHNfd3JfaW5k ZXgoaSk7CisJbWlwc193cl9wYWdlbWFzaygwKTsKKwltaXBzX3dyX2VudHJ5aGkoVExCSElfRU5U UlkodmEsIDApKTsKKwltaXBzX3dyX2VudHJ5bG8wKHB0ZTApOworCW1pcHNfd3JfZW50cnlsbzEo cHRlMSk7CisJdGxiX3dyaXRlX2luZGV4ZWQoKTsKKworCW1pcHNfd3JfZW50cnloaShhc2lkKTsK KwltaXBzX3dyX3BhZ2VtYXNrKG1hc2spOworCWludHJfcmVzdG9yZShzKTsKK30KKwordm9pZAor dGxiX2ludmFsaWRhdGVfYWRkcmVzcyhzdHJ1Y3QgcG1hcCAqcG1hcCwgdm1fb2Zmc2V0X3QgdmEp Cit7CisJcmVnaXN0ZXJfdCBtYXNrLCBhc2lkOworCXJlZ2lzdGVyX3QgczsKKwlpbnQgaTsKKwor CXZhICY9IH5QQUdFX01BU0s7CisKKwlzID0gaW50cl9kaXNhYmxlKCk7CisJbWFzayA9IG1pcHNf cmRfcGFnZW1hc2soKTsKKwlhc2lkID0gbWlwc19yZF9lbnRyeWhpKCkgJiBUTEJISV9BU0lEX01B U0s7CisKKwltaXBzX3dyX3BhZ2VtYXNrKDApOworCW1pcHNfd3JfZW50cnloaShUTEJISV9FTlRS WSh2YSwgcG1hcF9hc2lkKHBtYXApKSk7CisJdGxiX3Byb2JlKCk7CisJaSA9IG1pcHNfcmRfaW5k ZXgoKTsKKwlpZiAoaSA+PSAwKQorCQl0bGJfaW52YWxpZGF0ZV9vbmUoaSk7CisKKwltaXBzX3dy X2VudHJ5aGkoYXNpZCk7CisJbWlwc193cl9wYWdlbWFzayhtYXNrKTsKKwlpbnRyX3Jlc3RvcmUo cyk7Cit9CisKK3ZvaWQKK3RsYl9pbnZhbGlkYXRlX2FsbCh2b2lkKQoreworCXJlZ2lzdGVyX3Qg bWFzaywgYXNpZDsKKwlyZWdpc3Rlcl90IHM7CisJdW5zaWduZWQgaTsKKworCXMgPSBpbnRyX2Rp c2FibGUoKTsKKwltYXNrID0gbWlwc19yZF9wYWdlbWFzaygpOworCWFzaWQgPSBtaXBzX3JkX2Vu dHJ5aGkoKSAmIFRMQkhJX0FTSURfTUFTSzsKKworCWZvciAoaSA9IG1pcHNfcmRfd2lyZWQoKTsg aSA8IG51bV90bGJlbnRyaWVzOyBpKyspCisJCXRsYl9pbnZhbGlkYXRlX29uZShpKTsKKworCW1p cHNfd3JfZW50cnloaShhc2lkKTsKKwltaXBzX3dyX3BhZ2VtYXNrKG1hc2spOworCWludHJfcmVz dG9yZShzKTsKK30KKwordm9pZAordGxiX2ludmFsaWRhdGVfYWxsX3VzZXIoc3RydWN0IHBtYXAg KnBtYXApCit7CisJcmVnaXN0ZXJfdCBtYXNrLCBhc2lkOworCXJlZ2lzdGVyX3QgczsKKwl1bnNp Z25lZCBpOworCisJcyA9IGludHJfZGlzYWJsZSgpOworCW1hc2sgPSBtaXBzX3JkX3BhZ2VtYXNr KCk7CisJYXNpZCA9IG1pcHNfcmRfZW50cnloaSgpICYgVExCSElfQVNJRF9NQVNLOworCisJZm9y IChpID0gbWlwc19yZF93aXJlZCgpOyBpIDwgbnVtX3RsYmVudHJpZXM7IGkrKykgeworCQlyZWdp c3Rlcl90IHVhc2lkOworCisJCW1pcHNfd3JfaW5kZXgoaSk7CisJCXRsYl9yZWFkKCk7CisKKwkJ dWFzaWQgPSBtaXBzX3JkX2VudHJ5aGkoKSAmIFRMQkhJX0FTSURfTUFTSzsKKwkJaWYgKHBtYXAg PT0gTlVMTCkgeworCQkJLyoKKwkJCSAqIEludmFsaWRhdGUgYWxsIG5vbi1rZXJuZWwgZW50cmll cy4KKwkJCSAqLworCQkJaWYgKHVhc2lkID09IDApCisJCQkJY29udGludWU7CisJCX0gZWxzZSB7 CisJCQkvKgorCQkJICogSW52YWxpZGF0ZSB0aGlzIHBtYXAncyBlbnRyaWVzLgorCQkJICovCisJ CQlpZiAodWFzaWQgIT0gcG1hcF9hc2lkKHBtYXApKQorCQkJCWNvbnRpbnVlOworCQl9CisJCXRs Yl9pbnZhbGlkYXRlX29uZShpKTsKKwl9CisKKwltaXBzX3dyX2VudHJ5aGkoYXNpZCk7CisJbWlw c193cl9wYWdlbWFzayhtYXNrKTsKKwlpbnRyX3Jlc3RvcmUocyk7Cit9CisKKy8qIFhYWCBPbmx5 IGlmIEREQj8gICovCit2b2lkCit0bGJfc2F2ZSh2b2lkKQoreworCXVuc2lnbmVkIGksIGNwdTsK KworCWNwdSA9IFBDUFVfR0VUKGNwdWlkKTsKKworCXRsYl9zdGF0ZVtjcHVdLndpcmVkID0gbWlw c19yZF93aXJlZCgpOworCWZvciAoaSA9IDA7IGkgPCBudW1fdGxiZW50cmllczsgaSsrKSB7CisJ CW1pcHNfd3JfaW5kZXgoaSk7CisJCXRsYl9yZWFkKCk7CisKKwkJdGxiX3N0YXRlW2NwdV0uZW50 cnlbaV0uZW50cnloaSA9IG1pcHNfcmRfZW50cnloaSgpOworCQl0bGJfc3RhdGVbY3B1XS5lbnRy eVtpXS5lbnRyeWxvMCA9IG1pcHNfcmRfZW50cnlsbzAoKTsKKwkJdGxiX3N0YXRlW2NwdV0uZW50 cnlbaV0uZW50cnlsbzEgPSBtaXBzX3JkX2VudHJ5bG8xKCk7CisJfQorfQorCit2b2lkCit0bGJf dXBkYXRlKHN0cnVjdCBwbWFwICpwbWFwLCB2bV9vZmZzZXRfdCB2YSwgcHRfZW50cnlfdCBwdGUp Cit7CisJcmVnaXN0ZXJfdCBtYXNrLCBhc2lkOworCXJlZ2lzdGVyX3QgczsKKwlpbnQgaTsKKwor CXZhICY9IH5QQUdFX01BU0s7CisJcHRlICY9IH5UTEJMT19TV0JJVFNfTUFTSzsKKworCXMgPSBp bnRyX2Rpc2FibGUoKTsKKwltYXNrID0gbWlwc19yZF9wYWdlbWFzaygpOworCWFzaWQgPSBtaXBz X3JkX2VudHJ5aGkoKSAmIFRMQkhJX0FTSURfTUFTSzsKKworCW1pcHNfd3JfcGFnZW1hc2soMCk7 CisJbWlwc193cl9lbnRyeWhpKFRMQkhJX0VOVFJZKHZhLCBwbWFwX2FzaWQocG1hcCkpKTsKKwl0 bGJfcHJvYmUoKTsKKwlpID0gbWlwc19yZF9pbmRleCgpOworCWlmIChpID49IDApIHsKKwkJdGxi X3JlYWQoKTsKKworCQlpZiAoKHZhICYgUEFHRV9TSVpFKSA9PSAwKSB7CisJCQltaXBzX3dyX2Vu dHJ5bG8wKHB0ZSk7CisJCX0gZWxzZSB7CisJCQltaXBzX3dyX2VudHJ5bG8xKHB0ZSk7CisJCX0K KwkJdGxiX3dyaXRlX2luZGV4ZWQoKTsKKwl9CisKKwltaXBzX3dyX2VudHJ5aGkoYXNpZCk7CisJ bWlwc193cl9wYWdlbWFzayhtYXNrKTsKKwlpbnRyX3Jlc3RvcmUocyk7Cit9CisKK3N0YXRpYyB2 b2lkCit0bGJfaW52YWxpZGF0ZV9vbmUodW5zaWduZWQgaSkKK3sKKwkvKiBYWFggYW4gaW52YWxp ZCBBU0lEPyAqLworCW1pcHNfd3JfZW50cnloaShUTEJISV9FTlRSWShNSVBTX0tTRUcwX1NUQVJU ICsgKDIgKiBpICogUEFHRV9TSVpFKSwgMCkpOworCW1pcHNfd3JfZW50cnlsbzAoMCk7CisJbWlw c193cl9lbnRyeWxvMSgwKTsKKwltaXBzX3dyX3BhZ2VtYXNrKDApOworCW1pcHNfd3JfaW5kZXgo aSk7CisJdGxiX3dyaXRlX2luZGV4ZWQoKTsKK30KKworI2lmZGVmIEREQgorI2luY2x1ZGUgPGRk Yi9kZGIuaD4KKworREJfU0hPV19DT01NQU5EKHRsYiwgZGRiX2R1bXBfdGxiKQoreworCXJlZ2lz dGVyX3QgZWhpLCBlbG8wLCBlbG8xOworCXVuc2lnbmVkIGksIGNwdTsKKworCS8qCisJICogWFhY CisJICogVGhlIHdvcnN0IGNvbnZlcnNpb24gZnJvbSBoZXggdG8gZGVjaW1hbCBldmVyLgorCSAq LworCWlmIChoYXZlX2FkZHIpCisJCWNwdSA9ICgoYWRkciA+PiA0KSAlIDE2KSAqIDEwICsgKGFk ZHIgJSAxNik7CisJZWxzZQorCQljcHUgPSBQQ1BVX0dFVChjcHVpZCk7CisKKwlpZiAoY3B1IDwg MCB8fCBjcHUgPj0gbXBfbmNwdXMpIHsKKwkJZGJfcHJpbnRmKCJJbnZhbGlkIENQVSAldVxuIiwg Y3B1KTsKKwkJcmV0dXJuOworCX0KKworCWlmIChjcHUgPT0gUENQVV9HRVQoY3B1aWQpKQorCQl0 bGJfc2F2ZSgpOworCisJZGJfcHJpbnRmKCJCZWdpbm5pbmcgVExCIGR1bXAgZm9yIENQVSAldS4u LlxuIiwgY3B1KTsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3RsYmVudHJpZXM7IGkrKykgeworCQlp ZiAoaSA9PSB0bGJfc3RhdGVbY3B1XS53aXJlZCkgeworCQkJaWYgKGkgIT0gMCkKKwkJCQlkYl9w cmludGYoIl5eXiBXSVJFRCBFTlRSSUVTIF5eXlxuIik7CisJCQllbHNlCisJCQkJZGJfcHJpbnRm KCIoTm8gd2lyZWQgZW50cmllcy4pXG4iKTsKKwkJfQorCisJCS8qIFhYWCBQYWdlTWFzay4gICov CisJCWVoaSA9IHRsYl9zdGF0ZVtjcHVdLmVudHJ5W2ldLmVudHJ5aGk7CisJCWVsbzAgPSB0bGJf c3RhdGVbY3B1XS5lbnRyeVtpXS5lbnRyeWxvMDsKKwkJZWxvMSA9IHRsYl9zdGF0ZVtjcHVdLmVu dHJ5W2ldLmVudHJ5bG8xOworCisJCWlmIChlbG8wID09IDAgJiYgZWxvMSA9PSAwKQorCQkJY29u dGludWU7CisKKwkJZGJfcHJpbnRmKCIjJXVcdD0+ICVqeFxuIiwgaSwgKGludG1heF90KWVoaSk7 CisJCWRiX3ByaW50ZigiIExvMFx0JWp4XHQoJSNqeClcbiIsIChpbnRtYXhfdCllbG8wLCAoaW50 bWF4X3QpVExCTE9fUFRFX1RPX1BBKGVsbzApKTsKKwkJZGJfcHJpbnRmKCIgTG8xXHQlanhcdCgl I2p4KVxuIiwgKGludG1heF90KWVsbzEsIChpbnRtYXhfdClUTEJMT19QVEVfVE9fUEEoZWxvMSkp OworCX0KKwlkYl9wcmludGYoIkZpbmlzaGVkLlxuIik7Cit9CisjZW5kaWYKSW5kZXg6IHN5cy9t aXBzL21pcHMvY3B1LmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMvbWlwcy9jcHUuYwkocmV2aXNp b24gMjA5MTkzKQorKysgc3lzL21pcHMvbWlwcy9jcHUuYwkod29ya2luZyBjb3B5KQpAQCAtNDks NiArNDksNyBAQAogI2luY2x1ZGUgPG1hY2hpbmUvaW50cl9tYWNoZGVwLmg+CiAjaW5jbHVkZSA8 bWFjaGluZS9sb2NvcmUuaD4KICNpbmNsdWRlIDxtYWNoaW5lL3B0ZS5oPgorI2luY2x1ZGUgPG1h Y2hpbmUvdGxiLmg+CiAjaW5jbHVkZSA8bWFjaGluZS9od2Z1bmMuaD4KIAogc3RydWN0IG1pcHNf Y3B1aW5mbyBjcHVpbmZvOwpAQCAtMTM1LDkgKzEzNiw5IEBACiAJcGxhdGZvcm1fY3B1X2luaXQo KTsKIAltaXBzX2dldF9pZGVudGl0eSgmY3B1aW5mbyk7CiAJbnVtX3RsYmVudHJpZXMgPSBjcHVp bmZvLnRsYl9uZW50cmllczsKLQlNaXBzX1NldFdJUkVEKDApOwotCU1pcHNfVExCRmx1c2gobnVt X3RsYmVudHJpZXMpOwotCU1pcHNfU2V0V0lSRUQoVk1XSVJFRF9FTlRSSUVTKTsKKwltaXBzX3dy X3dpcmVkKDApOworCXRsYl9pbnZhbGlkYXRlX2FsbCgpOworCW1pcHNfd3Jfd2lyZWQoVk1XSVJF RF9FTlRSSUVTKTsKIAltaXBzX2NvbmZpZ19jYWNoZSgmY3B1aW5mbyk7CiAJbWlwc192ZWN0b3Jf aW5pdCgpOwogCkluZGV4OiBzeXMvbWlwcy9taXBzL3BtYXAuYwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMv bWlwcy9taXBzL3BtYXAuYwkocmV2aXNpb24gMjA5MTkzKQorKysgc3lzL21pcHMvbWlwcy9wbWFw LmMJKHdvcmtpbmcgY29weSkKQEAgLTk5LDYgKzk5LDcgQEAKIAogI2luY2x1ZGUgPG1hY2hpbmUv Y2FjaGUuaD4KICNpbmNsdWRlIDxtYWNoaW5lL21kX3Zhci5oPgorI2luY2x1ZGUgPG1hY2hpbmUv dGxiLmg+CiAKICNpZiBkZWZpbmVkKERJQUdOT1NUSUMpCiAjZGVmaW5lCVBNQVBfRElBR05PU1RJ QwpAQCAtMTUwLDggKzE1MSw2IEBACiAKIHZtX29mZnNldF90IGtlcm5lbF92bV9lbmQ7CiAKLXN0 YXRpYyBzdHJ1Y3QgdGxiIHRsYnN0YXNoW01BWENQVV1bTUlQU19NQVhfVExCX0VOVFJJRVNdOwot CiBzdGF0aWMgdm9pZCBwbWFwX2FzaWRfYWxsb2MocG1hcF90IHBtYXApOwogCiAvKgpAQCAtMTgy LDggKzE4MSw2IEBACiBzdGF0aWMgdm1fcGFnZV90IF9wbWFwX2FsbG9jcHRlKHBtYXBfdCBwbWFw LCB1bnNpZ25lZCBwdGVwaW5kZXgsIGludCBmbGFncyk7CiBzdGF0aWMgaW50IHBtYXBfdW51c2Vf cHQocG1hcF90LCB2bV9vZmZzZXRfdCwgdm1fcGFnZV90KTsKIHN0YXRpYyBpbnQgaW5pdF9wdGVf cHJvdCh2bV9vZmZzZXRfdCB2YSwgdm1fcGFnZV90IG0sIHZtX3Byb3RfdCBwcm90KTsKLXN0YXRp YyB2b2lkIHBtYXBfVExCX2ludmFsaWRhdGVfa2VybmVsKHZtX29mZnNldF90KTsKLXN0YXRpYyB2 b2lkIHBtYXBfVExCX3VwZGF0ZV9rZXJuZWwodm1fb2Zmc2V0X3QsIHB0X2VudHJ5X3QpOwogc3Rh dGljIHZtX3BhZ2VfdCBwbWFwX2FsbG9jX3B0ZV9wYWdlKHBtYXBfdCwgdW5zaWduZWQgaW50LCBp bnQsIHZtX29mZnNldF90ICopOwogc3RhdGljIHZvaWQgcG1hcF9yZWxlYXNlX3B0ZV9wYWdlKHZt X3BhZ2VfdCk7CiAKQEAgLTIyMyw3ICsyMjAsNyBAQAogCWludHIgPSBpbnRyX2Rpc2FibGUoKTsJ CQkJCQlcCiAJc2NoZWRfcGluKCk7CQkJCQkJCVwKIAl2YSA9IHN5c20tPmJhc2U7CQkJCQkJXAot CW5wdGUgPSBtaXBzX3BhZGRyX3RvX3RsYnBmbihwaHlzKSB8CQkJCVwKKwlucHRlID0gVExCTE9f UEFfVE9fUEZOKHBoeXMpIHwJCQkJCVwKIAkgICAgUFRFX1JXIHwgUFRFX1YgfCBQVEVfRyB8IFBU RV9XIHwgUFRFX0NBQ0hFOwkJCVwKIAlwdGUgPSBwbWFwX3B0ZShrZXJuZWxfcG1hcCwgdmEpOwkJ CQlcCiAJKnB0ZSA9IG5wdGU7CQkJCQkJCVwKQEAgLTI0MSwxMSArMjM4LDExIEBACiAJc2NoZWRf cGluKCk7CQkJCQkJCVwKIAl2YTEgPSBzeXNtLT5iYXNlOwkJCQkJCVwKIAl2YTIgPSBzeXNtLT5i YXNlICsgUEFHRV9TSVpFOwkJCQkJXAotCW5wdGUgPSBtaXBzX3BhZGRyX3RvX3RsYnBmbihwaHlz MSkgfAkJCQlcCisJbnB0ZSA9IFRMQkxPX1BBX1RPX1BGTihwaHlzMSkgfAkJCQkJXAogCSAgICBQ VEVfUlcgfCBQVEVfViB8IFBURV9HIHwgUFRFX1cgfCBQVEVfQ0FDSEU7CQkJXAogCXB0ZSA9IHBt YXBfcHRlKGtlcm5lbF9wbWFwLCB2YTEpOwkJCQlcCiAJKnB0ZSA9IG5wdGU7CQkJCQkJCVwKLQlu cHRlID0gbWlwc19wYWRkcl90b190bGJwZm4ocGh5czIpIHwJCQkJXAorCW5wdGUgPSAgVExCTE9f UEFfVE9fUEZOKHBoeXMyKSB8CQkJCVwKIAkgICAgUFRFX1JXIHwgUFRFX1YgfCBQVEVfRyB8IFBU RV9XIHwgUFRFX0NBQ0hFOwkJCVwKIAlwdGUgPSBwbWFwX3B0ZShrZXJuZWxfcG1hcCwgdmEyKTsJ CQkJXAogCSpwdGUgPSBucHRlOwkJCQkJCQlcCkBAIC0yNTUsMTEgKzI1MiwxMSBAQAogI2RlZmlu ZQlQTUFQX0xNRU1fVU5NQVAoKQkJCQkJCVwKIAlwdGUgPSBwbWFwX3B0ZShrZXJuZWxfcG1hcCwg c3lzbS0+YmFzZSk7CQkJXAogCSpwdGUgPSBQVEVfRzsJCQkJCQkJXAotCXBtYXBfVExCX2ludmFs aWRhdGVfa2VybmVsKHN5c20tPmJhc2UpOwkJCQlcCisJdGxiX2ludmFsaWRhdGVfYWRkcmVzcyhr ZXJuZWxfcG1hcCwgc3lzbS0+YmFzZSk7CQlcCiAJc3lzbS0+dmFsaWQxID0gMDsJCQkJCQlcCiAJ cHRlID0gcG1hcF9wdGUoa2VybmVsX3BtYXAsIHN5c20tPmJhc2UgKyBQQUdFX1NJWkUpOwkJXAog CSpwdGUgPSBQVEVfRzsJCQkJCQkJXAotCXBtYXBfVExCX2ludmFsaWRhdGVfa2VybmVsKHN5c20t PmJhc2UgKyBQQUdFX1NJWkUpOwkJXAorCXRsYl9pbnZhbGlkYXRlX2FkZHJlc3Moa2VybmVsX3Bt YXAsIHN5c20tPmJhc2UgKyBQQUdFX1NJWkUpOwlcCiAJc3lzbS0+dmFsaWQyID0gMDsJCQkJCQlc CiAJc2NoZWRfdW5waW4oKTsJCQkJCQkJXAogCWludHJfcmVzdG9yZShpbnRyKTsJCQkJCQlcCkBA IC00OTksNyArNDk2LDcgQEAKIAlrZXJuZWxfcG1hcC0+cG1fYXNpZFswXS5hc2lkID0gUE1BUF9B U0lEX1JFU0VSVkVEOwogCWtlcm5lbF9wbWFwLT5wbV9hc2lkWzBdLmdlbiA9IDA7CiAJcG1hcF9t YXhfYXNpZCA9IFZNTlVNX1BJRFM7Ci0JTWFjaFNldFBJRCgwKTsKKwltaXBzX3dyX2VudHJ5aGko MCk7CiB9CiAKIC8qCkBAIC01NzYsOSArNTczLDE0IEBACiAKICNlbmRpZgogCi0JaWYgKHBtYXAt PnBtX2FjdGl2ZSAmIFBDUFVfR0VUKGNwdW1hc2spKSB7Ci0JCXBtYXBfVExCX2ludmFsaWRhdGVf YWxsKCk7Ci0JfSBlbHNlCisJaWYgKHBtYXAgPT0ga2VybmVsX3BtYXApIHsKKwkJdGxiX2ludmFs aWRhdGVfYWxsKCk7CisJCXJldHVybjsKKwl9CisKKwlpZiAocG1hcC0+cG1fYWN0aXZlICYgUENQ VV9HRVQoY3B1bWFzaykpCisJCXRsYl9pbnZhbGlkYXRlX2FsbF91c2VyKHBtYXApOworCWVsc2UK IAkJcG1hcC0+cG1fYXNpZFtQQ1BVX0dFVChjcHVpZCldLmdlbiA9IDA7CiB9CiAKQEAgLTYwOCw3 ICs2MTAsNyBAQAogI2VuZGlmCiAKIAlpZiAoaXNfa2VybmVsX3BtYXAocG1hcCkpIHsKLQkJcG1h cF9UTEJfaW52YWxpZGF0ZV9rZXJuZWwodmEpOworCQl0bGJfaW52YWxpZGF0ZV9hZGRyZXNzKHBt YXAsIHZhKTsKIAkJcmV0dXJuOwogCX0KIAlpZiAocG1hcC0+cG1fYXNpZFtQQ1BVX0dFVChjcHVp ZCldLmdlbiAhPSBQQ1BVX0dFVChhc2lkX2dlbmVyYXRpb24pKQpAQCAtNjE3LDIwICs2MTksOSBA QAogCQlwbWFwLT5wbV9hc2lkW1BDUFVfR0VUKGNwdWlkKV0uZ2VuID0gMDsKIAkJcmV0dXJuOwog CX0KLQl2YSA9IHBtYXBfdmFfYXNpZChwbWFwLCAodmEgJiB+UEFHRV9NQVNLKSk7Ci0JbWlwc19U QklTKHZhKTsKKwl0bGJfaW52YWxpZGF0ZV9hZGRyZXNzKHBtYXAsIHZhKTsKIH0KIAotc3RhdGlj IHZvaWQKLXBtYXBfVExCX2ludmFsaWRhdGVfa2VybmVsKHZtX29mZnNldF90IHZhKQotewotCXVf aW50MzJfdCBwaWQ7Ci0KLQlNYWNoVExCR2V0UElEKHBpZCk7Ci0JdmEgPSB2YSB8IChwaWQgPDwg Vk1UTEJfUElEX1NISUZUKTsKLQltaXBzX1RCSVModmEpOwotfQotCiBzdHJ1Y3QgcG1hcF91cGRh dGVfcGFnZV9hcmcgewogCXBtYXBfdCBwbWFwOwogCXZtX29mZnNldF90IHZhOwpAQCAtNjU5LDcg KzY1MCw3IEBACiAKICNlbmRpZgogCWlmIChpc19rZXJuZWxfcG1hcChwbWFwKSkgewotCQlwbWFw X1RMQl91cGRhdGVfa2VybmVsKHZhLCBwdGUpOworCQl0bGJfdXBkYXRlKHBtYXAsIHZhLCBwdGUp OwogCQlyZXR1cm47CiAJfQogCWlmIChwbWFwLT5wbV9hc2lkW1BDUFVfR0VUKGNwdWlkKV0uZ2Vu ICE9IFBDUFVfR0VUKGFzaWRfZ2VuZXJhdGlvbikpCkBAIC02NjgsMjMgKzY1OSw5IEBACiAJCXBt YXAtPnBtX2FzaWRbUENQVV9HRVQoY3B1aWQpXS5nZW4gPSAwOwogCQlyZXR1cm47CiAJfQotCXZh ID0gcG1hcF92YV9hc2lkKHBtYXAsICh2YSAmIH5QQUdFX01BU0spKTsKLQlNYWNoVExCVXBkYXRl KHZhLCBwdGUpOworCXRsYl91cGRhdGUocG1hcCwgdmEsIHB0ZSk7CiB9CiAKLXN0YXRpYyB2b2lk Ci1wbWFwX1RMQl91cGRhdGVfa2VybmVsKHZtX29mZnNldF90IHZhLCBwdF9lbnRyeV90IHB0ZSkK LXsKLQl1X2ludDMyX3QgcGlkOwotCi0JdmEgJj0gflBBR0VfTUFTSzsKLQotCU1hY2hUTEJHZXRQ SUQocGlkKTsKLQl2YSA9IHZhIHwgKHBpZCA8PCBWTVRMQl9QSURfU0hJRlQpOwotCi0JTWFjaFRM QlVwZGF0ZSh2YSwgcHRlKTsKLX0KLQogLyoKICAqCVJvdXRpbmU6CXBtYXBfZXh0cmFjdAogICoJ RnVuY3Rpb246CkBAIC03MDAsNyArNjc3LDcgQEAKIAlQTUFQX0xPQ0socG1hcCk7CiAJcHRlID0g cG1hcF9wdGUocG1hcCwgdmEpOwogCWlmIChwdGUpIHsKLQkJcmV0dmFsID0gbWlwc190bGJwZm5f dG9fcGFkZHIoKnB0ZSkgfCAodmEgJiBQQUdFX01BU0spOworCQlyZXR2YWwgPSBUTEJMT19QVEVf VE9fUEEoKnB0ZSkgfCAodmEgJiBQQUdFX01BU0spOwogCX0KIAlQTUFQX1VOTE9DSyhwbWFwKTsK IAlyZXR1cm4gcmV0dmFsOwpAQCAtNzI3LDEwICs3MDQsMTAgQEAKIAlwdGUgPSAqcG1hcF9wdGUo cG1hcCwgdmEpOwogCWlmIChwdGUgIT0gMCAmJiBwbWFwX3B0ZV92KCZwdGUpICYmCiAJICAgICgo cHRlICYgUFRFX1JXKSB8fCAocHJvdCAmIFZNX1BST1RfV1JJVEUpID09IDApKSB7Ci0JCWlmICh2 bV9wYWdlX3BhX3RyeXJlbG9jayhwbWFwLCBtaXBzX3RsYnBmbl90b19wYWRkcihwdGUpLCAmcGEp KQorCQlpZiAodm1fcGFnZV9wYV90cnlyZWxvY2socG1hcCwgVExCTE9fUFRFX1RPX1BBKHB0ZSks ICZwYSkpCiAJCQlnb3RvIHJldHJ5OwogCi0JCW0gPSBQSFlTX1RPX1ZNX1BBR0UobWlwc190bGJw Zm5fdG9fcGFkZHIocHRlKSk7CisJCW0gPSBQSFlTX1RPX1ZNX1BBR0UoVExCTE9fUFRFX1RPX1BB KHB0ZSkpOwogCQl2bV9wYWdlX2hvbGQobSk7CiAJfQogCVBBX1VOTE9DS19DT05EKHBhKTsKQEAg LTc1NCw3ICs3MzEsNyBAQAogI2lmZGVmIFBNQVBfREVCVUcKIAlwcmludGYoInBtYXBfa2VudGVy OiAgdmE6IDB4JTA4eCAtPiBwYTogMHglMDh4XG4iLCB2YSwgcGEpOwogI2VuZGlmCi0JbnB0ZSA9 IG1pcHNfcGFkZHJfdG9fdGxicGZuKHBhKSB8IFBURV9SVyB8IFBURV9WIHwgUFRFX0cgfCBQVEVf VzsKKwlucHRlID0gVExCTE9fUEFfVE9fUEZOKHBhKSB8IFBURV9SVyB8IFBURV9WIHwgUFRFX0cg fCBQVEVfVzsKIAogCWlmIChpc19jYWNoZWFibGVfbWVtKHBhKSkKIAkJbnB0ZSB8PSBQVEVfQ0FD SEU7CkBAIC0xNDg0LDcgKzE0NjEsNyBAQAogCQlwbWFwLT5wbV9zdGF0cy53aXJlZF9jb3VudCAt PSAxOwogCiAJcG1hcC0+cG1fc3RhdHMucmVzaWRlbnRfY291bnQgLT0gMTsKLQlwYSA9IG1pcHNf dGxicGZuX3RvX3BhZGRyKG9sZHB0ZSk7CisJcGEgPSBUTEJMT19QVEVfVE9fUEEob2xkcHRlKTsK IAogCWlmIChwYWdlX2lzX21hbmFnZWQocGEpKSB7CiAJCW0gPSBQSFlTX1RPX1ZNX1BBR0UocGEp OwpAQCAtMTcwMCw3ICsxNjc3LDcgQEAKIAkJfQogcmV0cnk6CiAJCW9iaXRzID0gcGJpdHMgPSAq cHRlOwotCQlwYSA9IG1pcHNfdGxicGZuX3RvX3BhZGRyKHBiaXRzKTsKKwkJcGEgPSBUTEJMT19Q VEVfVE9fUEEocGJpdHMpOwogCiAJCWlmIChwYWdlX2lzX21hbmFnZWQocGEpICYmIChwYml0cyAm IFBURV9NKSAhPSAwKSB7CiAJCQltID0gUEhZU19UT19WTV9QQUdFKHBhKTsKQEAgLTE3NzYsNyAr MTc1Myw3IEBACiAJcGEgPSBWTV9QQUdFX1RPX1BIWVMobSk7CiAJb20gPSBOVUxMOwogCW9yaWdw dGUgPSAqcHRlOwotCW9wYSA9IG1pcHNfdGxicGZuX3RvX3BhZGRyKG9yaWdwdGUpOworCW9wYSA9 IFRMQkxPX1BURV9UT19QQShvcmlncHRlKTsKIAogCS8qCiAJICogTWFwcGluZyBoYXMgbm90IGNo YW5nZWQsIG11c3QgYmUgcHJvdGVjdGlvbiBvciB3aXJpbmcgY2hhbmdlLgpAQCAtMTg3Myw3ICsx ODUwLDcgQEAKIAkvKgogCSAqIE5vdyB2YWxpZGF0ZSBtYXBwaW5nIHdpdGggZGVzaXJlZCBwcm90 ZWN0aW9uL3dpcmluZy4KIAkgKi8KLQluZXdwdGUgPSBtaXBzX3BhZGRyX3RvX3RsYnBmbihwYSkg fCBydyB8IFBURV9WOworCW5ld3B0ZSA9IFRMQkxPX1BBX1RPX1BGTihwYSkgfCBydyB8IFBURV9W OwogCiAJaWYgKGlzX2NhY2hlYWJsZV9tZW0ocGEpKQogCQluZXdwdGUgfD0gUFRFX0NBQ0hFOwpA QCAtMjAzOSw3ICsyMDE2LDcgQEAKIAkvKgogCSAqIE5vdyB2YWxpZGF0ZSBtYXBwaW5nIHdpdGgg Uk8gcHJvdGVjdGlvbgogCSAqLwotCSpwdGUgPSBtaXBzX3BhZGRyX3RvX3RsYnBmbihwYSkgfCBQ VEVfVjsKKwkqcHRlID0gVExCTE9fUEFfVE9fUEZOKHBhKSB8IFBURV9WOwogCiAJaWYgKGlzX2Nh Y2hlYWJsZV9tZW0ocGEpKQogCQkqcHRlIHw9IFBURV9DQUNIRTsKQEAgLTIwOTIsNyArMjA2OSw3 IEBACiAJCWNwdSA9IFBDUFVfR0VUKGNwdWlkKTsKIAkJc3lzbSA9ICZzeXNtYXBfbG1lbVtjcHVd OwogCQkvKiBTaW5jZSB0aGlzIGlzIGZvciB0aGUgZGVidWdnZXIsIG5vIGxvY2tzIG9yIGFueSBv dGhlciBmdW4gKi8KLQkJbnB0ZSA9IG1pcHNfcGFkZHJfdG9fdGxicGZuKHBhKSB8IFBURV9SVyB8 IFBURV9WIHwgUFRFX0cgfCBQVEVfVyB8IFBURV9DQUNIRTsKKwkJbnB0ZSA9IFRMQkxPX1BBX1RP X1BGTihwYSkgfCBQVEVfUlcgfCBQVEVfViB8IFBURV9HIHwgUFRFX1cgfCBQVEVfQ0FDSEU7CiAJ CXB0ZSA9IHBtYXBfcHRlKGtlcm5lbF9wbWFwLCBzeXNtLT5iYXNlKTsKIAkJKnB0ZSA9IG5wdGU7 CiAJCXN5c20tPnZhbGlkMSA9IDE7CkBAIC0yNDA3LDcgKzIzODQsNyBAQAogCQl9CiAJCSpwdGUg PSBpc19rZXJuZWxfcG1hcChwbWFwKSA/IFBURV9HIDogMDsKIAotCQltID0gUEhZU19UT19WTV9Q QUdFKG1pcHNfdGxicGZuX3RvX3BhZGRyKHRwdGUpKTsKKwkJbSA9IFBIWVNfVE9fVk1fUEFHRShU TEJMT19QVEVfVE9fUEEodHB0ZSkpOwogCQlLQVNTRVJUKG0gIT0gTlVMTCwKIAkJICAgICgicG1h cF9yZW1vdmVfcGFnZXM6IGJhZCB0cHRlICV4IiwgdHB0ZSkpOwogCkBAIC0yODE0LDcgKzI3OTEs NyBAQAogCXZhbCA9IE1JTkNPUkVfSU5DT1JFOwogCWlmICgocHRlICYgUFRFX00pICE9IDApCiAJ CXZhbCB8PSBNSU5DT1JFX01PRElGSUVEIHwgTUlOQ09SRV9NT0RJRklFRF9PVEhFUjsKLQlwYSA9 IG1pcHNfdGxicGZuX3RvX3BhZGRyKHB0ZSk7CisJcGEgPSBUTEJMT19QVEVfVE9fUEEocHRlKTsK IAltYW5hZ2VkID0gcGFnZV9pc19tYW5hZ2VkKHBhKTsKIAlpZiAobWFuYWdlZCkgewogCQkvKgpA QCAtMjg1Niw3ICsyODMzLDcgQEAKIAlwbWFwX2FzaWRfYWxsb2MocG1hcCk7CiAJaWYgKHRkID09 IGN1cnRocmVhZCkgewogCQlQQ1BVX1NFVChzZWdiYXNlLCBwbWFwLT5wbV9zZWd0YWIpOwotCQlN YWNoU2V0UElEKHBtYXAtPnBtX2FzaWRbUENQVV9HRVQoY3B1aWQpXS5hc2lkKTsKKwkJbWlwc193 cl9lbnRyeWhpKHBtYXAtPnBtX2FzaWRbUENQVV9HRVQoY3B1aWQpXS5hc2lkKTsKIAl9CiAKIAlQ Q1BVX1NFVChjdXJwbWFwLCBwbWFwKTsKQEAgLTI5NDgsNyArMjkyNSw3IEBACiAJCQkJCQkJdm1f b2Zmc2V0X3QgcGE7CiAJCQkJCQkJdm1fcGFnZV90IG07CiAKLQkJCQkJCQlwYSA9IG1pcHNfdGxi cGZuX3RvX3BhZGRyKCpwdGUpOworCQkJCQkJCXBhID0gVExCTE9fUEZOX1RPX1BBKCpwdGUpOwog CQkJCQkJCW0gPSBQSFlTX1RPX1ZNX1BBR0UocGEpOwogCQkJCQkJCXByaW50ZigidmE6ICVwLCBw dDogJXAsIGg6ICVkLCB3OiAlZCwgZjogMHgleCIsCiAJCQkJCQkJICAgICh2b2lkICopdmEsCkBA IC0zMDQ0LDcgKzMwMjEsNyBAQAogCSAgICBwbWFwLT5wbV9hc2lkW1BDUFVfR0VUKGNwdWlkKV0u Z2VuID09IFBDUFVfR0VUKGFzaWRfZ2VuZXJhdGlvbikpOwogCWVsc2UgewogCQlpZiAoUENQVV9H RVQobmV4dF9hc2lkKSA9PSBwbWFwX21heF9hc2lkKSB7Ci0JCQlNSVBTX1RCSUFQKCk7CisJCQl0 bGJfaW52YWxpZGF0ZV9hbGxfdXNlcihOVUxMKTsKIAkJCVBDUFVfU0VUKGFzaWRfZ2VuZXJhdGlv biwKIAkJCSAgICAoUENQVV9HRVQoYXNpZF9nZW5lcmF0aW9uKSArIDEpICYgQVNJREdFTl9NQVNL KTsKIAkJCWlmIChQQ1BVX0dFVChhc2lkX2dlbmVyYXRpb24pID09IDApIHsKQEAgLTMxMjQsNyAr MzEwMSw3IEBACiAJCWlmIChjdXJwcm9jICYmIGN1cnByb2MtPnBfdm1zcGFjZSkgewogCQkJcHRl cCA9IHBtYXBfcHRlKCZjdXJwcm9jLT5wX3Ztc3BhY2UtPnZtX3BtYXAsIHZhKTsKIAkJCWlmIChw dGVwKQotCQkJCXBhID0gbWlwc190bGJwZm5fdG9fcGFkZHIoKnB0ZXApIHwKKwkJCQlwYSA9IFRM QkxPX1BURV9UT19QQSgqcHRlcCkgfAogCQkJCSAgICAodmEgJiBQQUdFX01BU0spOwogCQl9CiAJ fSBlbHNlIGlmICh2YSA+PSBNSVBTX0tTRUcwX1NUQVJUICYmCkBAIC0zMTQwLDkgKzMxMTcsMTEg QEAKIAkJaWYgKGtlcm5lbF9wbWFwLT5wbV9hY3RpdmUpIHsKIAkJCS8qIEl0cyBpbnNpZGUgdGhl IHZpcnR1YWwgYWRkcmVzcyByYW5nZSAqLwogCQkJcHRlcCA9IHBtYXBfcHRlKGtlcm5lbF9wbWFw LCB2YSk7Ci0JCQlpZiAocHRlcCkKLQkJCQlwYSA9IG1pcHNfdGxicGZuX3RvX3BhZGRyKCpwdGVw KSB8Ci0JCQkJICAgICh2YSAmIFBBR0VfTUFTSyk7CisJCQlpZiAocHRlcCkgeworCQkJCXJldHVy biAoVExCTE9fUFRFX1RPX1BBKCpwdGVwKSB8CisJCQkJICAgICh2YSAmIFBBR0VfTUFTSykpOwor CQkJfQorCQkJcmV0dXJuICgwKTsKIAkJfQogCX0KIAlyZXR1cm4gcGE7CkBAIC0zMTYwLDYxICsz MTM5LDMgQEAKIAkJfQogCX0KIH0KLQotdm9pZAotcG1hcF9zYXZlX3RsYih2b2lkKQotewotCWlu dCB0bGJubywgY3B1OwotCi0JY3B1ID0gUENQVV9HRVQoY3B1aWQpOwotCi0JZm9yICh0bGJubyA9 IDA7IHRsYm5vIDwgbnVtX3RsYmVudHJpZXM7ICsrdGxibm8pCi0JCU1hY2hUTEJSZWFkKHRsYm5v LCAmdGxic3Rhc2hbY3B1XVt0bGJub10pOwotfQotCi0jaWZkZWYgRERCCi0jaW5jbHVkZSA8ZGRi L2RkYi5oPgotCi1EQl9TSE9XX0NPTU1BTkQodGxiLCBkZGJfZHVtcF90bGIpCi17Ci0JaW50IGNw dSwgdGxibm87Ci0Jc3RydWN0IHRsYiAqdGxiOwotCi0JaWYgKGhhdmVfYWRkcikKLQkJY3B1ID0g KChhZGRyID4+IDQpICUgMTYpICogMTAgKyAoYWRkciAlIDE2KTsKLQllbHNlCi0JCWNwdSA9IFBD UFVfR0VUKGNwdWlkKTsKLQotCWlmIChjcHUgPCAwIHx8IGNwdSA+PSBtcF9uY3B1cykgewotCQlk Yl9wcmludGYoIkludmFsaWQgQ1BVICVkXG4iLCBjcHUpOwotCQlyZXR1cm47Ci0JfSBlbHNlCi0J CWRiX3ByaW50ZigiQ1BVICVkOlxuIiwgY3B1KTsKLQotCWlmIChjcHUgPT0gUENQVV9HRVQoY3B1 aWQpKQotCQlwbWFwX3NhdmVfdGxiKCk7Ci0KLQlmb3IgKHRsYm5vID0gMDsgdGxibm8gPCBudW1f dGxiZW50cmllczsgKyt0bGJubykgewotCQl0bGIgPSAmdGxic3Rhc2hbY3B1XVt0bGJub107Ci0J CWlmICh0bGItPnRsYl9sbzAgJiBQVEVfViB8fCB0bGItPnRsYl9sbzEgJiBQVEVfVikgewotCQkJ cHJpbnRmKCJUTEIgJTJkIHZhZCAweCUwbHggIiwKLQkJCQl0bGJubywgKGxvbmcpKHRsYi0+dGxi X2hpICYgMHhmZmZmZmYwMCkpOwotCQl9IGVsc2UgewotCQkJcHJpbnRmKCJUTEIqJTJkIHZhZCAw eCUwbHggIiwKLQkJCQl0bGJubywgKGxvbmcpKHRsYi0+dGxiX2hpICYgMHhmZmZmZmYwMCkpOwot CQl9Ci0JCXByaW50ZigiMD0weCUwbHggIiwgcGZuX3RvX3ZhZCgobG9uZyl0bGItPnRsYl9sbzAp KTsKLQkJcHJpbnRmKCIlYyIsIHRsYi0+dGxiX2xvMCAmIFBURV9WID8gJ1YnIDogJy0nKTsKLQkJ cHJpbnRmKCIlYyIsIHRsYi0+dGxiX2xvMCAmIFBURV9NID8gJ00nIDogJy0nKTsKLQkJcHJpbnRm KCIlYyIsIHRsYi0+dGxiX2xvMCAmIFBURV9HID8gJ0cnIDogJy0nKTsKLQkJcHJpbnRmKCIgYXRy ICV4ICIsICh0bGItPnRsYl9sbzAgPj4gMykgJiA3KTsKLQkJcHJpbnRmKCIxPTB4JTBseCAiLCBw Zm5fdG9fdmFkKChsb25nKXRsYi0+dGxiX2xvMSkpOwotCQlwcmludGYoIiVjIiwgdGxiLT50bGJf bG8xICYgUFRFX1YgPyAnVicgOiAnLScpOwotCQlwcmludGYoIiVjIiwgdGxiLT50bGJfbG8xICYg UFRFX00gPyAnTScgOiAnLScpOwotCQlwcmludGYoIiVjIiwgdGxiLT50bGJfbG8xICYgUFRFX0cg PyAnRycgOiAnLScpOwotCQlwcmludGYoIiBhdHIgJXggIiwgKHRsYi0+dGxiX2xvMSA+PiAzKSAm IDcpOwotCQlwcmludGYoIiBzej0leCBwaWQ9JXhcbiIsIHRsYi0+dGxiX21hc2ssCi0JCSAgICAg ICAodGxiLT50bGJfaGkgJiAweDAwMDAwMGZmKSk7Ci0JfQotfQotI2VuZGlmCS8qIEREQiAqLwpJ bmRleDogc3lzL21pcHMvbWlwcy9tcF9tYWNoZGVwLmMKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMv bWlwcy9tcF9tYWNoZGVwLmMJKHJldmlzaW9uIDIwOTE5MykKKysrIHN5cy9taXBzL21pcHMvbXBf bWFjaGRlcC5jCSh3b3JraW5nIGNvcHkpCkBAIC00OSw2ICs0OSw3IEBACiAjaW5jbHVkZSA8bWFj aGluZS9od2Z1bmMuaD4KICNpbmNsdWRlIDxtYWNoaW5lL2ludHJfbWFjaGRlcC5oPgogI2luY2x1 ZGUgPG1hY2hpbmUvY2FjaGUuaD4KKyNpbmNsdWRlIDxtYWNoaW5lL3RsYi5oPgogCiBzdHJ1Y3Qg cGNiIHN0b3BwY2JzW01BWENQVV07CiAKQEAgLTEyOCw3ICsxMjksNyBAQAogCQkJQ1RSMChLVFJf U01QLCAiSVBJX1NUT1Agb3IgSVBJX1NUT1BfSEFSRCIpOwogCiAJCQlzYXZlY3R4KCZzdG9wcGNi c1tjcHVdKTsKLQkJCXBtYXBfc2F2ZV90bGIoKTsKKwkJCXRsYl9zYXZlKCk7CiAKIAkJCS8qIElu ZGljYXRlIHdlIGFyZSBzdG9wcGVkICovCiAJCQlhdG9taWNfc2V0X2ludCgmc3RvcHBlZF9jcHVz LCBjcHVtYXNrKTsKQEAgLTIzOCw5ICsyMzksOSBAQAogc21wX2luaXRfc2Vjb25kYXJ5KHVfaW50 MzJfdCBjcHVpZCkKIHsKIAkvKiBUTEIgKi8KLQlNaXBzX1NldFdJUkVEKDApOwotCU1pcHNfVExC Rmx1c2gobnVtX3RsYmVudHJpZXMpOwotCU1pcHNfU2V0V0lSRUQoVk1XSVJFRF9FTlRSSUVTKTsK KwltaXBzX3dyX3dpcmVkKDApOworCXRsYl9pbnZhbGlkYXRlX2FsbCgpOworCW1pcHNfd3Jfd2ly ZWQoVk1XSVJFRF9FTlRSSUVTKTsKIAogCS8qCiAJICogV2UgYXNzdW1lIHRoYXQgdGhlIEwxIGNh Y2hlIG9uIHRoZSBBUHMgaXMgaWRlbnRpY2FsIHRvIHRoZSBvbmUKQEAgLTI1MSw3ICsyNTIsNyBA QAogCiAJbWlwc19zeW5jKCk7CiAKLQlNYWNoU2V0UElEKDApOworCW1pcHNfd3JfZW50cnloaSgw KTsKIAogCXBjcHVfaW5pdChQQ1BVX0FERFIoY3B1aWQpLCBjcHVpZCwgc2l6ZW9mKHN0cnVjdCBw Y3B1KSk7CiAJZHBjcHVfaW5pdChkcGNwdSwgY3B1aWQpOwpJbmRleDogc3lzL21pcHMvbWlwcy9t YWNoZGVwLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMvbWlwcy9tYWNoZGVwLmMJKHJldmlzaW9u IDIwOTE5MykKKysrIHN5cy9taXBzL21pcHMvbWFjaGRlcC5jCSh3b3JraW5nIGNvcHkpCkBAIC04 OSw2ICs4OSw3IEBACiAjaW5jbHVkZSA8bWFjaGluZS9od2Z1bmMuaD4KICNpbmNsdWRlIDxtYWNo aW5lL2ludHJfbWFjaGRlcC5oPgogI2luY2x1ZGUgPG1hY2hpbmUvbWRfdmFyLmg+CisjaW5jbHVk ZSA8bWFjaGluZS90bGIuaD4KICNpZmRlZiBEREIKICNpbmNsdWRlIDxzeXMva2RiLmg+CiAjaW5j bHVkZSA8ZGRiL2RkYi5oPgpAQCAtMTE4LDcgKzExOSw3IEBACiAvKgogICogRWFjaCBlbnRyeSBp biB0aGUgcGNwdV9zcGFjZVtdIGFycmF5IGlzIGxhaWQgb3V0IGluIHRoZSBmb2xsb3dpbmcgbWFu bmVyOgogICogc3RydWN0IHBjcHUgZm9yIGNwdSAnbicJcGNwdV9zcGFjZVtuXQotICogYm9vdCBz dGFjayBmb3IgY3B1ICduJwlwY3B1X3NwYWNlW25dICsgUEFHRV9TSVpFICogMiAtIFNUQVJUX0ZS QU1FCisgKiBib290IHN0YWNrIGZvciBjcHUgJ24nCXBjcHVfc3BhY2Vbbl0gKyBQQUdFX1NJWkUg KiAyIC0gQ0FMTEZSQU1FX1NJWgogICoKICAqIE5vdGUgdGhhdCB0aGUgYm9vdCBzdGFjayBncm93 cyBkb3dud2FyZHMgYW5kIHdlIGFzc3VtZSB0aGF0IHdlIG5ldmVyCiAgKiB1c2UgZW5vdWdoIHN0 YWNrIHNwYWNlIHRvIHRyYW1wbGUgb3ZlciB0aGUgJ3N0cnVjdCBwY3B1JyB0aGF0IGlzIGF0CkBA IC00MTMsMjAgKzQxNCwxNyBAQAogbWlwc19wY3B1X3RsYl9pbml0KHN0cnVjdCBwY3B1ICpwY3B1 KQogewogCXZtX3BhZGRyX3QgcGE7Ci0Jc3RydWN0IHRsYiB0bGI7Ci0JaW50IGxvYml0czsKKwlw dF9lbnRyeV90IHB0ZTsKIAogCS8qCiAJICogTWFwIHRoZSBwY3B1IHN0cnVjdHVyZSBhdCB0aGUg dmlydHVhbCBhZGRyZXNzICdwY3B1cCcuCiAJICogV2UgdXNlIGEgd2lyZWQgdGxiIGluZGV4IHRv IGRvIHRoaXMgb25lLXRpbWUgbWFwcGluZy4KIAkgKi8KLQltZW1zZXQoJnRsYiwgMCwgc2l6ZW9m KHRsYikpOwogCXBhID0gdnRvcGh5cyhwY3B1KTsKLQlsb2JpdHMgPSBQVEVfUlcgfCBQVEVfViB8 IFBURV9HIHwgUFRFX0NBQ0hFOwotCXRsYi50bGJfaGkgPSAodm1fb2Zmc2V0X3QpcGNwdXA7Ci0J dGxiLnRsYl9sbzAgPSBtaXBzX3BhZGRyX3RvX3RsYnBmbihwYSkgfCBsb2JpdHM7Ci0JdGxiLnRs Yl9sbzEgPSBtaXBzX3BhZGRyX3RvX3RsYnBmbihwYSArIFBBR0VfU0laRSkgfCBsb2JpdHM7Ci0J TWlwc19UTEJXcml0ZUluZGV4ZWQoUENQVV9UTEJfRU5UUlksICZ0bGIpOworCXB0ZSA9IFBURV9S VyB8IFBURV9WIHwgUFRFX0cgfCBQVEVfQ0FDSEU7CisJdGxiX2luc2VydF93aXJlZChQQ1BVX1RM Ql9FTlRSWSwgKHZtX29mZnNldF90KXBjcHVwLAorCQkJIFRMQkxPX1BBX1RPX1BGTihwYSkgfCBw dGUsCisJCQkgVExCTE9fUEFfVE9fUEZOKHBhICsgUEFHRV9TSVpFKSB8IHB0ZSk7CiB9CiAjZW5k aWYKIApJbmRleDogc3lzL21pcHMvbWlwcy90cmFwLmMKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMv bWlwcy90cmFwLmMJKHJldmlzaW9uIDIwOTE5MykKKysrIHN5cy9taXBzL21pcHMvdHJhcC5jCSh3 b3JraW5nIGNvcHkpCkBAIC0zOTYsNyArMzk2LDcgQEAKIAkJCX0KIAkJCSpwdGUgfD0gbWlwc19w Z19tX2JpdCgpOwogCQkJcG1hcF91cGRhdGVfcGFnZShrZXJuZWxfcG1hcCwgdHJhcGZyYW1lLT5i YWR2YWRkciwgKnB0ZSk7Ci0JCQlwYSA9IG1pcHNfdGxicGZuX3RvX3BhZGRyKCpwdGUpOworCQkJ cGEgPSBUTEJMT19QVEVfVE9fUEEoKnB0ZSk7CiAJCQlpZiAoIXBhZ2VfaXNfbWFuYWdlZChwYSkp CiAJCQkJcGFuaWMoInRyYXA6IGt0bGJtb2Q6IHVubWFuYWdlZCBwYWdlIik7CiAJCQlwbWFwX3Nl dF9tb2RpZmllZChwYSk7CkBAIC00MzUsNyArNDM1LDcgQEAKIAkJCX0KIAkJCSpwdGUgfD0gbWlw c19wZ19tX2JpdCgpOwogCQkJcG1hcF91cGRhdGVfcGFnZShwbWFwLCB0cmFwZnJhbWUtPmJhZHZh ZGRyLCAqcHRlKTsKLQkJCXBhID0gbWlwc190bGJwZm5fdG9fcGFkZHIoKnB0ZSk7CisJCQlwYSA9 IFRMQkxPX1BURV9UT19QQSgqcHRlKTsKIAkJCWlmICghcGFnZV9pc19tYW5hZ2VkKHBhKSkKIAkJ CQlwYW5pYygidHJhcDogdXRsYm1vZDogdW5tYW5hZ2VkIHBhZ2UiKTsKIAkJCXBtYXBfc2V0X21v ZGlmaWVkKHBhKTsK --e0cb4e88758397b495048911b0d9-- From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 13:55:39 2010 Return-Path: Delivered-To: freebsd-mips@FreeBSD.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 919721065677; Tue, 15 Jun 2010 13:55:39 +0000 (UTC) (envelope-from imp@bsdimp.com) Received: from harmony.bsdimp.com (bsdimp.com [199.45.160.85]) by mx1.freebsd.org (Postfix) with ESMTP id 5445F8FC26; Tue, 15 Jun 2010 13:55:39 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by harmony.bsdimp.com (8.14.3/8.14.1) with ESMTP id o5FDpciv037538; Tue, 15 Jun 2010 07:51:38 -0600 (MDT) (envelope-from imp@bsdimp.com) Date: Tue, 15 Jun 2010 07:51:42 -0600 (MDT) Message-Id: <20100615.075142.716508926086259279.imp@bsdimp.com> To: c.jayachandran@gmail.com From: "M. Warner Losh" In-Reply-To: References: X-Mailer: Mew version 6.3 on Emacs 22.3 / Mule 5.0 (SAKAKI) Mime-Version: 1.0 Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Cc: jmallett@FreeBSD.org, freebsd-mips@FreeBSD.org Subject: Re: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 13:55:39 -0000 In message: "Jayachandran C." writes: : I have volunteered to merge Juli's 64-bit work into HEAD, and : hopefully get it to work on XLR too. The tree : (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of : changes, so I would like to do this over multiple changesets and : without breaking the current o32 code. : : The first batch of changes are attached (also at : http://people.freebsd.org/~jchandra/jmallett-merge/), the patches are: : : libc-asm.patch - change libc assembly code to use macros which work on o32/n64 : libc-other.patch - makecontext implemenation, and other cleanup : ld.so.patch - change dynamic loader assembly code to use macros : tlb-to-c.patch - move TLB operations to C, update TLB operations API : : I've tested this on XLR, but there is a chance that this might break : other platforms. So please let me know your comments on both the : patches and the merge process. I've reviewed these changes with Juli as she was committing them to her branch. I think they are good to go. Warner : The future patches (if everything goes well), will do the PTE_ flag to : PG_ flag renaming in Juli's tree, then the actual n32/n64 changes. : : Thanks, : JC. From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 14:02:53 2010 Return-Path: Delivered-To: freebsd-mips@FreeBSD.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 82729106564A; Tue, 15 Jun 2010 14:02:53 +0000 (UTC) (envelope-from rrs@lakerest.net) Received: from lakerest.net (unknown [IPv6:2001:240:585:2:213:d4ff:fef3:2d8d]) by mx1.freebsd.org (Postfix) with ESMTP id 0FB9B8FC0C; Tue, 15 Jun 2010 14:02:52 +0000 (UTC) Received: from [192.168.1.69] (pool-70-109-12-150.atl.dsl-w.verizon.net [70.109.12.150]) (authenticated bits=0) by lakerest.net (8.14.3/8.14.3) with ESMTP id o5FE24dB017810 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NOT); Tue, 15 Jun 2010 10:02:49 -0400 (EDT) (envelope-from rrs@lakerest.net) DKIM-Signature: a=rsa-sha1; c=simple/simple; d=lakerest.net; s=mail; t=1276610569; h=Cc:Message-Id:From:To:In-Reply-To:Content-Type: Content-Transfer-Encoding:Mime-Version:Subject:Date:References: X-Mailer; b=fNp363scLJhWV1lCHxnoajLoQ3jxYodgNcCoQ7wV+/ktLbgjn/vkS1z 010ea+xV641P13O/ShFnxAcW6raNDxA== Message-Id: <3F1E3AAE-72B4-4323-9AC3-147066AF50E6@lakerest.net> From: Randall Stewart To: "M. Warner Losh" In-Reply-To: <20100615.075142.716508926086259279.imp@bsdimp.com> Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes Content-Transfer-Encoding: 7bit Mime-Version: 1.0 (Apple Message framework v936) Date: Tue, 15 Jun 2010 10:02:48 -0400 References: <20100615.075142.716508926086259279.imp@bsdimp.com> X-Mailer: Apple Mail (2.936) Cc: jmallett@FreeBSD.org, freebsd-mips@FreeBSD.org Subject: Re: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 14:02:53 -0000 Do we want to make sure that the changes work on a couple of other platforms (sibyte etc)? R On Jun 15, 2010, at 9:51 AM, M. Warner Losh wrote: > In message: > > "Jayachandran C." writes: > : I have volunteered to merge Juli's 64-bit work into HEAD, and > : hopefully get it to work on XLR too. The tree > : (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit > of > : changes, so I would like to do this over multiple changesets and > : without breaking the current o32 code. > : > : The first batch of changes are attached (also at > : http://people.freebsd.org/~jchandra/jmallett-merge/), the patches > are: > : > : libc-asm.patch - change libc assembly code to use macros which > work on o32/n64 > : libc-other.patch - makecontext implemenation, and other cleanup > : ld.so.patch - change dynamic loader assembly code to use macros > : tlb-to-c.patch - move TLB operations to C, update TLB operations API > : > : I've tested this on XLR, but there is a chance that this might break > : other platforms. So please let me know your comments on both the > : patches and the merge process. > > I've reviewed these changes with Juli as she was committing them to > her branch. I think they are good to go. > > Warner > > > : The future patches (if everything goes well), will do the PTE_ > flag to > : PG_ flag renaming in Juli's tree, then the actual n32/n64 changes. > : > : Thanks, > : JC. > ------------------------------ Randall Stewart 803-317-4952 (cell) From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 14:09:12 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 171BF1065677; Tue, 15 Jun 2010 14:09:12 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-vw0-f54.google.com (mail-vw0-f54.google.com [209.85.212.54]) by mx1.freebsd.org (Postfix) with ESMTP id A8D1D8FC13; Tue, 15 Jun 2010 14:09:11 +0000 (UTC) Received: by vws20 with SMTP id 20so6864760vws.13 for ; Tue, 15 Jun 2010 07:09:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:in-reply-to :references:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=ZzZVPVtCzfiPU8rJeN8+yHSQxfG+2aEV8foDFZ853Cc=; b=cYzo/o0KI2/lVgqEzsU9P/1KJoo598c87xGXlT8JH3jAW/cad2fg0S4+kFMUcw0egC b6dnvOav03gf1vUi4kEHSd+cLPpba35tZNaf/jNXRWCC5H0nV4PyfNNM3/vrVwlE2u7P rhLd7WiBo6ZW0aTDwjIb4PkTWlKOdV/1Gh714= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=c8IALHN4idlBTfrkkUfKtU3b3K0AwRMQ7cAr9aYJfo2lgGHYvFmdQyRDgn9A+pI5pk EsPowSPl0sz0utP2TQicUva900hqmtKvpFX6+me1khu5qqwPyUyku9DwIOInKtmUHMkl Fj2tpG5f9JbTRY1eAhA4LPt7pmSU26gkgKn78= MIME-Version: 1.0 Received: by 10.220.125.32 with SMTP id w32mr3941724vcr.7.1276610950491; Tue, 15 Jun 2010 07:09:10 -0700 (PDT) Received: by 10.220.199.136 with HTTP; Tue, 15 Jun 2010 07:09:10 -0700 (PDT) In-Reply-To: <3F1E3AAE-72B4-4323-9AC3-147066AF50E6@lakerest.net> References: <20100615.075142.716508926086259279.imp@bsdimp.com> <3F1E3AAE-72B4-4323-9AC3-147066AF50E6@lakerest.net> Date: Tue, 15 Jun 2010 19:39:10 +0530 Message-ID: From: "Jayachandran C." To: Randall Stewart Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 14:09:12 -0000 On Tue, Jun 15, 2010 at 7:32 PM, Randall Stewart wrote: > Do we want to make sure that the changes > work on a couple of other platforms (sibyte etc)? I can make sure that the compile does not break - but I don't have any way to test further. The changes (except the tlb.c change) really should not break the existing code, but it is always good to test. JC. > On Jun 15, 2010, at 9:51 AM, M. Warner Losh wrote: > >> In message: >> =A0 =A0 =A0 =A0 =A0 "Jayachandran C." writes: >> : I have volunteered to merge Juli's 64-bit work into HEAD, =A0and >> : hopefully get it to work on XLR too. The tree >> : (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of >> : changes, so I would like to do this over multiple changesets and >> : without breaking the current o32 code. >> : >> : The first batch of changes are attached (also at >> : http://people.freebsd.org/~jchandra/jmallett-merge/), the patches are: >> : >> : libc-asm.patch - change libc assembly code to use macros which work on >> o32/n64 >> : libc-other.patch - makecontext implemenation, and other cleanup >> : ld.so.patch - change dynamic loader assembly code to use macros >> : tlb-to-c.patch - move TLB operations to C, update TLB operations API >> : >> : I've tested this on XLR, but there is a chance that this might break >> : other platforms. So please let me know your comments on both the >> : patches and the merge process. >> >> I've reviewed these changes with Juli as she was committing them to >> her branch. =A0I think they are good to go. >> >> Warner >> >> >> : The future patches (if everything goes well), will do the PTE_ flag to >> : PG_ flag renaming in Juli's tree, then the actual n32/n64 changes. >> : >> : Thanks, >> : JC. >> > > ------------------------------ > Randall Stewart > 803-317-4952 (cell) > > --=20 C. Jayachandran c.jayachandran@gmail.com From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 14:10:33 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 091CF106567C; Tue, 15 Jun 2010 14:10:33 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-vw0-f54.google.com (mail-vw0-f54.google.com [209.85.212.54]) by mx1.freebsd.org (Postfix) with ESMTP id 9739B8FC26; Tue, 15 Jun 2010 14:10:32 +0000 (UTC) Received: by vws20 with SMTP id 20so6866497vws.13 for ; Tue, 15 Jun 2010 07:10:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:in-reply-to :references:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=YuzjiZNO1accwh/PjCzzqgSx0mtmuVnfHYuUmw6LYLg=; b=V3IDDUeWORAvAg6kPK/RegK/m3MIOcBQm5DrSqdR5pbjuihNX0uedtyZ8+fV0CDa6m oR7+ixcsX+PR4VIM4I5iPgzpR2PVYSfY0Ta+Uwwg7s1udSd3UoyT1ChluEji77RUVkom OYTN7q3tYzDtcXNA/3Dum6iWk1e6nxCcSMKWs= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=kNUm9dxwzaXmdgUkPEXngrlOXmthw6VjSwfWChWEtITTYCobHkAOUw2UroWs3NLgec sJZKzJ3jq0NCXPEjZxg1WQhHvOiSAEJSvv7qAYoeLnjaSn91nr8TB7BVXr8srzUD/88o Rfd0jAyrzE7iLQRQ6nT6/dnbO0id57KUjY6as= MIME-Version: 1.0 Received: by 10.220.47.210 with SMTP id o18mr3932090vcf.97.1276611031022; Tue, 15 Jun 2010 07:10:31 -0700 (PDT) Received: by 10.220.199.136 with HTTP; Tue, 15 Jun 2010 07:10:30 -0700 (PDT) In-Reply-To: <20100615.075142.716508926086259279.imp@bsdimp.com> References: <20100615.075142.716508926086259279.imp@bsdimp.com> Date: Tue, 15 Jun 2010 19:40:30 +0530 Message-ID: From: "Jayachandran C." To: "M. Warner Losh" Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 14:10:33 -0000 On Tue, Jun 15, 2010 at 7:21 PM, M. Warner Losh wrote: > In message: > =A0 =A0 =A0 =A0 =A0 =A0"Jayachandran C." write= s: > : I have volunteered to merge Juli's 64-bit work into HEAD, =A0and > : hopefully get it to work on XLR too. The tree > : (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of > : changes, so I would like to do this over multiple changesets and > : without breaking the current o32 code. > : > : The first batch of changes are attached (also at > : http://people.freebsd.org/~jchandra/jmallett-merge/), the patches are: > : > : libc-asm.patch - change libc assembly code to use macros which work on = o32/n64 > : libc-other.patch - makecontext implemenation, and other cleanup > : ld.so.patch - change dynamic loader assembly code to use macros > : tlb-to-c.patch - move TLB operations to C, update TLB operations API > : > : I've tested this on XLR, but there is a chance that this might break > : other platforms. So please let me know your comments on both the > : patches and the merge process. > > I've reviewed these changes with Juli as she was committing them to > her branch. =A0I think they are good to go. Then, would you want to do it this way, or one big merge from Juli's branch would be okay? JC. From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 14:14:48 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 481A11065670; Tue, 15 Jun 2010 14:14:48 +0000 (UTC) (envelope-from rrs@lakerest.net) Received: from lakerest.net (unknown [IPv6:2001:240:585:2:213:d4ff:fef3:2d8d]) by mx1.freebsd.org (Postfix) with ESMTP id C72128FC16; Tue, 15 Jun 2010 14:14:47 +0000 (UTC) Received: from [192.168.1.69] (pool-70-109-12-150.atl.dsl-w.verizon.net [70.109.12.150]) (authenticated bits=0) by lakerest.net (8.14.3/8.14.3) with ESMTP id o5FEEbdU018354 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NOT); Tue, 15 Jun 2010 10:14:43 -0400 (EDT) (envelope-from rrs@lakerest.net) DKIM-Signature: a=rsa-sha1; c=simple/simple; d=lakerest.net; s=mail; t=1276611284; h=Cc:Message-Id:From:To:In-Reply-To:Content-Type: Content-Transfer-Encoding:Mime-Version:Subject:Date:References: X-Mailer; b=TWc5Bk6tlTCD9YVlRDGhuBzH2T4To6VzDN+puUwLMwiD+hMlAaMRmJr 2h4ZB8z9a02kcWKllSGgOYVcHrfdVaQ== Message-Id: <7D8CB554-C1A9-48AA-99EF-136CCD19619B@lakerest.net> From: Randall Stewart To: "Jayachandran C." In-Reply-To: Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes Content-Transfer-Encoding: 7bit Mime-Version: 1.0 (Apple Message framework v936) Date: Tue, 15 Jun 2010 10:14:32 -0400 References: <20100615.075142.716508926086259279.imp@bsdimp.com> X-Mailer: Apple Mail (2.936) Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 14:14:48 -0000 I would think small verifiable changes would be good.. that way if something does break (and we miss it) we can more easily figure out what it was... R On Jun 15, 2010, at 10:10 AM, Jayachandran C. wrote: > On Tue, Jun 15, 2010 at 7:21 PM, M. Warner Losh > wrote: >> In message: > > >> "Jayachandran C." writes: >> : I have volunteered to merge Juli's 64-bit work into HEAD, and >> : hopefully get it to work on XLR too. The tree >> : (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a >> bit of >> : changes, so I would like to do this over multiple changesets and >> : without breaking the current o32 code. >> : >> : The first batch of changes are attached (also at >> : http://people.freebsd.org/~jchandra/jmallett-merge/), the patches >> are: >> : >> : libc-asm.patch - change libc assembly code to use macros which >> work on o32/n64 >> : libc-other.patch - makecontext implemenation, and other cleanup >> : ld.so.patch - change dynamic loader assembly code to use macros >> : tlb-to-c.patch - move TLB operations to C, update TLB operations >> API >> : >> : I've tested this on XLR, but there is a chance that this might >> break >> : other platforms. So please let me know your comments on both the >> : patches and the merge process. >> >> I've reviewed these changes with Juli as she was committing them to >> her branch. I think they are good to go. > > Then, would you want to do it this way, or one big merge from Juli's > branch would be okay? > > JC. > ------------------------------ Randall Stewart 803-317-4952 (cell) From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 21:16:08 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id D12A51065679; Tue, 15 Jun 2010 21:16:08 +0000 (UTC) (envelope-from phcoder@gmail.com) Received: from fg-out-1718.google.com (fg-out-1718.google.com [72.14.220.152]) by mx1.freebsd.org (Postfix) with ESMTP id F04C78FC0C; Tue, 15 Jun 2010 21:16:07 +0000 (UTC) Received: by fg-out-1718.google.com with SMTP id l26so989564fgb.13 for ; Tue, 15 Jun 2010 14:16:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:received:received:message-id:date:from :user-agent:mime-version:to:subject:x-enigmail-version:content-type; bh=3o7Jqj1FlyCW1zL8hRFCLCjMU/8h0knA/WjrG6e9fpI=; b=r/Fw0KWs1BqbBzzrfYcWs1P7yT0jQeS7/oUA0M75muNuqvgBNdlZ2DXSKspTdv75Ap pnCbpVKrgb+TO60VfXE2dnZudG6Oxdslir3E2MH3zjwgJuttRuxSgkmKpGAXcTiY9oUe bh0YznsP2eGskGI1r08G6AC0Hgw/L0leh1yeA= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=message-id:date:from:user-agent:mime-version:to:subject :x-enigmail-version:content-type; b=wcXzPMzS+lR3VdWAdxkqacSBqmlJM/TO8vB+LlCZgUBG1QyQiDG8KnesJk32QQSDE6 DVra1Ijl6DzQcWezy1V4/iBgH3tF9b1JQFm6BSzDGjwjzTID5zLiBXwO96AIyVHC3AbT 6UaVeRpZ8Uch9u26G62UtC/vB385PHDbsDH6U= Received: by 10.87.67.8 with SMTP id u8mr11043636fgk.9.1276636566101; Tue, 15 Jun 2010 14:16:06 -0700 (PDT) Received: from debian.bg45.phnet (117-45.2-85.cust.bluewin.ch [85.2.45.117]) by mx.google.com with ESMTPS id 12sm10510749fgg.14.2010.06.15.14.16.03 (version=TLSv1/SSLv3 cipher=RC4-MD5); Tue, 15 Jun 2010 14:16:05 -0700 (PDT) Message-ID: <4C17ED8B.6070206@gmail.com> Date: Tue, 15 Jun 2010 23:15:55 +0200 From: =?UTF-8?B?VmxhZGltaXIgJ8+GLWNvZGVyL3BoY29kZXInIFNlcmJpbmVua28=?= User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.9) Gecko/20100515 Icedove/3.0.4 MIME-Version: 1.0 To: freebsd-mips@freebsd.org, soc-students@freebsd.org X-Enigmail-Version: 1.0.1 Content-Type: multipart/signed; micalg=pgp-sha512; protocol="application/pgp-signature"; boundary="------------enigB6D73304FB66E55E023B2942" Cc: Subject: Weekly yeeloong report X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 21:16:08 -0000 This is an OpenPGP/MIME signed message (RFC 2440 and 3156) --------------enigB6D73304FB66E55E023B2942 Content-Type: multipart/mixed; boundary="------------010000070606020606040007" This is a multi-part message in MIME format. --------------010000070606020606040007 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hello, all. This time I have some better news than the last time: I've found the cause of early failure: one of the things I tried oreviously was increasing TLB entry size. AFterwards I did some more fixes but unfortunately my TLB entry size increase was still in my tree and I forgot to update asm handlers for it. When I did issue was gone but I decided to roll back to 32-bit TLBs for now. I was able to reach "mountroot>" stage but there is a memory corruption somewhere and it reaches mountroot only with some probability. Investigating. I attach the log of successful attempt. --=20 Regards Vladimir '=CF=86-coder/phcoder' Serbinenko --------------010000070606020606040007 Content-Type: text/plain; name="mountroot.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="mountroot.txt" R1JVQiBDUzU1MzYgYXQgMDAwMDAyMDBTTUJ1cyBjb250cm9sbGVyIGVuYWJsZWQuCjAwMDAw MDgwQ2FjaGVzIGVuYWJsZWQKV2VsY29tZSB0byBHUlVCIQoKR05VIEdSVUIgIHZlcnNpb24g MS45OAoKICAgTWluaW1hbCBCQVNILWxpa2UgbGluZSBlZGl0aW5nIGlzIHN1cHBvcnRlZC4g Rm9yIHRoZSBmaXJzdCB3b3JkLCBUQUIKICAgbGlzdHMgcG9zc2libGUgY29tbWFuZCBjb21w bGV0aW9ucy4gQW55d2hlcmUgZWxzZSBUQUIgbGlzdHMgcG9zc2libGUKICAgZGV2aWNlIG9y IGZpbGUgY29tcGxldGlvbnMuIAoKCgoKCmdydWI+IG11bHRpYm9vdDIgKHVzYjAsbXNkb3Mx KS9rZXJuZWwKZ3J1Yj4gYm9vdAplbnRyeTogbWlwc19pbml0KCkKQ2FjaGUgaW5mbzoKICBw aWNhY2hlX3N0cmlkZSAgICA9IDQwOTYKICBwaWNhY2hlX2xvb3Bjb3VudCA9IDE2CiAgcGRj YWNoZV9zdHJpZGUgICAgPSA0MDk2CiAgcGRjYWNoZV9sb29wY291bnQgPSAxNgpjcHUwOiBV bmtub3duIGNpZCAwIHByb2Nlc3NvciB2My45OQogIE1NVTogU3RhbmRhcmQgQkFULCA2NCBl bnRyaWVzCiAgTDEgaS1jYWNoZTogNCB3YXlzIG9mIDUxMiBzZXRzLCAzMiBieXRlcyBwZXIg bGluZQogIEwxIGQtY2FjaGU6IDQgd2F5cyBvZiA1MTIgc2V0cywgMzIgYnl0ZXMgcGVyIGxp bmUKUGh5c2ljYWwgbWVtb3J5IGNodW5rKHMpOgoweDQwMDAwMDAgLSAweDVmZmZmZmYsIDMz NTU0NDMyIGJ5dGVzICg4MTkyIHBhZ2VzKQpNYXhtZW0gaXMgMHg2MDAwMDAwCktEQjogZGVi dWdnZXIgYmFja2VuZHM6IGRkYgpLREI6IGN1cnJlbnQgYmFja2VuZDogZGRiCmh6PTEwMCB0 aW1lcjFoejo0MDAgY3lsX3Blcl90aWNrOjEwMDAwMDAgY3lsX3Blcl91c2VjOjQwMCBmcmVx OjQwMDAwMDAwMApDb3B5cmlnaHQgKGMpIDE5OTItMjAxMCBUaGUgRnJlZUJTRCBQcm9qZWN0 LgpDb3B5cmlnaHQgKGMpIDE5NzksIDE5ODAsIDE5ODMsIDE5ODYsIDE5ODgsIDE5ODksIDE5 OTEsIDE5OTIsIDE5OTMsIDE5OTQKCVRoZSBSZWdlbnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9m IENhbGlmb3JuaWEuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCkZyZWVCU0QgaXMgYSByZWdpc3Rl cmVkIHRyYWRlbWFyayBvZiBUaGUgRnJlZUJTRCBGb3VuZGF0aW9uLgpGcmVlQlNEIDkuMC1D VVJSRU5UICM3NTogTW9uIEp1biAxNCAxMzoxMDo1NCBDRVNUIDIwMTAKICAgIHBoY29kZXJA ZnJlZWJzZC5iZzQ1LnBobmV0Oi9ob21lL3BoY29kZXIvY29tcGlsZS9taXBzL2hvbWUvcGhj b2Rlci9mcmVlYnNkLWJ6ci95ZWVsb29uZy9zeXMvWUVFTE9PTkcgbWlwcwpzdWJzeXN0ZW0g OTAwMDAwCiAgIDB4ZmZmZmZmZmY4MDFiNjYzMCgwKS4uLiBkb25lLgpzdWJzeXN0ZW0gMTAw MDAwMAogICAweGZmZmZmZmZmODAzMmZjOTAoMCkuLi4gZG9uZS4KICAgMHhmZmZmZmZmZjgw MzY1Nzc4KDApLi4uIGRvbmUuCnN1YnN5c3RlbSAxODAwMDAwCiAgIDB4ZmZmZmZmZmY4MDFi MTVhMCgwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Nk NWQwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NkNWIw KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NkNTkwKS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2JlMDE4KS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NmNjcwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MxZTAwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NmNzAwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2JmM2YwKS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2JmNTk4KS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NmOTYwKS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjFkZTgoMHhmZmZmZmZmZjgwM2JmNWI4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx YjFkZTgoMHhmZmZmZmZmZjgwM2NmYjIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFk ZTgoMHhmZmZmZmZmZjgwM2NmYjQ4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgo MHhmZmZmZmZmZjgwM2NmYjAwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhm ZmZmZmZmZjgwM2NmYWUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZm ZmZmZjgwM2QwNTEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZm ZjgwM2QwNmYwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgw M2QwNzEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Mw MTQ4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QxM2Mw KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QxM2UwKS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QxNDAwKS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QxZTUwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QyMDAwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QyNDgwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QyZmMwKS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MwODA4KS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QzMDQwKS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjFkZTgoMHhmZmZmZmZmZjgwM2QzMDYwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx YjFkZTgoMHhmZmZmZmZmZjgwM2QzNWEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFk ZTgoMHhmZmZmZmZmZjgwM2QzOGIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgo MHhmZmZmZmZmZjgwM2QzYjk4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhm ZmZmZmZmZjgwM2Q0MmIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZm ZmZmZjgwM2MwODI4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZm ZjgwM2NhMjUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgw M2Q0NzEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Nh Mzk4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q0OWEw KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q0OWYwKS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MwODQ4KS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MwYWYwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NhODk4KS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q0ZGEwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q0ZGYwKS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q1MTUwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q1MWYwKS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q1MjEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx YjFkZTgoMHhmZmZmZmZmZjgwM2Q1MjMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFk ZTgoMHhmZmZmZmZmZjgwM2Q2NjUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgo MHhmZmZmZmZmZjgwM2Q2YjQwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhm ZmZmZmZmZjgwM2Q2ZTEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZm ZmZmZjgwM2Q3MzQwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZm ZjgwM2Q3MzkwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgw M2NhOGI4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q3 NWMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q3NWEw KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q4MzMwKS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q4M2MwKS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q4ZjAwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q5OGQ4KS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q5YmEwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q5YmYwKS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q5YzYwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NhOGQ4KS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Q5ZDkwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx YjFkZTgoMHhmZmZmZmZmZjgwM2Q5ZDcwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFk ZTgoMHhmZmZmZmZmZjgwM2RhOTMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgo MHhmZmZmZmZmZjgwM2RhZWQwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhm ZmZmZmZmZjgwM2RhZjg4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZm ZmZmZjgwM2RhZjY4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZm ZjgwM2RhZjQ4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgw M2RhZjIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Nh Y2MwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RiM2Iw KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RiNDAwKS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RiNmIwKS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NhZDYwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MwYjkwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NiMGQwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NiMmUwKS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NiMzMwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MwZDEwKS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NiNGY4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx YjFkZTgoMHhmZmZmZmZmZjgwM2NiNzkwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFk ZTgoMHhmZmZmZmZmZjgwM2RjMzAwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgo MHhmZmZmZmZmZjgwM2RjYTUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhm ZmZmZmZmZjgwM2RkMDA4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZm ZmZmZjgwM2NjZjEwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZm ZjgwM2MxNGUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgw M2NjZjMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Rk MWE4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RkMWM4 KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RkMWU4KS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RkMjA4KS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RlNWYwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2RmMmMwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2UwMTUwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2UwN2I4KS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2UxYTMwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2UxYWQwKS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjFkZTgoMHhmZmZmZmZmZjgwM2UxYWIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx YjFkZTgoMHhmZmZmZmZmZjgwM2UxYTkwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFk ZTgoMHhmZmZmZmZmZjgwM2UxYTcwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgo MHhmZmZmZmZmZjgwM2UxYTUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhm ZmZmZmZmZjgwM2UyNzgwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZm ZmZmZjgwM2UyNzYwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZm ZjgwM2UyZDQwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgw M2UzMjk4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2Nk NTIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NkYTk4 KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2MxNjYwKS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2U1NTMwKS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NkNjEwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2NkNWYwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjFkZTgoMHhmZmZmZmZmZjgwM2VlNjgwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxOGI3YzAoMCkuLi4gZG9uZS4KICAgMHhmZmZmZmZmZjgwMzEwNmIwKDAp Li4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDMxMDkwOCgwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxZGFiMjAoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIDFhMDAwMDAKICAgMHhmZmZmZmZm ZjgwMzM4YTEwKDApLi4uIGRvbmUuCnN1YnN5c3RlbSAxYWMwMDAwCiAgIDB4ZmZmZmZmZmY4 MDFiNjhiOCgwKS4uLiBkb25lLgpzdWJzeXN0ZW0gMWIwMDAwMAogICAweGZmZmZmZmZmODAx YWQ0ZDAoMCkuLi4gZG9uZS4KICAgMHhmZmZmZmZmZjgwMTg0MmM4KDApLi4uIGRvbmUuCiAg IDB4ZmZmZmZmZmY4MDFiNzU2MCgweGZmZmZmZmZmODAzY2IwODApLi4uIGRvbmUuCiAgIDB4 ZmZmZmZmZmY4MDFiNzU2MCgweGZmZmZmZmZmODAzY2IwOTgpLi4uIGRvbmUuCiAgIDB4ZmZm ZmZmZmY4MDFiNzU2MCgweGZmZmZmZmZmODAzZGQxNzgpLi4uIGRvbmUuCiAgIDB4ZmZmZmZm ZmY4MDFjYTY0MCgweGZmZmZmZmZmODAzZDk4YjgpLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4 MDFiNzU2MCgweGZmZmZmZmZmODAzY2IwYjApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFi NzU2MCgweGZmZmZmZmZmODAzZDFlMTgpLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFkNmI1 MCgweGZmZmZmZmZmODAzYzBiODApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFiNzU2MCgw eGZmZmZmZmZmODAzZGQ1MjApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFiNzU2MCgweGZm ZmZmZmZmODAzYzE0YzgpLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFiNzU2MCgweGZmZmZm ZmZmODAzZDIxNDApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFiNzU2MCgweGZmZmZmZmZm ODAzZDllZTApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFiYzg1OCgwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2RlNjcwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2Q1MWQwKS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxY2E2NDAoMHhmZmZmZmZmZjgwM2RlZmYwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2QyZmE4KS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjc1NjAoMHhmZmZmZmZmZjgwM2JmMDU4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx ZDZiNTAoMHhmZmZmZmZmZjgwM2JlMjk4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1 NjAoMHhmZmZmZmZmZjgwM2NiNDAwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxZDZiNTAo MHhmZmZmZmZmZjgwM2Q2YTk4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxZDZiNTAoMHhm ZmZmZmZmZjgwM2RiMzkwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZm ZmZmZjgwM2MxMWM4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZm ZjgwM2NiNzY4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxZDZiNTAoMHhmZmZmZmZmZjgw M2NhMTMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2Q2 ZjMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxY2E2NDAoMHhmZmZmZmZmZjgwM2RiODY4 KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2Q3MWU4KS4u LiBkb25lLgogICAweGZmZmZmZmZmODAxZDZiNTAoMHhmZmZmZmZmZjgwM2MxMWUwKS4uLiBk b25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2QzZTg4KS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxZDZiNTAoMHhmZmZmZmZmZjgwM2NjZWIwKS4uLiBkb25lLgog ICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2UzNWMwKS4uLiBkb25lLgogICAw eGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2Q3ODc4KS4uLiBkb25lLgogICAweGZm ZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2Q3ODkwKS4uLiBkb25lLgogICAweGZmZmZm ZmZmODAxYjc1NjAoMHhmZmZmZmZmZjgwM2QwN2Y4KS4uLiBkb25lLgogICAweGZmZmZmZmZm ODAxYjc1NjAoMHhmZmZmZmZmZjgwM2RiZjMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAx Yjc1NjAoMHhmZmZmZmZmZjgwM2U1NGUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1 NjAoMHhmZmZmZmZmZjgwM2RjMTM4KS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAo MHhmZmZmZmZmZjgwM2NjZWMwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhm ZmZmZmZmZjgwM2MxMWYwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZm ZmZmZjgwM2VlMmUwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAxYjc1NjAoMHhmZmZmZmZm ZjgwM2RjNWIwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAyOTY0ZjAoMCkuLi4gZG9uZS4K ICAgMHhmZmZmZmZmZjgwMzY1ODc4KDApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDIwZmYx MCgwKS4uLiBkb25lLgogICAweGZmZmZmZmZmODAyMjY1ZTAoMCkuLi4gZG9uZS4KICAgMHhm ZmZmZmZmZjgwMWI5Zjg4KDApLi4uIGRvbmUuCnN1YnN5c3RlbSAxYzAwMDAwCiAgIDB4ZmZm ZmZmZmY4MDIwY2RiMCgwKS4uLiBkb25lLgpzdWJzeXN0ZW0gMWMwMDAwMQogICAweGZmZmZm ZmZmODAxZTVjNjgoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIDIwMDAwMDAKICAgMHhmZmZmZmZm ZjgwMWI1MTI4KDApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDIxMmY3MCgwKS4uLiBkb25l LgogICAweGZmZmZmZmZmODAxYTU3ODgoMCkuLi4gZG9uZS4KICAgMHhmZmZmZmZmZjgwMzcw NWIwKDApLi4uIGRvbmUuCiAgIDB4ZmZmZmZmZmY4MDFmYTY1MCgwKS4uLiBkb25lLgogICBs aW5rZXJfZmlsZV91bmxvYWQoMCkuLi4gZG9uZS4KICAgc3lzY3RsX2RwY3B1X2ludCgwKS4u LiBkb25lLgogICBzeXNjdGxfZHBjcHVfaW50KDApLi4uIGRvbmUuCiAgIHN5c2N0bF9kcGNw dV9pbnQoMCkuLi4gZG9uZS4KICAgY3B1c2V0X3JlZigwKS4uLiBkb25lLgogICBhY2NlcHRf ZmlsdF9nZW5lcmljX21vZF9ldmVudCgwKS4uLiBkb25lLgogICBhY2NlcHRfZmlsdF9nZW5l cmljX21vZF9ldmVudCgwKS4uLiBkb25lLgogICBhY2NlcHRfZmlsdF9nZW5lcmljX21vZF9l dmVudCgwKS4uLiBkb25lLgogICBhY2NlcHRfZmlsdF9nZW5lcmljX21vZF9ldmVudCgwKS4u LiBkb25lLgogICBwcmlzb25fZW5mb3JjZV9zdGF0ZnMoMCkuLi4gZG9uZS4KICAgcG93ZXJf cG1fc3VzcGVuZCgwKS4uLiBkb25lLgogICBwYXJnc19ob2xkKDApLi4uIGRvbmUuCiAgIGRi X2NvbW1hbmRfcmVnaXN0ZXIoMCkuLi4gZG9uZS4KICAgcm1hbl9hY3RpdmF0ZV9yZXNvdXJj ZSgwKS4uLiBkb25lLgogICBybWFuX2FjdGl2YXRlX3Jlc291cmNlKDApLi4uIGRvbmUuCiAg IHJtYW5fYWN0aXZhdGVfcmVzb3VyY2UoMCkuLi4gZG9uZS4KICAgZmdldG93bigwKS4uLiBk b25lLgogICBhY2NlcHQoMCkuLi4gZG9uZS4KICAgZmdldG93bigwKS4uLiBkb25lLgogICBy dW5uaW5nYnVmd2FrZXVwKDApLi4uIGRvbmUuCiAgIHJ1bm5pbmdidWZ3YWtldXAoMCkuLi4g ZG9uZS4KICAgcnVubmluZ2J1Zndha2V1cCgwKS4uLiBkb25lLgogICBjb25maWdfaW50cmhv b2tfZXN0YWJsaXNoKDApLi4uIGRvbmUuCiAgIGdfZXJyb3JfcHJvdmlkZXIoMCkuLi4gZG9u ZS4KICAgc29fc290b3RjcGNiKDApLi4uIGRvbmUuCiAgIHNnbGlzdF9hcHBlbmRfdXNlcigw KS4uLiBkb25lLgogICBzZ2xpc3RfYXBwZW5kX3VzZXIoMCkuLi4gZG9uZS4KICAgZ19lcnJv cl9wcm92aWRlcigwKS4uLiBkb25lLgogICBkYl9jbGVhcl93YXRjaHBvaW50cygwKS4uLiBk b25lLgogICBsaW5rZXJfZmlsZV9sb29rdXBfc2V0KDApLi4uIGRvbmUuCiAgIHV0cmFjZSgw KS4uLiBkb25lLgogICB0Y3BfdHdfaW5pdCgwKS4uLiBkb25lLgogICBkYl9zaG93X3JlZ3Mo MCkuLi4gZG9uZS4KICAgaW5pdF90dXJuc3RpbGVzKDApLi4uIGRvbmUuCiAgIGluaXRfdHVy bnN0aWxlcygwKS4uLiBkb25lLgogICBzcGVlZHVwX3N5bmNlcigwKS4uLiBkb25lLgogICBz cGVlZHVwX3N5bmNlcigwKS4uLiBkb25lLgogICBzcGVlZHVwX3N5bmNlcigwKS4uLiBkb25l LgogICBpbml0X3R1cm5zdGlsZXMoMCkuLi4gZG9uZS4KICAgaW5pdF90dXJuc3RpbGVzKDAp Li4uIGRvbmUuCiAgIGluaXRfdHVybnN0aWxlcygwKS4uLiBkb25lLgogICBpZl9zdGFydCgw KS4uLiBkb25lLgogICBpZl9zdGFydCgwKS4uLiBkb25lLgogICB1bWFfZmluZF9yZWZjbnQo MCkuLi4gZG9uZS4KICAgaW5pdF90dXJuc3RpbGVzKDApLi4uIGRvbmUuCiAgIGZvcmsoMCku Li4gZG9uZS4KICAgZm9yaygwKS4uLiBkb25lLgogICBkYl9zaG93X3JlZ3MoMCkuLi4gZG9u ZS4KICAgdm1fbWFwX2xvY2tlZCgwKS4uLiBkb25lLgogICB2bV9tYXBfbG9ja2VkKDApLi4u IGRvbmUuCiAgIG1hbGxvY19sYXN0X2ZhaWwoMCkuLi4gZG9uZS4KICAgbXVubG9ja2FsbCgw KS4uLiBkb25lLgogICBtdW5sb2NrYWxsKDApLi4uIGRvbmUuCiAgIG11bmxvY2thbGwoMCku Li4gZG9uZS4KICAgdm1fcGFnZV9zcGxheSgwKS4uLiBkb25lLgogICB2bV9wYWdlX3NwbGF5 KDApLi4uIGRvbmUuCiAgIGtvYmpfY3JlYXRlKDApLi4uIGRvbmUuCiAgIGRiX3Nob3dfcmVn cygwKS4uLiBkb25lLgogICB0dHlfcmVsX3Nlc3MoMCkuLi4gZG9uZS4KICAgdm1fcGh5c19z ZXRfcG9vbCgwKS4uLiBkb25lLgogICBsb291dHB1dCgwKS4uLiBkb25lLgogICBjcHVfc2V0 X3VzZXJfdGxzKDApLi4uIGRvbmUuCiAgIGNwdV9zZXRfdXNlcl90bHMoMCkuLi4gZG9uZS4K ICAgdGxiX3NhdmUoMCkuLi4gZG9uZS4KICAgbG9vdXRwdXQoMCkuLi4gZG9uZS4KICAgbG9v dXRwdXQoMCkuLi4gZG9uZS4KICAgdHR5X3JlbF9zZXNzKDApLi4uIGRvbmUuCiAgIHN5c2N0 bF9kcGNwdV9pbnQoMCkuLi4gZG9uZS4KICAgbmV0aXNyX2dldHFkcm9wcygwKS4uLiBkb25l LgpzdWJzeXN0ZW0gMjEwMDAwMAogICBkdW1wc3lzKDApLi4uIHJlYWwgbWVtb3J5ICA9IDMz NTU0NDMyICgzMjc2OEsgYnl0ZXMpClBoeXNpY2FsIG1lbW9yeSBjaHVuayhzKToKMHgwNDA4 YzAwMCAtIDB4MDVlZTNmZmYsIDMxODE3NzI4IGJ5dGVzICg3NzY4IHBhZ2VzKQphdmFpbCBt ZW1vcnkgPSAzMTE4Njk0NCAoMjlNQikKZG9uZS4Kc3Vic3lzdGVtIDIxMjAwMDAKICAgZXhl Y19zaGVsbF9pbWdhY3QoMCkuLi4gZG9uZS4KICAgc2NoZWRpbml0KDApLi4uIGRvbmUuCnN1 YnN5c3RlbSAyMjAwMDAwCiAgIHN5c2luaXRfYWRkKDApLi4uIGRvbmUuCiAgIHNlbWFfaW5p dCgwKS4uLiBkb25lLgpzdWJzeXN0ZW0gMjMwMDAwMAogICB1bWFfem9uZV9leGhhdXN0ZWRf bm9sb2NrKDApLi4uIGRvbmUuCnN1YnN5c3RlbSAyMzgwMDAwCiAgIGRiX2NhcHR1cmVfZXhp dHBhZ2VyKDApLi4uIGRvbmUuCnN1YnN5c3RlbSAyNDAwMDAwCiAgIHNjaGVkaW5pdCgwKS4u LiBkb25lLgpzdWJzeXN0ZW0gMjUwMDAwMAogICBleGVjX3NoZWxsX2ltZ2FjdCgwKS4uLiBk b25lLgpzdWJzeXN0ZW0gMjYwMDAwMAogICBmb3JrKDApLi4uIGRvbmUuCnN1YnN5c3RlbSAy NzAwMDAwCiAgIG1fcGt0aGRyX2luaXQoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIDI4MDAwMDEK ICAgc3dpX2FkZCgwKS4uLiBkb25lLgogICBuZXRpc3JfZ2V0X2NwdWlkKDApLi4uIGRvbmUu CiAgIGNhbGxvdXRfaGFuZGxlX2luaXQoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIDJmMDAwMDAK ICAgdWFydF90dHlfaW50cigwKS4uLiBkb25lLgogICBkZXZ0b25hbWUoMCkuLi4gZG9uZS4K c3Vic3lzdGVtIDMwMDAwMDAKICAgaWZfc3RhcnQoMCkuLi4gZG9uZS4KICAgaWZfc3RhcnQo MCkuLi4gZG9uZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhmZmZmZmZmZjgwM2RiNTU4 KS4uLiBkb25lLgpzdWJzeXN0ZW0gMzEwMDAwMAogICB0dHlvdXRxX2ZsdXNoKDApLi4uIGRv bmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZmZmZmZmY4MDNlMzFmMCkuLi4gZG9u ZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhmZmZmZmZmZjgwM2MyNDEwKS4uLiBkb25l LgogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAzYzI3NDgpLi4uIGRvbmUu CiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZmZmZmZmY4MDNjMWM1OCkuLi4gZG9uZS4K ICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhmZmZmZmZmZjgwM2MxZGEwKS4uLiBkb25lLgog ICB0dHlfY2hlY2tvdXRxKDApLi4uIGRvbmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4 ZmZmZmZmZmY4MDNkMzRjOCkuLi4gZG9uZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhm ZmZmZmZmZjgwM2JmNzg4KS4uLiBkb25lLgogICB0dHlpbnFfcmVwcmludHBvc19yZXNldCgw KS4uLiBkb25lLgogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAzYmZiZDgp Li4uIG51bGw6IDxudWxsIGRldmljZSwgemVybyBkZXZpY2U+CmRvbmUuCiAgIGZnZXRvd24o MCkuLi4gZG9uZS4KICAgc3lzYmVlcCgwKS4uLiBkb25lLgogICBtb2R1bGVfcmVnaXN0ZXJf aW5pdCgweGZmZmZmZmZmODAzZWMwOTgpLi4uIGRvbmUuCiAgIHR0eW91dHFfcmVhZF91aW8o MCkuLi4gZG9uZS4KICAgZGJfd3JpdGVfY21kKDApLi4uIGRvbmUuCiAgIHBvc2l4X29wZW5w dCgwKS4uLiBkb25lLgogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAzYzA1 ZjApLi4uIGRvbmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZmZmZmZmY4MDNiZjhk MCkuLi4gbWVtOiA8bWVtb3J5Pgpkb25lLgogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZm ZmZmZmZmODAzY2E2ZDgpLi4uIGRvbmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZm ZmZmZmY4MDNlZTcxOCkuLi4gZG9uZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhmZmZm ZmZmZjgwM2UyOTIwKS4uLiBuZnNsb2NrOiBwc2V1ZG8tZGV2aWNlCmRvbmUuCiAgIGxvY2tf aW5pdCgwKS4uLiBkb25lLgogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAz ZWVhMzgpLi4uIGRvbmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZmZmZmZmY4MDNl ZWJkOCkuLi4gZG9uZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhmZmZmZmZmZjgwM2My YWYwKS4uLiBkb25lLgogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAzYzJj YjApLi4uIGRvbmUuCnN1YnN5c3RlbSAzODAwMDAwCiAgIGdldF9pbnRyX21hc2soMCkuLi4g ZG9uZS4KICAgdGFza3F1ZXVlX2NyZWF0ZV9mYXN0KDApLi4uIGRvbmUuCiAgIHRhc2txdWV1 ZV9zdGFydF90aHJlYWRzKDApLi4uIGRvbmUuCiAgIHRhc2txdWV1ZV9jcmVhdGUoMCkuLi4g ZG9uZS4KICAgdGFza3F1ZXVlX2NyZWF0ZSgwKS4uLiBkb25lLgogICBrbmxpc3RfaW5pdF9t dHgoMCkuLi4gZG9uZS4KICAgZ2V0X2ludHJfbWFzaygwKS4uLiBuZXh1czA6IDxNSVBTMzIg cm9vdCBuZXh1cz4KY2xvY2swOiA8R2VuZXJpYyBNSVBTMzIgdGlja2VyPiBvbiBuZXh1czAK Y2xvY2swOiBbRklMVEVSXQpkb25lLgogICB2ZnNfdW5peGlmeV9hY2Ntb2RlKDApLi4uIGRv bmUuCiAgIGdldF9pbnRyX21hc2soMCkuLi4gRGV2aWNlIGNvbmZpZ3VyYXRpb24gZmluaXNo ZWQuCmRvbmUuCnN1YnN5c3RlbSA0MDAwMDAwCiAgIHNwZWVkdXBfc3luY2VyKDApLi4uIGRv bmUuCiAgIHZmc19ieW5hbWVfa2xkKDApLi4uIGRvbmUuCiAgIGV4dGF0dHJfZGVsZXRlX2Zk KDApLi4uIGRvbmUuCiAgIGJyZWFkKDApLi4uIGRvbmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9p bml0KDB4ZmZmZmZmZmY4MDNlMjBjMCkuLi4gZG9uZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2lu aXQoMHhmZmZmZmZmZjgwM2MwYzI4KS4uLiBkb25lLgogICB3cml0ZSgwKS4uLiBkb25lLgog ICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAzZTE2NzApLi4uIGRvbmUuCiAg IG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZmZmZmZmY4MDNlMmQxOCkuLi4gZG9uZS4KICAg c3BlZWR1cF9zeW5jZXIoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIDQ4MDAwMDAKICAgdHZ0b2h6 KDApLi4uIFRpbWVjb3VudGVyICJNSVBTMzIiIGZyZXF1ZW5jeSA0MDAwMDAwMDAgSHogcXVh bGl0eSA4MDAKZG9uZS4KICAgY3B1dGljazJ1c2VjKDApLi4uIFRpbWVjb3VudGVycyB0aWNr IGV2ZXJ5IDEwLjAwMCBtc2VjCmRvbmUuCiAgIG50cF91cGRhdGVfc2Vjb25kKDApLi4uIGRv bmUuCnN1YnN5c3RlbSA2NDAwMDAwCiAgIG1fcHVsbGRvd24oMCkuLi4gZG9uZS4Kc3Vic3lz dGVtIDZlMDAwMDAKICAgTUQ1RmluYWwoMCkuLi4gZG9uZS4KICAga2Vybl9zaWdhbHRzdGFj aygwKS4uLiBkb25lLgogICByZWdpc3Rlcl9wb3NpeF9jbG9jaygwKS4uLiBkb25lLgogICBw MzFiX2lzY2ZnKDApLi4uIGRvbmUuCnN1YnN5c3RlbSA3MDAwMDAwCiAgIGxvb3V0cHV0KDAp Li4uIGRvbmUuCiAgIGFycHJlc29sdmUoMCkuLi4gZG9uZS4KICAgYXJwcmVzb2x2ZSgwKS4u LiBkb25lLgogICBrbmxpc3RfaW5pdF9tdHgoMCkuLi4gZG9uZS4KICAgbW9kdWxlX3JlZ2lz dGVyX2luaXQoMHhmZmZmZmZmZjgwM2RjZjM4KS4uLiBkb25lLgpzdWJzeXN0ZW0gNzQwMDAw MAogICBtb2R1bGVfcmVnaXN0ZXJfaW5pdCgweGZmZmZmZmZmODAzYzE2MzgpLi4uIGRvbmUu CiAgIGVsZjY0X2luc2VydF9icmFuZF9lbnRyeSgweGZmZmZmZmZmODAzZWMyYTApLi4uIGRv bmUuCiAgIG1vZHVsZV9yZWdpc3Rlcl9pbml0KDB4ZmZmZmZmZmY4MDNjMzRmOCkuLi4gZG9u ZS4KICAgbW9kdWxlX3JlZ2lzdGVyX2luaXQoMHhmZmZmZmZmZjgwM2MzNDY4KS4uLiBkb25l LgpzdWJzeXN0ZW0gODAwMDAwMAogICBuZXRpc3JfcmVnaXN0ZXIoMCkuLi4gZG9uZS4Kc3Vi c3lzdGVtIDg2MDAwMDAKICAgcGZfcHJvdG9fdW5yZWdpc3RlcigwKS4uLiBkb25lLgpzdWJz eXN0ZW0gODgwMDAwMAogICBkb21haW5fYWRkKDB4ZmZmZmZmZmY4MDNkZTIxOCkuLi4gZG9u ZS4KICAgZG9tYWluX2FkZCgweGZmZmZmZmZmODAzZGM1NDApLi4uIGRvbmUuCiAgIGRvbWFp bl9hZGQoMHhmZmZmZmZmZjgwM2Q3OWEwKS4uLiBkb25lLgogICBkb21haW5faW5pdCgweGZm ZmZmZmZmODAzZDc5YTApLi4uIGRvbmUuCiAgIGRvbWFpbl9pbml0KDB4ZmZmZmZmZmY4MDNk YzU0MCkuLi4gZG9uZS4KICAgZG9tYWluX2luaXQoMHhmZmZmZmZmZjgwM2RlMjE4KS4uLiBk b25lLgogICBydGlvY3RsKDApLi4uIGRvbmUuCiAgIHJ0aW5pdCgwKS4uLiBkb25lLgogICBy dGlvY3RsKDApLi4uIGRvbmUuCiAgIHJ0X21pc3Ntc2coMCkuLi4gZG9uZS4Kc3Vic3lzdGVt IDg4MDAwMDEKICAgcGZfcHJvdG9fdW5yZWdpc3RlcigwKS4uLiBkb25lLgogICBpZl9zdGFy dCgwKS4uLiBkb25lLgogICBsb2lvY3RsKDApLi4uIGRvbmUuCiAgIG1vZHVsZV9yZWdpc3Rl cl9pbml0KDB4ZmZmZmZmZmY4MDNkYjY4MCkuLi4gZG9uZS4Kc3Vic3lzdGVtIGEwMDAwMDAK ICAgX3N4X3RyeV9zbG9jaygwKS4uLiBkb25lLgpzdWJzeXN0ZW0gYTgwMDAwMAogICB2YWNj ZXNzX2FjbF9wb3NpeDFlKDApLi4uIGRvbmUuCnN1YnN5c3RlbSBiMDAwMDAwCiAgIG5mc19z ZXR1cF9kaXNrbGVzcygwKS4uLiBkb25lLgpzdWJzeXN0ZW0gZDAwMDAwMAogICBleGVjX3No ZWxsX2ltZ2FjdCgwKS4uLiBkb25lLgpzdWJzeXN0ZW0gZDgwMDAwMAogICBwb2xsX25vX3Bv bGwoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIGUwMDAwMDAKICAgZXhlY19zaGVsbF9pbWdhY3Qo MCkuLi4gZG9uZS4KICAgdm1fZmF1bHRfd2lyZSgwKS4uLiBkb25lLgpzdWJzeXN0ZW0gZTQw MDAwMAogICBrcHJvY19zdGFydCgweGZmZmZmZmZmODAzZTU1MTApLi4uIGRvbmUuCnN1YnN5 c3RlbSBlODAwMDAwCiAgIGtwcm9jX3N0YXJ0KDB4ZmZmZmZmZmY4MDNlNTRmOCkuLi4gZG9u ZS4KICAgb2JyZWFrKDApLi4uIGRvbmUuCnN1YnN5c3RlbSBlYTAwMDAwCiAgIGtwcm9jX3N0 YXJ0KDB4ZmZmZmZmZmY4MDNkOGVlMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIGVjMDAwMDAKICAg a3Byb2Nfc3RhcnQoMHhmZmZmZmZmZjgwM2RhOTAwKS4uLiBkb25lLgogICBrcHJvY19zdGFy dCgweGZmZmZmZmZmODAzZGE5MTgpLi4uIGRvbmUuCnN1YnN5c3RlbSBlZTAwMDAwCiAgIG5m c19uZnNpb2RuZXcoMCkuLi4gZG9uZS4Kc3Vic3lzdGVtIGYwMDAwMDAKICAgbmV0aXNyX2dl dF9jcHVpZCgwKS4uLiBkb25lLgogICBjcHVzZXRfcmVmKDApLi4uIGRvbmUuCnN1YnN5c3Rl bSBmZmZmZmZmCiAgIGtwcm9jX3N0YXJ0KDB4ZmZmZmZmZmY4MDNkMmU1OCkuLi4gZG9uZS4K ICAgbnRwX3VwZGF0ZV9zZWNvbmQoMCkuLi4gZG9uZS4KICAgZmF1bHRpbigwKS4uLiBMb2Fk ZXIgdmFyaWFibGVzOgp2ZnMucm9vdC5tb3VudGZyb209CnZmcy5yb290Lm1vdW50ZnJvbS5v cHRpb25zPQoKTWFudWFsIHJvb3QgZmlsZXN5c3RlbSBzcGVjaWZpY2F0aW9uOgogIDxmc3R5 cGU+OjxkZXZpY2U+ICBNb3VudCA8ZGV2aWNlPiB1c2luZyBmaWxlc3lzdGVtIDxmc3R5cGU+ CiAgICAgICAgICAgICAgICAgICAgICAgZWcuIHpmczp0YW5rCiAgICAgICAgICAgICAgICAg ICAgICAgZWcuIHVmczovZGV2L2RhMHMxYQogICAgICAgICAgICAgICAgICAgICAgIGVnLiBj ZDk2NjA6L2Rldi9hY2QwCiAgICAgICAgICAgICAgICAgICAgICAgVGhpcyBpcyBlcXVpdmFs ZW50IHRvOiBtb3VudCAtdCBjZDk2NjAgL2Rldi9hY2QwIC8KCiAgPyAgICAgICAgICAgICAg ICAgIExpc3QgdmFsaWQgZGlzayBib290IGRldmljZXMKICA8ZW1wdHkgbGluZT4gICAgICAg QWJvcnQgbWFudWFsIGlucHV0Cgptb3VudHJvb3Q+IHJlYm9vdApUcnlpbmcgdG8gbW91bnQg cm9vdCBmcm9tIHJlYm9vdApST09UIE1PVU5UIEVSUk9SOiAKSWYgeW91IGhhdmUgaW52YWxp ZCBtb3VudCBvcHRpb25zLCByZWJvb3QsIGFuZCBmaXJzdCB0cnkgdGhlIGZvbGxvd2luZyBm cm9tCnRoZSBsb2FkZXIgcHJvbXB0OgoKICAgICBzZXQgdmZzLnJvb3QubW91bnRmcm9tLm9w dGlvbnM9cncKCmFuZCB0aGVuIHJlbW92ZSBpbnZhbGlkIG1vdW50IG9wdGlvbnMgZnJvbSAv ZXRjL2ZzdGFiLgoKTG9hZGVyIHZhcmlhYmxlczoKdmZzLnJvb3QubW91bnRmcm9tPQp2ZnMu cm9vdC5tb3VudGZyb20ub3B0aW9ucz0KCk1hbnVhbCByb290IGZpbGVzeXN0ZW0gc3BlY2lm aWNhdGlvbjoKICA8ZnN0eXBlPjo8ZGV2aWNlPiAgTW91bnQgPGRldmljZT4gdXNpbmcgZmls ZXN5c3RlbSA8ZnN0eXBlPgogICAgICAgICAgICAgICAgICAgICAgIGVnLiB6ZnM6dGFuawog ICAgICAgICAgICAgICAgICAgICAgIGVnLiB1ZnM6L2Rldi9kYTBzMWEKICAgICAgICAgICAg ICAgICAgICAgICBlZy4gY2Q5NjYwOi9kZXYvYWNkMAogICAgICAgICAgICAgICAgICAgICAg IFRoaXMgaXMgZXF1aXZhbGVudCB0bzogbW91bnQgLXQgY2Q5NjYwIC9kZXYvYWNkMCAvCgog ID8gICAgICAgICAgICAgICAgICBMaXN0IHZhbGlkIGRpc2sgYm9vdCBkZXZpY2VzCiAgPGVt cHR5IGxpbmU+ICAgICAgIEFib3J0IG1hbnVhbCBpbnB1dAoKbW91bnRyb290PiAKcGFuaWM6 IFJvb3QgbW91bnQgZmFpbGVkLCBzdGFydHVwIGFib3J0ZWQuCktEQjogZW50ZXI6IHBhbmlj ClsgdGhyZWFkIHBpZCAxIHRpZCAxMDAwMDEgXQpTdG9wcGVkIGF0ICAgICAga2RiX2VudGVy KzB4OTA6IGx1aSAgICAgYXQsMHgwCmRiPiByZWJvb3QK --------------010000070606020606040007-- --------------enigB6D73304FB66E55E023B2942 Content-Type: application/pgp-signature; name="signature.asc" Content-Description: OpenPGP digital signature Content-Disposition: attachment; filename="signature.asc" -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.10 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iF4EAREKAAYFAkwX7ZIACgkQNak7dOguQgmKfwD7ByVsNRwQ3it0c9m93zbyoiYk Kp/u+eyRJsCqsSkxsywBAIZr7v0cF+c8SVtmdbFtkCFsrgSue2qqY3npXIY1WPj5 =GkuA -----END PGP SIGNATURE----- --------------enigB6D73304FB66E55E023B2942-- From owner-freebsd-mips@FreeBSD.ORG Tue Jun 15 21:26:17 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 6313A1065670 for ; Tue, 15 Jun 2010 21:26:17 +0000 (UTC) (envelope-from juli@clockworksquid.com) Received: from mail-vw0-f54.google.com (mail-vw0-f54.google.com [209.85.212.54]) by mx1.freebsd.org (Postfix) with ESMTP id 210B28FC0C for ; Tue, 15 Jun 2010 21:26:16 +0000 (UTC) Received: by vws20 with SMTP id 20so7434037vws.13 for ; Tue, 15 Jun 2010 14:26:16 -0700 (PDT) Received: by 10.220.63.7 with SMTP id z7mr4324026vch.106.1276637176143; Tue, 15 Jun 2010 14:26:16 -0700 (PDT) MIME-Version: 1.0 Sender: juli@clockworksquid.com Received: by 10.220.191.67 with HTTP; Tue, 15 Jun 2010 14:25:56 -0700 (PDT) In-Reply-To: <3F1E3AAE-72B4-4323-9AC3-147066AF50E6@lakerest.net> References: <20100615.075142.716508926086259279.imp@bsdimp.com> <3F1E3AAE-72B4-4323-9AC3-147066AF50E6@lakerest.net> From: Juli Mallett Date: Tue, 15 Jun 2010 14:25:56 -0700 X-Google-Sender-Auth: yJkhseOZi-dOc4-4nxXKJjIQCH4 Message-ID: To: Randall Stewart Content-Type: text/plain; charset=ISO-8859-1 Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 15 Jun 2010 21:26:17 -0000 On Tue, Jun 15, 2010 at 07:02, Randall Stewart wrote: > Do we want to make sure that the changes > work on a couple of other platforms (sibyte etc)? I've used the original source of these changes extensively on an SMP SiByte system and Octeon. I think as long as we continue to do commits in small chunks, that level of testing is probably alright, since it's not so hard to binary search (and I'm willing to binary search on any hardware I have or can easily get.) Thanks, Juli. From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 15:38:49 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id D18C9106564A; Thu, 17 Jun 2010 15:38:49 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-qy0-f182.google.com (mail-qy0-f182.google.com [209.85.216.182]) by mx1.freebsd.org (Postfix) with ESMTP id 4FFA08FC15; Thu, 17 Jun 2010 15:38:49 +0000 (UTC) Received: by qyk11 with SMTP id 11so1710969qyk.13 for ; Thu, 17 Jun 2010 08:38:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:date:message-id :subject:from:to:content-type; bh=ofzBbCeLScwIHncTBcjABRdxR+UZRlOOX8blPbNGL9k=; b=EMcu8e13JPHoRPVfmqzlI3NVrz2RV1+KGOWZJzQGeQLrKCz67IkXVaMtTojYCpYtCN n0+Oj6GsKhycIytrwSSAQM5cqmMsD25lCT8NQHE3njuPC0fquulvBTP6zxNViJtshxIZ AsgcNV6i2hQe0irVlppXckk6P9r69+m5wK7Fg= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:date:message-id:subject:from:to:content-type; b=LnAhsAcTZbPoFiXYKx87bWLJN0qQ7EIpaX0nmmPfS8NF/68P2X99omWECGEbPX9QWY 3sDnwz47wL8Lg5YF/ybFTSzz7UTP7lLFZ/xO0KDwlUeKMHv+/TWpgVg3nQgne9wYcyW9 Qc30mpxO5N5vURg0s82ZkC3+NCN48Grpk2HRs= MIME-Version: 1.0 Received: by 10.224.19.100 with SMTP id z36mr5544433qaa.84.1276789120386; Thu, 17 Jun 2010 08:38:40 -0700 (PDT) Received: by 10.224.37.139 with HTTP; Thu, 17 Jun 2010 08:38:40 -0700 (PDT) Date: Thu, 17 Jun 2010 21:08:40 +0530 Message-ID: From: "Jayachandran C." To: Randall Stewart , Juli Mallett , "M. Warner Losh" , freebsd-mips@freebsd.org Content-Type: multipart/mixed; boundary=00c09f8e5b59fa198104893ba12e Cc: Subject: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 15:38:50 -0000 --00c09f8e5b59fa198104893ba12e Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. wrote: > I have volunteered to merge Juli's 64-bit work into HEAD, =A0and > hopefully get it to work on XLR too. The tree > (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of > changes, so I would like to do this over multiple changesets and > without breaking the current o32 code. Here's part 2, containing two patches: pmap-PTE-to-PG.patch : This is a renaming patch with minor cleanup, The PTE_* flags are renamed to PG_ and related changes are made to other files. I have tried to make this patch limited to just the renaming and the changes related to it. I will make another patch for the rest of the minor changes in pmap.c. My comment on this patch: The name PG_C_CNC for value 3 in pte.h may be confusing, at least on XLR. We don't have cached non-coherent mode, the cached memory is coherent(except L1 I-cache), so I would prefer PG_CACHED and PG_UNCACHED names. pmap-lgmem-lock-remove.patch : Remove the lock in local_sysmaps, and sched_pin()/unpin() in the PMAP_LMEM_ macros. The 64-bit support changes would be next - comments on the patches esp. the first one is welcome. Thanks, JC. --00c09f8e5b59fa198104893ba12e Content-Type: text/x-patch; charset=US-ASCII; name="pmap-PTE-to-PG.patch" Content-Disposition: attachment; filename="pmap-PTE-to-PG.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gajrc9j94 SW5kZXg6IHN5cy9taXBzL2luY2x1ZGUvdm0uaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBzeXMvbWlwcy9pbmNs dWRlL3ZtLmgJKHJldmlzaW9uIDIwOTI0MykKKysrIHN5cy9taXBzL2luY2x1ZGUvdm0uaAkod29y a2luZyBjb3B5KQpAQCAtMzIsOCArMzIsOCBAQAogI2luY2x1ZGUgPG1hY2hpbmUvcHRlLmg+CiAK IC8qIE1lbW9yeSBhdHRyaWJ1dGVzLiAqLwotI2RlZmluZQlWTV9NRU1BVFRSX1VOQ0FDSEVECQkJ KCh2bV9tZW1hdHRyX3QpUFRFX1VOQ0FDSEVEKQotI2RlZmluZQlWTV9NRU1BVFRSX0NBQ0hFQUJM RV9OT05DT0hFUkVOVAkoKHZtX21lbWF0dHJfdClQVEVfQ0FDSEUpCisjZGVmaW5lCVZNX01FTUFU VFJfVU5DQUNIRUQJCQkoKHZtX21lbWF0dHJfdClQR19DX1VDKQorI2RlZmluZQlWTV9NRU1BVFRS X0NBQ0hFQUJMRV9OT05DT0hFUkVOVAkoKHZtX21lbWF0dHJfdClQR19DX0NOQykKIAogI2RlZmlu ZQlWTV9NRU1BVFRSX0RFRkFVTFQJCVZNX01FTUFUVFJfQ0FDSEVBQkxFX05PTkNPSEVSRU5UCiAK SW5kZXg6IHN5cy9taXBzL2luY2x1ZGUvcHRlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMvaW5j bHVkZS9wdGUuaAkocmV2aXNpb24gMjA5MjQzKQorKysgc3lzL21pcHMvaW5jbHVkZS9wdGUuaAko d29ya2luZyBjb3B5KQpAQCAtNjMsNyArNjMsNyBAQAogI2RlZmluZQlUTEJMT19QRk5fVE9fUEEo cGZuKQkoKHZtX3BhZGRyX3QpKChwZm4pID4+IFRMQkxPX1BGTl9TSElGVCkgPDwgVExCX1BBR0Vf U0hJRlQpCiAjZGVmaW5lCVRMQkxPX1BURV9UT19QRk4ocHRlKQkoKHB0ZSkgJiBUTEJMT19QRk5f TUFTSykKICNkZWZpbmUJVExCTE9fUFRFX1RPX1BBKHB0ZSkJKFRMQkxPX1BGTl9UT19QQShUTEJM T19QVEVfVE9fUEZOKChwdGUpKSkpCi0gIAorCiAvKgogICogVlBOIGZvciBFbnRyeUhpIHJlZ2lz dGVyLiAgVXBwZXIgdHdvIGJpdHMgc2VsZWN0IHVzZXIsIHN1cGVydmlzb3IsCiAgKiBvciBrZXJu ZWwuICBCaXRzIDYxIHRvIDQwIGNvcHkgYml0IDYzLiAgVlBOMiBpcyBiaXRzIDM5IGFuZCBkb3du IHRvCkBAIC03Niw1NCArNzYsNDkgQEAKICNkZWZpbmUJVExCSElfRU5UUlkodmEsIGFzaWQpCSgo KHZhKSAmIH5QQUdFX01BU0spIHwgKChhc2lkKSAmIFRMQkhJX0FTSURfTUFTSykpCiAKICNpZm5k ZWYgX0xPQ09SRQotdHlwZWRlZiB1bnNpZ25lZCBpbnQgcHRfZW50cnlfdDsKLXR5cGVkZWYgcHRf ZW50cnlfdCAqcGRfZW50cnlfdDsKK3R5cGVkZWYJdWludDMyX3QgcHRfZW50cnlfdDsKK3R5cGVk ZWYJcHRfZW50cnlfdCAqcGRfZW50cnlfdDsKICNlbmRpZgogCisKICNkZWZpbmUJUERFU0laRQkJ c2l6ZW9mKHBkX2VudHJ5X3QpCS8qIGZvciBhc3NlbWJseSBmaWxlcyAqLwogI2RlZmluZQlQVEVT SVpFCQlzaXplb2YocHRfZW50cnlfdCkJLyogZm9yIGFzc2VtYmx5IGZpbGVzICovCiAKLSNkZWZp bmUJUFRfRU5UUllfTlVMTAkoKHB0X2VudHJ5X3QgKikgMCkKKy8qCisgKiBUTEIgZmxhZ3MgbWFu YWdlZCBpbiBoYXJkd2FyZToKKyAqIAlDOglDYWNoZSBhdHRyaWJ1dGUuCisgKiAJRDoJRGlydHkg Yml0LiAgVGhpcyBtZWFucyBhIHBhZ2UgaXMgd3JpdGFibGUuICBJdCBpcyBub3QKKyAqIAkJc2V0 IGF0IGZpcnN0LCBhbmQgYSB3cml0ZSBpcyB0cmFwcGVkLCBhbmQgdGhlIGRpcnR5CisgKiAJCWJp dCBpcyBzZXQuICBTZWUgYWxzbyBQR19STy4KKyAqIAlWOglWYWxpZCBiaXQuICBPYnZpb3VzLCBp c24ndCBpdD8KKyAqIAlHOglHbG9iYWwgYml0LiAgVGhpcyBtZWFucyB0aGF0IHRoaXMgbWFwcGlu ZyBpcyBwcmVzZW50CisgKiAJCWluIEVWRVJZIGFkZHJlc3Mgc3BhY2UsIGFuZCB0byBpZ25vcmUg dGhlIEFTSUQgd2hlbgorICogCQlpdCBpcyBtYXRjaGVkLgorICovCisjZGVmaW5lCVBHX0MoYXR0 cikJKChhdHRyICYgMHgwNykgPDwgMykKKyNkZWZpbmUJUEdfQ19VQwkJKFBHX0MoMHgwMikpCisj ZGVmaW5lCVBHX0NfQ05DCShQR19DKDB4MDMpKQorI2RlZmluZQlQR19ECQkweDA0CisjZGVmaW5l CVBHX1YJCTB4MDIKKyNkZWZpbmUJUEdfRwkJMHgwMQogCi0jZGVmaW5lCVBURV9XSVJFRAkweDgw MDAwMDAwCS8qIFNXICovCi0jZGVmaW5lCVBURV9XCQlQVEVfV0lSRUQKLSNkZWZpbmUJUFRFX1JP CQkweDQwMDAwMDAwCS8qIFNXICovCisvKgorICogVk0gZmxhZ3MgbWFuYWdlZCBpbiBzb2Z0d2Fy ZToKKyAqIAlSTzoJUmVhZCBvbmx5LiAgTmV2ZXIgc2V0IFBHX0Qgb24gdGhpcyBwYWdlLCBhbmQg ZG9uJ3QKKyAqIAkJbGlzdGVuIHRvIHJlcXVlc3RzIHRvIHdyaXRlIHRvIGl0LgorICogCVc6CVdp cmVkLiAgPz8/CisgKi8KKyNkZWZpbmUJUEdfUk8JKDB4MDEgPDwgVExCTE9fU1dCSVRTX1NISUZU KQorI2RlZmluZQlQR19XCSgweDAyIDw8IFRMQkxPX1NXQklUU19TSElGVCkKIAotI2RlZmluZQlQ VEVfRwkJMHgwMDAwMDAwMQkvKiBIVyAqLwotI2RlZmluZQlQVEVfVgkJMHgwMDAwMDAwMgotLyoj ZGVmaW5lCVBURV9OVgkJMHgwMDAwMDAwMCAgICAgICBOb3QgVXNlZCAqLwotI2RlZmluZQlQVEVf TQkJMHgwMDAwMDAwNAotI2RlZmluZQlQVEVfUlcJCVBURV9NCi0jZGVmaW5lIFBURV9PRERQRyAg ICAgICAweDAwMDAxMDAwIAotLyojZGVmaW5lCVBHX0FUVFIJCTB4MDAwMDAwM2YgIE5vdCBVc2Vk ICovCi0jZGVmaW5lCVBURV9VTkNBQ0hFRAkweDAwMDAwMDEwCi0jaWZkZWYgQ1BVX1NCMQotI2Rl ZmluZQlQVEVfQ0FDSEUJMHgwMDAwMDAyOAkvKiBjYWNoZWFibGUgY29oZXJlbnQgKi8KLSNlbHNl Ci0jZGVmaW5lCVBURV9DQUNIRQkweDAwMDAwMDE4Ci0jZW5kaWYKLS8qI2RlZmluZQlQR19DQUNI RU1PREUJMHgwMDAwMDAzOCBOb3QgVXNlZCovCi0jZGVmaW5lCVBURV9ST1BBR0UJKFBURV9WIHwg UFRFX1JPIHwgUFRFX0NBQ0hFKSAvKiBXcml0ZSBwcm90ZWN0ZWQgKi8KLSNkZWZpbmUJUFRFX1JX UEFHRQkoUFRFX1YgfCBQVEVfTSB8IFBURV9DQUNIRSkgIC8qIE5vdCB3ci1wcm90IG5vdCBjbGVh biAqLwotI2RlZmluZQlQVEVfQ1dQQUdFCShQVEVfViB8IFBURV9DQUNIRSkJICAgLyogTm90IHdy LXByb3QgYnV0IGNsZWFuICovCi0jZGVmaW5lCVBURV9JT1BBR0UJKFBURV9HIHwgUFRFX1YgfCBQ VEVfTSB8IFBURV9VTkNBQ0hFRCkKLSNkZWZpbmUJUFRFX0ZSQU1FCTB4M2ZmZmZmYzAKLSNkZWZp bmUgUFRFX0hWUE4gICAgICAgIDB4ZmZmZmUwMDAgICAgICAvKiBIYXJkd2FyZSBwYWdlIG5vIG1h c2sgKi8KLSNkZWZpbmUgUFRFX0FTSUQgICAgICAgIDB4MDAwMDAwZmYgICAgICAvKiBBZGRyZXNz IHNwYWNlIElEICovCisvKgorICogUFRFIG1hbmFnZW1lbnQgZnVuY3Rpb25zIGZvciBiaXRzIGRl ZmluZWQgYWJvdmUuCisgKgorICogWFhYIENhbiBtYWtlIHRoZXNlIGF0b21pY3MsIGJ1dCBzb21l IHVzZXJzIG9mIHRoZW0gYXJlIHVzaW5nIFBURXMgaW4gbG9jYWwKKyAqIHJlZ2lzdGVycyBhbmQg c3VjaCBhbmQgZG9uJ3QgbmVlZCB0aGUgb3ZlcmhlYWQuCisgKi8KKyNkZWZpbmUJcHRlX2NsZWFy KHB0ZSwgYml0KQkoKCpwdGUpICY9IH4oYml0KSkKKyNkZWZpbmUJcHRlX3NldChwdGUsIGJpdCkJ KCgqcHRlKSB8PSAoYml0KSkKKyNkZWZpbmUJcHRlX3Rlc3QocHRlLCBiaXQpCSgoKCpwdGUpICYg KGJpdCkpID09IChiaXQpKQogCi0KLS8qIFVzZXIgdmlydHVhbCB0byBwdGUgb2Zmc2V0IGluIHBh Z2UgdGFibGUgKi8KLSNkZWZpbmUJdmFkX3RvX3B0ZV9vZmZzZXQoYWRyKQkoKChhZHIpID4+IFBB R0VfU0hJRlQpICYgKE5QVEVQRyAtMSkpCi0KLSNkZWZpbmUJbWlwc19wZ192KGVudHJ5KQkoKGVu dHJ5KSAmIFBURV9WKQotI2RlZmluZQltaXBzX3BnX3dpcmVkKGVudHJ5KQkoKGVudHJ5KSAmIFBU RV9XSVJFRCkKLSNkZWZpbmUJbWlwc19wZ19tX2JpdCgpCQkoUFRFX00pCi0jZGVmaW5lCW1pcHNf cGdfcndfYml0KCkJKFBURV9NKQotI2RlZmluZQltaXBzX3BnX3JvX2JpdCgpCShQVEVfUk8pCi0j ZGVmaW5lCW1pcHNfcGdfcm9wYWdlX2JpdCgpCShQVEVfUk9QQUdFKQotI2RlZmluZQltaXBzX3Bn X3J3cGFnZV9iaXQoKQkoUFRFX1JXUEFHRSkKLSNkZWZpbmUJbWlwc19wZ19jd3BhZ2VfYml0KCkJ KFBURV9DV1BBR0UpCi0jZGVmaW5lCW1pcHNfcGdfZ2xvYmFsX2JpdCgpCShQVEVfRykKLSNkZWZp bmUJbWlwc19wZ193aXJlZF9iaXQoKQkoUFRFX1dJUkVEKQotCiAjZW5kaWYgLyogIV9NQUNISU5F X1BURV9IXyAqLwpJbmRleDogc3lzL21pcHMvbWlwcy92bV9tYWNoZGVwLmMKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gc3lzL21pcHMvbWlwcy92bV9tYWNoZGVwLmMJKHJldmlzaW9uIDIwOTI0MykKKysrIHN5cy9t aXBzL21pcHMvdm1fbWFjaGRlcC5jCSh3b3JraW5nIGNvcHkpCkBAIC0yMTksNyArMjE5LDcgQEAK IAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgS1NUQUNLX1BBR0VTOyBpKyspIHsKIAkJcHRlID0gcG1h cF9wdGUoa2VybmVsX3BtYXAsIHRkLT50ZF9rc3RhY2sgKyBpICogUEFHRV9TSVpFKTsKLQkJdGQt PnRkX21kLm1kX3VwdGVbaV0gPSAqcHRlICYgfihQVEVfUk98UFRFX1dJUkVEKTsKKwkJdGQtPnRk X21kLm1kX3VwdGVbaV0gPSAqcHRlICYgflRMQkxPX1NXQklUU19NQVNLOwogCX0KIH0KIApAQCAt MjQxLDcgKzI0MSw3IEBACiAKIAlmb3IgKGkgPSAwOyBpIDwgS1NUQUNLX1BBR0VTOyBpKyspIHsK IAkJcHRlID0gcG1hcF9wdGUoa2VybmVsX3BtYXAsIHRkLT50ZF9rc3RhY2sgKyBpICogUEFHRV9T SVpFKTsKLQkJdGQtPnRkX21kLm1kX3VwdGVbaV0gPSAqcHRlICYgfihQVEVfUk98UFRFX1dJUkVE KTsKKwkJdGQtPnRkX21kLm1kX3VwdGVbaV0gPSAqcHRlICYgflRMQkxPX1NXQklUU19NQVNLOwog CX0KIH0KIApJbmRleDogc3lzL21pcHMvbWlwcy9leGNlcHRpb24uUwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBz eXMvbWlwcy9taXBzL2V4Y2VwdGlvbi5TCShyZXZpc2lvbiAyMDkyNDMpCisrKyBzeXMvbWlwcy9t aXBzL2V4Y2VwdGlvbi5TCSh3b3JraW5nIGNvcHkpCkBAIC04MTUsNyArODE1LDcgQEAKIAlsdwkJ azAsIDAoazEpCQkJIyBrMD10aGlzIFBURQogCiAJLyogVmFsaWRhdGUgcGFnZSB0YWJsZSBlbnRy eS4gICovCi0JYW5kaQkJazAsIFBURV9WCisJYW5kaQkJazAsIFBHX1YKIAliZXF6CQlrMCwgM2YK IAlub3AKIApJbmRleDogc3lzL21pcHMvbWlwcy9wbWFwLmMKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21p cHMvbWlwcy9wbWFwLmMJKHJldmlzaW9uIDIwOTI0MykKKysrIHN5cy9taXBzL21pcHMvcG1hcC5j CSh3b3JraW5nIGNvcHkpCkBAIC02OCw3ICs2OCw2IEBACiAjaW5jbHVkZSA8c3lzL2NkZWZzLmg+ CiBfX0ZCU0RJRCgiJEZyZWVCU0QkIik7CiAKLSNpbmNsdWRlICJvcHRfZGRiLmgiCiAjaW5jbHVk ZSAib3B0X21zZ2J1Zi5oIgogI2luY2x1ZGUgPHN5cy9wYXJhbS5oPgogI2luY2x1ZGUgPHN5cy9z eXN0bS5oPgpAQCAtMTIwLDIyICsxMTksMTMgQEAKIC8qCiAgKiBHZXQgUERFcyBhbmQgUFRFcyBm b3IgdXNlci9rZXJuZWwgYWRkcmVzcyBzcGFjZQogICovCi0jZGVmaW5lCXBtYXBfcGRlKG0sIHYp CSAgICAgICAoJigobSktPnBtX3NlZ3RhYlsodm1fb2Zmc2V0X3QpKHYpID4+IFNFR1NISUZUXSkp CisjZGVmaW5lCXBtYXBfcGRlKG0sIHYpCQkoJigobSktPnBtX3NlZ3RhYlsodm1fb2Zmc2V0X3Qp KHYpID4+IFNFR1NISUZUXSkpCiAjZGVmaW5lCXNlZ3RhYl9wZGUobSwgdikJKG1bKHZtX29mZnNl dF90KSh2KSA+PiBTRUdTSElGVF0pCiAKLSNkZWZpbmUJcG1hcF9wdGVfdyhwdGUpCQkoKCooaW50 ICopcHRlICYgUFRFX1cpICE9IDApCi0jZGVmaW5lCXBtYXBfcGRlX3YocHRlKQkJKCgqKGludCAq KXB0ZSkgIT0gMCkKLSNkZWZpbmUJcG1hcF9wdGVfbShwdGUpCQkoKCooaW50ICopcHRlICYgUFRF X00pICE9IDApCi0jZGVmaW5lCXBtYXBfcHRlX3YocHRlKQkJKCgqKGludCAqKXB0ZSAmIFBURV9W KSAhPSAwKQotCi0jZGVmaW5lCXBtYXBfcHRlX3NldF93KHB0ZSwgdikJKCh2KT8oKihpbnQgKilw dGUgfD0gUFRFX1cpOigqKGludCAqKXB0ZSAmPSB+UFRFX1cpKQotI2RlZmluZQlwbWFwX3B0ZV9z ZXRfcHJvdChwdGUsIHYpICgoKihpbnQgKilwdGUgJj0gflBHX1BST1QpLCAoKihpbnQgKilwdGUg fD0gKHYpKSkKLQogI2RlZmluZQlNSVBTX1NFR1NJWkUJCSgxTCA8PCBTRUdTSElGVCkKICNkZWZp bmUJbWlwc19zZWd0cnVuYyh2YSkJKCh2YSkgJiB+KE1JUFNfU0VHU0laRS0xKSkKLSNkZWZpbmUJ cG1hcF9UTEJfaW52YWxpZGF0ZV9hbGwoKSBNSVBTX1RCSUFQKCkKLSNkZWZpbmUJcG1hcF92YV9h c2lkKHBtYXAsIHZhKQkoKHZhKSB8ICgocG1hcCktPnBtX2FzaWRbUENQVV9HRVQoY3B1aWQpXS5h c2lkIDw8IFZNVExCX1BJRF9TSElGVCkpCiAjZGVmaW5lCWlzX2tlcm5lbF9wbWFwKHgpCSgoeCkg PT0ga2VybmVsX3BtYXApCisjZGVmaW5lCXZhZF90b19wdGVfb2Zmc2V0KGFkcikJKCgoYWRyKSA+ PiBQQUdFX1NISUZUKSAmIChOUFRFUEcgLTEpKQogCiBzdHJ1Y3QgcG1hcCBrZXJuZWxfcG1hcF9z dG9yZTsKIHBkX2VudHJ5X3QgKmtlcm5lbF9zZWdtYXA7CkBAIC0xNzIsOSArMTYyLDEwIEBACiBz dGF0aWMgaW50IHBtYXBfcmVtb3ZlX3B0ZShzdHJ1Y3QgcG1hcCAqcG1hcCwgcHRfZW50cnlfdCAq cHRxLCB2bV9vZmZzZXRfdCB2YSk7CiBzdGF0aWMgdm9pZCBwbWFwX3JlbW92ZV9wYWdlKHN0cnVj dCBwbWFwICpwbWFwLCB2bV9vZmZzZXRfdCB2YSk7CiBzdGF0aWMgdm9pZCBwbWFwX3JlbW92ZV9l bnRyeShzdHJ1Y3QgcG1hcCAqcG1hcCwgdm1fcGFnZV90IG0sIHZtX29mZnNldF90IHZhKTsKLXN0 YXRpYyBib29sZWFuX3QgcG1hcF90ZXN0Yml0KHZtX3BhZ2VfdCBtLCBpbnQgYml0KTsKIHN0YXRp YyBib29sZWFuX3QgcG1hcF90cnlfaW5zZXJ0X3B2X2VudHJ5KHBtYXBfdCBwbWFwLCB2bV9wYWdl X3QgbXB0ZSwKICAgICB2bV9vZmZzZXRfdCB2YSwgdm1fcGFnZV90IG0pOworc3RhdGljIF9faW5s aW5lIHZvaWQKK3BtYXBfaW52YWxpZGF0ZV9wYWdlKHBtYXBfdCBwbWFwLCB2bV9vZmZzZXRfdCB2 YSk7CiAKIHN0YXRpYyB2bV9wYWdlX3QgcG1hcF9hbGxvY3B0ZShwbWFwX3QgcG1hcCwgdm1fb2Zm c2V0X3QgdmEsIGludCBmbGFncyk7CiAKQEAgLTIyMSwxMCArMjEyLDEwIEBACiAJc2NoZWRfcGlu KCk7CQkJCQkJCVwKIAl2YSA9IHN5c20tPmJhc2U7CQkJCQkJXAogCW5wdGUgPSBUTEJMT19QQV9U T19QRk4ocGh5cykgfAkJCQkJXAotCSAgICBQVEVfUlcgfCBQVEVfViB8IFBURV9HIHwgUFRFX1cg fCBQVEVfQ0FDSEU7CQkJXAorCSAgIFBHX0QgfCBQR19WIHwgUEdfRyB8IFBHX1cgfCBQR19DX0NO QzsJCQlcCiAJcHRlID0gcG1hcF9wdGUoa2VybmVsX3BtYXAsIHZhKTsJCQkJXAogCSpwdGUgPSBu cHRlOwkJCQkJCQlcCi0Jc3lzbS0+dmFsaWQxID0gMTsKKwlzeXNtLT52YWxpZDEgPSAxCiAKICNk ZWZpbmUJUE1BUF9MTUVNX01BUDIodmExLCBwaHlzMSwgdmEyLCBwaHlzMikJCQkJXAogCWludCBj cHU7CQkJCQkJCVwKQEAgLTIzOSwyOCArMjMwLDI4IEBACiAJdmExID0gc3lzbS0+YmFzZTsJCQkJ CQlcCiAJdmEyID0gc3lzbS0+YmFzZSArIFBBR0VfU0laRTsJCQkJCVwKIAlucHRlID0gVExCTE9f UEFfVE9fUEZOKHBoeXMxKSB8CQkJCQlcCi0JICAgIFBURV9SVyB8IFBURV9WIHwgUFRFX0cgfCBQ VEVfVyB8IFBURV9DQUNIRTsJCQlcCisJICAgIFBHX0QgfCBQR19WIHwgUEdfRyB8IFBHX1cgfCBQ R19DX0NOQzsJCQlcCiAJcHRlID0gcG1hcF9wdGUoa2VybmVsX3BtYXAsIHZhMSk7CQkJCVwKIAkq cHRlID0gbnB0ZTsJCQkJCQkJXAogCW5wdGUgPSAgVExCTE9fUEFfVE9fUEZOKHBoeXMyKSB8CQkJ CVwKLQkgICAgUFRFX1JXIHwgUFRFX1YgfCBQVEVfRyB8IFBURV9XIHwgUFRFX0NBQ0hFOwkJCVwK KwkgICAgUEdfRCB8IFBHX1YgfCBQR19HIHwgUEdfVyB8IFBHX0NfQ05DOwkJCVwKIAlwdGUgPSBw bWFwX3B0ZShrZXJuZWxfcG1hcCwgdmEyKTsJCQkJXAogCSpwdGUgPSBucHRlOwkJCQkJCQlcCiAJ c3lzbS0+dmFsaWQxID0gMTsJCQkJCQlcCi0Jc3lzbS0+dmFsaWQyID0gMTsKKwlzeXNtLT52YWxp ZDIgPSAxCiAKICNkZWZpbmUJUE1BUF9MTUVNX1VOTUFQKCkJCQkJCQlcCiAJcHRlID0gcG1hcF9w dGUoa2VybmVsX3BtYXAsIHN5c20tPmJhc2UpOwkJCVwKLQkqcHRlID0gUFRFX0c7CQkJCQkJCVwK KwkqcHRlID0gUEdfRzsJCQkJCQkJXAogCXRsYl9pbnZhbGlkYXRlX2FkZHJlc3Moa2VybmVsX3Bt YXAsIHN5c20tPmJhc2UpOwkJXAogCXN5c20tPnZhbGlkMSA9IDA7CQkJCQkJXAogCXB0ZSA9IHBt YXBfcHRlKGtlcm5lbF9wbWFwLCBzeXNtLT5iYXNlICsgUEFHRV9TSVpFKTsJCVwKLQkqcHRlID0g UFRFX0c7CQkJCQkJCVwKKwkqcHRlID0gUEdfRzsJCQkJCQkJXAogCXRsYl9pbnZhbGlkYXRlX2Fk ZHJlc3Moa2VybmVsX3BtYXAsIHN5c20tPmJhc2UgKyBQQUdFX1NJWkUpOwlcCiAJc3lzbS0+dmFs aWQyID0gMDsJCQkJCQlcCiAJc2NoZWRfdW5waW4oKTsJCQkJCQkJXAogCWludHJfcmVzdG9yZShp bnRyKTsJCQkJCQlcCi0JUE1BUF9MR01FTV9VTkxPQ0soc3lzbSk7CisJUE1BUF9MR01FTV9VTkxP Q0soc3lzbSkKIAogcGRfZW50cnlfdAogcG1hcF9zZWdtYXAocG1hcF90IHBtYXAsIHZtX29mZnNl dF90IHZhKQpAQCAtNDc1LDcgKzQ2Niw3IEBACiAJICogaW4gdGhlIHRsYi4KIAkgKi8KIAlmb3Ig KGkgPSAwLCBwdGUgPSBwZ3RhYjsgaSA8IChua3B0ICogTlBURVBHKTsgaSsrLCBwdGUrKykKLQkJ KnB0ZSA9IFBURV9HOworCQkqcHRlID0gUEdfRzsKIAogCS8qCiAJICogVGhlIHNlZ21lbnQgdGFi bGUgY29udGFpbnMgdGhlIEtWQSBvZiB0aGUgcGFnZXMgaW4gdGhlIHNlY29uZApAQCAtNTUxLDcg KzU0Miw3IEBACiBzdGF0aWMgaW50CiBwbWFwX253X21vZGlmaWVkKHB0X2VudHJ5X3QgcHRlKQog ewotCWlmICgocHRlICYgKFBURV9NIHwgUFRFX1JPKSkgPT0gKFBURV9NIHwgUFRFX1JPKSkKKwlp ZiAoKHB0ZSAmIChQR19EIHwgUEdfUk8pKSA9PSAoUEdfRCB8IFBHX1JPKSkKIAkJcmV0dXJuICgx KTsKIAllbHNlCiAJCXJldHVybiAoMCk7CkBAIC03MDIsOCArNjkzLDggQEAKIAlQTUFQX0xPQ0so cG1hcCk7CiByZXRyeToKIAlwdGUgPSAqcG1hcF9wdGUocG1hcCwgdmEpOwotCWlmIChwdGUgIT0g MCAmJiBwbWFwX3B0ZV92KCZwdGUpICYmCi0JICAgICgocHRlICYgUFRFX1JXKSB8fCAocHJvdCAm IFZNX1BST1RfV1JJVEUpID09IDApKSB7CisJaWYgKHB0ZSAhPSAwICYmIHB0ZV90ZXN0KCZwdGUs IFBHX1YpICYmCisJICAgIChwdGVfdGVzdCgmcHRlLCBQR19EKSB8fCAocHJvdCAmIFZNX1BST1Rf V1JJVEUpID09IDApKSB7CiAJCWlmICh2bV9wYWdlX3BhX3RyeXJlbG9jayhwbWFwLCBUTEJMT19Q VEVfVE9fUEEocHRlKSwgJnBhKSkKIAkJCWdvdG8gcmV0cnk7CiAKQEAgLTcyNSwxOCArNzE2LDE4 IEBACiAgLyogUE1BUF9JTkxJTkUgKi8gdm9pZAogcG1hcF9rZW50ZXIodm1fb2Zmc2V0X3QgdmEs IHZtX3BhZGRyX3QgcGEpCiB7Ci0JcmVnaXN0ZXIgcHRfZW50cnlfdCAqcHRlOwotCXB0X2VudHJ5 X3QgbnB0ZSwgb3B0ZTsKKwlwdF9lbnRyeV90ICpwdGU7CisJcHRfZW50cnlfdCBvcHRlLCBucHRl OwogCiAjaWZkZWYgUE1BUF9ERUJVRwotCXByaW50ZigicG1hcF9rZW50ZXI6ICB2YTogMHglMDh4 IC0+IHBhOiAweCUwOHhcbiIsIHZhLCBwYSk7CisJcHJpbnRmKCJwbWFwX2tlbnRlcjogIHZhOiAl cCAtPiBwYTogJXBcbiIsICh2b2lkICopdmEsICh2b2lkICopcGEpOwogI2VuZGlmCi0JbnB0ZSA9 IFRMQkxPX1BBX1RPX1BGTihwYSkgfCBQVEVfUlcgfCBQVEVfViB8IFBURV9HIHwgUFRFX1c7CisJ bnB0ZSA9IFRMQkxPX1BBX1RPX1BGTihwYSkgfCBQR19EIHwgUEdfViB8IFBHX0cgfCBQR19XOwog CiAJaWYgKGlzX2NhY2hlYWJsZV9tZW0ocGEpKQotCQlucHRlIHw9IFBURV9DQUNIRTsKKwkJbnB0 ZSB8PSBQR19DX0NOQzsKIAllbHNlCi0JCW5wdGUgfD0gUFRFX1VOQ0FDSEVEOworCQlucHRlIHw9 IFBHX0NfVUM7CiAKIAlwdGUgPSBwbWFwX3B0ZShrZXJuZWxfcG1hcCwgdmEpOwogCW9wdGUgPSAq cHRlOwpAQCAtNzUxLDcgKzc0Miw3IEBACiAgLyogUE1BUF9JTkxJTkUgKi8gdm9pZAogcG1hcF9r cmVtb3ZlKHZtX29mZnNldF90IHZhKQogewotCXJlZ2lzdGVyIHB0X2VudHJ5X3QgKnB0ZTsKKwlw dF9lbnRyeV90ICpwdGU7CiAKIAkvKgogCSAqIFdyaXRlIGJhY2sgYWxsIGNhY2hlcyBmcm9tIHRo ZSBwYWdlIGJlaW5nIGRlc3Ryb3llZApAQCAtNzU5LDcgKzc1MCw3IEBACiAJbWlwc19kY2FjaGVf d2JpbnZfcmFuZ2VfaW5kZXgodmEsIFBBR0VfU0laRSk7CiAKIAlwdGUgPSBwbWFwX3B0ZShrZXJu ZWxfcG1hcCwgdmEpOwotCSpwdGUgPSBQVEVfRzsKKwkqcHRlID0gUEdfRzsKIAlwbWFwX2ludmFs aWRhdGVfcGFnZShrZXJuZWxfcG1hcCwgdmEpOwogfQogCkBAIC0xMjMyLDcgKzEyMjMsNyBAQAog CQkgKiBwcm9kdWNlIGEgZ2xvYmFsIGJpdCB0byBzdG9yZSBpbiB0aGUgdGxiLgogCQkgKi8KIAkJ Zm9yIChpID0gMDsgaSA8IE5QVEVQRzsgaSsrLCBwdGUrKykKLQkJCSpwdGUgPSBQVEVfRzsKKwkJ CSpwdGUgPSBQR19HOwogCiAJCWtlcm5lbF92bV9lbmQgPSAoa2VybmVsX3ZtX2VuZCArIFBBR0Vf U0laRSAqIE5QVEVQRykgJgogCQkgICAgfihQQUdFX1NJWkUgKiBOUFRFUEcgLSAxKTsKQEAgLTEz MTIsMTIgKzEzMDMsMTIgQEAKIAkJCUtBU1NFUlQocHRlICE9IE5VTEwsICgicHRlIikpOwogCQkJ b2xkcHRlID0gbG9hZGFuZGNsZWFyKCh1X2ludCAqKXB0ZSk7CiAJCQlpZiAoaXNfa2VybmVsX3Bt YXAocG1hcCkpCi0JCQkJKnB0ZSA9IFBURV9HOwotCQkJS0FTU0VSVCgob2xkcHRlICYgUFRFX1cp ID09IDAsCisJCQkJKnB0ZSA9IFBHX0c7CisJCQlLQVNTRVJUKCFwdGVfdGVzdCgmb2xkcHRlLCBQ R19XKSwKIAkJCSAgICAoIndpcmVkIHB0ZSBmb3IgdW53aXJlZCBwYWdlIikpOwogCQkJaWYgKG0t Pm1kLnB2X2ZsYWdzICYgUFZfVEFCTEVfUkVGKQogCQkJCXZtX3BhZ2VfZmxhZ19zZXQobSwgUEdf UkVGRVJFTkNFRCk7Ci0JCQlpZiAob2xkcHRlICYgUFRFX00pCisJCQlpZiAocHRlX3Rlc3QoJm9s ZHB0ZSwgUEdfRCkpCiAJCQkJdm1fcGFnZV9kaXJ0eShtKTsKIAkJCXBtYXBfaW52YWxpZGF0ZV9w YWdlKHBtYXAsIHZhKTsKIAkJCVRBSUxRX1JFTU9WRSgmcG1hcC0+cG1fcHZsaXN0LCBwdiwgcHZf cGxpc3QpOwpAQCAtMTQ1NSw5ICsxNDQ2LDkgQEAKIAogCW9sZHB0ZSA9IGxvYWRhbmRjbGVhcigo dV9pbnQgKilwdHEpOwogCWlmIChpc19rZXJuZWxfcG1hcChwbWFwKSkKLQkJKnB0cSA9IFBURV9H OworCQkqcHRxID0gUEdfRzsKIAotCWlmIChvbGRwdGUgJiBQVEVfVykKKwlpZiAocHRlX3Rlc3Qo Jm9sZHB0ZSwgUEdfVykpCiAJCXBtYXAtPnBtX3N0YXRzLndpcmVkX2NvdW50IC09IDE7CiAKIAlw bWFwLT5wbV9zdGF0cy5yZXNpZGVudF9jb3VudCAtPSAxOwpAQCAtMTQ2NSw3ICsxNDU2LDcgQEAK IAogCWlmIChwYWdlX2lzX21hbmFnZWQocGEpKSB7CiAJCW0gPSBQSFlTX1RPX1ZNX1BBR0UocGEp OwotCQlpZiAob2xkcHRlICYgUFRFX00pIHsKKwkJaWYgKHB0ZV90ZXN0KCZvbGRwdGUsIFBHX0Qp KSB7CiAjaWYgZGVmaW5lZChQTUFQX0RJQUdOT1NUSUMpCiAJCQlpZiAocG1hcF9ud19tb2RpZmll ZChvbGRwdGUpKSB7CiAJCQkJcHJpbnRmKApAQCAtMTQ5MCw3ICsxNDgxLDcgQEAKIHN0YXRpYyB2 b2lkCiBwbWFwX3JlbW92ZV9wYWdlKHN0cnVjdCBwbWFwICpwbWFwLCB2bV9vZmZzZXRfdCB2YSkK IHsKLQlyZWdpc3RlciBwdF9lbnRyeV90ICpwdHE7CisJcHRfZW50cnlfdCAqcHRxOwogCiAJbXR4 X2Fzc2VydCgmdm1fcGFnZV9xdWV1ZV9tdHgsIE1BX09XTkVEKTsKIAlQTUFQX0xPQ0tfQVNTRVJU KHBtYXAsIE1BX09XTkVEKTsKQEAgLTE0OTksNyArMTQ5MCw3IEBACiAJLyoKIAkgKiBpZiB0aGVy ZSBpcyBubyBwdGUgZm9yIHRoaXMgYWRkcmVzcywganVzdCBza2lwIGl0ISEhCiAJICovCi0JaWYg KCFwdHEgfHwgIXBtYXBfcHRlX3YocHRxKSkgeworCWlmICghcHRxIHx8ICFwdGVfdGVzdChwdHEs IFBHX1YpKSB7CiAJCXJldHVybjsKIAl9CiAKQEAgLTE1NzUsOCArMTU2Niw4IEBACiB2b2lkCiBw bWFwX3JlbW92ZV9hbGwodm1fcGFnZV90IG0pCiB7Ci0JcmVnaXN0ZXIgcHZfZW50cnlfdCBwdjsK LQlyZWdpc3RlciBwdF9lbnRyeV90ICpwdGUsIHRwdGU7CisJcHZfZW50cnlfdCBwdjsKKwlwdF9l bnRyeV90ICpwdGUsIHRwdGU7CiAKIAlLQVNTRVJUKChtLT5mbGFncyAmIFBHX0ZJQ1RJVElPVVMp ID09IDAsCiAJICAgICgicG1hcF9yZW1vdmVfYWxsOiBwYWdlICVwIGlzIGZpY3RpdGlvdXMiLCBt KSk7CkBAIC0xNjAxLDE1ICsxNTkyLDE1IEBACiAKIAkJdHB0ZSA9IGxvYWRhbmRjbGVhcigodV9p bnQgKilwdGUpOwogCQlpZiAoaXNfa2VybmVsX3BtYXAocHYtPnB2X3BtYXApKQotCQkJKnB0ZSA9 IFBURV9HOworCQkJKnB0ZSA9IFBHX0c7CiAKLQkJaWYgKHRwdGUgJiBQVEVfVykKKwkJaWYgKHB0 ZV90ZXN0KCZ0cHRlLCBQR19XKSkKIAkJCXB2LT5wdl9wbWFwLT5wbV9zdGF0cy53aXJlZF9jb3Vu dC0tOwogCiAJCS8qCiAJCSAqIFVwZGF0ZSB0aGUgdm1fcGFnZV90IGNsZWFuIGFuZCByZWZlcmVu Y2UgYml0cy4KIAkJICovCi0JCWlmICh0cHRlICYgUFRFX00pIHsKKwkJaWYgKHB0ZV90ZXN0KCZ0 cHRlLCBQR19EKSkgewogI2lmIGRlZmluZWQoUE1BUF9ESUFHTk9TVElDKQogCQkJaWYgKHBtYXBf bndfbW9kaWZpZWQodHB0ZSkpIHsKIAkJCQlwcmludGYoCkBAIC0xNjcxLDcgKzE2NjIsNyBAQAog CQkgKiBJZiBwdGUgaXMgaW52YWxpZCwgc2tpcCB0aGlzIHBhZ2UKIAkJICovCiAJCXB0ZSA9IHBt YXBfcHRlKHBtYXAsIHN2YSk7Ci0JCWlmICghcG1hcF9wdGVfdihwdGUpKSB7CisJCWlmICghcHRl X3Rlc3QocHRlLCBQR19WKSkgewogCQkJc3ZhICs9IFBBR0VfU0laRTsKIAkJCWNvbnRpbnVlOwog CQl9CkBAIC0xNjc5LDEyICsxNjcwLDEzIEBACiAJCW9iaXRzID0gcGJpdHMgPSAqcHRlOwogCQlw YSA9IFRMQkxPX1BURV9UT19QQShwYml0cyk7CiAKLQkJaWYgKHBhZ2VfaXNfbWFuYWdlZChwYSkg JiYgKHBiaXRzICYgUFRFX00pICE9IDApIHsKKwkJaWYgKHBhZ2VfaXNfbWFuYWdlZChwYSkgJiYg cHRlX3Rlc3QoJnBiaXRzLCBQR19EKSkgewogCQkJbSA9IFBIWVNfVE9fVk1fUEFHRShwYSk7CiAJ CQl2bV9wYWdlX2RpcnR5KG0pOwogCQkJbS0+bWQucHZfZmxhZ3MgJj0gflBWX1RBQkxFX01PRDsK IAkJfQotCQlwYml0cyA9IChwYml0cyAmIH5QVEVfTSkgfCBQVEVfUk87CisJCXB0ZV9jbGVhcigm cGJpdHMsIFBHX0QpOworCQlwdGVfc2V0KCZwYml0cywgUEdfUk8pOwogCiAJCWlmIChwYml0cyAh PSAqcHRlKSB7CiAJCQlpZiAoIWF0b21pY19jbXBzZXRfaW50KCh1X2ludCAqKXB0ZSwgb2JpdHMs IHBiaXRzKSkKQEAgLTE3MTQsNyArMTcwNiw3IEBACiAgICAgdm1fcHJvdF90IHByb3QsIGJvb2xl YW5fdCB3aXJlZCkKIHsKIAl2bV9vZmZzZXRfdCBwYSwgb3BhOwotCXJlZ2lzdGVyIHB0X2VudHJ5 X3QgKnB0ZTsKKwlwdF9lbnRyeV90ICpwdGU7CiAJcHRfZW50cnlfdCBvcmlncHRlLCBuZXdwdGU7 CiAJcHZfZW50cnlfdCBwdjsKIAl2bV9wYWdlX3QgbXB0ZSwgb207CkBAIC0xNzU4LDE2ICsxNzUw LDE2IEBACiAJLyoKIAkgKiBNYXBwaW5nIGhhcyBub3QgY2hhbmdlZCwgbXVzdCBiZSBwcm90ZWN0 aW9uIG9yIHdpcmluZyBjaGFuZ2UuCiAJICovCi0JaWYgKChvcmlncHRlICYgUFRFX1YpICYmIChv cGEgPT0gcGEpKSB7CisJaWYgKHB0ZV90ZXN0KCZvcmlncHRlLCBQR19WKSAmJiBvcGEgPT0gcGEp IHsKIAkJLyoKIAkJICogV2lyaW5nIGNoYW5nZSwganVzdCB1cGRhdGUgc3RhdHMuIFdlIGRvbid0 IHdvcnJ5IGFib3V0CiAJCSAqIHdpcmluZyBQVCBwYWdlcyBhcyB0aGV5IHJlbWFpbiByZXNpZGVu dCBhcyBsb25nIGFzIHRoZXJlCiAJCSAqIGFyZSB2YWxpZCBtYXBwaW5ncyBpbiB0aGVtLiBIZW5j ZSwgaWYgYSB1c2VyIHBhZ2UgaXMKIAkJICogd2lyZWQsIHRoZSBQVCBwYWdlIHdpbGwgYmUgYWxz by4KIAkJICovCi0JCWlmICh3aXJlZCAmJiAoKG9yaWdwdGUgJiBQVEVfVykgPT0gMCkpCisJCWlm ICh3aXJlZCAmJiAhcHRlX3Rlc3QoJm9yaWdwdGUsIFBHX1cpKQogCQkJcG1hcC0+cG1fc3RhdHMu d2lyZWRfY291bnQrKzsKLQkJZWxzZSBpZiAoIXdpcmVkICYmIChvcmlncHRlICYgUFRFX1cpKQor CQllbHNlIGlmICghd2lyZWQgJiYgcHRlX3Rlc3QoJm9yaWdwdGUsIFBHX1cpKQogCQkJcG1hcC0+ cG1fc3RhdHMud2lyZWRfY291bnQtLTsKIAogI2lmIGRlZmluZWQoUE1BUF9ESUFHTk9TVElDKQpA QCAtMTc5Nyw3ICsxNzg5LDcgQEAKIAkgKiBoYW5kbGUgdmFsaWRhdGluZyBuZXcgbWFwcGluZy4K IAkgKi8KIAlpZiAob3BhKSB7Ci0JCWlmIChvcmlncHRlICYgUFRFX1cpCisJCWlmIChwdGVfdGVz dCgmb3JpZ3B0ZSwgUEdfVykpCiAJCQlwbWFwLT5wbV9zdGF0cy53aXJlZF9jb3VudC0tOwogCiAJ CWlmIChwYWdlX2lzX21hbmFnZWQob3BhKSkgewpAQCAtMTg0NSwzMSArMTgzNywzMCBAQAogCXJ3 ID0gaW5pdF9wdGVfcHJvdCh2YSwgbSwgcHJvdCk7CiAKICNpZmRlZiBQTUFQX0RFQlVHCi0JcHJp bnRmKCJwbWFwX2VudGVyOiAgdmE6IDB4JTA4eCAtPiBwYTogMHglMDh4XG4iLCB2YSwgcGEpOwor CXByaW50ZigicG1hcF9lbnRlcjogIHZhOiAlcCAtPiBwYTogJXBcbiIsICh2b2lkICopdmEsICh2 b2lkICopcGEpOwogI2VuZGlmCiAJLyoKIAkgKiBOb3cgdmFsaWRhdGUgbWFwcGluZyB3aXRoIGRl c2lyZWQgcHJvdGVjdGlvbi93aXJpbmcuCiAJICovCi0JbmV3cHRlID0gVExCTE9fUEFfVE9fUEZO KHBhKSB8IHJ3IHwgUFRFX1Y7CisJbmV3cHRlID0gVExCTE9fUEFfVE9fUEZOKHBhKSB8IHJ3IHwg UEdfVjsKIAogCWlmIChpc19jYWNoZWFibGVfbWVtKHBhKSkKLQkJbmV3cHRlIHw9IFBURV9DQUNI RTsKKwkJbmV3cHRlIHw9IFBHX0NfQ05DOwogCWVsc2UKLQkJbmV3cHRlIHw9IFBURV9VTkNBQ0hF RDsKKwkJbmV3cHRlIHw9IFBHX0NfVUM7CiAKIAlpZiAod2lyZWQpCi0JCW5ld3B0ZSB8PSBQVEVf VzsKKwkJbmV3cHRlIHw9IFBHX1c7CiAKLQlpZiAoaXNfa2VybmVsX3BtYXAocG1hcCkpIHsKLQkg ICAgICAgICBuZXdwdGUgfD0gUFRFX0c7Ci0JfQorCWlmIChpc19rZXJuZWxfcG1hcChwbWFwKSkK KwkgICAgICAgICBuZXdwdGUgfD0gUEdfRzsKIAogCS8qCiAJICogaWYgdGhlIG1hcHBpbmcgb3Ig cGVybWlzc2lvbiBiaXRzIGFyZSBkaWZmZXJlbnQsIHdlIG5lZWQgdG8KIAkgKiB1cGRhdGUgdGhl IHB0ZS4KIAkgKi8KIAlpZiAob3JpZ3B0ZSAhPSBuZXdwdGUpIHsKLQkJaWYgKG9yaWdwdGUgJiBQ VEVfVikgeworCQlpZiAocHRlX3Rlc3QoJm9yaWdwdGUsIFBHX1YpKSB7CiAJCQkqcHRlID0gbmV3 cHRlOwogCQkJaWYgKHBhZ2VfaXNfbWFuYWdlZChvcGEpICYmIChvcGEgIT0gcGEpKSB7CiAJCQkJ aWYgKG9tLT5tZC5wdl9mbGFncyAmIFBWX1RBQkxFX1JFRikKQEAgLTE4NzcsOCArMTg2OCw4IEBA CiAJCQkJb20tPm1kLnB2X2ZsYWdzICY9CiAJCQkJICAgIH4oUFZfVEFCTEVfUkVGIHwgUFZfVEFC TEVfTU9EKTsKIAkJCX0KLQkJCWlmIChvcmlncHRlICYgUFRFX00pIHsKLQkJCQlLQVNTRVJUKChv cmlncHRlICYgUFRFX1JXKSwKKwkJCWlmIChwdGVfdGVzdCgmb3JpZ3B0ZSwgUEdfRCkpIHsKKwkJ CQlLQVNTRVJUKCFwdGVfdGVzdCgmb3JpZ3B0ZSwgUEdfUk8pLAogCQkJCSAgICAoInBtYXBfZW50 ZXI6IG1vZGlmaWVkIHBhZ2Ugbm90IHdyaXRhYmxlOiIKIAkJCQkgICAgIiB2YTogJXAsIHB0ZTog MHgleCIsICh2b2lkICopdmEsIG9yaWdwdGUpKTsKIAkJCQlpZiAocGFnZV9pc19tYW5hZ2VkKG9w YSkpCkBAIC0xOTg2LDcgKzE5NzcsNyBAQAogCX0KIAogCXB0ZSA9IHBtYXBfcHRlKHBtYXAsIHZh KTsKLQlpZiAocG1hcF9wdGVfdihwdGUpKSB7CisJaWYgKHB0ZV90ZXN0KHB0ZSwgUEdfVikpIHsK IAkJaWYgKG1wdGUgIT0gTlVMTCkgewogCQkJbXB0ZS0+d2lyZV9jb3VudC0tOwogCQkJbXB0ZSA9 IE5VTEw7CkBAIC0yMDE2LDE3ICsyMDA3LDE3IEBACiAJLyoKIAkgKiBOb3cgdmFsaWRhdGUgbWFw cGluZyB3aXRoIFJPIHByb3RlY3Rpb24KIAkgKi8KLQkqcHRlID0gVExCTE9fUEFfVE9fUEZOKHBh KSB8IFBURV9WOworCSpwdGUgPSBUTEJMT19QQV9UT19QRk4ocGEpIHwgUEdfVjsKIAogCWlmIChp c19jYWNoZWFibGVfbWVtKHBhKSkKLQkJKnB0ZSB8PSBQVEVfQ0FDSEU7CisJCSpwdGUgfD0gUEdf Q19DTkM7CiAJZWxzZQotCQkqcHRlIHw9IFBURV9VTkNBQ0hFRDsKKwkJKnB0ZSB8PSBQR19DX1VD OwogCiAJaWYgKGlzX2tlcm5lbF9wbWFwKHBtYXApKQotCQkqcHRlIHw9IFBURV9HOworCQkqcHRl IHw9IFBHX0c7CiAJZWxzZSB7Ci0JCSpwdGUgfD0gUFRFX1JPOworCQkqcHRlIHw9IFBHX1JPOwog CQkvKgogCQkgKiBTeW5jIEkgJiBEIGNhY2hlcy4gIERvIHRoaXMgb25seSBpZiB0aGUgdGhlIHRh cmdldCBwbWFwCiAJCSAqIGJlbG9uZ3MgdG8gdGhlIGN1cnJlbnQgcHJvY2Vzcy4gIE90aGVyd2lz ZSwgYW4KQEAgLTIwNjksNyArMjA2MCw3IEBACiAJCWNwdSA9IFBDUFVfR0VUKGNwdWlkKTsKIAkJ c3lzbSA9ICZzeXNtYXBfbG1lbVtjcHVdOwogCQkvKiBTaW5jZSB0aGlzIGlzIGZvciB0aGUgZGVi dWdnZXIsIG5vIGxvY2tzIG9yIGFueSBvdGhlciBmdW4gKi8KLQkJbnB0ZSA9IFRMQkxPX1BBX1RP X1BGTihwYSkgfCBQVEVfUlcgfCBQVEVfViB8IFBURV9HIHwgUFRFX1cgfCBQVEVfQ0FDSEU7CisJ CW5wdGUgPSBUTEJMT19QQV9UT19QRk4ocGEpIHwgUEdfRCB8IFBHX1YgfCBQR19HIHwgUEdfVyB8 IFBHX0NfQ05DOwogCQlwdGUgPSBwbWFwX3B0ZShrZXJuZWxfcG1hcCwgc3lzbS0+YmFzZSk7CiAJ CSpwdGUgPSBucHRlOwogCQlzeXNtLT52YWxpZDEgPSAxOwpAQCAtMjA5OCw3ICsyMDg5LDcgQEAK IAogCQlpbnRyID0gaW50cl9kaXNhYmxlKCk7CiAJCXB0ZSA9IHBtYXBfcHRlKGtlcm5lbF9wbWFw LCBzeXNtLT5iYXNlKTsKLQkJKnB0ZSA9IFBURV9HOworCQkqcHRlID0gUEdfRzsKIAkJcG1hcF9p bnZhbGlkYXRlX3BhZ2Uoa2VybmVsX3BtYXAsIHN5c20tPmJhc2UpOwogCQlpbnRyX3Jlc3RvcmUo aW50cik7CiAJCXN5c20tPnZhbGlkMSA9IDA7CkBAIC0yMTY4LDcgKzIxNTksNyBAQAogdm9pZAog cG1hcF9jaGFuZ2Vfd2lyaW5nKHBtYXBfdCBwbWFwLCB2bV9vZmZzZXRfdCB2YSwgYm9vbGVhbl90 IHdpcmVkKQogewotCXJlZ2lzdGVyIHB0X2VudHJ5X3QgKnB0ZTsKKwlwdF9lbnRyeV90ICpwdGU7 CiAKIAlpZiAocG1hcCA9PSBOVUxMKQogCQlyZXR1cm47CkBAIC0yMTc2LDE2ICsyMTY3LDE5IEBA CiAJUE1BUF9MT0NLKHBtYXApOwogCXB0ZSA9IHBtYXBfcHRlKHBtYXAsIHZhKTsKIAotCWlmICh3 aXJlZCAmJiAhcG1hcF9wdGVfdyhwdGUpKQorCWlmICh3aXJlZCAmJiAhcHRlX3Rlc3QocHRlLCBQ R19XKSkKIAkJcG1hcC0+cG1fc3RhdHMud2lyZWRfY291bnQrKzsKLQllbHNlIGlmICghd2lyZWQg JiYgcG1hcF9wdGVfdyhwdGUpKQorCWVsc2UgaWYgKCF3aXJlZCAmJiBwdGVfdGVzdChwdGUsIFBH X1cpKQogCQlwbWFwLT5wbV9zdGF0cy53aXJlZF9jb3VudC0tOwogCiAJLyoKIAkgKiBXaXJpbmcg aXMgbm90IGEgaGFyZHdhcmUgY2hhcmFjdGVyaXN0aWMgc28gdGhlcmUgaXMgbm8gbmVlZCB0bwog CSAqIGludmFsaWRhdGUgVExCLgogCSAqLwotCXBtYXBfcHRlX3NldF93KHB0ZSwgd2lyZWQpOwor CWlmICh3aXJlZCkKKwkJcHRlX3NldChwdGUsIFBHX1cpOworCWVsc2UKKwkJcHRlX2NsZWFyKHB0 ZSwgUEdfVyk7CiAJUE1BUF9VTkxPQ0socG1hcCk7CiB9CiAKQEAgLTIzNzEsMTggKzIzNjUsMTgg QEAKIAlmb3IgKHB2ID0gVEFJTFFfRklSU1QoJnBtYXAtPnBtX3B2bGlzdCk7IHB2OyBwdiA9IG5w dikgewogCiAJCXB0ZSA9IHBtYXBfcHRlKHB2LT5wdl9wbWFwLCBwdi0+cHZfdmEpOwotCQlpZiAo IXBtYXBfcHRlX3YocHRlKSkKKwkJaWYgKCFwdGVfdGVzdChwdGUsIFBHX1YpKQogCQkJcGFuaWMo InBtYXBfcmVtb3ZlX3BhZ2VzOiBwYWdlIG9uIHBtX3B2bGlzdCBoYXMgbm8gcHRlXG4iKTsKIAkJ dHB0ZSA9ICpwdGU7CiAKIC8qCiAgKiBXZSBjYW5ub3QgcmVtb3ZlIHdpcmVkIHBhZ2VzIGZyb20g YSBwcm9jZXNzJyBtYXBwaW5nIGF0IHRoaXMgdGltZQogICovCi0JCWlmICh0cHRlICYgUFRFX1cp IHsKKwkJaWYgKHB0ZV90ZXN0KCZ0cHRlLCBQR19XKSkgewogCQkJbnB2ID0gVEFJTFFfTkVYVChw diwgcHZfcGxpc3QpOwogCQkJY29udGludWU7CiAJCX0KLQkJKnB0ZSA9IGlzX2tlcm5lbF9wbWFw KHBtYXApID8gUFRFX0cgOiAwOworCQkqcHRlID0gaXNfa2VybmVsX3BtYXAocG1hcCkgPyBQR19H IDogMDsKIAogCQltID0gUEhZU19UT19WTV9QQUdFKFRMQkxPX1BURV9UT19QQSh0cHRlKSk7CiAJ CUtBU1NFUlQobSAhPSBOVUxMLApAQCAtMjM5Myw3ICsyMzg3LDcgQEAKIAkJLyoKIAkJICogVXBk YXRlIHRoZSB2bV9wYWdlX3QgY2xlYW4gYW5kIHJlZmVyZW5jZSBiaXRzLgogCQkgKi8KLQkJaWYg KHRwdGUgJiBQVEVfTSkgeworCQlpZiAocHRlX3Rlc3QoJnRwdGUsIFBHX0QpKSB7CiAJCQl2bV9w YWdlX2RpcnR5KG0pOwogCQl9CiAJCW5wdiA9IFRBSUxRX05FWFQocHYsIHB2X3BsaXN0KTsKQEAg LTI0NDEsNyArMjQzNSw3IEBACiAjZW5kaWYKIAkJUE1BUF9MT0NLKHB2LT5wdl9wbWFwKTsKIAkJ cHRlID0gcG1hcF9wdGUocHYtPnB2X3BtYXAsIHB2LT5wdl92YSk7Ci0JCXJ2ID0gKCpwdGUgJiBi aXQpICE9IDA7CisJCXJ2ID0gcHRlX3Rlc3QocHRlLCBiaXQpOwogCQlQTUFQX1VOTE9DSyhwdi0+ cHZfcG1hcCk7CiAJCWlmIChydikKIAkJCWJyZWFrOwpAQCAtMjQ1MCwxMyArMjQ0NCwxMyBAQAog fQogCiAvKgotICogdGhpcyByb3V0aW5lIGlzIHVzZWQgdG8gbW9kaWZ5IGJpdHMgaW4gcHRlcwor ICogdGhpcyByb3V0aW5lIGlzIHVzZWQgdG8gY2xlYXIgZGlydHkgYml0cyBpbiBwdGVzCiAgKi8K IHN0YXRpYyBfX2lubGluZSB2b2lkCiBwbWFwX2NoYW5nZWJpdCh2bV9wYWdlX3QgbSwgaW50IGJp dCwgYm9vbGVhbl90IHNldGVtKQogewotCXJlZ2lzdGVyIHB2X2VudHJ5X3QgcHY7Ci0JcmVnaXN0 ZXIgcHRfZW50cnlfdCAqcHRlOworCXB2X2VudHJ5X3QgcHY7CisJcHRfZW50cnlfdCAqcHRlOwog CiAJaWYgKG0tPmZsYWdzICYgUEdfRklDVElUSU9VUykKIAkJcmV0dXJuOwpAQCAtMjQ4NCwxMiAr MjQ3OCwxMSBAQAogCQkJdm1fb2Zmc2V0X3QgcGJpdHMgPSAqKHZtX29mZnNldF90ICopcHRlOwog CiAJCQlpZiAocGJpdHMgJiBiaXQpIHsKLQkJCQlpZiAoYml0ID09IFBURV9SVykgewotCQkJCQlp ZiAocGJpdHMgJiBQVEVfTSkgeworCQkJCWlmIChiaXQgPT0gUEdfRCkgeworCQkJCQlpZiAocGJp dHMgJiBQR19EKSB7CiAJCQkJCQl2bV9wYWdlX2RpcnR5KG0pOwogCQkJCQl9Ci0JCQkJCSooaW50 ICopcHRlID0gKHBiaXRzICYgfihQVEVfTSB8IFBURV9SVykpIHwKLQkJCQkJICAgIFBURV9STzsK KwkJCQkJKihpbnQgKilwdGUgPSAocGJpdHMgJiB+UEdfRCkgfCBQR19STzsKIAkJCQl9IGVsc2Ug ewogCQkJCQkqKGludCAqKXB0ZSA9IHBiaXRzICYgfmJpdDsKIAkJCQl9CkBAIC0yNDk4LDcgKzI0 OTEsNyBAQAogCQl9CiAJCVBNQVBfVU5MT0NLKHB2LT5wdl9wbWFwKTsKIAl9Ci0JaWYgKCFzZXRl bSAmJiBiaXQgPT0gUFRFX1JXKQorCWlmICghc2V0ZW0gJiYgYml0ID09IFBHX0QpCiAJCXZtX3Bh Z2VfZmxhZ19jbGVhcihtLCBQR19XUklURUFCTEUpOwogfQogCkBAIC0yNTU1LDggKzI1NDgsNyBA QAogCWZvciAocHYgPSBUQUlMUV9GSVJTVCgmbS0+bWQucHZfbGlzdCk7IHB2OyBwdiA9IG5wdikg ewogCQlucHYgPSBUQUlMUV9ORVhUKHB2LCBwdl9wbGlzdCk7CiAJCXB0ZSA9IHBtYXBfcHRlKHB2 LT5wdl9wbWFwLCBwdi0+cHZfdmEpOwotCi0JCWlmICgocHRlID09IE5VTEwpIHx8ICFtaXBzX3Bn X3YoKnB0ZSkpCisJCWlmIChwdGUgPT0gTlVMTCB8fCAhcHRlX3Rlc3QocHRlLCBQR19WKSkKIAkJ CXBhbmljKCJwYWdlIG9uIHBtX3B2bGlzdCBoYXMgbm8gcHRlXG4iKTsKIAogCQl2YSA9IHB2LT5w dl92YTsKQEAgLTI2MDQsNyArMjU5Niw3IEBACiAJLyoKIAkgKiBJZiB0aGUgcGFnZSBpcyBub3Qg VlBPX0JVU1ksIHRoZW4gUEdfV1JJVEVBQkxFIGNhbm5vdCBiZQogCSAqIGNvbmN1cnJlbnRseSBz ZXQgd2hpbGUgdGhlIG9iamVjdCBpcyBsb2NrZWQuICBUaHVzLCBpZiBQR19XUklURUFCTEUKLQkg KiBpcyBjbGVhciwgbm8gUFRFcyBjYW4gaGF2ZSBQVEVfTSBzZXQuCisJICogaXMgY2xlYXIsIG5v IFBURXMgY2FuIGhhdmUgUEdfRCBzZXQuCiAJICovCiAJVk1fT0JKRUNUX0xPQ0tfQVNTRVJUKG0t Pm9iamVjdCwgTUFfT1dORUQpOwogCWlmICgobS0+b2ZsYWdzICYgVlBPX0JVU1kpID09IDAgJiYK QEAgLTI2MTQsNyArMjYwNiw3IEBACiAJaWYgKG0tPm1kLnB2X2ZsYWdzICYgUFZfVEFCTEVfTU9E KQogCQlydiA9IFRSVUU7CiAJZWxzZQotCQlydiA9IHBtYXBfdGVzdGJpdChtLCBQVEVfTSk7CisJ CXJ2ID0gcG1hcF90ZXN0Yml0KG0sIFBHX0QpOwogCXZtX3BhZ2VfdW5sb2NrX3F1ZXVlcygpOwog CXJldHVybiAocnYpOwogfQpAQCAtMjY1Nyw3ICsyNjQ5LDcgQEAKIAkgICAgKCJwbWFwX2NsZWFy X21vZGlmeTogcGFnZSAlcCBpcyBidXN5IiwgbSkpOwogCiAJLyoKLQkgKiBJZiB0aGUgcGFnZSBp cyBub3QgUEdfV1JJVEVBQkxFLCB0aGVuIG5vIFBURXMgY2FuIGhhdmUgUFRFX00gc2V0LgorCSAq IElmIHRoZSBwYWdlIGlzIG5vdCBQR19XUklURUFCTEUsIHRoZW4gbm8gUFRFcyBjYW4gaGF2ZSBQ R19EIHNldC4KIAkgKiBJZiB0aGUgb2JqZWN0IGNvbnRhaW5pbmcgdGhlIHBhZ2UgaXMgbG9ja2Vk IGFuZCB0aGUgcGFnZSBpcyBub3QKIAkgKiBWUE9fQlVTWSwgdGhlbiBQR19XUklURUFCTEUgY2Fu bm90IGJlIGNvbmN1cnJlbnRseSBzZXQuCiAJICovCkBAIC0yNjY1LDcgKzI2NTcsNyBAQAogCQly ZXR1cm47CiAJdm1fcGFnZV9sb2NrX3F1ZXVlcygpOwogCWlmIChtLT5tZC5wdl9mbGFncyAmIFBW X1RBQkxFX01PRCkgewotCQlwbWFwX2NoYW5nZWJpdChtLCBQVEVfTSwgRkFMU0UpOworCQlwbWFw X2NoYW5nZWJpdChtLCBQR19ELCBGQUxTRSk7CiAJCW0tPm1kLnB2X2ZsYWdzICY9IH5QVl9UQUJM RV9NT0Q7CiAJfQogCXZtX3BhZ2VfdW5sb2NrX3F1ZXVlcygpOwpAQCAtMjc4NCwxMiArMjc3Niwx MiBAQAogcmV0cnk6CiAJcHRlcCA9IHBtYXBfcHRlKHBtYXAsIGFkZHIpOwogCXB0ZSA9IChwdGVw ICE9IE5VTEwpID8gKnB0ZXAgOiAwOwotCWlmICghbWlwc19wZ192KHB0ZSkpIHsKKwlpZiAoIXB0 ZV90ZXN0KCZwdGUsIFBHX1YpKSB7CiAJCXZhbCA9IDA7CiAJCWdvdG8gb3V0OwogCX0KIAl2YWwg PSBNSU5DT1JFX0lOQ09SRTsKLQlpZiAoKHB0ZSAmIFBURV9NKSAhPSAwKQorCWlmIChwdGVfdGVz dCgmcHRlLCBQR19EKSkKIAkJdmFsIHw9IE1JTkNPUkVfTU9ESUZJRUQgfCBNSU5DT1JFX01PRElG SUVEX09USEVSOwogCXBhID0gVExCTE9fUFRFX1RPX1BBKHB0ZSk7CiAJbWFuYWdlZCA9IHBhZ2Vf aXNfbWFuYWdlZChwYSk7CkBAIC0yOTE1LDEzICsyOTA3LDEzIEBACiAJCQkJdW5zaWduZWQgYmFz ZSA9IGkgPDwgU0VHU0hJRlQ7CiAKIAkJCQlwZGUgPSAmcG1hcC0+cG1fc2VndGFiW2ldOwotCQkJ CWlmIChwZGUgJiYgcG1hcF9wZGVfdihwZGUpKSB7CisJCQkJaWYgKHBkZSAmJiAqcGRlICE9IDAp IHsKIAkJCQkJZm9yIChqID0gMDsgaiA8IDEwMjQ7IGorKykgewogCQkJCQkJdm1fb2Zmc2V0X3Qg dmEgPSBiYXNlICsKIAkJCQkJCShqIDw8IFBBR0VfU0hJRlQpOwogCiAJCQkJCQlwdGUgPSBwbWFw X3B0ZShwbWFwLCB2YSk7Ci0JCQkJCQlpZiAocHRlICYmIHBtYXBfcHRlX3YocHRlKSkgeworCQkJ CQkJaWYgKHB0ZSAmJiBwdGVfdGVzdChwdGUsIFBHX1YpKSB7CiAJCQkJCQkJdm1fb2Zmc2V0X3Qg cGE7CiAJCQkJCQkJdm1fcGFnZV90IG07CiAKQEAgLTMwNTgsMTYgKzMwNTAsMTYgQEAKIAlpbnQg cnc7CiAKIAlpZiAoIShwcm90ICYgVk1fUFJPVF9XUklURSkpCi0JCXJ3ID0gUFRFX1JPUEFHRTsK KwkJcncgPSAgUEdfViB8IFBHX1JPIHwgUEdfQ19DTkM7ICAvKiBST1BBR0UgKi8KIAllbHNlIGlm ICgobS0+ZmxhZ3MgJiAoUEdfRklDVElUSU9VUyB8IFBHX1VOTUFOQUdFRCkpID09IDApIHsKIAkJ aWYgKChtLT5tZC5wdl9mbGFncyAmIFBWX1RBQkxFX01PRCkgIT0gMCkKLQkJCXJ3ID0gUFRFX1JX UEFHRTsKKwkJCXJ3ID0gIFBHX1YgfCBQR19EIHwgUEdfQ19DTkM7IC8qIFJXUEFHRSAqLwogCQll bHNlCi0JCQlydyA9IFBURV9DV1BBR0U7CisJCQlydyA9IFBHX1YgfCBQR19DX0NOQzsgIC8qIENX UEFHRSAqLwogCQl2bV9wYWdlX2ZsYWdfc2V0KG0sIFBHX1dSSVRFQUJMRSk7CiAJfSBlbHNlCiAJ CS8qIE5lZWRuJ3QgZW11bGF0ZSBhIG1vZGlmaWVkIGJpdCBmb3IgdW5tYW5hZ2VkIHBhZ2VzLiAq LwotCQlydyA9IFBURV9SV1BBR0U7CisJCXJ3ID0gIFBHX1YgfCBQR19EIHwgUEdfQ19DTkM7IC8q IFJXUEFHRSAqLwogCXJldHVybiAocncpOwogfQogCkluZGV4OiBzeXMvbWlwcy9taXBzL21hY2hk ZXAuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBzeXMvbWlwcy9taXBzL21hY2hkZXAuYwkocmV2aXNpb24gMjA5 MjQzKQorKysgc3lzL21pcHMvbWlwcy9tYWNoZGVwLmMJKHdvcmtpbmcgY29weSkKQEAgLTQyMSw3 ICs0MjEsNyBAQAogCSAqIFdlIHVzZSBhIHdpcmVkIHRsYiBpbmRleCB0byBkbyB0aGlzIG9uZS10 aW1lIG1hcHBpbmcuCiAJICovCiAJcGEgPSB2dG9waHlzKHBjcHUpOwotCXB0ZSA9IFBURV9SVyB8 IFBURV9WIHwgUFRFX0cgfCBQVEVfQ0FDSEU7CisJcHRlID0gUEdfRCB8IFBHX1YgfCBQR19HIHwg UEdfQ19DTkM7CiAJdGxiX2luc2VydF93aXJlZChQQ1BVX1RMQl9FTlRSWSwgKHZtX29mZnNldF90 KXBjcHVwLAogCQkJIFRMQkxPX1BBX1RPX1BGTihwYSkgfCBwdGUsCiAJCQkgVExCTE9fUEFfVE9f UEZOKHBhICsgUEFHRV9TSVpFKSB8IHB0ZSk7CkluZGV4OiBzeXMvbWlwcy9taXBzL3RyYXAuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBzeXMvbWlwcy9taXBzL3RyYXAuYwkocmV2aXNpb24gMjA5MjQzKQorKysg c3lzL21pcHMvbWlwcy90cmFwLmMJKHdvcmtpbmcgY29weSkKQEAgLTMyNyw3ICszMjcsNyBAQAog I2lmZGVmIFNNUAogCQlwcmludGYoImNwdWlkID0gJWRcbiIsIFBDUFVfR0VUKGNwdWlkKSk7CiAj ZW5kaWYKLQkJTWFjaFRMQkdldFBJRChwaWQpOworCQlwaWQgPSBtaXBzX3JkX2VudHJ5aGkoKSAm IFRMQkhJX0FTSURfTUFTSzsKIAkJcHJpbnRmKCJiYWRhZGRyID0gJSNqeCwgcGMgPSAlI2p4LCBy YSA9ICUjangsIHNwID0gJSNqeCwgc3IgPSAlangsIHBpZCA9ICVkLCBBU0lEID0gJXVcbiIsCiAJ CSAgICAoaW50bWF4X3QpdHJhcGZyYW1lLT5iYWR2YWRkciwgKGludG1heF90KXRyYXBmcmFtZS0+ cGMsIChpbnRtYXhfdCl0cmFwZnJhbWUtPnJhLAogCQkgICAgKGludG1heF90KXRyYXBmcmFtZS0+ c3AsIChpbnRtYXhfdCl0cmFwZnJhbWUtPnNyLApAQCAtMzc4LDIzICszNzgsMjMgQEAKIAkJCQlw YW5pYygidHJhcDoga3RsYm1vZDogY2FuJ3QgZmluZCBQVEUiKTsKICNpZmRlZiBTTVAKIAkJCS8q IEl0IGlzIHBvc3NpYmxlIHRoYXQgc29tZSBvdGhlciBDUFUgY2hhbmdlZCBtLWJpdCAqLwotCQkJ aWYgKCFtaXBzX3BnX3YoKnB0ZSkgfHwgKCpwdGUgJiBtaXBzX3BnX21fYml0KCkpKSB7CisJCQlp ZiAoIXB0ZV90ZXN0KHB0ZSwgUEdfVikgfHwgcHRlX3Rlc3QocHRlLCBQR19EKSkgewogCQkJCXBt YXBfdXBkYXRlX3BhZ2Uoa2VybmVsX3BtYXAsCiAJCQkJICAgIHRyYXBmcmFtZS0+YmFkdmFkZHIs ICpwdGUpOwogCQkJCVBNQVBfVU5MT0NLKGtlcm5lbF9wbWFwKTsKIAkJCQlyZXR1cm4gKHRyYXBm cmFtZS0+cGMpOwogCQkJfQogI2Vsc2UKLQkJCWlmICghbWlwc19wZ192KCpwdGUpIHx8ICgqcHRl ICYgbWlwc19wZ19tX2JpdCgpKSkKKwkJCWlmICghcHRlX3Rlc3QocHRlLCBQR19WKSB8fCBwdGVf dGVzdChwdGUsIFBHX0QpKQogCQkJCXBhbmljKCJ0cmFwOiBrdGxibW9kOiBpbnZhbGlkIHB0ZSIp OwogI2VuZGlmCi0JCQlpZiAoKnB0ZSAmIG1pcHNfcGdfcm9fYml0KCkpIHsKKwkJCWlmIChwdGVf dGVzdChwdGUsIFBHX1JPKSkgewogCQkJCS8qIHdyaXRlIHRvIHJlYWQgb25seSBwYWdlIGluIHRo ZSBrZXJuZWwgKi8KIAkJCQlmdHlwZSA9IFZNX1BST1RfV1JJVEU7CiAJCQkJUE1BUF9VTkxPQ0so a2VybmVsX3BtYXApOwogCQkJCWdvdG8ga2VybmVsX2ZhdWx0OwogCQkJfQotCQkJKnB0ZSB8PSBt aXBzX3BnX21fYml0KCk7CisJCQlwdGVfc2V0KHB0ZSwgUEdfRCk7CiAJCQlwbWFwX3VwZGF0ZV9w YWdlKGtlcm5lbF9wbWFwLCB0cmFwZnJhbWUtPmJhZHZhZGRyLCAqcHRlKTsKIAkJCXBhID0gVExC TE9fUFRFX1RPX1BBKCpwdGUpOwogCQkJaWYgKCFwYWdlX2lzX21hbmFnZWQocGEpKQpAQCAtNDE3 LDIzICs0MTcsMjMgQEAKIAkJCQlwYW5pYygidHJhcDogdXRsYm1vZDogY2FuJ3QgZmluZCBQVEUi KTsKICNpZmRlZiBTTVAKIAkJCS8qIEl0IGlzIHBvc3NpYmxlIHRoYXQgc29tZSBvdGhlciBDUFUg Y2hhbmdlZCBtLWJpdCAqLwotCQkJaWYgKCFtaXBzX3BnX3YoKnB0ZSkgfHwgKCpwdGUgJiBtaXBz X3BnX21fYml0KCkpKSB7CisJCQlpZiAoIXB0ZV90ZXN0KHB0ZSwgUEdfVikgfHwgcHRlX3Rlc3Qo cHRlLCBQR19EKSkgewogCQkJCXBtYXBfdXBkYXRlX3BhZ2UocG1hcCwgdHJhcGZyYW1lLT5iYWR2 YWRkciwgKnB0ZSk7CiAJCQkJUE1BUF9VTkxPQ0socG1hcCk7CiAJCQkJZ290byBvdXQ7CiAJCQl9 CiAjZWxzZQotCQkJaWYgKCFtaXBzX3BnX3YoKnB0ZSkgfHwgKCpwdGUgJiBtaXBzX3BnX21fYml0 KCkpKQorCQkJaWYgKCFwdGVfdGVzdChwdGUsIFBHX1YpIHx8IHB0ZV90ZXN0KHB0ZSwgUEdfRCkp CiAJCQkJcGFuaWMoInRyYXA6IHV0bGJtb2Q6IGludmFsaWQgcHRlIik7CiAjZW5kaWYKIAotCQkJ aWYgKCpwdGUgJiBtaXBzX3BnX3JvX2JpdCgpKSB7CisJCQlpZiAocHRlX3Rlc3QocHRlLCBQR19S TykpIHsKIAkJCQkvKiB3cml0ZSB0byByZWFkIG9ubHkgcGFnZSAqLwogCQkJCWZ0eXBlID0gVk1f UFJPVF9XUklURTsKIAkJCQlQTUFQX1VOTE9DSyhwbWFwKTsKIAkJCQlnb3RvIGRvZmF1bHQ7CiAJ CQl9Ci0JCQkqcHRlIHw9IG1pcHNfcGdfbV9iaXQoKTsKKwkJCXB0ZV9zZXQocHRlLCBQR19EKTsK IAkJCXBtYXBfdXBkYXRlX3BhZ2UocG1hcCwgdHJhcGZyYW1lLT5iYWR2YWRkciwgKnB0ZSk7CiAJ CQlwYSA9IFRMQkxPX1BURV9UT19QQSgqcHRlKTsKIAkJCWlmICghcGFnZV9pc19tYW5hZ2VkKHBh KSkK --00c09f8e5b59fa198104893ba12e Content-Type: text/x-patch; charset=US-ASCII; name="pmap-lgmem-lock-remove.patch" Content-Disposition: attachment; filename="pmap-lgmem-lock-remove.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gajrcc4x5 SW5kZXg6IHN5cy9taXBzL21pcHMvcG1hcC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHN5cy9taXBzL21pcHMv cG1hcC5jCShyZXZpc2lvbiAyMDkyNDMpCisrKyBzeXMvbWlwcy9taXBzL3BtYXAuYwkod29ya2lu ZyBjb3B5KQpAQCAtMTk1LDcgKzE5NSw2IEBACiBzdGF0aWMgdW1hX3pvbmVfdCBwdHBnem9uZTsK IAogc3RydWN0IGxvY2FsX3N5c21hcHMgewotCXN0cnVjdCBtdHggbG9jazsKIAl2bV9vZmZzZXRf dCBiYXNlOwogCXVpbnQxNl90IHZhbGlkMSwgdmFsaWQyOwogfTsKQEAgLTIxNCwxMSArMjEzLDkg QEAKIAlzdHJ1Y3QgbG9jYWxfc3lzbWFwcyAqc3lzbTsJCQkJCVwKIAlwdF9lbnRyeV90ICpwdGUs IG5wdGU7CQkJCQkJXAogCQkJCQkJCQkJXAorCWludHIgPSBpbnRyX2Rpc2FibGUoKTsJCQkJCQlc CiAJY3B1ID0gUENQVV9HRVQoY3B1aWQpOwkJCQkJCVwKIAlzeXNtID0gJnN5c21hcF9sbWVtW2Nw dV07CQkJCQlcCi0JUE1BUF9MR01FTV9MT0NLKHN5c20pOwkJCQkJCVwKLQlpbnRyID0gaW50cl9k aXNhYmxlKCk7CQkJCQkJXAotCXNjaGVkX3BpbigpOwkJCQkJCQlcCiAJdmEgPSBzeXNtLT5iYXNl OwkJCQkJCVwKIAlucHRlID0gVExCTE9fUEFfVE9fUEZOKHBoeXMpIHwJCQkJCVwKIAkgICAgUFRF X1JXIHwgUFRFX1YgfCBQVEVfRyB8IFBURV9XIHwgUFRFX0NBQ0hFOwkJCVwKQEAgLTIzMSwxMSAr MjI4LDkgQEAKIAlzdHJ1Y3QgbG9jYWxfc3lzbWFwcyAqc3lzbTsJCQkJCVwKIAlwdF9lbnRyeV90 ICpwdGUsIG5wdGU7CQkJCQkJXAogCQkJCQkJCQkJXAorCWludHIgPSBpbnRyX2Rpc2FibGUoKTsJ CQkJCQlcCiAJY3B1ID0gUENQVV9HRVQoY3B1aWQpOwkJCQkJCVwKIAlzeXNtID0gJnN5c21hcF9s bWVtW2NwdV07CQkJCQlcCi0JUE1BUF9MR01FTV9MT0NLKHN5c20pOwkJCQkJCVwKLQlpbnRyID0g aW50cl9kaXNhYmxlKCk7CQkJCQkJXAotCXNjaGVkX3BpbigpOwkJCQkJCQlcCiAJdmExID0gc3lz bS0+YmFzZTsJCQkJCQlcCiAJdmEyID0gc3lzbS0+YmFzZSArIFBBR0VfU0laRTsJCQkJCVwKIAlu cHRlID0gVExCTE9fUEFfVE9fUEZOKHBoeXMxKSB8CQkJCQlcCkBAIC0yNTgsOSArMjUzLDcgQEAK IAkqcHRlID0gUFRFX0c7CQkJCQkJCVwKIAl0bGJfaW52YWxpZGF0ZV9hZGRyZXNzKGtlcm5lbF9w bWFwLCBzeXNtLT5iYXNlICsgUEFHRV9TSVpFKTsJXAogCXN5c20tPnZhbGlkMiA9IDA7CQkJCQkJ XAotCXNjaGVkX3VucGluKCk7CQkJCQkJCVwKIAlpbnRyX3Jlc3RvcmUoaW50cik7CQkJCQkJXAot CVBNQVBfTEdNRU1fVU5MT0NLKHN5c20pCiAKIHBkX2VudHJ5X3QKIHBtYXBfc2VnbWFwKHBtYXBf dCBwbWFwLCB2bV9vZmZzZXRfdCB2YSkKQEAgLTQzNiw3ICs0MjksNiBAQAogCQkJc3lzbWFwX2xt ZW1baV0uYmFzZSA9IHZpcnR1YWxfYXZhaWw7CiAJCQl2aXJ0dWFsX2F2YWlsICs9IFBBR0VfU0la RSAqIDI7CiAJCQlzeXNtYXBfbG1lbVtpXS52YWxpZDEgPSBzeXNtYXBfbG1lbVtpXS52YWxpZDIg PSAwOwotCQkJUE1BUF9MR01FTV9MT0NLX0lOSVQoJnN5c21hcF9sbWVtW2ldKTsKIAkJfQogCX0K IApJbmRleDogc3lzL21pcHMvaW5jbHVkZS9wbWFwLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gc3lzL21pcHMv aW5jbHVkZS9wbWFwLmgJKHJldmlzaW9uIDIwOTI0MykKKysrIHN5cy9taXBzL2luY2x1ZGUvcG1h cC5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMTYsMTIgKzExNiw2IEBACiAjZGVmaW5lCVBNQVBfVFJZ TE9DSyhwbWFwKQltdHhfdHJ5bG9jaygmKHBtYXApLT5wbV9tdHgpCiAjZGVmaW5lCVBNQVBfVU5M T0NLKHBtYXApCW10eF91bmxvY2soJihwbWFwKS0+cG1fbXR4KQogCi0jZGVmaW5lIFBNQVBfTEdN RU1fTE9DS19JTklUKHN5c21hcCkgbXR4X2luaXQoJihzeXNtYXApLT5sb2NrLCAicG1hcC1sZ21l bSIsIFwKLQkJCQkgICAgInBlci1jcHUtbWFwIiwgKE1UWF9ERUZ8IE1UWF9EVVBPSykpCi0jZGVm aW5lIFBNQVBfTEdNRU1fTE9DSyhzeXNtYXApIG10eF9sb2NrKCYoc3lzbWFwKS0+bG9jaykKLSNk ZWZpbmUgUE1BUF9MR01FTV9VTkxPQ0soc3lzbWFwKSBtdHhfdW5sb2NrKCYoc3lzbWFwKS0+bG9j aykKLSNkZWZpbmUgUE1BUF9MR01FTV9ERVNUUk9ZKHN5c21hcCkgbXR4X2Rlc3Ryb3koJihzeXNt YXApLT5sb2NrKQotCiAvKgogICogRm9yIGVhY2ggdm1fcGFnZV90LCB0aGVyZSBpcyBhIGxpc3Qg b2YgYWxsIGN1cnJlbnRseSB2YWxpZCB2aXJ0dWFsCiAgKiBtYXBwaW5ncyBvZiB0aGF0IHBhZ2Uu ICBBbiBlbnRyeSBpcyBhIHB2X2VudHJ5X3QsIHRoZSBsaXN0IGlzIHB2X3RhYmxlLgo= --00c09f8e5b59fa198104893ba12e-- From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 15:48:43 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id B6D351065675; Thu, 17 Jun 2010 15:48:43 +0000 (UTC) (envelope-from rrs@lakerest.net) Received: from lakerest.net (unknown [IPv6:2001:240:585:2:213:d4ff:fef3:2d8d]) by mx1.freebsd.org (Postfix) with ESMTP id 3BA5B8FC12; Thu, 17 Jun 2010 15:48:43 +0000 (UTC) Received: from [192.168.1.69] (pool-70-109-12-150.atl.dsl-w.verizon.net [70.109.12.150]) (authenticated bits=0) by lakerest.net (8.14.3/8.14.3) with ESMTP id o5HFmTY4039953 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NOT); Thu, 17 Jun 2010 11:48:35 -0400 (EDT) (envelope-from rrs@lakerest.net) DKIM-Signature: a=rsa-sha1; c=simple/simple; d=lakerest.net; s=mail; t=1276789716; h=Cc:Message-Id:From:To:In-Reply-To:Content-Type: Content-Transfer-Encoding:Mime-Version:Subject:Date:References: X-Mailer; b=glnammWRP5pjneWUxxmjsljShz0L1D7dLEt0QV9DhqDsGG5bit9wz4X RetwxPM1MT5HoJWnmBVxSWJFCstPvQg== Message-Id: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> From: Randall Stewart To: "Jayachandran C." In-Reply-To: Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes Content-Transfer-Encoding: 7bit Mime-Version: 1.0 (Apple Message framework v936) Date: Thu, 17 Jun 2010 11:48:24 -0400 References: X-Mailer: Apple Mail (2.936) Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 15:48:43 -0000 JC: I don't think renaming the PTE entries to PG_ is a good idea. Way back in 2007 this was one of the issues I hit.. the J code used PG_ and somewhere in the VM we used PG_ to indicate (Page). Thus we ended up with a PG_G defined in two places and we were setting PG_G and it was Not the PTE PG_G.. but the one defined in the VM. The folks in the VM world suggested we change this to PTE_xxx which I did. R On Jun 17, 2010, at 11:38 AM, Jayachandran C. wrote: > On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. > wrote: >> I have volunteered to merge Juli's 64-bit work into HEAD, and >> hopefully get it to work on XLR too. The tree >> (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of >> changes, so I would like to do this over multiple changesets and >> without breaking the current o32 code. > > Here's part 2, containing two patches: > > pmap-PTE-to-PG.patch : > > This is a renaming patch with minor cleanup, The PTE_* flags are > renamed to PG_ and related changes are made to other files. I have > tried to make this patch limited to just the renaming and the changes > related to it. I will make another patch for the rest of the minor > changes in pmap.c. > > My comment on this patch: The name PG_C_CNC for value 3 in pte.h may > be confusing, at least on XLR. We don't have cached non-coherent mode, > the cached memory is coherent(except L1 I-cache), so I would prefer > PG_CACHED and PG_UNCACHED names. > > pmap-lgmem-lock-remove.patch : > > Remove the lock in local_sysmaps, and sched_pin()/unpin() in the > PMAP_LMEM_ macros. > > The 64-bit support changes would be next - comments on the patches > esp. the first one is welcome. > > Thanks, > JC. > ------------------------------ Randall Stewart 803-317-4952 (cell) From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 16:08:28 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id D6B8E1065673; Thu, 17 Jun 2010 16:08:28 +0000 (UTC) (envelope-from imp@bsdimp.com) Received: from harmony.bsdimp.com (bsdimp.com [199.45.160.85]) by mx1.freebsd.org (Postfix) with ESMTP id 7B2C98FC1A; Thu, 17 Jun 2010 16:08:28 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by harmony.bsdimp.com (8.14.3/8.14.1) with ESMTP id o5HG2VlI070033; Thu, 17 Jun 2010 10:02:31 -0600 (MDT) (envelope-from imp@bsdimp.com) Date: Thu, 17 Jun 2010 10:02:35 -0600 (MDT) Message-Id: <20100617.100235.195066307596264499.imp@bsdimp.com> To: rrs@lakerest.net From: "M. Warner Losh" In-Reply-To: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> References: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> X-Mailer: Mew version 6.3 on Emacs 22.3 / Mule 5.0 (SAKAKI) Mime-Version: 1.0 Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 16:08:28 -0000 In message: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> Randall Stewart writes: : JC: : : I don't think renaming the PTE entries to PG_ is a good idea. : : Way back in 2007 this was one of the issues I hit.. the J code : used PG_ and somewhere in the VM we used PG_ to indicate (Page). : : Thus we ended up with a PG_G defined in two places and we were setting : PG_G and it was Not the PTE PG_G.. but the one defined in the VM. This was a big frustration at the time... I'd somehow blocked it from my memory when Juli and I talked about this a while ago... : The folks in the VM world suggested we change this to PTE_xxx which I : did. Alan Cox, if memory serves. Warner : R : On Jun 17, 2010, at 11:38 AM, Jayachandran C. wrote: : : > On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. : > wrote: : >> I have volunteered to merge Juli's 64-bit work into HEAD, and : >> hopefully get it to work on XLR too. The tree : >> (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit of : >> changes, so I would like to do this over multiple changesets and : >> without breaking the current o32 code. : > : > Here's part 2, containing two patches: : > : > pmap-PTE-to-PG.patch : : > : > This is a renaming patch with minor cleanup, The PTE_* flags are : > renamed to PG_ and related changes are made to other files. I have : > tried to make this patch limited to just the renaming and the changes : > related to it. I will make another patch for the rest of the minor : > changes in pmap.c. : > : > My comment on this patch: The name PG_C_CNC for value 3 in pte.h may : > be confusing, at least on XLR. We don't have cached non-coherent mode, : > the cached memory is coherent(except L1 I-cache), so I would prefer : > PG_CACHED and PG_UNCACHED names. : > : > pmap-lgmem-lock-remove.patch : : > : > Remove the lock in local_sysmaps, and sched_pin()/unpin() in the : > PMAP_LMEM_ macros. : > : > The 64-bit support changes would be next - comments on the patches : > esp. the first one is welcome. : > : > Thanks, : > JC. : > : : ------------------------------ : Randall Stewart : 803-317-4952 (cell) : : From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 16:23:11 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 892741065673; Thu, 17 Jun 2010 16:23:11 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-yx0-f182.google.com (mail-yx0-f182.google.com [209.85.213.182]) by mx1.freebsd.org (Postfix) with ESMTP id 2E3FC8FC15; Thu, 17 Jun 2010 16:23:10 +0000 (UTC) Received: by yxm34 with SMTP id 34so2890671yxm.13 for ; Thu, 17 Jun 2010 09:23:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:in-reply-to :references:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=gmmJl7bP1U1Tap1Q7BE+4hq5+M+Wpxf1ZvKj80a5kFs=; b=MxF7k54Sac4uUQS3ouyAYzN+q3YRv95/GA4YnuokRpudM2LI6sGHdfseexUDovNWe4 RmREHBLjN/4t5M0Oj63GQguOWU5yqNjxtn00IGiOw/msEiOi54IYRohYSMAaZEckr1eK 6cWSH3bOoiNcwYsTrabr5lcq6jdlwOUluCjs0= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=ZcCiAnj5wAExa243jcrpYDjmRxgoAQlQUvUP58+s/N/U45xEcslAL05i3BfY6MXVIU 180RNCkUvyakhV8SLxNByDuVg/9mkt5KG+yZy28a95M+TS7cF/yrdrKUUgNgw5+TxNwP ljaX2cTirc1lahJrYKS4GBkqc5xdb7GkDRAxk= MIME-Version: 1.0 Received: by 10.224.39.66 with SMTP id f2mr5159134qae.157.1276791790073; Thu, 17 Jun 2010 09:23:10 -0700 (PDT) Received: by 10.224.37.139 with HTTP; Thu, 17 Jun 2010 09:23:09 -0700 (PDT) In-Reply-To: <20100617.100235.195066307596264499.imp@bsdimp.com> References: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> <20100617.100235.195066307596264499.imp@bsdimp.com> Date: Thu, 17 Jun 2010 21:53:09 +0530 Message-ID: From: "Jayachandran C." To: "M. Warner Losh" Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 16:23:11 -0000 On Thu, Jun 17, 2010 at 9:32 PM, M. Warner Losh wrote: > In message: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> > =A0 =A0 =A0 =A0 =A0 =A0Randall Stewart writes: > : JC: > : > : I don't think renaming the PTE entries to PG_ is a good idea. > : > : Way back in 2007 this was one of the issues I hit.. the J code > : used PG_ and somewhere in the VM we used PG_ to indicate (Page). > : > : Thus we ended up with a PG_G defined in two places and we were setting > : PG_G and it was Not the PTE PG_G.. but the one defined in the VM. > > This was a big frustration at the time... =A0I'd somehow blocked it from > my memory when Juli and I talked about this a while ago... > > : The folks in the VM world suggested we change this to PTE_xxx which I > : did. > > Alan Cox, if memory serves. I had tested the changes (buildworld on 32 cpus) , so there is a chance that the problem no longer exists. There is one minor cleanup in the patch that can be done (ie unify the mips_pg and pmap_pte macros). But the renaming itself does not seem to buy us anything. I will wait for Juli's comments too, as she is the original author of the patch... JC. > Warner > > : R > : On Jun 17, 2010, at 11:38 AM, Jayachandran C. wrote: > : > : > On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. > : > wrote: > : >> I have volunteered to merge Juli's 64-bit work into HEAD, =A0and > : >> hopefully get it to work on XLR too. The tree > : >> (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a bit o= f > : >> changes, so I would like to do this over multiple changesets and > : >> without breaking the current o32 code. > : > > : > Here's part 2, containing two patches: > : > > : > pmap-PTE-to-PG.patch : > : > > : > This is a renaming patch with minor cleanup, The PTE_* flags are > : > renamed to PG_ and related changes are made to other files. I have > : > tried to make this patch limited to just the renaming and the changes > : > related to it. =A0I will make another patch for the rest of the minor > : > changes in pmap.c. > : > > : > My comment on this patch: The name PG_C_CNC for value 3 in pte.h may > : > be confusing, at least on XLR. We don't have cached non-coherent mode= , > : > the cached memory is coherent(except L1 I-cache), so I would prefer > : > PG_CACHED and PG_UNCACHED names. > : > > : > pmap-lgmem-lock-remove.patch : > : > > : > Remove the lock in local_sysmaps, and sched_pin()/unpin() in the > : > PMAP_LMEM_ macros. > : > > : > The 64-bit support changes would be next - comments on the patches > : > esp. the first one is welcome. > : > > : > Thanks, > : > JC. > : > > : > : ------------------------------ > : Randall Stewart > : 803-317-4952 (cell) > : > : > --=20 C. Jayachandran c.jayachandran@gmail.com From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 16:40:46 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 525B1106566C; Thu, 17 Jun 2010 16:40:46 +0000 (UTC) (envelope-from rrs@lakerest.net) Received: from lakerest.net (unknown [IPv6:2001:240:585:2:213:d4ff:fef3:2d8d]) by mx1.freebsd.org (Postfix) with ESMTP id 068388FC16; Thu, 17 Jun 2010 16:40:45 +0000 (UTC) Received: from [192.168.1.69] (pool-70-109-12-150.atl.dsl-w.verizon.net [70.109.12.150]) (authenticated bits=0) by lakerest.net (8.14.3/8.14.3) with ESMTP id o5HGeZHM042323 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NOT); Thu, 17 Jun 2010 12:40:42 -0400 (EDT) (envelope-from rrs@lakerest.net) DKIM-Signature: a=rsa-sha1; c=simple/simple; d=lakerest.net; s=mail; t=1276792843; h=Cc:Message-Id:From:To:In-Reply-To:Content-Type: Content-Transfer-Encoding:Mime-Version:Subject:Date:References: X-Mailer; b=zvGTZKtuimKqDjvgE9IjkybxXqqq2vDEdKGv14rbDwsQyJzIf0vr+aY 5kzC9DnAoceMSrAIXCiVwT3UM4pkrow== Message-Id: <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> From: Randall Stewart To: "Jayachandran C." In-Reply-To: Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes Content-Transfer-Encoding: 7bit Mime-Version: 1.0 (Apple Message framework v936) Date: Thu, 17 Jun 2010 12:40:30 -0400 References: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> <20100617.100235.195066307596264499.imp@bsdimp.com> X-Mailer: Apple Mail (2.936) Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 16:40:46 -0000 On Jun 17, 2010, at 12:23 PM, Jayachandran C. wrote: > On Thu, Jun 17, 2010 at 9:32 PM, M. Warner Losh > wrote: >> In message: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> >> Randall Stewart writes: >> : JC: >> : >> : I don't think renaming the PTE entries to PG_ is a good idea. >> : >> : Way back in 2007 this was one of the issues I hit.. the J code >> : used PG_ and somewhere in the VM we used PG_ to indicate (Page). >> : >> : Thus we ended up with a PG_G defined in two places and we were >> setting >> : PG_G and it was Not the PTE PG_G.. but the one defined in the VM. >> >> This was a big frustration at the time... I'd somehow blocked it >> from >> my memory when Juli and I talked about this a while ago... >> >> : The folks in the VM world suggested we change this to PTE_xxx >> which I >> : did. >> >> Alan Cox, if memory serves. > > I had tested the changes (buildworld on 32 cpus) , so there is a > chance that the problem no longer exists. > > There is one minor cleanup in the patch that can be done (ie unify the > mips_pg and pmap_pte macros). But the renaming itself does not seem to > buy us anything. > > I will wait for Juli's comments too, as she is the original author of > the patch... > But JC: I don't understand why you have this urge to move PTE_xxx -> PG_xxx a) We had that and changed that b) Alan (I think you are right here Warner it was Alan that made the suggestion) suggested the changes to PTE_xx So what are your reasons for wanting to do this? R > JC. > > >> Warner >> >> : R >> : On Jun 17, 2010, at 11:38 AM, Jayachandran C. wrote: >> : >> : > On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. >> : > wrote: >> : >> I have volunteered to merge Juli's 64-bit work into HEAD, and >> : >> hopefully get it to work on XLR too. The tree >> : >> (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a >> bit of >> : >> changes, so I would like to do this over multiple changesets and >> : >> without breaking the current o32 code. >> : > >> : > Here's part 2, containing two patches: >> : > >> : > pmap-PTE-to-PG.patch : >> : > >> : > This is a renaming patch with minor cleanup, The PTE_* flags are >> : > renamed to PG_ and related changes are made to other files. I >> have >> : > tried to make this patch limited to just the renaming and the >> changes >> : > related to it. I will make another patch for the rest of the >> minor >> : > changes in pmap.c. >> : > >> : > My comment on this patch: The name PG_C_CNC for value 3 in >> pte.h may >> : > be confusing, at least on XLR. We don't have cached non- >> coherent mode, >> : > the cached memory is coherent(except L1 I-cache), so I would >> prefer >> : > PG_CACHED and PG_UNCACHED names. >> : > >> : > pmap-lgmem-lock-remove.patch : >> : > >> : > Remove the lock in local_sysmaps, and sched_pin()/unpin() in the >> : > PMAP_LMEM_ macros. >> : > >> : > The 64-bit support changes would be next - comments on the >> patches >> : > esp. the first one is welcome. >> : > >> : > Thanks, >> : > JC. >> : > >> : >> : ------------------------------ >> : Randall Stewart >> : 803-317-4952 (cell) >> : >> : >> > > > > -- > C. Jayachandran c.jayachandran@gmail.com > ------------------------------ Randall Stewart 803-317-4952 (cell) From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 16:42:16 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 583D5106564A; Thu, 17 Jun 2010 16:42:16 +0000 (UTC) (envelope-from rrs@lakerest.net) Received: from lakerest.net (unknown [IPv6:2001:240:585:2:213:d4ff:fef3:2d8d]) by mx1.freebsd.org (Postfix) with ESMTP id 0C6C98FC17; Thu, 17 Jun 2010 16:42:15 +0000 (UTC) Received: from [192.168.1.69] (pool-70-109-12-150.atl.dsl-w.verizon.net [70.109.12.150]) (authenticated bits=0) by lakerest.net (8.14.3/8.14.3) with ESMTP id o5HGg7YJ042385 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NOT); Thu, 17 Jun 2010 12:42:12 -0400 (EDT) (envelope-from rrs@lakerest.net) DKIM-Signature: a=rsa-sha1; c=simple/simple; d=lakerest.net; s=mail; t=1276792933; h=Cc:Message-Id:From:To:In-Reply-To:Content-Type: Content-Transfer-Encoding:Mime-Version:Subject:Date:References: X-Mailer; b=2BRgywkELGmOcgb/1aiUTVbW/olGooSGEz8Uu+4YrhLdRLSXG/41pLy a+i5l/tttAhSQbfiQRnJj+fQWPxbnRw== Message-Id: From: Randall Stewart To: "Jayachandran C." In-Reply-To: Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes Content-Transfer-Encoding: 7bit Mime-Version: 1.0 (Apple Message framework v936) Date: Thu, 17 Jun 2010 12:42:01 -0400 References: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> <20100617.100235.195066307596264499.imp@bsdimp.com> X-Mailer: Apple Mail (2.936) Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 16:42:16 -0000 Just as a pointer.. Go look at sys/vm/vm_page.h You will find lots of PG_xxxx things in there. I strongly suggest you roll these back out.. if that means changing some of Juli's patches.. I think thats fine ;-) Juli: any comment? R On Jun 17, 2010, at 12:23 PM, Jayachandran C. wrote: > On Thu, Jun 17, 2010 at 9:32 PM, M. Warner Losh > wrote: >> In message: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> >> Randall Stewart writes: >> : JC: >> : >> : I don't think renaming the PTE entries to PG_ is a good idea. >> : >> : Way back in 2007 this was one of the issues I hit.. the J code >> : used PG_ and somewhere in the VM we used PG_ to indicate (Page). >> : >> : Thus we ended up with a PG_G defined in two places and we were >> setting >> : PG_G and it was Not the PTE PG_G.. but the one defined in the VM. >> >> This was a big frustration at the time... I'd somehow blocked it >> from >> my memory when Juli and I talked about this a while ago... >> >> : The folks in the VM world suggested we change this to PTE_xxx >> which I >> : did. >> >> Alan Cox, if memory serves. > > I had tested the changes (buildworld on 32 cpus) , so there is a > chance that the problem no longer exists. > > There is one minor cleanup in the patch that can be done (ie unify the > mips_pg and pmap_pte macros). But the renaming itself does not seem to > buy us anything. > > I will wait for Juli's comments too, as she is the original author of > the patch... > > JC. > > >> Warner >> >> : R >> : On Jun 17, 2010, at 11:38 AM, Jayachandran C. wrote: >> : >> : > On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. >> : > wrote: >> : >> I have volunteered to merge Juli's 64-bit work into HEAD, and >> : >> hopefully get it to work on XLR too. The tree >> : >> (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a >> bit of >> : >> changes, so I would like to do this over multiple changesets and >> : >> without breaking the current o32 code. >> : > >> : > Here's part 2, containing two patches: >> : > >> : > pmap-PTE-to-PG.patch : >> : > >> : > This is a renaming patch with minor cleanup, The PTE_* flags are >> : > renamed to PG_ and related changes are made to other files. I >> have >> : > tried to make this patch limited to just the renaming and the >> changes >> : > related to it. I will make another patch for the rest of the >> minor >> : > changes in pmap.c. >> : > >> : > My comment on this patch: The name PG_C_CNC for value 3 in >> pte.h may >> : > be confusing, at least on XLR. We don't have cached non- >> coherent mode, >> : > the cached memory is coherent(except L1 I-cache), so I would >> prefer >> : > PG_CACHED and PG_UNCACHED names. >> : > >> : > pmap-lgmem-lock-remove.patch : >> : > >> : > Remove the lock in local_sysmaps, and sched_pin()/unpin() in the >> : > PMAP_LMEM_ macros. >> : > >> : > The 64-bit support changes would be next - comments on the >> patches >> : > esp. the first one is welcome. >> : > >> : > Thanks, >> : > JC. >> : > >> : >> : ------------------------------ >> : Randall Stewart >> : 803-317-4952 (cell) >> : >> : >> > > > > -- > C. Jayachandran c.jayachandran@gmail.com > ------------------------------ Randall Stewart 803-317-4952 (cell) From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 17:07:31 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 95C73106566C; Thu, 17 Jun 2010 17:07:31 +0000 (UTC) (envelope-from imp@bsdimp.com) Received: from harmony.bsdimp.com (bsdimp.com [199.45.160.85]) by mx1.freebsd.org (Postfix) with ESMTP id 445928FC0C; Thu, 17 Jun 2010 17:07:31 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by harmony.bsdimp.com (8.14.3/8.14.1) with ESMTP id o5HH50Dm070954; Thu, 17 Jun 2010 11:05:00 -0600 (MDT) (envelope-from imp@bsdimp.com) Date: Thu, 17 Jun 2010 11:05:04 -0600 (MDT) Message-Id: <20100617.110504.200754750200158040.imp@bsdimp.com> To: rrs@lakerest.net From: "M. Warner Losh" In-Reply-To: <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> X-Mailer: Mew version 6.3 on Emacs 22.3 / Mule 5.0 (SAKAKI) Mime-Version: 1.0 Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 17:07:31 -0000 In message: <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> Randall Stewart writes: : : On Jun 17, 2010, at 12:23 PM, Jayachandran C. wrote: : : > On Thu, Jun 17, 2010 at 9:32 PM, M. Warner Losh : > wrote: : >> In message: <98F8CB29-62FE-41A6-8AE6-6F8AF086D29C@lakerest.net> : >> Randall Stewart writes: : >> : JC: : >> : : >> : I don't think renaming the PTE entries to PG_ is a good idea. : >> : : >> : Way back in 2007 this was one of the issues I hit.. the J code : >> : used PG_ and somewhere in the VM we used PG_ to indicate (Page). : >> : : >> : Thus we ended up with a PG_G defined in two places and we were : >> setting : >> : PG_G and it was Not the PTE PG_G.. but the one defined in the VM. : >> : >> This was a big frustration at the time... I'd somehow blocked it from : >> my memory when Juli and I talked about this a while ago... : >> : >> : The folks in the VM world suggested we change this to PTE_xxx which : >> I : >> : did. : >> : >> Alan Cox, if memory serves. : > : > I had tested the changes (buildworld on 32 cpus) , so there is a : > chance that the problem no longer exists. : > : > There is one minor cleanup in the patch that can be done (ie unify the : > mips_pg and pmap_pte macros). But the renaming itself does not seem to : > buy us anything. : > : > I will wait for Juli's comments too, as she is the original author of : > the patch... : > : : But JC: : : I don't understand why you have this urge to move PTE_xxx -> PG_xxx : : a) We had that and changed that : b) Alan (I think you are right here Warner it was Alan that made the : suggestion) suggested : the changes to PTE_xx : : : So what are your reasons for wanting to do this? It was also a name-space collision, so we were using PG_x instead of PG_y in the PTE code due to the overlap. Maybe it all works now, but that was the motivation for the change. Warner : R : : : > JC. : > : > : >> Warner : >> : >> : R : >> : On Jun 17, 2010, at 11:38 AM, Jayachandran C. wrote: : >> : : >> : > On Tue, Jun 15, 2010 at 7:06 PM, Jayachandran C. : >> : > wrote: : >> : >> I have volunteered to merge Juli's 64-bit work into HEAD, and : >> : >> hopefully get it to work on XLR too. The tree : >> : >> (http://svn.freebsd.org/base/user/jmallett/octeon) has quite a : >> bit of : >> : >> changes, so I would like to do this over multiple changesets and : >> : >> without breaking the current o32 code. : >> : > : >> : > Here's part 2, containing two patches: : >> : > : >> : > pmap-PTE-to-PG.patch : : >> : > : >> : > This is a renaming patch with minor cleanup, The PTE_* flags are : >> : > renamed to PG_ and related changes are made to other files. I have : >> : > tried to make this patch limited to just the renaming and the : >> changes : >> : > related to it. I will make another patch for the rest of the : >> minor : >> : > changes in pmap.c. : >> : > : >> : > My comment on this patch: The name PG_C_CNC for value 3 in pte.h : >> may : >> : > be confusing, at least on XLR. We don't have cached non-coherent : >> mode, : >> : > the cached memory is coherent(except L1 I-cache), so I would : >> prefer : >> : > PG_CACHED and PG_UNCACHED names. : >> : > : >> : > pmap-lgmem-lock-remove.patch : : >> : > : >> : > Remove the lock in local_sysmaps, and sched_pin()/unpin() in the : >> : > PMAP_LMEM_ macros. : >> : > : >> : > The 64-bit support changes would be next - comments on the patches : >> : > esp. the first one is welcome. : >> : > : >> : > Thanks, : >> : > JC. : >> : > : >> : : >> : ------------------------------ : >> : Randall Stewart : >> : 803-317-4952 (cell) : >> : : >> : : >> : > : > : > : > -- : > C. Jayachandran c.jayachandran@gmail.com : > : : ------------------------------ : Randall Stewart : 803-317-4952 (cell) : : From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 18:35:47 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 3D360106564A for ; Thu, 17 Jun 2010 18:35:47 +0000 (UTC) (envelope-from felipe.no88@yahoo.com.br) Received: from web45815.mail.sp1.yahoo.com (web45815.mail.sp1.yahoo.com [68.180.199.60]) by mx1.freebsd.org (Postfix) with SMTP id 1D15B8FC0A for ; Thu, 17 Jun 2010 18:35:46 +0000 (UTC) Received: (qmail 76288 invoked by uid 60001); 17 Jun 2010 18:09:06 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yahoo.com.br; s=s1024; t=1276798146; bh=CtQ0uD9+pDcXieKxFsb+6g0sydCU6dfZl4dv+/n1F7c=; h=Message-ID:X-YMail-OSG:Received:X-Mailer:Date:From:Subject:To:MIME-Version:Content-Type; b=Euudq7kGUH0x0d98XCcqx963nvtyds/1rlPWLlAMq41xUylJiVYGp8FmoVDfxJ92pJdihpIW/qZps0xhPybp12E05ExDC7mpU7DlqLtIq1buP+e0iwWs1++PGg+gC5LSI2+PrmP89iqgM7sa/dH+LGylmKDSST78Z611HLME268= DomainKey-Signature: a=rsa-sha1; q=dns; c=nofws; s=s1024; d=yahoo.com.br; h=Message-ID:X-YMail-OSG:Received:X-Mailer:Date:From:Subject:To:MIME-Version:Content-Type; b=QMICClxJhnayZEh1wNOXwNM4ct2KqjWycjPWqoX/XpAfQEC4uga40QOSmT78aDKUO6bCnImx17eoS3Y0R2FYLQKGG824RpC8NN6WumWngj7DmdeipZKqj2GgizgrpDNy1oBfQB4W/rqmUk5mOVmitufTkahjqzeiiAgwiwxQZpo=; Message-ID: <259623.75989.qm@web45815.mail.sp1.yahoo.com> X-YMail-OSG: NAwIsSMVM1nnJJrK4MukcTi2ktaiHi6wlw7o5J23QiaqWOC .zAZAxO1OVeICLw.I0m2bmygc5NPievJN1D7y8mSfkNwbz5bI4hW2F3tyZE3 j9oFZp3xNmnxB0ypAzGzOdzRxVPgVP0i57NshEKfSHbqX0W9JbvAlu0OYdjS fuk4N4_.SlPHlHBtj3gelcvvW.e4RpfQWDyRJz_YTgxIJ_lkDDeeUtuqNXeB W8__nx.R1V1HCPcNXwOxYvrZDhnWihwt_UfAKPVdY.XowznpAkzV440McYZC DXeTwgVLfGAxc Received: from [201.55.136.253] by web45815.mail.sp1.yahoo.com via HTTP; Thu, 17 Jun 2010 11:09:06 PDT X-Mailer: YahooMailRC/397.8 YahooMailWebService/0.8.103.269680 Date: Thu, 17 Jun 2010 11:09:06 -0700 (PDT) From: Felipe Nogueira To: freebsd-mips@freebsd.org MIME-Version: 1.0 X-Mailman-Approved-At: Thu, 17 Jun 2010 18:41:51 +0000 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-Content-Filtered-By: Mailman/MimeDel 2.1.5 Subject: RB433 with FreeBSD 7.3 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 18:35:47 -0000 Is possible run FreeBSD 7.3 on RB433AH in card SD with the patchs for FreeB= SD9-current?=0A=0A=0A Felipe N.Oliva=0Afelipe.no88@yahoo.com.br=0A=0A=0A=0A= From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 19:18:32 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id D5F36106567B for ; Thu, 17 Jun 2010 19:18:32 +0000 (UTC) (envelope-from imp@bsdimp.com) Received: from harmony.bsdimp.com (bsdimp.com [199.45.160.85]) by mx1.freebsd.org (Postfix) with ESMTP id 7F4A08FC17 for ; Thu, 17 Jun 2010 19:18:32 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by harmony.bsdimp.com (8.14.3/8.14.1) with ESMTP id o5HJF9Lo072587; Thu, 17 Jun 2010 13:15:09 -0600 (MDT) (envelope-from imp@bsdimp.com) Date: Thu, 17 Jun 2010 13:15:13 -0600 (MDT) Message-Id: <20100617.131513.177916662552750992.imp@bsdimp.com> To: felipe.no88@yahoo.com.br From: "M. Warner Losh" In-Reply-To: <259623.75989.qm@web45815.mail.sp1.yahoo.com> References: <259623.75989.qm@web45815.mail.sp1.yahoo.com> X-Mailer: Mew version 6.3 on Emacs 22.3 / Mule 5.0 (SAKAKI) Mime-Version: 1.0 Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Cc: freebsd-mips@freebsd.org Subject: Re: RB433 with FreeBSD 7.3 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 19:18:32 -0000 : Is possible run FreeBSD 7.3 on RB433AH in card SD with the patchs : for FreeBSD9-current? Yes. However, I think that the question you really want to ask is 'how much effort is it to port the AR71xx support in -current back to 7.3-release? And also how much effort it would be enhance the SD stack to support running over SPI instead of running over the specialized SD interface. The port back to 7.3 likely isn't a huge amount of work. Interfaces haven't changed that much. However, I'm sure that I'm forgetting about some changes that would make it difficult :). Augmenting the SD stack to work over an SPI bus would be quite a bit more effort. The SPI commands are a little different than the normal ones, and some careful thought and attention to detail would be needed to make it work. The current SD stack likely would need some refactoring to accomplish this, since I don't think it is possible to mechanically translate the SD "bus" commands to the SPI commands (but to be honest, it has been 3 years since I looked at that part of the SD standard). Warner From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 21:33:09 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id DF157106566B for ; Thu, 17 Jun 2010 21:33:09 +0000 (UTC) (envelope-from juli@clockworksquid.com) Received: from mail-yw0-f191.google.com (mail-yw0-f191.google.com [209.85.211.191]) by mx1.freebsd.org (Postfix) with ESMTP id A368E8FC15 for ; Thu, 17 Jun 2010 21:33:09 +0000 (UTC) Received: by ywh29 with SMTP id 29so561958ywh.27 for ; Thu, 17 Jun 2010 14:33:07 -0700 (PDT) Received: by 10.220.126.200 with SMTP id d8mr90245vcs.41.1276810387201; Thu, 17 Jun 2010 14:33:07 -0700 (PDT) MIME-Version: 1.0 Sender: juli@clockworksquid.com Received: by 10.220.191.67 with HTTP; Thu, 17 Jun 2010 14:32:46 -0700 (PDT) In-Reply-To: <20100617.110504.200754750200158040.imp@bsdimp.com> References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> From: Juli Mallett Date: Thu, 17 Jun 2010 14:32:46 -0700 X-Google-Sender-Auth: IG05ZbPUP1Z8yYRrsXvIGVLFqDg Message-ID: To: "M. Warner Losh" Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 21:33:10 -0000 [ Picking the most recent message to reply to ] On Thu, Jun 17, 2010 at 10:05, M. Warner Losh wrote: > It was also a name-space collision, so we were using PG_x instead of > PG_y in the PTE code due to the overlap. =A0Maybe it all works now, but > that was the motivation for the change. The header and source I checked in to my branch date from my original work on FreeBSD for MIPS and I decided to use the existing spellings in those files rather than changing them to use the ones in the tree because using PG_ is fairly traditional and normal. I don't have an objection to PTE_ as such. JC is just trying to reduce diffs with my branch, but I don't care what the prefix on the name is as long as they're consistent and correct. I'm torn on the matter of cache attributes. I'd like for us to use consistent spellings for the cache coherency bits and to lump them all together in naming, which is why I like PG_C_UC and PG_C_CNC. The latter bit is defined in the various user's guides I've read as always meaning cacheable non-coherent. Is that same bit used on CPUs we care about to mean cacheable coherent? I don't really care, I suppose, as long as the bits are grouped (e.g. PG_C_*) and consistent between XKPHYS and PTE names. I'd prefer for us to not have cases where the same PTE with the same bits set are coherent on some CPUs and not coherent on others, but it sounds like that may be beyond our control. Thanks, Juli. From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 22:31:05 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id C31B2106566C; Thu, 17 Jun 2010 22:31:05 +0000 (UTC) (envelope-from rrs@lakerest.net) Received: from lakerest.net (unknown [IPv6:2001:240:585:2:213:d4ff:fef3:2d8d]) by mx1.freebsd.org (Postfix) with ESMTP id 6BA7F8FC08; Thu, 17 Jun 2010 22:31:05 +0000 (UTC) Received: from [10.1.1.53] ([10.1.1.53]) (authenticated bits=0) by lakerest.net (8.14.3/8.14.3) with ESMTP id o5HMUv5H056202 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NOT); Thu, 17 Jun 2010 18:30:58 -0400 (EDT) (envelope-from rrs@lakerest.net) DKIM-Signature: a=rsa-sha1; c=simple/simple; d=lakerest.net; s=mail; t=1276813858; h=Cc:Message-Id:From:To:In-Reply-To:Content-Type: Content-Transfer-Encoding:Mime-Version:Subject:Date:References: X-Mailer; b=PQpbCFCUlS0PCvW6HisMi5kmEwae1LJgQjZKTfjJfJ/Z4qA1DuMjwX4 BKPRl6IP5L5bfHKPDnKTWhpEkBBAgHQ== Message-Id: <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> From: Randall Stewart To: "M. Warner Losh" In-Reply-To: <20100617.110504.200754750200158040.imp@bsdimp.com> Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes Content-Transfer-Encoding: 7bit Mime-Version: 1.0 (Apple Message framework v936) Date: Thu, 17 Jun 2010 18:30:56 -0400 References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> X-Mailer: Apple Mail (2.936) Cc: Alan Cox , freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 22:31:05 -0000 On Jun 17, 2010, at 1:05 PM, M. Warner Losh wrote: > > > It was also a name-space collision, so we were using PG_x instead of > PG_y in the PTE code due to the overlap. Maybe it all works now, but > that was the motivation for the change. Yes, basically if I remember right someone used PG_GLOBAL instead of PG_G. This caused the wrong bits to be set. In general I think its a BAD idea to have two name spaces in the same section of the system (VM) that have similar define's that mean different things. Far better to KEEP the PTE_xxx or for that matter pick something else.. Just NOT PG_xxx R ------------------------------ Randall Stewart 803-317-4952 (cell) From owner-freebsd-mips@FreeBSD.ORG Thu Jun 17 23:37:16 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 00DF21065672 for ; Thu, 17 Jun 2010 23:37:16 +0000 (UTC) (envelope-from alc@cs.rice.edu) Received: from mail.cs.rice.edu (mail.cs.rice.edu [128.42.1.31]) by mx1.freebsd.org (Postfix) with ESMTP id CA20B8FC15 for ; Thu, 17 Jun 2010 23:37:15 +0000 (UTC) Received: from mail.cs.rice.edu (localhost.localdomain [127.0.0.1]) by mail.cs.rice.edu (Postfix) with ESMTP id 73D152C2ACA; Thu, 17 Jun 2010 18:10:12 -0500 (CDT) X-Virus-Scanned: by amavis-2.4.0 at mail.cs.rice.edu Received: from mail.cs.rice.edu ([127.0.0.1]) by mail.cs.rice.edu (mail.cs.rice.edu [127.0.0.1]) (amavisd-new, port 10024) with LMTP id VSmyDZ11dFsU; Thu, 17 Jun 2010 18:10:04 -0500 (CDT) Received: from [173.37.10.52] (nat.ironport.com [63.251.108.100]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by mail.cs.rice.edu (Postfix) with ESMTP id 5E60F2C2AAC; Thu, 17 Jun 2010 18:10:04 -0500 (CDT) Message-ID: <4C1AAB2A.5030507@cs.rice.edu> Date: Thu, 17 Jun 2010 18:09:30 -0500 From: Alan Cox User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.9) Gecko/20100317 Thunderbird/3.0.4 MIME-Version: 1.0 To: Randall Stewart References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> In-Reply-To: <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Jun 2010 23:37:16 -0000 On 6/17/2010 5:30 PM, Randall Stewart wrote: > > On Jun 17, 2010, at 1:05 PM, M. Warner Losh wrote: > >> >> >> It was also a name-space collision, so we were using PG_x instead of >> PG_y in the PTE code due to the overlap. Maybe it all works now, but >> that was the motivation for the change. > > > > Yes, basically if I remember right someone used > > PG_GLOBAL instead of PG_G. This caused the wrong bits > to be set. > > In general I think its a BAD idea to have two name spaces in the > same section of the system (VM) that have similar define's that mean > different things. > > > Far better to KEEP the PTE_xxx or for that matter pick something > else.. Just > NOT PG_xxx There is precedent for the PTE_ prefix: ia64 and powerpc. I would stick with it. (For the historically inclined, the name space collision goes back to CVS revision 1.1 of the relevant files, i.e., 1993.) Alan From owner-freebsd-mips@FreeBSD.ORG Fri Jun 18 05:59:53 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id CDE32106566C; Fri, 18 Jun 2010 05:59:53 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-vw0-f54.google.com (mail-vw0-f54.google.com [209.85.212.54]) by mx1.freebsd.org (Postfix) with ESMTP id 63ACD8FC13; Fri, 18 Jun 2010 05:59:53 +0000 (UTC) Received: by vws20 with SMTP id 20so11135914vws.13 for ; Thu, 17 Jun 2010 22:59:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:in-reply-to :references:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=dnDrKhqWJfCeOOCfPTR30IAp+8pLHB+AGUMawzvOPVA=; b=Ug/zJnlkKMuP6skFRYMVKQFnM9hLUmoR9964J9mJo7qsQ2MI+IEWTLa5ED7DKN1pa5 3cFZfU2nUBgLcyTrLdydTUAxMBWbGCu6/BUAm4H0HeTuqStVW8Rtc+o+TQVlGPxKppmw 6lqHMo0yYohUDJER4Tx2FWqSYVRo8yOc5JffM= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=lZQgNsonRcLfSwwXdNoM7EDMOkxkU/SgrvePh6MFkoOMcqKBBv1Sjrw8V3BMo03uiB PH1bbKEGiFHiavtgrW4yJQUAu2BW2zx3viHl/Y/nPh1tJ2Mrlv+D/WFvwfBpLgesQC3Q gmz2W4cU2KZzhvuK97kn2WTt13DosRwnAJdE0= MIME-Version: 1.0 Received: by 10.220.63.12 with SMTP id z12mr330058vch.260.1276840792550; Thu, 17 Jun 2010 22:59:52 -0700 (PDT) Received: by 10.220.199.200 with HTTP; Thu, 17 Jun 2010 22:59:52 -0700 (PDT) In-Reply-To: <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> Date: Fri, 18 Jun 2010 11:29:52 +0530 Message-ID: From: "Jayachandran C." To: Randall Stewart Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Cc: Alan Cox , freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 18 Jun 2010 05:59:53 -0000 On Fri, Jun 18, 2010 at 4:00 AM, Randall Stewart wrote: > > On Jun 17, 2010, at 1:05 PM, M. Warner Losh wrote: >> >> It was also a name-space collision, so we were using PG_x instead of >> PG_y in the PTE code due to the overlap. =A0Maybe it all works now, but >> that was the motivation for the change. > > > > Yes, basically if I remember right someone used > > PG_GLOBAL instead of PG_G. This caused the wrong bits > to be set. > > In general I think its a BAD idea to have two name spaces in the > same section of the system (VM) that have similar define's that mean > different things. > > > Far better to KEEP the PTE_xxx or for that matter pick something else.. J= ust > NOT PG_xxx I was not aware of the PG/PTE history, I thought I would get the diffs against Juli's tree down. I will drop the renaming patch. But can you review/approve the second patch. This change removes the sched_pin and lock in the LMEM macros.My understanding is that, these are not needed because each cpu is given its own va to map the physical memory to, and this pa/va mapping in in the kernel_pmap. JC. From owner-freebsd-mips@FreeBSD.ORG Fri Jun 18 19:41:40 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id E94FE106566C for ; Fri, 18 Jun 2010 19:41:40 +0000 (UTC) (envelope-from neelnatu@gmail.com) Received: from mail-iw0-f182.google.com (mail-iw0-f182.google.com [209.85.214.182]) by mx1.freebsd.org (Postfix) with ESMTP id A6B658FC14 for ; Fri, 18 Jun 2010 19:41:40 +0000 (UTC) Received: by iwn7 with SMTP id 7so1758897iwn.13 for ; Fri, 18 Jun 2010 12:41:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:in-reply-to :references:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=vrYRIUzPkXA+aM9iHp56YYepMkigNM84KP4chygPU3c=; b=Un8lcVrgjMFxNVZnt1Afj15IwwGk40lNiQ17gYy9M+w89FgRDf8EChsjoUb1gq9ucQ PYUe7VUW95ZUdn0oq6EtREdF9wrUusRIv5YE8n+iO3amZtdnTyOk9Yh97EEyqDGo8avI 72LYWHDUVdABdgfKzGFt7RlDEbjdHXDR8O7r0= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=pUQ6zLfkZ3lhj+c45YdxKuHbz7N6LTaDpjv0qPITszce2TYP5bwDjv+uM861oRffZN VdkETpWILYhD0XzCi6JLu8307K51/A8spSXCKyQ98S007RSOrzJTzhXxDY1wfwMCm005 SSQDVbvFmE8ifPX26huqVJOXTMTCPr9N624fQ= MIME-Version: 1.0 Received: by 10.231.130.162 with SMTP id t34mr1634465ibs.157.1276890099961; Fri, 18 Jun 2010 12:41:39 -0700 (PDT) Received: by 10.231.32.197 with HTTP; Fri, 18 Jun 2010 12:41:39 -0700 (PDT) In-Reply-To: References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> Date: Fri, 18 Jun 2010 12:41:39 -0700 Message-ID: From: Neel Natu To: "Jayachandran C." Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Cc: Alan Cox , freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 18 Jun 2010 19:41:41 -0000 Hi JC, On Thu, Jun 17, 2010 at 10:59 PM, Jayachandran C. wrote: > On Fri, Jun 18, 2010 at 4:00 AM, Randall Stewart wrote= : >> >> On Jun 17, 2010, at 1:05 PM, M. Warner Losh wrote: >>> >>> It was also a name-space collision, so we were using PG_x instead of >>> PG_y in the PTE code due to the overlap. =A0Maybe it all works now, but >>> that was the motivation for the change. >> >> >> >> Yes, basically if I remember right someone used >> >> PG_GLOBAL instead of PG_G. This caused the wrong bits >> to be set. >> >> In general I think its a BAD idea to have two name spaces in the >> same section of the system (VM) that have similar define's that mean >> different things. >> >> >> Far better to KEEP the PTE_xxx or for that matter pick something else.. = Just >> NOT PG_xxx > > I was not aware of the PG/PTE history, I thought I would get the diffs > against Juli's tree down. > > I will drop the renaming patch. > > But can you review/approve the second patch. =A0This change removes the > sched_pin and lock in the LMEM macros.My understanding is that, these > are not needed because each cpu is given its own va to map the > physical memory to, and this pa/va mapping in in the kernel_pmap. > Your second patch as it stands looks good. But what you really want here is to eliminate the intr_disable() and intr_restore() and keep sched_pin() and sched_unpin(). The interrupt disable hack was necessary when we would directly update the TLB with the temporary mappings as opposed to going through the kernel_pmap as we do now. By instantiating the temporary mappings in the kernel pmap we can rely on the TLB miss handler to put these mappings in the TLB in case they get removed because of interrupt processing. See this change that introduced the interrupt disable code: http://svn.freebsd.org/viewvc/base?view=3Drevision&revision=3D203151 best Neel > JC. > _______________________________________________ > freebsd-mips@freebsd.org mailing list > http://lists.freebsd.org/mailman/listinfo/freebsd-mips > To unsubscribe, send any mail to "freebsd-mips-unsubscribe@freebsd.org" > From owner-freebsd-mips@FreeBSD.ORG Sat Jun 19 10:18:35 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 38A37106566B for ; Sat, 19 Jun 2010 10:18:35 +0000 (UTC) (envelope-from juli@clockworksquid.com) Received: from mail-gy0-f182.google.com (mail-gy0-f182.google.com [209.85.160.182]) by mx1.freebsd.org (Postfix) with ESMTP id EE9D48FC14 for ; Sat, 19 Jun 2010 10:18:34 +0000 (UTC) Received: by gyh20 with SMTP id 20so1988714gyh.13 for ; Sat, 19 Jun 2010 03:18:34 -0700 (PDT) Received: by 10.220.124.66 with SMTP id t2mr797236vcr.186.1276942714118; Sat, 19 Jun 2010 03:18:34 -0700 (PDT) MIME-Version: 1.0 Sender: juli@clockworksquid.com Received: by 10.220.191.67 with HTTP; Sat, 19 Jun 2010 03:18:14 -0700 (PDT) In-Reply-To: References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> From: Juli Mallett Date: Sat, 19 Jun 2010 03:18:14 -0700 X-Google-Sender-Auth: pAAZ3Gl7SsxRr723RO2_xd4AAGg Message-ID: To: Neel Natu Content-Type: text/plain; charset=windows-1252 Content-Transfer-Encoding: quoted-printable Cc: Alan Cox , freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 19 Jun 2010 10:18:35 -0000 On Fri, Jun 18, 2010 at 12:41, Neel Natu wrote: > Hi JC, > > But what you really want here is to eliminate the intr_disable() and > intr_restore() and keep sched_pin() and =A0sched_unpin(). Are you sure? I'm not. By disabling interrupts we only have to ensure that the fault path on any address we might access within those routines doesn't need to use the large memory map. This isn't trivial, but I think we can acquire a reasonable confidence about it. If we merely pin, we have to ensure that nothing else that can run (including interrupts and threads that run via preemption) that would access the large memory map =97 given that this includes routines like pmap_zero_page, I think there's good reason for caution. Disabling interrupts is more conservative, but I think rightly-so. I may be mistaken. Thanks, Juli. From owner-freebsd-mips@FreeBSD.ORG Sat Jun 19 16:19:53 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 59C33106566B; Sat, 19 Jun 2010 16:19:53 +0000 (UTC) (envelope-from alc@cs.rice.edu) Received: from mail.cs.rice.edu (mail.cs.rice.edu [128.42.1.31]) by mx1.freebsd.org (Postfix) with ESMTP id 1F5378FC0C; Sat, 19 Jun 2010 16:19:52 +0000 (UTC) Received: from mail.cs.rice.edu (localhost.localdomain [127.0.0.1]) by mail.cs.rice.edu (Postfix) with ESMTP id 8E7042C2A92; Sat, 19 Jun 2010 11:19:52 -0500 (CDT) X-Virus-Scanned: by amavis-2.4.0 at mail.cs.rice.edu Received: from mail.cs.rice.edu ([127.0.0.1]) by mail.cs.rice.edu (mail.cs.rice.edu [127.0.0.1]) (amavisd-new, port 10024) with LMTP id apyZvPoHfDVL; Sat, 19 Jun 2010 11:19:44 -0500 (CDT) Received: from [10.24.157.225] (h-67-101-114-10.snfccasy.static.covad.net [67.101.114.10]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by mail.cs.rice.edu (Postfix) with ESMTP id 6E1422C2A81; Sat, 19 Jun 2010 11:19:44 -0500 (CDT) Message-ID: <4C1CEDFB.9070802@cs.rice.edu> Date: Sat, 19 Jun 2010 11:19:07 -0500 From: Alan Cox User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.9) Gecko/20100317 Thunderbird/3.0.4 MIME-Version: 1.0 To: Juli Mallett References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> In-Reply-To: Content-Type: text/plain; charset=windows-1252; format=flowed Content-Transfer-Encoding: 8bit Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 19 Jun 2010 16:19:53 -0000 On 6/19/2010 5:18 AM, Juli Mallett wrote: > On Fri, Jun 18, 2010 at 12:41, Neel Natu wrote: > >> Hi JC, >> >> But what you really want here is to eliminate the intr_disable() and >> intr_restore() and keep sched_pin() and sched_unpin(). >> > Are you sure? I'm not. By disabling interrupts we only have to > ensure that the fault path on any address we might access within those > routines doesn't need to use the large memory map. This isn't > trivial, but I think we can acquire a reasonable confidence about it. > If we merely pin, we have to ensure that nothing else that can run > (including interrupts and threads that run via preemption) that would > access the large memory map — given that this includes routines like > pmap_zero_page, I think there's good reason for caution. Disabling > interrupts is more conservative, but I think rightly-so. I may be > mistaken. > You're not mistaken. See, for example, the i386 pmap_zero_page(). Pinning by itself is insufficient because a pinned thread can be preempted, and the thread that then runs (on the same processor) could call pmap_zero_page(). So, pinning must be combined with a per-processor mutex. I can imagine that blocking interrupts on mips is cheaper than the combination of pinning and a mutex. However, do you want to have interrupts blocked for the time it takes to read 4KB from DRAM and write 4KB to DRAM for pmap_copy_page()? Ultimately, that's the question that you need to answer. Alan From owner-freebsd-mips@FreeBSD.ORG Sat Jun 19 17:04:20 2010 Return-Path: Delivered-To: mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id A5A59106566C; Sat, 19 Jun 2010 17:04:20 +0000 (UTC) (envelope-from alc@cs.rice.edu) Received: from mail.cs.rice.edu (mail.cs.rice.edu [128.42.1.31]) by mx1.freebsd.org (Postfix) with ESMTP id 2A09D8FC16; Sat, 19 Jun 2010 17:04:20 +0000 (UTC) Received: from mail.cs.rice.edu (localhost.localdomain [127.0.0.1]) by mail.cs.rice.edu (Postfix) with ESMTP id CF5292C2AAC; Sat, 19 Jun 2010 12:04:19 -0500 (CDT) X-Virus-Scanned: by amavis-2.4.0 at mail.cs.rice.edu Received: from mail.cs.rice.edu ([127.0.0.1]) by mail.cs.rice.edu (mail.cs.rice.edu [127.0.0.1]) (amavisd-new, port 10024) with LMTP id J4WG9I5Pfxxg; Sat, 19 Jun 2010 12:04:12 -0500 (CDT) Received: from [10.24.157.225] (h-67-101-114-10.snfccasy.static.covad.net [67.101.114.10]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by mail.cs.rice.edu (Postfix) with ESMTP id 8B67E2C2A81; Sat, 19 Jun 2010 12:04:11 -0500 (CDT) Message-ID: <4C1CF867.8070301@cs.rice.edu> Date: Sat, 19 Jun 2010 12:03:35 -0500 From: Alan Cox User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.9) Gecko/20100317 Thunderbird/3.0.4 MIME-Version: 1.0 To: Juli Mallett , mips@freebsd.org, Alan Cox References: <201006191023.o5JANNLq052471@svn.freebsd.org> In-Reply-To: <201006191023.o5JANNLq052471@svn.freebsd.org> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Cc: Subject: Re: svn commit: r209336 - user/jmallett/octeon/sys/mips/include X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 19 Jun 2010 17:04:20 -0000 On 6/19/2010 5:23 AM, Juli Mallett wrote: > Author: jmallett > Date: Sat Jun 19 10:23:23 2010 > New Revision: 209336 > URL: http://svn.freebsd.org/changeset/base/209336 > > Log: > Add notes about comments I need to update and attempt to explain the wired > bit (and mostly fail.) > > Modified: > user/jmallett/octeon/sys/mips/include/pte.h > > Modified: user/jmallett/octeon/sys/mips/include/pte.h > ============================================================================== > --- user/jmallett/octeon/sys/mips/include/pte.h Sat Jun 19 10:14:43 2010 (r209335) > +++ user/jmallett/octeon/sys/mips/include/pte.h Sat Jun 19 10:23:23 2010 (r209336) > @@ -55,6 +55,8 @@ typedef pt_entry_t *pd_entry_t; > #define TLBMASK_MASK ((PAGE_MASK>> TLBMASK_SHIFT)<< TLBMASK_SHIFT) > > /* > + * XXX This comment is not correct for FreeBSD. > + * > * PFN for EntryLo register. Upper bits are 0, which is to say that > * bit 29 is the last hardware bit; Bits 30 and upwards (EntryLo is > * 64 bit though it can be referred to in 32-bits providing 2 software > @@ -73,11 +75,14 @@ typedef pt_entry_t *pd_entry_t; > #define TLBLO_PTE_TO_PA(pte) (TLBLO_PFN_TO_PA(TLBLO_PTE_TO_PFN((pte)))) > > /* > + * XXX This comment is not correct for anything more modern than R4K. > + * > * VPN for EntryHi register. Upper two bits select user, supervisor, > * or kernel. Bits 61 to 40 copy bit 63. VPN2 is bits 39 and down to > * as low as 13, down to PAGE_SHIFT, to index 2 TLB pages*. From bit 12 > * to bit 8 there is a 5-bit 0 field. Low byte is ASID. > * > + * XXX This comment is not correct for FreeBSD. > * Note that in FreeBSD, we map 2 TLB pages is equal to 1 VM page. > */ > #define TLBHI_ASID_MASK (0xff) > @@ -121,7 +126,9 @@ typedef pt_entry_t *pd_entry_t; > * VM flags managed in software: > * RO: Read only. Never set PTE_D on this page, and don't > * listen to requests to write to it. > - * W: Wired. ??? > + * W: Wired. Allows us to quickly increment and decrement > + * the wired count by looking at the PTE and skip wired > + * mappings when removing mappings from a process. > */ > #define PTE_RO (0x01<< TLBLO_SWBITS_SHIFT) > #define PTE_W (0x02<< TLBLO_SWBITS_SHIFT) > I have two observations relating to PTE_W on mips: First, pmap_change_wiring() is broken on mips because it only updates the PTE_W bit in the PTE but not the wired flag in the pv entry. Consequently, pmap_page_wired_mappings() may return an incorrect result. Second, given the paucity of bits available to software, I think that this bit would be better used as a PTE_MANAGED or PTE_REFERENCED bit. PTE_MANAGED would allow you to avoid quite a number of PHYS_TO_VM_PAGE operations, which became more costly when you switched to VM_PHYSSEG_SPARSE, and PTE_REFERENCED would enable you to do a proper implementation of pmap_ts_referenced(). (FreeBSD's page daemon really wants to know how many processes have referenced a page, and mips does not currently provide that.) Alan From owner-freebsd-mips@FreeBSD.ORG Sat Jun 19 17:58:33 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 09BE7106566B; Sat, 19 Jun 2010 17:58:33 +0000 (UTC) (envelope-from c.jayachandran@gmail.com) Received: from mail-gy0-f182.google.com (mail-gy0-f182.google.com [209.85.160.182]) by mx1.freebsd.org (Postfix) with ESMTP id 90FDD8FC1E; Sat, 19 Jun 2010 17:58:32 +0000 (UTC) Received: by gyh20 with SMTP id 20so2208858gyh.13 for ; Sat, 19 Jun 2010 10:58:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:received:in-reply-to :references:date:message-id:subject:from:to:cc:content-type :content-transfer-encoding; bh=BRUcLp+8Uyjbi536eI/Ftdzx0Q8pzuLdRNAVqK50G84=; b=PKCfwuA0QAMCmjXjIFIKpaNf410m7mddW3KSFt3SX6tGpgJeIDE5+8KPkwfCv/RxWl L/DtSKhOSO4C6+qO0/syTZUmqs2ewXM/JzxlG+MNsSqx+mgqby+iNRH2mmpd24oF0ZCN O62qcq9GShrMelZnVDtVTkg6R++q/Zyw+B95g= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type:content-transfer-encoding; b=vXhkq3YzypyDEQqMCEJxHwmUTTdBSXYOZrTRo/dTTRJhl6gK44W7MOQ6ObrcCI1VO/ QUrU8VExo3KL5fvUYgfEWT1bR4fyAL77IiYX6FNMek6Td11QmFlWS1NVNtYhGNAg8D+Y yPhkku+NAF9JwXmsX+OEETrCFfHsvceGh+cVU= MIME-Version: 1.0 Received: by 10.220.47.79 with SMTP id m15mr859372vcf.233.1276970311507; Sat, 19 Jun 2010 10:58:31 -0700 (PDT) Received: by 10.220.199.200 with HTTP; Sat, 19 Jun 2010 10:58:31 -0700 (PDT) In-Reply-To: <4C1CEDFB.9070802@cs.rice.edu> References: <20100617.100235.195066307596264499.imp@bsdimp.com> <4B66E1A4-E2A5-471F-9FA4-38B506797272@lakerest.net> <20100617.110504.200754750200158040.imp@bsdimp.com> <763BEBBB-B85A-44CE-BFEE-0BADEFF3C185@lakerest.net> <4C1CEDFB.9070802@cs.rice.edu> Date: Sat, 19 Jun 2010 23:28:31 +0530 Message-ID: From: "Jayachandran C." To: Alan Cox Content-Type: text/plain; charset=windows-1252 Content-Transfer-Encoding: quoted-printable Cc: freebsd-mips@freebsd.org Subject: Re: Merging 64 bit changes to -HEAD - part 2 X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 19 Jun 2010 17:58:33 -0000 On Sat, Jun 19, 2010 at 9:49 PM, Alan Cox wrote: > On 6/19/2010 5:18 AM, Juli Mallett wrote: >> >> On Fri, Jun 18, 2010 at 12:41, Neel Natu =A0wrote: >> >>> >>> Hi JC, >>> >>> But what you really want here is to eliminate the intr_disable() and >>> intr_restore() and keep sched_pin() and =A0sched_unpin(). >>> >> >> Are you sure? =A0I'm not. =A0By disabling interrupts we only have to >> ensure that the fault path on any address we might access within those >> routines doesn't need to use the large memory map. =A0This isn't >> trivial, but I think we can acquire a reasonable confidence about it. >> If we merely pin, we have to ensure that nothing else that can run >> (including interrupts and threads that run via preemption) that would >> access the large memory map =97 given that this includes routines like >> pmap_zero_page, I think there's good reason for caution. =A0Disabling >> interrupts is more conservative, but I think rightly-so. =A0I may be >> mistaken. >> > > You're not mistaken. =A0See, for example, the i386 pmap_zero_page(). =A0P= inning > by itself is insufficient because a pinned thread can be preempted, and t= he > thread that then runs (on the same processor) could call pmap_zero_page()= . > =A0So, pinning must be combined with a per-processor mutex. > > I can imagine that blocking interrupts on mips is cheaper than the > combination of pinning and a mutex. =A0However, do you want to have inter= rupts > blocked for the time it takes to read 4KB from DRAM and write 4KB to DRAM > for pmap_copy_page()? =A0Ultimately, that's the question that you need to > answer. The original implementation was to lock and sched_pin(). As Neel noted, the intr_disable was added later as a temporary fix. I think we can go back to lock and pin. If there are no objections, I will post a patch for this. Thanks, JC. From owner-freebsd-mips@FreeBSD.ORG Sat Jun 19 18:07:49 2010 Return-Path: Delivered-To: freebsd-mips@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 27C311065670 for ; Sat, 19 Jun 2010 18:07:49 +0000 (UTC) (envelope-from freebsd@luftivennad.com) Received: from fiona.equix.ee (fiona.equix.ee [188.92.161.31]) by mx1.freebsd.org (Postfix) with ESMTP id D36238FC0A for ; Sat, 19 Jun 2010 18:07:48 +0000 (UTC) Received: by fiona.equix.ee (Postfix, from userid 2500) id 0F84F26F941; Sat, 19 Jun 2010 21:09:21 +0300 (EEST) X-Spam-Checker-Version: SpamAssassin 3.2.5 (2008-06-10) on mail.equix.ee X-Spam-Level: X-Spam-Status: No, score=-0.8 required=5.0 tests=AWL autolearn=disabled version=3.2.5 Received: from webmail.equix.ee (localhost [188.92.161.31]) by fiona.equix.ee (Postfix) with ESMTP id 8486326F93B for ; Sat, 19 Jun 2010 21:09:15 +0300 (EEST) Received: from 62.65.227.20.cable.starman.ee ([62.65.227.20]) (SquirrelMail authenticated user zwoz) by webmail.equix.ee with HTTP; Sat, 19 Jun 2010 21:09:15 +0300 Message-ID: <3f993635fc9c54a4d44aa360e26a9be0.squirrel@webmail.equix.ee> Date: Sat, 19 Jun 2010 21:09:15 +0300 From: "Ain" To: freebsd-mips@freebsd.org User-Agent: SquirrelMail/1.4.19 MIME-Version: 1.0 Content-Type: text/plain;charset=iso-8859-15 Content-Transfer-Encoding: 8bit X-Priority: 3 (Normal) Importance: Normal Subject: AR5416 MAC based ath X-BeenThere: freebsd-mips@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Porting FreeBSD to MIPS List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 19 Jun 2010 18:07:49 -0000 Hello! Last month was here a discussion about AR92XX (with subject line "Trap when setting up ath0"). Now i have same kind trap, my chip is ar9220. If i understand correctly, patch for 71xx (http://people.freebsd.org/~imp/ar71xx_ath_war.diff) contains magic number AR_RXCFG, what is not defined in ar5416reg.h. Can i use same magic to get my AR92XX working? If not, maybe some other ideas? Thanks, Ain