From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9C92EC2D0C9 for ; Thu, 12 Dec 2019 10:25:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 67A2E206DA for ; Thu, 12 Dec 2019 10:25:27 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="cjoNityX" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728461AbfLLKZ0 (ORCPT ); Thu, 12 Dec 2019 05:25:26 -0500 Received: from us-smtp-2.mimecast.com ([205.139.110.61]:49865 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1728339AbfLLKZ0 (ORCPT ); Thu, 12 Dec 2019 05:25:26 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1576146324; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=OSkgRtiYdPEzh+f+fCW5bB76S/m0r1Iwv0u/JAADSrk=; b=cjoNityXg+kqM6Fp10hzfwlh7HsRNTV9eU5PiR0jumsgwMvH6MLYTD9rdQkvw4jD4iAHnN mkdSrQKmUJmhGCkdi4MKDi3TSVtCpyODDdHvSa5OHtd/ggqT8mOhsj+8zXvreMlDl4trIp uu07zDq2GoxRLkNYud/LoI24Z5y72lw= Received: from mail-qk1-f199.google.com (mail-qk1-f199.google.com [209.85.222.199]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-70-qi_rf9HpPrmAS9x98Ps7gg-1; Thu, 12 Dec 2019 05:25:22 -0500 X-MC-Unique: qi_rf9HpPrmAS9x98Ps7gg-1 Received: by mail-qk1-f199.google.com with SMTP id u10so1105879qkk.1 for ; Thu, 12 Dec 2019 02:25:22 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=OSkgRtiYdPEzh+f+fCW5bB76S/m0r1Iwv0u/JAADSrk=; b=HEAf1IXqQZCm5yjQ34WEfVWnUg6wpmZfSlvjoZZyZWGgh/o8IYVQtilMOctTINNerZ 8znvL6PmOkmPWO3z6SMTuwVa/CwZQZcVF4yhdRSLUc9zdsaWnVIFSBuaI2MlPcjUkhPC hLtOnc5ci5nKvHRJ0VDyHabWbq+6tbJN4gbuohkHznf75tIwPgYNV1xpm4iIJFzEB+MS LLaLj9lh5OYSgd+uoVAaQ49lg5MYYSxu0C2GMSn63Vc8tcYMZ67gItkRnf4cMPDoAUQ0 AS8ZX10+7T65WTuh+CTIKdbDCimWlc8yVz2yg92+6RAC8isuSEHbs0xmjlcQ1SCJEyaU 2stQ== X-Gm-Message-State: APjAAAVJuEgO1U+A5Rw7W5Vcsye5itiSHLoxIMJgJqMbw9jUDy5vZYNv kppAfdXHadVkQ6h58q26EWUw/AaImxafSovXEJ1osg+/4LGRx6oueGfLUcO3zE1W70yzaGs8cCp AtSuv4s75VXMUNqWaYbbAsQk= X-Received: by 2002:ac8:30f7:: with SMTP id w52mr6149749qta.380.1576146321957; Thu, 12 Dec 2019 02:25:21 -0800 (PST) X-Google-Smtp-Source: APXvYqwSGl+JKJyuG7phPNnisrpigPfhOzco07eF2KpqZAcQtpmCc770dLTw0BAD3K5ElTorv/5quQ== X-Received: by 2002:ac8:30f7:: with SMTP id w52mr6149731qta.380.1576146321461; Thu, 12 Dec 2019 02:25:21 -0800 (PST) Received: from redhat.com (bzq-79-181-48-215.red.bezeqint.net. [79.181.48.215]) by smtp.gmail.com with ESMTPSA id e12sm513890qtq.4.2019.12.12.02.25.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 12 Dec 2019 02:25:20 -0800 (PST) Date: Thu, 12 Dec 2019 05:25:12 -0500 From: "Michael S. Tsirkin" To: Arnd Bergmann Cc: Jens Axboe , "James E.J. Bottomley" , "Martin K. Petersen" , Alexander Viro , Jason Wang , Doug Gilbert , Kai =?iso-8859-1?Q?M=E4kisara?= , linux-kernel@vger.kernel.org, y2038@lists.linaro.org, Paolo Bonzini , Stefan Hajnoczi , Bart Van Assche , Hannes Reinecke , Damien Le Moal , John Garry , virtualization@lists.linux-foundation.org, linux-block@vger.kernel.org, linux-scsi@vger.kernel.org, linux-fsdevel@vger.kernel.org Subject: Re: [PATCH 15/24] compat_ioctl: scsi: move ioctl handling into drivers Message-ID: <20191212052500-mutt-send-email-mst@kernel.org> References: <20191211204306.1207817-1-arnd@arndb.de> <20191211204306.1207817-16-arnd@arndb.de> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20191211204306.1207817-16-arnd@arndb.de> Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org On Wed, Dec 11, 2019 at 09:42:49PM +0100, Arnd Bergmann wrote: > Each driver calling scsi_ioctl() gets an equivalent compat_ioctl() > handler that implements the same commands by calling scsi_compat_ioctl(). > > The scsi_cmd_ioctl() and scsi_cmd_blk_ioctl() functions are compatible > at this point, so any driver that calls those can do so for both native > and compat mode, with the argument passed through compat_ptr(). > > With this, we can remove the entries from fs/compat_ioctl.c. The new > code is larger, but should be easier to maintain and keep updated with > newly added commands. > > Signed-off-by: Arnd Bergmann > --- > drivers/block/virtio_blk.c | 3 + > drivers/scsi/ch.c | 9 ++- > drivers/scsi/sd.c | 50 ++++++-------- > drivers/scsi/sg.c | 44 ++++++++----- > drivers/scsi/sr.c | 57 ++++++++++++++-- > drivers/scsi/st.c | 51 ++++++++------ > fs/compat_ioctl.c | 132 +------------------------------------ > 7 files changed, 142 insertions(+), 204 deletions(-) > > diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c > index 7ffd719d89de..fbbf18ac1d5d 100644 > --- a/drivers/block/virtio_blk.c > +++ b/drivers/block/virtio_blk.c > @@ -405,6 +405,9 @@ static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo) > > static const struct block_device_operations virtblk_fops = { > .ioctl = virtblk_ioctl, > +#ifdef CONFIG_COMPAT > + .compat_ioctl = blkdev_compat_ptr_ioctl, > +#endif > .owner = THIS_MODULE, > .getgeo = virtblk_getgeo, > }; virtio part: Acked-by: Michael S. Tsirkin > diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c > index 76751d6c7f0d..ed5f4a6ae270 100644 > --- a/drivers/scsi/ch.c > +++ b/drivers/scsi/ch.c > @@ -872,6 +872,10 @@ static long ch_ioctl_compat(struct file * file, > unsigned int cmd, unsigned long arg) > { > scsi_changer *ch = file->private_data; > + int retval = scsi_ioctl_block_when_processing_errors(ch->device, cmd, > + file->f_flags & O_NDELAY); > + if (retval) > + return retval; > > switch (cmd) { > case CHIOGPARAMS: > @@ -883,7 +887,7 @@ static long ch_ioctl_compat(struct file * file, > case CHIOINITELEM: > case CHIOSVOLTAG: > /* compatible */ > - return ch_ioctl(file, cmd, arg); > + return ch_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); > case CHIOGSTATUS32: > { > struct changer_element_status32 ces32; > @@ -898,8 +902,7 @@ static long ch_ioctl_compat(struct file * file, > return ch_gstatus(ch, ces32.ces_type, data); > } > default: > - // return scsi_ioctl_compat(ch->device, cmd, (void*)arg); > - return -ENOIOCTLCMD; > + return scsi_compat_ioctl(ch->device, cmd, compat_ptr(arg)); > > } > } > diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c > index cea625906440..5afb0046b12a 100644 > --- a/drivers/scsi/sd.c > +++ b/drivers/scsi/sd.c > @@ -1465,13 +1465,12 @@ static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo) > * Note: most ioctls are forward onto the block subsystem or further > * down in the scsi subsystem. > **/ > -static int sd_ioctl(struct block_device *bdev, fmode_t mode, > - unsigned int cmd, unsigned long arg) > +static int sd_ioctl_common(struct block_device *bdev, fmode_t mode, > + unsigned int cmd, void __user *p) > { > struct gendisk *disk = bdev->bd_disk; > struct scsi_disk *sdkp = scsi_disk(disk); > struct scsi_device *sdp = sdkp->device; > - void __user *p = (void __user *)arg; > int error; > > SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, " > @@ -1507,9 +1506,6 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode, > break; > default: > error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p); > - if (error != -ENOTTY) > - break; > - error = scsi_ioctl(sdp, cmd, p); > break; > } > out: > @@ -1691,39 +1687,31 @@ static void sd_rescan(struct device *dev) > revalidate_disk(sdkp->disk); > } > > +static int sd_ioctl(struct block_device *bdev, fmode_t mode, > + unsigned int cmd, unsigned long arg) > +{ > + void __user *p = (void __user *)arg; > + int ret; > + > + ret = sd_ioctl_common(bdev, mode, cmd, p); > + if (ret != -ENOTTY) > + return ret; > + > + return scsi_ioctl(scsi_disk(bdev->bd_disk)->device, cmd, p); > +} > > #ifdef CONFIG_COMPAT > -/* > - * This gets directly called from VFS. When the ioctl > - * is not recognized we go back to the other translation paths. > - */ > static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode, > unsigned int cmd, unsigned long arg) > { > - struct gendisk *disk = bdev->bd_disk; > - struct scsi_disk *sdkp = scsi_disk(disk); > - struct scsi_device *sdev = sdkp->device; > void __user *p = compat_ptr(arg); > - int error; > - > - error = scsi_verify_blk_ioctl(bdev, cmd); > - if (error < 0) > - return error; > + int ret; > > - error = scsi_ioctl_block_when_processing_errors(sdev, cmd, > - (mode & FMODE_NDELAY) != 0); > - if (error) > - return error; > + ret = sd_ioctl_common(bdev, mode, cmd, p); > + if (ret != -ENOTTY) > + return ret; > > - if (is_sed_ioctl(cmd)) > - return sed_ioctl(sdkp->opal_dev, cmd, p); > - > - /* > - * Let the static ioctl translation table take care of it. > - */ > - if (!sdev->host->hostt->compat_ioctl) > - return -ENOIOCTLCMD; > - return sdev->host->hostt->compat_ioctl(sdev, cmd, p); > + return scsi_compat_ioctl(scsi_disk(bdev->bd_disk)->device, cmd, p); > } > #endif > > diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c > index 985546aac236..08efcee7a34d 100644 > --- a/drivers/scsi/sg.c > +++ b/drivers/scsi/sg.c > @@ -910,19 +910,14 @@ static int put_compat_request_table(struct compat_sg_req_info __user *o, > #endif > > static long > -sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) > +sg_ioctl_common(struct file *filp, Sg_device *sdp, Sg_fd *sfp, > + unsigned int cmd_in, void __user *p) > { > - void __user *p = (void __user *)arg; > int __user *ip = p; > int result, val, read_only; > - Sg_device *sdp; > - Sg_fd *sfp; > Sg_request *srp; > unsigned long iflags; > > - if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) > - return -ENXIO; > - > SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp, > "sg_ioctl: cmd=0x%x\n", (int) cmd_in)); > read_only = (O_RDWR != (filp->f_flags & O_ACCMODE)); > @@ -1145,29 +1140,44 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) > cmd_in, filp->f_flags & O_NDELAY); > if (result) > return result; > + > + return -ENOIOCTLCMD; > +} > + > +static long > +sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) > +{ > + void __user *p = (void __user *)arg; > + Sg_device *sdp; > + Sg_fd *sfp; > + int ret; > + > + if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) > + return -ENXIO; > + > + ret = sg_ioctl_common(filp, sdp, sfp, cmd_in, p); > + if (ret != -ENOIOCTLCMD) > + return ret; > + > return scsi_ioctl(sdp->device, cmd_in, p); > } > > #ifdef CONFIG_COMPAT > static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg) > { > + void __user *p = compat_ptr(arg); > Sg_device *sdp; > Sg_fd *sfp; > - struct scsi_device *sdev; > + int ret; > > if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) > return -ENXIO; > > - sdev = sdp->device; > - if (sdev->host->hostt->compat_ioctl) { > - int ret; > - > - ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg); > - > + ret = sg_ioctl_common(filp, sdp, sfp, cmd_in, p); > + if (ret != -ENOIOCTLCMD) > return ret; > - } > - > - return -ENOIOCTLCMD; > + > + return scsi_compat_ioctl(sdp->device, cmd_in, p); > } > #endif > > diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c > index 4664fdf75c0f..6033a886c42c 100644 > --- a/drivers/scsi/sr.c > +++ b/drivers/scsi/sr.c > @@ -38,6 +38,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -598,6 +599,55 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd, > return ret; > } > > +#ifdef CONFIG_COMPAT > +static int sr_block_compat_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd, > + unsigned long arg) > +{ > + struct scsi_cd *cd = scsi_cd(bdev->bd_disk); > + struct scsi_device *sdev = cd->device; > + void __user *argp = compat_ptr(arg); > + int ret; > + > + mutex_lock(&sr_mutex); > + > + ret = scsi_ioctl_block_when_processing_errors(sdev, cmd, > + (mode & FMODE_NDELAY) != 0); > + if (ret) > + goto out; > + > + scsi_autopm_get_device(sdev); > + > + /* > + * Send SCSI addressing ioctls directly to mid level, send other > + * ioctls to cdrom/block level. > + */ > + switch (cmd) { > + case SCSI_IOCTL_GET_IDLUN: > + case SCSI_IOCTL_GET_BUS_NUMBER: > + ret = scsi_compat_ioctl(sdev, cmd, argp); > + goto put; > + } > + > + /* > + * CDROM ioctls are handled in the block layer, but > + * do the scsi blk ioctls here. > + */ > + ret = scsi_cmd_blk_ioctl(bdev, mode, cmd, argp); > + if (ret != -ENOTTY) > + return ret; > + > + ret = scsi_compat_ioctl(sdev, cmd, argp); > + > +put: > + scsi_autopm_put_device(sdev); > + > +out: > + mutex_unlock(&sr_mutex); > + return ret; > + > +} > +#endif > + > static unsigned int sr_block_check_events(struct gendisk *disk, > unsigned int clearing) > { > @@ -641,12 +691,11 @@ static const struct block_device_operations sr_bdops = > .open = sr_block_open, > .release = sr_block_release, > .ioctl = sr_block_ioctl, > +#ifdef CONFIG_COMPAT > + .ioctl = sr_block_compat_ioctl, > +#endif > .check_events = sr_block_check_events, > .revalidate_disk = sr_block_revalidate_disk, > - /* > - * No compat_ioctl for now because sr_block_ioctl never > - * seems to pass arbitrary ioctls down to host drivers. > - */ > }; > > static int sr_open(struct cdrom_device_info *cdi, int purpose) > diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c > index 9e3fff2de83e..393f3019ccac 100644 > --- a/drivers/scsi/st.c > +++ b/drivers/scsi/st.c > @@ -3501,7 +3501,7 @@ static int partition_tape(struct scsi_tape *STp, int size) > > > /* The ioctl command */ > -static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) > +static long st_ioctl_common(struct file *file, unsigned int cmd_in, void __user *p) > { > int i, cmd_nr, cmd_type, bt; > int retval = 0; > @@ -3509,7 +3509,6 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) > struct scsi_tape *STp = file->private_data; > struct st_modedef *STm; > struct st_partstat *STps; > - void __user *p = (void __user *)arg; > > if (mutex_lock_interruptible(&STp->lock)) > return -ERESTARTSYS; > @@ -3824,9 +3823,19 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) > } > mutex_unlock(&STp->lock); > switch (cmd_in) { > + case SCSI_IOCTL_STOP_UNIT: > + /* unload */ > + retval = scsi_ioctl(STp->device, cmd_in, p); > + if (!retval) { > + STp->rew_at_close = 0; > + STp->ready = ST_NO_TAPE; > + } > + return retval; > + > case SCSI_IOCTL_GET_IDLUN: > case SCSI_IOCTL_GET_BUS_NUMBER: > break; > + > default: > if ((cmd_in == SG_IO || > cmd_in == SCSI_IOCTL_SEND_COMMAND || > @@ -3840,42 +3849,46 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) > return i; > break; > } > - retval = scsi_ioctl(STp->device, cmd_in, p); > - if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */ > - STp->rew_at_close = 0; > - STp->ready = ST_NO_TAPE; > - } > - return retval; > + return -ENOTTY; > > out: > mutex_unlock(&STp->lock); > return retval; > } > > +static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) > +{ > + void __user *p = (void __user *)arg; > + struct scsi_tape *STp = file->private_data; > + int ret; > + > + ret = st_ioctl_common(file, cmd_in, p); > + if (ret != -ENOTTY) > + return ret; > + > + return scsi_ioctl(STp->device, cmd_in, p); > +} > + > #ifdef CONFIG_COMPAT > static long st_compat_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg) > { > void __user *p = compat_ptr(arg); > struct scsi_tape *STp = file->private_data; > - struct scsi_device *sdev = STp->device; > - int ret = -ENOIOCTLCMD; > + int ret; > > /* argument conversion is handled using put_user_mtpos/put_user_mtget */ > switch (cmd_in) { > - case MTIOCTOP: > - return st_ioctl(file, MTIOCTOP, (unsigned long)p); > case MTIOCPOS32: > - return st_ioctl(file, MTIOCPOS, (unsigned long)p); > + return st_ioctl_common(file, MTIOCPOS, p); > case MTIOCGET32: > - return st_ioctl(file, MTIOCGET, (unsigned long)p); > + return st_ioctl_common(file, MTIOCGET, p); > } > > - if (sdev->host->hostt->compat_ioctl) { > + ret = st_ioctl_common(file, cmd_in, p); > + if (ret != -ENOTTY) > + return ret; > > - ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg); > - > - } > - return ret; > + return scsi_compat_ioctl(STp->device, cmd_in, p); > } > #endif > > diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c > index 358ea2ecf36b..ab4471f469e6 100644 > --- a/fs/compat_ioctl.c > +++ b/fs/compat_ioctl.c > @@ -36,109 +36,11 @@ > > #include "internal.h" > > -#ifdef CONFIG_BLOCK > -#include > -#include > -#include > -#include > -#include > -#endif > - > #include > #include > > #include > > - > -#include > - > -/* > - * simple reversible transform to make our table more evenly > - * distributed after sorting. > - */ > -#define XFORM(i) (((i) ^ ((i) << 27) ^ ((i) << 17)) & 0xffffffff) > - > -#define COMPATIBLE_IOCTL(cmd) XFORM((u32)cmd), > -static unsigned int ioctl_pointer[] = { > -#ifdef CONFIG_BLOCK > -/* Big S */ > -COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN) > -COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK) > -COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK) > -COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY) > -COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER) > -COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND) > -COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST) > -COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI) > -#endif > -#ifdef CONFIG_BLOCK > -/* SG stuff */ > -COMPATIBLE_IOCTL(SG_IO) > -COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE) > -COMPATIBLE_IOCTL(SG_SET_TIMEOUT) > -COMPATIBLE_IOCTL(SG_GET_TIMEOUT) > -COMPATIBLE_IOCTL(SG_EMULATED_HOST) > -COMPATIBLE_IOCTL(SG_GET_TRANSFORM) > -COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE) > -COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE) > -COMPATIBLE_IOCTL(SG_GET_SCSI_ID) > -COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA) > -COMPATIBLE_IOCTL(SG_GET_LOW_DMA) > -COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID) > -COMPATIBLE_IOCTL(SG_GET_PACK_ID) > -COMPATIBLE_IOCTL(SG_GET_NUM_WAITING) > -COMPATIBLE_IOCTL(SG_SET_DEBUG) > -COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE) > -COMPATIBLE_IOCTL(SG_GET_COMMAND_Q) > -COMPATIBLE_IOCTL(SG_SET_COMMAND_Q) > -COMPATIBLE_IOCTL(SG_GET_VERSION_NUM) > -COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN) > -COMPATIBLE_IOCTL(SG_SCSI_RESET) > -COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE) > -COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN) > -COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN) > -#endif > -}; > - > -/* > - * Convert common ioctl arguments based on their command number > - * > - * Please do not add any code in here. Instead, implement > - * a compat_ioctl operation in the place that handleѕ the > - * ioctl for the native case. > - */ > -static long do_ioctl_trans(unsigned int cmd, > - unsigned long arg, struct file *file) > -{ > - return -ENOIOCTLCMD; > -} > - > -static int compat_ioctl_check_table(unsigned int xcmd) > -{ > -#ifdef CONFIG_BLOCK > - int i; > - const int max = ARRAY_SIZE(ioctl_pointer) - 1; > - > - BUILD_BUG_ON(max >= (1 << 16)); > - > - /* guess initial offset into table, assuming a > - normalized distribution */ > - i = ((xcmd >> 16) * max) >> 16; > - > - /* do linear search up first, until greater or equal */ > - while (ioctl_pointer[i] < xcmd && i < max) > - i++; > - > - /* then do linear search down */ > - while (ioctl_pointer[i] > xcmd && i > 0) > - i--; > - > - return ioctl_pointer[i] == xcmd; > -#else > - return 0; > -#endif > -} > - > COMPAT_SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, > compat_ulong_t, arg32) > { > @@ -216,19 +118,9 @@ COMPAT_SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, > goto out_fput; > } > > - if (!f.file->f_op->unlocked_ioctl) > - goto do_ioctl; > - break; > - } > - > - if (compat_ioctl_check_table(XFORM(cmd))) > - goto found_handler; > - > - error = do_ioctl_trans(cmd, arg, f.file); > - if (error == -ENOIOCTLCMD) > error = -ENOTTY; > - > - goto out_fput; > + goto out_fput; > + } > > found_handler: > arg = (unsigned long)compat_ptr(arg); > @@ -239,23 +131,3 @@ COMPAT_SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, > out: > return error; > } > - > -static int __init init_sys32_ioctl_cmp(const void *p, const void *q) > -{ > - unsigned int a, b; > - a = *(unsigned int *)p; > - b = *(unsigned int *)q; > - if (a > b) > - return 1; > - if (a < b) > - return -1; > - return 0; > -} > - > -static int __init init_sys32_ioctl(void) > -{ > - sort(ioctl_pointer, ARRAY_SIZE(ioctl_pointer), sizeof(*ioctl_pointer), > - init_sys32_ioctl_cmp, NULL); > - return 0; > -} > -__initcall(init_sys32_ioctl); > -- > 2.20.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: Re: [PATCH 15/24] compat_ioctl: scsi: move ioctl handling into drivers Date: Thu, 12 Dec 2019 05:25:12 -0500 Message-ID: <20191212052500-mutt-send-email-mst@kernel.org> References: <20191211204306.1207817-1-arnd@arndb.de> <20191211204306.1207817-16-arnd@arndb.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191211204306.1207817-16-arnd@arndb.de> Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" To: Arnd Bergmann Cc: Jens Axboe , Hannes Reinecke , Bart Van Assche , "Martin K. Petersen" , y2038@lists.linaro.org, Damien Le Moal , "James E.J. Bottomley" , John Garry , linux-kernel@vger.kernel.org, Kai =?iso-8859-1?Q?M=E4kisara?= , linux-block@vger.kernel.org, Alexander Viro , Stefan Hajnoczi , Doug Gilbert , linux-fsdevel@vger.kernel.org, Paolo Bonzini , virtualization@lists.linux-foundation.org, linux-scsi@vger.kernel.org List-Id: virtualization@lists.linuxfoundation.org T24gV2VkLCBEZWMgMTEsIDIwMTkgYXQgMDk6NDI6NDlQTSArMDEwMCwgQXJuZCBCZXJnbWFubiB3 cm90ZToKPiBFYWNoIGRyaXZlciBjYWxsaW5nIHNjc2lfaW9jdGwoKSBnZXRzIGFuIGVxdWl2YWxl bnQgY29tcGF0X2lvY3RsKCkKPiBoYW5kbGVyIHRoYXQgaW1wbGVtZW50cyB0aGUgc2FtZSBjb21t YW5kcyBieSBjYWxsaW5nIHNjc2lfY29tcGF0X2lvY3RsKCkuCj4gCj4gVGhlIHNjc2lfY21kX2lv Y3RsKCkgYW5kIHNjc2lfY21kX2Jsa19pb2N0bCgpIGZ1bmN0aW9ucyBhcmUgY29tcGF0aWJsZQo+ IGF0IHRoaXMgcG9pbnQsIHNvIGFueSBkcml2ZXIgdGhhdCBjYWxscyB0aG9zZSBjYW4gZG8gc28g Zm9yIGJvdGggbmF0aXZlCj4gYW5kIGNvbXBhdCBtb2RlLCB3aXRoIHRoZSBhcmd1bWVudCBwYXNz ZWQgdGhyb3VnaCBjb21wYXRfcHRyKCkuCj4gCj4gV2l0aCB0aGlzLCB3ZSBjYW4gcmVtb3ZlIHRo ZSBlbnRyaWVzIGZyb20gZnMvY29tcGF0X2lvY3RsLmMuICBUaGUgbmV3Cj4gY29kZSBpcyBsYXJn ZXIsIGJ1dCBzaG91bGQgYmUgZWFzaWVyIHRvIG1haW50YWluIGFuZCBrZWVwIHVwZGF0ZWQgd2l0 aAo+IG5ld2x5IGFkZGVkIGNvbW1hbmRzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEFybmQgQmVyZ21h bm4gPGFybmRAYXJuZGIuZGU+Cj4gLS0tCj4gIGRyaXZlcnMvYmxvY2svdmlydGlvX2Jsay5jIHwg ICAzICsKPiAgZHJpdmVycy9zY3NpL2NoLmMgICAgICAgICAgfCAgIDkgKystCj4gIGRyaXZlcnMv c2NzaS9zZC5jICAgICAgICAgIHwgIDUwICsrKysrKy0tLS0tLS0tCj4gIGRyaXZlcnMvc2NzaS9z Zy5jICAgICAgICAgIHwgIDQ0ICsrKysrKysrLS0tLS0KPiAgZHJpdmVycy9zY3NpL3NyLmMgICAg ICAgICAgfCAgNTcgKysrKysrKysrKysrKystLQo+ICBkcml2ZXJzL3Njc2kvc3QuYyAgICAgICAg ICB8ICA1MSArKysrKysrKy0tLS0tLQo+ICBmcy9jb21wYXRfaW9jdGwuYyAgICAgICAgICB8IDEz MiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gIDcgZmlsZXMgY2hhbmdl ZCwgMTQyIGluc2VydGlvbnMoKyksIDIwNCBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMgYi9kcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYwo+ IGluZGV4IDdmZmQ3MTlkODlkZS4uZmJiZjE4YWMxZDVkIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv YmxvY2svdmlydGlvX2Jsay5jCj4gKysrIGIvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKPiBA QCAtNDA1LDYgKzQwNSw5IEBAIHN0YXRpYyBpbnQgdmlydGJsa19nZXRnZW8oc3RydWN0IGJsb2Nr X2RldmljZSAqYmQsIHN0cnVjdCBoZF9nZW9tZXRyeSAqZ2VvKQo+ICAKPiAgc3RhdGljIGNvbnN0 IHN0cnVjdCBibG9ja19kZXZpY2Vfb3BlcmF0aW9ucyB2aXJ0YmxrX2ZvcHMgPSB7Cj4gIAkuaW9j dGwgID0gdmlydGJsa19pb2N0bCwKPiArI2lmZGVmIENPTkZJR19DT01QQVQKPiArCS5jb21wYXRf aW9jdGwgPSBibGtkZXZfY29tcGF0X3B0cl9pb2N0bCwKPiArI2VuZGlmCj4gIAkub3duZXIgID0g VEhJU19NT0RVTEUsCj4gIAkuZ2V0Z2VvID0gdmlydGJsa19nZXRnZW8sCj4gIH07CgoKdmlydGlv IHBhcnQ6CgpBY2tlZC1ieTogTWljaGFlbCBTLiBUc2lya2luIDxtc3RAcmVkaGF0LmNvbT4KCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9jaC5jIGIvZHJpdmVycy9zY3NpL2NoLmMKPiBpbmRl eCA3Njc1MWQ2YzdmMGQuLmVkNWY0YTZhZTI3MCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3Njc2kv Y2guYwo+ICsrKyBiL2RyaXZlcnMvc2NzaS9jaC5jCj4gQEAgLTg3Miw2ICs4NzIsMTAgQEAgc3Rh dGljIGxvbmcgY2hfaW9jdGxfY29tcGF0KHN0cnVjdCBmaWxlICogZmlsZSwKPiAgCQkJICAgIHVu c2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQo+ICB7Cj4gIAlzY3NpX2NoYW5nZXIg KmNoID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICsJaW50IHJldHZhbCA9IHNjc2lfaW9jdGxfYmxv Y2tfd2hlbl9wcm9jZXNzaW5nX2Vycm9ycyhjaC0+ZGV2aWNlLCBjbWQsCj4gKwkJCQkJCQlmaWxl LT5mX2ZsYWdzICYgT19OREVMQVkpOwo+ICsJaWYgKHJldHZhbCkKPiArCQlyZXR1cm4gcmV0dmFs Owo+ICAKPiAgCXN3aXRjaCAoY21kKSB7Cj4gIAljYXNlIENISU9HUEFSQU1TOgo+IEBAIC04ODMs NyArODg3LDcgQEAgc3RhdGljIGxvbmcgY2hfaW9jdGxfY29tcGF0KHN0cnVjdCBmaWxlICogZmls ZSwKPiAgCWNhc2UgQ0hJT0lOSVRFTEVNOgo+ICAJY2FzZSBDSElPU1ZPTFRBRzoKPiAgCQkvKiBj b21wYXRpYmxlICovCj4gLQkJcmV0dXJuIGNoX2lvY3RsKGZpbGUsIGNtZCwgYXJnKTsKPiArCQly ZXR1cm4gY2hfaW9jdGwoZmlsZSwgY21kLCAodW5zaWduZWQgbG9uZyljb21wYXRfcHRyKGFyZykp Owo+ICAJY2FzZSBDSElPR1NUQVRVUzMyOgo+ICAJewo+ICAJCXN0cnVjdCBjaGFuZ2VyX2VsZW1l bnRfc3RhdHVzMzIgY2VzMzI7Cj4gQEAgLTg5OCw4ICs5MDIsNyBAQCBzdGF0aWMgbG9uZyBjaF9p b2N0bF9jb21wYXQoc3RydWN0IGZpbGUgKiBmaWxlLAo+ICAJCXJldHVybiBjaF9nc3RhdHVzKGNo LCBjZXMzMi5jZXNfdHlwZSwgZGF0YSk7Cj4gIAl9Cj4gIAlkZWZhdWx0Ogo+IC0JCS8vIHJldHVy biBzY3NpX2lvY3RsX2NvbXBhdChjaC0+ZGV2aWNlLCBjbWQsICh2b2lkKilhcmcpOwo+IC0JCXJl dHVybiAtRU5PSU9DVExDTUQ7Cj4gKwkJcmV0dXJuIHNjc2lfY29tcGF0X2lvY3RsKGNoLT5kZXZp Y2UsIGNtZCwgY29tcGF0X3B0cihhcmcpKTsKPiAgCj4gIAl9Cj4gIH0KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9zY3NpL3NkLmMgYi9kcml2ZXJzL3Njc2kvc2QuYwo+IGluZGV4IGNlYTYyNTkwNjQ0 MC4uNWFmYjAwNDZiMTJhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvc2NzaS9zZC5jCj4gKysrIGIv ZHJpdmVycy9zY3NpL3NkLmMKPiBAQCAtMTQ2NSwxMyArMTQ2NSwxMiBAQCBzdGF0aWMgaW50IHNk X2dldGdlbyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBzdHJ1Y3QgaGRfZ2VvbWV0cnkgKmdl bykKPiAgICoJTm90ZTogbW9zdCBpb2N0bHMgYXJlIGZvcndhcmQgb250byB0aGUgYmxvY2sgc3Vi c3lzdGVtIG9yIGZ1cnRoZXIKPiAgICoJZG93biBpbiB0aGUgc2NzaSBzdWJzeXN0ZW0uCj4gICAq Ki8KPiAtc3RhdGljIGludCBzZF9pb2N0bChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBmbW9k ZV90IG1vZGUsCj4gLQkJICAgIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQo+ ICtzdGF0aWMgaW50IHNkX2lvY3RsX2NvbW1vbihzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBm bW9kZV90IG1vZGUsCj4gKwkJCSAgIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgX191c2VyICpwKQo+ ICB7Cj4gIAlzdHJ1Y3QgZ2VuZGlzayAqZGlzayA9IGJkZXYtPmJkX2Rpc2s7Cj4gIAlzdHJ1Y3Qg c2NzaV9kaXNrICpzZGtwID0gc2NzaV9kaXNrKGRpc2spOwo+ICAJc3RydWN0IHNjc2lfZGV2aWNl ICpzZHAgPSBzZGtwLT5kZXZpY2U7Cj4gLQl2b2lkIF9fdXNlciAqcCA9ICh2b2lkIF9fdXNlciAq KWFyZzsKPiAgCWludCBlcnJvcjsKPiAgICAgIAo+ICAJU0NTSV9MT0dfSU9DVEwoMSwgc2RfcHJp bnRrKEtFUk5fSU5GTywgc2RrcCwgInNkX2lvY3RsOiBkaXNrPSVzLCAiCj4gQEAgLTE1MDcsOSAr MTUwNiw2IEBAIHN0YXRpYyBpbnQgc2RfaW9jdGwoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwg Zm1vZGVfdCBtb2RlLAo+ICAJCQlicmVhazsKPiAgCQlkZWZhdWx0Ogo+ICAJCQllcnJvciA9IHNj c2lfY21kX2Jsa19pb2N0bChiZGV2LCBtb2RlLCBjbWQsIHApOwo+IC0JCQlpZiAoZXJyb3IgIT0g LUVOT1RUWSkKPiAtCQkJCWJyZWFrOwo+IC0JCQllcnJvciA9IHNjc2lfaW9jdGwoc2RwLCBjbWQs IHApOwo+ICAJCQlicmVhazsKPiAgCX0KPiAgb3V0Ogo+IEBAIC0xNjkxLDM5ICsxNjg3LDMxIEBA IHN0YXRpYyB2b2lkIHNkX3Jlc2NhbihzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gIAlyZXZhbGlkYXRl X2Rpc2soc2RrcC0+ZGlzayk7Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbnQgc2RfaW9jdGwoc3RydWN0 IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLAo+ICsJCSAgICB1bnNpZ25lZCBpbnQg Y21kLCB1bnNpZ25lZCBsb25nIGFyZykKPiArewo+ICsJdm9pZCBfX3VzZXIgKnAgPSAodm9pZCBf X3VzZXIgKilhcmc7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IHNkX2lvY3RsX2NvbW1vbihi ZGV2LCBtb2RlLCBjbWQsIHApOwo+ICsJaWYgKHJldCAhPSAtRU5PVFRZKQo+ICsJCXJldHVybiBy ZXQ7Cj4gKwo+ICsJcmV0dXJuIHNjc2lfaW9jdGwoc2NzaV9kaXNrKGJkZXYtPmJkX2Rpc2spLT5k ZXZpY2UsIGNtZCwgcCk7Cj4gK30KPiAgCj4gICNpZmRlZiBDT05GSUdfQ09NUEFUCj4gLS8qIAo+ IC0gKiBUaGlzIGdldHMgZGlyZWN0bHkgY2FsbGVkIGZyb20gVkZTLiBXaGVuIHRoZSBpb2N0bCAK PiAtICogaXMgbm90IHJlY29nbml6ZWQgd2UgZ28gYmFjayB0byB0aGUgb3RoZXIgdHJhbnNsYXRp b24gcGF0aHMuIAo+IC0gKi8KPiAgc3RhdGljIGludCBzZF9jb21wYXRfaW9jdGwoc3RydWN0IGJs b2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLAo+ICAJCQkgICB1bnNpZ25lZCBpbnQgY21k LCB1bnNpZ25lZCBsb25nIGFyZykKPiAgewo+IC0Jc3RydWN0IGdlbmRpc2sgKmRpc2sgPSBiZGV2 LT5iZF9kaXNrOwo+IC0Jc3RydWN0IHNjc2lfZGlzayAqc2RrcCA9IHNjc2lfZGlzayhkaXNrKTsK PiAtCXN0cnVjdCBzY3NpX2RldmljZSAqc2RldiA9IHNka3AtPmRldmljZTsKPiAgCXZvaWQgX191 c2VyICpwID0gY29tcGF0X3B0cihhcmcpOwo+IC0JaW50IGVycm9yOwo+IC0KPiAtCWVycm9yID0g c2NzaV92ZXJpZnlfYmxrX2lvY3RsKGJkZXYsIGNtZCk7Cj4gLQlpZiAoZXJyb3IgPCAwKQo+IC0J CXJldHVybiBlcnJvcjsKPiArCWludCByZXQ7Cj4gIAo+IC0JZXJyb3IgPSBzY3NpX2lvY3RsX2Js b2NrX3doZW5fcHJvY2Vzc2luZ19lcnJvcnMoc2RldiwgY21kLAo+IC0JCQkobW9kZSAmIEZNT0RF X05ERUxBWSkgIT0gMCk7Cj4gLQlpZiAoZXJyb3IpCj4gLQkJcmV0dXJuIGVycm9yOwo+ICsJcmV0 ID0gc2RfaW9jdGxfY29tbW9uKGJkZXYsIG1vZGUsIGNtZCwgcCk7Cj4gKwlpZiAocmV0ICE9IC1F Tk9UVFkpCj4gKwkJcmV0dXJuIHJldDsKPiAgCj4gLQlpZiAoaXNfc2VkX2lvY3RsKGNtZCkpCj4g LQkJcmV0dXJuIHNlZF9pb2N0bChzZGtwLT5vcGFsX2RldiwgY21kLCBwKTsKPiAtCSAgICAgICAK PiAtCS8qIAo+IC0JICogTGV0IHRoZSBzdGF0aWMgaW9jdGwgdHJhbnNsYXRpb24gdGFibGUgdGFr ZSBjYXJlIG9mIGl0Lgo+IC0JICovCj4gLQlpZiAoIXNkZXYtPmhvc3QtPmhvc3R0LT5jb21wYXRf aW9jdGwpCj4gLQkJcmV0dXJuIC1FTk9JT0NUTENNRDsgCj4gLQlyZXR1cm4gc2Rldi0+aG9zdC0+ aG9zdHQtPmNvbXBhdF9pb2N0bChzZGV2LCBjbWQsIHApOwo+ICsJcmV0dXJuIHNjc2lfY29tcGF0 X2lvY3RsKHNjc2lfZGlzayhiZGV2LT5iZF9kaXNrKS0+ZGV2aWNlLCBjbWQsIHApOwo+ICB9Cj4g ICNlbmRpZgo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NnLmMgYi9kcml2ZXJzL3Nj c2kvc2cuYwo+IGluZGV4IDk4NTU0NmFhYzIzNi4uMDhlZmNlZTdhMzRkIDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvc2NzaS9zZy5jCj4gKysrIGIvZHJpdmVycy9zY3NpL3NnLmMKPiBAQCAtOTEwLDE5 ICs5MTAsMTQgQEAgc3RhdGljIGludCBwdXRfY29tcGF0X3JlcXVlc3RfdGFibGUoc3RydWN0IGNv bXBhdF9zZ19yZXFfaW5mbyBfX3VzZXIgKm8sCj4gICNlbmRpZgo+ICAKPiAgc3RhdGljIGxvbmcK PiAtc2dfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWRfaW4sIHVuc2ln bmVkIGxvbmcgYXJnKQo+ICtzZ19pb2N0bF9jb21tb24oc3RydWN0IGZpbGUgKmZpbHAsIFNnX2Rl dmljZSAqc2RwLCBTZ19mZCAqc2ZwLAo+ICsJCXVuc2lnbmVkIGludCBjbWRfaW4sIHZvaWQgX191 c2VyICpwKQo+ICB7Cj4gLQl2b2lkIF9fdXNlciAqcCA9ICh2b2lkIF9fdXNlciAqKWFyZzsKPiAg CWludCBfX3VzZXIgKmlwID0gcDsKPiAgCWludCByZXN1bHQsIHZhbCwgcmVhZF9vbmx5Owo+IC0J U2dfZGV2aWNlICpzZHA7Cj4gLQlTZ19mZCAqc2ZwOwo+ICAJU2dfcmVxdWVzdCAqc3JwOwo+ICAJ dW5zaWduZWQgbG9uZyBpZmxhZ3M7Cj4gIAo+IC0JaWYgKCghKHNmcCA9IChTZ19mZCAqKSBmaWxw LT5wcml2YXRlX2RhdGEpKSB8fCAoIShzZHAgPSBzZnAtPnBhcmVudGRwKSkpCj4gLQkJcmV0dXJu IC1FTlhJTzsKPiAtCj4gIAlTQ1NJX0xPR19USU1FT1VUKDMsIHNnX3ByaW50ayhLRVJOX0lORk8s IHNkcCwKPiAgCQkJCSAgICJzZ19pb2N0bDogY21kPTB4JXhcbiIsIChpbnQpIGNtZF9pbikpOwo+ ICAJcmVhZF9vbmx5ID0gKE9fUkRXUiAhPSAoZmlscC0+Zl9mbGFncyAmIE9fQUNDTU9ERSkpOwo+ IEBAIC0xMTQ1LDI5ICsxMTQwLDQ0IEBAIHNnX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNp Z25lZCBpbnQgY21kX2luLCB1bnNpZ25lZCBsb25nIGFyZykKPiAgCQkJY21kX2luLCBmaWxwLT5m X2ZsYWdzICYgT19OREVMQVkpOwo+ICAJaWYgKHJlc3VsdCkKPiAgCQlyZXR1cm4gcmVzdWx0Owo+ ICsKPiArCXJldHVybiAtRU5PSU9DVExDTUQ7Cj4gK30KPiArCj4gK3N0YXRpYyBsb25nCj4gK3Nn X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kX2luLCB1bnNpZ25lZCBs b25nIGFyZykKPiArewo+ICsJdm9pZCBfX3VzZXIgKnAgPSAodm9pZCBfX3VzZXIgKilhcmc7Cj4g KwlTZ19kZXZpY2UgKnNkcDsKPiArCVNnX2ZkICpzZnA7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlm ICgoIShzZnAgPSAoU2dfZmQgKikgZmlscC0+cHJpdmF0ZV9kYXRhKSkgfHwgKCEoc2RwID0gc2Zw LT5wYXJlbnRkcCkpKQo+ICsJCXJldHVybiAtRU5YSU87Cj4gKwo+ICsJcmV0ID0gc2dfaW9jdGxf Y29tbW9uKGZpbHAsIHNkcCwgc2ZwLCBjbWRfaW4sIHApOwo+ICsJaWYgKHJldCAhPSAtRU5PSU9D VExDTUQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gIAlyZXR1cm4gc2NzaV9pb2N0bChzZHAtPmRl dmljZSwgY21kX2luLCBwKTsKPiAgfQo+ICAKPiAgI2lmZGVmIENPTkZJR19DT01QQVQKPiAgc3Rh dGljIGxvbmcgc2dfY29tcGF0X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQg Y21kX2luLCB1bnNpZ25lZCBsb25nIGFyZykKPiAgewo+ICsJdm9pZCBfX3VzZXIgKnAgPSBjb21w YXRfcHRyKGFyZyk7Cj4gIAlTZ19kZXZpY2UgKnNkcDsKPiAgCVNnX2ZkICpzZnA7Cj4gLQlzdHJ1 Y3Qgc2NzaV9kZXZpY2UgKnNkZXY7Cj4gKwlpbnQgcmV0Owo+ICAKPiAgCWlmICgoIShzZnAgPSAo U2dfZmQgKikgZmlscC0+cHJpdmF0ZV9kYXRhKSkgfHwgKCEoc2RwID0gc2ZwLT5wYXJlbnRkcCkp KQo+ICAJCXJldHVybiAtRU5YSU87Cj4gIAo+IC0Jc2RldiA9IHNkcC0+ZGV2aWNlOwo+IC0JaWYg KHNkZXYtPmhvc3QtPmhvc3R0LT5jb21wYXRfaW9jdGwpIHsgCj4gLQkJaW50IHJldDsKPiAtCj4g LQkJcmV0ID0gc2Rldi0+aG9zdC0+aG9zdHQtPmNvbXBhdF9pb2N0bChzZGV2LCBjbWRfaW4sICh2 b2lkIF9fdXNlciAqKWFyZyk7Cj4gLQo+ICsJcmV0ID0gc2dfaW9jdGxfY29tbW9uKGZpbHAsIHNk cCwgc2ZwLCBjbWRfaW4sIHApOwo+ICsJaWYgKHJldCAhPSAtRU5PSU9DVExDTUQpCj4gIAkJcmV0 dXJuIHJldDsKPiAtCX0KPiAtCQo+IC0JcmV0dXJuIC1FTk9JT0NUTENNRDsKPiArCj4gKwlyZXR1 cm4gc2NzaV9jb21wYXRfaW9jdGwoc2RwLT5kZXZpY2UsIGNtZF9pbiwgcCk7Cj4gIH0KPiAgI2Vu ZGlmCj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc3IuYyBiL2RyaXZlcnMvc2NzaS9z ci5jCj4gaW5kZXggNDY2NGZkZjc1YzBmLi42MDMzYTg4NmM0MmMgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9zY3NpL3NyLmMKPiArKysgYi9kcml2ZXJzL3Njc2kvc3IuYwo+IEBAIC0zOCw2ICszOCw3 IEBACj4gICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L21tLmg+ Cj4gICNpbmNsdWRlIDxsaW51eC9iaW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2NvbXBhdC5oPgo+ ICAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgo+ ICAjaW5jbHVkZSA8bGludXgvY2Ryb20uaD4KPiBAQCAtNTk4LDYgKzU5OSw1NSBAQCBzdGF0aWMg aW50IHNyX2Jsb2NrX2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2RlX3QgbW9k ZSwgdW5zaWduZWQgY21kLAo+ICAJcmV0dXJuIHJldDsKPiAgfQo+ICAKPiArI2lmZGVmIENPTkZJ R19DT01QQVQKPiArc3RhdGljIGludCBzcl9ibG9ja19jb21wYXRfaW9jdGwoc3RydWN0IGJsb2Nr X2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlLCB1bnNpZ25lZCBjbWQsCj4gKwkJCSAgdW5zaWdu ZWQgbG9uZyBhcmcpCj4gK3sKPiArCXN0cnVjdCBzY3NpX2NkICpjZCA9IHNjc2lfY2QoYmRldi0+ YmRfZGlzayk7Cj4gKwlzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYgPSBjZC0+ZGV2aWNlOwo+ICsJ dm9pZCBfX3VzZXIgKmFyZ3AgPSBjb21wYXRfcHRyKGFyZyk7Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CW11dGV4X2xvY2soJnNyX211dGV4KTsKPiArCj4gKwlyZXQgPSBzY3NpX2lvY3RsX2Jsb2NrX3do ZW5fcHJvY2Vzc2luZ19lcnJvcnMoc2RldiwgY21kLAo+ICsJCQkobW9kZSAmIEZNT0RFX05ERUxB WSkgIT0gMCk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gb3V0Owo+ICsKPiArCXNjc2lfYXV0b3Bt X2dldF9kZXZpY2Uoc2Rldik7Cj4gKwo+ICsJLyoKPiArCSAqIFNlbmQgU0NTSSBhZGRyZXNzaW5n IGlvY3RscyBkaXJlY3RseSB0byBtaWQgbGV2ZWwsIHNlbmQgb3RoZXIKPiArCSAqIGlvY3RscyB0 byBjZHJvbS9ibG9jayBsZXZlbC4KPiArCSAqLwo+ICsJc3dpdGNoIChjbWQpIHsKPiArCWNhc2Ug U0NTSV9JT0NUTF9HRVRfSURMVU46Cj4gKwljYXNlIFNDU0lfSU9DVExfR0VUX0JVU19OVU1CRVI6 Cj4gKwkJcmV0ID0gc2NzaV9jb21wYXRfaW9jdGwoc2RldiwgY21kLCBhcmdwKTsKPiArCQlnb3Rv IHB1dDsKPiArCX0KPiArCj4gKwkvKgo+ICsJICogQ0RST00gaW9jdGxzIGFyZSBoYW5kbGVkIGlu IHRoZSBibG9jayBsYXllciwgYnV0Cj4gKwkgKiBkbyB0aGUgc2NzaSBibGsgaW9jdGxzIGhlcmUu Cj4gKwkgKi8KPiArCXJldCA9IHNjc2lfY21kX2Jsa19pb2N0bChiZGV2LCBtb2RlLCBjbWQsIGFy Z3ApOwo+ICsJaWYgKHJldCAhPSAtRU5PVFRZKQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0 ID0gc2NzaV9jb21wYXRfaW9jdGwoc2RldiwgY21kLCBhcmdwKTsKPiArCj4gK3B1dDoKPiArCXNj c2lfYXV0b3BtX3B1dF9kZXZpY2Uoc2Rldik7Cj4gKwo+ICtvdXQ6Cj4gKwltdXRleF91bmxvY2so JnNyX211dGV4KTsKPiArCXJldHVybiByZXQ7Cj4gKwo+ICt9Cj4gKyNlbmRpZgo+ICsKPiAgc3Rh dGljIHVuc2lnbmVkIGludCBzcl9ibG9ja19jaGVja19ldmVudHMoc3RydWN0IGdlbmRpc2sgKmRp c2ssCj4gIAkJCQkJICB1bnNpZ25lZCBpbnQgY2xlYXJpbmcpCj4gIHsKPiBAQCAtNjQxLDEyICs2 OTEsMTEgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZpY2Vfb3BlcmF0aW9ucyBzcl9i ZG9wcyA9Cj4gIAkub3BlbgkJPSBzcl9ibG9ja19vcGVuLAo+ICAJLnJlbGVhc2UJPSBzcl9ibG9j a19yZWxlYXNlLAo+ICAJLmlvY3RsCQk9IHNyX2Jsb2NrX2lvY3RsLAo+ICsjaWZkZWYgQ09ORklH X0NPTVBBVAo+ICsJLmlvY3RsCQk9IHNyX2Jsb2NrX2NvbXBhdF9pb2N0bCwKPiArI2VuZGlmCj4g IAkuY2hlY2tfZXZlbnRzCT0gc3JfYmxvY2tfY2hlY2tfZXZlbnRzLAo+ICAJLnJldmFsaWRhdGVf ZGlzayA9IHNyX2Jsb2NrX3JldmFsaWRhdGVfZGlzaywKPiAtCS8qIAo+IC0JICogTm8gY29tcGF0 X2lvY3RsIGZvciBub3cgYmVjYXVzZSBzcl9ibG9ja19pb2N0bCBuZXZlcgo+IC0JICogc2VlbXMg dG8gcGFzcyBhcmJpdHJhcnkgaW9jdGxzIGRvd24gdG8gaG9zdCBkcml2ZXJzLgo+IC0JICovCj4g IH07Cj4gIAo+ICBzdGF0aWMgaW50IHNyX29wZW4oc3RydWN0IGNkcm9tX2RldmljZV9pbmZvICpj ZGksIGludCBwdXJwb3NlKQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc3QuYyBiL2RyaXZl cnMvc2NzaS9zdC5jCj4gaW5kZXggOWUzZmZmMmRlODNlLi4zOTNmMzAxOWNjYWMgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9zY3NpL3N0LmMKPiArKysgYi9kcml2ZXJzL3Njc2kvc3QuYwo+IEBAIC0z NTAxLDcgKzM1MDEsNyBAQCBzdGF0aWMgaW50IHBhcnRpdGlvbl90YXBlKHN0cnVjdCBzY3NpX3Rh cGUgKlNUcCwgaW50IHNpemUpCj4gIAo+ICAKPiAgLyogVGhlIGlvY3RsIGNvbW1hbmQgKi8KPiAt c3RhdGljIGxvbmcgc3RfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWRf aW4sIHVuc2lnbmVkIGxvbmcgYXJnKQo+ICtzdGF0aWMgbG9uZyBzdF9pb2N0bF9jb21tb24oc3Ry dWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWRfaW4sIHZvaWQgX191c2VyICpwKQo+ICB7 Cj4gIAlpbnQgaSwgY21kX25yLCBjbWRfdHlwZSwgYnQ7Cj4gIAlpbnQgcmV0dmFsID0gMDsKPiBA QCAtMzUwOSw3ICszNTA5LDYgQEAgc3RhdGljIGxvbmcgc3RfaW9jdGwoc3RydWN0IGZpbGUgKmZp bGUsIHVuc2lnbmVkIGludCBjbWRfaW4sIHVuc2lnbmVkIGxvbmcgYXJnKQo+ICAJc3RydWN0IHNj c2lfdGFwZSAqU1RwID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwo+ICAJc3RydWN0IHN0X21vZGVkZWYg KlNUbTsKPiAgCXN0cnVjdCBzdF9wYXJ0c3RhdCAqU1RwczsKPiAtCXZvaWQgX191c2VyICpwID0g KHZvaWQgX191c2VyICopYXJnOwo+ICAKPiAgCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUo JlNUcC0+bG9jaykpCj4gIAkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKPiBAQCAtMzgyNCw5ICszODIz LDE5IEBAIHN0YXRpYyBsb25nIHN0X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBp bnQgY21kX2luLCB1bnNpZ25lZCBsb25nIGFyZykKPiAgCX0KPiAgCW11dGV4X3VubG9jaygmU1Rw LT5sb2NrKTsKPiAgCXN3aXRjaCAoY21kX2luKSB7Cj4gKwkJY2FzZSBTQ1NJX0lPQ1RMX1NUT1Bf VU5JVDoKPiArCQkJLyogdW5sb2FkICovCj4gKwkJCXJldHZhbCA9IHNjc2lfaW9jdGwoU1RwLT5k ZXZpY2UsIGNtZF9pbiwgcCk7Cj4gKwkJCWlmICghcmV0dmFsKSB7Cj4gKwkJCQlTVHAtPnJld19h dF9jbG9zZSA9IDA7Cj4gKwkJCQlTVHAtPnJlYWR5ID0gU1RfTk9fVEFQRTsKPiArCQkJfQo+ICsJ CQlyZXR1cm4gcmV0dmFsOwo+ICsKPiAgCQljYXNlIFNDU0lfSU9DVExfR0VUX0lETFVOOgo+ICAJ CWNhc2UgU0NTSV9JT0NUTF9HRVRfQlVTX05VTUJFUjoKPiAgCQkJYnJlYWs7Cj4gKwo+ICAJCWRl ZmF1bHQ6Cj4gIAkJCWlmICgoY21kX2luID09IFNHX0lPIHx8Cj4gIAkJCSAgICAgY21kX2luID09 IFNDU0lfSU9DVExfU0VORF9DT01NQU5EIHx8Cj4gQEAgLTM4NDAsNDIgKzM4NDksNDYgQEAgc3Rh dGljIGxvbmcgc3RfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWRfaW4s IHVuc2lnbmVkIGxvbmcgYXJnKQo+ICAJCQkJcmV0dXJuIGk7Cj4gIAkJCWJyZWFrOwo+ICAJfQo+ IC0JcmV0dmFsID0gc2NzaV9pb2N0bChTVHAtPmRldmljZSwgY21kX2luLCBwKTsKPiAtCWlmICgh cmV0dmFsICYmIGNtZF9pbiA9PSBTQ1NJX0lPQ1RMX1NUT1BfVU5JVCkgeyAvKiB1bmxvYWQgKi8K PiAtCQlTVHAtPnJld19hdF9jbG9zZSA9IDA7Cj4gLQkJU1RwLT5yZWFkeSA9IFNUX05PX1RBUEU7 Cj4gLQl9Cj4gLQlyZXR1cm4gcmV0dmFsOwo+ICsJcmV0dXJuIC1FTk9UVFk7Cj4gIAo+ICAgb3V0 Ogo+ICAJbXV0ZXhfdW5sb2NrKCZTVHAtPmxvY2spOwo+ICAJcmV0dXJuIHJldHZhbDsKPiAgfQo+ ICAKPiArc3RhdGljIGxvbmcgc3RfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGlu dCBjbWRfaW4sIHVuc2lnbmVkIGxvbmcgYXJnKQo+ICt7Cj4gKwl2b2lkIF9fdXNlciAqcCA9ICh2 b2lkIF9fdXNlciAqKWFyZzsKPiArCXN0cnVjdCBzY3NpX3RhcGUgKlNUcCA9IGZpbGUtPnByaXZh dGVfZGF0YTsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gc3RfaW9jdGxfY29tbW9uKGZpbGUs IGNtZF9pbiwgcCk7Cj4gKwlpZiAocmV0ICE9IC1FTk9UVFkpCj4gKwkJcmV0dXJuIHJldDsKPiAr Cj4gKwlyZXR1cm4gc2NzaV9pb2N0bChTVHAtPmRldmljZSwgY21kX2luLCBwKTsKPiArfQo+ICsK PiAgI2lmZGVmIENPTkZJR19DT01QQVQKPiAgc3RhdGljIGxvbmcgc3RfY29tcGF0X2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kX2luLCB1bnNpZ25lZCBsb25nIGFyZykK PiAgewo+ICAJdm9pZCBfX3VzZXIgKnAgPSBjb21wYXRfcHRyKGFyZyk7Cj4gIAlzdHJ1Y3Qgc2Nz aV90YXBlICpTVHAgPSBmaWxlLT5wcml2YXRlX2RhdGE7Cj4gLQlzdHJ1Y3Qgc2NzaV9kZXZpY2Ug KnNkZXYgPSBTVHAtPmRldmljZTsKPiAtCWludCByZXQgPSAtRU5PSU9DVExDTUQ7Cj4gKwlpbnQg cmV0Owo+ICAKPiAgCS8qIGFyZ3VtZW50IGNvbnZlcnNpb24gaXMgaGFuZGxlZCB1c2luZyBwdXRf dXNlcl9tdHBvcy9wdXRfdXNlcl9tdGdldCAqLwo+ICAJc3dpdGNoIChjbWRfaW4pIHsKPiAtCWNh c2UgTVRJT0NUT1A6Cj4gLQkJcmV0dXJuIHN0X2lvY3RsKGZpbGUsIE1USU9DVE9QLCAodW5zaWdu ZWQgbG9uZylwKTsKPiAgCWNhc2UgTVRJT0NQT1MzMjoKPiAtCQlyZXR1cm4gc3RfaW9jdGwoZmls ZSwgTVRJT0NQT1MsICh1bnNpZ25lZCBsb25nKXApOwo+ICsJCXJldHVybiBzdF9pb2N0bF9jb21t b24oZmlsZSwgTVRJT0NQT1MsIHApOwo+ICAJY2FzZSBNVElPQ0dFVDMyOgo+IC0JCXJldHVybiBz dF9pb2N0bChmaWxlLCBNVElPQ0dFVCwgKHVuc2lnbmVkIGxvbmcpcCk7Cj4gKwkJcmV0dXJuIHN0 X2lvY3RsX2NvbW1vbihmaWxlLCBNVElPQ0dFVCwgcCk7Cj4gIAl9Cj4gIAo+IC0JaWYgKHNkZXYt Pmhvc3QtPmhvc3R0LT5jb21wYXRfaW9jdGwpIHsgCj4gKwlyZXQgPSBzdF9pb2N0bF9jb21tb24o ZmlsZSwgY21kX2luLCBwKTsKPiArCWlmIChyZXQgIT0gLUVOT1RUWSkKPiArCQlyZXR1cm4gcmV0 Owo+ICAKPiAtCQlyZXQgPSBzZGV2LT5ob3N0LT5ob3N0dC0+Y29tcGF0X2lvY3RsKHNkZXYsIGNt ZF9pbiwgKHZvaWQgX191c2VyICopYXJnKTsKPiAtCj4gLQl9Cj4gLQlyZXR1cm4gcmV0Owo+ICsJ cmV0dXJuIHNjc2lfY29tcGF0X2lvY3RsKFNUcC0+ZGV2aWNlLCBjbWRfaW4sIHApOwo+ICB9Cj4g ICNlbmRpZgo+ICAKPiBkaWZmIC0tZ2l0IGEvZnMvY29tcGF0X2lvY3RsLmMgYi9mcy9jb21wYXRf aW9jdGwuYwo+IGluZGV4IDM1OGVhMmVjZjM2Yi4uYWI0NDcxZjQ2OWU2IDEwMDY0NAo+IC0tLSBh L2ZzL2NvbXBhdF9pb2N0bC5jCj4gKysrIGIvZnMvY29tcGF0X2lvY3RsLmMKPiBAQCAtMzYsMTA5 ICszNiwxMSBAQAo+ICAKPiAgI2luY2x1ZGUgImludGVybmFsLmgiCj4gIAo+IC0jaWZkZWYgQ09O RklHX0JMT0NLCj4gLSNpbmNsdWRlIDxsaW51eC9jZHJvbS5oPgo+IC0jaW5jbHVkZSA8bGludXgv ZmQuaD4KPiAtI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgo+IC0jaW5jbHVkZSA8c2NzaS9zY3NpX2lv Y3RsLmg+Cj4gLSNpbmNsdWRlIDxzY3NpL3NnLmg+Cj4gLSNlbmRpZgo+IC0KPiAgI2luY2x1ZGUg PGxpbnV4L3VhY2Nlc3MuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3dhdGNoZG9nLmg+Cj4gIAo+ICAj aW5jbHVkZSA8bGludXgvaGlkZGV2Lmg+Cj4gIAo+IC0KPiAtI2luY2x1ZGUgPGxpbnV4L3NvcnQu aD4KPiAtCj4gLS8qCj4gLSAqIHNpbXBsZSByZXZlcnNpYmxlIHRyYW5zZm9ybSB0byBtYWtlIG91 ciB0YWJsZSBtb3JlIGV2ZW5seQo+IC0gKiBkaXN0cmlidXRlZCBhZnRlciBzb3J0aW5nLgo+IC0g Ki8KPiAtI2RlZmluZSBYRk9STShpKSAoKChpKSBeICgoaSkgPDwgMjcpIF4gKChpKSA8PCAxNykp ICYgMHhmZmZmZmZmZikKPiAtCj4gLSNkZWZpbmUgQ09NUEFUSUJMRV9JT0NUTChjbWQpIFhGT1JN KCh1MzIpY21kKSwKPiAtc3RhdGljIHVuc2lnbmVkIGludCBpb2N0bF9wb2ludGVyW10gPSB7Cj4g LSNpZmRlZiBDT05GSUdfQkxPQ0sKPiAtLyogQmlnIFMgKi8KPiAtQ09NUEFUSUJMRV9JT0NUTChT Q1NJX0lPQ1RMX0dFVF9JRExVTikKPiAtQ09NUEFUSUJMRV9JT0NUTChTQ1NJX0lPQ1RMX0RPT1JM T0NLKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNDU0lfSU9DVExfRE9PUlVOTE9DSykKPiAtQ09NUEFU SUJMRV9JT0NUTChTQ1NJX0lPQ1RMX1RFU1RfVU5JVF9SRUFEWSkKPiAtQ09NUEFUSUJMRV9JT0NU TChTQ1NJX0lPQ1RMX0dFVF9CVVNfTlVNQkVSKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNDU0lfSU9D VExfU0VORF9DT01NQU5EKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNDU0lfSU9DVExfUFJPQkVfSE9T VCkKPiAtQ09NUEFUSUJMRV9JT0NUTChTQ1NJX0lPQ1RMX0dFVF9QQ0kpCj4gLSNlbmRpZgo+IC0j aWZkZWYgQ09ORklHX0JMT0NLCj4gLS8qIFNHIHN0dWZmICovCj4gLUNPTVBBVElCTEVfSU9DVEwo U0dfSU8pCj4gLUNPTVBBVElCTEVfSU9DVEwoU0dfR0VUX1JFUVVFU1RfVEFCTEUpCj4gLUNPTVBB VElCTEVfSU9DVEwoU0dfU0VUX1RJTUVPVVQpCj4gLUNPTVBBVElCTEVfSU9DVEwoU0dfR0VUX1RJ TUVPVVQpCj4gLUNPTVBBVElCTEVfSU9DVEwoU0dfRU1VTEFURURfSE9TVCkKPiAtQ09NUEFUSUJM RV9JT0NUTChTR19HRVRfVFJBTlNGT1JNKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX1NFVF9SRVNF UlZFRF9TSVpFKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX0dFVF9SRVNFUlZFRF9TSVpFKQo+IC1D T01QQVRJQkxFX0lPQ1RMKFNHX0dFVF9TQ1NJX0lEKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX1NF VF9GT1JDRV9MT1dfRE1BKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX0dFVF9MT1dfRE1BKQo+IC1D T01QQVRJQkxFX0lPQ1RMKFNHX1NFVF9GT1JDRV9QQUNLX0lEKQo+IC1DT01QQVRJQkxFX0lPQ1RM KFNHX0dFVF9QQUNLX0lEKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX0dFVF9OVU1fV0FJVElORykK PiAtQ09NUEFUSUJMRV9JT0NUTChTR19TRVRfREVCVUcpCj4gLUNPTVBBVElCTEVfSU9DVEwoU0df R0VUX1NHX1RBQkxFU0laRSkKPiAtQ09NUEFUSUJMRV9JT0NUTChTR19HRVRfQ09NTUFORF9RKQo+ IC1DT01QQVRJQkxFX0lPQ1RMKFNHX1NFVF9DT01NQU5EX1EpCj4gLUNPTVBBVElCTEVfSU9DVEwo U0dfR0VUX1ZFUlNJT05fTlVNKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX05FWFRfQ01EX0xFTikK PiAtQ09NUEFUSUJMRV9JT0NUTChTR19TQ1NJX1JFU0VUKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNH X0dFVF9SRVFVRVNUX1RBQkxFKQo+IC1DT01QQVRJQkxFX0lPQ1RMKFNHX1NFVF9LRUVQX09SUEhB TikKPiAtQ09NUEFUSUJMRV9JT0NUTChTR19HRVRfS0VFUF9PUlBIQU4pCj4gLSNlbmRpZgo+IC19 Owo+IC0KPiAtLyoKPiAtICogQ29udmVydCBjb21tb24gaW9jdGwgYXJndW1lbnRzIGJhc2VkIG9u IHRoZWlyIGNvbW1hbmQgbnVtYmVyCj4gLSAqCj4gLSAqIFBsZWFzZSBkbyBub3QgYWRkIGFueSBj b2RlIGluIGhlcmUuIEluc3RlYWQsIGltcGxlbWVudAo+IC0gKiBhIGNvbXBhdF9pb2N0bCBvcGVy YXRpb24gaW4gdGhlIHBsYWNlIHRoYXQgaGFuZGxl0ZUgdGhlCj4gLSAqIGlvY3RsIGZvciB0aGUg bmF0aXZlIGNhc2UuCj4gLSAqLwo+IC1zdGF0aWMgbG9uZyBkb19pb2N0bF90cmFucyh1bnNpZ25l ZCBpbnQgY21kLAo+IC0JCSB1bnNpZ25lZCBsb25nIGFyZywgc3RydWN0IGZpbGUgKmZpbGUpCj4g LXsKPiAtCXJldHVybiAtRU5PSU9DVExDTUQ7Cj4gLX0KPiAtCj4gLXN0YXRpYyBpbnQgY29tcGF0 X2lvY3RsX2NoZWNrX3RhYmxlKHVuc2lnbmVkIGludCB4Y21kKQo+IC17Cj4gLSNpZmRlZiBDT05G SUdfQkxPQ0sKPiAtCWludCBpOwo+IC0JY29uc3QgaW50IG1heCA9IEFSUkFZX1NJWkUoaW9jdGxf cG9pbnRlcikgLSAxOwo+IC0KPiAtCUJVSUxEX0JVR19PTihtYXggPj0gKDEgPDwgMTYpKTsKPiAt Cj4gLQkvKiBndWVzcyBpbml0aWFsIG9mZnNldCBpbnRvIHRhYmxlLCBhc3N1bWluZyBhCj4gLQkg ICBub3JtYWxpemVkIGRpc3RyaWJ1dGlvbiAqLwo+IC0JaSA9ICgoeGNtZCA+PiAxNikgKiBtYXgp ID4+IDE2Owo+IC0KPiAtCS8qIGRvIGxpbmVhciBzZWFyY2ggdXAgZmlyc3QsIHVudGlsIGdyZWF0 ZXIgb3IgZXF1YWwgKi8KPiAtCXdoaWxlIChpb2N0bF9wb2ludGVyW2ldIDwgeGNtZCAmJiBpIDwg bWF4KQo+IC0JCWkrKzsKPiAtCj4gLQkvKiB0aGVuIGRvIGxpbmVhciBzZWFyY2ggZG93biAqLwo+ IC0Jd2hpbGUgKGlvY3RsX3BvaW50ZXJbaV0gPiB4Y21kICYmIGkgPiAwKQo+IC0JCWktLTsKPiAt Cj4gLQlyZXR1cm4gaW9jdGxfcG9pbnRlcltpXSA9PSB4Y21kOwo+IC0jZWxzZQo+IC0JcmV0dXJu IDA7Cj4gLSNlbmRpZgo+IC19Cj4gLQo+ICBDT01QQVRfU1lTQ0FMTF9ERUZJTkUzKGlvY3RsLCB1 bnNpZ25lZCBpbnQsIGZkLCB1bnNpZ25lZCBpbnQsIGNtZCwKPiAgCQkgICAgICAgY29tcGF0X3Vs b25nX3QsIGFyZzMyKQo+ICB7Cj4gQEAgLTIxNiwxOSArMTE4LDkgQEAgQ09NUEFUX1NZU0NBTExf REVGSU5FMyhpb2N0bCwgdW5zaWduZWQgaW50LCBmZCwgdW5zaWduZWQgaW50LCBjbWQsCj4gIAkJ CQlnb3RvIG91dF9mcHV0Owo+ICAJCX0KPiAgCj4gLQkJaWYgKCFmLmZpbGUtPmZfb3AtPnVubG9j a2VkX2lvY3RsKQo+IC0JCQlnb3RvIGRvX2lvY3RsOwo+IC0JCWJyZWFrOwo+IC0JfQo+IC0KPiAt CWlmIChjb21wYXRfaW9jdGxfY2hlY2tfdGFibGUoWEZPUk0oY21kKSkpCj4gLQkJZ290byBmb3Vu ZF9oYW5kbGVyOwo+IC0KPiAtCWVycm9yID0gZG9faW9jdGxfdHJhbnMoY21kLCBhcmcsIGYuZmls ZSk7Cj4gLQlpZiAoZXJyb3IgPT0gLUVOT0lPQ1RMQ01EKQo+ICAJCWVycm9yID0gLUVOT1RUWTsK PiAtCj4gLQlnb3RvIG91dF9mcHV0Owo+ICsJCWdvdG8gb3V0X2ZwdXQ7Cj4gKwl9Cj4gIAo+ICAg Zm91bmRfaGFuZGxlcjoKPiAgCWFyZyA9ICh1bnNpZ25lZCBsb25nKWNvbXBhdF9wdHIoYXJnKTsK PiBAQCAtMjM5LDIzICsxMzEsMyBAQCBDT01QQVRfU1lTQ0FMTF9ERUZJTkUzKGlvY3RsLCB1bnNp Z25lZCBpbnQsIGZkLCB1bnNpZ25lZCBpbnQsIGNtZCwKPiAgIG91dDoKPiAgCXJldHVybiBlcnJv cjsKPiAgfQo+IC0KPiAtc3RhdGljIGludCBfX2luaXQgaW5pdF9zeXMzMl9pb2N0bF9jbXAoY29u c3Qgdm9pZCAqcCwgY29uc3Qgdm9pZCAqcSkKPiAtewo+IC0JdW5zaWduZWQgaW50IGEsIGI7Cj4g LQlhID0gKih1bnNpZ25lZCBpbnQgKilwOwo+IC0JYiA9ICoodW5zaWduZWQgaW50ICopcTsKPiAt CWlmIChhID4gYikKPiAtCQlyZXR1cm4gMTsKPiAtCWlmIChhIDwgYikKPiAtCQlyZXR1cm4gLTE7 Cj4gLQlyZXR1cm4gMDsKPiAtfQo+IC0KPiAtc3RhdGljIGludCBfX2luaXQgaW5pdF9zeXMzMl9p b2N0bCh2b2lkKQo+IC17Cj4gLQlzb3J0KGlvY3RsX3BvaW50ZXIsIEFSUkFZX1NJWkUoaW9jdGxf cG9pbnRlciksIHNpemVvZigqaW9jdGxfcG9pbnRlciksCj4gLQkJaW5pdF9zeXMzMl9pb2N0bF9j bXAsIE5VTEwpOwo+IC0JcmV0dXJuIDA7Cj4gLX0KPiAtX19pbml0Y2FsbChpbml0X3N5czMyX2lv Y3RsKTsKPiAtLSAKPiAyLjIwLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlzdApWaXJ0dWFsaXphdGlvbkBs aXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlvbi5v cmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg==