* Re: [PATCH bpf v5 1/2] bpf: Run generic devmap egress prog on private skb
From: sun jian @ 2026-06-14 3:46 UTC (permalink / raw)
To: Jakub Kicinski
Cc: Alexei Starovoitov, bpf, Network Development, LKML,
open list:KERNEL SELFTEST FRAMEWORK, Alexei Starovoitov,
Daniel Borkmann, Andrii Nakryiko, Martin KaFai Lau,
David S. Miller, Jesper Dangaard Brouer, John Fastabend,
Stanislav Fomichev, Shuah Khan, Jiayuan Chen,
Toke Høiland-Jørgensen, Menglong Dong, Emil Tsalapatis
In-Reply-To: <20260613130343.3984878b@kernel.org>
On Sun, Jun 14, 2026 at 4:03 AM Jakub Kicinski <kuba@kernel.org> wrote:
>
> On Sat, 13 Jun 2026 10:53:35 -0700 Alexei Starovoitov wrote:
> > On Sat, Jun 13, 2026 at 10:25 AM Jakub Kicinski <kuba@kernel.org> wrote:
> > >
> > > On Fri, 12 Jun 2026 19:40:31 +0800 Sun Jian wrote:
> > > > Suggested-by: Jakub Kicinski <kuba@kernel.org>
> > >
> > > I did not suggest this
> >
> > ohh. I didn't follow discussion closely.
> > Do you want me to revert the whole set or just remove that line?
>
> It's alright, I was just being grumpy.
>
> Maybe we can amend Chris's prompts to catch these?
> Noobs tend to add Suggested-by for people who simply commented
> on patches.
Hi Jakub, Alexei,
Sorry about that. I had meant to drop that Suggested-by tag before
sending v5, but missed it.
No action needed from my side.
Thanks,
Sun Jian
^ permalink raw reply
* Re: [PATCH net-next] virtio-net: support xsk wake up
From: Menglong Dong @ 2026-06-14 2:21 UTC (permalink / raw)
To: Menglong Dong, Jakub Kicinski
Cc: xuanzhuo, mst, jasowang, eperezma, andrew+netdev, davem, edumazet,
pabeni, netdev, virtualization, linux-kernel
In-Reply-To: <20260613144438.767f8069@kernel.org>
On 2026/6/14 05:44, Jakub Kicinski wrote:
> On Wed, 10 Jun 2026 16:16:48 +0800 Menglong Dong wrote:
> > + /* If both rq->vq and fill ring are empty, and then the user submit
> > + * all the chunks to the fill ring and check the wake up flag
> > + * after xsk_buff_alloc_batch() and before xsk_set_rx_need_wakeup(),
> > + * we will lose the chance to wake up the rx napi, so we have to
> > + * set the need_wakeup flag here.
> > + */
>
> TBH all the comments you're adding are harder to understand than the
> code itself ;( Please try to phrase them better or just remove them.
Ah, sorry about that. The race condition here is a little hard to describe
for me. After the discussion in the V2:
https://lore.kernel.org/netdev/rHZz5_ylT4WggoZ-Ic2Q4w@linux.dev/
the race condition seems not likely to happen. So I'll remove this
part in V3.
Thanks!
Menglong Dong
>
>
^ permalink raw reply
* [PATCH] staging: remove obsolete network and 16-bit video drivers
From: Gabriel Ramos @ 2026-06-14 2:20 UTC (permalink / raw)
To: andrew; +Cc: netdev, linux-kernel, Gabriel Ramos Barbosa Mota
From: Gabriel Ramos Barbosa Mota <maguraa53@gmail.com>
These drivers are currently in the staging tree and have been identified as unmaintained and obsolete. They lack modern hardware support, do not integrate with the current device model, and represent technical debt. This patch removes these drivers to clean up the staging area and reduce the overall maintenance burden, as there is no evidence of active users or ongoing development for these specific components. Signed-off-by: Gabriel Ramos <maguraa53@gmail.com>
---
teste_disco.img | Bin 0 -> 20971520 bytes
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 teste_disco.img
diff --git a/teste_disco.img b/teste_disco.img
new file mode 100644
index 0000000000000000000000000000000000000000..13145eb3ecf765e330220f06cf8ad7553c3d9ff2
GIT binary patch
literal 20971520
zcmeF)cdV859mny{y<AWM6-C7@;#Nf5sHiwl+<Olkh>8>U1}6^Odn*o1+N80r*p<dV
zurY1Y_KzBqrnc24O<QAAZERXonjb@MBNXZY;rn_ehunM4^W1ZO&pq$wIh^}E=ShI7
z{?R|l!AZK3+eRjT>7R6TUl;?Ec6p&!GU}bd<JzSo)2AQyVaJT=hP*R)-0aC`&)272
z(UA=AmrNU!oYmEly@rpT(6#CAYu^6z*M89VotLJ~p69Fe<mZ0e(%r7P@7aTYId$@0
z&ph<N(_=;qnm)dxV?_GSy1k8~_eULVG0f4GOljj^VEz7U%7Gd9*)r*_t0Q^4`xQ%o
zy?Za%ApUmuB|q&x<?Q9p!ne<sAO3YplIN1VkYw}KAM4dQtAIcM{!cqT*6ZG3^LkWw
zzIo5T+ilMzc|OUZoyq7m+FGLLj9JFt(AF96Uo)@yN3S~bmS>YpP4a1vWcu=R=6~S5
zHvi>!%xnIgemAdMfCbg#|JuF*OOh`ALs>ob4`ubzKa{nU{-La;^$%q&qkkx?xBj85
zKKh5U`syFbT2}v1)^hrXvX<9Bl+{oFP}U0ihq6}GKa|y9|4`OS`iHVs)<2ZBivFRj
z0s4osR@Fb0wVM8+tkv}oWv!uqC~HmqLs@I-AIe%=|4`OC`iHUx>L1ElSN~AfApJvG
z>**iLT3`QA)&}~AvNqH|l(mump{$Md4`pqle<*8H{X<!s=^x4(tbZtLbNxeEL-Y@2
zZJ~cCYpDLAtS$8qWo@N@C~Ir|Ls{GCAIjQR|4`O;`iHW%*FTgsO#e{U4*G|(cGN$V
zwUhp#tl|2HvUb)#l(mcgp{!l?4`q$eKa{nb{-Lbh^$%t3p?@fAPyIt#BlQnu?WKPx
zYj6ESS)=q1W$mMXC~IH+Ls|RjAIjQa|4`Ne`iHU()IXGUkp7{pgY^$(9io3I>rnke
zS%>K#$~s*CP}ULphq8{;Ka_Qp{-La+^$%qoqkkytSp7p;$LSx+I$r-!)(QHDvQE@L
zlr>uaP}WKMhq6xAKa_Qf{-LZ>^$%r@(La=Rn*O1zvHFLyPS-z_b%y?-tTXiwWsTE6
zly#Q=p{%p@4`rRBe<<r*{X<#j=^x5EU;j|nc>P0J7w8|#x={a6)<yb<vM$y?ly!;z
zp{z^w4`p4Ze<<s6{X<z-=pV|uQvXoaRr-gruGT-4b&dX^tO@#uvL@;u%DPtnP}X(&
zhqA8MKa_QY{-LZJ^$%s;q<<)DlK!EroAnQ6-J*Xe>sI|kS-0sQ%9^ZyDC>6pLs@s|
zAIiE@|4`Ol`iHXa)<2YWkN%;od-V@x-KT#j>wf)1Sr6zR%6d@$P}W2Ghq4~lKa}-|
z{-LZ#^$%q|rhh2was5MCPv{@YdQ$&T)>Hb2vYysIlr?>^wN%;P8GKc~iTQVYRf7Xy
zUM7AM*Z(X;%g^hnu^3y3iw_oOi*e-uz?U@Sox$T~U%upzT42Y$yTFrvZ9dp7Nmu4F
z{vPR^aj#3y__y~*9c{ADwD%~V@A=ucUr1-aWMC%U-F@cvJLvxXlI)FJm*mmS-^QEI
zf0`xP*a1uO=;rU`W9C22*KOjpNrrZH&0hD<S^sq8nwcxWFYKlHtRJ5n+SY&H>)rhh
z=G_0nF=PDcH<$H)M`o`2=f3`L8-poda^IO}_G#l^WkUCnF6{9yN<#)O%6nh*K0Rg8
zKZYN-*FQt&_WGwYtIl|MbASH#O)_;peb3M7Pqyd($dkHHx3Hi8Gy0!6xAAvm#Qzw7
zOaJ9BIsR{rYU3aH)S?_e000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z0000000000000000000000000000000000000000z@pNbq;EPpha|JU?(7^gB<Yjn
z*FAc7o_*eh7i~87yo=8rv#1^+@Kx)Z{HE`3|Fur*ynFwD>@l-{V9C|`UuT&kFK#3J
zxW|$^PT=!e|0fT-{@Qkn{-GBALtXlZy7Uiq=^yISKh&jvs7wD)m;RwH{X<>d`)|Ad
zb|vYVq*s!qk}REMnIye4^H`w1NtR8rT$1IJ^h>frk`<HmPqI>ym6NQJWI&QtldP6x
z^(1Q~Su@F6N!CuXPLhF1)=e@f$$ClFPqIOh4U=q?WaA{8B-u2{W=RGo**r-*PHBrI
zLz8ToWUC}wC)p;+wn?^2vVD?aNp?uGW0IYc3{SFil3kMQnq)+h-IDB{WRE0!CK;Jz
zuOxdX8I@$8B>N`WFUkH%4oGrfl7o^QoaB%shbB2J$>B+kNOEM7qmmq*<d`JKCOIz2
z@kvfda$=IvNlr>~a*|V$oSLK^UUgcMu}Mx(az>IflZ;DpR+6)moRj3-B<CeLKgswc
z7bLkb$wf)p&fJ$IxiraTNiI)vMUpF%T$SYNB-bRFkYr+#w)5w8Nv=<FLy{Yl+>~Te
zlADv<lH}GTw<VdJ<n|<YB)K!mT}kdva!-<bliZi&{v;11c`(UCNght}NRmgBJeK6~
zBu^xHGRad(p01l8z#`N2R=++ctUs)6et=?H|2@Yp(_WSV#kBs{{MD=Nzh*!&t^Ymm
zo7CQN0*Yz<@9_S#_O>ukOzZ#T=RawG{sD?<{a?1qsP-pcpqSSGz{4+ZyM_S8wEp+K
zWc#*z7f?*=f5mNjwcSR6Vp{)wZg{=zIt~=m`af*i&Fzp5pqSSGFHZm2tHp*5wBvo>
z>euI%4L)s$xdO$s{_nbfk9H_KP)zIpCvRWyVzFTZvtIvC`TOwpF*ramZTtVv*OvWJ
zv0($Vw*T)f_1)Jk45+7V|Gz)-`u0(mKryZVY1_WhK8_YBruF~Cr60AAVFrq6{ZD#x
z|Ea}>4a|D~@7)`(Zl|aKifP;bSEg?LLa|{3v$p>q{Gqd*t_mooZT~+$;)m@Nc0e($
z|8EbN{GDRM24=nfU+$G%+o@-PV%qlq$WNAQr(_0-Y5gCx_lxcH>_9QC{{cNGjwv>5
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000008(8dvG8C00000<p0_Ts;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a6g?9{zWRbd<l@b9scgk4B*iE<Fz
zq?#)oM98K<>JPX}Q%x>GOD=6?(F@`rL~7~o;NlPswlqjf+_9Ibf}oa$=*IDC-jE9t
z(h#2yJe>19zZcH)z<B@w000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000U>|+&OEQt9Om3e~
zKKCU>d;fu?8q3|S#nX+GSCeM*@|RX#Yu>V5cet7sMMip)7lX;QG8rGKPnAPs{nHz(
zYqiG8`c}z4d%UaPp|+JrixaPx?u;+Y&OEs?I@p{niqX`z;?+KSz7^Fm>?o7@YX5uI
z`$y(L27aGOyRt~$v@iSzF7)he6JPINf7PD3eg6D=Ck8K$&L?@AWI4&HV{_eITYtc(
zcOTEqbw51Q>8tL&eDJf1EhKrC<Wg5sKVIDu2RBP5Z&i23hnt=1>qlFW#Ux8fejG@e
zM|SFG-dFWE?slple%mPm000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000004jQ`S97<BxS2Z_1JtZlFhNp_(*-K92)DN-dJ6$HCEO;
z<pBTy000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z000000000000000000000000000000000000000000000000000000000000008id
zJva~m00000@_%gvRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI3L
z_TWGO00000$p5twR8>_~RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
z+JgfU00000LH}R3BTxYV000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
O000000000006qd(Y)0Au
literal 0
HcmV?d00001
--
2.54.0
^ permalink raw reply
* [PATCH] staging: remove obsolete network and 16-bit video drivers
From: Gabriel Ramos @ 2026-06-14 2:16 UTC (permalink / raw)
To: andrew; +Cc: netdev, linux-kernel, linux-staging, Gabriel Ramos Barbosa Mota
From: Gabriel Ramos Barbosa Mota <maguraa53@gmail.com>
These drivers are currently in the staging tree and have been identified as unmaintained and obsolete. They lack modern hardware support, do not integrate with the current device model, and represent technical debt. This patch removes these drivers to clean up the staging area and reduce the overall maintenance burden, as there is no evidence of active users or ongoing development for these specific components. Signed-off-by: Gabriel Ramos <maguraa53@gmail.com>
---
teste_disco.img | Bin 0 -> 20971520 bytes
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 teste_disco.img
diff --git a/teste_disco.img b/teste_disco.img
new file mode 100644
index 0000000000000000000000000000000000000000..13145eb3ecf765e330220f06cf8ad7553c3d9ff2
GIT binary patch
literal 20971520
zcmeF)cdV859mny{y<AWM6-C7@;#Nf5sHiwl+<Olkh>8>U1}6^Odn*o1+N80r*p<dV
zurY1Y_KzBqrnc24O<QAAZERXonjb@MBNXZY;rn_ehunM4^W1ZO&pq$wIh^}E=ShI7
z{?R|l!AZK3+eRjT>7R6TUl;?Ec6p&!GU}bd<JzSo)2AQyVaJT=hP*R)-0aC`&)272
z(UA=AmrNU!oYmEly@rpT(6#CAYu^6z*M89VotLJ~p69Fe<mZ0e(%r7P@7aTYId$@0
z&ph<N(_=;qnm)dxV?_GSy1k8~_eULVG0f4GOljj^VEz7U%7Gd9*)r*_t0Q^4`xQ%o
zy?Za%ApUmuB|q&x<?Q9p!ne<sAO3YplIN1VkYw}KAM4dQtAIcM{!cqT*6ZG3^LkWw
zzIo5T+ilMzc|OUZoyq7m+FGLLj9JFt(AF96Uo)@yN3S~bmS>YpP4a1vWcu=R=6~S5
zHvi>!%xnIgemAdMfCbg#|JuF*OOh`ALs>ob4`ubzKa{nU{-La;^$%q&qkkx?xBj85
zKKh5U`syFbT2}v1)^hrXvX<9Bl+{oFP}U0ihq6}GKa|y9|4`OS`iHVs)<2ZBivFRj
z0s4osR@Fb0wVM8+tkv}oWv!uqC~HmqLs@I-AIe%=|4`OC`iHUx>L1ElSN~AfApJvG
z>**iLT3`QA)&}~AvNqH|l(mump{$Md4`pqle<*8H{X<!s=^x4(tbZtLbNxeEL-Y@2
zZJ~cCYpDLAtS$8qWo@N@C~Ir|Ls{GCAIjQR|4`O;`iHW%*FTgsO#e{U4*G|(cGN$V
zwUhp#tl|2HvUb)#l(mcgp{!l?4`q$eKa{nb{-Lbh^$%t3p?@fAPyIt#BlQnu?WKPx
zYj6ESS)=q1W$mMXC~IH+Ls|RjAIjQa|4`Ne`iHU()IXGUkp7{pgY^$(9io3I>rnke
zS%>K#$~s*CP}ULphq8{;Ka_Qp{-La+^$%qoqkkytSp7p;$LSx+I$r-!)(QHDvQE@L
zlr>uaP}WKMhq6xAKa_Qf{-LZ>^$%r@(La=Rn*O1zvHFLyPS-z_b%y?-tTXiwWsTE6
zly#Q=p{%p@4`rRBe<<r*{X<#j=^x5EU;j|nc>P0J7w8|#x={a6)<yb<vM$y?ly!;z
zp{z^w4`p4Ze<<s6{X<z-=pV|uQvXoaRr-gruGT-4b&dX^tO@#uvL@;u%DPtnP}X(&
zhqA8MKa_QY{-LZJ^$%s;q<<)DlK!EroAnQ6-J*Xe>sI|kS-0sQ%9^ZyDC>6pLs@s|
zAIiE@|4`Ol`iHXa)<2YWkN%;od-V@x-KT#j>wf)1Sr6zR%6d@$P}W2Ghq4~lKa}-|
z{-LZ#^$%q|rhh2was5MCPv{@YdQ$&T)>Hb2vYysIlr?>^wN%;P8GKc~iTQVYRf7Xy
zUM7AM*Z(X;%g^hnu^3y3iw_oOi*e-uz?U@Sox$T~U%upzT42Y$yTFrvZ9dp7Nmu4F
z{vPR^aj#3y__y~*9c{ADwD%~V@A=ucUr1-aWMC%U-F@cvJLvxXlI)FJm*mmS-^QEI
zf0`xP*a1uO=;rU`W9C22*KOjpNrrZH&0hD<S^sq8nwcxWFYKlHtRJ5n+SY&H>)rhh
z=G_0nF=PDcH<$H)M`o`2=f3`L8-poda^IO}_G#l^WkUCnF6{9yN<#)O%6nh*K0Rg8
zKZYN-*FQt&_WGwYtIl|MbASH#O)_;peb3M7Pqyd($dkHHx3Hi8Gy0!6xAAvm#Qzw7
zOaJ9BIsR{rYU3aH)S?_e000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z0000000000000000000000000000000000000000z@pNbq;EPpha|JU?(7^gB<Yjn
z*FAc7o_*eh7i~87yo=8rv#1^+@Kx)Z{HE`3|Fur*ynFwD>@l-{V9C|`UuT&kFK#3J
zxW|$^PT=!e|0fT-{@Qkn{-GBALtXlZy7Uiq=^yISKh&jvs7wD)m;RwH{X<>d`)|Ad
zb|vYVq*s!qk}REMnIye4^H`w1NtR8rT$1IJ^h>frk`<HmPqI>ym6NQJWI&QtldP6x
z^(1Q~Su@F6N!CuXPLhF1)=e@f$$ClFPqIOh4U=q?WaA{8B-u2{W=RGo**r-*PHBrI
zLz8ToWUC}wC)p;+wn?^2vVD?aNp?uGW0IYc3{SFil3kMQnq)+h-IDB{WRE0!CK;Jz
zuOxdX8I@$8B>N`WFUkH%4oGrfl7o^QoaB%shbB2J$>B+kNOEM7qmmq*<d`JKCOIz2
z@kvfda$=IvNlr>~a*|V$oSLK^UUgcMu}Mx(az>IflZ;DpR+6)moRj3-B<CeLKgswc
z7bLkb$wf)p&fJ$IxiraTNiI)vMUpF%T$SYNB-bRFkYr+#w)5w8Nv=<FLy{Yl+>~Te
zlADv<lH}GTw<VdJ<n|<YB)K!mT}kdva!-<bliZi&{v;11c`(UCNght}NRmgBJeK6~
zBu^xHGRad(p01l8z#`N2R=++ctUs)6et=?H|2@Yp(_WSV#kBs{{MD=Nzh*!&t^Ymm
zo7CQN0*Yz<@9_S#_O>ukOzZ#T=RawG{sD?<{a?1qsP-pcpqSSGz{4+ZyM_S8wEp+K
zWc#*z7f?*=f5mNjwcSR6Vp{)wZg{=zIt~=m`af*i&Fzp5pqSSGFHZm2tHp*5wBvo>
z>euI%4L)s$xdO$s{_nbfk9H_KP)zIpCvRWyVzFTZvtIvC`TOwpF*ramZTtVv*OvWJ
zv0($Vw*T)f_1)Jk45+7V|Gz)-`u0(mKryZVY1_WhK8_YBruF~Cr60AAVFrq6{ZD#x
z|Ea}>4a|D~@7)`(Zl|aKifP;bSEg?LLa|{3v$p>q{Gqd*t_mooZT~+$;)m@Nc0e($
z|8EbN{GDRM24=nfU+$G%+o@-PV%qlq$WNAQr(_0-Y5gCx_lxcH>_9QC{{cNGjwv>5
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000008(8dvG8C00000<p0_Ts;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a80
zs;a80s;a80s;a80s;a80s;a80s;a80s;a80s;a6g?9{zWRbd<l@b9scgk4B*iE<Fz
zq?#)oM98K<>JPX}Q%x>GOD=6?(F@`rL~7~o;NlPswlqjf+_9Ibf}oa$=*IDC-jE9t
z(h#2yJe>19zZcH)z<B@w000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000U>|+&OEQt9Om3e~
zKKCU>d;fu?8q3|S#nX+GSCeM*@|RX#Yu>V5cet7sMMip)7lX;QG8rGKPnAPs{nHz(
zYqiG8`c}z4d%UaPp|+JrixaPx?u;+Y&OEs?I@p{niqX`z;?+KSz7^Fm>?o7@YX5uI
z`$y(L27aGOyRt~$v@iSzF7)he6JPINf7PD3eg6D=Ck8K$&L?@AWI4&HV{_eITYtc(
zcOTEqbw51Q>8tL&eDJf1EhKrC<Wg5sKVIDu2RBP5Z&i23hnt=1>qlFW#Ux8fejG@e
zM|SFG-dFWE?slple%mPm000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000004jQ`S97<BxS2Z_1JtZlFhNp_(*-K92)DN-dJ6$HCEO;
z<pBTy000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z000000000000000000000000000000000000000000000000000000000000008id
zJva~m00000@_%gvRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI3L
z_TWGO00000$p5twR8>_~RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
zRaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40RaI40
z+JgfU00000LH}R3BTxYV000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
z00000000000000000000000000000000000000000000000000000000000000000
O000000000006qd(Y)0Au
literal 0
HcmV?d00001
--
2.54.0
^ permalink raw reply
* Re: [PATCH net v3] ip_tunnel: drop stale dst from generated PMTU ICMP replies
From: Jakub Kicinski @ 2026-06-14 1:42 UTC (permalink / raw)
To: Laika Price via B4 Relay
Cc: laikabcprice, David Ahern, Ido Schimmel, David S. Miller,
Eric Dumazet, Paolo Abeni, Simon Horman, Shuah Khan, netdev,
linux-kernel, linux-kselftest
In-Reply-To: <20260614-master-v3-1-9f5060ba1ed1@gmail.com>
On Sun, 14 Jun 2026 00:13:57 +0100 Laika Price via B4 Relay wrote:
> Changes in v3:
> - Squashed the selftest update into the ip_tunnel fix so the patch remains
> bisectable.
> - Link to v2: https://patch.msgid.link/20260613-master-v2-0-061b70fd45dd@gmail.com
>
> Changes in v2:
> - Fixed incorrect PMTU exception generation in the selftest.
> - Link to v1: https://patch.msgid.link/20260613-master-v1-1-df796e8e2d74@gmail.com
It's still failing the tests.
Please do not repost it again until someone guides you towards
a correct fix.
^ permalink raw reply
* [PATCH net-next 5/5] selftests/bpf: test that TLS crypto is rejected on a sockmap socket
From: Jakub Kicinski @ 2026-06-14 1:41 UTC (permalink / raw)
To: davem
Cc: netdev, edumazet, pabeni, andrew+netdev, horms, bpf, jakub,
john.fastabend, sd, Jakub Kicinski
In-Reply-To: <20260614014102.461064-1-kuba@kernel.org>
TLS and sockmap are mutually exclusive. We already have a test
for the sockmap side rejecting kTLS, add the inverse test matching
patch 1 of this series.
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
---
.../selftests/bpf/prog_tests/sockmap_ktls.c | 65 +++++++++++++++++++
1 file changed, 65 insertions(+)
diff --git a/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c b/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
index cda6b22cf759..34737e8df6ea 100644
--- a/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
+++ b/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
@@ -116,6 +116,68 @@ static void test_sockmap_ktls_update_fails_when_sock_has_ulp(int family, int map
close(s);
}
+static void test_sockmap_ktls_enable_fails_when_in_sockmap(int family, int map)
+{
+ struct tls12_crypto_info_aes_gcm_128 crypto = {
+ .info = {
+ .version = TLS_1_2_VERSION,
+ .cipher_type = TLS_CIPHER_AES_GCM_128,
+ },
+ };
+ struct sockaddr_storage addr = {};
+ socklen_t len = sizeof(addr);
+ struct sockaddr_in6 *v6;
+ struct sockaddr_in *v4;
+ int err, s, zero = 0;
+
+ switch (family) {
+ case AF_INET:
+ v4 = (struct sockaddr_in *)&addr;
+ v4->sin_family = AF_INET;
+ break;
+ case AF_INET6:
+ v6 = (struct sockaddr_in6 *)&addr;
+ v6->sin6_family = AF_INET6;
+ break;
+ default:
+ PRINT_FAIL("unsupported socket family %d", family);
+ return;
+ }
+
+ s = socket(family, SOCK_STREAM, 0);
+ if (!ASSERT_GE(s, 0, "socket"))
+ return;
+
+ err = bind(s, (struct sockaddr *)&addr, len);
+ if (!ASSERT_OK(err, "bind"))
+ goto close;
+
+ err = getsockname(s, (struct sockaddr *)&addr, &len);
+ if (!ASSERT_OK(err, "getsockname"))
+ goto close;
+
+ err = connect(s, (struct sockaddr *)&addr, len);
+ if (!ASSERT_OK(err, "connect"))
+ goto close;
+
+ /* Add the socket to the sockmap, attaching a psock. */
+ err = bpf_map_update_elem(map, &zero, &s, BPF_ANY);
+ if (!ASSERT_OK(err, "sockmap update elem"))
+ goto close;
+
+ /* Installing the TLS ULP is allowed, it does not touch the datapath. */
+ err = setsockopt(s, IPPROTO_TCP, TCP_ULP, "tls", strlen("tls"));
+ if (!ASSERT_OK(err, "setsockopt(TCP_ULP)"))
+ goto close;
+
+ /* Enabling the TLS crypto datapath must be rejected. */
+ err = setsockopt(s, SOL_TLS, TLS_TX, &crypto, sizeof(crypto));
+ ASSERT_ERR(err, "setsockopt(TLS_TX)");
+
+close:
+ close(s);
+}
+
static const char *fmt_test_name(const char *subtest_name, int family,
enum bpf_map_type map_type)
{
@@ -170,6 +232,9 @@ static void run_tests(int family, enum bpf_map_type map_type)
if (test__start_subtest(fmt_test_name("update_fails_when_sock_has_ulp", family, map_type)))
test_sockmap_ktls_update_fails_when_sock_has_ulp(family, map);
+ if (test__start_subtest(fmt_test_name("enable_fails_when_in_sockmap", family, map_type)))
+ test_sockmap_ktls_enable_fails_when_in_sockmap(family, map);
+
close(map);
}
--
2.54.0
^ permalink raw reply related
* [PATCH net-next 4/5] selftests/bpf: drop the unused kTLS program from test_sockmap
From: Jakub Kicinski @ 2026-06-14 1:40 UTC (permalink / raw)
To: davem
Cc: netdev, edumazet, pabeni, andrew+netdev, horms, bpf, jakub,
john.fastabend, sd, Jakub Kicinski
In-Reply-To: <20260614014102.461064-1-kuba@kernel.org>
With the sockmap + kTLS tests gone, the BPF-side support in test_sockmap
is dead: the tls_sock_map map and bpf_prog3 (which redirected skbs into
it) are no longer referenced. Remove them, along with the now-unused
bpf_write_pass() helper.
bpf_prog3 was progs[2], so renumber the progs[] users in test_sockmap.c:
the sockops program drops to progs[2] and the sk_msg tx programs to
progs[3..7]. Shrink the map/prog arrays from 9 to 8 and drop the
tls_sock_map entry (the last one) from map_names[] to match.
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
---
.../selftests/bpf/progs/test_sockmap_kern.h | 56 -------------------
tools/testing/selftests/bpf/test_sockmap.c | 23 ++++----
2 files changed, 11 insertions(+), 68 deletions(-)
diff --git a/tools/testing/selftests/bpf/progs/test_sockmap_kern.h b/tools/testing/selftests/bpf/progs/test_sockmap_kern.h
index f48f85f1bd70..284a2f2e50cf 100644
--- a/tools/testing/selftests/bpf/progs/test_sockmap_kern.h
+++ b/tools/testing/selftests/bpf/progs/test_sockmap_kern.h
@@ -85,13 +85,6 @@ struct {
__type(value, int);
} sock_skb_opts SEC(".maps");
-struct {
- __uint(type, TEST_MAP_TYPE);
- __uint(max_entries, 20);
- __uint(key_size, sizeof(int));
- __uint(value_size, sizeof(int));
-} tls_sock_map SEC(".maps");
-
SEC("sk_skb/stream_parser")
int bpf_prog1(struct __sk_buff *skb)
{
@@ -135,55 +128,6 @@ int bpf_prog2(struct __sk_buff *skb)
}
-static inline void bpf_write_pass(struct __sk_buff *skb, int offset)
-{
- int err = bpf_skb_pull_data(skb, 6 + offset);
- void *data_end;
- char *c;
-
- if (err)
- return;
-
- c = (char *)(long)skb->data;
- data_end = (void *)(long)skb->data_end;
-
- if (c + 5 + offset < data_end)
- memcpy(c + offset, "PASS", 4);
-}
-
-SEC("sk_skb/stream_verdict")
-int bpf_prog3(struct __sk_buff *skb)
-{
- int err, *f, ret = SK_PASS;
- const int one = 1;
-
- f = bpf_map_lookup_elem(&sock_skb_opts, &one);
- if (f && *f) {
- __u64 flags = 0;
-
- ret = 0;
- flags = *f;
-
- err = bpf_skb_adjust_room(skb, -13, 0, 0);
- if (err)
- return SK_DROP;
- err = bpf_skb_adjust_room(skb, 4, 0, 0);
- if (err)
- return SK_DROP;
- bpf_write_pass(skb, 0);
-#ifdef SOCKMAP
- return bpf_sk_redirect_map(skb, &tls_sock_map, ret, flags);
-#else
- return bpf_sk_redirect_hash(skb, &tls_sock_map, &ret, flags);
-#endif
- }
- err = bpf_skb_adjust_room(skb, 4, 0, 0);
- if (err)
- return SK_DROP;
- bpf_write_pass(skb, 13);
- return ret;
-}
-
SEC("sockops")
int bpf_sockmap(struct bpf_sock_ops *skops)
{
diff --git a/tools/testing/selftests/bpf/test_sockmap.c b/tools/testing/selftests/bpf/test_sockmap.c
index 32d6068df4b3..ac814eb63edb 100644
--- a/tools/testing/selftests/bpf/test_sockmap.c
+++ b/tools/testing/selftests/bpf/test_sockmap.c
@@ -55,10 +55,10 @@ int s1, s2, c1, c2, p1, p2;
int test_cnt;
int passed;
int failed;
-int map_fd[9];
-struct bpf_map *maps[9];
-struct bpf_program *progs[9];
-struct bpf_link *links[9];
+int map_fd[8];
+struct bpf_map *maps[8];
+struct bpf_program *progs[8];
+struct bpf_link *links[8];
int txmsg_pass;
int txmsg_redir;
@@ -967,7 +967,7 @@ static int run_options(struct sockmap_options *options, int cg_fd, int test)
}
/* Attach to cgroups */
- err = bpf_prog_attach(bpf_program__fd(progs[3]), cg_fd, BPF_CGROUP_SOCK_OPS, 0);
+ err = bpf_prog_attach(bpf_program__fd(progs[2]), cg_fd, BPF_CGROUP_SOCK_OPS, 0);
if (err) {
fprintf(stderr, "ERROR: bpf_prog_attach (groups): %d (%s)\n",
err, strerror(errno));
@@ -983,15 +983,15 @@ static int run_options(struct sockmap_options *options, int cg_fd, int test)
/* Attach txmsg program to sockmap */
if (txmsg_pass)
- tx_prog = progs[4];
+ tx_prog = progs[3];
else if (txmsg_redir)
- tx_prog = progs[5];
+ tx_prog = progs[4];
else if (txmsg_apply)
- tx_prog = progs[6];
+ tx_prog = progs[5];
else if (txmsg_cork)
- tx_prog = progs[7];
+ tx_prog = progs[6];
else if (txmsg_drop)
- tx_prog = progs[8];
+ tx_prog = progs[7];
else
tx_prog = NULL;
@@ -1218,7 +1218,7 @@ static int run_options(struct sockmap_options *options, int cg_fd, int test)
fprintf(stderr, "unknown test\n");
out:
/* Detach and zero all the maps */
- bpf_prog_detach2(bpf_program__fd(progs[3]), cg_fd, BPF_CGROUP_SOCK_OPS);
+ bpf_prog_detach2(bpf_program__fd(progs[2]), cg_fd, BPF_CGROUP_SOCK_OPS);
for (i = 0; i < ARRAY_SIZE(links); i++) {
if (links[i])
@@ -1724,7 +1724,6 @@ char *map_names[] = {
"sock_bytes",
"sock_redir_flags",
"sock_skb_opts",
- "tls_sock_map",
};
static int populate_progs(char *bpf_file)
--
2.54.0
^ permalink raw reply related
* [PATCH net-next 3/5] selftests/bpf: remove sockmap + ktls tests
From: Jakub Kicinski @ 2026-06-14 1:40 UTC (permalink / raw)
To: davem
Cc: netdev, edumazet, pabeni, andrew+netdev, horms, bpf, jakub,
john.fastabend, sd, Jakub Kicinski
In-Reply-To: <20260614014102.461064-1-kuba@kernel.org>
The combination of sockmap and TLS is no longer supported - installing
the TLS ULP on a sockmap socket (and vice versa) is now rejected. Remove
the tests that exercise the combination along with their BPF program;
the file covered nothing but sockmap sockets holding kTLS contexts.
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
---
.../selftests/bpf/prog_tests/sockmap_ktls.c | 355 ------------------
.../selftests/bpf/progs/test_sockmap_ktls.c | 61 ---
tools/testing/selftests/bpf/test_sockmap.c | 227 +----------
3 files changed, 1 insertion(+), 642 deletions(-)
delete mode 100644 tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
diff --git a/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c b/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
index 6ed8e149e3d5..cda6b22cf759 100644
--- a/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
+++ b/tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c
@@ -9,7 +9,6 @@
#include "test_progs.h"
#include "sockmap_helpers.h"
#include "test_skmsg_load_helpers.skel.h"
-#include "test_sockmap_ktls.skel.h"
#define MAX_TEST_NAME 80
#define TCP_ULP 31
@@ -160,249 +159,6 @@ static void test_sockmap_ktls_offload(int family, int sotype)
close(p);
}
-static void test_sockmap_ktls_tx_cork(int family, int sotype, bool push)
-{
- int err, off;
- int i, j;
- int start_push = 0, push_len = 0;
- int c = 0, p = 0, one = 1, sent, recvd;
- int prog_fd, map_fd;
- char msg[12] = "hello world\0";
- char rcv[20] = {0};
- struct test_sockmap_ktls *skel;
-
- skel = test_sockmap_ktls__open_and_load();
- if (!ASSERT_TRUE(skel, "open ktls skel"))
- return;
-
- err = create_pair(family, sotype, &c, &p);
- if (!ASSERT_OK(err, "create_pair()"))
- goto out;
-
- prog_fd = bpf_program__fd(skel->progs.prog_sk_policy);
- map_fd = bpf_map__fd(skel->maps.sock_map);
-
- err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);
- if (!ASSERT_OK(err, "bpf_prog_attach sk msg"))
- goto out;
-
- err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);
- if (!ASSERT_OK(err, "bpf_map_update_elem(c)"))
- goto out;
-
- err = init_ktls_pairs(c, p);
- if (!ASSERT_OK(err, "init_ktls_pairs(c, p)"))
- goto out;
-
- skel->bss->cork_byte = sizeof(msg);
- if (push) {
- start_push = 1;
- push_len = 2;
- }
- skel->bss->push_start = start_push;
- skel->bss->push_end = push_len;
-
- off = sizeof(msg) / 2;
- sent = send(c, msg, off, 0);
- if (!ASSERT_EQ(sent, off, "send(msg)"))
- goto out;
-
- recvd = recv_timeout(p, rcv, sizeof(rcv), MSG_DONTWAIT, 1);
- if (!ASSERT_EQ(-1, recvd, "expected no data"))
- goto out;
-
- /* send remaining msg */
- sent = send(c, msg + off, sizeof(msg) - off, 0);
- if (!ASSERT_EQ(sent, sizeof(msg) - off, "send remaining data"))
- goto out;
-
- recvd = recv_timeout(p, rcv, sizeof(rcv), MSG_DONTWAIT, 1);
- if (!ASSERT_OK(err, "recv(msg)") ||
- !ASSERT_EQ(recvd, sizeof(msg) + push_len, "check length mismatch"))
- goto out;
-
- for (i = 0, j = 0; i < recvd;) {
- /* skip checking the data that has been pushed in */
- if (i >= start_push && i <= start_push + push_len - 1) {
- i++;
- continue;
- }
- if (!ASSERT_EQ(rcv[i], msg[j], "data mismatch"))
- goto out;
- i++;
- j++;
- }
-out:
- if (c)
- close(c);
- if (p)
- close(p);
- test_sockmap_ktls__destroy(skel);
-}
-
-static void test_sockmap_ktls_tx_no_buf(int family, int sotype, bool push)
-{
- int c = -1, p = -1, one = 1, two = 2;
- struct test_sockmap_ktls *skel;
- unsigned char *data = NULL;
- struct msghdr msg = {0};
- struct iovec iov[2];
- int prog_fd, map_fd;
- int txrx_buf = 1024;
- int iov_length = 8192;
- int err;
-
- skel = test_sockmap_ktls__open_and_load();
- if (!ASSERT_TRUE(skel, "open ktls skel"))
- return;
-
- err = create_pair(family, sotype, &c, &p);
- if (!ASSERT_OK(err, "create_pair()"))
- goto out;
-
- err = setsockopt(c, SOL_SOCKET, SO_RCVBUFFORCE, &txrx_buf, sizeof(int));
- err |= setsockopt(p, SOL_SOCKET, SO_SNDBUFFORCE, &txrx_buf, sizeof(int));
- if (!ASSERT_OK(err, "set buf limit"))
- goto out;
-
- prog_fd = bpf_program__fd(skel->progs.prog_sk_policy_redir);
- map_fd = bpf_map__fd(skel->maps.sock_map);
-
- err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);
- if (!ASSERT_OK(err, "bpf_prog_attach sk msg"))
- goto out;
-
- err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);
- if (!ASSERT_OK(err, "bpf_map_update_elem(c)"))
- goto out;
-
- err = bpf_map_update_elem(map_fd, &two, &p, BPF_NOEXIST);
- if (!ASSERT_OK(err, "bpf_map_update_elem(p)"))
- goto out;
-
- skel->bss->apply_bytes = 1024;
-
- err = init_ktls_pairs(c, p);
- if (!ASSERT_OK(err, "init_ktls_pairs(c, p)"))
- goto out;
-
- data = calloc(iov_length, sizeof(char));
- if (!data)
- goto out;
-
- iov[0].iov_base = data;
- iov[0].iov_len = iov_length;
- iov[1].iov_base = data;
- iov[1].iov_len = iov_length;
- msg.msg_iov = iov;
- msg.msg_iovlen = 2;
-
- for (;;) {
- err = sendmsg(c, &msg, MSG_DONTWAIT);
- if (err <= 0)
- break;
- }
-
-out:
- if (data)
- free(data);
- if (c != -1)
- close(c);
- if (p != -1)
- close(p);
-
- test_sockmap_ktls__destroy(skel);
-}
-
-static void test_sockmap_ktls_tx_pop(int family, int sotype)
-{
- char msg[37] = "0123456789abcdefghijklmnopqrstuvwxyz\0";
- int c = 0, p = 0, one = 1, sent, recvd;
- struct test_sockmap_ktls *skel;
- int prog_fd, map_fd;
- char rcv[50] = {0};
- int err;
- int i, m, r;
-
- skel = test_sockmap_ktls__open_and_load();
- if (!ASSERT_TRUE(skel, "open ktls skel"))
- return;
-
- err = create_pair(family, sotype, &c, &p);
- if (!ASSERT_OK(err, "create_pair()"))
- goto out;
-
- prog_fd = bpf_program__fd(skel->progs.prog_sk_policy);
- map_fd = bpf_map__fd(skel->maps.sock_map);
-
- err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT, 0);
- if (!ASSERT_OK(err, "bpf_prog_attach sk msg"))
- goto out;
-
- err = bpf_map_update_elem(map_fd, &one, &c, BPF_NOEXIST);
- if (!ASSERT_OK(err, "bpf_map_update_elem(c)"))
- goto out;
-
- err = init_ktls_pairs(c, p);
- if (!ASSERT_OK(err, "init_ktls_pairs(c, p)"))
- goto out;
-
- struct {
- int pop_start;
- int pop_len;
- } pop_policy[] = {
- /* trim the start */
- {0, 2},
- {0, 10},
- {1, 2},
- {1, 10},
- /* trim the end */
- {35, 2},
- /* New entries should be added before this line */
- {-1, -1},
- };
-
- i = 0;
- while (pop_policy[i].pop_start >= 0) {
- skel->bss->pop_start = pop_policy[i].pop_start;
- skel->bss->pop_end = pop_policy[i].pop_len;
-
- sent = send(c, msg, sizeof(msg), 0);
- if (!ASSERT_EQ(sent, sizeof(msg), "send(msg)"))
- goto out;
-
- recvd = recv_timeout(p, rcv, sizeof(rcv), MSG_DONTWAIT, 1);
- if (!ASSERT_EQ(recvd, sizeof(msg) - pop_policy[i].pop_len, "pop len mismatch"))
- goto out;
-
- /* verify the data
- * msg: 0123456789a bcdefghij klmnopqrstuvwxyz
- * | |
- * popped data
- */
- for (m = 0, r = 0; m < sizeof(msg);) {
- /* skip checking the data that has been popped */
- if (m >= pop_policy[i].pop_start &&
- m <= pop_policy[i].pop_start + pop_policy[i].pop_len - 1) {
- m++;
- continue;
- }
-
- if (!ASSERT_EQ(msg[m], rcv[r], "data mismatch"))
- goto out;
- m++;
- r++;
- }
- i++;
- }
-out:
- if (c)
- close(c);
- if (p)
- close(p);
- test_sockmap_ktls__destroy(skel);
-}
-
static void run_tests(int family, enum bpf_map_type map_type)
{
int map;
@@ -417,121 +173,10 @@ static void run_tests(int family, enum bpf_map_type map_type)
close(map);
}
-/*
- * Regression test for the KTLS + sockmap (verdict) reverse-order UAF.
- *
- * Vulnerable sequence:
- * 1. Insert receiver socket into sockmap with BPF_SK_SKB_VERDICT program.
- * sk->sk_data_ready becomes sk_psock_verdict_data_ready.
- * 2. Configure TLS RX: tls_sw_strparser_arm() saves
- * sk_psock_verdict_data_ready as rx_ctx->saved_data_ready.
- *
- * When data arrives, tls_rx_msg_ready() calls saved_data_ready() =
- * sk_psock_verdict_data_ready(), which calls tcp_read_skb() and drains
- * sk_receive_queue via __skb_unlink() without advancing copied_seq.
- * tls_strp_msg_load() then finds the queue empty while tcp_inq() is still
- * non-zero, hits WARN_ON_ONCE(!first), and leaves a dangling frag_list
- * pointer that tls_decrypt_sg() walks — a use-after-free.
- *
- * The fix adds a tls_sw_has_ctx_rx() check to sk_psock_verdict_data_ready(),
- * mirroring what sk_psock_strp_data_ready() already does: when a TLS RX
- * context is present, defer to psock->saved_data_ready (sock_def_readable)
- * instead of calling tcp_read_skb(), so TLS retains sole ownership of the
- * receive queue. Data is then decrypted and returned correctly by
- * tls_sw_recvmsg().
- */
-static void test_sockmap_ktls_verdict_with_tls_rx(int family, int sotype)
-{
- struct tls12_crypto_info_aes_gcm_128 crypto_info = {};
- char send_buf[] = "hello ktls sockmap reverse order";
- char recv_buf[sizeof(send_buf)] = {};
- struct test_sockmap_ktls *skel;
- int c = -1, p = -1, zero = 0;
- int prog_fd, map_fd;
- ssize_t n;
- int err;
-
- skel = test_sockmap_ktls__open_and_load();
- if (!ASSERT_TRUE(skel, "open_and_load"))
- return;
-
- err = create_pair(family, sotype, &c, &p);
- if (!ASSERT_OK(err, "create_pair"))
- goto out;
-
- prog_fd = bpf_program__fd(skel->progs.prog_skb_verdict_pass);
- map_fd = bpf_map__fd(skel->maps.sock_map_verdict);
-
- err = bpf_prog_attach(prog_fd, map_fd, BPF_SK_SKB_VERDICT, 0);
- if (!ASSERT_OK(err, "bpf_prog_attach sk_skb verdict"))
- goto out;
-
- /* Step 1: configure TLS TX on sender (no sockmap involvement) */
- err = setsockopt(c, IPPROTO_TCP, TCP_ULP, "tls", strlen("tls"));
- if (!ASSERT_OK(err, "setsockopt(TCP_ULP) client"))
- goto out;
-
- crypto_info.info.version = TLS_1_2_VERSION;
- crypto_info.info.cipher_type = TLS_CIPHER_AES_GCM_128;
- memset(crypto_info.key, 0x01, sizeof(crypto_info.key));
- memset(crypto_info.salt, 0x02, sizeof(crypto_info.salt));
-
- err = setsockopt(c, SOL_TLS, TLS_TX, &crypto_info, sizeof(crypto_info));
- if (!ASSERT_OK(err, "setsockopt(TLS_TX)"))
- goto out;
-
- /* Step 2: insert receiver into sockmap BEFORE TLS RX */
- err = bpf_map_update_elem(map_fd, &zero, &p, BPF_NOEXIST);
- if (!ASSERT_OK(err, "bpf_map_update_elem"))
- goto out;
-
- /* Step 3: configure TLS RX AFTER sockmap insertion */
- err = setsockopt(p, IPPROTO_TCP, TCP_ULP, "tls", strlen("tls"));
- if (!ASSERT_OK(err, "setsockopt(TCP_ULP) server"))
- goto out;
-
- err = setsockopt(p, SOL_TLS, TLS_RX, &crypto_info, sizeof(crypto_info));
- if (!ASSERT_OK(err, "setsockopt(TLS_RX)"))
- goto out;
-
- /*
- * A buggy kernel hits WARN_ON_ONCE in tls_strp_load_anchor_with_queue
- * and may UAF in tls_decrypt_sg here. With the fix,
- * sk_psock_verdict_data_ready defers to sock_def_readable and TLS
- * decrypts the record normally.
- */
- n = send(c, send_buf, sizeof(send_buf), 0);
- if (!ASSERT_EQ(n, (ssize_t)sizeof(send_buf), "send"))
- goto out;
-
- n = recv_timeout(p, recv_buf, sizeof(recv_buf), 0, 5);
- if (!ASSERT_EQ(n, (ssize_t)sizeof(send_buf), "recv"))
- goto out;
-
- ASSERT_OK(memcmp(send_buf, recv_buf, sizeof(send_buf)), "data integrity");
-
-out:
- if (c != -1)
- close(c);
- if (p != -1)
- close(p);
- test_sockmap_ktls__destroy(skel);
-}
-
static void run_ktls_test(int family, int sotype)
{
if (test__start_subtest("tls simple offload"))
test_sockmap_ktls_offload(family, sotype);
- if (test__start_subtest("tls tx cork"))
- test_sockmap_ktls_tx_cork(family, sotype, false);
- if (test__start_subtest("tls tx cork with push"))
- test_sockmap_ktls_tx_cork(family, sotype, true);
- if (test__start_subtest("tls tx egress with no buf"))
- test_sockmap_ktls_tx_no_buf(family, sotype, true);
- if (test__start_subtest("tls tx with pop"))
- test_sockmap_ktls_tx_pop(family, sotype);
- if (test__start_subtest("tls verdict with tls rx"))
- test_sockmap_ktls_verdict_with_tls_rx(family, sotype);
}
void test_sockmap_ktls(void)
diff --git a/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c b/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
deleted file mode 100644
index facafeaf4620..000000000000
--- a/tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
+++ /dev/null
@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-#include <linux/bpf.h>
-#include <bpf/bpf_helpers.h>
-#include <bpf/bpf_endian.h>
-
-int cork_byte;
-int push_start;
-int push_end;
-int apply_bytes;
-int pop_start;
-int pop_end;
-
-struct {
- __uint(type, BPF_MAP_TYPE_SOCKMAP);
- __uint(max_entries, 20);
- __type(key, int);
- __type(value, int);
-} sock_map SEC(".maps");
-
-struct {
- __uint(type, BPF_MAP_TYPE_SOCKMAP);
- __uint(max_entries, 2);
- __type(key, int);
- __type(value, int);
-} sock_map_verdict SEC(".maps");
-
-SEC("sk_msg")
-int prog_sk_policy(struct sk_msg_md *msg)
-{
- if (cork_byte > 0)
- bpf_msg_cork_bytes(msg, cork_byte);
- if (push_start > 0 && push_end > 0)
- bpf_msg_push_data(msg, push_start, push_end, 0);
- if (pop_start >= 0 && pop_end > 0)
- bpf_msg_pop_data(msg, pop_start, pop_end, 0);
-
- return SK_PASS;
-}
-
-SEC("sk_msg")
-int prog_sk_policy_redir(struct sk_msg_md *msg)
-{
- int two = 2;
-
- bpf_msg_apply_bytes(msg, apply_bytes);
- return bpf_msg_redirect_map(msg, &sock_map, two, 0);
-}
-
-/*
- * Verdict program for the reverse-order TLS/sockmap regression test.
- * Returns SK_PASS so tcp_read_skb() drains the receive queue via
- * sk_psock_verdict_recv() without calling tcp_eat_skb(), which is
- * the precondition for the KTLS strparser frag_list UAF.
- */
-SEC("sk_skb/verdict")
-int prog_skb_verdict_pass(struct __sk_buff *skb)
-{
- return SK_PASS;
-}
-
-char _license[] SEC("license") = "GPL";
diff --git a/tools/testing/selftests/bpf/test_sockmap.c b/tools/testing/selftests/bpf/test_sockmap.c
index 76568db7a664..32d6068df4b3 100644
--- a/tools/testing/selftests/bpf/test_sockmap.c
+++ b/tools/testing/selftests/bpf/test_sockmap.c
@@ -26,7 +26,6 @@
#include <linux/sock_diag.h>
#include <linux/bpf.h>
#include <linux/if_link.h>
-#include <linux/tls.h>
#include <assert.h>
#include <libgen.h>
@@ -41,13 +40,6 @@
int running;
static void running_handler(int a);
-#ifndef TCP_ULP
-# define TCP_ULP 31
-#endif
-#ifndef SOL_TLS
-# define SOL_TLS 282
-#endif
-
/* randomly selected ports for testing on lo */
#define S1_PORT 10000
#define S2_PORT 10001
@@ -81,10 +73,6 @@ int txmsg_start_pop;
int txmsg_pop;
int txmsg_ingress;
int txmsg_redir_skb;
-int txmsg_ktls_skb;
-int txmsg_ktls_skb_drop;
-int txmsg_ktls_skb_redir;
-int ktls;
int peek_flag;
int skb_use_parser;
int txmsg_omit_skb_parser;
@@ -115,7 +103,6 @@ static const struct option long_options[] = {
{"txmsg_pop", required_argument, NULL, 'x'},
{"txmsg_ingress", no_argument, &txmsg_ingress, 1 },
{"txmsg_redir_skb", no_argument, &txmsg_redir_skb, 1 },
- {"ktls", no_argument, &ktls, 1 },
{"peek", no_argument, &peek_flag, 1 },
{"txmsg_omit_skb_parser", no_argument, &txmsg_omit_skb_parser, 1},
{"whitelist", required_argument, NULL, 'n' },
@@ -183,7 +170,6 @@ static void test_reset(void)
txmsg_pass = txmsg_drop = txmsg_redir = 0;
txmsg_apply = txmsg_cork = 0;
txmsg_ingress = txmsg_redir_skb = 0;
- txmsg_ktls_skb = txmsg_ktls_skb_drop = txmsg_ktls_skb_redir = 0;
txmsg_omit_skb_parser = 0;
skb_use_parser = 0;
}
@@ -238,71 +224,6 @@ static void usage(char *argv[])
printf("\n");
}
-char *sock_to_string(int s)
-{
- if (s == c1)
- return "client1";
- else if (s == c2)
- return "client2";
- else if (s == s1)
- return "server1";
- else if (s == s2)
- return "server2";
- else if (s == p1)
- return "peer1";
- else if (s == p2)
- return "peer2";
- else
- return "unknown";
-}
-
-static int sockmap_init_ktls(int verbose, int s)
-{
- struct tls12_crypto_info_aes_gcm_128 tls_tx = {
- .info = {
- .version = TLS_1_2_VERSION,
- .cipher_type = TLS_CIPHER_AES_GCM_128,
- },
- };
- struct tls12_crypto_info_aes_gcm_128 tls_rx = {
- .info = {
- .version = TLS_1_2_VERSION,
- .cipher_type = TLS_CIPHER_AES_GCM_128,
- },
- };
- int so_buf = 6553500;
- int err;
-
- err = setsockopt(s, 6, TCP_ULP, "tls", sizeof("tls"));
- if (err) {
- fprintf(stderr, "setsockopt: TCP_ULP(%s) failed with error %i\n", sock_to_string(s), err);
- return -EINVAL;
- }
- err = setsockopt(s, SOL_TLS, TLS_TX, (void *)&tls_tx, sizeof(tls_tx));
- if (err) {
- fprintf(stderr, "setsockopt: TLS_TX(%s) failed with error %i\n", sock_to_string(s), err);
- return -EINVAL;
- }
- err = setsockopt(s, SOL_TLS, TLS_RX, (void *)&tls_rx, sizeof(tls_rx));
- if (err) {
- fprintf(stderr, "setsockopt: TLS_RX(%s) failed with error %i\n", sock_to_string(s), err);
- return -EINVAL;
- }
- err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, &so_buf, sizeof(so_buf));
- if (err) {
- fprintf(stderr, "setsockopt: (%s) failed sndbuf with error %i\n", sock_to_string(s), err);
- return -EINVAL;
- }
- err = setsockopt(s, SOL_SOCKET, SO_RCVBUF, &so_buf, sizeof(so_buf));
- if (err) {
- fprintf(stderr, "setsockopt: (%s) failed rcvbuf with error %i\n", sock_to_string(s), err);
- return -EINVAL;
- }
-
- if (verbose)
- fprintf(stdout, "socket(%s) kTLS enabled\n", sock_to_string(s));
- return 0;
-}
static int sockmap_init_sockets(int verbose)
{
int i, err, one = 1;
@@ -557,19 +478,6 @@ static int msg_verify_data(struct msghdr *msg, int size, int chunk_sz,
for (i = 0, j = 0; i < msg->msg_iovlen && size; i++, j = 0) {
unsigned char *d = msg->msg_iov[i].iov_base;
- /* Special case test for skb ingress + ktls */
- if (i == 0 && txmsg_ktls_skb) {
- if (msg->msg_iov[i].iov_len < 4)
- return -EDATAINTEGRITY;
- if (memcmp(d, "PASS", 4) != 0) {
- fprintf(stderr,
- "detected skb data error with skb ingress update @iov[%i]:%i \"%02x %02x %02x %02x\" != \"PASS\"\n",
- i, 0, d[0], d[1], d[2], d[3]);
- return -EDATAINTEGRITY;
- }
- j = 4; /* advance index past PASS header */
- }
-
for (; j < msg->msg_iov[i].iov_len && size; j++) {
if (push > 0 &&
check_cnt == verify_push_start + verify_push_len - push) {
@@ -849,21 +757,6 @@ static int sendmsg_test(struct sockmap_options *opt)
else
rx_fd = p2;
- if (ktls) {
- /* Redirecting into non-TLS socket which sends into a TLS
- * socket is not a valid test. So in this case lets not
- * enable kTLS but still run the test.
- */
- if (!txmsg_redir || txmsg_ingress) {
- err = sockmap_init_ktls(opt->verbose, rx_fd);
- if (err)
- return err;
- }
- err = sockmap_init_ktls(opt->verbose, c1);
- if (err)
- return err;
- }
-
if (opt->tx_wait_mem) {
struct timeval timeout;
int rxtx_buf_len = 1024;
@@ -882,7 +775,7 @@ static int sendmsg_test(struct sockmap_options *opt)
rxpid = fork();
if (rxpid == 0) {
- if (opt->drop_expected || txmsg_ktls_skb_drop)
+ if (opt->drop_expected)
_exit(0);
if (!iov_buf) /* zero bytes sent case */
@@ -1073,26 +966,6 @@ static int run_options(struct sockmap_options *options, int cg_fd, int test)
return -1;
}
- /* Attach programs to TLS sockmap */
- if (txmsg_ktls_skb) {
- if (!txmsg_omit_skb_parser) {
- links[2] = bpf_program__attach_sockmap(progs[0], map_fd[8]);
- if (!links[2]) {
- fprintf(stderr,
- "ERROR: bpf_program__attach_sockmap (TLS sockmap %i->%i): (%s)\n",
- bpf_program__fd(progs[0]), map_fd[8], strerror(errno));
- return -1;
- }
- }
-
- links[3] = bpf_program__attach_sockmap(progs[2], map_fd[8]);
- if (!links[3]) {
- fprintf(stderr, "ERROR: bpf_program__attach_sockmap (TLS sockmap): (%s)\n",
- strerror(errno));
- return -1;
- }
- }
-
/* Attach to cgroups */
err = bpf_prog_attach(bpf_program__fd(progs[3]), cg_fd, BPF_CGROUP_SOCK_OPS, 0);
if (err) {
@@ -1291,34 +1164,6 @@ static int run_options(struct sockmap_options *options, int cg_fd, int test)
}
}
- if (txmsg_ktls_skb) {
- int ingress = BPF_F_INGRESS;
-
- i = 0;
- err = bpf_map_update_elem(map_fd[8], &i, &p2, BPF_ANY);
- if (err) {
- fprintf(stderr,
- "ERROR: bpf_map_update_elem (c1 sockmap): %d (%s)\n",
- err, strerror(errno));
- }
-
- if (txmsg_ktls_skb_redir) {
- i = 1;
- err = bpf_map_update_elem(map_fd[7],
- &i, &ingress, BPF_ANY);
- if (err) {
- fprintf(stderr,
- "ERROR: bpf_map_update_elem (txmsg_ingress): %d (%s)\n",
- err, strerror(errno));
- }
- }
-
- if (txmsg_ktls_skb_drop) {
- i = 1;
- err = bpf_map_update_elem(map_fd[7], &i, &i, BPF_ANY);
- }
- }
-
if (txmsg_redir_skb) {
int skb_fd = (test == SENDMSG || test == SENDPAGE) ?
p2 : p1;
@@ -1457,10 +1302,6 @@ static void test_options(char *options)
append_str(options, "ingress,", OPTSTRING);
if (txmsg_redir_skb)
append_str(options, "redir_skb,", OPTSTRING);
- if (txmsg_ktls_skb)
- append_str(options, "ktls_skb,", OPTSTRING);
- if (ktls)
- append_str(options, "ktls,", OPTSTRING);
if (peek_flag)
append_str(options, "peek,", OPTSTRING);
}
@@ -1602,57 +1443,6 @@ static void test_txmsg_ingress_redir(int cgrp, struct sockmap_options *opt)
test_send(opt, cgrp);
}
-static void test_txmsg_skb(int cgrp, struct sockmap_options *opt)
-{
- bool data = opt->data_test;
- int k = ktls;
-
- opt->data_test = true;
- ktls = 1;
-
- txmsg_pass = txmsg_drop = 0;
- txmsg_ingress = txmsg_redir = 0;
- txmsg_ktls_skb = 1;
- txmsg_pass = 1;
-
- /* Using data verification so ensure iov layout is
- * expected from test receiver side. e.g. has enough
- * bytes to write test code.
- */
- opt->iov_length = 100;
- opt->iov_count = 1;
- opt->rate = 1;
- test_exec(cgrp, opt);
-
- txmsg_ktls_skb_drop = 1;
- test_exec(cgrp, opt);
-
- txmsg_ktls_skb_drop = 0;
- txmsg_ktls_skb_redir = 1;
- test_exec(cgrp, opt);
- txmsg_ktls_skb_redir = 0;
-
- /* Tests that omit skb_parser */
- txmsg_omit_skb_parser = 1;
- ktls = 0;
- txmsg_ktls_skb = 0;
- test_exec(cgrp, opt);
-
- txmsg_ktls_skb_drop = 1;
- test_exec(cgrp, opt);
- txmsg_ktls_skb_drop = 0;
-
- txmsg_ktls_skb_redir = 1;
- test_exec(cgrp, opt);
-
- ktls = 1;
- test_exec(cgrp, opt);
- txmsg_omit_skb_parser = 0;
-
- opt->data_test = data;
- ktls = k;
-}
-
/* Test cork with hung data. This tests poor usage patterns where
* cork can leave data on the ring if user program is buggy and
* doesn't flush them somehow. They do take some time however
@@ -1908,8 +1698,6 @@ static void test_txmsg_ingress_parser(int cgrp, struct sockmap_options *opt)
{
txmsg_pass = 1;
skb_use_parser = 512;
- if (ktls == 1)
- skb_use_parser = 570;
opt->iov_length = 256;
opt->iov_count = 1;
opt->rate = 2;
@@ -1918,8 +1706,6 @@ static void test_txmsg_ingress_parser(int cgrp, struct sockmap_options *opt)
static void test_txmsg_ingress_parser2(int cgrp, struct sockmap_options *opt)
{
- if (ktls == 1)
- return;
skb_use_parser = 10;
opt->iov_length = 20;
opt->iov_count = 1;
@@ -1988,7 +1774,6 @@ struct _test test[] = {
{"txmsg test redirect wait send mem", test_txmsg_redir_wait_sndmem},
{"txmsg test drop", test_txmsg_drop},
{"txmsg test ingress redirect", test_txmsg_ingress_redir},
- {"txmsg test skb", test_txmsg_skb},
{"txmsg test apply", test_txmsg_apply},
{"txmsg test cork", test_txmsg_cork},
{"txmsg test hanging corks", test_txmsg_cork_hangs},
@@ -2085,20 +1870,10 @@ static void test_selftests_sockhash(int cg_fd, struct sockmap_options *opt)
__test_selftests(cg_fd, opt);
}
-static void test_selftests_ktls(int cg_fd, struct sockmap_options *opt)
-{
- opt->map = BPF_SOCKHASH_FILENAME;
- opt->prepend = "ktls";
- ktls = 1;
- __test_selftests(cg_fd, opt);
- ktls = 0;
-}
-
static int test_selftest(int cg_fd, struct sockmap_options *opt)
{
test_selftests_sockmap(cg_fd, opt);
test_selftests_sockhash(cg_fd, opt);
- test_selftests_ktls(cg_fd, opt);
test_print_results();
return 0;
}
--
2.54.0
^ permalink raw reply related
* [PATCH net-next 2/5] tls: remove dead sockmap (psock) handling from the SW path
From: Jakub Kicinski @ 2026-06-14 1:40 UTC (permalink / raw)
To: davem
Cc: netdev, edumazet, pabeni, andrew+netdev, horms, bpf, jakub,
john.fastabend, sd, Jakub Kicinski
In-Reply-To: <20260614014102.461064-1-kuba@kernel.org>
TLS and sockmap are now mutually exclusive. Try to delete the code
from sendmsg and recvmsg path which is now obviously dead.
The main goal is to delete enough code for AI security scanners
to no longer bother us with sockmap related bugs. At the same
time retain the code in case someone has the cycles to fix
all of this and make the integration work, again.
If the integration does not get restored we can wipe the rest
of the skmsg code from TLS in two or three releases.
The changes on the Tx side are deeper since that's where most
of the bugs are, Rx side simply takes the data from sockmap
and gives it to the user. On Tx split record handling and
rolling back the iterator were the two problem areas.
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
---
include/linux/skmsg.h | 9 -
net/core/skmsg.c | 52 +-----
net/tls/tls_main.c | 8 +-
net/tls/tls_sw.c | 399 +++---------------------------------------
4 files changed, 31 insertions(+), 437 deletions(-)
diff --git a/include/linux/skmsg.h b/include/linux/skmsg.h
index 19f4f253b4f9..ca0ec9c8608e 100644
--- a/include/linux/skmsg.h
+++ b/include/linux/skmsg.h
@@ -544,15 +544,6 @@ static inline void psock_progs_drop(struct sk_psock_progs *progs)
psock_set_prog(&progs->skb_verdict, NULL);
}
-int sk_psock_tls_strp_read(struct sk_psock *psock, struct sk_buff *skb);
-
-static inline bool sk_psock_strp_enabled(struct sk_psock *psock)
-{
- if (!psock)
- return false;
- return !!psock->saved_data_ready;
-}
-
/* for tcp only, sk is locked */
static inline ssize_t sk_psock_msg_inq(struct sock *sk)
{
diff --git a/net/core/skmsg.c b/net/core/skmsg.c
index e1850caf1a71..73ae12f25940 100644
--- a/net/core/skmsg.c
+++ b/net/core/skmsg.c
@@ -7,7 +7,6 @@
#include <net/sock.h>
#include <net/tcp.h>
-#include <net/tls.h>
#include <trace/events/sock.h>
static bool sk_msg_try_coalesce_ok(struct sk_msg *msg, int elem_first_coalesce)
@@ -992,41 +991,6 @@ static int sk_psock_skb_redirect(struct sk_psock *from, struct sk_buff *skb)
return 0;
}
-static void sk_psock_tls_verdict_apply(struct sk_buff *skb,
- struct sk_psock *from, int verdict)
-{
- switch (verdict) {
- case __SK_REDIRECT:
- sk_psock_skb_redirect(from, skb);
- break;
- case __SK_PASS:
- case __SK_DROP:
- default:
- break;
- }
-}
-
-int sk_psock_tls_strp_read(struct sk_psock *psock, struct sk_buff *skb)
-{
- struct bpf_prog *prog;
- int ret = __SK_PASS;
-
- rcu_read_lock();
- prog = READ_ONCE(psock->progs.stream_verdict);
- if (likely(prog)) {
- skb->sk = psock->sk;
- skb_dst_drop(skb);
- skb_bpf_redirect_clear(skb);
- ret = bpf_prog_run_pin_on_cpu(prog, skb);
- ret = sk_psock_map_verd(ret, skb_bpf_redirect_fetch(skb));
- skb->sk = NULL;
- }
- sk_psock_tls_verdict_apply(skb, psock, ret);
- rcu_read_unlock();
- return ret;
-}
-EXPORT_SYMBOL_GPL(sk_psock_tls_strp_read);
-
static int sk_psock_verdict_apply(struct sk_psock *psock, struct sk_buff *skb,
int verdict)
{
@@ -1167,13 +1131,9 @@ static void sk_psock_strp_data_ready(struct sock *sk)
rcu_read_lock();
psock = sk_psock(sk);
if (likely(psock)) {
- if (tls_sw_has_ctx_rx(sk)) {
- psock->saved_data_ready(sk);
- } else {
- read_lock_bh(&sk->sk_callback_lock);
- strp_data_ready(&psock->strp);
- read_unlock_bh(&sk->sk_callback_lock);
- }
+ read_lock_bh(&sk->sk_callback_lock);
+ strp_data_ready(&psock->strp);
+ read_unlock_bh(&sk->sk_callback_lock);
}
rcu_read_unlock();
}
@@ -1275,12 +1235,6 @@ static void sk_psock_verdict_data_ready(struct sock *sk)
trace_sk_data_ready(sk);
rcu_read_lock();
- psock = sk_psock(sk);
- if (psock && tls_sw_has_ctx_rx(sk)) {
- psock->saved_data_ready(sk);
- rcu_read_unlock();
- return;
- }
sock = READ_ONCE(sk->sk_socket);
if (likely(sock))
ops = READ_ONCE(sock->ops);
diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index 8e7ba018988d..8c588cdab733 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -402,7 +402,6 @@ static __poll_t tls_sk_poll(struct file *file, struct socket *sock,
struct tls_sw_context_rx *ctx;
struct tls_context *tls_ctx;
struct sock *sk = sock->sk;
- struct sk_psock *psock;
__poll_t mask = 0;
u8 shutdown;
int state;
@@ -416,17 +415,12 @@ static __poll_t tls_sk_poll(struct file *file, struct socket *sock,
tls_ctx = tls_get_ctx(sk);
ctx = tls_sw_ctx_rx(tls_ctx);
- psock = sk_psock_get(sk);
if ((skb_queue_empty_lockless(&ctx->rx_list) &&
- !tls_strp_msg_ready(ctx) &&
- sk_psock_queue_empty(psock)) ||
+ !tls_strp_msg_ready(ctx)) ||
READ_ONCE(ctx->key_update_pending))
mask &= ~(EPOLLIN | EPOLLRDNORM);
- if (psock)
- sk_psock_put(sk, psock);
-
return mask;
}
diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c
index 5a4300c943a1..9324e4ed20a3 100644
--- a/net/tls/tls_sw.c
+++ b/net/tls/tls_sw.c
@@ -614,136 +614,17 @@ static int tls_do_encryption(struct sock *sk,
return rc;
}
-static int tls_split_open_record(struct sock *sk, struct tls_rec *from,
- struct tls_rec **to, struct sk_msg *msg_opl,
- struct sk_msg *msg_oen, u32 split_point,
- u32 tx_overhead_size, u32 *orig_end)
-{
- u32 i, j, bytes = 0, apply = msg_opl->apply_bytes;
- struct scatterlist *sge, *osge, *nsge;
- u32 orig_size = msg_opl->sg.size;
- struct scatterlist tmp = { };
- struct sk_msg *msg_npl;
- struct tls_rec *new;
- int ret;
-
- new = tls_get_rec(sk);
- if (!new)
- return -ENOMEM;
- ret = sk_msg_alloc(sk, &new->msg_encrypted, msg_opl->sg.size +
- tx_overhead_size, 0);
- if (ret < 0) {
- tls_free_rec(sk, new);
- return ret;
- }
-
- *orig_end = msg_opl->sg.end;
- i = msg_opl->sg.start;
- sge = sk_msg_elem(msg_opl, i);
- while (apply && sge->length) {
- if (sge->length > apply) {
- u32 len = sge->length - apply;
-
- get_page(sg_page(sge));
- sg_set_page(&tmp, sg_page(sge), len,
- sge->offset + apply);
- sge->length = apply;
- bytes += apply;
- apply = 0;
- } else {
- apply -= sge->length;
- bytes += sge->length;
- }
-
- sk_msg_iter_var_next(i);
- if (i == msg_opl->sg.end)
- break;
- sge = sk_msg_elem(msg_opl, i);
- }
-
- msg_opl->sg.end = i;
- msg_opl->sg.curr = i;
- msg_opl->sg.copybreak = 0;
- msg_opl->apply_bytes = 0;
- msg_opl->sg.size = bytes;
-
- msg_npl = &new->msg_plaintext;
- msg_npl->apply_bytes = apply;
- msg_npl->sg.size = orig_size - bytes;
-
- j = msg_npl->sg.start;
- nsge = sk_msg_elem(msg_npl, j);
- if (tmp.length) {
- memcpy(nsge, &tmp, sizeof(*nsge));
- sk_msg_iter_var_next(j);
- nsge = sk_msg_elem(msg_npl, j);
- }
-
- osge = sk_msg_elem(msg_opl, i);
- while (osge->length) {
- memcpy(nsge, osge, sizeof(*nsge));
- sg_unmark_end(nsge);
- sk_msg_iter_var_next(i);
- sk_msg_iter_var_next(j);
- if (i == *orig_end)
- break;
- osge = sk_msg_elem(msg_opl, i);
- nsge = sk_msg_elem(msg_npl, j);
- }
-
- msg_npl->sg.end = j;
- msg_npl->sg.curr = j;
- msg_npl->sg.copybreak = 0;
-
- *to = new;
- return 0;
-}
-
-static void tls_merge_open_record(struct sock *sk, struct tls_rec *to,
- struct tls_rec *from, u32 orig_end)
-{
- struct sk_msg *msg_npl = &from->msg_plaintext;
- struct sk_msg *msg_opl = &to->msg_plaintext;
- struct scatterlist *osge, *nsge;
- u32 i, j;
-
- i = msg_opl->sg.end;
- sk_msg_iter_var_prev(i);
- j = msg_npl->sg.start;
-
- osge = sk_msg_elem(msg_opl, i);
- nsge = sk_msg_elem(msg_npl, j);
-
- if (sg_page(osge) == sg_page(nsge) &&
- osge->offset + osge->length == nsge->offset) {
- osge->length += nsge->length;
- put_page(sg_page(nsge));
- }
-
- msg_opl->sg.end = orig_end;
- msg_opl->sg.curr = orig_end;
- msg_opl->sg.copybreak = 0;
- msg_opl->apply_bytes = msg_opl->sg.size + msg_npl->sg.size;
- msg_opl->sg.size += msg_npl->sg.size;
-
- sk_msg_free(sk, &to->msg_encrypted);
- sk_msg_xfer_full(&to->msg_encrypted, &from->msg_encrypted);
-
- kfree(from);
-}
-
static int tls_push_record(struct sock *sk, int flags,
unsigned char record_type)
{
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_prot_info *prot = &tls_ctx->prot_info;
struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
- struct tls_rec *rec = ctx->open_rec, *tmp = NULL;
- u32 i, split_point, orig_end;
+ struct tls_rec *rec = ctx->open_rec;
struct sk_msg *msg_pl, *msg_en;
struct aead_request *req;
- bool split;
int rc;
+ u32 i;
if (!rec)
return 0;
@@ -751,38 +632,6 @@ static int tls_push_record(struct sock *sk, int flags,
msg_pl = &rec->msg_plaintext;
msg_en = &rec->msg_encrypted;
- split_point = msg_pl->apply_bytes;
- split = split_point && split_point < msg_pl->sg.size;
- if (unlikely((!split &&
- msg_pl->sg.size +
- prot->overhead_size > msg_en->sg.size) ||
- (split &&
- split_point +
- prot->overhead_size > msg_en->sg.size))) {
- split = true;
- split_point = msg_en->sg.size;
- }
- if (split) {
- rc = tls_split_open_record(sk, rec, &tmp, msg_pl, msg_en,
- split_point, prot->overhead_size,
- &orig_end);
- if (rc < 0)
- return rc;
- /* This can happen if above tls_split_open_record allocates
- * a single large encryption buffer instead of two smaller
- * ones. In this case adjust pointers and continue without
- * split.
- */
- if (!msg_pl->sg.size) {
- tls_merge_open_record(sk, rec, tmp, orig_end);
- msg_pl = &rec->msg_plaintext;
- msg_en = &rec->msg_encrypted;
- split = false;
- }
- sk_msg_trim(sk, msg_en, msg_pl->sg.size +
- prot->overhead_size);
- }
-
rec->tx_flags = flags;
req = &rec->aead_req;
@@ -840,155 +689,26 @@ static int tls_push_record(struct sock *sk, int flags,
rc = tls_do_encryption(sk, tls_ctx, ctx, req,
msg_pl->sg.size + prot->tail_size, i);
if (rc < 0) {
- if (rc != -EINPROGRESS) {
+ if (rc != -EINPROGRESS)
tls_err_abort(sk, -EBADMSG);
- if (split) {
- tls_ctx->pending_open_record_frags = true;
- tls_merge_open_record(sk, rec, tmp, orig_end);
- }
- }
ctx->async_capable = 1;
return rc;
- } else if (split) {
- msg_pl = &tmp->msg_plaintext;
- msg_en = &tmp->msg_encrypted;
- sk_msg_trim(sk, msg_en, msg_pl->sg.size + prot->overhead_size);
- tls_ctx->pending_open_record_frags = true;
- ctx->open_rec = tmp;
}
return tls_tx_records(sk, flags);
}
static int bpf_exec_tx_verdict(struct sk_msg *msg, struct sock *sk,
- bool full_record, u8 record_type,
- ssize_t *copied, int flags)
+ u8 record_type, ssize_t *copied, int flags)
{
- struct tls_context *tls_ctx = tls_get_ctx(sk);
- struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
- struct sk_msg msg_redir = { };
- struct sk_psock *psock;
- struct sock *sk_redir;
- struct tls_rec *rec;
- bool enospc, policy, redir_ingress;
- int err = 0, send;
- u32 delta = 0;
+ int err;
- policy = !(flags & MSG_SENDPAGE_NOPOLICY);
- psock = sk_psock_get(sk);
- if (!psock || !policy) {
- err = tls_push_record(sk, flags, record_type);
- if (err && err != -EINPROGRESS && sk->sk_err == EBADMSG) {
- *copied -= sk_msg_free(sk, msg);
- tls_free_open_rec(sk);
- err = -sk->sk_err;
- }
- if (psock)
- sk_psock_put(sk, psock);
- return err;
+ err = tls_push_record(sk, flags, record_type);
+ if (err && err != -EINPROGRESS && sk->sk_err == EBADMSG) {
+ *copied -= sk_msg_free(sk, msg);
+ tls_free_open_rec(sk);
+ err = -sk->sk_err;
}
-more_data:
- enospc = sk_msg_full(msg);
- if (psock->eval == __SK_NONE) {
- delta = msg->sg.size;
- psock->eval = sk_psock_msg_verdict(sk, psock, msg);
- delta -= msg->sg.size;
-
- if ((s32)delta > 0) {
- /* It indicates that we executed bpf_msg_pop_data(),
- * causing the plaintext data size to decrease.
- * Therefore the encrypted data size also needs to
- * correspondingly decrease. We only need to subtract
- * delta to calculate the new ciphertext length since
- * ktls does not support block encryption.
- */
- struct sk_msg *enc = &ctx->open_rec->msg_encrypted;
-
- sk_msg_trim(sk, enc, enc->sg.size - delta);
- }
- }
- if (msg->cork_bytes && msg->cork_bytes > msg->sg.size &&
- !enospc && !full_record) {
- err = -ENOSPC;
- goto out_err;
- }
- msg->cork_bytes = 0;
- send = msg->sg.size;
- if (msg->apply_bytes && msg->apply_bytes < send)
- send = msg->apply_bytes;
-
- switch (psock->eval) {
- case __SK_PASS:
- err = tls_push_record(sk, flags, record_type);
- if (err && err != -EINPROGRESS && sk->sk_err == EBADMSG) {
- *copied -= sk_msg_free(sk, msg);
- tls_free_open_rec(sk);
- err = -sk->sk_err;
- goto out_err;
- }
- break;
- case __SK_REDIRECT:
- redir_ingress = psock->redir_ingress;
- sk_redir = psock->sk_redir;
- memcpy(&msg_redir, msg, sizeof(*msg));
- if (msg->apply_bytes < send)
- msg->apply_bytes = 0;
- else
- msg->apply_bytes -= send;
- sk_msg_return_zero(sk, msg, send);
- msg->sg.size -= send;
- release_sock(sk);
- err = tcp_bpf_sendmsg_redir(sk_redir, redir_ingress,
- &msg_redir, send, flags);
- lock_sock(sk);
- if (err < 0) {
- /* Regardless of whether the data represented by
- * msg_redir is sent successfully, we have already
- * uncharged it via sk_msg_return_zero(). The
- * msg->sg.size represents the remaining unprocessed
- * data, which needs to be uncharged here.
- */
- sk_mem_uncharge(sk, msg->sg.size);
- *copied -= sk_msg_free_nocharge(sk, &msg_redir);
- msg->sg.size = 0;
- }
- if (msg->sg.size == 0)
- tls_free_open_rec(sk);
- break;
- case __SK_DROP:
- default:
- sk_msg_free_partial(sk, msg, send);
- if (msg->apply_bytes < send)
- msg->apply_bytes = 0;
- else
- msg->apply_bytes -= send;
- if (msg->sg.size == 0)
- tls_free_open_rec(sk);
- *copied -= (send + delta);
- err = -EACCES;
- }
-
- if (likely(!err)) {
- bool reset_eval = !ctx->open_rec;
-
- rec = ctx->open_rec;
- if (rec) {
- msg = &rec->msg_plaintext;
- if (!msg->apply_bytes)
- reset_eval = true;
- }
- if (reset_eval) {
- psock->eval = __SK_NONE;
- if (psock->sk_redir) {
- sock_put(psock->sk_redir);
- psock->sk_redir = NULL;
- }
- }
- if (rec)
- goto more_data;
- }
- out_err:
- sk_psock_put(sk, psock);
return err;
}
@@ -1008,7 +728,7 @@ static int tls_sw_push_pending_record(struct sock *sk, int flags)
if (!copied)
return 0;
- return bpf_exec_tx_verdict(msg_pl, sk, true, TLS_RECORD_TYPE_DATA,
+ return bpf_exec_tx_verdict(msg_pl, sk, TLS_RECORD_TYPE_DATA,
&copied, flags);
}
@@ -1156,7 +876,7 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg,
copied += try_to_copy;
sk_msg_sg_copy_set(msg_pl, first);
- ret = bpf_exec_tx_verdict(msg_pl, sk, full_record,
+ ret = bpf_exec_tx_verdict(msg_pl, sk,
record_type, &copied,
msg->msg_flags);
if (ret) {
@@ -1164,13 +884,7 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg,
num_async++;
else if (ret == -ENOMEM)
goto wait_for_memory;
- else if (ctx->open_rec && ret == -ENOSPC) {
- if (msg_pl->cork_bytes) {
- ret = 0;
- goto send_end;
- }
- goto rollback_iter;
- } else if (ret != -EAGAIN)
+ else if (ret != -EAGAIN)
goto send_end;
}
@@ -1181,11 +895,6 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg,
}
continue;
-rollback_iter:
- copied -= try_to_copy;
- sk_msg_sg_copy_clear(msg_pl, first);
- iov_iter_revert(&msg->msg_iter,
- msg_pl->sg.size - orig_size);
fallback_to_reg_send:
sk_msg_trim(sk, msg_pl, orig_size);
}
@@ -1221,7 +930,7 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg,
copied += try_to_copy;
copied:
if (full_record || eor) {
- ret = bpf_exec_tx_verdict(msg_pl, sk, full_record,
+ ret = bpf_exec_tx_verdict(msg_pl, sk,
record_type, &copied,
msg->msg_flags);
if (ret) {
@@ -1229,11 +938,8 @@ static int tls_sw_sendmsg_locked(struct sock *sk, struct msghdr *msg,
num_async++;
else if (ret == -ENOMEM)
goto wait_for_memory;
- else if (ret != -EAGAIN) {
- if (ret == -ENOSPC)
- ret = 0;
+ else if (ret != -EAGAIN)
goto send_end;
- }
}
/* Transmit if any encryptions have completed */
@@ -1335,8 +1041,8 @@ void tls_sw_splice_eof(struct socket *sock)
if (msg_pl->sg.size == 0)
goto unlock;
- /* Check the BPF advisor and perform transmission. */
- ret = bpf_exec_tx_verdict(msg_pl, sk, false, TLS_RECORD_TYPE_DATA,
+ /* Perform transmission. */
+ ret = bpf_exec_tx_verdict(msg_pl, sk, TLS_RECORD_TYPE_DATA,
&copied, 0);
switch (ret) {
case 0:
@@ -1372,8 +1078,7 @@ void tls_sw_splice_eof(struct socket *sock)
* consumed via sock_error().
*/
static int
-tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock, bool nonblock,
- bool released, bool has_copied)
+tls_rx_rec_wait(struct sock *sk, bool nonblock, bool released, bool has_copied)
{
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
@@ -1388,9 +1093,6 @@ tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock, bool nonblock,
timeo = sock_rcvtimeo(sk, nonblock);
while (!tls_strp_msg_ready(ctx)) {
- if (!sk_psock_queue_empty(psock))
- return 0;
-
if (sk->sk_err) {
if (has_copied)
return -READ_ONCE(sk->sk_err);
@@ -1434,9 +1136,7 @@ tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock, bool nonblock,
add_wait_queue(sk_sleep(sk), &wait);
sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
ret = sk_wait_event(sk, &timeo,
- tls_strp_msg_ready(ctx) ||
- !sk_psock_queue_empty(psock),
- &wait);
+ tls_strp_msg_ready(ctx), &wait);
sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
remove_wait_queue(sk_sleep(sk), &wait);
@@ -1446,7 +1146,7 @@ tls_rx_rec_wait(struct sock *sk, struct sk_psock *psock, bool nonblock,
}
if (unlikely(!tls_strp_msg_load(&ctx->strp, released)))
- return tls_rx_rec_wait(sk, psock, nonblock, false, has_copied);
+ return tls_rx_rec_wait(sk, nonblock, false, has_copied);
return 1;
}
@@ -2096,7 +1796,6 @@ int tls_sw_recvmsg(struct sock *sk,
struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
struct tls_prot_info *prot = &tls_ctx->prot_info;
ssize_t decrypted = 0, async_copy_bytes = 0;
- struct sk_psock *psock;
unsigned char control = 0;
size_t flushed_at = 0;
struct strp_msg *rxm;
@@ -2109,7 +1808,6 @@ int tls_sw_recvmsg(struct sock *sk,
bool is_peek = flags & MSG_PEEK;
bool rx_more = false;
bool released = true;
- bool bpf_strp_enabled;
bool zc_capable;
if (unlikely(flags & MSG_ERRQUEUE))
@@ -2118,8 +1816,6 @@ int tls_sw_recvmsg(struct sock *sk,
err = tls_rx_reader_lock(sk, ctx, flags & MSG_DONTWAIT);
if (err < 0)
return err;
- psock = sk_psock_get(sk);
- bpf_strp_enabled = sk_psock_strp_enabled(psock);
/* If crypto failed the connection is broken */
err = ctx->async_wait.err;
@@ -2140,27 +1836,16 @@ int tls_sw_recvmsg(struct sock *sk,
target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
len = len - copied;
- zc_capable = !bpf_strp_enabled && !is_kvec && !is_peek &&
- ctx->zc_capable;
+ zc_capable = !is_kvec && !is_peek && ctx->zc_capable;
decrypted = 0;
while (len && (decrypted + copied < target || tls_strp_msg_ready(ctx))) {
struct tls_decrypt_arg darg;
int to_decrypt, chunk;
- err = tls_rx_rec_wait(sk, psock, flags & MSG_DONTWAIT,
+ err = tls_rx_rec_wait(sk, flags & MSG_DONTWAIT,
released, !!(decrypted + copied));
- if (err <= 0) {
- if (psock) {
- chunk = sk_msg_recvmsg(sk, psock, msg, len,
- flags);
- if (chunk > 0) {
- decrypted += chunk;
- len -= chunk;
- continue;
- }
- }
+ if (err <= 0)
goto recv_end;
- }
memset(&darg.inargs, 0, sizeof(darg.inargs));
@@ -2174,7 +1859,7 @@ int tls_sw_recvmsg(struct sock *sk,
darg.zc = true;
/* Do not use async mode if record is non-data */
- if (tlm->control == TLS_RECORD_TYPE_DATA && !bpf_strp_enabled)
+ if (tlm->control == TLS_RECORD_TYPE_DATA)
darg.async = ctx->async_capable;
else
darg.async = false;
@@ -2230,18 +1915,6 @@ int tls_sw_recvmsg(struct sock *sk,
continue;
}
- if (bpf_strp_enabled) {
- released = true;
- err = sk_psock_tls_strp_read(psock, skb);
- if (err != __SK_PASS) {
- rxm->offset = rxm->offset + rxm->full_len;
- rxm->full_len = 0;
- if (err == __SK_DROP)
- consume_skb(skb);
- continue;
- }
- }
-
if (partially_consumed)
chunk = len;
@@ -2304,8 +1977,6 @@ int tls_sw_recvmsg(struct sock *sk,
end:
tls_rx_reader_unlock(sk, ctx);
- if (psock)
- sk_psock_put(sk, psock);
return copied ? : err;
}
@@ -2332,7 +2003,7 @@ ssize_t tls_sw_splice_read(struct socket *sock, loff_t *ppos,
} else {
struct tls_decrypt_arg darg;
- err = tls_rx_rec_wait(sk, NULL, flags & SPLICE_F_NONBLOCK,
+ err = tls_rx_rec_wait(sk, flags & SPLICE_F_NONBLOCK,
true, false);
if (err <= 0)
goto splice_read_end;
@@ -2417,7 +2088,7 @@ int tls_sw_read_sock(struct sock *sk, read_descriptor_t *desc,
} else {
struct tls_decrypt_arg darg;
- err = tls_rx_rec_wait(sk, NULL, true, released, !!copied);
+ err = tls_rx_rec_wait(sk, true, released, !!copied);
if (err <= 0)
goto read_sock_end;
@@ -2473,16 +2144,8 @@ bool tls_sw_sock_is_readable(struct sock *sk)
{
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
- bool ingress_empty = true;
- struct sk_psock *psock;
- rcu_read_lock();
- psock = sk_psock(sk);
- if (psock)
- ingress_empty = list_empty(&psock->ingress_msg);
- rcu_read_unlock();
-
- return !ingress_empty || tls_strp_msg_ready(ctx) ||
+ return tls_strp_msg_ready(ctx) ||
!skb_queue_empty(&ctx->rx_list);
}
@@ -2565,7 +2228,6 @@ static void tls_data_ready(struct sock *sk)
{
struct tls_context *tls_ctx = tls_get_ctx(sk);
struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
- struct sk_psock *psock;
gfp_t alloc_save;
trace_sk_data_ready(sk);
@@ -2574,13 +2236,6 @@ static void tls_data_ready(struct sock *sk)
sk->sk_allocation = GFP_ATOMIC;
tls_strp_data_ready(&ctx->strp);
sk->sk_allocation = alloc_save;
-
- psock = sk_psock_get(sk);
- if (psock) {
- if (!list_empty(&psock->ingress_msg))
- ctx->saved_data_ready(sk);
- sk_psock_put(sk, psock);
- }
}
void tls_sw_cancel_work_tx(struct tls_context *tls_ctx)
--
2.54.0
^ permalink raw reply related
* [PATCH net-next 1/5] tls: reject the combination of TLS and sockmap
From: Jakub Kicinski @ 2026-06-14 1:40 UTC (permalink / raw)
To: davem
Cc: netdev, edumazet, pabeni, andrew+netdev, horms, bpf, jakub,
john.fastabend, sd, Jakub Kicinski
In-Reply-To: <20260614014102.461064-1-kuba@kernel.org>
TLS and sockmap (BPF psock) integration hides a lot of latent bugs.
Bugs which may be more or less relevant for real users but they
are definitely exploitable.
We could not find anyone actively using this integration so let's
reject this config. Adding a TLS socket to a sockmap was already
rejected by sk_psock_init() through the inet_csk_has_ulp() check.
We need to reject the attempts to configure the TLS keys (rather
than adding the ULP itself) because checking prior to the ULP
installation is tricky without risking a race with sockmap getting
added in parallel (sockmap does not hold the socket lock).
This patch is a minimal rejection of the feature. Subsequent patch
in the series will do a light dead code removal. Full cleanup would
require a major rewrite of the Tx path, we don't need skmsg any more.
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
---
net/tls/tls_main.c | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index 13c88a7b8787..8e7ba018988d 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -643,6 +643,17 @@ static int do_tls_setsockopt_conf(struct sock *sk, sockptr_t optval,
int rc = 0;
int conf;
+ /* TLS and sockmap are mutually exclusive. A socket already in a
+ * sockmap (i.e. with a psock attached) cannot be upgraded to TLS.
+ * sockmap rejects TLS sockets already (see sk_psock_init()).
+ */
+ rcu_read_lock();
+ if (sk_psock(sk)) {
+ rcu_read_unlock();
+ return -EINVAL;
+ }
+ rcu_read_unlock();
+
if (sockptr_is_null(optval) || (optlen < sizeof(*crypto_info)))
return -EINVAL;
--
2.54.0
^ permalink raw reply related
* [PATCH net-next 0/5] tls: reject the combination of TLS and sockmap
From: Jakub Kicinski @ 2026-06-14 1:40 UTC (permalink / raw)
To: davem
Cc: netdev, edumazet, pabeni, andrew+netdev, horms, bpf, jakub,
john.fastabend, sd, Jakub Kicinski
There are no known TLS+sockmap users and it has some known
hard to solve bugs. Let's reject this configuration as we
discussed a number of times.
Jakub Kicinski (5):
tls: reject the combination of TLS and sockmap
tls: remove dead sockmap (psock) handling from the SW path
selftests/bpf: remove sockmap + ktls tests
selftests/bpf: drop the unused kTLS program from test_sockmap
selftests/bpf: test that TLS crypto is rejected on a sockmap socket
include/linux/skmsg.h | 9 -
.../selftests/bpf/progs/test_sockmap_kern.h | 56 ---
net/core/skmsg.c | 52 +--
net/tls/tls_main.c | 19 +-
net/tls/tls_sw.c | 399 ++---------------
.../selftests/bpf/prog_tests/sockmap_ktls.c | 420 +++---------------
.../selftests/bpf/progs/test_sockmap_ktls.c | 61 ---
tools/testing/selftests/bpf/test_sockmap.c | 250 +----------
8 files changed, 119 insertions(+), 1147 deletions(-)
delete mode 100644 tools/testing/selftests/bpf/progs/test_sockmap_ktls.c
--
2.54.0
^ permalink raw reply
* Re: [PATCH net-next v4 0/5] ionic: Expose more port stats to ethtool
From: Eric Joyner @ 2026-06-14 1:34 UTC (permalink / raw)
To: Jakub Kicinski
Cc: netdev, Brett Creeley, Andrew Lunn, David S. Miller, Eric Dumazet,
Paolo Abeni, Jacob Keller
In-Reply-To: <20260613165323.4df246d9@kernel.org>
On 6/13/2026 4:53 PM, Jakub Kicinski wrote:
> Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.
>
>
> On Tue, 9 Jun 2026 23:18:25 -0700 Eric Joyner wrote:
>> - The link_down_count from firmware mentioned in v2 was moved back to an
>> entry in the general ethtool statistics; the existing driver-calculated
>> value for the ethtool ext link is more appropriate due to the firmware
>> value being a small size and not resetting between driver loads.
>
> There's a uAPI stat defined for something but you don't use it because
> you can't be bothered to handle overflow and reset? What am I missing :/
I could add the overflow and reset handling (I was working on it for a v5), but
to me, it didn't seem like it was worth the effort to modify the stat from
firmware instead of continuing to use the existing driver-calculated stat. It
wasn't really a "can I do this" question but more "is it worth doing this?"
To start, it didn't seem like there was a specific standard that the API
expected; it looked like "copy straight from the adapter if you can, or just
calculate something if you can't". It's hard to tell what the actual
expectations for the interface outside of the struct comment since there aren't
many drivers using it. The Mellanox and Broadcom driver stat handlers just read
the link down count straight from hardware (though I don't know if those stats
get reset on driver load or reboot and we're the outlier in the way our firmware
behaves). The Intel drivers are similar to what we do now in the ionic driver,
and they just count the link down events that the driver detects, but I know
that they don't expose a link down count from the hardware. What we do now
seems good enough for that purpose? It's bigger than 16 bits and gets reset on
driver load, so why add more code to handle something that this seems to do well
enough?
But, I also still want the raw firmware stat because the firmware has a
different lifetime than the driver, and so it will count link down events while
the driver isn't loaded or in a state to receive link events. But since maybe
that's only useful for debugging, it belongs in debugfs instead? I just thought
drivers could more or less put what they want in `ethtool -S` output, so that
seemed like an okay place to put it.
- Eric
^ permalink raw reply
* Re: [PATCH V4 net-next 0/6] net: hns3: enhance tc flow offload support
From: patchwork-bot+netdevbpf @ 2026-06-14 1:20 UTC (permalink / raw)
To: Jijie Shao
Cc: davem, edumazet, kuba, pabeni, andrew+netdev, horms, shenjian15,
liuyonglong, chenhao418, huangdonghua3, yangshuaisong, netdev,
linux-kernel
In-Reply-To: <20260610060618.834987-1-shaojijie@huawei.com>
Hello:
This series was applied to netdev/net-next.git (main)
by Jakub Kicinski <kuba@kernel.org>:
On Wed, 10 Jun 2026 14:06:12 +0800 you wrote:
> This patchset enhances the tc flow offload support for hns3 driver:
>
> - Patch 1: Refactor hclge_add_cls_flower() to support more actions
> - Patch 2: Improve unused_tuple parameter setting for separate src/dst configuration
> - Patch 3: Add support for HCLGE_FD_ACTION_SELECT_QUEUE and HCLGE_FD_ACTION_DROP_PACKET actions
> - Patch 4: Add support for FLOW_DISSECTOR_KEY_IP and FLOW_DISSECTOR_KEY_ENC_KEYID dissectors
> - Patch 5: Add debugfs support for dumping FD rules
> - Patch 6: Move FD code to a separate file (hclge_fd.c) for better code organization
>
> [...]
Here is the summary with links:
- [V4,net-next,1/6] net: hns3: refactor add_cls_flower to prepare for multiple actions
https://git.kernel.org/netdev/net-next/c/d7db57e3b42a
- [V4,net-next,2/6] net: hns3: improve the unused_tuple parameter setting
https://git.kernel.org/netdev/net-next/c/1ad6f1ff3e96
- [V4,net-next,3/6] net: hns3: support two more actions for tc flow
https://git.kernel.org/netdev/net-next/c/e6703605b47e
- [V4,net-next,4/6] net: hns3: support IP and tunnel VNI dissectors for tc flow
https://git.kernel.org/netdev/net-next/c/cc2c4dbb00fb
- [V4,net-next,5/6] net: hns3: debugfs support for dumping fd rules
https://git.kernel.org/netdev/net-next/c/6c586b3ab8b7
- [V4,net-next,6/6] net: hns3: move fd code to a separate file
https://git.kernel.org/netdev/net-next/c/d76612e4aacf
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH net-next 0/5] dpaa2-switch: FDB management refactoring
From: patchwork-bot+netdevbpf @ 2026-06-14 1:00 UTC (permalink / raw)
To: Ioana Ciornei
Cc: andrew+netdev, davem, edumazet, kuba, pabeni, netdev,
linux-kernel
In-Reply-To: <20260610150912.1788482-1-ioana.ciornei@nxp.com>
Hello:
This series was applied to netdev/net-next.git (main)
by Jakub Kicinski <kuba@kernel.org>:
On Wed, 10 Jun 2026 18:09:07 +0300 you wrote:
> The FDB management done by the dpaa2_switch_port_set_fdb() function is
> hard to follow even by trained eyes. This series tries to make it easier
> to read and understand it by factoring out some code blocks into helper
> functions and unifying the join and leave paths in terms of FDB
> management.
>
> Ioana Ciornei (5):
> dpaa2-switch: change dpaa2_switch_port_set_fdb() function prototype
> dpaa2-switch: factor out the FDB in-use check into a helper
> dpaa2-switch: move FDB selection for join path into a helper
> dpaa2-switch: move FDB selection for leave path into a helper
> dpaa2-switch: unify the FDB update logic in
> dpaa2_switch_port_set_fdb()
>
> [...]
Here is the summary with links:
- [net-next,1/5] dpaa2-switch: change dpaa2_switch_port_set_fdb() function prototype
https://git.kernel.org/netdev/net-next/c/646077cc6b20
- [net-next,2/5] dpaa2-switch: factor out the FDB in-use check into a helper
https://git.kernel.org/netdev/net-next/c/5617bf8538ec
- [net-next,3/5] dpaa2-switch: move FDB selection for join path into a helper
https://git.kernel.org/netdev/net-next/c/e31f457ac7da
- [net-next,4/5] dpaa2-switch: move FDB selection for leave path into a helper
https://git.kernel.org/netdev/net-next/c/2230a2e62251
- [net-next,5/5] dpaa2-switch: unify the FDB update logic in dpaa2_switch_port_set_fdb()
https://git.kernel.org/netdev/net-next/c/7aae797a003e
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH 1/2] net: ife: require ETH_HLEN to be pullable in ife_decode()
From: patchwork-bot+netdevbpf @ 2026-06-14 0:50 UTC (permalink / raw)
To: Ren Wei
Cc: netdev, yotam.gi, jhs, davem, xiyou.wangcong, kuba, victor,
yuantan098, bird, edragain
In-Reply-To: <20260610183814.1648888-2-n05ec@lzu.edu.cn>
Hello:
This series was applied to netdev/net.git (main)
by Jakub Kicinski <kuba@kernel.org>:
On Thu, 11 Jun 2026 02:37:43 +0800 you wrote:
> From: Yong Wang <edragain@163.com>
>
> ife decode may return after making only the outer IFE header and
> metadata pullable. The caller then passes the decapsulated packet to
> eth_type_trans(), which expects the inner Ethernet header to be
> accessible from the linear data area.
>
> [...]
Here is the summary with links:
- [1/2] net: ife: require ETH_HLEN to be pullable in ife_decode()
https://git.kernel.org/netdev/net/c/9406f6012b73
- [2/2] selftests/tc-testing: Verify IFE can handle truncated inner Ethernet header
https://git.kernel.org/netdev/net/c/a4004aa0debf
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH net-next] net: dsa: yt921x: Add limited ACL flow statistics support
From: Jakub Kicinski @ 2026-06-14 0:45 UTC (permalink / raw)
To: mmyangfl
Cc: Jakub Kicinski, netdev, andrew, olteanv, davem, edumazet, pabeni,
linux-kernel
In-Reply-To: <20260610202508.845328-1-mmyangfl@gmail.com>
This is an AI-generated review of your patch. The human sending this
email says "I thought this is a false positive and the register is
Clear-on-Read but you seem to be writing 0 to it when allocating."
---
net: dsa: yt921x: Add limited ACL flow statistics support
This commit adds .cls_flower_stats() support to the yt921x DSA driver,
backed by a pool of 64 hardware flow counters configured in byte mode.
A counter is allocated at rule-install time and read on demand via
yt921x_acl_stat().
> diff --git a/drivers/net/dsa/yt921x.c b/drivers/net/dsa/yt921x.c
> index 159b16606f6c..7919afcb8136 100644
> --- a/drivers/net/dsa/yt921x.c
> +++ b/drivers/net/dsa/yt921x.c
> @@ -373,6 +373,11 @@ yt921x_regs_clear_bits(struct yt921x_priv *priv, u32 reg, const u32 *masks,
> return yt921x_regs_write(priv, reg, vs, num_regs);
> }
>
> +static int yt921x_reg64_read(struct yt921x_priv *priv, u32 reg, u32 *vals)
> +{
> + return yt921x_regs_read(priv, reg, vals, 2);
> +}
> +
[Low]
yt921x_reg64_read() reads the 64-bit FLOWSTATn_STAT register as two
independent 32-bit transactions, one for each word, and combines them
in yt921x_acl_stat() with:
*statp = ((u64)vals[1] << 32) | vals[0];
The hardware counter is live and can increment between the two reads.
If the low word wraps from ~0xffffffff to a small value while the high
word increments between the two transactions, the recombined value
becomes (new_high << 32) | old_low, producing a spurious ~4 GiB jump.
Does the chip provide a latch/snapshot register, or a documented
read-low/high/low retry protocol, that should be used here instead of
two independent reads?
> static int
> yt921x_reg64_write(struct yt921x_priv *priv, u32 reg, const u32 *vals)
> {
> @@ -2224,6 +2229,40 @@ yt921x_acl_reserve(struct yt921x_priv *priv, unsigned int entscnt,
> return UINT_MAX;
> }
>
> +static int
> +yt921x_acl_stat(struct yt921x_priv *priv, enum tc_setup_type type,
> + unsigned long tag, u64 *statp)
> +{
> + const struct yt921x_acl_rule *aclrule;
> + const struct yt921x_acl_blk *aclblk;
> + unsigned int statid;
> + unsigned int binid;
> + unsigned int blkid;
> + unsigned int entid;
> + u32 vals[2];
> + int res;
> +
> + entid = yt921x_acl_find(priv, type, tag);
> + if (entid == UINT_MAX)
> + return -ENOENT;
> +
> + blkid = entid / YT921X_ACL_ENT_PER_BLK;
> + binid = entid % YT921X_ACL_ENT_PER_BLK;
> + aclblk = priv->acl_blks[blkid];
> + aclrule = aclblk->rules[binid];
> +
> + if (!(aclrule->action[0] & YT921X_ACL_ACTa_FLOWSTAT_EN))
> + return -EOPNOTSUPP;
> +
> + statid = FIELD_GET(YT921X_ACL_ACTa_FLOWSTAT_ID_M, aclrule->action[0]);
> + res = yt921x_reg64_read(priv, YT921X_FLOWSTATn_STAT(statid), vals);
> + if (res)
> + return res;
> +
> + *statp = ((u64)vals[1] << 32) | vals[0];
> + return 0;
> +}
> +
[High]
The absolute hardware counter is written directly into cls->stats.bytes,
and the flow_offload framework treats this value as a per-poll delta.
Following the call chain tcf_exts_hw_stats_update() ->
tcf_action_stats_update() -> a->ops->stats_update() -> _bstats_update(),
the framework performs:
u64_stats_add(&bstats->bytes, bytes);
So if the hardware counter currently shows X bytes, every subsequent
poll of an idle counter adds another X to the kernel running total. After
N polls of an unchanged counter the user-visible "tc -s flower" value
will read N*X instead of X.
Two existing drivers handle this correctly:
- drivers/net/dsa/sja1105/sja1105_vl.c:sja1105_vl_stats() caches a
"last reported" value and reports (current - last).
- drivers/net/ethernet/mscc/ocelot_vcap.c:ocelot_vcap_filter_stats_update()
clears the hardware counter after each read.
Should yt921x_acl_stat() do something similar, either by tracking the
previously reported value per-rule, or by clearing FLOWSTATn_STAT after
the read?
[Medium]
cls->stats.pkts and cls->stats.lastused are never populated. The
hardware is hardwired to byte mode (YT921X_FLOWSTAT_CTRL_TYPE_FLOW with
PKT_MODE cleared), so no packet count is available, but the driver still
sets:
cls->stats.used_hw_stats = FLOW_ACTION_HW_STATS_IMMEDIATE;
cls->stats.used_hw_stats_valid = true;
Combined with the additive _bstats_update() semantics above, "tc -s
flower" will always show 0 packets even under traffic. Similarly
flow_stats->lastused stays 0, and any rule-aging logic that consults
lastused (it is updated via max_t(u64, ...)) will see the rule as never
used. For comparison, sja1105_vl_stats() passes
(jiffies - rule->vl.stats.lastused) as a delta.
Should the commit message and/or used_hw_stats_valid acknowledge that
pkts and lastused are not being reported?
> static int
> yt921x_acl_commit(struct yt921x_priv *priv, unsigned int entid, u8 entsmask)
> {
> @@ -2336,6 +2375,10 @@ yt921x_acl_del(struct yt921x_priv *priv, enum tc_setup_type type,
> clear_bit(FIELD_GET(YT921X_ACL_ACTa_METER_ID_M,
> aclrule->action[0]),
> priv->meters_map);
> + if (aclrule->action[0] & YT921X_ACL_ACTa_FLOWSTAT_EN)
> + clear_bit(FIELD_GET(YT921X_ACL_ACTa_FLOWSTAT_ID_M,
> + aclrule->action[0]),
> + priv->flowstats_map);
[Low]
On rule delete the priv->flowstats_map bit is cleared, but
YT921X_FLOWSTATn_CTRL(statid) is not written to clear FLOWSTAT_CTRL_EN.
The counter remains physically enabled with TYPE_FLOW until something
else reprograms it.
Today this is benign because acl_commit() zeros the action register so
no rule references the counter, and reuse rewrites CTRL. However, the
header file enumerates other types (TYPE_CPU_CODE, TYPE_DROP_CODE,
TYPE_PORT) for the same slot pool. If a future caller picks one of
these types without first disabling the slot, could it observe stale
counts from the previous flow user?
> priv->acl_masks[blkid] &= ~aclrule->mask;
> kvfree(aclrule);
> if (!priv->acl_masks[blkid]) {
> @@ -2355,11 +2398,13 @@ yt921x_acl_add(struct yt921x_priv *priv,
> struct yt921x_acl_blk *aclblk;
> bool use_trap = false;
> unsigned int meterid;
> + unsigned int statid;
> unsigned long mask;
> unsigned int binid;
> unsigned int blkid;
> unsigned int entid;
> unsigned int o;
> + u32 ctrl;
> int res;
>
> /* Allocate resources */
> @@ -2386,6 +2431,22 @@ yt921x_acl_add(struct yt921x_priv *priv,
> }
> }
>
> + statid = find_first_zero_bit(priv->flowstats_map, YT921X_FLOWSTAT_NUM);
> + if (statid < YT921X_FLOWSTAT_NUM) {
> + u32 zeros[2] = {};
> +
> + ctrl = YT921X_FLOWSTAT_CTRL_EN | YT921X_FLOWSTAT_CTRL_TYPE_FLOW;
> + res = yt921x_reg_write(priv, YT921X_FLOWSTATn_CTRL(statid),
> + ctrl);
> + if (res)
> + return res;
> +
> + res = yt921x_reg64_write(priv, YT921X_FLOWSTATn_STAT(statid),
> + zeros);
> + if (res)
> + return res;
> + }
> +
[Medium]
This block runs unconditionally for every ACL rule, regardless of
whether the user requested statistics. When all 64 counters are in use
(statid >= YT921X_FLOWSTAT_NUM), the rule is still installed but
silently without stats; the user only learns by querying and getting
-EOPNOTSUPP from yt921x_acl_stat().
There is no NL_SET_ERR_MSG_MOD() at install time and no kernel log
message. The same function explicitly emits
NL_SET_ERR_MSG_MOD(extack, "No more meters available");
for the meter pool right above this hunk.
Should the flow-stat path either be gated on whether the rule actually
needs stats (so unrelated rules do not consume counters), or surface a
diagnostic via extack when the pool is exhausted? Otherwise an old set
of un-queried rules can starve newer rules that do need stats.
[Low]
After the YT921X_FLOWSTATn_CTRL write succeeds, the bare "return res;"
on a failing YT921X_FLOWSTATn_STAT write leaves the counter enabled in
hardware while priv->flowstats_map remains clear. Likewise, if any
later step (kvmemdup, yt921x_acl_commit) fails, the err: label does not
unwind the CTRL write or the meter configuration done in the prior
hunk.
The same asymmetric rollback pre-exists for meters and is implicitly
healed by the next allocation reprogramming the slot, but the new
flow-stat path's bare returns bypass the err: label entirely. Should
this teardown path be made symmetric?
> /* Prepare acl block ctrlblk */
> blkid = entid / YT921X_ACL_ENT_PER_BLK;
> binid = entid % YT921X_ACL_ENT_PER_BLK;
> @@ -2426,6 +2487,9 @@ yt921x_acl_add(struct yt921x_priv *priv,
> aclrule->action[0] |= YT921X_ACL_ACTa_METER_ID(meterid);
> else
> aclrule->action[0] &= ~YT921X_ACL_ACTa_METER_EN;
> + if (statid < YT921X_FLOWSTAT_NUM)
> + aclrule->action[0] |= YT921X_ACL_ACTa_FLOWSTAT_EN |
> + YT921X_ACL_ACTa_FLOWSTAT_ID(statid);
>
> /* Write rules */
> aclblk->rules[binid] = aclrule;
[ ... ]
--
pw-bot: cr
^ permalink raw reply
* Re: [PATCH] net/smc: bound sndbuf_space on the SMC-D DMB-merge receive path
From: Jakub Kicinski @ 2026-06-14 0:31 UTC (permalink / raw)
To: Bryam Vargas
Cc: D . Wythe, Dust Li, Sidraya Jayagond, Wenjia Zhang,
Mahanta Jambigi, Tony Lu, Wen Gu, David S . Miller, Eric Dumazet,
Paolo Abeni, Simon Horman, linux-rdma, linux-s390, netdev,
linux-kernel
In-Reply-To: <20260610090928.192177-1-hexlabsecurity@proton.me>
On Wed, 10 Jun 2026 09:09:36 +0000 Bryam Vargas wrote:
> /* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */
> + if (atomic_read(&conn->sndbuf_space) >
> + conn->sndbuf_desc->len)
> + atomic_set(&conn->sndbuf_space,
> + conn->sndbuf_desc->len);
similar comments here as on the previous patch
--
pw-bot: cr
^ permalink raw reply
* Re: [PATCH] net/smc: bound the peer producer cursor on SMC-D and SMC-R CDC receive
From: Jakub Kicinski @ 2026-06-14 0:31 UTC (permalink / raw)
To: hexlabsecurity
Cc: Jakub Kicinski, alibuda, dust.li, sidraya, wenjia, mjambigi,
tonylu, guwen, davem, edumazet, pabeni, horms, raspl, ubraun,
linux-rdma, linux-s390, netdev, linux-kernel
In-Reply-To: <20260610084803.186516-1-hexlabsecurity@proton.me>
This is an AI-generated review of your patch. The human sending this
email has considered the AI review valid, or at least plausible.
---
net/smc: bound the peer producer cursor on SMC-D and SMC-R CDC receive
This patch attempts to close an out-of-bounds read in the SMC CDC
receive path by clamping the peer producer cursor and the
bytes_to_rcv accumulator against rmb_desc->len. A couple of
questions on the approach below.
> diff --git a/net/smc/smc_cdc.c b/net/smc/smc_cdc.c
> index 619b3bab3824..738c45fd5cd0 100644
> --- a/net/smc/smc_cdc.c
> +++ b/net/smc/smc_cdc.c
> @@ -382,6 +382,8 @@ static void smc_cdc_msg_recv_action(struct smc_sock *smc,
> smp_mb__before_atomic();
> atomic_add(diff_prod, &conn->bytes_to_rcv);
> /* guarantee 0 <= bytes_to_rcv <= rmb_desc->len */
> + if (atomic_read(&conn->bytes_to_rcv) > conn->rmb_desc->len)
> + atomic_set(&conn->bytes_to_rcv, conn->rmb_desc->len);
[Critical]
Is this clamp safe against a concurrent smc_rx_recvmsg() on another
CPU?
smc_cdc_msg_recv() runs the BH path under bh_lock_sock() (slock with
BH disabled), while smc_rx_recvmsg() runs under lock_sock(), which
sets sk_lock.owned but releases the slock for the body of the
syscall. The body contains:
/* update cursors */
if (!(flags & MSG_PEEK)) {
smp_mb__before_atomic();
atomic_sub(copylen, &conn->bytes_to_rcv);
smp_mb__after_atomic();
...
}
so the BH on CPU0 and the recvmsg body on CPU1 can run concurrently
on the same connection.
The new clamp here is a non-atomic read-then-set:
atomic_add(diff_prod, &conn->bytes_to_rcv);
if (atomic_read(&conn->bytes_to_rcv) > conn->rmb_desc->len)
atomic_set(&conn->bytes_to_rcv, conn->rmb_desc->len);
With L = rmb_desc->len, the commit message notes that the
differing-wrap branch of smc_curs_diff() can return up to
(L - old.count) + new.count, i.e. close to 2L, even after the count
itself is clamped. Can the following interleaving happen?
CPU0 (BH) CPU1 (recvmsg)
atomic_add(diff_prod) -> X (~2L)
readable =
atomic_read(&bytes_to_rcv) = X
copylen = min(remaining, X)
chunk_len = min(copylen,
L - cons.count)
second chunk = copylen - chunk_len
memcpy_to_msg(rcvbuf_base + 0,
second_chunk_len)
atomic_read() -> X
atomic_set(&bytes_to_rcv, L)
With cons.count near L/2 and copylen near 2L, the second chunk reads
roughly 3L/2 bytes starting at rcvbuf_base + 0, walking past the end
of the RMB allocation. Is that not the same OOB read this patch is
meant to close?
A second variant of the same race seems to silently corrupt the
counter:
CPU0 (BH) CPU1 (recvmsg)
atomic_add(diff_prod) -> X > L
atomic_sub(Y) -> X - Y
atomic_read() -> X - Y
(X - Y still > L?)
atomic_set(L)
If X - Y is still above L, CPU0 overwrites the consumer's decrement
and bytes_to_rcv ends up at L even though Y bytes were already
consumed, leaving a persistent over-report that future recvmsg calls
use as readable.
smp_mb__after_atomic() does not turn this read-then-set into an RMW;
atomic_set() is a relaxed store. Would clamping diff_prod against
(L - atomic_read(&bytes_to_rcv)) before the atomic_add (or using an
atomic_cmpxchg loop) close both windows?
> smp_mb__after_atomic();
> smc->sk.sk_data_ready(&smc->sk);
> } else {
> diff --git a/net/smc/smc_cdc.h b/net/smc/smc_cdc.h
> index 696cc11f2303..7fa6e0d3817f 100644
> --- a/net/smc/smc_cdc.h
> +++ b/net/smc/smc_cdc.h
> @@ -230,6 +230,12 @@ static inline void smc_cdc_cursor_to_host(union smc_host_cursor *local,
> smc_curs_copy_net(&net, peer, conn);
> temp.count = ntohl(net.count);
> temp.wrap = ntohs(net.wrap);
> + /* the peer producer cursor is wire-controlled; bound the SMC-R count to
> + * our RMB before it is used as a raw index by the urgent path, mirroring
> + * the SMC-D conversion in smcd_cdc_msg_to_host().
> + */
> + if (temp.count > conn->rmb_desc->len)
> + temp.count = conn->rmb_desc->len;
[High]
Should this clamp live in the shared helper, or only on the prod
call site?
smc_cdc_cursor_to_host() is invoked twice from smcr_cdc_msg_to_host():
smc_cdc_cursor_to_host(&local->prod, &peer->prod, conn);
smc_cdc_cursor_to_host(&local->cons, &peer->cons, conn);
The producer cursor is bounded by our local RMB (conn->rmb_desc->len),
but the consumer cursor lives in the peer's RMB space and is bounded
by conn->peer_rmbe_size, which is set independently in
smcr_conn_save_peer_info() from the peer's CLC bufsize.
smc_cdc_msg_recv_action() confirms the asymmetry:
diff_cons = smc_curs_diff(conn->peer_rmbe_size, &cons_old,
&conn->local_rx_ctrl.cons);
...
atomic_add(diff_cons, &conn->peer_rmbe_space);
so peer_rmbe_size (not rmb_desc->len) is the right bound for the cons
cursor.
Whenever peer_rmbe_size > rmb_desc->len, legitimate peer cons.count
values in (rmb_desc->len, peer_rmbe_size] are silently truncated to
rmb_desc->len here, diff_cons is under-credited and
peer_rmbe_space stays artificially low, which can stall TX flow
control on perfectly well-behaved peers.
The SMC-D companion in this same patch is structured the way the
prod/cons asymmetry suggests -- it clamps prod and copies cons
unmodified:
> @@ -260,6 +266,12 @@ static inline void smcd_cdc_msg_to_host(struct smc_host_cdc_msg *local,
>
> temp.wrap = peer->prod.wrap;
> temp.count = peer->prod.count;
> + /* the peer producer cursor is wire-controlled; a count past our RMB is
> + * used as a raw index by the urgent path (smc_cdc_handle_urg_data_arrival)
> + * and as a length by the recv path. Bound it to the RMB.
> + */
> + if (temp.count > conn->rmb_desc->len)
> + temp.count = conn->rmb_desc->len;
> smc_curs_copy(&local->prod, &temp, conn);
>
> temp.wrap = peer->cons.wrap;
Should the SMC-R hunk be moved out of the shared smc_cdc_cursor_to_host()
helper and onto the prod call site in smcr_cdc_msg_to_host(), to match
the SMC-D shape?
--
pw-bot: cr
^ permalink raw reply
* Re: [PATCH net-next] ipv4: igmp: remove multicast group from hash table on device destruction
From: Yuyang Huang @ 2026-06-14 0:29 UTC (permalink / raw)
To: nicolas.dichtel
Cc: David S. Miller, David Ahern, Eric Dumazet, Ido Schimmel,
Jakub Kicinski, Paolo Abeni, Simon Horman, linux-kernel, netdev
In-Reply-To: <CADXeF1EtcaMaA0DseoR96R7Ru0Fgu9YTrOX_y887MajN7kw57g@mail.gmail.com>
If there is a strong preference for adding a Fixes tag, I will include
it in the v2 patch.
Thanks,
Yuyang
^ permalink raw reply
* Re: [PATCH v2 3/7] net: wwan: t9xx: Add control DMA interface
From: Jakub Kicinski @ 2026-06-14 0:30 UTC (permalink / raw)
To: Jack Wu via B4 Relay
Cc: jackbb_wu, Loic Poulain, Sergey Ryazanov, Johannes Berg,
Andrew Lunn, David S. Miller, Eric Dumazet, Paolo Abeni,
Wen-Zhi Huang, Shi-Wei Yeh, Minano Tseng, Matthias Brugger,
AngeloGioacchino Del Regno, Simon Horman, Jonathan Corbet,
Shuah Khan, linux-kernel, netdev, linux-arm-kernel,
linux-mediatek, linux-doc
In-Reply-To: <20260610-t9xx_driver_v1-v2-3-c65addf23b3f@compal.com>
On Wed, 10 Jun 2026 18:41:06 +0800 Jack Wu via B4 Relay wrote:
> From: Jack Wu <jackbb_wu@compal.com>
>
> Cross Layer Direct Memory Access(CLDMA) is the hardware
> interface used by the control plane and designated to
> translate data between the host and the device. It supports
> 8 hardware queues for the device AP and modem respectively.
Transient build warnings:
+../drivers/net/wwan/t9xx/pcie/mtk_pci_drv_m9xx.c:52:30: warning: symbol 'mtk_dev_cfg_0900' was not declared. Should it be static?
+../drivers/net/wwan/t9xx/pcie/mtk_ctrl_cfg_m9xx.c:19:22: warning: symbol 'mtk_ctrl_info_m9xx' was not declared. Should it be static?
+../drivers/net/wwan/t9xx/pcie/mtk_cldma_drv_m9xx.c:33:22: warning: symbol 'mtk_cldma_regs_m9xx' was not declared. Should it be static?
+../drivers/net/wwan/t9xx/pcie/mtk_cldma_drv_m9xx.c:166:22: warning: symbol 'cldma_drv_ops_m9xx' was not declared. Should it be static?
please also see all the AI code comments at:
https://sashiko.dev/#/patchset/20260610-t9xx_driver_v1-v2-3-c65addf23b3f@compal.com
--
pw-bot: cr
^ permalink raw reply
* Re: [PATCH net-next v3 0/6] pds_core: Add PLDM firmware update and host backed memory support
From: Rao, Nikhil @ 2026-06-14 0:15 UTC (permalink / raw)
To: Jakub Kicinski, Jacob Keller
Cc: netdev, Brett Creeley, Andrew Lunn, David S . Miller,
Eric Dumazet, Paolo Abeni, Eric Joyner
In-Reply-To: <20260613135811.1b1f7e65@kernel.org>
On 6/13/2026 1:58 PM, Jakub Kicinski wrote:
> On Thu, 11 Jun 2026 11:53:13 -0700 Jacob Keller wrote:
>> On 6/11/2026 10:15 AM, Rao, Nikhil wrote:
>>>> The preference is to use generic names when possible/feasible. I think
>>>> at least some of your name choices could align with the generic ones.
>>>>
>>>> Could you explain why fw.mainfw was selected and fw.mgmt was deemed not
>>>> suitable?
>>>
>>> This component handles both control and data path, so fw.mgmt didn't
>>> feel right since devlink-info.rst explicitly excludes data path from
>>> that definition. We went with fw.mainfw to indicate it's the primary
>>> firmware component
>>
>> It might make sense to extend or add a new definition in this case.
>> Technically you could also report both fw.mgmt and fw.app together, but
>> I think that would be more confusing.
>>
>> Perhaps Jakub has a suggestion on the name or policy here. The
>> maintainer preference has generally been to use or extend standardized
>> names first unless the name or component is clearly unique to the device.
>
> If it covers both datapath and mgmt then shouldn't it be just "fw" ?
> Right now driver reports something "running"-only as "fw", looks off
Will change the PLDM component from "fw.mainfw" to just "fw".
For identity version 2+, the PLDM code reports both running and stored
versions. For version 1 (no PLDM), will retain the dev_info.fw_version
running-only report.
Thanks,
Nikhil
^ permalink raw reply
* Re: [PATCH net] psample: zero the netlink attribute padding in PSAMPLE_ATTR_DATA
From: Jakub Kicinski @ 2026-06-14 0:10 UTC (permalink / raw)
To: Xiang Mei; +Cc: netdev, davem, yotam.gi, edumazet, pabeni, horms, bestswngs
In-Reply-To: <CAPpSM+RuCaNoYFN7JKGDeUScK2-xLjSULA4i8bnChmG05hBaNA@mail.gmail.com>
On Sat, 13 Jun 2026 17:02:39 -0700 Xiang Mei wrote:
> > > if (data_len) {
> > > - int nla_len = nla_total_size(data_len);
> > > struct nlattr *nla;
> > >
> > > - nla = skb_put(nl_skb, nla_len);
> > > - nla->nla_type = PSAMPLE_ATTR_DATA;
> > > - nla->nla_len = nla_attr_size(data_len);
> > > + nla = nla_reserve(nl_skb, PSAMPLE_ATTR_DATA, data_len);
> > > + if (!nla)
> > > + goto error;
> > >
> > > if (skb_copy_bits(skb, 0, nla_data(nla), data_len))
> > > goto error;
> > >
> > > Let me know if the new patch makes sense.
> >
> > I assumed the author intentionally was avoiding the memset for
> > the memory we will override with data. Otherwise the whole dance
> > could be avoided and nla_put() would have been the answer.
>
> The reason nla_put() isn't used here is that the payload source is the
> sampled skb, which can be nonlinear, so the data has to be gathered with
> skb_copy_bits() rather than a flat memcpy().
That too.
> There is no nla_put() variant that takes an skb source, hence the
> reserve-then-copy.
>
> But that doesn't require open-coding the attribute: nla_reserve() only
> memsets the alignment padding (nla_padlen), never the data region, so
> nla_reserve() + skb_copy_bits() writes every byte exactly once with no
> redundant memset over the payload. The bug was that the open-coded
> version dropped that padding-zero step.
I find it hard to believe that nla_reserve() was not considered.
It's a widely used function in the networking stack.
Please move on.
^ permalink raw reply
* Re: [PATCH net] psample: zero the netlink attribute padding in PSAMPLE_ATTR_DATA
From: Xiang Mei @ 2026-06-14 0:02 UTC (permalink / raw)
To: Jakub Kicinski
Cc: netdev, davem, yotam.gi, edumazet, pabeni, horms, bestswngs
In-Reply-To: <20260613164820.491226a7@kernel.org>
On Sat, Jun 13, 2026 at 4:48 PM Jakub Kicinski <kuba@kernel.org> wrote:
>
> On Sat, 13 Jun 2026 16:33:44 -0700 Xiang Mei wrote:
> > That looks better. I just found that nla_reserve can memset for us:
> >
> > diff --git a/net/psample/psample.c b/net/psample/psample.c
> > index 7763662036fb..c112e1f0ccac 100644
> > --- a/net/psample/psample.c
> > +++ b/net/psample/psample.c
> > @@ -476,12 +476,11 @@ void psample_sample_packet(struct psample_group *group,
> > goto error;
> >
> > if (data_len) {
> > - int nla_len = nla_total_size(data_len);
> > struct nlattr *nla;
> >
> > - nla = skb_put(nl_skb, nla_len);
> > - nla->nla_type = PSAMPLE_ATTR_DATA;
> > - nla->nla_len = nla_attr_size(data_len);
> > + nla = nla_reserve(nl_skb, PSAMPLE_ATTR_DATA, data_len);
> > + if (!nla)
> > + goto error;
> >
> > if (skb_copy_bits(skb, 0, nla_data(nla), data_len))
> > goto error;
> >
> > Let me know if the new patch makes sense.
>
> I assumed the author intentionally was avoiding the memset for
> the memory we will override with data. Otherwise the whole dance
> could be avoided and nla_put() would have been the answer.
The reason nla_put() isn't used here is that the payload source is the
sampled skb, which can be nonlinear, so the data has to be gathered with
skb_copy_bits() rather than a flat memcpy(). There is no nla_put() variant
that takes an skb source, hence the reserve-then-copy.
But that doesn't require open-coding the attribute: nla_reserve() only
memsets the alignment padding (nla_padlen), never the data region, so
nla_reserve() + skb_copy_bits() writes every byte exactly once with no
redundant memset over the payload. The bug was that the open-coded
version dropped that padding-zero step.
Xiang
^ permalink raw reply
* Re: [PATCH net-next v2 1/2] netdev: expose io_uring rx_page_order order via netlink
From: Jakub Kicinski @ 2026-06-14 0:02 UTC (permalink / raw)
To: Dragos Tatulea
Cc: Pavel Begunkov, Donald Hunter, David S. Miller, Eric Dumazet,
Paolo Abeni, Simon Horman, Andrew Lunn, Jens Axboe, Yael Chemla,
Tariq Toukan, netdev, linux-kernel, io-uring
In-Reply-To: <b581d253-135b-4c75-a50d-2049c6d6e249@nvidia.com>
On Sat, 13 Jun 2026 16:09:03 +0200 Dragos Tatulea wrote:
> On 13.06.26 11:53, Pavel Begunkov wrote:
> > On 6/12/26 22:17, Dragos Tatulea wrote:
> >> This adds observability for the io_uring zcrx rx-buf-len configuration.
> >
> > It might be nicer to look it up in the queue, e.g. rxq->mp_params,
> > and make it a queue attribute instead of zcrx specific one. In either
> > case, no objections.
>
> In io_pp_nl_fill() or in page_pool_nl_fill() as it was done in v1 for order?
It's fine. We decided to make the "page size" a memory provider
property, now we're going back to making it a queue level param?
Like my RFC had that everyone hated so much? Sigh.
^ permalink raw reply
* Re: [PATCH net-next v5 2/4] net: phy: c45: add genphy_c45_config_master_slave()
From: Jakub Kicinski @ 2026-06-13 23:59 UTC (permalink / raw)
To: javen
Cc: andrew, hkallweit1, linux, davem, edumazet, pabeni, freddy_gu, nb,
netdev, linux-kernel, daniel, vladimir.oltean
In-Reply-To: <20260611031839.568-3-javen_xu@realsil.com.cn>
On Thu, 11 Jun 2026 11:18:37 +0800 javen wrote:
> + * Returns negative errno code on failure, 0 if Master/Slave didn't change,
> + * or 1 if Master/Slave modes changed.
Returns:
the colon is needed otherwise:
Warning: drivers/net/phy/phy-c45.c:420 No description found for return value of 'genphy_c45_an_setup_master_slave'
There's also an AI review at
https://sashiko.dev/#/patchset/20260611031839.568-3-javen_xu@realsil.com.cn
--
pw-bot: cr
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox