From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wm1-f52.google.com (mail-wm1-f52.google.com [209.85.128.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6A4455A4EF for ; Fri, 22 Mar 2024 18:14:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.52 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711131273; cv=none; b=UzMYQieDLMdhu4MdDUHQfVj45HjjYtYGBwx8d6WTkQ1Qp1n6y3v3UmKT0pwEFV5qIKxzbzqketIVRcKtKYQV9LKbVen5zzHaMptDaufNySV2ZugqXvI1QTVZL4wChKMvdtG6ptSoCdutmZelMkZSO1uRKTi1gZcMhW7EUcZAOrE= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1711131273; c=relaxed/simple; bh=Ulh2+U57NPF9A35k/OArrt2i9+CAkPAY0qErvvEfms0=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=CwhUg3KkTQZQh/x/eyug/PyfBRBMw1Ng9Nslpjgmryp3VhKZcZ5ct/mLNZQ7vHq5fylKq6lsz/TpcZqzFbaJLifXsi32yWnKPmQY87RT9axlMXLt3MgYGGnJAXnUFUKCi2Pjp9CtIeU3NNFxhtQ8FstB+ki+k3M6ihZZDjTaQ3w= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=EFeWjj0I; arc=none smtp.client-ip=209.85.128.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="EFeWjj0I" Received: by mail-wm1-f52.google.com with SMTP id 5b1f17b1804b1-41428b378b9so9475e9.1 for ; Fri, 22 Mar 2024 11:14:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1711131270; x=1711736070; darn=lists.linux.dev; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=Tg7FK1adNy9kVBWtxm5M01gQDSSIPZ6QTtS5XJqEjTE=; b=EFeWjj0If7kIswmNJwDm6+QcuJt3KRnUQ5BLi2IoFT/E8Eu40TkErAA5ZgEf5kEvZx UtIQU+4vZr3gWS/aalVWAdi6/AlTxEM5NM9rX676gyBRQPPCJ/qEbloYLqWRrYTPwoBa 2xdujWEeOzGVoNi+cyf7tHpKWdiqDC/N+bfeFptTyoFgMMCdYLeNwSmlXlcKkV+/Rwgz 6OAedA3n6tj3ndpBj2q2/biDN82cz7zQ7x0N331NNXJvqALkWqATkAaSjmi/1NbRCNFp VANzVLwucErXhrmnUl4q1r+k5YcdEqf2YWXQ6vIkVdonjbfsjXv4GXyIv62o8RG3Ixkd 8y5A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1711131270; x=1711736070; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=Tg7FK1adNy9kVBWtxm5M01gQDSSIPZ6QTtS5XJqEjTE=; b=tXeGQB5Lfa8HA9KaHLTCb4+J+3/pB2b+WzWPOUCcn8E6Z+7K5I7vXG6+PkpplJEM8o eoQibQ8VgPTUCSrrtx11F68V122KkNOpFPOpKC7BRRCZoH9l5z8pB8P6Ym9TDJUQeZmf HrmZs9HYtpDix2a45XXdqYLwCiVglgRt4lrbTUnpgSp5vRAKykllNLVIS7IOicalxAVu qmdKZygLX+lMtH18vI/HcbfWH4gi87rHQAqxNFRDayMx/Q8yXArFFLDV7hWjikoZEz8h DjDYxt9tTvzgqg0umlpdX6fXRfJGBs/L8uM00TEDkdCZvA+494xzFsrQAy2+vibX2N1y kG+w== X-Gm-Message-State: AOJu0YwRyD23JvwZjKLFC13yuE31p4maJt6dQKyHiTQl3a05EF6NCL/o S/C+oH0ltMSiMO04dJ1wEiyITn1AXywBzRVo9xC28x/mINPQjWgfR9PK9M/+Qw== X-Google-Smtp-Source: AGHT+IFlAz1VWtABt9QEIqbX69Q4NML8xtukhkG+yMimaYpYIEIBbyT8vCbvi1HwwGOkvRDTRZqDFQ== X-Received: by 2002:a05:600c:1c8d:b0:414:800f:f992 with SMTP id k13-20020a05600c1c8d00b00414800ff992mr10631wms.2.1711131269544; Fri, 22 Mar 2024 11:14:29 -0700 (PDT) Received: from google.com (180.232.140.34.bc.googleusercontent.com. [34.140.232.180]) by smtp.gmail.com with ESMTPSA id n14-20020a5d51ce000000b0033e9fca1e49sm2573790wrv.60.2024.03.22.11.14.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Mar 2024 11:14:28 -0700 (PDT) Date: Fri, 22 Mar 2024 18:14:24 +0000 From: Mostafa Saleh To: Jason Gunthorpe Cc: iommu@lists.linux.dev, Joerg Roedel , linux-arm-kernel@lists.infradead.org, Robin Murphy , Will Deacon , Eric Auger , Jean-Philippe Brucker , Moritz Fischer , Michael Shavit , Nicolin Chen , patches@lists.linux.dev, Shameerali Kolothum Thodi Subject: Re: [PATCH v5 04/27] iommu/arm-smmu-v3: Add an ops indirection to the STE code Message-ID: References: <0-v5-9a37e0c884ce+31e3-smmuv3_newapi_p2_jgg@nvidia.com> <4-v5-9a37e0c884ce+31e3-smmuv3_newapi_p2_jgg@nvidia.com> Precedence: bulk X-Mailing-List: iommu@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <4-v5-9a37e0c884ce+31e3-smmuv3_newapi_p2_jgg@nvidia.com> Hi Jason, On Mon, Mar 04, 2024 at 07:43:52PM -0400, Jason Gunthorpe wrote: > Prepare to put the CD code into the same mechanism. Add an ops indirection > around all the STE specific code and make the worker functions independent > of the entry content being processed. > > get_used and sync ops are provided to hook the correct code. > > Signed-off-by: Michael Shavit > Signed-off-by: Jason Gunthorpe > --- > drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c | 172 ++++++++++++-------- > 1 file changed, 104 insertions(+), 68 deletions(-) > > diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c > index c60b067c1f553e..b7f947e36f596f 100644 > --- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c > +++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c > @@ -48,8 +48,20 @@ enum arm_smmu_msi_index { > ARM_SMMU_MAX_MSIS, > }; > > -static void arm_smmu_sync_ste_for_sid(struct arm_smmu_device *smmu, > - ioasid_t sid); > +struct arm_smmu_entry_writer_ops; > +struct arm_smmu_entry_writer { > + const struct arm_smmu_entry_writer_ops *ops; > + struct arm_smmu_master *master; > +}; > + > +struct arm_smmu_entry_writer_ops { > + unsigned int num_entry_qwords; > + __le64 v_bit; > + void (*get_used)(const __le64 *entry, __le64 *used); > + void (*sync)(struct arm_smmu_entry_writer *writer); > +}; > + > +#define NUM_ENTRY_QWORDS (sizeof(struct arm_smmu_ste) / sizeof(u64)) > > static phys_addr_t arm_smmu_msi_cfg[ARM_SMMU_MAX_MSIS][3] = { > [EVTQ_MSI_INDEX] = { > @@ -982,43 +994,42 @@ void arm_smmu_tlb_inv_asid(struct arm_smmu_device *smmu, u16 asid) > * would be nice if this was complete according to the spec, but minimally it > * has to capture the bits this driver uses. > */ > -static void arm_smmu_get_ste_used(const struct arm_smmu_ste *ent, > - struct arm_smmu_ste *used_bits) > +static void arm_smmu_get_ste_used(const __le64 *ent, __le64 *used_bits) > { > - unsigned int cfg = FIELD_GET(STRTAB_STE_0_CFG, le64_to_cpu(ent->data[0])); > + unsigned int cfg = FIELD_GET(STRTAB_STE_0_CFG, le64_to_cpu(ent[0])); > > - used_bits->data[0] = cpu_to_le64(STRTAB_STE_0_V); > - if (!(ent->data[0] & cpu_to_le64(STRTAB_STE_0_V))) > + used_bits[0] = cpu_to_le64(STRTAB_STE_0_V); > + if (!(ent[0] & cpu_to_le64(STRTAB_STE_0_V))) > return; > > - used_bits->data[0] |= cpu_to_le64(STRTAB_STE_0_CFG); > + used_bits[0] |= cpu_to_le64(STRTAB_STE_0_CFG); > > /* S1 translates */ > if (cfg & BIT(0)) { > - used_bits->data[0] |= cpu_to_le64(STRTAB_STE_0_S1FMT | > - STRTAB_STE_0_S1CTXPTR_MASK | > - STRTAB_STE_0_S1CDMAX); > - used_bits->data[1] |= > + used_bits[0] |= cpu_to_le64(STRTAB_STE_0_S1FMT | > + STRTAB_STE_0_S1CTXPTR_MASK | > + STRTAB_STE_0_S1CDMAX); > + used_bits[1] |= > cpu_to_le64(STRTAB_STE_1_S1DSS | STRTAB_STE_1_S1CIR | > STRTAB_STE_1_S1COR | STRTAB_STE_1_S1CSH | > STRTAB_STE_1_S1STALLD | STRTAB_STE_1_STRW | > STRTAB_STE_1_EATS); > - used_bits->data[2] |= cpu_to_le64(STRTAB_STE_2_S2VMID); > + used_bits[2] |= cpu_to_le64(STRTAB_STE_2_S2VMID); > } > > /* S2 translates */ > if (cfg & BIT(1)) { > - used_bits->data[1] |= > + used_bits[1] |= > cpu_to_le64(STRTAB_STE_1_EATS | STRTAB_STE_1_SHCFG); > - used_bits->data[2] |= > + used_bits[2] |= > cpu_to_le64(STRTAB_STE_2_S2VMID | STRTAB_STE_2_VTCR | > STRTAB_STE_2_S2AA64 | STRTAB_STE_2_S2ENDI | > STRTAB_STE_2_S2PTW | STRTAB_STE_2_S2R); > - used_bits->data[3] |= cpu_to_le64(STRTAB_STE_3_S2TTB_MASK); > + used_bits[3] |= cpu_to_le64(STRTAB_STE_3_S2TTB_MASK); > } > > if (cfg == STRTAB_STE_0_CFG_BYPASS) > - used_bits->data[1] |= cpu_to_le64(STRTAB_STE_1_SHCFG); > + used_bits[1] |= cpu_to_le64(STRTAB_STE_1_SHCFG); > } > > /* > @@ -1027,57 +1038,55 @@ static void arm_smmu_get_ste_used(const struct arm_smmu_ste *ent, > * unused_update is an intermediate value of entry that has unused bits set to > * their new values. > */ > -static u8 arm_smmu_entry_qword_diff(const struct arm_smmu_ste *entry, > - const struct arm_smmu_ste *target, > - struct arm_smmu_ste *unused_update) > +static u8 arm_smmu_entry_qword_diff(struct arm_smmu_entry_writer *writer, > + const __le64 *entry, const __le64 *target, > + __le64 *unused_update) > { > - struct arm_smmu_ste target_used = {}; > - struct arm_smmu_ste cur_used = {}; > + __le64 target_used[NUM_ENTRY_QWORDS] = {}; > + __le64 cur_used[NUM_ENTRY_QWORDS] = {}; This is confusing to me, the function was modified to be generic, so its has args are __le64 * instead of struct arm_smmu_ste *. But NUM_ENTRY_QWORDS is defined as “(sizeof(struct arm_smmu_ste) / sizeof(u64))” and in the same function writer->ops->num_entry_qwords is used nterchangeably, I understand that this not a constant and the compiler would complain. But since for any other num_entry_qwords larger than NUM_ENTRY_QWORDS it fails, and we know STEs and CDs both have the same size, we simplify the code and make it a constant everywhere. I see in the next patch, that this is redefined to be the max between STE and CD, but again, this hardware and it never changes, so my opinion is to simplify the code, as there is no need to generalize this part. > u8 used_qword_diff = 0; > unsigned int i; > > - arm_smmu_get_ste_used(entry, &cur_used); > - arm_smmu_get_ste_used(target, &target_used); > + writer->ops->get_used(entry, cur_used); > + writer->ops->get_used(target, target_used); > > - for (i = 0; i != ARRAY_SIZE(target_used.data); i++) { > + for (i = 0; i != writer->ops->num_entry_qwords; i++) { > /* > * Check that masks are up to date, the make functions are not > * allowed to set a bit to 1 if the used function doesn't say it > * is used. > */ > - WARN_ON_ONCE(target->data[i] & ~target_used.data[i]); > + WARN_ON_ONCE(target[i] & ~target_used[i]); > > /* Bits can change because they are not currently being used */ > - unused_update->data[i] = (entry->data[i] & cur_used.data[i]) | > - (target->data[i] & ~cur_used.data[i]); > + unused_update[i] = (entry[i] & cur_used[i]) | > + (target[i] & ~cur_used[i]); > /* > * Each bit indicates that a used bit in a qword needs to be > * changed after unused_update is applied. > */ > - if ((unused_update->data[i] & target_used.data[i]) != > - target->data[i]) > + if ((unused_update[i] & target_used[i]) != target[i]) > used_qword_diff |= 1 << i; > } > return used_qword_diff; > } > > -static bool entry_set(struct arm_smmu_device *smmu, ioasid_t sid, > - struct arm_smmu_ste *entry, > - const struct arm_smmu_ste *target, unsigned int start, > +static bool entry_set(struct arm_smmu_entry_writer *writer, __le64 *entry, > + const __le64 *target, unsigned int start, > unsigned int len) > { > bool changed = false; > unsigned int i; > > for (i = start; len != 0; len--, i++) { > - if (entry->data[i] != target->data[i]) { > - WRITE_ONCE(entry->data[i], target->data[i]); > + if (entry[i] != target[i]) { > + WRITE_ONCE(entry[i], target[i]); > changed = true; > } > } > > if (changed) > - arm_smmu_sync_ste_for_sid(smmu, sid); > + writer->ops->sync(writer); > return changed; > } > > @@ -1107,17 +1116,15 @@ static bool entry_set(struct arm_smmu_device *smmu, ioasid_t sid, > * V=0 process. This relies on the IGNORED behavior described in the > * specification. > */ > -static void arm_smmu_write_ste(struct arm_smmu_master *master, u32 sid, > - struct arm_smmu_ste *entry, > - const struct arm_smmu_ste *target) > +static void arm_smmu_write_entry(struct arm_smmu_entry_writer *writer, > + __le64 *entry, const __le64 *target) > { > - unsigned int num_entry_qwords = ARRAY_SIZE(target->data); > - struct arm_smmu_device *smmu = master->smmu; > - struct arm_smmu_ste unused_update; > + unsigned int num_entry_qwords = writer->ops->num_entry_qwords; > + __le64 unused_update[NUM_ENTRY_QWORDS]; > u8 used_qword_diff; > > used_qword_diff = > - arm_smmu_entry_qword_diff(entry, target, &unused_update); > + arm_smmu_entry_qword_diff(writer, entry, target, unused_update); > if (hweight8(used_qword_diff) == 1) { > /* > * Only one qword needs its used bits to be changed. This is a > @@ -1133,22 +1140,21 @@ static void arm_smmu_write_ste(struct arm_smmu_master *master, u32 sid, > * writing it in the next step anyways. This can save a sync > * when the only change is in that qword. > */ > - unused_update.data[critical_qword_index] = > - entry->data[critical_qword_index]; > - entry_set(smmu, sid, entry, &unused_update, 0, num_entry_qwords); > - entry_set(smmu, sid, entry, target, critical_qword_index, 1); > - entry_set(smmu, sid, entry, target, 0, num_entry_qwords); > + unused_update[critical_qword_index] = > + entry[critical_qword_index]; > + entry_set(writer, entry, unused_update, 0, num_entry_qwords); > + entry_set(writer, entry, target, critical_qword_index, 1); > + entry_set(writer, entry, target, 0, num_entry_qwords); > } else if (used_qword_diff) { > /* > * At least two qwords need their inuse bits to be changed. This > * requires a breaking update, zero the V bit, write all qwords > * but 0, then set qword 0 > */ > - unused_update.data[0] = entry->data[0] & > - cpu_to_le64(~STRTAB_STE_0_V); > - entry_set(smmu, sid, entry, &unused_update, 0, 1); > - entry_set(smmu, sid, entry, target, 1, num_entry_qwords - 1); > - entry_set(smmu, sid, entry, target, 0, 1); > + unused_update[0] = entry[0] & (~writer->ops->v_bit); > + entry_set(writer, entry, unused_update, 0, 1); > + entry_set(writer, entry, target, 1, num_entry_qwords - 1); > + entry_set(writer, entry, target, 0, 1); > } else { > /* > * No inuse bit changed. Sanity check that all unused bits are 0 > @@ -1156,18 +1162,7 @@ static void arm_smmu_write_ste(struct arm_smmu_master *master, u32 sid, > * compute_qword_diff(). > */ > WARN_ON_ONCE( > - entry_set(smmu, sid, entry, target, 0, num_entry_qwords)); > - } > - > - /* It's likely that we'll want to use the new STE soon */ > - if (!(smmu->options & ARM_SMMU_OPT_SKIP_PREFETCH)) { > - struct arm_smmu_cmdq_ent > - prefetch_cmd = { .opcode = CMDQ_OP_PREFETCH_CFG, > - .prefetch = { > - .sid = sid, > - } }; > - > - arm_smmu_cmdq_issue_cmd(smmu, &prefetch_cmd); > + entry_set(writer, entry, target, 0, num_entry_qwords)); > } > } > > @@ -1440,17 +1435,58 @@ arm_smmu_write_strtab_l1_desc(__le64 *dst, struct arm_smmu_strtab_l1_desc *desc) > WRITE_ONCE(*dst, cpu_to_le64(val)); > } > > -static void arm_smmu_sync_ste_for_sid(struct arm_smmu_device *smmu, u32 sid) > +struct arm_smmu_ste_writer { > + struct arm_smmu_entry_writer writer; > + u32 sid; > +}; > + > +static void arm_smmu_ste_writer_sync_entry(struct arm_smmu_entry_writer *writer) > { > + struct arm_smmu_ste_writer *ste_writer = > + container_of(writer, struct arm_smmu_ste_writer, writer); > struct arm_smmu_cmdq_ent cmd = { > .opcode = CMDQ_OP_CFGI_STE, > .cfgi = { > - .sid = sid, > + .sid = ste_writer->sid, > .leaf = true, > }, > }; > > - arm_smmu_cmdq_issue_cmd_with_sync(smmu, &cmd); > + arm_smmu_cmdq_issue_cmd_with_sync(writer->master->smmu, &cmd); > +} > + > +static const struct arm_smmu_entry_writer_ops arm_smmu_ste_writer_ops = { > + .sync = arm_smmu_ste_writer_sync_entry, > + .get_used = arm_smmu_get_ste_used, > + .v_bit = cpu_to_le64(STRTAB_STE_0_V), > + .num_entry_qwords = sizeof(struct arm_smmu_ste) / sizeof(u64), > +}; > + > +static void arm_smmu_write_ste(struct arm_smmu_master *master, u32 sid, > + struct arm_smmu_ste *ste, > + const struct arm_smmu_ste *target) > +{ > + struct arm_smmu_device *smmu = master->smmu; > + struct arm_smmu_ste_writer ste_writer = { > + .writer = { > + .ops = &arm_smmu_ste_writer_ops, > + .master = master, > + }, > + .sid = sid, > + }; > + > + arm_smmu_write_entry(&ste_writer.writer, ste->data, target->data); > + > + /* It's likely that we'll want to use the new STE soon */ > + if (!(smmu->options & ARM_SMMU_OPT_SKIP_PREFETCH)) { > + struct arm_smmu_cmdq_ent > + prefetch_cmd = { .opcode = CMDQ_OP_PREFETCH_CFG, > + .prefetch = { > + .sid = sid, > + } }; > + > + arm_smmu_cmdq_issue_cmd(smmu, &prefetch_cmd); > + } > } > > static void arm_smmu_make_abort_ste(struct arm_smmu_ste *target) > -- > 2.43.2 > Thanks, Mostafa 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 99611C54E71 for ; Fri, 22 Mar 2024 18:14:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=ul6O2yYolzjbhRJ9qCloG1c6FRmrmQwoeSwdKZGeXco=; b=eeqhKYUypPfXNt gR++5NsoWBDMBznBGC4DXFz+VuZ2C08dfWFHCeXGvsjpLwETqWTkRgsVhGRFZju4XIgYlDXuVRR81 LhctzYMFXO6iYN8SrzY4M/Je1RB+LPn1XSaMBWenzW9kvCiP84hAwi+l96AgW5at5RnTF+haVTCfU +l8Rx/Puz1SC4ZRa4KIsPkZpe4X/LgDtUCzHP+YFZKKqXIieS575gfuA6JP6SFZ66HS6xjNCgpz2i 7mLE0o5/+EbO+mnGfT4e7cEI9aehUvEsMlsR20y2bows3OPn6V6kHGKLH2Vb5h/QpCaI3g6m0VWDQ DhVIv7JvusGeSEW6EQyg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1rnjPY-00000008JcC-3Uvi; Fri, 22 Mar 2024 18:14:36 +0000 Received: from mail-wm1-x32b.google.com ([2a00:1450:4864:20::32b]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1rnjPU-00000008Jaf-3kQm for linux-arm-kernel@lists.infradead.org; Fri, 22 Mar 2024 18:14:34 +0000 Received: by mail-wm1-x32b.google.com with SMTP id 5b1f17b1804b1-41428b378b9so9495e9.1 for ; Fri, 22 Mar 2024 11:14:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1711131270; x=1711736070; darn=lists.infradead.org; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date:from:to :cc:subject:date:message-id:reply-to; bh=Tg7FK1adNy9kVBWtxm5M01gQDSSIPZ6QTtS5XJqEjTE=; b=GQFHkcINdmbilmq2fkIH7exJVCW6bGjAub+ApGa2E1NSoqVblUGoV9OnqAJ1VrDXxL Hwlfyss/NtPeNth5OEcZAvy6K0eIGLt/wDTc2GQMyXWbzjUuT/vJKRJd1yTuUQuJrozV dykfjnWvpv7+IDgQYuoDaWrtP5d2Tl4rebhED4Fws8KhpdWl5dn3wkAQOWV5bRlplzty M9BnWKgGEJcGe2MdGOl4QUIGl58VCEjbHiFZU17oai7JR9RI7axIyB2d79YwJ5YDgcyX AHJXbykK4+GJKKtYc9xIYsixJ94iGT6XLWL9iHN/YzzoFKs2b/P1pLViazvBU8v9Yn2S fazQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1711131270; x=1711736070; h=in-reply-to:content-transfer-encoding:content-disposition :mime-version:references:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=Tg7FK1adNy9kVBWtxm5M01gQDSSIPZ6QTtS5XJqEjTE=; b=n8Cm9RXDwgRGL//+MVIIDIqegIjQhm0318tEZVXSpo4JRXZ1eLkjjRHMZuwNc9Bwde kA41k7YgzDpdHvQMomu2u2+z04ywzt/5H/T6/r3uejiaYjP0SMWN13eblgnUfSfFTU2o RYQR8v/etpX1g/o/A2ao/MpsiRczgjN7EI9TxMQ59nUALfLRPajLEa3V6ADQVuIsdQC/ XB40pvU5fKiM9knHz5RO0HG+VYKjQ1Kz7rCaXl6Z4nFRaEnGxqdcMQb1NQubB873WXeA XP7W5dV69LXXhVyOvJ0m97ySpJRiHQqx04W+HaeNtbbrg4qQeThrZ+ryEtqJaVDEv2Lu iFwg== X-Forwarded-Encrypted: i=1; AJvYcCUSYquoQGQlLUbUlWJmSr7joe4exgr8hjKOJDVJMdAIh3QRWp8uoGJTa2XAdb0uWusBmZux7csXRM9xZo3leKUgTWkHaBWT2QePF2i7LStf469sgsk= X-Gm-Message-State: AOJu0YwhdrzKZPDk8AJlTjv+iUBZrndQ3I5ithV6z/Qv+mtvC61wyIPx DOhh2G5k+6j8qbyeU/j3ILEpiFKmL6cM1RW4ZLaKMR4t8GMwrKO6QqAolmT8bQ== X-Google-Smtp-Source: AGHT+IFlAz1VWtABt9QEIqbX69Q4NML8xtukhkG+yMimaYpYIEIBbyT8vCbvi1HwwGOkvRDTRZqDFQ== X-Received: by 2002:a05:600c:1c8d:b0:414:800f:f992 with SMTP id k13-20020a05600c1c8d00b00414800ff992mr10631wms.2.1711131269544; Fri, 22 Mar 2024 11:14:29 -0700 (PDT) Received: from google.com (180.232.140.34.bc.googleusercontent.com. [34.140.232.180]) by smtp.gmail.com with ESMTPSA id n14-20020a5d51ce000000b0033e9fca1e49sm2573790wrv.60.2024.03.22.11.14.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Mar 2024 11:14:28 -0700 (PDT) Date: Fri, 22 Mar 2024 18:14:24 +0000 From: Mostafa Saleh To: Jason Gunthorpe Cc: iommu@lists.linux.dev, Joerg Roedel , linux-arm-kernel@lists.infradead.org, Robin Murphy , Will Deacon , Eric Auger , Jean-Philippe Brucker , Moritz Fischer , Michael Shavit , Nicolin Chen , patches@lists.linux.dev, Shameerali Kolothum Thodi Subject: Re: [PATCH v5 04/27] iommu/arm-smmu-v3: Add an ops indirection to the STE code Message-ID: References: <0-v5-9a37e0c884ce+31e3-smmuv3_newapi_p2_jgg@nvidia.com> <4-v5-9a37e0c884ce+31e3-smmuv3_newapi_p2_jgg@nvidia.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <4-v5-9a37e0c884ce+31e3-smmuv3_newapi_p2_jgg@nvidia.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240322_111432_975763_8D138DE9 X-CRM114-Status: GOOD ( 42.60 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGkgSmFzb24sCgpPbiBNb24sIE1hciAwNCwgMjAyNCBhdCAwNzo0Mzo1MlBNIC0wNDAwLCBKYXNv biBHdW50aG9ycGUgd3JvdGU6Cj4gUHJlcGFyZSB0byBwdXQgdGhlIENEIGNvZGUgaW50byB0aGUg c2FtZSBtZWNoYW5pc20uIEFkZCBhbiBvcHMgaW5kaXJlY3Rpb24KPiBhcm91bmQgYWxsIHRoZSBT VEUgc3BlY2lmaWMgY29kZSBhbmQgbWFrZSB0aGUgd29ya2VyIGZ1bmN0aW9ucyBpbmRlcGVuZGVu dAo+IG9mIHRoZSBlbnRyeSBjb250ZW50IGJlaW5nIHByb2Nlc3NlZC4KPiAKPiBnZXRfdXNlZCBh bmQgc3luYyBvcHMgYXJlIHByb3ZpZGVkIHRvIGhvb2sgdGhlIGNvcnJlY3QgY29kZS4KPiAKPiBT aWduZWQtb2ZmLWJ5OiBNaWNoYWVsIFNoYXZpdCA8bXNoYXZpdEBnb29nbGUuY29tPgo+IFNpZ25l ZC1vZmYtYnk6IEphc29uIEd1bnRob3JwZSA8amdnQG52aWRpYS5jb20+Cj4gLS0tCj4gIGRyaXZl cnMvaW9tbXUvYXJtL2FybS1zbW11LXYzL2FybS1zbW11LXYzLmMgfCAxNzIgKysrKysrKysrKysr LS0tLS0tLS0KPiAgMSBmaWxlIGNoYW5nZWQsIDEwNCBpbnNlcnRpb25zKCspLCA2OCBkZWxldGlv bnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9hcm0vYXJtLXNtbXUtdjMvYXJt LXNtbXUtdjMuYyBiL2RyaXZlcnMvaW9tbXUvYXJtL2FybS1zbW11LXYzL2FybS1zbW11LXYzLmMK PiBpbmRleCBjNjBiMDY3YzFmNTUzZS4uYjdmOTQ3ZTM2ZjU5NmYgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9pb21tdS9hcm0vYXJtLXNtbXUtdjMvYXJtLXNtbXUtdjMuYwo+ICsrKyBiL2RyaXZlcnMv aW9tbXUvYXJtL2FybS1zbW11LXYzL2FybS1zbW11LXYzLmMKPiBAQCAtNDgsOCArNDgsMjAgQEAg ZW51bSBhcm1fc21tdV9tc2lfaW5kZXggewo+ICAJQVJNX1NNTVVfTUFYX01TSVMsCj4gIH07Cj4g IAo+IC1zdGF0aWMgdm9pZCBhcm1fc21tdV9zeW5jX3N0ZV9mb3Jfc2lkKHN0cnVjdCBhcm1fc21t dV9kZXZpY2UgKnNtbXUsCj4gLQkJCQkgICAgICBpb2FzaWRfdCBzaWQpOwo+ICtzdHJ1Y3QgYXJt X3NtbXVfZW50cnlfd3JpdGVyX29wczsKPiArc3RydWN0IGFybV9zbW11X2VudHJ5X3dyaXRlciB7 Cj4gKwljb25zdCBzdHJ1Y3QgYXJtX3NtbXVfZW50cnlfd3JpdGVyX29wcyAqb3BzOwo+ICsJc3Ry dWN0IGFybV9zbW11X21hc3RlciAqbWFzdGVyOwo+ICt9Owo+ICsKPiArc3RydWN0IGFybV9zbW11 X2VudHJ5X3dyaXRlcl9vcHMgewo+ICsJdW5zaWduZWQgaW50IG51bV9lbnRyeV9xd29yZHM7Cj4g KwlfX2xlNjQgdl9iaXQ7Cj4gKwl2b2lkICgqZ2V0X3VzZWQpKGNvbnN0IF9fbGU2NCAqZW50cnks IF9fbGU2NCAqdXNlZCk7Cj4gKwl2b2lkICgqc3luYykoc3RydWN0IGFybV9zbW11X2VudHJ5X3dy aXRlciAqd3JpdGVyKTsKPiArfTsKPiArCj4gKyNkZWZpbmUgTlVNX0VOVFJZX1FXT1JEUyAoc2l6 ZW9mKHN0cnVjdCBhcm1fc21tdV9zdGUpIC8gc2l6ZW9mKHU2NCkpCj4KPiAgc3RhdGljIHBoeXNf YWRkcl90IGFybV9zbW11X21zaV9jZmdbQVJNX1NNTVVfTUFYX01TSVNdWzNdID0gewo+ICAJW0VW VFFfTVNJX0lOREVYXSA9IHsKPiBAQCAtOTgyLDQzICs5OTQsNDIgQEAgdm9pZCBhcm1fc21tdV90 bGJfaW52X2FzaWQoc3RydWN0IGFybV9zbW11X2RldmljZSAqc21tdSwgdTE2IGFzaWQpCj4gICAq IHdvdWxkIGJlIG5pY2UgaWYgdGhpcyB3YXMgY29tcGxldGUgYWNjb3JkaW5nIHRvIHRoZSBzcGVj LCBidXQgbWluaW1hbGx5IGl0Cj4gICAqIGhhcyB0byBjYXB0dXJlIHRoZSBiaXRzIHRoaXMgZHJp dmVyIHVzZXMuCj4gICAqLwo+IC1zdGF0aWMgdm9pZCBhcm1fc21tdV9nZXRfc3RlX3VzZWQoY29u c3Qgc3RydWN0IGFybV9zbW11X3N0ZSAqZW50LAo+IC0JCQkJICBzdHJ1Y3QgYXJtX3NtbXVfc3Rl ICp1c2VkX2JpdHMpCj4gK3N0YXRpYyB2b2lkIGFybV9zbW11X2dldF9zdGVfdXNlZChjb25zdCBf X2xlNjQgKmVudCwgX19sZTY0ICp1c2VkX2JpdHMpCj4gIHsKPiAtCXVuc2lnbmVkIGludCBjZmcg PSBGSUVMRF9HRVQoU1RSVEFCX1NURV8wX0NGRywgbGU2NF90b19jcHUoZW50LT5kYXRhWzBdKSk7 Cj4gKwl1bnNpZ25lZCBpbnQgY2ZnID0gRklFTERfR0VUKFNUUlRBQl9TVEVfMF9DRkcsIGxlNjRf dG9fY3B1KGVudFswXSkpOwo+ICAKPiAtCXVzZWRfYml0cy0+ZGF0YVswXSA9IGNwdV90b19sZTY0 KFNUUlRBQl9TVEVfMF9WKTsKPiAtCWlmICghKGVudC0+ZGF0YVswXSAmIGNwdV90b19sZTY0KFNU UlRBQl9TVEVfMF9WKSkpCj4gKwl1c2VkX2JpdHNbMF0gPSBjcHVfdG9fbGU2NChTVFJUQUJfU1RF XzBfVik7Cj4gKwlpZiAoIShlbnRbMF0gJiBjcHVfdG9fbGU2NChTVFJUQUJfU1RFXzBfVikpKQo+ ICAJCXJldHVybjsKPiAgCj4gLQl1c2VkX2JpdHMtPmRhdGFbMF0gfD0gY3B1X3RvX2xlNjQoU1RS VEFCX1NURV8wX0NGRyk7Cj4gKwl1c2VkX2JpdHNbMF0gfD0gY3B1X3RvX2xlNjQoU1RSVEFCX1NU RV8wX0NGRyk7Cj4gIAo+ICAJLyogUzEgdHJhbnNsYXRlcyAqLwo+ICAJaWYgKGNmZyAmIEJJVCgw KSkgewo+IC0JCXVzZWRfYml0cy0+ZGF0YVswXSB8PSBjcHVfdG9fbGU2NChTVFJUQUJfU1RFXzBf UzFGTVQgfAo+IC0JCQkJCQkgIFNUUlRBQl9TVEVfMF9TMUNUWFBUUl9NQVNLIHwKPiAtCQkJCQkJ ICBTVFJUQUJfU1RFXzBfUzFDRE1BWCk7Cj4gLQkJdXNlZF9iaXRzLT5kYXRhWzFdIHw9Cj4gKwkJ dXNlZF9iaXRzWzBdIHw9IGNwdV90b19sZTY0KFNUUlRBQl9TVEVfMF9TMUZNVCB8Cj4gKwkJCQkJ ICAgIFNUUlRBQl9TVEVfMF9TMUNUWFBUUl9NQVNLIHwKPiArCQkJCQkgICAgU1RSVEFCX1NURV8w X1MxQ0RNQVgpOwo+ICsJCXVzZWRfYml0c1sxXSB8PQo+ICAJCQljcHVfdG9fbGU2NChTVFJUQUJf U1RFXzFfUzFEU1MgfCBTVFJUQUJfU1RFXzFfUzFDSVIgfAo+ICAJCQkJICAgIFNUUlRBQl9TVEVf MV9TMUNPUiB8IFNUUlRBQl9TVEVfMV9TMUNTSCB8Cj4gIAkJCQkgICAgU1RSVEFCX1NURV8xX1Mx U1RBTExEIHwgU1RSVEFCX1NURV8xX1NUUlcgfAo+ICAJCQkJICAgIFNUUlRBQl9TVEVfMV9FQVRT KTsKPiAtCQl1c2VkX2JpdHMtPmRhdGFbMl0gfD0gY3B1X3RvX2xlNjQoU1RSVEFCX1NURV8yX1My Vk1JRCk7Cj4gKwkJdXNlZF9iaXRzWzJdIHw9IGNwdV90b19sZTY0KFNUUlRBQl9TVEVfMl9TMlZN SUQpOwo+ICAJfQo+ICAKPiAgCS8qIFMyIHRyYW5zbGF0ZXMgKi8KPiAgCWlmIChjZmcgJiBCSVQo MSkpIHsKPiAtCQl1c2VkX2JpdHMtPmRhdGFbMV0gfD0KPiArCQl1c2VkX2JpdHNbMV0gfD0KPiAg CQkJY3B1X3RvX2xlNjQoU1RSVEFCX1NURV8xX0VBVFMgfCBTVFJUQUJfU1RFXzFfU0hDRkcpOwo+ IC0JCXVzZWRfYml0cy0+ZGF0YVsyXSB8PQo+ICsJCXVzZWRfYml0c1syXSB8PQo+ICAJCQljcHVf dG9fbGU2NChTVFJUQUJfU1RFXzJfUzJWTUlEIHwgU1RSVEFCX1NURV8yX1ZUQ1IgfAo+ICAJCQkJ ICAgIFNUUlRBQl9TVEVfMl9TMkFBNjQgfCBTVFJUQUJfU1RFXzJfUzJFTkRJIHwKPiAgCQkJCSAg ICBTVFJUQUJfU1RFXzJfUzJQVFcgfCBTVFJUQUJfU1RFXzJfUzJSKTsKPiAtCQl1c2VkX2JpdHMt PmRhdGFbM10gfD0gY3B1X3RvX2xlNjQoU1RSVEFCX1NURV8zX1MyVFRCX01BU0spOwo+ICsJCXVz ZWRfYml0c1szXSB8PSBjcHVfdG9fbGU2NChTVFJUQUJfU1RFXzNfUzJUVEJfTUFTSyk7Cj4gIAl9 Cj4gIAo+ICAJaWYgKGNmZyA9PSBTVFJUQUJfU1RFXzBfQ0ZHX0JZUEFTUykKPiAtCQl1c2VkX2Jp dHMtPmRhdGFbMV0gfD0gY3B1X3RvX2xlNjQoU1RSVEFCX1NURV8xX1NIQ0ZHKTsKPiArCQl1c2Vk X2JpdHNbMV0gfD0gY3B1X3RvX2xlNjQoU1RSVEFCX1NURV8xX1NIQ0ZHKTsKPiAgfQo+ICAKPiAg LyoKPiBAQCAtMTAyNyw1NyArMTAzOCw1NSBAQCBzdGF0aWMgdm9pZCBhcm1fc21tdV9nZXRfc3Rl X3VzZWQoY29uc3Qgc3RydWN0IGFybV9zbW11X3N0ZSAqZW50LAo+ICAgKiB1bnVzZWRfdXBkYXRl IGlzIGFuIGludGVybWVkaWF0ZSB2YWx1ZSBvZiBlbnRyeSB0aGF0IGhhcyB1bnVzZWQgYml0cyBz ZXQgdG8KPiAgICogdGhlaXIgbmV3IHZhbHVlcy4KPiAgICovCj4gLXN0YXRpYyB1OCBhcm1fc21t dV9lbnRyeV9xd29yZF9kaWZmKGNvbnN0IHN0cnVjdCBhcm1fc21tdV9zdGUgKmVudHJ5LAo+IC0J CQkJICAgIGNvbnN0IHN0cnVjdCBhcm1fc21tdV9zdGUgKnRhcmdldCwKPiAtCQkJCSAgICBzdHJ1 Y3QgYXJtX3NtbXVfc3RlICp1bnVzZWRfdXBkYXRlKQo+ICtzdGF0aWMgdTggYXJtX3NtbXVfZW50 cnlfcXdvcmRfZGlmZihzdHJ1Y3QgYXJtX3NtbXVfZW50cnlfd3JpdGVyICp3cml0ZXIsCj4gKwkJ CQkgICAgY29uc3QgX19sZTY0ICplbnRyeSwgY29uc3QgX19sZTY0ICp0YXJnZXQsCj4gKwkJCQkg ICAgX19sZTY0ICp1bnVzZWRfdXBkYXRlKQo+ICB7Cj4gLQlzdHJ1Y3QgYXJtX3NtbXVfc3RlIHRh cmdldF91c2VkID0ge307Cj4gLQlzdHJ1Y3QgYXJtX3NtbXVfc3RlIGN1cl91c2VkID0ge307Cj4g KwlfX2xlNjQgdGFyZ2V0X3VzZWRbTlVNX0VOVFJZX1FXT1JEU10gPSB7fTsKPiArCV9fbGU2NCBj dXJfdXNlZFtOVU1fRU5UUllfUVdPUkRTXSA9IHt9OwpUaGlzIGlzIGNvbmZ1c2luZyB0byBtZSwg dGhlIGZ1bmN0aW9uIHdhcyBtb2RpZmllZCB0byBiZSBnZW5lcmljLCBzbyBpdHMgaGFzCmFyZ3Mg YXJlIF9fbGU2NCAqIGluc3RlYWQgb2Ygc3RydWN0IGFybV9zbW11X3N0ZSAqLgpCdXQgTlVNX0VO VFJZX1FXT1JEUyBpcyBkZWZpbmVkIGFzIOKAnChzaXplb2Yoc3RydWN0IGFybV9zbW11X3N0ZSkg LyBzaXplb2YodTY0KSnigJ0KYW5kIGluIHRoZSBzYW1lIGZ1bmN0aW9uIHdyaXRlci0+b3BzLT5u dW1fZW50cnlfcXdvcmRzIGlzIHVzZWQgbnRlcmNoYW5nZWFibHksCkkgdW5kZXJzdGFuZCB0aGF0 IHRoaXMgbm90IGEgY29uc3RhbnQgYW5kIHRoZSBjb21waWxlciB3b3VsZCBjb21wbGFpbi4KQnV0 IHNpbmNlIGZvciBhbnkgb3RoZXIgbnVtX2VudHJ5X3F3b3JkcyBsYXJnZXIgdGhhbiBOVU1fRU5U UllfUVdPUkRTIGl0IGZhaWxzLAphbmQgd2Uga25vdyBTVEVzIGFuZCBDRHMgYm90aCBoYXZlIHRo ZSBzYW1lIHNpemUsIHdlIHNpbXBsaWZ5IHRoZSBjb2RlIGFuZCBtYWtlCml0IGEgY29uc3RhbnQg ZXZlcnl3aGVyZS4KCkkgc2VlIGluIHRoZSBuZXh0IHBhdGNoLCB0aGF0IHRoaXMgaXMgcmVkZWZp bmVkIHRvIGJlIHRoZSBtYXggYmV0d2VlbiBTVEUgYW5kCkNELCBidXQgYWdhaW4sIHRoaXMgaGFy ZHdhcmUgYW5kIGl0IG5ldmVyIGNoYW5nZXMsIHNvIG15IG9waW5pb24gaXMgdG8gc2ltcGxpZnkK dGhlIGNvZGUsIGFzIHRoZXJlIGlzIG5vIG5lZWQgdG8gZ2VuZXJhbGl6ZSB0aGlzIHBhcnQuCgo+ ICAJdTggdXNlZF9xd29yZF9kaWZmID0gMDsKPiAgCXVuc2lnbmVkIGludCBpOwo+ICAKPiAtCWFy bV9zbW11X2dldF9zdGVfdXNlZChlbnRyeSwgJmN1cl91c2VkKTsKPiAtCWFybV9zbW11X2dldF9z dGVfdXNlZCh0YXJnZXQsICZ0YXJnZXRfdXNlZCk7Cj4gKwl3cml0ZXItPm9wcy0+Z2V0X3VzZWQo ZW50cnksIGN1cl91c2VkKTsKPiArCXdyaXRlci0+b3BzLT5nZXRfdXNlZCh0YXJnZXQsIHRhcmdl dF91c2VkKTsKPiAgCj4gLQlmb3IgKGkgPSAwOyBpICE9IEFSUkFZX1NJWkUodGFyZ2V0X3VzZWQu ZGF0YSk7IGkrKykgewo+ICsJZm9yIChpID0gMDsgaSAhPSB3cml0ZXItPm9wcy0+bnVtX2VudHJ5 X3F3b3JkczsgaSsrKSB7Cj4gIAkJLyoKPiAgCQkgKiBDaGVjayB0aGF0IG1hc2tzIGFyZSB1cCB0 byBkYXRlLCB0aGUgbWFrZSBmdW5jdGlvbnMgYXJlIG5vdAo+ICAJCSAqIGFsbG93ZWQgdG8gc2V0 IGEgYml0IHRvIDEgaWYgdGhlIHVzZWQgZnVuY3Rpb24gZG9lc24ndCBzYXkgaXQKPiAgCQkgKiBp cyB1c2VkLgo+ICAJCSAqLwo+IC0JCVdBUk5fT05fT05DRSh0YXJnZXQtPmRhdGFbaV0gJiB+dGFy Z2V0X3VzZWQuZGF0YVtpXSk7Cj4gKwkJV0FSTl9PTl9PTkNFKHRhcmdldFtpXSAmIH50YXJnZXRf dXNlZFtpXSk7Cj4gIAo+ICAJCS8qIEJpdHMgY2FuIGNoYW5nZSBiZWNhdXNlIHRoZXkgYXJlIG5v dCBjdXJyZW50bHkgYmVpbmcgdXNlZCAqLwo+IC0JCXVudXNlZF91cGRhdGUtPmRhdGFbaV0gPSAo ZW50cnktPmRhdGFbaV0gJiBjdXJfdXNlZC5kYXRhW2ldKSB8Cj4gLQkJCQkJICh0YXJnZXQtPmRh dGFbaV0gJiB+Y3VyX3VzZWQuZGF0YVtpXSk7Cj4gKwkJdW51c2VkX3VwZGF0ZVtpXSA9IChlbnRy eVtpXSAmIGN1cl91c2VkW2ldKSB8Cj4gKwkJCQkgICAodGFyZ2V0W2ldICYgfmN1cl91c2VkW2ld KTsKPiAgCQkvKgo+ICAJCSAqIEVhY2ggYml0IGluZGljYXRlcyB0aGF0IGEgdXNlZCBiaXQgaW4g YSBxd29yZCBuZWVkcyB0byBiZQo+ICAJCSAqIGNoYW5nZWQgYWZ0ZXIgdW51c2VkX3VwZGF0ZSBp cyBhcHBsaWVkLgo+ICAJCSAqLwo+IC0JCWlmICgodW51c2VkX3VwZGF0ZS0+ZGF0YVtpXSAmIHRh cmdldF91c2VkLmRhdGFbaV0pICE9Cj4gLQkJICAgIHRhcmdldC0+ZGF0YVtpXSkKPiArCQlpZiAo KHVudXNlZF91cGRhdGVbaV0gJiB0YXJnZXRfdXNlZFtpXSkgIT0gdGFyZ2V0W2ldKQo+ICAJCQl1 c2VkX3F3b3JkX2RpZmYgfD0gMSA8PCBpOwo+ICAJfQo+ICAJcmV0dXJuIHVzZWRfcXdvcmRfZGlm ZjsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgZW50cnlfc2V0KHN0cnVjdCBhcm1fc21tdV9kZXZp Y2UgKnNtbXUsIGlvYXNpZF90IHNpZCwKPiAtCQkgICAgICBzdHJ1Y3QgYXJtX3NtbXVfc3RlICpl bnRyeSwKPiAtCQkgICAgICBjb25zdCBzdHJ1Y3QgYXJtX3NtbXVfc3RlICp0YXJnZXQsIHVuc2ln bmVkIGludCBzdGFydCwKPiArc3RhdGljIGJvb2wgZW50cnlfc2V0KHN0cnVjdCBhcm1fc21tdV9l bnRyeV93cml0ZXIgKndyaXRlciwgX19sZTY0ICplbnRyeSwKPiArCQkgICAgICBjb25zdCBfX2xl NjQgKnRhcmdldCwgdW5zaWduZWQgaW50IHN0YXJ0LAo+ICAJCSAgICAgIHVuc2lnbmVkIGludCBs ZW4pCj4gIHsKPiAgCWJvb2wgY2hhbmdlZCA9IGZhbHNlOwo+ICAJdW5zaWduZWQgaW50IGk7Cj4g IAo+ICAJZm9yIChpID0gc3RhcnQ7IGxlbiAhPSAwOyBsZW4tLSwgaSsrKSB7Cj4gLQkJaWYgKGVu dHJ5LT5kYXRhW2ldICE9IHRhcmdldC0+ZGF0YVtpXSkgewo+IC0JCQlXUklURV9PTkNFKGVudHJ5 LT5kYXRhW2ldLCB0YXJnZXQtPmRhdGFbaV0pOwo+ICsJCWlmIChlbnRyeVtpXSAhPSB0YXJnZXRb aV0pIHsKPiArCQkJV1JJVEVfT05DRShlbnRyeVtpXSwgdGFyZ2V0W2ldKTsKPiAgCQkJY2hhbmdl ZCA9IHRydWU7Cj4gIAkJfQo+ICAJfQo+ICAKPiAgCWlmIChjaGFuZ2VkKQo+IC0JCWFybV9zbW11 X3N5bmNfc3RlX2Zvcl9zaWQoc21tdSwgc2lkKTsKPiArCQl3cml0ZXItPm9wcy0+c3luYyh3cml0 ZXIpOwo+ICAJcmV0dXJuIGNoYW5nZWQ7Cj4gIH0KPiAgCj4gQEAgLTExMDcsMTcgKzExMTYsMTUg QEAgc3RhdGljIGJvb2wgZW50cnlfc2V0KHN0cnVjdCBhcm1fc21tdV9kZXZpY2UgKnNtbXUsIGlv YXNpZF90IHNpZCwKPiAgICogVj0wIHByb2Nlc3MuIFRoaXMgcmVsaWVzIG9uIHRoZSBJR05PUkVE IGJlaGF2aW9yIGRlc2NyaWJlZCBpbiB0aGUKPiAgICogc3BlY2lmaWNhdGlvbi4KPiAgICovCj4g LXN0YXRpYyB2b2lkIGFybV9zbW11X3dyaXRlX3N0ZShzdHJ1Y3QgYXJtX3NtbXVfbWFzdGVyICpt YXN0ZXIsIHUzMiBzaWQsCj4gLQkJCSAgICAgICBzdHJ1Y3QgYXJtX3NtbXVfc3RlICplbnRyeSwK PiAtCQkJICAgICAgIGNvbnN0IHN0cnVjdCBhcm1fc21tdV9zdGUgKnRhcmdldCkKPiArc3RhdGlj IHZvaWQgYXJtX3NtbXVfd3JpdGVfZW50cnkoc3RydWN0IGFybV9zbW11X2VudHJ5X3dyaXRlciAq d3JpdGVyLAo+ICsJCQkJIF9fbGU2NCAqZW50cnksIGNvbnN0IF9fbGU2NCAqdGFyZ2V0KQo+ICB7 Cj4gLQl1bnNpZ25lZCBpbnQgbnVtX2VudHJ5X3F3b3JkcyA9IEFSUkFZX1NJWkUodGFyZ2V0LT5k YXRhKTsKPiAtCXN0cnVjdCBhcm1fc21tdV9kZXZpY2UgKnNtbXUgPSBtYXN0ZXItPnNtbXU7Cj4g LQlzdHJ1Y3QgYXJtX3NtbXVfc3RlIHVudXNlZF91cGRhdGU7Cj4gKwl1bnNpZ25lZCBpbnQgbnVt X2VudHJ5X3F3b3JkcyA9IHdyaXRlci0+b3BzLT5udW1fZW50cnlfcXdvcmRzOwo+ICsJX19sZTY0 IHVudXNlZF91cGRhdGVbTlVNX0VOVFJZX1FXT1JEU107Cj4gIAl1OCB1c2VkX3F3b3JkX2RpZmY7 Cj4gIAo+ICAJdXNlZF9xd29yZF9kaWZmID0KPiAtCQlhcm1fc21tdV9lbnRyeV9xd29yZF9kaWZm KGVudHJ5LCB0YXJnZXQsICZ1bnVzZWRfdXBkYXRlKTsKPiArCQlhcm1fc21tdV9lbnRyeV9xd29y ZF9kaWZmKHdyaXRlciwgZW50cnksIHRhcmdldCwgdW51c2VkX3VwZGF0ZSk7Cj4gIAlpZiAoaHdl aWdodDgodXNlZF9xd29yZF9kaWZmKSA9PSAxKSB7Cj4gIAkJLyoKPiAgCQkgKiBPbmx5IG9uZSBx d29yZCBuZWVkcyBpdHMgdXNlZCBiaXRzIHRvIGJlIGNoYW5nZWQuIFRoaXMgaXMgYQo+IEBAIC0x MTMzLDIyICsxMTQwLDIxIEBAIHN0YXRpYyB2b2lkIGFybV9zbW11X3dyaXRlX3N0ZShzdHJ1Y3Qg YXJtX3NtbXVfbWFzdGVyICptYXN0ZXIsIHUzMiBzaWQsCj4gIAkJICogd3JpdGluZyBpdCBpbiB0 aGUgbmV4dCBzdGVwIGFueXdheXMuIFRoaXMgY2FuIHNhdmUgYSBzeW5jCj4gIAkJICogd2hlbiB0 aGUgb25seSBjaGFuZ2UgaXMgaW4gdGhhdCBxd29yZC4KPiAgCQkgKi8KPiAtCQl1bnVzZWRfdXBk YXRlLmRhdGFbY3JpdGljYWxfcXdvcmRfaW5kZXhdID0KPiAtCQkJZW50cnktPmRhdGFbY3JpdGlj YWxfcXdvcmRfaW5kZXhdOwo+IC0JCWVudHJ5X3NldChzbW11LCBzaWQsIGVudHJ5LCAmdW51c2Vk X3VwZGF0ZSwgMCwgbnVtX2VudHJ5X3F3b3Jkcyk7Cj4gLQkJZW50cnlfc2V0KHNtbXUsIHNpZCwg ZW50cnksIHRhcmdldCwgY3JpdGljYWxfcXdvcmRfaW5kZXgsIDEpOwo+IC0JCWVudHJ5X3NldChz bW11LCBzaWQsIGVudHJ5LCB0YXJnZXQsIDAsIG51bV9lbnRyeV9xd29yZHMpOwo+ICsJCXVudXNl ZF91cGRhdGVbY3JpdGljYWxfcXdvcmRfaW5kZXhdID0KPiArCQkJZW50cnlbY3JpdGljYWxfcXdv cmRfaW5kZXhdOwo+ICsJCWVudHJ5X3NldCh3cml0ZXIsIGVudHJ5LCB1bnVzZWRfdXBkYXRlLCAw LCBudW1fZW50cnlfcXdvcmRzKTsKPiArCQllbnRyeV9zZXQod3JpdGVyLCBlbnRyeSwgdGFyZ2V0 LCBjcml0aWNhbF9xd29yZF9pbmRleCwgMSk7Cj4gKwkJZW50cnlfc2V0KHdyaXRlciwgZW50cnks IHRhcmdldCwgMCwgbnVtX2VudHJ5X3F3b3Jkcyk7Cj4gIAl9IGVsc2UgaWYgKHVzZWRfcXdvcmRf ZGlmZikgewo+ICAJCS8qCj4gIAkJICogQXQgbGVhc3QgdHdvIHF3b3JkcyBuZWVkIHRoZWlyIGlu dXNlIGJpdHMgdG8gYmUgY2hhbmdlZC4gVGhpcwo+ICAJCSAqIHJlcXVpcmVzIGEgYnJlYWtpbmcg dXBkYXRlLCB6ZXJvIHRoZSBWIGJpdCwgd3JpdGUgYWxsIHF3b3Jkcwo+ICAJCSAqIGJ1dCAwLCB0 aGVuIHNldCBxd29yZCAwCj4gIAkJICovCj4gLQkJdW51c2VkX3VwZGF0ZS5kYXRhWzBdID0gZW50 cnktPmRhdGFbMF0gJgo+IC0JCQkJCWNwdV90b19sZTY0KH5TVFJUQUJfU1RFXzBfVik7Cj4gLQkJ ZW50cnlfc2V0KHNtbXUsIHNpZCwgZW50cnksICZ1bnVzZWRfdXBkYXRlLCAwLCAxKTsKPiAtCQll bnRyeV9zZXQoc21tdSwgc2lkLCBlbnRyeSwgdGFyZ2V0LCAxLCBudW1fZW50cnlfcXdvcmRzIC0g MSk7Cj4gLQkJZW50cnlfc2V0KHNtbXUsIHNpZCwgZW50cnksIHRhcmdldCwgMCwgMSk7Cj4gKwkJ dW51c2VkX3VwZGF0ZVswXSA9IGVudHJ5WzBdICYgKH53cml0ZXItPm9wcy0+dl9iaXQpOwo+ICsJ CWVudHJ5X3NldCh3cml0ZXIsIGVudHJ5LCB1bnVzZWRfdXBkYXRlLCAwLCAxKTsKPiArCQllbnRy eV9zZXQod3JpdGVyLCBlbnRyeSwgdGFyZ2V0LCAxLCBudW1fZW50cnlfcXdvcmRzIC0gMSk7Cj4g KwkJZW50cnlfc2V0KHdyaXRlciwgZW50cnksIHRhcmdldCwgMCwgMSk7Cj4gIAl9IGVsc2Ugewo+ ICAJCS8qCj4gIAkJICogTm8gaW51c2UgYml0IGNoYW5nZWQuIFNhbml0eSBjaGVjayB0aGF0IGFs bCB1bnVzZWQgYml0cyBhcmUgMAo+IEBAIC0xMTU2LDE4ICsxMTYyLDcgQEAgc3RhdGljIHZvaWQg YXJtX3NtbXVfd3JpdGVfc3RlKHN0cnVjdCBhcm1fc21tdV9tYXN0ZXIgKm1hc3RlciwgdTMyIHNp ZCwKPiAgCQkgKiBjb21wdXRlX3F3b3JkX2RpZmYoKS4KPiAgCQkgKi8KPiAgCQlXQVJOX09OX09O Q0UoCj4gLQkJCWVudHJ5X3NldChzbW11LCBzaWQsIGVudHJ5LCB0YXJnZXQsIDAsIG51bV9lbnRy eV9xd29yZHMpKTsKPiAtCX0KPiAtCj4gLQkvKiBJdCdzIGxpa2VseSB0aGF0IHdlJ2xsIHdhbnQg dG8gdXNlIHRoZSBuZXcgU1RFIHNvb24gKi8KPiAtCWlmICghKHNtbXUtPm9wdGlvbnMgJiBBUk1f U01NVV9PUFRfU0tJUF9QUkVGRVRDSCkpIHsKPiAtCQlzdHJ1Y3QgYXJtX3NtbXVfY21kcV9lbnQK PiAtCQkJcHJlZmV0Y2hfY21kID0geyAub3Bjb2RlID0gQ01EUV9PUF9QUkVGRVRDSF9DRkcsCj4g LQkJCQkJIC5wcmVmZXRjaCA9IHsKPiAtCQkJCQkJIC5zaWQgPSBzaWQsCj4gLQkJCQkJIH0gfTsK PiAtCj4gLQkJYXJtX3NtbXVfY21kcV9pc3N1ZV9jbWQoc21tdSwgJnByZWZldGNoX2NtZCk7Cj4g KwkJCWVudHJ5X3NldCh3cml0ZXIsIGVudHJ5LCB0YXJnZXQsIDAsIG51bV9lbnRyeV9xd29yZHMp KTsKPiAgCX0KPiAgfQo+ICAKPiBAQCAtMTQ0MCwxNyArMTQzNSw1OCBAQCBhcm1fc21tdV93cml0 ZV9zdHJ0YWJfbDFfZGVzYyhfX2xlNjQgKmRzdCwgc3RydWN0IGFybV9zbW11X3N0cnRhYl9sMV9k ZXNjICpkZXNjKQo+ICAJV1JJVEVfT05DRSgqZHN0LCBjcHVfdG9fbGU2NCh2YWwpKTsKPiAgfQo+ ICAKPiAtc3RhdGljIHZvaWQgYXJtX3NtbXVfc3luY19zdGVfZm9yX3NpZChzdHJ1Y3QgYXJtX3Nt bXVfZGV2aWNlICpzbW11LCB1MzIgc2lkKQo+ICtzdHJ1Y3QgYXJtX3NtbXVfc3RlX3dyaXRlciB7 Cj4gKwlzdHJ1Y3QgYXJtX3NtbXVfZW50cnlfd3JpdGVyIHdyaXRlcjsKPiArCXUzMiBzaWQ7Cj4g K307Cj4gKwo+ICtzdGF0aWMgdm9pZCBhcm1fc21tdV9zdGVfd3JpdGVyX3N5bmNfZW50cnkoc3Ry dWN0IGFybV9zbW11X2VudHJ5X3dyaXRlciAqd3JpdGVyKQo+ICB7Cj4gKwlzdHJ1Y3QgYXJtX3Nt bXVfc3RlX3dyaXRlciAqc3RlX3dyaXRlciA9Cj4gKwkJY29udGFpbmVyX29mKHdyaXRlciwgc3Ry dWN0IGFybV9zbW11X3N0ZV93cml0ZXIsIHdyaXRlcik7Cj4gIAlzdHJ1Y3QgYXJtX3NtbXVfY21k cV9lbnQgY21kID0gewo+ICAJCS5vcGNvZGUJPSBDTURRX09QX0NGR0lfU1RFLAo+ICAJCS5jZmdp CT0gewo+IC0JCQkuc2lkCT0gc2lkLAo+ICsJCQkuc2lkCT0gc3RlX3dyaXRlci0+c2lkLAo+ICAJ CQkubGVhZgk9IHRydWUsCj4gIAkJfSwKPiAgCX07Cj4gIAo+IC0JYXJtX3NtbXVfY21kcV9pc3N1 ZV9jbWRfd2l0aF9zeW5jKHNtbXUsICZjbWQpOwo+ICsJYXJtX3NtbXVfY21kcV9pc3N1ZV9jbWRf d2l0aF9zeW5jKHdyaXRlci0+bWFzdGVyLT5zbW11LCAmY21kKTsKPiArfQo+ICsKPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBhcm1fc21tdV9lbnRyeV93cml0ZXJfb3BzIGFybV9zbW11X3N0ZV93cml0 ZXJfb3BzID0gewo+ICsJLnN5bmMgPSBhcm1fc21tdV9zdGVfd3JpdGVyX3N5bmNfZW50cnksCj4g KwkuZ2V0X3VzZWQgPSBhcm1fc21tdV9nZXRfc3RlX3VzZWQsCj4gKwkudl9iaXQgPSBjcHVfdG9f bGU2NChTVFJUQUJfU1RFXzBfViksCj4gKwkubnVtX2VudHJ5X3F3b3JkcyA9IHNpemVvZihzdHJ1 Y3QgYXJtX3NtbXVfc3RlKSAvIHNpemVvZih1NjQpLAo+ICt9Owo+ICsKPiArc3RhdGljIHZvaWQg YXJtX3NtbXVfd3JpdGVfc3RlKHN0cnVjdCBhcm1fc21tdV9tYXN0ZXIgKm1hc3RlciwgdTMyIHNp ZCwKPiArCQkJICAgICAgIHN0cnVjdCBhcm1fc21tdV9zdGUgKnN0ZSwKPiArCQkJICAgICAgIGNv bnN0IHN0cnVjdCBhcm1fc21tdV9zdGUgKnRhcmdldCkKPiArewo+ICsJc3RydWN0IGFybV9zbW11 X2RldmljZSAqc21tdSA9IG1hc3Rlci0+c21tdTsKPiArCXN0cnVjdCBhcm1fc21tdV9zdGVfd3Jp dGVyIHN0ZV93cml0ZXIgPSB7Cj4gKwkJLndyaXRlciA9IHsKPiArCQkJLm9wcyA9ICZhcm1fc21t dV9zdGVfd3JpdGVyX29wcywKPiArCQkJLm1hc3RlciA9IG1hc3RlciwKPiArCQl9LAo+ICsJCS5z aWQgPSBzaWQsCj4gKwl9Owo+ICsKPiArCWFybV9zbW11X3dyaXRlX2VudHJ5KCZzdGVfd3JpdGVy LndyaXRlciwgc3RlLT5kYXRhLCB0YXJnZXQtPmRhdGEpOwo+ICsKPiArCS8qIEl0J3MgbGlrZWx5 IHRoYXQgd2UnbGwgd2FudCB0byB1c2UgdGhlIG5ldyBTVEUgc29vbiAqLwo+ICsJaWYgKCEoc21t dS0+b3B0aW9ucyAmIEFSTV9TTU1VX09QVF9TS0lQX1BSRUZFVENIKSkgewo+ICsJCXN0cnVjdCBh cm1fc21tdV9jbWRxX2VudAo+ICsJCQlwcmVmZXRjaF9jbWQgPSB7IC5vcGNvZGUgPSBDTURRX09Q X1BSRUZFVENIX0NGRywKPiArCQkJCQkgLnByZWZldGNoID0gewo+ICsJCQkJCQkgLnNpZCA9IHNp ZCwKPiArCQkJCQkgfSB9Owo+ICsKPiArCQlhcm1fc21tdV9jbWRxX2lzc3VlX2NtZChzbW11LCAm cHJlZmV0Y2hfY21kKTsKPiArCX0KPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQgYXJtX3NtbXVfbWFr ZV9hYm9ydF9zdGUoc3RydWN0IGFybV9zbW11X3N0ZSAqdGFyZ2V0KQo+IC0tIAo+IDIuNDMuMgo+ ClRoYW5rcywKTW9zdGFmYQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBs aXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlz dGluZm8vbGludXgtYXJtLWtlcm5lbAo=