From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-qt1-f178.google.com (mail-qt1-f178.google.com [209.85.160.178]) (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 CB93329C327 for ; Tue, 30 Jun 2026 23:55:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=pass smtp.client-ip=209.85.160.178 ARC-Seal:i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1782863754; cv=pass; b=WdnPRasKngt4oj/G23l//Hlz3JCa+ywK1KUkFz0Ug68AUj1si+YhEPaY5c7yfQxNPgx2g8cOSxnupcBwRkbVZHLe5ecgGjuCOYndhGxZNKjzY7jkoZ6oUce/ngi24hp1yX8FWdh4hZjLEkn0nQlbTdhf9aQ2Y7XxHcrw48ESKEo= ARC-Message-Signature:i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1782863754; c=relaxed/simple; bh=DJmfBCBTKzJSuwbBBx6CKWIfnQXDzqpsWdDCdaVFVOI=; h=MIME-Version:References:In-Reply-To:From:Date:Message-ID:Subject: To:Cc:Content-Type; b=KxxMK0v6V/rAZJwysCmZaPLFfBcqTmkyOaF8abzvji4FrtQ66FT22f7XopsDA8cb133GpsP2rlpS3lOsoY5TrDIGqF3wM5QaEjGzIjCkmhIWHmQpMCm9SdtND7sDHmOyPJ/9xA22lAZmrhZwkI0+iC9NAg7Bage/q7NCqFvl/gU= ARC-Authentication-Results:i=2; 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=Ndsbl7Lv; arc=pass smtp.client-ip=209.85.160.178 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="Ndsbl7Lv" Received: by mail-qt1-f178.google.com with SMTP id d75a77b69052e-51c10ed63c0so57521cf.1 for ; Tue, 30 Jun 2026 16:55:52 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1782863752; cv=none; d=google.com; s=arc-20260327; b=FKn3yJSVE+LhBtOcZI4aYIuYyVkqfRVOb9wX6d135MkS4eLK7lksapsR6v0r5IWah3 vlbj/Hi3GD/RZxSl/CwBXJOc4ivv/TerXU7zQh7QcJWcpx73liZbq4bDMyvuMfWey8do pnniSvBFqbSxr40kUm8Sv0i5GuYE5+H9oMz+8+Apx/arO+J9oWLgrfT8+GWkGOQ4I2vS N73Szuw5nDzWyB5fuKPe+LrKgz1FbS5FYU5238CEgwWOqZWYNIUWgJzmx0LyKRvjqH0t kOqbSyccfEjqRbezHdmeBD7dxuJgHPtrfNGjxKUhhqe64jXwl7A5JGXI1mqzuwvSeAvw 6fFQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20260327; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=NYGFmPNTsPWcLLLz5II6AmDWi4dt4jx8f/C1sSPaA9c=; fh=9Z6PsEcSsITnkcusfHGRBnmalIk1GPPgjzvQ3kz1qlk=; b=RVzVZHl3a1yaA48T6Qgh4lKbeGoLqhNQ861egZJAkEIh+0nDlaZclwinR/aLisKu/D CtELlzcMI18n+UlObXQRtOOpkgl2FHCi0PWuKfzGdJ4E3OSDCKKXTQY2sw2xp8KYp+SX rLFXdF/wN9D41fzwR7cwgqryfRfuKP7eXsau3VZxg6KM6K8dnehGenE070RYyW1HP5ST sCgVSehF0ayerb68FZ2VKy79lHb9aiwbBLu8SfxEJUhIZSzl+Rpfxv32uZ7v/xPp//g0 LwaHZkrufsNNd1KaHGjYZK0JPCA4QOTFOBP06sE9ra9xCYWwSNvDm8GcswL371r0TwzN xcHQ==; darn=vger.kernel.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1782863752; x=1783468552; darn=vger.kernel.org; h=content-type:cc:to:subject:message-id:date:from:in-reply-to :references:mime-version:from:to:cc:subject:date:message-id:reply-to :content-type; bh=NYGFmPNTsPWcLLLz5II6AmDWi4dt4jx8f/C1sSPaA9c=; b=Ndsbl7LvbpKB9rCbi21XVg7f/CPjGGRn8OLZPpG1jr4FWOFYbqYDkV9PWisjPq5YNF aePFgJ8n1IVB7yq9TwnfylZPzuvxbOIOokA5i92voahbiB6Ga+r+JrnEw8eD/QUriSO1 FaA6mxI1gXzaZ4888s6uIz5kVXke0wojo4m3wYjdR421hsA7kCgbV+n/n4+bhk3dOWAz us/UOhWzS6hrebNud8Bm9w5pctd14K14BjKRLNBNVmqsVhZlwKJgvwev+n1PxcHNry9F epAzOifeL3fX9b+1RSgF9aVEn+vgoVzO8MFCXobQMmqJBKU59YhPehrWv88ObGeRD/Ys Crlg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1782863752; x=1783468552; h=content-type:cc:to:subject:message-id:date:from:in-reply-to :references:mime-version:x-gm-gg:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to:content-type; bh=NYGFmPNTsPWcLLLz5II6AmDWi4dt4jx8f/C1sSPaA9c=; b=OBOosY2XiZpiKK7PtQ7EfUhrcYBlmqZuTPHuT9085CYgXiRNR1YzFxm6t3hbTdRh62 l4XxB+uN632RBdveQoTCSFCX4C1AVcRIqM1AvvXQxrAnDtw9G5DRf0Snk7bxM3CK7NoQ htHFNCZnUowzWRKcRHvNgKVUanSnwHRAXXMFoOgYbM6GtivR0GVVigLBKZsY4uUCxkTD EKAJk55yMY3LYK/93nb2h+wn0K0elOxe/3OGuw3XlouNSOXRMkegWCzJ5yydom924jJ5 Kg7ddRQAVBIO1ae4ar0ndPp2JyvuBtyz9emN+RIKGxxJkeiN/8bGJZXlgW7BFH6PZDL+ eIJA== X-Forwarded-Encrypted: i=1; AFNElJ/Rr1wzK0oqKo7OnxixGJddkRqIErHkNKB7AQpoSUSP9T3lkRnxjI6VxjynyzAeCPxOAXMHK89NgF2oe8M=@vger.kernel.org X-Gm-Message-State: AOJu0Yzudi72byqGHcQrMZil7/maAz379Zum6zpiQZ3USPhPNbfb1BsG TzpECKmFKLtbulnwic4BDb5tjQC4zmt+ijCV2Pzvge+m8tVGsc4+y4V/rt90syv5I0QN6GqGzLb F00BhgS4AtIFhQGsKU6lUB9HdJUkX1kttUt3IV+BD X-Gm-Gg: AfdE7cmhiKkj13gZnuuyYaY6VKRqDIjVyzYmX45IBx71XkS84BX1drq2R8rN5BUvbN6 Wgce/pAnmr9g4g9A5PIl1yWSkfdf3YawsLc5wOA5h1MvkO6bK+YzQ8vwWy0PGveZn1tLCUIkR8t N6q031d7raWCspJeIPF1T5553X8KUbFe39eYzYw87cW1RKHJyU0QhrIRAxEqvVSKufK0lr01CAe ajeJU2PrdNgyW6U0S8mqJOKAkd5e4sBUkTlq50Q0RO2nONsCgPerAOjUJsZhHa2NVUZ/Kc= X-Received: by 2002:a05:622a:90e:b0:510:f9b:fb5f with SMTP id d75a77b69052e-51c2177d19emr3298091cf.16.1782863751090; Tue, 30 Jun 2026 16:55:51 -0700 (PDT) Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 References: <62969830-4b1f-483d-8fa9-9ce487568570@kernel.org> <39a79576-dcae-4b66-9478-c81dfe676699@kernel.org> <5ebd3c4a-5c06-43b4-ab0a-7a8f0396c84c@kernel.org> In-Reply-To: From: Suren Baghdasaryan Date: Tue, 30 Jun 2026 16:55:39 -0700 X-Gm-Features: AVVi8CdklnwzRzdYqHyHST7ySa2NDDxRnhvnohjju3D2dp_nAGbZREeoJzxw4qk Message-ID: Subject: Re: [PATCH] mm/slub: serve slabobj_ext array from a strictly larger kmalloc cache To: Harry Yoo Cc: Shakeel Butt , "Vlastimil Babka (SUSE)" , Andrew Morton , Roman Gushchin , Hao Li , Christoph Lameter , David Rientjes , Usama Arif , Meta kernel team , linux-mm@kvack.org, linux-kernel@vger.kernel.org, Danielle Costantino , Kees Cook Content-Type: multipart/mixed; boundary="000000000000925b27065581508b" --000000000000925b27065581508b Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Tue, Jun 30, 2026 at 8:27=E2=80=AFAM Harry Yoo wrote: > > > > On 6/30/26 11:52 PM, Suren Baghdasaryan wrote: > > On Tue, Jun 30, 2026 at 7:36=E2=80=AFAM Shakeel Butt wrote: > >> > >> On Tue, Jun 30, 2026 at 04:03:30PM +0900, Harry Yoo wrote: > >>> > >>> > >>> On 6/30/26 3:12 PM, Vlastimil Babka (SUSE) wrote: > >>>> On 6/30/26 07:29, Suren Baghdasaryan wrote: > >>>>> On Mon, Jun 29, 2026 at 9:42=E2=80=AFPM Harry Yoo wrote: > >>>>>> > >>>>>> > >>>>>> > >>>>>> On 6/30/26 1:39 PM, Suren Baghdasaryan wrote: > >>>>>>> On Mon, Jun 29, 2026 at 9:38=E2=80=AFPM Suren Baghdasaryan wrote: > >>>>>>>> > >>>>>> > >>>>>> Ah, here I meant backporting either the kmalloc_flags()+KMALLOC_TY= PE or > >>>>>> SLAB_BUCKETS approach. > >>>>>> > >>>>>>>> Yes, it's worth backporting, so we can merge Shakeel's change as= is > >>>>>> > >>>>>> Right. > >>>>>> > >>>>>>>> and then once Vlastimil's patch is merged we can implement the n= ew > >>>>>> > >>>>>> Vlastimil's patch has already landed mainline, by the way :) > >>>>> > >>>>> Nice! I suggest posting Shakeel's patch CC'ing stable for backports > >>>>> and then following up with the fix using KMALLOC_TYPE. Vlastimil, > >>>>> WDYT? > >>>> > >>>> Sounded like a plan, but then I realized I misunderstood the amount = of the > >>>> wastage. E.g. on my system kmalloc-8k with 4 objects per slab would = have > >>>> obj_ext size of 64, but now it's 16k? That's ridiculous. > >>> > >>> Right. > >> > >> Yeah I should have given more thought on wastage. > > > > Ugh! I didn't realize the wastage was that high. > > Ouch! > > >>> ...which is why I was assuming either the KMALLOC_TYPE or SLAB_BUCKET= S > >>> approach would be backported as a follow-up. Err, should have > >>> communicated clearly, apologies. > >> > >> Harry, do you want to take a stab at prototyping these? If these look = simple > >> enough, we can request backports of this. > > Ack, let's see what would be the minimal changes to resolve this. > > > I'll also give it some thought to see if there is maybe a different > > way to fix this that would be easy to backport. > > Thanks, let's discuss! So, below patch is based on stable linux-7.1.y branch and I think it's the simplest backportable way to fix this issue. Build-tested only, so use just as a prototype. Not sure if making buckets parameter unconditional from CONFIG_SLAB_BUCKETS has side-effects... Attaching the patch as well since I'm sure gmail will butcher the tabs. The fix for 7.2 should be much simpler using a new flag in kmalloc_flags() for obj_ext vector allocations and serving these from a dedicated cache. Please let me know what you think: --- include/linux/slab.h | 42 +++++++++++++++++++++--------- mm/slub.c | 61 +++++++++++--------------------------------- 2 files changed, 45 insertions(+), 58 deletions(-) diff --git a/include/linux/slab.h b/include/linux/slab.h index 2b5ab488e96b..2d4a6e3064a3 100644 --- a/include/linux/slab.h +++ b/include/linux/slab.h @@ -618,6 +618,10 @@ static inline unsigned int arch_slab_minalign(void) #define RANDOM_KMALLOC_CACHES_NR 0 #endif +#if defined(CONFIG_MEM_ALLOC_PROFILING) && defined(CONFIG_SLUB_TINY) +#define OBJ_EXT_VEC_CACHE +#endif + /* * Whenever changing this, take care of that kmalloc_type() and * create_kmalloc_caches() still work as intended. @@ -646,6 +650,9 @@ enum kmalloc_cache_type { #endif #ifdef CONFIG_MEMCG KMALLOC_CGROUP, +#endif +#ifdef OBJ_EXT_VEC_CACHE + KMALLOC_OBJ_EXT_VEC, #endif NR_KMALLOC_TYPES }; @@ -654,6 +661,18 @@ typedef struct kmem_cache * kmem_buckets[KMALLOC_SHIFT_HIGH + 1]; extern kmem_buckets kmalloc_caches[NR_KMALLOC_TYPES]; +#ifdef OBJ_EXT_VEC_CACHE +static inline kmem_buckets *obj_ext_vec_buckets(void) +{ + return &kmalloc_caches[KMALLOC_OBJ_EXT_VEC]; +} +#else +static inline kmem_buckets *obj_ext_vec_buckets(void) +{ + return NULL; +} +#endif + /* * Define gfp bits that should not be set for KMALLOC_NORMAL. */ @@ -843,20 +862,10 @@ void *kmem_cache_alloc_from_sheaf_noprof(struct kmem_cache *cachep, gfp_t gfp, unsigned int kmem_cache_sheaf_size(struct slab_sheaf *sheaf); -/* - * These macros allow declaring a kmem_buckets * parameter alongside size, which - * can be compiled out with CONFIG_SLAB_BUCKETS=3Dn so that a large number of call - * sites don't have to pass NULL. - */ -#ifdef CONFIG_SLAB_BUCKETS +/* TODO: these macros should be removed in a prerequisite patch */ #define DECL_BUCKET_PARAMS(_size, _b) size_t (_size), kmem_buckets = *(_b) #define PASS_BUCKET_PARAMS(_size, _b) (_size), (_b) #define PASS_BUCKET_PARAM(_b) (_b) -#else -#define DECL_BUCKET_PARAMS(_size, _b) size_t (_size) -#define PASS_BUCKET_PARAMS(_size, _b) (_size) -#define PASS_BUCKET_PARAM(_b) NULL -#endif /* * The following functions are not to be used directly and are intended on= ly @@ -955,7 +964,13 @@ static __always_inline __alloc_size(1) void *kmalloc_noprof(size_t size, gfp_t f } #define kmalloc(...) alloc_hooks(kmalloc_noprof(__VA_ARGS__)) -void *kmalloc_nolock_noprof(size_t size, gfp_t gfp_flags, int node); +void *__kmalloc_nolock_noprof(size_t size, kmem_buckets *b, gfp_t gfp_flags, int node); +#define __kmalloc_nolock(...) alloc_hooks(__kmalloc_nolock_noprof(__VA_ARGS__)) + +static __always_inline void *kmalloc_nolock_noprof(size_t size, gfp_t gfp_flags, int node) +{ + return __kmalloc_nolock_noprof(size, NULL, gfp_flags, node); +} #define kmalloc_nolock(...) alloc_hooks(kmalloc_nolock_noprof(__VA_ARGS__)) /** @@ -1062,6 +1077,9 @@ void *kmalloc_nolock_noprof(size_t size, gfp_t gfp_flags, int node); #define kmem_buckets_alloc(_b, _size, _flags) \ alloc_hooks(__kmalloc_node_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, NUMA_NO_NODE)) +#define kmem_buckets_node_alloc(_size, _b, _flags, _node) \ + alloc_hooks(__kmalloc_node_noprof(PASS_BUCKET_PARAMS(_size, _b), _flags, _node)) + #define kmem_buckets_alloc_track_caller(_b, _size, _flags) \ alloc_hooks(__kmalloc_node_track_caller_noprof(PASS_BUCKET_PARAMS(= _size, _b), _flags, NUMA_NO_NODE, _RET_IP_)) diff --git a/mm/slub.c b/mm/slub.c index a2bf3756ca7d..c59d9ee4f4f3 100644 --- a/mm/slub.c +++ b/mm/slub.c @@ -2106,42 +2106,6 @@ static inline void init_slab_obj_exts(struct slab *s= lab) slab->obj_exts =3D 0; } -/* - * Calculate the allocation size for slabobj_ext array. - * - * When memory allocation profiling is enabled, the obj_exts array - * could be allocated from the same slab cache it's being allocated for. - * This would prevent the slab from ever being freed because it would - * always contain at least one allocated object (its own obj_exts array). - * - * To avoid this, increase the allocation size when we detect the array - * may come from the same cache, forcing it to use a different cache. - */ -static inline size_t obj_exts_alloc_size(struct kmem_cache *s, - struct slab *slab, gfp_t gfp) -{ - size_t sz =3D sizeof(struct slabobj_ext) * slab->objects; - struct kmem_cache *obj_exts_cache; - - if (sz > KMALLOC_MAX_CACHE_SIZE) - return sz; - - if (!is_kmalloc_normal(s)) - return sz; - - obj_exts_cache =3D kmalloc_slab(sz, NULL, gfp, 0); - /* - * We can't simply compare s with obj_exts_cache, because random kmalloc - * caches have multiple caches per size, selected by caller addres= s. - * Since caller address may differ between kmalloc_slab() and actu= al - * allocation, bump size when sizes are equal. - */ - if (s->object_size =3D=3D obj_exts_cache->object_size) - return obj_exts_cache->object_size + 1; - - return sz; -} - int alloc_slab_obj_exts(struct slab *slab, struct kmem_cache *s, gfp_t gfp, bool new_slab) { @@ -2156,19 +2120,23 @@ int alloc_slab_obj_exts(struct slab *slab, struct kmem_cache *s, /* Prevent recursive extension vector allocation */ gfp |=3D __GFP_NO_OBJ_EXT; - sz =3D obj_exts_alloc_size(s, slab, gfp); - + sz =3D sizeof(struct slabobj_ext) * slab->objects; /* * Note that allow_spin may be false during early boot and its * restricted GFP_BOOT_MASK. Due to kmalloc_nolock() only supporti= ng * architectures with cmpxchg16b, early obj_exts will be missing f= or * very early allocations on those. */ - if (unlikely(!allow_spin)) - vec =3D kmalloc_nolock(sz, __GFP_ZERO | __GFP_NO_OBJ_EXT, - slab_nid(slab)); - else - vec =3D kmalloc_node(sz, gfp | __GFP_ZERO, slab_nid(slab))= ; + if (unlikely(!allow_spin)) { + vec =3D __kmalloc_nolock(sz, obj_ext_vec_buckets(), + __GFP_ZERO | __GFP_NO_OBJ_EXT, slab_nid(slab)); + } else { + if (sz > KMALLOC_MAX_CACHE_SIZE) + vec =3D kmalloc_node(sz, gfp | __GFP_ZERO, slab_nid(slab)); + else + vec =3D kmem_buckets_node_alloc(sz, obj_ext_vec_buckets(), + gfp | __GFP_ZERO, slab_nid(slab)); + } if (!vec) { /* @@ -5311,6 +5279,7 @@ EXPORT_SYMBOL(__kmalloc_noprof); /** * kmalloc_nolock - Allocate an object of given size from any context. + * @b: kmem_cach bucket * @size: size to allocate * @gfp_flags: GFP flags. Only __GFP_ACCOUNT, __GFP_ZERO, __GFP_NO_OBJ_EXT * allowed. @@ -5320,7 +5289,7 @@ EXPORT_SYMBOL(__kmalloc_noprof); * NULL does not mean EBUSY or EAGAIN. It means ENOMEM. * There is no reason to call it again and expect !NULL. */ -void *kmalloc_nolock_noprof(size_t size, gfp_t gfp_flags, int node) +void *__kmalloc_nolock_noprof(size_t size, kmem_buckets *b, gfp_t gfp_flags, int node) { gfp_t alloc_gfp =3D __GFP_NOWARN | __GFP_NOMEMALLOC | gfp_flags; struct kmem_cache *s; @@ -5347,7 +5316,7 @@ void *kmalloc_nolock_noprof(size_t size, gfp_t gfp_flags, int node) retry: if (unlikely(size > KMALLOC_MAX_CACHE_SIZE)) return NULL; - s =3D kmalloc_slab(size, NULL, alloc_gfp, _RET_IP_); + s =3D kmalloc_slab(size, b, alloc_gfp, _RET_IP_); if (!(s->flags & __CMPXCHG_DOUBLE) && !kmem_cache_debug(s)) /* @@ -5400,7 +5369,7 @@ void *kmalloc_nolock_noprof(size_t size, gfp_t gfp_flags, int node) ret =3D kasan_kmalloc(s, ret, size, alloc_gfp); return ret; } -EXPORT_SYMBOL_GPL(kmalloc_nolock_noprof); +EXPORT_SYMBOL_GPL(__kmalloc_nolock_noprof); void *__kmalloc_node_track_caller_noprof(DECL_BUCKET_PARAMS(size, b), gfp_t flags, int node, unsigned long caller) -- > > >>>> We could say it's for a debugging feature, but also it's running in > >>>> production fleets (and Android?), so probably not that easy to dismi= ss. > >>> > >>> I think a key factor is when it's enabled in production. > >>> > >>> kconfigs says Android selects MEM_ALLOC_PROFILING, but not > >>> MEM_ALLOC_PROFILING_ENABLED_BY_DEFAULT. > >>> > >>> I assumed that turning it on by default in the entire fleet > >>> would be bit hard to justify... (please correct me, > >>> if it's not the case) > >> > >> Actually we have memory profiling enabled by default across Meta fleet= . So, the > >> issue is very real. > > I see, thanks for clarifying. > > >> At the moment, we are seeing this issue on a specific > >> type of machine and we have disabled memory profiling for those machin= es. > >> Internally we did discuss to simply disable memory allocation profilin= g for > >> kmalloc-normal caches but to me that was a big hammer and thus suggest= ed the > >> current approach. > > -- > Cheers, > Harry / Hyeonggon --000000000000925b27065581508b Content-Type: application/x-patch; name="0001-prototype-for-a-fix-to-the-circular-allocation-issue.patch" Content-Disposition: attachment; filename="0001-prototype-for-a-fix-to-the-circular-allocation-issue.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mr1b168c0 RnJvbSA3MzRiYmRlODQ1ODkwZmQyNzg4ZTBmOGM0NGU0YTc5ZmJmZTBjODAzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBTdXJlbiBCYWdoZGFzYXJ5YW4gPHN1cmVuYkBnb29nbGUuY29t PgpEYXRlOiBUdWUsIDMwIEp1biAyMDI2IDEzOjA0OjAyIC0wNzAwClN1YmplY3Q6IFtQQVRDSCAx LzFdIHByb3RvdHlwZSBmb3IgYSBmaXggdG8gdGhlIGNpcmN1bGFyIGFsbG9jYXRpb24gaXNzdWUg ZnJvbQogWzFdCgpbMV0gaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvYWxsLzIwMjYwNjI1MjMwMDI5 LjcwMzc1MC0xLXNoYWtlZWwuYnV0dEBsaW51eC5kZXYvCgpTaWduZWQtb2ZmLWJ5OiBTdXJlbiBC YWdoZGFzYXJ5YW4gPHN1cmVuYkBnb29nbGUuY29tPgotLS0KIGluY2x1ZGUvbGludXgvc2xhYi5o IHwgNDIgKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiBtbS9zbHViLmMgICAgICAgICAg ICB8IDYxICsrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAyIGZp bGVzIGNoYW5nZWQsIDQ1IGluc2VydGlvbnMoKyksIDU4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvc2xhYi5oIGIvaW5jbHVkZS9saW51eC9zbGFiLmgKaW5kZXggMmI1 YWI0ODhlOTZiLi4yZDRhNmUzMDY0YTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc2xhYi5o CisrKyBiL2luY2x1ZGUvbGludXgvc2xhYi5oCkBAIC02MTgsNiArNjE4LDEwIEBAIHN0YXRpYyBp bmxpbmUgdW5zaWduZWQgaW50IGFyY2hfc2xhYl9taW5hbGlnbih2b2lkKQogI2RlZmluZSBSQU5E T01fS01BTExPQ19DQUNIRVNfTlIJMAogI2VuZGlmCiAKKyNpZiBkZWZpbmVkKENPTkZJR19NRU1f QUxMT0NfUFJPRklMSU5HKSAmJiBkZWZpbmVkKENPTkZJR19TTFVCX1RJTlkpCisjZGVmaW5lIE9C Sl9FWFRfVkVDX0NBQ0hFCisjZW5kaWYKKwogLyoKICAqIFdoZW5ldmVyIGNoYW5naW5nIHRoaXMs IHRha2UgY2FyZSBvZiB0aGF0IGttYWxsb2NfdHlwZSgpIGFuZAogICogY3JlYXRlX2ttYWxsb2Nf Y2FjaGVzKCkgc3RpbGwgd29yayBhcyBpbnRlbmRlZC4KQEAgLTY0Niw2ICs2NTAsOSBAQCBlbnVt IGttYWxsb2NfY2FjaGVfdHlwZSB7CiAjZW5kaWYKICNpZmRlZiBDT05GSUdfTUVNQ0cKIAlLTUFM TE9DX0NHUk9VUCwKKyNlbmRpZgorI2lmZGVmIE9CSl9FWFRfVkVDX0NBQ0hFCisJS01BTExPQ19P QkpfRVhUX1ZFQywKICNlbmRpZgogCU5SX0tNQUxMT0NfVFlQRVMKIH07CkBAIC02NTQsNiArNjYx LDE4IEBAIHR5cGVkZWYgc3RydWN0IGttZW1fY2FjaGUgKiBrbWVtX2J1Y2tldHNbS01BTExPQ19T SElGVF9ISUdIICsgMV07CiAKIGV4dGVybiBrbWVtX2J1Y2tldHMga21hbGxvY19jYWNoZXNbTlJf S01BTExPQ19UWVBFU107CiAKKyNpZmRlZiBPQkpfRVhUX1ZFQ19DQUNIRQorc3RhdGljIGlubGlu ZSBrbWVtX2J1Y2tldHMgKm9ial9leHRfdmVjX2J1Y2tldHModm9pZCkKK3sKKwlyZXR1cm4gJmtt YWxsb2NfY2FjaGVzW0tNQUxMT0NfT0JKX0VYVF9WRUNdOworfQorI2Vsc2UKK3N0YXRpYyBpbmxp bmUga21lbV9idWNrZXRzICpvYmpfZXh0X3ZlY19idWNrZXRzKHZvaWQpCit7CisJcmV0dXJuIE5V TEw7Cit9CisjZW5kaWYKKwogLyoKICAqIERlZmluZSBnZnAgYml0cyB0aGF0IHNob3VsZCBub3Qg YmUgc2V0IGZvciBLTUFMTE9DX05PUk1BTC4KICAqLwpAQCAtODQzLDIwICs4NjIsMTAgQEAgdm9p ZCAqa21lbV9jYWNoZV9hbGxvY19mcm9tX3NoZWFmX25vcHJvZihzdHJ1Y3Qga21lbV9jYWNoZSAq Y2FjaGVwLCBnZnBfdCBnZnAsCiAKIHVuc2lnbmVkIGludCBrbWVtX2NhY2hlX3NoZWFmX3NpemUo c3RydWN0IHNsYWJfc2hlYWYgKnNoZWFmKTsKIAotLyoKLSAqIFRoZXNlIG1hY3JvcyBhbGxvdyBk ZWNsYXJpbmcgYSBrbWVtX2J1Y2tldHMgKiBwYXJhbWV0ZXIgYWxvbmdzaWRlIHNpemUsIHdoaWNo Ci0gKiBjYW4gYmUgY29tcGlsZWQgb3V0IHdpdGggQ09ORklHX1NMQUJfQlVDS0VUUz1uIHNvIHRo YXQgYSBsYXJnZSBudW1iZXIgb2YgY2FsbAotICogc2l0ZXMgZG9uJ3QgaGF2ZSB0byBwYXNzIE5V TEwuCi0gKi8KLSNpZmRlZiBDT05GSUdfU0xBQl9CVUNLRVRTCisvKiBUT0RPOiB0aGVzZSBtYWNy b3Mgc2hvdWxkIGJlIHJlbW92ZWQgaW4gYSBwcmVyZXF1aXNpdGUgcGF0Y2ggKi8KICNkZWZpbmUg REVDTF9CVUNLRVRfUEFSQU1TKF9zaXplLCBfYikJc2l6ZV90IChfc2l6ZSksIGttZW1fYnVja2V0 cyAqKF9iKQogI2RlZmluZSBQQVNTX0JVQ0tFVF9QQVJBTVMoX3NpemUsIF9iKQkoX3NpemUpLCAo X2IpCiAjZGVmaW5lIFBBU1NfQlVDS0VUX1BBUkFNKF9iKQkJKF9iKQotI2Vsc2UKLSNkZWZpbmUg REVDTF9CVUNLRVRfUEFSQU1TKF9zaXplLCBfYikJc2l6ZV90IChfc2l6ZSkKLSNkZWZpbmUgUEFT U19CVUNLRVRfUEFSQU1TKF9zaXplLCBfYikJKF9zaXplKQotI2RlZmluZSBQQVNTX0JVQ0tFVF9Q QVJBTShfYikJCU5VTEwKLSNlbmRpZgogCiAvKgogICogVGhlIGZvbGxvd2luZyBmdW5jdGlvbnMg YXJlIG5vdCB0byBiZSB1c2VkIGRpcmVjdGx5IGFuZCBhcmUgaW50ZW5kZWQgb25seQpAQCAtOTU1 LDcgKzk2NCwxMyBAQCBzdGF0aWMgX19hbHdheXNfaW5saW5lIF9fYWxsb2Nfc2l6ZSgxKSB2b2lk ICprbWFsbG9jX25vcHJvZihzaXplX3Qgc2l6ZSwgZ2ZwX3QgZgogfQogI2RlZmluZSBrbWFsbG9j KC4uLikJCQkJYWxsb2NfaG9va3Moa21hbGxvY19ub3Byb2YoX19WQV9BUkdTX18pKQogCi12b2lk ICprbWFsbG9jX25vbG9ja19ub3Byb2Yoc2l6ZV90IHNpemUsIGdmcF90IGdmcF9mbGFncywgaW50 IG5vZGUpOwordm9pZCAqX19rbWFsbG9jX25vbG9ja19ub3Byb2Yoc2l6ZV90IHNpemUsIGttZW1f YnVja2V0cyAqYiwgZ2ZwX3QgZ2ZwX2ZsYWdzLCBpbnQgbm9kZSk7CisjZGVmaW5lIF9fa21hbGxv Y19ub2xvY2soLi4uKQkJCWFsbG9jX2hvb2tzKF9fa21hbGxvY19ub2xvY2tfbm9wcm9mKF9fVkFf QVJHU19fKSkKKworc3RhdGljIF9fYWx3YXlzX2lubGluZSB2b2lkICprbWFsbG9jX25vbG9ja19u b3Byb2Yoc2l6ZV90IHNpemUsIGdmcF90IGdmcF9mbGFncywgaW50IG5vZGUpCit7CisJcmV0dXJu IF9fa21hbGxvY19ub2xvY2tfbm9wcm9mKHNpemUsIE5VTEwsIGdmcF9mbGFncywgbm9kZSk7Cit9 CiAjZGVmaW5lIGttYWxsb2Nfbm9sb2NrKC4uLikJCQlhbGxvY19ob29rcyhrbWFsbG9jX25vbG9j a19ub3Byb2YoX19WQV9BUkdTX18pKQogCiAvKioKQEAgLTEwNjIsNiArMTA3Nyw5IEBAIHZvaWQg KmttYWxsb2Nfbm9sb2NrX25vcHJvZihzaXplX3Qgc2l6ZSwgZ2ZwX3QgZ2ZwX2ZsYWdzLCBpbnQg bm9kZSk7CiAjZGVmaW5lIGttZW1fYnVja2V0c19hbGxvYyhfYiwgX3NpemUsIF9mbGFncykJXAog CWFsbG9jX2hvb2tzKF9fa21hbGxvY19ub2RlX25vcHJvZihQQVNTX0JVQ0tFVF9QQVJBTVMoX3Np emUsIF9iKSwgX2ZsYWdzLCBOVU1BX05PX05PREUpKQogCisjZGVmaW5lIGttZW1fYnVja2V0c19u b2RlX2FsbG9jKF9zaXplLCBfYiwgX2ZsYWdzLCBfbm9kZSkJXAorCWFsbG9jX2hvb2tzKF9fa21h bGxvY19ub2RlX25vcHJvZihQQVNTX0JVQ0tFVF9QQVJBTVMoX3NpemUsIF9iKSwgX2ZsYWdzLCBf bm9kZSkpCisKICNkZWZpbmUga21lbV9idWNrZXRzX2FsbG9jX3RyYWNrX2NhbGxlcihfYiwgX3Np emUsIF9mbGFncykJXAogCWFsbG9jX2hvb2tzKF9fa21hbGxvY19ub2RlX3RyYWNrX2NhbGxlcl9u b3Byb2YoUEFTU19CVUNLRVRfUEFSQU1TKF9zaXplLCBfYiksIF9mbGFncywgTlVNQV9OT19OT0RF LCBfUkVUX0lQXykpCiAKZGlmZiAtLWdpdCBhL21tL3NsdWIuYyBiL21tL3NsdWIuYwppbmRleCBh MmJmMzc1NmNhN2QuLmM1OWQ5ZWU0ZjRmMyAxMDA2NDQKLS0tIGEvbW0vc2x1Yi5jCisrKyBiL21t L3NsdWIuYwpAQCAtMjEwNiw0MiArMjEwNiw2IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBpbml0X3Ns YWJfb2JqX2V4dHMoc3RydWN0IHNsYWIgKnNsYWIpCiAJc2xhYi0+b2JqX2V4dHMgPSAwOwogfQog Ci0vKgotICogQ2FsY3VsYXRlIHRoZSBhbGxvY2F0aW9uIHNpemUgZm9yIHNsYWJvYmpfZXh0IGFy cmF5LgotICoKLSAqIFdoZW4gbWVtb3J5IGFsbG9jYXRpb24gcHJvZmlsaW5nIGlzIGVuYWJsZWQs IHRoZSBvYmpfZXh0cyBhcnJheQotICogY291bGQgYmUgYWxsb2NhdGVkIGZyb20gdGhlIHNhbWUg c2xhYiBjYWNoZSBpdCdzIGJlaW5nIGFsbG9jYXRlZCBmb3IuCi0gKiBUaGlzIHdvdWxkIHByZXZl bnQgdGhlIHNsYWIgZnJvbSBldmVyIGJlaW5nIGZyZWVkIGJlY2F1c2UgaXQgd291bGQKLSAqIGFs d2F5cyBjb250YWluIGF0IGxlYXN0IG9uZSBhbGxvY2F0ZWQgb2JqZWN0IChpdHMgb3duIG9ial9l eHRzIGFycmF5KS4KLSAqCi0gKiBUbyBhdm9pZCB0aGlzLCBpbmNyZWFzZSB0aGUgYWxsb2NhdGlv biBzaXplIHdoZW4gd2UgZGV0ZWN0IHRoZSBhcnJheQotICogbWF5IGNvbWUgZnJvbSB0aGUgc2Ft ZSBjYWNoZSwgZm9yY2luZyBpdCB0byB1c2UgYSBkaWZmZXJlbnQgY2FjaGUuCi0gKi8KLXN0YXRp YyBpbmxpbmUgc2l6ZV90IG9ial9leHRzX2FsbG9jX3NpemUoc3RydWN0IGttZW1fY2FjaGUgKnMs Ci0JCQkJCSBzdHJ1Y3Qgc2xhYiAqc2xhYiwgZ2ZwX3QgZ2ZwKQotewotCXNpemVfdCBzeiA9IHNp emVvZihzdHJ1Y3Qgc2xhYm9ial9leHQpICogc2xhYi0+b2JqZWN0czsKLQlzdHJ1Y3Qga21lbV9j YWNoZSAqb2JqX2V4dHNfY2FjaGU7Ci0KLQlpZiAoc3ogPiBLTUFMTE9DX01BWF9DQUNIRV9TSVpF KQotCQlyZXR1cm4gc3o7Ci0KLQlpZiAoIWlzX2ttYWxsb2Nfbm9ybWFsKHMpKQotCQlyZXR1cm4g c3o7Ci0KLQlvYmpfZXh0c19jYWNoZSA9IGttYWxsb2Nfc2xhYihzeiwgTlVMTCwgZ2ZwLCAwKTsK LQkvKgotCSAqIFdlIGNhbid0IHNpbXBseSBjb21wYXJlIHMgd2l0aCBvYmpfZXh0c19jYWNoZSwg YmVjYXVzZSByYW5kb20ga21hbGxvYwotCSAqIGNhY2hlcyBoYXZlIG11bHRpcGxlIGNhY2hlcyBw ZXIgc2l6ZSwgc2VsZWN0ZWQgYnkgY2FsbGVyIGFkZHJlc3MuCi0JICogU2luY2UgY2FsbGVyIGFk ZHJlc3MgbWF5IGRpZmZlciBiZXR3ZWVuIGttYWxsb2Nfc2xhYigpIGFuZCBhY3R1YWwKLQkgKiBh bGxvY2F0aW9uLCBidW1wIHNpemUgd2hlbiBzaXplcyBhcmUgZXF1YWwuCi0JICovCi0JaWYgKHMt Pm9iamVjdF9zaXplID09IG9ial9leHRzX2NhY2hlLT5vYmplY3Rfc2l6ZSkKLQkJcmV0dXJuIG9i al9leHRzX2NhY2hlLT5vYmplY3Rfc2l6ZSArIDE7Ci0KLQlyZXR1cm4gc3o7Ci19Ci0KIGludCBh bGxvY19zbGFiX29ial9leHRzKHN0cnVjdCBzbGFiICpzbGFiLCBzdHJ1Y3Qga21lbV9jYWNoZSAq cywKIAkJICAgICAgICBnZnBfdCBnZnAsIGJvb2wgbmV3X3NsYWIpCiB7CkBAIC0yMTU2LDE5ICsy MTIwLDIzIEBAIGludCBhbGxvY19zbGFiX29ial9leHRzKHN0cnVjdCBzbGFiICpzbGFiLCBzdHJ1 Y3Qga21lbV9jYWNoZSAqcywKIAkvKiBQcmV2ZW50IHJlY3Vyc2l2ZSBleHRlbnNpb24gdmVjdG9y IGFsbG9jYXRpb24gKi8KIAlnZnAgfD0gX19HRlBfTk9fT0JKX0VYVDsKIAotCXN6ID0gb2JqX2V4 dHNfYWxsb2Nfc2l6ZShzLCBzbGFiLCBnZnApOwotCisJc3ogPSBzaXplb2Yoc3RydWN0IHNsYWJv YmpfZXh0KSAqIHNsYWItPm9iamVjdHM7CiAJLyoKIAkgKiBOb3RlIHRoYXQgYWxsb3dfc3BpbiBt YXkgYmUgZmFsc2UgZHVyaW5nIGVhcmx5IGJvb3QgYW5kIGl0cwogCSAqIHJlc3RyaWN0ZWQgR0ZQ X0JPT1RfTUFTSy4gRHVlIHRvIGttYWxsb2Nfbm9sb2NrKCkgb25seSBzdXBwb3J0aW5nCiAJICog YXJjaGl0ZWN0dXJlcyB3aXRoIGNtcHhjaGcxNmIsIGVhcmx5IG9ial9leHRzIHdpbGwgYmUgbWlz c2luZyBmb3IKIAkgKiB2ZXJ5IGVhcmx5IGFsbG9jYXRpb25zIG9uIHRob3NlLgogCSAqLwotCWlm ICh1bmxpa2VseSghYWxsb3dfc3BpbikpCi0JCXZlYyA9IGttYWxsb2Nfbm9sb2NrKHN6LCBfX0dG UF9aRVJPIHwgX19HRlBfTk9fT0JKX0VYVCwKLQkJCQkgICAgIHNsYWJfbmlkKHNsYWIpKTsKLQll bHNlCi0JCXZlYyA9IGttYWxsb2Nfbm9kZShzeiwgZ2ZwIHwgX19HRlBfWkVSTywgc2xhYl9uaWQo c2xhYikpOworCWlmICh1bmxpa2VseSghYWxsb3dfc3BpbikpIHsKKwkJdmVjID0gX19rbWFsbG9j X25vbG9jayhzeiwgb2JqX2V4dF92ZWNfYnVja2V0cygpLAorCQkJCSAgICAgICBfX0dGUF9aRVJP IHwgX19HRlBfTk9fT0JKX0VYVCwgc2xhYl9uaWQoc2xhYikpOworCX0gZWxzZSB7CisJCWlmIChz eiA+IEtNQUxMT0NfTUFYX0NBQ0hFX1NJWkUpCisJCQl2ZWMgPSAga21hbGxvY19ub2RlKHN6LCBn ZnAgfCBfX0dGUF9aRVJPLCBzbGFiX25pZChzbGFiKSk7CisJCWVsc2UKKwkJCXZlYyA9IGttZW1f YnVja2V0c19ub2RlX2FsbG9jKHN6LCBvYmpfZXh0X3ZlY19idWNrZXRzKCksCisJCQkJCQkgICAg ICBnZnAgfCBfX0dGUF9aRVJPLCBzbGFiX25pZChzbGFiKSk7CisJfQogCiAJaWYgKCF2ZWMpIHsK IAkJLyoKQEAgLTUzMTEsNiArNTI3OSw3IEBAIEVYUE9SVF9TWU1CT0woX19rbWFsbG9jX25vcHJv Zik7CiAKIC8qKgogICoga21hbGxvY19ub2xvY2sgLSBBbGxvY2F0ZSBhbiBvYmplY3Qgb2YgZ2l2 ZW4gc2l6ZSBmcm9tIGFueSBjb250ZXh0LgorICogQGI6IGttZW1fY2FjaCBidWNrZXQKICAqIEBz aXplOiBzaXplIHRvIGFsbG9jYXRlCiAgKiBAZ2ZwX2ZsYWdzOiBHRlAgZmxhZ3MuIE9ubHkgX19H RlBfQUNDT1VOVCwgX19HRlBfWkVSTywgX19HRlBfTk9fT0JKX0VYVAogICogYWxsb3dlZC4KQEAg LTUzMjAsNyArNTI4OSw3IEBAIEVYUE9SVF9TWU1CT0woX19rbWFsbG9jX25vcHJvZik7CiAgKiBO VUxMIGRvZXMgbm90IG1lYW4gRUJVU1kgb3IgRUFHQUlOLiBJdCBtZWFucyBFTk9NRU0uCiAgKiBU aGVyZSBpcyBubyByZWFzb24gdG8gY2FsbCBpdCBhZ2FpbiBhbmQgZXhwZWN0ICFOVUxMLgogICov Ci12b2lkICprbWFsbG9jX25vbG9ja19ub3Byb2Yoc2l6ZV90IHNpemUsIGdmcF90IGdmcF9mbGFn cywgaW50IG5vZGUpCit2b2lkICpfX2ttYWxsb2Nfbm9sb2NrX25vcHJvZihzaXplX3Qgc2l6ZSwg a21lbV9idWNrZXRzICpiLCBnZnBfdCBnZnBfZmxhZ3MsIGludCBub2RlKQogewogCWdmcF90IGFs bG9jX2dmcCA9IF9fR0ZQX05PV0FSTiB8IF9fR0ZQX05PTUVNQUxMT0MgfCBnZnBfZmxhZ3M7CiAJ c3RydWN0IGttZW1fY2FjaGUgKnM7CkBAIC01MzQ3LDcgKzUzMTYsNyBAQCB2b2lkICprbWFsbG9j X25vbG9ja19ub3Byb2Yoc2l6ZV90IHNpemUsIGdmcF90IGdmcF9mbGFncywgaW50IG5vZGUpCiBy ZXRyeToKIAlpZiAodW5saWtlbHkoc2l6ZSA+IEtNQUxMT0NfTUFYX0NBQ0hFX1NJWkUpKQogCQly ZXR1cm4gTlVMTDsKLQlzID0ga21hbGxvY19zbGFiKHNpemUsIE5VTEwsIGFsbG9jX2dmcCwgX1JF VF9JUF8pOworCXMgPSBrbWFsbG9jX3NsYWIoc2l6ZSwgYiwgYWxsb2NfZ2ZwLCBfUkVUX0lQXyk7 CiAKIAlpZiAoIShzLT5mbGFncyAmIF9fQ01QWENIR19ET1VCTEUpICYmICFrbWVtX2NhY2hlX2Rl YnVnKHMpKQogCQkvKgpAQCAtNTQwMCw3ICs1MzY5LDcgQEAgdm9pZCAqa21hbGxvY19ub2xvY2tf bm9wcm9mKHNpemVfdCBzaXplLCBnZnBfdCBnZnBfZmxhZ3MsIGludCBub2RlKQogCXJldCA9IGth c2FuX2ttYWxsb2MocywgcmV0LCBzaXplLCBhbGxvY19nZnApOwogCXJldHVybiByZXQ7CiB9Ci1F WFBPUlRfU1lNQk9MX0dQTChrbWFsbG9jX25vbG9ja19ub3Byb2YpOworRVhQT1JUX1NZTUJPTF9H UEwoX19rbWFsbG9jX25vbG9ja19ub3Byb2YpOwogCiB2b2lkICpfX2ttYWxsb2Nfbm9kZV90cmFj a19jYWxsZXJfbm9wcm9mKERFQ0xfQlVDS0VUX1BBUkFNUyhzaXplLCBiKSwgZ2ZwX3QgZmxhZ3Ms CiAJCQkJCSBpbnQgbm9kZSwgdW5zaWduZWQgbG9uZyBjYWxsZXIpCi0tIAoyLjU1LjAucmMwLjc5 OS5nZDZmOTRlZDU5My1nb29nCgo= --000000000000925b27065581508b--