From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1NSGIk-0002sq-CN for qemu-devel@nongnu.org; Tue, 05 Jan 2010 15:46:50 -0500 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1NSGIi-0002sd-88 for qemu-devel@nongnu.org; Tue, 05 Jan 2010 15:46:49 -0500 Received: from [199.232.76.173] (port=39596 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1NSGIi-0002sa-2z for qemu-devel@nongnu.org; Tue, 05 Jan 2010 15:46:48 -0500 Received: from fg-out-1718.google.com ([72.14.220.157]:22944) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1NSGIg-0007Zq-Tw for qemu-devel@nongnu.org; Tue, 05 Jan 2010 15:46:47 -0500 Received: by fg-out-1718.google.com with SMTP id 19so1938213fgg.10 for ; Tue, 05 Jan 2010 12:46:45 -0800 (PST) MIME-Version: 1.0 Date: Tue, 5 Jan 2010 20:46:45 +0000 Message-ID: From: Stefan Hajnoczi Content-Type: multipart/mixed; boundary=001485eafef29d92c3047c70ef97 Subject: [Qemu-devel] [PATCH] [virtio] Add virtio block device sanboot support List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: gpxe@etherboot.org Cc: qemu-devel@nongnu.org --001485eafef29d92c3047c70ef97 Content-Type: text/plain; charset=ISO-8859-1 This patch adds virtio block device support alongside the existing iSCSI, ATA-over-Ethernet, and ramdisk block devices. The virtio block device provides storage in virtualized environments. Using this patch, a gPXE option ROM can boot a QEMU/KVM virtual machine directly from a virtio block device. Here is an example QEMU invocation: qemu -drive if=virtio,file=debian.qcow2 -option-rom gpxe/src/bin/1af41001.rom SANBOOT_PROTO_VIRTIO_BLK must be defined in config/general.h to enable this feature. The gPXE option ROM must be built for PCI ID 1af4:1001. The sanboot gPXE command is used with the virtio_blk: root path scheme. The virtio block device instance is identified by its PCI bus, device, and function (there could be multiple virtio block devices). gPXE> sanboot virtio_blk:PCI00:04.0 Perhaps the first available device should be chosen if virtio_blk: is given without PCI bus, device, and function. I am open to suggestions on how virtio block device option ROMs should work. I have successfully booted Debian testing i386 and FreeDOS 0.84-pre2 under QEMU 0.11.0. Note that QEMU/KVM can boot from a virtio block device using a separate non-virtio interface (-drive if=virtio,boot=on,[...]). This gPXE patch provides a native virtio block implementation. While developing this feature, I noticed that the AoE sanboot code leaves a pointer to a stack value around after it returns. A commit to fix this is included. Stefan Hajnoczi (2): [sanboot] Prevent leaking a stack reference for "keep-san" AoE [virtio] Add virtio block device sanboot support src/arch/i386/interface/pcbios/aoeboot.c | 54 +++-- src/arch/i386/interface/pcbios/virtio_blkboot.c | 70 ++++++ src/config/config.c | 3 + src/config/general.h | 1 + src/drivers/block/virtio-blk.c | 271 +++++++++++++++++++++++ src/drivers/block/virtio-blk.h | 30 +++ src/include/gpxe/errfile.h | 2 + src/include/gpxe/virtblk.h | 37 +++ 8 files changed, 447 insertions(+), 21 deletions(-) create mode 100644 src/arch/i386/interface/pcbios/virtio_blkboot.c create mode 100644 src/drivers/block/virtio-blk.c create mode 100644 src/drivers/block/virtio-blk.h create mode 100644 src/include/gpxe/virtblk.h >>From 0926649bece8e06dfdb19e4f819795da6ee364dd Mon Sep 17 00:00:00 2001 From: Stefan Hajnoczi Date: Tue, 5 Jan 2010 08:05:32 +0000 Subject: [PATCH 1/2] [sanboot] Prevent leaking a stack reference for "keep-san" AoE When the "keep-san" option is used, the function is exited without unregistering the stack allocated int13h drive. To prevent a dangling pointer to the stack, these structs should be heap allocated. --- src/arch/i386/interface/pcbios/aoeboot.c | 54 ++++++++++++++++++----------- 1 files changed, 33 insertions(+), 21 deletions(-) diff --git a/src/arch/i386/interface/pcbios/aoeboot.c b/src/arch/i386/interface/pcbios/aoeboot.c index 8446c15..2670b15 100644 --- a/src/arch/i386/interface/pcbios/aoeboot.c +++ b/src/arch/i386/interface/pcbios/aoeboot.c @@ -1,11 +1,11 @@ #include #include +#include #include -#include +#include #include #include #include -#include #include #include #include @@ -13,50 +13,62 @@ FILE_LICENCE ( GPL2_OR_LATER ); static int aoeboot ( const char *root_path ) { - struct ata_device ata; - struct int13_drive drive; + struct ata_device *ata; + struct int13_drive *drive; int rc; - memset ( &ata, 0, sizeof ( ata ) ); - memset ( &drive, 0, sizeof ( drive ) ); + ata = zalloc ( sizeof ( *ata ) ); + if ( ! ata ) { + rc = -ENOMEM; + goto err_alloc_ata; + } + drive = zalloc ( sizeof ( *drive ) ); + if ( ! drive ) { + rc = -ENOMEM; + goto err_alloc_drive; + } /* FIXME: ugly, ugly hack */ struct net_device *netdev = last_opened_netdev(); - if ( ( rc = aoe_attach ( &ata, netdev, root_path ) ) != 0 ) { + if ( ( rc = aoe_attach ( ata, netdev, root_path ) ) != 0 ) { printf ( "Could not attach AoE device: %s\n", strerror ( rc ) ); - goto error_attach; + goto err_attach; } - if ( ( rc = init_atadev ( &ata ) ) != 0 ) { + if ( ( rc = init_atadev ( ata ) ) != 0 ) { printf ( "Could not initialise AoE device: %s\n", strerror ( rc ) ); - goto error_init; + goto err_init; } /* FIXME: ugly, ugly hack */ struct aoe_session *aoe = - container_of ( ata.backend, struct aoe_session, refcnt ); + container_of ( ata->backend, struct aoe_session, refcnt ); abft_fill_data ( aoe ); - drive.blockdev = &ata.blockdev; + drive->blockdev = &ata->blockdev; - register_int13_drive ( &drive ); - printf ( "Registered as BIOS drive %#02x\n", drive.drive ); - printf ( "Booting from BIOS drive %#02x\n", drive.drive ); - rc = int13_boot ( drive.drive ); + register_int13_drive ( drive ); + printf ( "Registered as BIOS drive %#02x\n", drive->drive ); + printf ( "Booting from BIOS drive %#02x\n", drive->drive ); + rc = int13_boot ( drive->drive ); printf ( "Boot failed\n" ); /* Leave drive registered, if instructed to do so */ if ( keep_san() ) return rc; - printf ( "Unregistering BIOS drive %#02x\n", drive.drive ); - unregister_int13_drive ( &drive ); + printf ( "Unregistering BIOS drive %#02x\n", drive->drive ); + unregister_int13_drive ( drive ); - error_init: - aoe_detach ( &ata ); - error_attach: + err_init: + aoe_detach ( ata ); + err_attach: + free ( drive ); + err_alloc_drive: + free ( ata ); + err_alloc_ata: return rc; } -- 1.6.5 >>From 3dbc385d29cbdff520ed0694934c01a6808ff1dc Mon Sep 17 00:00:00 2001 From: Stefan Hajnoczi Date: Tue, 5 Jan 2010 17:39:18 +0000 Subject: [PATCH 2/2] [virtio] Add virtio block device sanboot support This patch adds virtio block device support alongside the existing iSCSI, ATA-over-Ethernet, and ramdisk block devices. A gPXE option ROM can boot a QEMU/KVM virtual machine directly from a virtio block device: # Ensure SANBOOT_PROTO_VIRTIO_BLK is defined in config/defaults.h make bin/1af41001.rom The sanboot gPXE command is used with the virtio_blk: root path scheme. The virtio block device instance is identified by its PCI bus, device, and function (there could be multiple virtio block devices). sanboot virtio_blk:PCI00:04.0 Successfully boots Debian testing i386 and FreeDOS 0.84-pre2 under QEMU. --- src/arch/i386/interface/pcbios/virtio_blkboot.c | 70 ++++++ src/config/config.c | 3 + src/config/general.h | 1 + src/drivers/block/virtio-blk.c | 271 +++++++++++++++++++++++ src/drivers/block/virtio-blk.h | 30 +++ src/include/gpxe/errfile.h | 2 + src/include/gpxe/virtblk.h | 37 +++ 7 files changed, 414 insertions(+), 0 deletions(-) create mode 100644 src/arch/i386/interface/pcbios/virtio_blkboot.c create mode 100644 src/drivers/block/virtio-blk.c create mode 100644 src/drivers/block/virtio-blk.h create mode 100644 src/include/gpxe/virtblk.h diff --git a/src/arch/i386/interface/pcbios/virtio_blkboot.c b/src/arch/i386/interface/pcbios/virtio_blkboot.c new file mode 100644 index 0000000..3c2dd47 --- /dev/null +++ b/src/arch/i386/interface/pcbios/virtio_blkboot.c @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2010 Stefan Hajnoczi . + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include +#include +#include +#include +#include +#include +#include + +/** + * @file + * + * Virtio block device boot + * + */ + +static int virtio_blkboot ( const char *root_path ) { + struct int13_drive *drive; + struct virtblk *virtblk; + int rc; + + virtblk = find_virtblk ( root_path + sizeof ( "virtio_blk:" ) - 1 ); + if ( ! virtblk ) + return -ENOENT; + + drive = zalloc ( sizeof ( *drive ) ); + if ( ! drive ) + return -ENOMEM; + + drive->blockdev = &virtblk->blockdev; + + register_int13_drive ( drive ); + printf ( "Registered as BIOS drive %#02x\n", drive->drive ); + printf ( "Booting from BIOS drive %#02x\n", drive->drive ); + rc = int13_boot ( drive->drive ); + printf ( "Boot failed\n" ); + + /* Leave drive registered, if instructed to do so */ + if ( keep_san() ) + return rc; + + printf ( "Unregistering BIOS drive %#02x\n", drive->drive ); + unregister_int13_drive ( drive ); + free ( drive ); + return rc; +} + +struct sanboot_protocol virtblk_sanboot_protocol __sanboot_protocol = { + .prefix = "virtio_blk:", + .boot = virtio_blkboot, +}; diff --git a/src/config/config.c b/src/config/config.c index 3c43dfb..bb0ff67 100644 --- a/src/config/config.c +++ b/src/config/config.c @@ -130,6 +130,9 @@ REQUIRE_OBJECT ( aoeboot ); #ifdef SANBOOT_PROTO_IB_SRP REQUIRE_OBJECT ( ib_srpboot ); #endif +#ifdef SANBOOT_PROTO_VIRTIO_BLK +REQUIRE_OBJECT ( virtio_blkboot ); +#endif /* * Drag in all requested resolvers diff --git a/src/config/general.h b/src/config/general.h index ee07dfc..a1dec39 100644 --- a/src/config/general.h +++ b/src/config/general.h @@ -63,6 +63,7 @@ FILE_LICENCE ( GPL2_OR_LATER ); //#undef SANBOOT_PROTO_ISCSI /* iSCSI protocol */ //#undef SANBOOT_PROTO_AOE /* AoE protocol */ //#undef SANBOOT_PROTO_IB_SRP /* Infiniband SCSI RDMA protocol */ +//#undef SANBOOT_PROTO_VIRTIO_BLK /* Virtio block device */ /* * Name resolution modules diff --git a/src/drivers/block/virtio-blk.c b/src/drivers/block/virtio-blk.c new file mode 100644 index 0000000..fab5930 --- /dev/null +++ b/src/drivers/block/virtio-blk.c @@ -0,0 +1,271 @@ +/* + * Copyright (C) 2010 Stefan Hajnoczi . + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include +#include +#include +#include +#include "virtio-blk.h" + +/** + * @file + * + * Virtio block devices + * + */ + +/** List of virtio block devices */ +static LIST_HEAD ( virtblk_devices ); + +/** + * Register virtio block device + * + * @v virtblk Virtio block device + * + * Adds the virtio block device to the list of virtio block devices. + */ +static void register_virtblk ( struct virtblk *virtblk ) { + list_add_tail ( &virtblk->virtblk_devices, &virtblk_devices ); +} + +/** + * Unregister virtio block device + * + * @v virtblk Virtio block device + * + * Removes the virtio block device from the list of virtio block devices. + */ +static void unregister_virtblk ( struct virtblk *virtblk ) { + list_del ( &virtblk->virtblk_devices ); +} + +/** + * Find virtio block device by name + * + * @v device_name Device name + * @ret virtblk Virtio block device or NULL + * + * Searches the list of virtio block devices by name. + */ +struct virtblk *find_virtblk ( const char *device_name ) { + struct virtblk *virtblk; + DBG ( "find_virtblk \"%s\"\n", device_name ); + list_for_each_entry ( virtblk, &virtblk_devices, virtblk_devices ) { + if ( ! strcmp ( device_name, virtblk->pdev->dev.name ) ) + return virtblk; + } + return NULL; +} + +/** + * Issue an I/O request and wait for completion + * + * @v virtblk Virtio block device + * @v type VIRTIO_BLK_T_IN or VIRTIO_BLK_T_OUT + * @v block Block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int virtblk_command ( struct virtblk *virtblk, u32 type, + uint64_t block, unsigned long count, + userptr_t buffer ) { + /* + * Virtio block requests have the following format: + * + * +--------------------------------+ + * | struct virtio_blk_outhdr [IN] | + * +--------------------------------+ + * | In/out buffer [IN/OUT] | + * +--------------------------------+ + * | Status byte [OUT] | + * +--------------------------------+ + * + * The device fills in the status byte to indicate the outcome the + * operation. + */ + struct vring_virtqueue *vq = &virtblk->virtqueue; + struct virtio_blk_outhdr hdr = { + .type = type, + .ioprio = 0, + .sector = block, + }; + uint8_t status = VIRTIO_BLK_S_UNSUPP; + struct vring_list list[] = { + { + .addr = ( char * ) &hdr, + .length = sizeof ( hdr ), + }, + { + .addr = ( char * ) user_to_virt ( buffer, 0 ), + .length = virtblk->blockdev.blksize * count, + }, + { + .addr = ( char * ) &status, + .length = sizeof ( status ), + }, + }; + unsigned int in, out; + + DBG ( "VIRTBLK req 0x%02x LBA 0x%llx count 0x%lx\n", + type, block, count ); + + /* Number of elements readable and writable */ + if ( type == VIRTIO_BLK_T_IN ) { + out = 1; + in = 2; + } else { + out = 2; + in = 1; + } + + /* Add to virtqueue and kick host */ + vring_add_buf ( vq, list, out, in, 0, 0 ); + vring_kick ( virtblk->pdev->ioaddr, vq, 1 ); + + /* Wait for reply */ + while ( ! vring_more_used ( vq ) ) { + mb(); + step(); + } + + /* Reclaim virtqueue element */ + vring_get_buf ( vq, NULL ); + return status == VIRTIO_BLK_S_OK ? 0 : -EIO; +} + +/** + * Read block + * + * @v blockdev Block device + * @v block Block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int virtblk_read ( struct block_device *blockdev, uint64_t block, + unsigned long count, userptr_t buffer ) { + struct virtblk *virtblk = + container_of ( blockdev, struct virtblk, blockdev ); + return virtblk_command ( virtblk, VIRTIO_BLK_T_IN, block, + count, buffer ); +} + +/** + * Write block + * + * @v blockdev Block device + * @v block Block number + * @v count Block count + * @v buffer Data buffer + * @ret rc Return status code + */ +static int virtblk_write ( struct block_device *blockdev __unused, uint64_t block __unused, + unsigned long count __unused, userptr_t buffer __unused ) { + struct virtblk *virtblk = + container_of ( blockdev, struct virtblk, blockdev ); + return virtblk_command ( virtblk, VIRTIO_BLK_T_OUT, block, + count, buffer ); +} + +static struct block_device_operations virtblk_operations = { + .read = virtblk_read, + .write = virtblk_write, +}; + +/** + * Probe PCI device + * + * @v pci PCI device + * @v id PCI ID + * @ret rc Return status code + */ +static int virtblk_probe ( struct pci_device *pci, + const struct pci_device_id *id __unused ) { + unsigned long ioaddr = pci->ioaddr; + + /* Initialize driver state */ + struct virtblk *virtblk = zalloc ( sizeof *virtblk ); + if ( ! virtblk ) + return -ENOMEM; + INIT_LIST_HEAD ( &virtblk->virtblk_devices ); + virtblk->blockdev.op = &virtblk_operations; + virtblk->pdev = pci; + pci->priv = virtblk; + + /* Prepare the device */ + adjust_pci_device ( pci ); + vp_reset ( ioaddr ); + + /* Indicate that the driver is starting */ + vp_set_status ( ioaddr, VIRTIO_CONFIG_S_ACKNOWLEDGE | + VIRTIO_CONFIG_S_DRIVER ); + + /* Grab the I/O requests virtqueue */ + if ( vp_find_vq ( ioaddr, 0, &virtblk->virtqueue ) < 0 ) { + free ( virtblk ); + return -ENOENT; + } + + /* Feature negotiation */ + u32 features = vp_get_features ( ioaddr ); + vp_set_features ( ioaddr, 0 ); /* no features required */ + + /* Find out the drive capacity */ + virtblk->blockdev.blksize = 512; /* the default */ + vp_get ( ioaddr, 0, &virtblk->blockdev.blocks, + sizeof virtblk->blockdev.blocks ); + + /* Indicate that the driver is ready */ + vp_set_status ( ioaddr, VIRTIO_CONFIG_S_ACKNOWLEDGE | + VIRTIO_CONFIG_S_DRIVER | + VIRTIO_CONFIG_S_DRIVER_OK ); + + DBGC ( virtblk, "VIRTBLK %p virtio_blk:%s ioaddr=0x%lx irq=%d features=0x%x capacity=%lld\n", + virtblk, pci->dev.name, ioaddr, pci->irq, + features, virtblk->blockdev.blocks ); + + register_virtblk ( virtblk ); + return 0; +} + +/** + * Remove PCI device + * + * @v pci PCI device + */ +static void virtblk_remove ( struct pci_device *pci ) { + struct virtblk *virtblk = pci->priv; + + unregister_virtblk ( virtblk ); + vp_reset ( pci->ioaddr ); + free ( virtblk ); +} + +static struct pci_device_id virtblk_ids[] = { + PCI_ROM(0x1af4, 0x1001, "virtio-blk", "Virtio Block Device", 0), +}; + +struct pci_driver virtblk_driver __pci_driver = { + .ids = virtblk_ids, + .id_count = ( sizeof ( virtblk_ids ) / sizeof ( virtblk_ids[0] ) ), + .probe = virtblk_probe, + .remove = virtblk_remove, +}; diff --git a/src/drivers/block/virtio-blk.h b/src/drivers/block/virtio-blk.h new file mode 100644 index 0000000..3a34868 --- /dev/null +++ b/src/drivers/block/virtio-blk.h @@ -0,0 +1,30 @@ +#ifndef _VIRTIO_BLK_H +#define _VIRTIO_BLK_H +/* This header is BSD licensed so anyone can use the definitions to implement + * compatible drivers/servers. */ + +FILE_LICENCE ( BSD2 ); + +/* + * Command types + */ + +/* These two define direction. */ +#define VIRTIO_BLK_T_IN 0 +#define VIRTIO_BLK_T_OUT 1 + +/* This is the first element of the read scatter-gather list. */ +struct virtio_blk_outhdr { + /* VIRTIO_BLK_T* */ + u32 type; + /* io priority. */ + u32 ioprio; + /* Sector (ie. 512 byte offset) */ + u64 sector; +}; + +/* And this is the final byte of the write scatter-gather list. */ +#define VIRTIO_BLK_S_OK 0 +#define VIRTIO_BLK_S_IOERR 1 +#define VIRTIO_BLK_S_UNSUPP 2 +#endif /* _VIRTIO_BLK_H */ diff --git a/src/include/gpxe/errfile.h b/src/include/gpxe/errfile.h index 5231c14..092d7eb 100644 --- a/src/include/gpxe/errfile.h +++ b/src/include/gpxe/errfile.h @@ -122,6 +122,7 @@ FILE_LICENCE ( GPL2_OR_LATER ); #define ERRFILE_linda ( ERRFILE_DRIVER | 0x00730000 ) #define ERRFILE_ata ( ERRFILE_DRIVER | 0x00740000 ) #define ERRFILE_srp ( ERRFILE_DRIVER | 0x00750000 ) +#define ERRFILE_virtio_blk ( ERRFILE_DRIVER | 0x00760000 ) #define ERRFILE_aoe ( ERRFILE_NET | 0x00000000 ) #define ERRFILE_arp ( ERRFILE_NET | 0x00010000 ) @@ -191,6 +192,7 @@ FILE_LICENCE ( GPL2_OR_LATER ); #define ERRFILE_x509 ( ERRFILE_OTHER | 0x00160000 ) #define ERRFILE_login_ui ( ERRFILE_OTHER | 0x00170000 ) #define ERRFILE_ib_srpboot ( ERRFILE_OTHER | 0x00180000 ) +#define ERRFILE_virtio_blkboot ( ERRFILE_OTHER | 0x00190000 ) /** @} */ diff --git a/src/include/gpxe/virtblk.h b/src/include/gpxe/virtblk.h new file mode 100644 index 0000000..781d433 --- /dev/null +++ b/src/include/gpxe/virtblk.h @@ -0,0 +1,37 @@ +#ifndef _GPXE_VIRTBLK_H +#define _GPXE_VIRTBLK_H + +/** @file + * + * Virtio block device + * + */ + +FILE_LICENCE ( GPL2_OR_LATER ); + +#include +#include +#include +#include +#include + +/** + * Virtio block device + */ +struct virtblk { + /** List of virtio-blk devices */ + struct list_head virtblk_devices; + + /** Underlying PCI device */ + struct pci_device *pdev; + + /** Outgoing requests virtqueue */ + struct vring_virtqueue virtqueue; + + /** Block device */ + struct block_device blockdev; +}; + +extern struct virtblk *find_virtblk ( const char *device_name ); + +#endif /* _GPXE_VIRTBLK_H */ -- 1.6.5 --001485eafef29d92c3047c70ef97 Content-Type: text/x-patch; charset=US-ASCII; name="virtio_blk.diff" Content-Disposition: attachment; filename="virtio_blk.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_g435hafq0 RnJvbSAwOTI2NjQ5YmVjZThlMDZkZmRiMTllNGY4MTk3OTVkYTZlZTM2NGRkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBTdGVmYW4gSGFqbm9jemkgPHN0ZWZhbmhhQGdtYWlsLmNvbT4K RGF0ZTogVHVlLCA1IEphbiAyMDEwIDA4OjA1OjMyICswMDAwClN1YmplY3Q6IFtQQVRDSCAxLzJd IFtzYW5ib290XSBQcmV2ZW50IGxlYWtpbmcgYSBzdGFjayByZWZlcmVuY2UgZm9yICJrZWVwLXNh biIgQW9FCgpXaGVuIHRoZSAia2VlcC1zYW4iIG9wdGlvbiBpcyB1c2VkLCB0aGUgZnVuY3Rpb24g aXMgZXhpdGVkIHdpdGhvdXQKdW5yZWdpc3RlcmluZyB0aGUgc3RhY2sgYWxsb2NhdGVkIGludDEz aCBkcml2ZS4gIFRvIHByZXZlbnQgYSBkYW5nbGluZwpwb2ludGVyIHRvIHRoZSBzdGFjaywgdGhl c2Ugc3RydWN0cyBzaG91bGQgYmUgaGVhcCBhbGxvY2F0ZWQuCi0tLQogc3JjL2FyY2gvaTM4Ni9p bnRlcmZhY2UvcGNiaW9zL2FvZWJvb3QuYyB8ICAgNTQgKysrKysrKysrKysrKysrKysrLS0tLS0t LS0tLS0KIDEgZmlsZXMgY2hhbmdlZCwgMzMgaW5zZXJ0aW9ucygrKSwgMjEgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvc3JjL2FyY2gvaTM4Ni9pbnRlcmZhY2UvcGNiaW9zL2FvZWJvb3QuYyBi L3NyYy9hcmNoL2kzODYvaW50ZXJmYWNlL3BjYmlvcy9hb2Vib290LmMKaW5kZXggODQ0NmMxNS4u MjY3MGIxNSAxMDA2NDQKLS0tIGEvc3JjL2FyY2gvaTM4Ni9pbnRlcmZhY2UvcGNiaW9zL2FvZWJv b3QuYworKysgYi9zcmMvYXJjaC9pMzg2L2ludGVyZmFjZS9wY2Jpb3MvYW9lYm9vdC5jCkBAIC0x LDExICsxLDExIEBACiAjaW5jbHVkZSA8c3RkaW50Lmg+CiAjaW5jbHVkZSA8c3RyaW5nLmg+Cisj aW5jbHVkZSA8c3RkbGliLmg+CiAjaW5jbHVkZSA8c3RkaW8uaD4KLSNpbmNsdWRlIDxieXRlc3dh cC5oPgorI2luY2x1ZGUgPGVycm5vLmg+CiAjaW5jbHVkZSA8Z3B4ZS9hb2UuaD4KICNpbmNsdWRl IDxncHhlL2F0YS5oPgogI2luY2x1ZGUgPGdweGUvbmV0ZGV2aWNlLmg+Ci0jaW5jbHVkZSA8Z3B4 ZS9zZXR0aW5ncy5oPgogI2luY2x1ZGUgPGdweGUvc2FuYm9vdC5oPgogI2luY2x1ZGUgPGdweGUv YWJmdC5oPgogI2luY2x1ZGUgPGludDEzLmg+CkBAIC0xMyw1MCArMTMsNjIgQEAKIEZJTEVfTElD RU5DRSAoIEdQTDJfT1JfTEFURVIgKTsKIAogc3RhdGljIGludCBhb2Vib290ICggY29uc3QgY2hh ciAqcm9vdF9wYXRoICkgewotCXN0cnVjdCBhdGFfZGV2aWNlIGF0YTsKLQlzdHJ1Y3QgaW50MTNf ZHJpdmUgZHJpdmU7CisJc3RydWN0IGF0YV9kZXZpY2UgKmF0YTsKKwlzdHJ1Y3QgaW50MTNfZHJp dmUgKmRyaXZlOwogCWludCByYzsKIAotCW1lbXNldCAoICZhdGEsIDAsIHNpemVvZiAoIGF0YSAp ICk7Ci0JbWVtc2V0ICggJmRyaXZlLCAwLCBzaXplb2YgKCBkcml2ZSApICk7CisJYXRhID0gemFs bG9jICggc2l6ZW9mICggKmF0YSApICk7CisJaWYgKCAhIGF0YSApIHsKKwkJcmMgPSAtRU5PTUVN OworCQlnb3RvIGVycl9hbGxvY19hdGE7CisJfQorCWRyaXZlID0gemFsbG9jICggc2l6ZW9mICgg KmRyaXZlICkgKTsKKwlpZiAoICEgZHJpdmUgKSB7CisJCXJjID0gLUVOT01FTTsKKwkJZ290byBl cnJfYWxsb2NfZHJpdmU7CisJfQogCiAJLyogRklYTUU6IHVnbHksIHVnbHkgaGFjayAqLwogCXN0 cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYgPSBsYXN0X29wZW5lZF9uZXRkZXYoKTsKIAotCWlmICgg KCByYyA9IGFvZV9hdHRhY2ggKCAmYXRhLCBuZXRkZXYsIHJvb3RfcGF0aCApICkgIT0gMCApIHsK KwlpZiAoICggcmMgPSBhb2VfYXR0YWNoICggYXRhLCBuZXRkZXYsIHJvb3RfcGF0aCApICkgIT0g MCApIHsKIAkJcHJpbnRmICggIkNvdWxkIG5vdCBhdHRhY2ggQW9FIGRldmljZTogJXNcbiIsCiAJ CQkgc3RyZXJyb3IgKCByYyApICk7Ci0JCWdvdG8gZXJyb3JfYXR0YWNoOworCQlnb3RvIGVycl9h dHRhY2g7CiAJfQotCWlmICggKCByYyA9IGluaXRfYXRhZGV2ICggJmF0YSApICkgIT0gMCApIHsK KwlpZiAoICggcmMgPSBpbml0X2F0YWRldiAoIGF0YSApICkgIT0gMCApIHsKIAkJcHJpbnRmICgg IkNvdWxkIG5vdCBpbml0aWFsaXNlIEFvRSBkZXZpY2U6ICVzXG4iLAogCQkJIHN0cmVycm9yICgg cmMgKSApOwotCQlnb3RvIGVycm9yX2luaXQ7CisJCWdvdG8gZXJyX2luaXQ7CiAJfQogCiAJLyog RklYTUU6IHVnbHksIHVnbHkgaGFjayAqLwogCXN0cnVjdCBhb2Vfc2Vzc2lvbiAqYW9lID0KLQkJ Y29udGFpbmVyX29mICggYXRhLmJhY2tlbmQsIHN0cnVjdCBhb2Vfc2Vzc2lvbiwgcmVmY250ICk7 CisJCWNvbnRhaW5lcl9vZiAoIGF0YS0+YmFja2VuZCwgc3RydWN0IGFvZV9zZXNzaW9uLCByZWZj bnQgKTsKIAlhYmZ0X2ZpbGxfZGF0YSAoIGFvZSApOwogCi0JZHJpdmUuYmxvY2tkZXYgPSAmYXRh LmJsb2NrZGV2OworCWRyaXZlLT5ibG9ja2RldiA9ICZhdGEtPmJsb2NrZGV2OwogCi0JcmVnaXN0 ZXJfaW50MTNfZHJpdmUgKCAmZHJpdmUgKTsKLQlwcmludGYgKCAiUmVnaXN0ZXJlZCBhcyBCSU9T IGRyaXZlICUjMDJ4XG4iLCBkcml2ZS5kcml2ZSApOwotCXByaW50ZiAoICJCb290aW5nIGZyb20g QklPUyBkcml2ZSAlIzAyeFxuIiwgZHJpdmUuZHJpdmUgKTsKLQlyYyA9IGludDEzX2Jvb3QgKCBk cml2ZS5kcml2ZSApOworCXJlZ2lzdGVyX2ludDEzX2RyaXZlICggZHJpdmUgKTsKKwlwcmludGYg KCAiUmVnaXN0ZXJlZCBhcyBCSU9TIGRyaXZlICUjMDJ4XG4iLCBkcml2ZS0+ZHJpdmUgKTsKKwlw cmludGYgKCAiQm9vdGluZyBmcm9tIEJJT1MgZHJpdmUgJSMwMnhcbiIsIGRyaXZlLT5kcml2ZSAp OworCXJjID0gaW50MTNfYm9vdCAoIGRyaXZlLT5kcml2ZSApOwogCXByaW50ZiAoICJCb290IGZh aWxlZFxuIiApOwogCiAJLyogTGVhdmUgZHJpdmUgcmVnaXN0ZXJlZCwgaWYgaW5zdHJ1Y3RlZCB0 byBkbyBzbyAqLwogCWlmICgga2VlcF9zYW4oKSApCiAJCXJldHVybiByYzsKIAotCXByaW50ZiAo ICJVbnJlZ2lzdGVyaW5nIEJJT1MgZHJpdmUgJSMwMnhcbiIsIGRyaXZlLmRyaXZlICk7Ci0JdW5y ZWdpc3Rlcl9pbnQxM19kcml2ZSAoICZkcml2ZSApOworCXByaW50ZiAoICJVbnJlZ2lzdGVyaW5n IEJJT1MgZHJpdmUgJSMwMnhcbiIsIGRyaXZlLT5kcml2ZSApOworCXVucmVnaXN0ZXJfaW50MTNf ZHJpdmUgKCBkcml2ZSApOwogCi0gZXJyb3JfaW5pdDoKLQlhb2VfZGV0YWNoICggJmF0YSApOwot IGVycm9yX2F0dGFjaDoKKyBlcnJfaW5pdDoKKwlhb2VfZGV0YWNoICggYXRhICk7CisgZXJyX2F0 dGFjaDoKKwlmcmVlICggZHJpdmUgKTsKKyBlcnJfYWxsb2NfZHJpdmU6CisJZnJlZSAoIGF0YSAp OworIGVycl9hbGxvY19hdGE6CiAJcmV0dXJuIHJjOwogfQogCi0tIAoxLjYuNQoKCkZyb20gM2Ri YzM4NWQyOWNiZGZmNTIwZWQwNjk0OTM0YzAxYTY4MDhmZjFkYyBNb24gU2VwIDE3IDAwOjAwOjAw IDIwMDEKRnJvbTogU3RlZmFuIEhham5vY3ppIDxzdGVmYW5oYUBnbWFpbC5jb20+CkRhdGU6IFR1 ZSwgNSBKYW4gMjAxMCAxNzozOToxOCArMDAwMApTdWJqZWN0OiBbUEFUQ0ggMi8yXSBbdmlydGlv XSBBZGQgdmlydGlvIGJsb2NrIGRldmljZSBzYW5ib290IHN1cHBvcnQKClRoaXMgcGF0Y2ggYWRk cyB2aXJ0aW8gYmxvY2sgZGV2aWNlIHN1cHBvcnQgYWxvbmdzaWRlIHRoZSBleGlzdGluZwppU0NT SSwgQVRBLW92ZXItRXRoZXJuZXQsIGFuZCByYW1kaXNrIGJsb2NrIGRldmljZXMuICBBIGdQWEUg b3B0aW9uIFJPTQpjYW4gYm9vdCBhIFFFTVUvS1ZNIHZpcnR1YWwgbWFjaGluZSBkaXJlY3RseSBm cm9tIGEgdmlydGlvIGJsb2NrIGRldmljZToKCiAgICAjIEVuc3VyZSBTQU5CT09UX1BST1RPX1ZJ UlRJT19CTEsgaXMgZGVmaW5lZCBpbiBjb25maWcvZGVmYXVsdHMuaAogICAgbWFrZSBiaW4vMWFm NDEwMDEucm9tCgpUaGUgc2FuYm9vdCBnUFhFIGNvbW1hbmQgaXMgdXNlZCB3aXRoIHRoZSB2aXJ0 aW9fYmxrOiByb290IHBhdGggc2NoZW1lLgpUaGUgdmlydGlvIGJsb2NrIGRldmljZSBpbnN0YW5j ZSBpcyBpZGVudGlmaWVkIGJ5IGl0cyBQQ0kgYnVzLCBkZXZpY2UsCmFuZCBmdW5jdGlvbiAodGhl cmUgY291bGQgYmUgbXVsdGlwbGUgdmlydGlvIGJsb2NrIGRldmljZXMpLgoKICAgIHNhbmJvb3Qg dmlydGlvX2JsazpQQ0kwMDowNC4wCgpTdWNjZXNzZnVsbHkgYm9vdHMgRGViaWFuIHRlc3Rpbmcg aTM4NiBhbmQgRnJlZURPUyAwLjg0LXByZTIgdW5kZXIgUUVNVS4KLS0tCiBzcmMvYXJjaC9pMzg2 L2ludGVyZmFjZS9wY2Jpb3MvdmlydGlvX2Jsa2Jvb3QuYyB8ICAgNzAgKysrKysrCiBzcmMvY29u ZmlnL2NvbmZpZy5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDMgKwogc3JjL2Nv bmZpZy9nZW5lcmFsLmggICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsKIHNyYy9k cml2ZXJzL2Jsb2NrL3ZpcnRpby1ibGsuYyAgICAgICAgICAgICAgICAgIHwgIDI3MSArKysrKysr KysrKysrKysrKysrKysrKwogc3JjL2RyaXZlcnMvYmxvY2svdmlydGlvLWJsay5oICAgICAgICAg ICAgICAgICAgfCAgIDMwICsrKwogc3JjL2luY2x1ZGUvZ3B4ZS9lcnJmaWxlLmggICAgICAgICAg ICAgICAgICAgICAgfCAgICAyICsKIHNyYy9pbmNsdWRlL2dweGUvdmlydGJsay5oICAgICAgICAg ICAgICAgICAgICAgIHwgICAzNyArKysKIDcgZmlsZXMgY2hhbmdlZCwgNDE0IGluc2VydGlvbnMo KyksIDAgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL2FyY2gvaTM4Ni9pbnRl cmZhY2UvcGNiaW9zL3ZpcnRpb19ibGtib290LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvZHJp dmVycy9ibG9jay92aXJ0aW8tYmxrLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvZHJpdmVycy9i bG9jay92aXJ0aW8tYmxrLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvaW5jbHVkZS9ncHhlL3Zp cnRibGsuaAoKZGlmZiAtLWdpdCBhL3NyYy9hcmNoL2kzODYvaW50ZXJmYWNlL3BjYmlvcy92aXJ0 aW9fYmxrYm9vdC5jIGIvc3JjL2FyY2gvaTM4Ni9pbnRlcmZhY2UvcGNiaW9zL3ZpcnRpb19ibGti b290LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2MyZGQ0NwotLS0gL2Rl di9udWxsCisrKyBiL3NyYy9hcmNoL2kzODYvaW50ZXJmYWNlL3BjYmlvcy92aXJ0aW9fYmxrYm9v dC5jCkBAIC0wLDAgKzEsNzAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU3RlZmFuIEhh am5vY3ppIDxzdGVmYW5oYUBnbWFpbC5jb20+LgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzCisgKiBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24g MiBvZiB0aGUKKyAqIExpY2Vuc2UsIG9yIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFt OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMu LCA2NzUgTWFzcyBBdmUsIENhbWJyaWRnZSwgTUEgMDIxMzksIFVTQS4KKyAqLworCitGSUxFX0xJ Q0VOQ0UgKCBHUEwyX09SX0xBVEVSICk7CisKKyNpbmNsdWRlIDxzdGRpbnQuaD4KKyNpbmNsdWRl IDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdGRpby5oPgorI2luY2x1ZGUgPGVycm5vLmg+CisjaW5j bHVkZSA8Z3B4ZS9zYW5ib290Lmg+CisjaW5jbHVkZSA8Z3B4ZS92aXJ0YmxrLmg+CisjaW5jbHVk ZSA8aW50MTMuaD4KKworLyoqCisgKiBAZmlsZQorICoKKyAqIFZpcnRpbyBibG9jayBkZXZpY2Ug Ym9vdAorICoKKyAqLworCitzdGF0aWMgaW50IHZpcnRpb19ibGtib290ICggY29uc3QgY2hhciAq cm9vdF9wYXRoICkgeworCXN0cnVjdCBpbnQxM19kcml2ZSAqZHJpdmU7CisJc3RydWN0IHZpcnRi bGsgKnZpcnRibGs7CisJaW50IHJjOworCisJdmlydGJsayA9IGZpbmRfdmlydGJsayAoIHJvb3Rf cGF0aCArIHNpemVvZiAoICJ2aXJ0aW9fYmxrOiIgKSAtIDEgKTsKKwlpZiAoICEgdmlydGJsayAp CisJCXJldHVybiAtRU5PRU5UOworCisJZHJpdmUgPSB6YWxsb2MgKCBzaXplb2YgKCAqZHJpdmUg KSApOworCWlmICggISBkcml2ZSApCisJCXJldHVybiAtRU5PTUVNOworCisJZHJpdmUtPmJsb2Nr ZGV2ID0gJnZpcnRibGstPmJsb2NrZGV2OworCisJcmVnaXN0ZXJfaW50MTNfZHJpdmUgKCBkcml2 ZSApOworCXByaW50ZiAoICJSZWdpc3RlcmVkIGFzIEJJT1MgZHJpdmUgJSMwMnhcbiIsIGRyaXZl LT5kcml2ZSApOworCXByaW50ZiAoICJCb290aW5nIGZyb20gQklPUyBkcml2ZSAlIzAyeFxuIiwg ZHJpdmUtPmRyaXZlICk7CisJcmMgPSBpbnQxM19ib290ICggZHJpdmUtPmRyaXZlICk7CisJcHJp bnRmICggIkJvb3QgZmFpbGVkXG4iICk7CisKKwkvKiBMZWF2ZSBkcml2ZSByZWdpc3RlcmVkLCBp ZiBpbnN0cnVjdGVkIHRvIGRvIHNvICovCisJaWYgKCBrZWVwX3NhbigpICkKKwkJcmV0dXJuIHJj OworCisJcHJpbnRmICggIlVucmVnaXN0ZXJpbmcgQklPUyBkcml2ZSAlIzAyeFxuIiwgZHJpdmUt PmRyaXZlICk7CisJdW5yZWdpc3Rlcl9pbnQxM19kcml2ZSAoIGRyaXZlICk7CisJZnJlZSAoIGRy aXZlICk7CisJcmV0dXJuIHJjOworfQorCitzdHJ1Y3Qgc2FuYm9vdF9wcm90b2NvbCB2aXJ0Ymxr X3NhbmJvb3RfcHJvdG9jb2wgX19zYW5ib290X3Byb3RvY29sID0geworCS5wcmVmaXggPSAidmly dGlvX2JsazoiLAorCS5ib290ID0gdmlydGlvX2Jsa2Jvb3QsCit9OwpkaWZmIC0tZ2l0IGEvc3Jj L2NvbmZpZy9jb25maWcuYyBiL3NyYy9jb25maWcvY29uZmlnLmMKaW5kZXggM2M0M2RmYi4uYmIw ZmY2NyAxMDA2NDQKLS0tIGEvc3JjL2NvbmZpZy9jb25maWcuYworKysgYi9zcmMvY29uZmlnL2Nv bmZpZy5jCkBAIC0xMzAsNiArMTMwLDkgQEAgUkVRVUlSRV9PQkpFQ1QgKCBhb2Vib290ICk7CiAj aWZkZWYgU0FOQk9PVF9QUk9UT19JQl9TUlAKIFJFUVVJUkVfT0JKRUNUICggaWJfc3JwYm9vdCAp OwogI2VuZGlmCisjaWZkZWYgU0FOQk9PVF9QUk9UT19WSVJUSU9fQkxLCitSRVFVSVJFX09CSkVD VCAoIHZpcnRpb19ibGtib290ICk7CisjZW5kaWYKIAogLyoKICAqIERyYWcgaW4gYWxsIHJlcXVl c3RlZCByZXNvbHZlcnMKZGlmZiAtLWdpdCBhL3NyYy9jb25maWcvZ2VuZXJhbC5oIGIvc3JjL2Nv bmZpZy9nZW5lcmFsLmgKaW5kZXggZWUwN2RmYy4uYTFkZWMzOSAxMDA2NDQKLS0tIGEvc3JjL2Nv bmZpZy9nZW5lcmFsLmgKKysrIGIvc3JjL2NvbmZpZy9nZW5lcmFsLmgKQEAgLTYzLDYgKzYzLDcg QEAgRklMRV9MSUNFTkNFICggR1BMMl9PUl9MQVRFUiApOwogLy8jdW5kZWYJU0FOQk9PVF9QUk9U T19JU0NTSQkvKiBpU0NTSSBwcm90b2NvbCAqLwogLy8jdW5kZWYJU0FOQk9PVF9QUk9UT19BT0UJ LyogQW9FIHByb3RvY29sICovCiAvLyN1bmRlZglTQU5CT09UX1BST1RPX0lCX1NSUAkvKiBJbmZp bmliYW5kIFNDU0kgUkRNQSBwcm90b2NvbCAqLworLy8jdW5kZWYJU0FOQk9PVF9QUk9UT19WSVJU SU9fQkxLIC8qIFZpcnRpbyBibG9jayBkZXZpY2UgKi8KIAogLyoKICAqIE5hbWUgcmVzb2x1dGlv biBtb2R1bGVzCmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9ibG9jay92aXJ0aW8tYmxrLmMgYi9z cmMvZHJpdmVycy9ibG9jay92aXJ0aW8tYmxrLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uZmFiNTkzMAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9kcml2ZXJzL2Jsb2NrL3Zp cnRpby1ibGsuYwpAQCAtMCwwICsxLDI3MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBT dGVmYW4gSGFqbm9jemkgPHN0ZWZhbmhhQGdtYWlsLmNvbT4uCisgKgorICogVGhpcyBwcm9ncmFt IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug YXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIg dmVyc2lvbiAyIG9mIHRoZQorICogTGljZW5zZSwgb3IgYW55IGxhdGVyIHZlcnNpb24uCisgKgor ICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRp b24sIEluYy4sIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgorICovCisK K0ZJTEVfTElDRU5DRSAoIEdQTDJfT1JfTEFURVIgKTsKKworI2luY2x1ZGUgPGVycm5vLmg+Cisj aW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8Z3B4ZS9wcm9jZXNzLmg+CisjaW5jbHVkZSA8 Z3B4ZS92aXJ0YmxrLmg+CisjaW5jbHVkZSAidmlydGlvLWJsay5oIgorCisvKioKKyAqIEBmaWxl CisgKgorICogVmlydGlvIGJsb2NrIGRldmljZXMKKyAqCisgKi8KKworLyoqIExpc3Qgb2Ygdmly dGlvIGJsb2NrIGRldmljZXMgKi8KK3N0YXRpYyBMSVNUX0hFQUQgKCB2aXJ0YmxrX2RldmljZXMg KTsKKworLyoqCisgKiBSZWdpc3RlciB2aXJ0aW8gYmxvY2sgZGV2aWNlCisgKgorICogQHYgdmly dGJsawkJVmlydGlvIGJsb2NrIGRldmljZQorICoKKyAqIEFkZHMgdGhlIHZpcnRpbyBibG9jayBk ZXZpY2UgdG8gdGhlIGxpc3Qgb2YgdmlydGlvIGJsb2NrIGRldmljZXMuCisgKi8KK3N0YXRpYyB2 b2lkIHJlZ2lzdGVyX3ZpcnRibGsgKCBzdHJ1Y3QgdmlydGJsayAqdmlydGJsayApIHsKKwlsaXN0 X2FkZF90YWlsICggJnZpcnRibGstPnZpcnRibGtfZGV2aWNlcywgJnZpcnRibGtfZGV2aWNlcyAp OworfQorCisvKioKKyAqIFVucmVnaXN0ZXIgdmlydGlvIGJsb2NrIGRldmljZQorICoKKyAqIEB2 IHZpcnRibGsJCVZpcnRpbyBibG9jayBkZXZpY2UKKyAqCisgKiBSZW1vdmVzIHRoZSB2aXJ0aW8g YmxvY2sgZGV2aWNlIGZyb20gdGhlIGxpc3Qgb2YgdmlydGlvIGJsb2NrIGRldmljZXMuCisgKi8K K3N0YXRpYyB2b2lkIHVucmVnaXN0ZXJfdmlydGJsayAoIHN0cnVjdCB2aXJ0YmxrICp2aXJ0Ymxr ICkgeworCWxpc3RfZGVsICggJnZpcnRibGstPnZpcnRibGtfZGV2aWNlcyApOworfQorCisvKioK KyAqIEZpbmQgdmlydGlvIGJsb2NrIGRldmljZSBieSBuYW1lCisgKgorICogQHYgZGV2aWNlX25h bWUJRGV2aWNlIG5hbWUKKyAqIEByZXQgdmlydGJsawkJVmlydGlvIGJsb2NrIGRldmljZSBvciBO VUxMCisgKgorICogU2VhcmNoZXMgdGhlIGxpc3Qgb2YgdmlydGlvIGJsb2NrIGRldmljZXMgYnkg bmFtZS4KKyAqLworc3RydWN0IHZpcnRibGsgKmZpbmRfdmlydGJsayAoIGNvbnN0IGNoYXIgKmRl dmljZV9uYW1lICkgeworCXN0cnVjdCB2aXJ0YmxrICp2aXJ0YmxrOworCURCRyAoICJmaW5kX3Zp cnRibGsgXCIlc1wiXG4iLCBkZXZpY2VfbmFtZSApOworCWxpc3RfZm9yX2VhY2hfZW50cnkgKCB2 aXJ0YmxrLCAmdmlydGJsa19kZXZpY2VzLCB2aXJ0YmxrX2RldmljZXMgKSB7CisJCWlmICggISBz dHJjbXAgKCBkZXZpY2VfbmFtZSwgdmlydGJsay0+cGRldi0+ZGV2Lm5hbWUgKSApCisJCQlyZXR1 cm4gdmlydGJsazsKKwl9CisJcmV0dXJuIE5VTEw7Cit9CisKKy8qKgorICogSXNzdWUgYW4gSS9P IHJlcXVlc3QgYW5kIHdhaXQgZm9yIGNvbXBsZXRpb24KKyAqCisgKiBAdiB2aXJ0YmxrCQlWaXJ0 aW8gYmxvY2sgZGV2aWNlCisgKiBAdiB0eXBlCQlWSVJUSU9fQkxLX1RfSU4gb3IgVklSVElPX0JM S19UX09VVAorICogQHYgYmxvY2sJCUJsb2NrIG51bWJlcgorICogQHYgY291bnQJCUJsb2NrIGNv dW50CisgKiBAdiBidWZmZXIJCURhdGEgYnVmZmVyCisgKiBAcmV0IHJjCQlSZXR1cm4gc3RhdHVz IGNvZGUKKyAqLworc3RhdGljIGludCB2aXJ0YmxrX2NvbW1hbmQgKCBzdHJ1Y3QgdmlydGJsayAq dmlydGJsaywgdTMyIHR5cGUsCisJCQkgICAgIHVpbnQ2NF90IGJsb2NrLCB1bnNpZ25lZCBsb25n IGNvdW50LAorCQkJICAgICB1c2VycHRyX3QgYnVmZmVyICkgeworCS8qCisJICogVmlydGlvIGJs b2NrIHJlcXVlc3RzIGhhdmUgdGhlIGZvbGxvd2luZyBmb3JtYXQ6CisJICoKKwkgKiAgICstLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKKwkgKiAgIHwgc3RydWN0IHZpcnRpb19ibGtf b3V0aGRyICBbSU5dIHwKKwkgKiAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsK KwkgKiAgIHwgSW4vb3V0IGJ1ZmZlciAgICAgICAgIFtJTi9PVVRdIHwKKwkgKiAgICstLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKKwkgKiAgIHwgU3RhdHVzIGJ5dGUgICAgICAgICAg ICAgIFtPVVRdIHwKKwkgKiAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKKwkg KgorCSAqIFRoZSBkZXZpY2UgZmlsbHMgaW4gdGhlIHN0YXR1cyBieXRlIHRvIGluZGljYXRlIHRo ZSBvdXRjb21lIHRoZQorCSAqIG9wZXJhdGlvbi4KKwkgKi8KKwlzdHJ1Y3QgdnJpbmdfdmlydHF1 ZXVlICp2cSA9ICZ2aXJ0YmxrLT52aXJ0cXVldWU7CisJc3RydWN0IHZpcnRpb19ibGtfb3V0aGRy IGhkciA9IHsKKwkJLnR5cGUgPSB0eXBlLAorCQkuaW9wcmlvID0gMCwKKwkJLnNlY3RvciA9IGJs b2NrLAorCX07CisJdWludDhfdCBzdGF0dXMgPSBWSVJUSU9fQkxLX1NfVU5TVVBQOworCXN0cnVj dCB2cmluZ19saXN0IGxpc3RbXSA9IHsKKwkJeworCQkJLmFkZHIJPSAoIGNoYXIgKiApICZoZHIs CisJCQkubGVuZ3RoCT0gc2l6ZW9mICggaGRyICksCisJCX0sCisJCXsKKwkJCS5hZGRyCT0gKCBj aGFyICogKSB1c2VyX3RvX3ZpcnQgKCBidWZmZXIsIDAgKSwKKwkJCS5sZW5ndGgJPSB2aXJ0Ymxr LT5ibG9ja2Rldi5ibGtzaXplICogY291bnQsCisJCX0sCisJCXsKKwkJCS5hZGRyCT0gKCBjaGFy ICogKSAmc3RhdHVzLAorCQkJLmxlbmd0aAk9IHNpemVvZiAoIHN0YXR1cyApLAorCQl9LAorCX07 CisJdW5zaWduZWQgaW50IGluLCBvdXQ7CisKKwlEQkcgKCAiVklSVEJMSyByZXEgMHglMDJ4IExC QSAweCVsbHggY291bnQgMHglbHhcbiIsCisJICAgICAgdHlwZSwgYmxvY2ssIGNvdW50ICk7CisK KwkvKiBOdW1iZXIgb2YgZWxlbWVudHMgcmVhZGFibGUgYW5kIHdyaXRhYmxlICovCisJaWYgKCB0 eXBlID09IFZJUlRJT19CTEtfVF9JTiApIHsKKwkJb3V0ID0gMTsKKwkJaW4gPSAyOworCX0gZWxz ZSB7CisJCW91dCA9IDI7CisJCWluID0gMTsKKwl9CisKKwkvKiBBZGQgdG8gdmlydHF1ZXVlIGFu ZCBraWNrIGhvc3QgKi8KKwl2cmluZ19hZGRfYnVmICggdnEsIGxpc3QsIG91dCwgaW4sIDAsIDAg KTsKKwl2cmluZ19raWNrICggdmlydGJsay0+cGRldi0+aW9hZGRyLCB2cSwgMSApOworCisJLyog V2FpdCBmb3IgcmVwbHkgKi8KKwl3aGlsZSAoICEgdnJpbmdfbW9yZV91c2VkICggdnEgKSApIHsK KwkJbWIoKTsKKwkJc3RlcCgpOworCX0KKworCS8qIFJlY2xhaW0gdmlydHF1ZXVlIGVsZW1lbnQg Ki8KKwl2cmluZ19nZXRfYnVmICggdnEsIE5VTEwgKTsKKwlyZXR1cm4gc3RhdHVzID09IFZJUlRJ T19CTEtfU19PSyA/IDAgOiAtRUlPOworfQorCisvKioKKyAqIFJlYWQgYmxvY2sKKyAqCisgKiBA diBibG9ja2RldgkJQmxvY2sgZGV2aWNlCisgKiBAdiBibG9jawkJQmxvY2sgbnVtYmVyCisgKiBA diBjb3VudAkJQmxvY2sgY291bnQKKyAqIEB2IGJ1ZmZlcgkJRGF0YSBidWZmZXIKKyAqIEByZXQg cmMJCVJldHVybiBzdGF0dXMgY29kZQorICovCitzdGF0aWMgaW50IHZpcnRibGtfcmVhZCAoIHN0 cnVjdCBibG9ja19kZXZpY2UgKmJsb2NrZGV2LCB1aW50NjRfdCBibG9jaywKKwkJCSAgdW5zaWdu ZWQgbG9uZyBjb3VudCwgdXNlcnB0cl90IGJ1ZmZlciApIHsKKwlzdHJ1Y3QgdmlydGJsayAqdmly dGJsayA9CisJCWNvbnRhaW5lcl9vZiAoIGJsb2NrZGV2LCBzdHJ1Y3QgdmlydGJsaywgYmxvY2tk ZXYgKTsKKwlyZXR1cm4gdmlydGJsa19jb21tYW5kICggdmlydGJsaywgVklSVElPX0JMS19UX0lO LCBibG9jaywKKwkJCQkgY291bnQsIGJ1ZmZlciApOworfQorCisvKioKKyAqIFdyaXRlIGJsb2Nr CisgKgorICogQHYgYmxvY2tkZXYJCUJsb2NrIGRldmljZQorICogQHYgYmxvY2sJCUJsb2NrIG51 bWJlcgorICogQHYgY291bnQJCUJsb2NrIGNvdW50CisgKiBAdiBidWZmZXIJCURhdGEgYnVmZmVy CisgKiBAcmV0IHJjCQlSZXR1cm4gc3RhdHVzIGNvZGUKKyAqLworc3RhdGljIGludCB2aXJ0Ymxr X3dyaXRlICggc3RydWN0IGJsb2NrX2RldmljZSAqYmxvY2tkZXYgX191bnVzZWQsIHVpbnQ2NF90 IGJsb2NrIF9fdW51c2VkLAorCQkJICAgdW5zaWduZWQgbG9uZyBjb3VudCBfX3VudXNlZCwgdXNl cnB0cl90IGJ1ZmZlciBfX3VudXNlZCApIHsKKwlzdHJ1Y3QgdmlydGJsayAqdmlydGJsayA9CisJ CWNvbnRhaW5lcl9vZiAoIGJsb2NrZGV2LCBzdHJ1Y3QgdmlydGJsaywgYmxvY2tkZXYgKTsKKwly ZXR1cm4gdmlydGJsa19jb21tYW5kICggdmlydGJsaywgVklSVElPX0JMS19UX09VVCwgYmxvY2ss CisJCQkJIGNvdW50LCBidWZmZXIgKTsKK30KKworc3RhdGljIHN0cnVjdCBibG9ja19kZXZpY2Vf b3BlcmF0aW9ucyB2aXJ0YmxrX29wZXJhdGlvbnMgPSB7CisJLnJlYWQJPSB2aXJ0YmxrX3JlYWQs CisJLndyaXRlCT0gdmlydGJsa193cml0ZSwKK307CisKKy8qKgorICogUHJvYmUgUENJIGRldmlj ZQorICoKKyAqIEB2IHBjaQlQQ0kgZGV2aWNlCisgKiBAdiBpZAlQQ0kgSUQKKyAqIEByZXQgcmMJ UmV0dXJuIHN0YXR1cyBjb2RlCisgKi8KK3N0YXRpYyBpbnQgdmlydGJsa19wcm9iZSAoIHN0cnVj dCBwY2lfZGV2aWNlICpwY2ksCisJCQkgICBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQg X191bnVzZWQgKSB7CisJdW5zaWduZWQgbG9uZyBpb2FkZHIgPSBwY2ktPmlvYWRkcjsKKworCS8q IEluaXRpYWxpemUgZHJpdmVyIHN0YXRlICovCisJc3RydWN0IHZpcnRibGsgKnZpcnRibGsgPSB6 YWxsb2MgKCBzaXplb2YgKnZpcnRibGsgKTsKKwlpZiAoICEgdmlydGJsayApCisJCXJldHVybiAt RU5PTUVNOworCUlOSVRfTElTVF9IRUFEICggJnZpcnRibGstPnZpcnRibGtfZGV2aWNlcyApOwor CXZpcnRibGstPmJsb2NrZGV2Lm9wID0gJnZpcnRibGtfb3BlcmF0aW9uczsKKwl2aXJ0YmxrLT5w ZGV2ID0gcGNpOworCXBjaS0+cHJpdiA9IHZpcnRibGs7CisKKwkvKiBQcmVwYXJlIHRoZSBkZXZp Y2UgKi8KKwlhZGp1c3RfcGNpX2RldmljZSAoIHBjaSApOworCXZwX3Jlc2V0ICggaW9hZGRyICk7 CisKKwkvKiBJbmRpY2F0ZSB0aGF0IHRoZSBkcml2ZXIgaXMgc3RhcnRpbmcgKi8KKwl2cF9zZXRf c3RhdHVzICggaW9hZGRyLCBWSVJUSU9fQ09ORklHX1NfQUNLTk9XTEVER0UgfAorCQkJCVZJUlRJ T19DT05GSUdfU19EUklWRVIgKTsKKworCS8qIEdyYWIgdGhlIEkvTyByZXF1ZXN0cyB2aXJ0cXVl dWUgKi8KKwlpZiAoIHZwX2ZpbmRfdnEgKCBpb2FkZHIsIDAsICZ2aXJ0YmxrLT52aXJ0cXVldWUg KSA8IDAgKSB7CisJCWZyZWUgKCB2aXJ0YmxrICk7CisJCXJldHVybiAtRU5PRU5UOworCX0KKwor CS8qIEZlYXR1cmUgbmVnb3RpYXRpb24gKi8KKwl1MzIgZmVhdHVyZXMgPSB2cF9nZXRfZmVhdHVy ZXMgKCBpb2FkZHIgKTsKKwl2cF9zZXRfZmVhdHVyZXMgKCBpb2FkZHIsIDAgKTsgLyogbm8gZmVh dHVyZXMgcmVxdWlyZWQgKi8KKworCS8qIEZpbmQgb3V0IHRoZSBkcml2ZSBjYXBhY2l0eSAqLwor CXZpcnRibGstPmJsb2NrZGV2LmJsa3NpemUgPSA1MTI7IC8qIHRoZSBkZWZhdWx0ICovCisJdnBf Z2V0ICggaW9hZGRyLCAwLCAmdmlydGJsay0+YmxvY2tkZXYuYmxvY2tzLAorCQkgc2l6ZW9mIHZp cnRibGstPmJsb2NrZGV2LmJsb2NrcyApOworCisJLyogSW5kaWNhdGUgdGhhdCB0aGUgZHJpdmVy IGlzIHJlYWR5ICovCisJdnBfc2V0X3N0YXR1cyAoIGlvYWRkciwgVklSVElPX0NPTkZJR19TX0FD S05PV0xFREdFIHwKKwkJCQlWSVJUSU9fQ09ORklHX1NfRFJJVkVSIHwKKwkJCQlWSVJUSU9fQ09O RklHX1NfRFJJVkVSX09LICk7CisKKwlEQkdDICggdmlydGJsaywgIlZJUlRCTEsgJXAgdmlydGlv X2JsazolcyBpb2FkZHI9MHglbHggaXJxPSVkIGZlYXR1cmVzPTB4JXggY2FwYWNpdHk9JWxsZFxu IiwKKwkgICAgICAgdmlydGJsaywgcGNpLT5kZXYubmFtZSwgaW9hZGRyLCBwY2ktPmlycSwKKwkg ICAgICAgZmVhdHVyZXMsIHZpcnRibGstPmJsb2NrZGV2LmJsb2NrcyApOworCisJcmVnaXN0ZXJf dmlydGJsayAoIHZpcnRibGsgKTsKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiBSZW1vdmUgUENJ IGRldmljZQorICoKKyAqIEB2IHBjaQlQQ0kgZGV2aWNlCisgKi8KK3N0YXRpYyB2b2lkIHZpcnRi bGtfcmVtb3ZlICggc3RydWN0IHBjaV9kZXZpY2UgKnBjaSApIHsKKwlzdHJ1Y3QgdmlydGJsayAq dmlydGJsayA9IHBjaS0+cHJpdjsKKworCXVucmVnaXN0ZXJfdmlydGJsayAoIHZpcnRibGsgKTsK Kwl2cF9yZXNldCAoIHBjaS0+aW9hZGRyICk7CisJZnJlZSAoIHZpcnRibGsgKTsKK30KKworc3Rh dGljIHN0cnVjdCBwY2lfZGV2aWNlX2lkIHZpcnRibGtfaWRzW10gPSB7CisJUENJX1JPTSgweDFh ZjQsIDB4MTAwMSwgInZpcnRpby1ibGsiLCAiVmlydGlvIEJsb2NrIERldmljZSIsIDApLAorfTsK Kworc3RydWN0IHBjaV9kcml2ZXIgdmlydGJsa19kcml2ZXIgX19wY2lfZHJpdmVyID0geworICAu aWRzID0gdmlydGJsa19pZHMsCisgIC5pZF9jb3VudCA9ICggc2l6ZW9mICggdmlydGJsa19pZHMg KSAvIHNpemVvZiAoIHZpcnRibGtfaWRzWzBdICkgKSwKKyAgLnByb2JlID0gdmlydGJsa19wcm9i ZSwKKyAgLnJlbW92ZSA9IHZpcnRibGtfcmVtb3ZlLAorfTsKZGlmZiAtLWdpdCBhL3NyYy9kcml2 ZXJzL2Jsb2NrL3ZpcnRpby1ibGsuaCBiL3NyYy9kcml2ZXJzL2Jsb2NrL3ZpcnRpby1ibGsuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zYTM0ODY4Ci0tLSAvZGV2L251bGwK KysrIGIvc3JjL2RyaXZlcnMvYmxvY2svdmlydGlvLWJsay5oCkBAIC0wLDAgKzEsMzAgQEAKKyNp Zm5kZWYgX1ZJUlRJT19CTEtfSAorI2RlZmluZSBfVklSVElPX0JMS19ICisvKiBUaGlzIGhlYWRl ciBpcyBCU0QgbGljZW5zZWQgc28gYW55b25lIGNhbiB1c2UgdGhlIGRlZmluaXRpb25zIHRvIGlt cGxlbWVudAorICogY29tcGF0aWJsZSBkcml2ZXJzL3NlcnZlcnMuICovCisKK0ZJTEVfTElDRU5D RSAoIEJTRDIgKTsKKworLyoKKyAqIENvbW1hbmQgdHlwZXMKKyAqLworCisvKiBUaGVzZSB0d28g ZGVmaW5lIGRpcmVjdGlvbi4gKi8KKyNkZWZpbmUgVklSVElPX0JMS19UX0lOCQkwCisjZGVmaW5l IFZJUlRJT19CTEtfVF9PVVQJMQorCisvKiBUaGlzIGlzIHRoZSBmaXJzdCBlbGVtZW50IG9mIHRo ZSByZWFkIHNjYXR0ZXItZ2F0aGVyIGxpc3QuICovCitzdHJ1Y3QgdmlydGlvX2Jsa19vdXRoZHIg eworCS8qIFZJUlRJT19CTEtfVCogKi8KKwl1MzIgdHlwZTsKKwkvKiBpbyBwcmlvcml0eS4gKi8K Kwl1MzIgaW9wcmlvOworCS8qIFNlY3RvciAoaWUuIDUxMiBieXRlIG9mZnNldCkgKi8KKwl1NjQg c2VjdG9yOworfTsKKworLyogQW5kIHRoaXMgaXMgdGhlIGZpbmFsIGJ5dGUgb2YgdGhlIHdyaXRl IHNjYXR0ZXItZ2F0aGVyIGxpc3QuICovCisjZGVmaW5lIFZJUlRJT19CTEtfU19PSwkJMAorI2Rl ZmluZSBWSVJUSU9fQkxLX1NfSU9FUlIJMQorI2RlZmluZSBWSVJUSU9fQkxLX1NfVU5TVVBQCTIK KyNlbmRpZiAvKiBfVklSVElPX0JMS19IICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ncHhl L2VycmZpbGUuaCBiL3NyYy9pbmNsdWRlL2dweGUvZXJyZmlsZS5oCmluZGV4IDUyMzFjMTQuLjA5 MmQ3ZWIgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2dweGUvZXJyZmlsZS5oCisrKyBiL3NyYy9p bmNsdWRlL2dweGUvZXJyZmlsZS5oCkBAIC0xMjIsNiArMTIyLDcgQEAgRklMRV9MSUNFTkNFICgg R1BMMl9PUl9MQVRFUiApOwogI2RlZmluZSBFUlJGSUxFX2xpbmRhCQkgICAgICggRVJSRklMRV9E UklWRVIgfCAweDAwNzMwMDAwICkKICNkZWZpbmUgRVJSRklMRV9hdGEJCSAgICAgKCBFUlJGSUxF X0RSSVZFUiB8IDB4MDA3NDAwMDAgKQogI2RlZmluZSBFUlJGSUxFX3NycAkJICAgICAoIEVSUkZJ TEVfRFJJVkVSIHwgMHgwMDc1MDAwMCApCisjZGVmaW5lIEVSUkZJTEVfdmlydGlvX2JsawkgICAg ICggRVJSRklMRV9EUklWRVIgfCAweDAwNzYwMDAwICkKIAogI2RlZmluZSBFUlJGSUxFX2FvZQkJ CSggRVJSRklMRV9ORVQgfCAweDAwMDAwMDAwICkKICNkZWZpbmUgRVJSRklMRV9hcnAJCQkoIEVS UkZJTEVfTkVUIHwgMHgwMDAxMDAwMCApCkBAIC0xOTEsNiArMTkyLDcgQEAgRklMRV9MSUNFTkNF ICggR1BMMl9PUl9MQVRFUiApOwogI2RlZmluZSBFUlJGSUxFX3g1MDkJCSAgICAgICggRVJSRklM RV9PVEhFUiB8IDB4MDAxNjAwMDAgKQogI2RlZmluZSBFUlJGSUxFX2xvZ2luX3VpCSAgICAgICgg RVJSRklMRV9PVEhFUiB8IDB4MDAxNzAwMDAgKQogI2RlZmluZSBFUlJGSUxFX2liX3NycGJvb3QJ ICAgICAgKCBFUlJGSUxFX09USEVSIHwgMHgwMDE4MDAwMCApCisjZGVmaW5lIEVSUkZJTEVfdmly dGlvX2Jsa2Jvb3QJICAgICAgKCBFUlJGSUxFX09USEVSIHwgMHgwMDE5MDAwMCApCiAKIC8qKiBA fSAqLwogCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9ncHhlL3ZpcnRibGsuaCBiL3NyYy9pbmNs dWRlL2dweGUvdmlydGJsay5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc4 MWQ0MzMKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvaW5jbHVkZS9ncHhlL3ZpcnRibGsuaApAQCAt MCwwICsxLDM3IEBACisjaWZuZGVmIF9HUFhFX1ZJUlRCTEtfSAorI2RlZmluZSBfR1BYRV9WSVJU QkxLX0gKKworLyoqIEBmaWxlCisgKgorICogVmlydGlvIGJsb2NrIGRldmljZQorICoKKyAqLwor CitGSUxFX0xJQ0VOQ0UgKCBHUEwyX09SX0xBVEVSICk7CisKKyNpbmNsdWRlIDxncHhlL2xpc3Qu aD4KKyNpbmNsdWRlIDxncHhlL3BjaS5oPgorI2luY2x1ZGUgPGdweGUvdmlydGlvLXJpbmcuaD4K KyNpbmNsdWRlIDxncHhlL3ZpcnRpby1wY2kuaD4KKyNpbmNsdWRlIDxncHhlL2Jsb2NrZGV2Lmg+ CisKKy8qKgorICogVmlydGlvIGJsb2NrIGRldmljZQorICovCitzdHJ1Y3QgdmlydGJsayB7CisJ LyoqIExpc3Qgb2YgdmlydGlvLWJsayBkZXZpY2VzICovCisJc3RydWN0IGxpc3RfaGVhZCB2aXJ0 YmxrX2RldmljZXM7CisKKwkvKiogVW5kZXJseWluZyBQQ0kgZGV2aWNlICovCisJc3RydWN0IHBj aV9kZXZpY2UgKnBkZXY7CisKKwkvKiogT3V0Z29pbmcgcmVxdWVzdHMgdmlydHF1ZXVlICovCisJ c3RydWN0IHZyaW5nX3ZpcnRxdWV1ZSB2aXJ0cXVldWU7CisKKwkvKiogQmxvY2sgZGV2aWNlICov CisJc3RydWN0IGJsb2NrX2RldmljZSBibG9ja2RldjsKK307CisKK2V4dGVybiBzdHJ1Y3Qgdmly dGJsayAqZmluZF92aXJ0YmxrICggY29uc3QgY2hhciAqZGV2aWNlX25hbWUgKTsKKworI2VuZGlm IC8qIF9HUFhFX1ZJUlRCTEtfSCAqLwotLSAKMS42LjUKCg== --001485eafef29d92c3047c70ef97--