tcp.c 94 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * Implementation of the Transmission Control Protocol(TCP).
  7. *
  8. * Authors: Ross Biro
  9. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  10. * Mark Evans, <evansmp@uhura.aston.ac.uk>
  11. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  12. * Florian La Roche, <flla@stud.uni-sb.de>
  13. * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
  14. * Linus Torvalds, <torvalds@cs.helsinki.fi>
  15. * Alan Cox, <gw4pts@gw4pts.ampr.org>
  16. * Matthew Dillon, <dillon@apollo.west.oic.com>
  17. * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
  18. * Jorge Cwik, <jorge@laser.satlink.net>
  19. *
  20. * Fixes:
  21. * Alan Cox : Numerous verify_area() calls
  22. * Alan Cox : Set the ACK bit on a reset
  23. * Alan Cox : Stopped it crashing if it closed while
  24. * sk->inuse=1 and was trying to connect
  25. * (tcp_err()).
  26. * Alan Cox : All icmp error handling was broken
  27. * pointers passed where wrong and the
  28. * socket was looked up backwards. Nobody
  29. * tested any icmp error code obviously.
  30. * Alan Cox : tcp_err() now handled properly. It
  31. * wakes people on errors. poll
  32. * behaves and the icmp error race
  33. * has gone by moving it into sock.c
  34. * Alan Cox : tcp_send_reset() fixed to work for
  35. * everything not just packets for
  36. * unknown sockets.
  37. * Alan Cox : tcp option processing.
  38. * Alan Cox : Reset tweaked (still not 100%) [Had
  39. * syn rule wrong]
  40. * Herp Rosmanith : More reset fixes
  41. * Alan Cox : No longer acks invalid rst frames.
  42. * Acking any kind of RST is right out.
  43. * Alan Cox : Sets an ignore me flag on an rst
  44. * receive otherwise odd bits of prattle
  45. * escape still
  46. * Alan Cox : Fixed another acking RST frame bug.
  47. * Should stop LAN workplace lockups.
  48. * Alan Cox : Some tidyups using the new skb list
  49. * facilities
  50. * Alan Cox : sk->keepopen now seems to work
  51. * Alan Cox : Pulls options out correctly on accepts
  52. * Alan Cox : Fixed assorted sk->rqueue->next errors
  53. * Alan Cox : PSH doesn't end a TCP read. Switched a
  54. * bit to skb ops.
  55. * Alan Cox : Tidied tcp_data to avoid a potential
  56. * nasty.
  57. * Alan Cox : Added some better commenting, as the
  58. * tcp is hard to follow
  59. * Alan Cox : Removed incorrect check for 20 * psh
  60. * Michael O'Reilly : ack < copied bug fix.
  61. * Johannes Stille : Misc tcp fixes (not all in yet).
  62. * Alan Cox : FIN with no memory -> CRASH
  63. * Alan Cox : Added socket option proto entries.
  64. * Also added awareness of them to accept.
  65. * Alan Cox : Added TCP options (SOL_TCP)
  66. * Alan Cox : Switched wakeup calls to callbacks,
  67. * so the kernel can layer network
  68. * sockets.
  69. * Alan Cox : Use ip_tos/ip_ttl settings.
  70. * Alan Cox : Handle FIN (more) properly (we hope).
  71. * Alan Cox : RST frames sent on unsynchronised
  72. * state ack error.
  73. * Alan Cox : Put in missing check for SYN bit.
  74. * Alan Cox : Added tcp_select_window() aka NET2E
  75. * window non shrink trick.
  76. * Alan Cox : Added a couple of small NET2E timer
  77. * fixes
  78. * Charles Hedrick : TCP fixes
  79. * Toomas Tamm : TCP window fixes
  80. * Alan Cox : Small URG fix to rlogin ^C ack fight
  81. * Charles Hedrick : Rewrote most of it to actually work
  82. * Linus : Rewrote tcp_read() and URG handling
  83. * completely
  84. * Gerhard Koerting: Fixed some missing timer handling
  85. * Matthew Dillon : Reworked TCP machine states as per RFC
  86. * Gerhard Koerting: PC/TCP workarounds
  87. * Adam Caldwell : Assorted timer/timing errors
  88. * Matthew Dillon : Fixed another RST bug
  89. * Alan Cox : Move to kernel side addressing changes.
  90. * Alan Cox : Beginning work on TCP fastpathing
  91. * (not yet usable)
  92. * Arnt Gulbrandsen: Turbocharged tcp_check() routine.
  93. * Alan Cox : TCP fast path debugging
  94. * Alan Cox : Window clamping
  95. * Michael Riepe : Bug in tcp_check()
  96. * Matt Dillon : More TCP improvements and RST bug fixes
  97. * Matt Dillon : Yet more small nasties remove from the
  98. * TCP code (Be very nice to this man if
  99. * tcp finally works 100%) 8)
  100. * Alan Cox : BSD accept semantics.
  101. * Alan Cox : Reset on closedown bug.
  102. * Peter De Schrijver : ENOTCONN check missing in tcp_sendto().
  103. * Michael Pall : Handle poll() after URG properly in
  104. * all cases.
  105. * Michael Pall : Undo the last fix in tcp_read_urg()
  106. * (multi URG PUSH broke rlogin).
  107. * Michael Pall : Fix the multi URG PUSH problem in
  108. * tcp_readable(), poll() after URG
  109. * works now.
  110. * Michael Pall : recv(...,MSG_OOB) never blocks in the
  111. * BSD api.
  112. * Alan Cox : Changed the semantics of sk->socket to
  113. * fix a race and a signal problem with
  114. * accept() and async I/O.
  115. * Alan Cox : Relaxed the rules on tcp_sendto().
  116. * Yury Shevchuk : Really fixed accept() blocking problem.
  117. * Craig I. Hagan : Allow for BSD compatible TIME_WAIT for
  118. * clients/servers which listen in on
  119. * fixed ports.
  120. * Alan Cox : Cleaned the above up and shrank it to
  121. * a sensible code size.
  122. * Alan Cox : Self connect lockup fix.
  123. * Alan Cox : No connect to multicast.
  124. * Ross Biro : Close unaccepted children on master
  125. * socket close.
  126. * Alan Cox : Reset tracing code.
  127. * Alan Cox : Spurious resets on shutdown.
  128. * Alan Cox : Giant 15 minute/60 second timer error
  129. * Alan Cox : Small whoops in polling before an
  130. * accept.
  131. * Alan Cox : Kept the state trace facility since
  132. * it's handy for debugging.
  133. * Alan Cox : More reset handler fixes.
  134. * Alan Cox : Started rewriting the code based on
  135. * the RFC's for other useful protocol
  136. * references see: Comer, KA9Q NOS, and
  137. * for a reference on the difference
  138. * between specifications and how BSD
  139. * works see the 4.4lite source.
  140. * A.N.Kuznetsov : Don't time wait on completion of tidy
  141. * close.
  142. * Linus Torvalds : Fin/Shutdown & copied_seq changes.
  143. * Linus Torvalds : Fixed BSD port reuse to work first syn
  144. * Alan Cox : Reimplemented timers as per the RFC
  145. * and using multiple timers for sanity.
  146. * Alan Cox : Small bug fixes, and a lot of new
  147. * comments.
  148. * Alan Cox : Fixed dual reader crash by locking
  149. * the buffers (much like datagram.c)
  150. * Alan Cox : Fixed stuck sockets in probe. A probe
  151. * now gets fed up of retrying without
  152. * (even a no space) answer.
  153. * Alan Cox : Extracted closing code better
  154. * Alan Cox : Fixed the closing state machine to
  155. * resemble the RFC.
  156. * Alan Cox : More 'per spec' fixes.
  157. * Jorge Cwik : Even faster checksumming.
  158. * Alan Cox : tcp_data() doesn't ack illegal PSH
  159. * only frames. At least one pc tcp stack
  160. * generates them.
  161. * Alan Cox : Cache last socket.
  162. * Alan Cox : Per route irtt.
  163. * Matt Day : poll()->select() match BSD precisely on error
  164. * Alan Cox : New buffers
  165. * Marc Tamsky : Various sk->prot->retransmits and
  166. * sk->retransmits misupdating fixed.
  167. * Fixed tcp_write_timeout: stuck close,
  168. * and TCP syn retries gets used now.
  169. * Mark Yarvis : In tcp_read_wakeup(), don't send an
  170. * ack if state is TCP_CLOSED.
  171. * Alan Cox : Look up device on a retransmit - routes may
  172. * change. Doesn't yet cope with MSS shrink right
  173. * but it's a start!
  174. * Marc Tamsky : Closing in closing fixes.
  175. * Mike Shaver : RFC1122 verifications.
  176. * Alan Cox : rcv_saddr errors.
  177. * Alan Cox : Block double connect().
  178. * Alan Cox : Small hooks for enSKIP.
  179. * Alexey Kuznetsov: Path MTU discovery.
  180. * Alan Cox : Support soft errors.
  181. * Alan Cox : Fix MTU discovery pathological case
  182. * when the remote claims no mtu!
  183. * Marc Tamsky : TCP_CLOSE fix.
  184. * Colin (G3TNE) : Send a reset on syn ack replies in
  185. * window but wrong (fixes NT lpd problems)
  186. * Pedro Roque : Better TCP window handling, delayed ack.
  187. * Joerg Reuter : No modification of locked buffers in
  188. * tcp_do_retransmit()
  189. * Eric Schenk : Changed receiver side silly window
  190. * avoidance algorithm to BSD style
  191. * algorithm. This doubles throughput
  192. * against machines running Solaris,
  193. * and seems to result in general
  194. * improvement.
  195. * Stefan Magdalinski : adjusted tcp_readable() to fix FIONREAD
  196. * Willy Konynenberg : Transparent proxying support.
  197. * Mike McLagan : Routing by source
  198. * Keith Owens : Do proper merging with partial SKB's in
  199. * tcp_do_sendmsg to avoid burstiness.
  200. * Eric Schenk : Fix fast close down bug with
  201. * shutdown() followed by close().
  202. * Andi Kleen : Make poll agree with SIGIO
  203. * Salvatore Sanfilippo : Support SO_LINGER with linger == 1 and
  204. * lingertime == 0 (RFC 793 ABORT Call)
  205. * Hirokazu Takahashi : Use copy_from_user() instead of
  206. * csum_and_copy_from_user() if possible.
  207. *
  208. * This program is free software; you can redistribute it and/or
  209. * modify it under the terms of the GNU General Public License
  210. * as published by the Free Software Foundation; either version
  211. * 2 of the License, or(at your option) any later version.
  212. *
  213. * Description of States:
  214. *
  215. * TCP_SYN_SENT sent a connection request, waiting for ack
  216. *
  217. * TCP_SYN_RECV received a connection request, sent ack,
  218. * waiting for final ack in three-way handshake.
  219. *
  220. * TCP_ESTABLISHED connection established
  221. *
  222. * TCP_FIN_WAIT1 our side has shutdown, waiting to complete
  223. * transmission of remaining buffered data
  224. *
  225. * TCP_FIN_WAIT2 all buffered data sent, waiting for remote
  226. * to shutdown
  227. *
  228. * TCP_CLOSING both sides have shutdown but we still have
  229. * data we have to finish sending
  230. *
  231. * TCP_TIME_WAIT timeout to catch resent junk before entering
  232. * closed, can only be entered from FIN_WAIT2
  233. * or CLOSING. Required because the other end
  234. * may not have gotten our last ACK causing it
  235. * to retransmit the data packet (which we ignore)
  236. *
  237. * TCP_CLOSE_WAIT remote side has shutdown and is waiting for
  238. * us to finish writing our data and to shutdown
  239. * (we have to close() to move on to LAST_ACK)
  240. *
  241. * TCP_LAST_ACK out side has shutdown after remote has
  242. * shutdown. There may still be data in our
  243. * buffer that we have to finish sending
  244. *
  245. * TCP_CLOSE socket is finished
  246. */
  247. #define pr_fmt(fmt) "TCP: " fmt
  248. #include <linux/kernel.h>
  249. #include <linux/module.h>
  250. #include <linux/types.h>
  251. #include <linux/fcntl.h>
  252. #include <linux/poll.h>
  253. #include <linux/init.h>
  254. #include <linux/fs.h>
  255. #include <linux/skbuff.h>
  256. #include <linux/scatterlist.h>
  257. #include <linux/splice.h>
  258. #include <linux/net.h>
  259. #include <linux/socket.h>
  260. #include <linux/random.h>
  261. #include <linux/bootmem.h>
  262. #include <linux/highmem.h>
  263. #include <linux/swap.h>
  264. #include <linux/cache.h>
  265. #include <linux/err.h>
  266. #include <linux/crypto.h>
  267. #include <linux/time.h>
  268. #include <linux/slab.h>
  269. #include <net/icmp.h>
  270. #include <net/inet_common.h>
  271. #include <net/tcp.h>
  272. #include <net/xfrm.h>
  273. #include <net/ip.h>
  274. #include <net/netdma.h>
  275. #include <net/sock.h>
  276. #include <asm/uaccess.h>
  277. #include <asm/ioctls.h>
  278. int sysctl_tcp_fin_timeout __read_mostly = TCP_FIN_TIMEOUT;
  279. struct percpu_counter tcp_orphan_count;
  280. EXPORT_SYMBOL_GPL(tcp_orphan_count);
  281. int sysctl_tcp_wmem[3] __read_mostly;
  282. int sysctl_tcp_rmem[3] __read_mostly;
  283. EXPORT_SYMBOL(sysctl_tcp_rmem);
  284. EXPORT_SYMBOL(sysctl_tcp_wmem);
  285. atomic_long_t tcp_memory_allocated; /* Current allocated memory. */
  286. EXPORT_SYMBOL(tcp_memory_allocated);
  287. /*
  288. * Current number of TCP sockets.
  289. */
  290. struct percpu_counter tcp_sockets_allocated;
  291. EXPORT_SYMBOL(tcp_sockets_allocated);
  292. /*
  293. * TCP splice context
  294. */
  295. struct tcp_splice_state {
  296. struct pipe_inode_info *pipe;
  297. size_t len;
  298. unsigned int flags;
  299. };
  300. /*
  301. * Pressure flag: try to collapse.
  302. * Technical note: it is used by multiple contexts non atomically.
  303. * All the __sk_mem_schedule() is of this nature: accounting
  304. * is strict, actions are advisory and have some latency.
  305. */
  306. int tcp_memory_pressure __read_mostly;
  307. EXPORT_SYMBOL(tcp_memory_pressure);
  308. void tcp_enter_memory_pressure(struct sock *sk)
  309. {
  310. if (!tcp_memory_pressure) {
  311. NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
  312. tcp_memory_pressure = 1;
  313. }
  314. }
  315. EXPORT_SYMBOL(tcp_enter_memory_pressure);
  316. /* Convert seconds to retransmits based on initial and max timeout */
  317. static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
  318. {
  319. u8 res = 0;
  320. if (seconds > 0) {
  321. int period = timeout;
  322. res = 1;
  323. while (seconds > period && res < 255) {
  324. res++;
  325. timeout <<= 1;
  326. if (timeout > rto_max)
  327. timeout = rto_max;
  328. period += timeout;
  329. }
  330. }
  331. return res;
  332. }
  333. /* Convert retransmits to seconds based on initial and max timeout */
  334. static int retrans_to_secs(u8 retrans, int timeout, int rto_max)
  335. {
  336. int period = 0;
  337. if (retrans > 0) {
  338. period = timeout;
  339. while (--retrans) {
  340. timeout <<= 1;
  341. if (timeout > rto_max)
  342. timeout = rto_max;
  343. period += timeout;
  344. }
  345. }
  346. return period;
  347. }
  348. /* Address-family independent initialization for a tcp_sock.
  349. *
  350. * NOTE: A lot of things set to zero explicitly by call to
  351. * sk_alloc() so need not be done here.
  352. */
  353. void tcp_init_sock(struct sock *sk)
  354. {
  355. struct inet_connection_sock *icsk = inet_csk(sk);
  356. struct tcp_sock *tp = tcp_sk(sk);
  357. skb_queue_head_init(&tp->out_of_order_queue);
  358. tcp_init_xmit_timers(sk);
  359. tcp_prequeue_init(tp);
  360. INIT_LIST_HEAD(&tp->tsq_node);
  361. icsk->icsk_rto = TCP_TIMEOUT_INIT;
  362. tp->mdev = TCP_TIMEOUT_INIT;
  363. /* So many TCP implementations out there (incorrectly) count the
  364. * initial SYN frame in their delayed-ACK and congestion control
  365. * algorithms that we must have the following bandaid to talk
  366. * efficiently to them. -DaveM
  367. */
  368. tp->snd_cwnd = TCP_INIT_CWND;
  369. /* See draft-stevens-tcpca-spec-01 for discussion of the
  370. * initialization of these values.
  371. */
  372. tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
  373. tp->snd_cwnd_clamp = ~0;
  374. tp->mss_cache = TCP_MSS_DEFAULT;
  375. tp->reordering = sysctl_tcp_reordering;
  376. tcp_enable_early_retrans(tp);
  377. icsk->icsk_ca_ops = &tcp_init_congestion_ops;
  378. sk->sk_state = TCP_CLOSE;
  379. sk->sk_write_space = sk_stream_write_space;
  380. sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
  381. icsk->icsk_sync_mss = tcp_sync_mss;
  382. /* TCP Cookie Transactions */
  383. if (sysctl_tcp_cookie_size > 0) {
  384. /* Default, cookies without s_data_payload. */
  385. tp->cookie_values =
  386. kzalloc(sizeof(*tp->cookie_values),
  387. sk->sk_allocation);
  388. if (tp->cookie_values != NULL)
  389. kref_init(&tp->cookie_values->kref);
  390. }
  391. /* Presumed zeroed, in order of appearance:
  392. * cookie_in_always, cookie_out_never,
  393. * s_data_constant, s_data_in, s_data_out
  394. */
  395. sk->sk_sndbuf = sysctl_tcp_wmem[1];
  396. sk->sk_rcvbuf = sysctl_tcp_rmem[1];
  397. local_bh_disable();
  398. sock_update_memcg(sk);
  399. sk_sockets_allocated_inc(sk);
  400. local_bh_enable();
  401. }
  402. EXPORT_SYMBOL(tcp_init_sock);
  403. /*
  404. * Wait for a TCP event.
  405. *
  406. * Note that we don't need to lock the socket, as the upper poll layers
  407. * take care of normal races (between the test and the event) and we don't
  408. * go look at any of the socket buffers directly.
  409. */
  410. unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
  411. {
  412. unsigned int mask;
  413. struct sock *sk = sock->sk;
  414. const struct tcp_sock *tp = tcp_sk(sk);
  415. sock_poll_wait(file, sk_sleep(sk), wait);
  416. if (sk->sk_state == TCP_LISTEN)
  417. return inet_csk_listen_poll(sk);
  418. /* Socket is not locked. We are protected from async events
  419. * by poll logic and correct handling of state changes
  420. * made by other threads is impossible in any case.
  421. */
  422. mask = 0;
  423. /*
  424. * POLLHUP is certainly not done right. But poll() doesn't
  425. * have a notion of HUP in just one direction, and for a
  426. * socket the read side is more interesting.
  427. *
  428. * Some poll() documentation says that POLLHUP is incompatible
  429. * with the POLLOUT/POLLWR flags, so somebody should check this
  430. * all. But careful, it tends to be safer to return too many
  431. * bits than too few, and you can easily break real applications
  432. * if you don't tell them that something has hung up!
  433. *
  434. * Check-me.
  435. *
  436. * Check number 1. POLLHUP is _UNMASKABLE_ event (see UNIX98 and
  437. * our fs/select.c). It means that after we received EOF,
  438. * poll always returns immediately, making impossible poll() on write()
  439. * in state CLOSE_WAIT. One solution is evident --- to set POLLHUP
  440. * if and only if shutdown has been made in both directions.
  441. * Actually, it is interesting to look how Solaris and DUX
  442. * solve this dilemma. I would prefer, if POLLHUP were maskable,
  443. * then we could set it on SND_SHUTDOWN. BTW examples given
  444. * in Stevens' books assume exactly this behaviour, it explains
  445. * why POLLHUP is incompatible with POLLOUT. --ANK
  446. *
  447. * NOTE. Check for TCP_CLOSE is added. The goal is to prevent
  448. * blocking on fresh not-connected or disconnected socket. --ANK
  449. */
  450. if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == TCP_CLOSE)
  451. mask |= POLLHUP;
  452. if (sk->sk_shutdown & RCV_SHUTDOWN)
  453. mask |= POLLIN | POLLRDNORM | POLLRDHUP;
  454. /* Connected or passive Fast Open socket? */
  455. if (sk->sk_state != TCP_SYN_SENT &&
  456. (sk->sk_state != TCP_SYN_RECV || tp->fastopen_rsk != NULL)) {
  457. int target = sock_rcvlowat(sk, 0, INT_MAX);
  458. if (tp->urg_seq == tp->copied_seq &&
  459. !sock_flag(sk, SOCK_URGINLINE) &&
  460. tp->urg_data)
  461. target++;
  462. /* Potential race condition. If read of tp below will
  463. * escape above sk->sk_state, we can be illegally awaken
  464. * in SYN_* states. */
  465. if (tp->rcv_nxt - tp->copied_seq >= target)
  466. mask |= POLLIN | POLLRDNORM;
  467. if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
  468. if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
  469. mask |= POLLOUT | POLLWRNORM;
  470. } else { /* send SIGIO later */
  471. set_bit(SOCK_ASYNC_NOSPACE,
  472. &sk->sk_socket->flags);
  473. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  474. /* Race breaker. If space is freed after
  475. * wspace test but before the flags are set,
  476. * IO signal will be lost.
  477. */
  478. if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
  479. mask |= POLLOUT | POLLWRNORM;
  480. }
  481. } else
  482. mask |= POLLOUT | POLLWRNORM;
  483. if (tp->urg_data & TCP_URG_VALID)
  484. mask |= POLLPRI;
  485. }
  486. /* This barrier is coupled with smp_wmb() in tcp_reset() */
  487. smp_rmb();
  488. if (sk->sk_err)
  489. mask |= POLLERR;
  490. return mask;
  491. }
  492. EXPORT_SYMBOL(tcp_poll);
  493. int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
  494. {
  495. struct tcp_sock *tp = tcp_sk(sk);
  496. int answ;
  497. bool slow;
  498. switch (cmd) {
  499. case SIOCINQ:
  500. if (sk->sk_state == TCP_LISTEN)
  501. return -EINVAL;
  502. slow = lock_sock_fast(sk);
  503. if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
  504. answ = 0;
  505. else if (sock_flag(sk, SOCK_URGINLINE) ||
  506. !tp->urg_data ||
  507. before(tp->urg_seq, tp->copied_seq) ||
  508. !before(tp->urg_seq, tp->rcv_nxt)) {
  509. answ = tp->rcv_nxt - tp->copied_seq;
  510. /* Subtract 1, if FIN was received */
  511. if (answ && sock_flag(sk, SOCK_DONE))
  512. answ--;
  513. } else
  514. answ = tp->urg_seq - tp->copied_seq;
  515. unlock_sock_fast(sk, slow);
  516. break;
  517. case SIOCATMARK:
  518. answ = tp->urg_data && tp->urg_seq == tp->copied_seq;
  519. break;
  520. case SIOCOUTQ:
  521. if (sk->sk_state == TCP_LISTEN)
  522. return -EINVAL;
  523. if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
  524. answ = 0;
  525. else
  526. answ = tp->write_seq - tp->snd_una;
  527. break;
  528. case SIOCOUTQNSD:
  529. if (sk->sk_state == TCP_LISTEN)
  530. return -EINVAL;
  531. if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
  532. answ = 0;
  533. else
  534. answ = tp->write_seq - tp->snd_nxt;
  535. break;
  536. default:
  537. return -ENOIOCTLCMD;
  538. }
  539. return put_user(answ, (int __user *)arg);
  540. }
  541. EXPORT_SYMBOL(tcp_ioctl);
  542. static inline void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb)
  543. {
  544. TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
  545. tp->pushed_seq = tp->write_seq;
  546. }
  547. static inline bool forced_push(const struct tcp_sock *tp)
  548. {
  549. return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1));
  550. }
  551. static inline void skb_entail(struct sock *sk, struct sk_buff *skb)
  552. {
  553. struct tcp_sock *tp = tcp_sk(sk);
  554. struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
  555. skb->csum = 0;
  556. tcb->seq = tcb->end_seq = tp->write_seq;
  557. tcb->tcp_flags = TCPHDR_ACK;
  558. tcb->sacked = 0;
  559. skb_header_release(skb);
  560. tcp_add_write_queue_tail(sk, skb);
  561. sk->sk_wmem_queued += skb->truesize;
  562. sk_mem_charge(sk, skb->truesize);
  563. if (tp->nonagle & TCP_NAGLE_PUSH)
  564. tp->nonagle &= ~TCP_NAGLE_PUSH;
  565. }
  566. static inline void tcp_mark_urg(struct tcp_sock *tp, int flags)
  567. {
  568. if (flags & MSG_OOB)
  569. tp->snd_up = tp->write_seq;
  570. }
  571. static inline void tcp_push(struct sock *sk, int flags, int mss_now,
  572. int nonagle)
  573. {
  574. if (tcp_send_head(sk)) {
  575. struct tcp_sock *tp = tcp_sk(sk);
  576. if (!(flags & MSG_MORE) || forced_push(tp))
  577. tcp_mark_push(tp, tcp_write_queue_tail(sk));
  578. tcp_mark_urg(tp, flags);
  579. __tcp_push_pending_frames(sk, mss_now,
  580. (flags & MSG_MORE) ? TCP_NAGLE_CORK : nonagle);
  581. }
  582. }
  583. static int tcp_splice_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
  584. unsigned int offset, size_t len)
  585. {
  586. struct tcp_splice_state *tss = rd_desc->arg.data;
  587. int ret;
  588. ret = skb_splice_bits(skb, offset, tss->pipe, min(rd_desc->count, len),
  589. tss->flags);
  590. if (ret > 0)
  591. rd_desc->count -= ret;
  592. return ret;
  593. }
  594. static int __tcp_splice_read(struct sock *sk, struct tcp_splice_state *tss)
  595. {
  596. /* Store TCP splice context information in read_descriptor_t. */
  597. read_descriptor_t rd_desc = {
  598. .arg.data = tss,
  599. .count = tss->len,
  600. };
  601. return tcp_read_sock(sk, &rd_desc, tcp_splice_data_recv);
  602. }
  603. /**
  604. * tcp_splice_read - splice data from TCP socket to a pipe
  605. * @sock: socket to splice from
  606. * @ppos: position (not valid)
  607. * @pipe: pipe to splice to
  608. * @len: number of bytes to splice
  609. * @flags: splice modifier flags
  610. *
  611. * Description:
  612. * Will read pages from given socket and fill them into a pipe.
  613. *
  614. **/
  615. ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos,
  616. struct pipe_inode_info *pipe, size_t len,
  617. unsigned int flags)
  618. {
  619. struct sock *sk = sock->sk;
  620. struct tcp_splice_state tss = {
  621. .pipe = pipe,
  622. .len = len,
  623. .flags = flags,
  624. };
  625. long timeo;
  626. ssize_t spliced;
  627. int ret;
  628. sock_rps_record_flow(sk);
  629. /*
  630. * We can't seek on a socket input
  631. */
  632. if (unlikely(*ppos))
  633. return -ESPIPE;
  634. ret = spliced = 0;
  635. lock_sock(sk);
  636. timeo = sock_rcvtimeo(sk, sock->file->f_flags & O_NONBLOCK);
  637. while (tss.len) {
  638. ret = __tcp_splice_read(sk, &tss);
  639. if (ret < 0)
  640. break;
  641. else if (!ret) {
  642. if (spliced)
  643. break;
  644. if (sock_flag(sk, SOCK_DONE))
  645. break;
  646. if (sk->sk_err) {
  647. ret = sock_error(sk);
  648. break;
  649. }
  650. if (sk->sk_shutdown & RCV_SHUTDOWN)
  651. break;
  652. if (sk->sk_state == TCP_CLOSE) {
  653. /*
  654. * This occurs when user tries to read
  655. * from never connected socket.
  656. */
  657. if (!sock_flag(sk, SOCK_DONE))
  658. ret = -ENOTCONN;
  659. break;
  660. }
  661. if (!timeo) {
  662. ret = -EAGAIN;
  663. break;
  664. }
  665. sk_wait_data(sk, &timeo);
  666. if (signal_pending(current)) {
  667. ret = sock_intr_errno(timeo);
  668. break;
  669. }
  670. continue;
  671. }
  672. tss.len -= ret;
  673. spliced += ret;
  674. if (!timeo)
  675. break;
  676. release_sock(sk);
  677. lock_sock(sk);
  678. if (sk->sk_err || sk->sk_state == TCP_CLOSE ||
  679. (sk->sk_shutdown & RCV_SHUTDOWN) ||
  680. signal_pending(current))
  681. break;
  682. }
  683. release_sock(sk);
  684. if (spliced)
  685. return spliced;
  686. return ret;
  687. }
  688. EXPORT_SYMBOL(tcp_splice_read);
  689. struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp)
  690. {
  691. struct sk_buff *skb;
  692. /* The TCP header must be at least 32-bit aligned. */
  693. size = ALIGN(size, 4);
  694. skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
  695. if (skb) {
  696. if (sk_wmem_schedule(sk, skb->truesize)) {
  697. skb_reserve(skb, sk->sk_prot->max_header);
  698. /*
  699. * Make sure that we have exactly size bytes
  700. * available to the caller, no more, no less.
  701. */
  702. skb->avail_size = size;
  703. return skb;
  704. }
  705. __kfree_skb(skb);
  706. } else {
  707. sk->sk_prot->enter_memory_pressure(sk);
  708. sk_stream_moderate_sndbuf(sk);
  709. }
  710. return NULL;
  711. }
  712. static unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now,
  713. int large_allowed)
  714. {
  715. struct tcp_sock *tp = tcp_sk(sk);
  716. u32 xmit_size_goal, old_size_goal;
  717. xmit_size_goal = mss_now;
  718. if (large_allowed && sk_can_gso(sk)) {
  719. xmit_size_goal = ((sk->sk_gso_max_size - 1) -
  720. inet_csk(sk)->icsk_af_ops->net_header_len -
  721. inet_csk(sk)->icsk_ext_hdr_len -
  722. tp->tcp_header_len);
  723. /* TSQ : try to have two TSO segments in flight */
  724. xmit_size_goal = min_t(u32, xmit_size_goal,
  725. sysctl_tcp_limit_output_bytes >> 1);
  726. xmit_size_goal = tcp_bound_to_half_wnd(tp, xmit_size_goal);
  727. /* We try hard to avoid divides here */
  728. old_size_goal = tp->xmit_size_goal_segs * mss_now;
  729. if (likely(old_size_goal <= xmit_size_goal &&
  730. old_size_goal + mss_now > xmit_size_goal)) {
  731. xmit_size_goal = old_size_goal;
  732. } else {
  733. tp->xmit_size_goal_segs =
  734. min_t(u16, xmit_size_goal / mss_now,
  735. sk->sk_gso_max_segs);
  736. xmit_size_goal = tp->xmit_size_goal_segs * mss_now;
  737. }
  738. }
  739. return max(xmit_size_goal, mss_now);
  740. }
  741. static int tcp_send_mss(struct sock *sk, int *size_goal, int flags)
  742. {
  743. int mss_now;
  744. mss_now = tcp_current_mss(sk);
  745. *size_goal = tcp_xmit_size_goal(sk, mss_now, !(flags & MSG_OOB));
  746. return mss_now;
  747. }
  748. static ssize_t do_tcp_sendpages(struct sock *sk, struct page **pages, int poffset,
  749. size_t psize, int flags)
  750. {
  751. struct tcp_sock *tp = tcp_sk(sk);
  752. int mss_now, size_goal;
  753. int err;
  754. ssize_t copied;
  755. long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
  756. /* Wait for a connection to finish. One exception is TCP Fast Open
  757. * (passive side) where data is allowed to be sent before a connection
  758. * is fully established.
  759. */
  760. if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
  761. !tcp_passive_fastopen(sk)) {
  762. if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
  763. goto out_err;
  764. }
  765. clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
  766. mss_now = tcp_send_mss(sk, &size_goal, flags);
  767. copied = 0;
  768. err = -EPIPE;
  769. if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
  770. goto out_err;
  771. while (psize > 0) {
  772. struct sk_buff *skb = tcp_write_queue_tail(sk);
  773. struct page *page = pages[poffset / PAGE_SIZE];
  774. int copy, i;
  775. int offset = poffset % PAGE_SIZE;
  776. int size = min_t(size_t, psize, PAGE_SIZE - offset);
  777. bool can_coalesce;
  778. if (!tcp_send_head(sk) || (copy = size_goal - skb->len) <= 0) {
  779. new_segment:
  780. if (!sk_stream_memory_free(sk))
  781. goto wait_for_sndbuf;
  782. skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation);
  783. if (!skb)
  784. goto wait_for_memory;
  785. skb_entail(sk, skb);
  786. copy = size_goal;
  787. }
  788. if (copy > size)
  789. copy = size;
  790. i = skb_shinfo(skb)->nr_frags;
  791. can_coalesce = skb_can_coalesce(skb, i, page, offset);
  792. if (!can_coalesce && i >= MAX_SKB_FRAGS) {
  793. tcp_mark_push(tp, skb);
  794. goto new_segment;
  795. }
  796. if (!sk_wmem_schedule(sk, copy))
  797. goto wait_for_memory;
  798. if (can_coalesce) {
  799. skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
  800. } else {
  801. get_page(page);
  802. skb_fill_page_desc(skb, i, page, offset, copy);
  803. }
  804. skb->len += copy;
  805. skb->data_len += copy;
  806. skb->truesize += copy;
  807. sk->sk_wmem_queued += copy;
  808. sk_mem_charge(sk, copy);
  809. skb->ip_summed = CHECKSUM_PARTIAL;
  810. tp->write_seq += copy;
  811. TCP_SKB_CB(skb)->end_seq += copy;
  812. skb_shinfo(skb)->gso_segs = 0;
  813. if (!copied)
  814. TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
  815. copied += copy;
  816. poffset += copy;
  817. if (!(psize -= copy))
  818. goto out;
  819. if (skb->len < size_goal || (flags & MSG_OOB))
  820. continue;
  821. if (forced_push(tp)) {
  822. tcp_mark_push(tp, skb);
  823. __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
  824. } else if (skb == tcp_send_head(sk))
  825. tcp_push_one(sk, mss_now);
  826. continue;
  827. wait_for_sndbuf:
  828. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  829. wait_for_memory:
  830. tcp_push(sk, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH);
  831. if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
  832. goto do_error;
  833. mss_now = tcp_send_mss(sk, &size_goal, flags);
  834. }
  835. out:
  836. if (copied && !(flags & MSG_SENDPAGE_NOTLAST))
  837. tcp_push(sk, flags, mss_now, tp->nonagle);
  838. return copied;
  839. do_error:
  840. if (copied)
  841. goto out;
  842. out_err:
  843. return sk_stream_error(sk, flags, err);
  844. }
  845. int tcp_sendpage(struct sock *sk, struct page *page, int offset,
  846. size_t size, int flags)
  847. {
  848. ssize_t res;
  849. if (!(sk->sk_route_caps & NETIF_F_SG) ||
  850. !(sk->sk_route_caps & NETIF_F_ALL_CSUM))
  851. return sock_no_sendpage(sk->sk_socket, page, offset, size,
  852. flags);
  853. lock_sock(sk);
  854. res = do_tcp_sendpages(sk, &page, offset, size, flags);
  855. release_sock(sk);
  856. return res;
  857. }
  858. EXPORT_SYMBOL(tcp_sendpage);
  859. static inline int select_size(const struct sock *sk, bool sg)
  860. {
  861. const struct tcp_sock *tp = tcp_sk(sk);
  862. int tmp = tp->mss_cache;
  863. if (sg) {
  864. if (sk_can_gso(sk)) {
  865. /* Small frames wont use a full page:
  866. * Payload will immediately follow tcp header.
  867. */
  868. tmp = SKB_WITH_OVERHEAD(2048 - MAX_TCP_HEADER);
  869. } else {
  870. int pgbreak = SKB_MAX_HEAD(MAX_TCP_HEADER);
  871. if (tmp >= pgbreak &&
  872. tmp <= pgbreak + (MAX_SKB_FRAGS - 1) * PAGE_SIZE)
  873. tmp = pgbreak;
  874. }
  875. }
  876. return tmp;
  877. }
  878. void tcp_free_fastopen_req(struct tcp_sock *tp)
  879. {
  880. if (tp->fastopen_req != NULL) {
  881. kfree(tp->fastopen_req);
  882. tp->fastopen_req = NULL;
  883. }
  884. }
  885. static int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg, int *size)
  886. {
  887. struct tcp_sock *tp = tcp_sk(sk);
  888. int err, flags;
  889. if (!(sysctl_tcp_fastopen & TFO_CLIENT_ENABLE))
  890. return -EOPNOTSUPP;
  891. if (tp->fastopen_req != NULL)
  892. return -EALREADY; /* Another Fast Open is in progress */
  893. tp->fastopen_req = kzalloc(sizeof(struct tcp_fastopen_request),
  894. sk->sk_allocation);
  895. if (unlikely(tp->fastopen_req == NULL))
  896. return -ENOBUFS;
  897. tp->fastopen_req->data = msg;
  898. flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0;
  899. err = __inet_stream_connect(sk->sk_socket, msg->msg_name,
  900. msg->msg_namelen, flags);
  901. *size = tp->fastopen_req->copied;
  902. tcp_free_fastopen_req(tp);
  903. return err;
  904. }
  905. int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
  906. size_t size)
  907. {
  908. struct iovec *iov;
  909. struct tcp_sock *tp = tcp_sk(sk);
  910. struct sk_buff *skb;
  911. int iovlen, flags, err, copied = 0;
  912. int mss_now = 0, size_goal, copied_syn = 0, offset = 0;
  913. bool sg;
  914. long timeo;
  915. lock_sock(sk);
  916. flags = msg->msg_flags;
  917. if (flags & MSG_FASTOPEN) {
  918. err = tcp_sendmsg_fastopen(sk, msg, &copied_syn);
  919. if (err == -EINPROGRESS && copied_syn > 0)
  920. goto out;
  921. else if (err)
  922. goto out_err;
  923. offset = copied_syn;
  924. }
  925. timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
  926. /* Wait for a connection to finish. One exception is TCP Fast Open
  927. * (passive side) where data is allowed to be sent before a connection
  928. * is fully established.
  929. */
  930. if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
  931. !tcp_passive_fastopen(sk)) {
  932. if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
  933. goto do_error;
  934. }
  935. if (unlikely(tp->repair)) {
  936. if (tp->repair_queue == TCP_RECV_QUEUE) {
  937. copied = tcp_send_rcvq(sk, msg, size);
  938. goto out;
  939. }
  940. err = -EINVAL;
  941. if (tp->repair_queue == TCP_NO_QUEUE)
  942. goto out_err;
  943. /* 'common' sending to sendq */
  944. }
  945. /* This should be in poll */
  946. clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
  947. mss_now = tcp_send_mss(sk, &size_goal, flags);
  948. /* Ok commence sending. */
  949. iovlen = msg->msg_iovlen;
  950. iov = msg->msg_iov;
  951. copied = 0;
  952. err = -EPIPE;
  953. if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
  954. goto out_err;
  955. sg = !!(sk->sk_route_caps & NETIF_F_SG);
  956. while (--iovlen >= 0) {
  957. size_t seglen = iov->iov_len;
  958. unsigned char __user *from = iov->iov_base;
  959. iov++;
  960. if (unlikely(offset > 0)) { /* Skip bytes copied in SYN */
  961. if (offset >= seglen) {
  962. offset -= seglen;
  963. continue;
  964. }
  965. seglen -= offset;
  966. from += offset;
  967. offset = 0;
  968. }
  969. while (seglen > 0) {
  970. int copy = 0;
  971. int max = size_goal;
  972. skb = tcp_write_queue_tail(sk);
  973. if (tcp_send_head(sk)) {
  974. if (skb->ip_summed == CHECKSUM_NONE)
  975. max = mss_now;
  976. copy = max - skb->len;
  977. }
  978. if (copy <= 0) {
  979. new_segment:
  980. /* Allocate new segment. If the interface is SG,
  981. * allocate skb fitting to single page.
  982. */
  983. if (!sk_stream_memory_free(sk))
  984. goto wait_for_sndbuf;
  985. skb = sk_stream_alloc_skb(sk,
  986. select_size(sk, sg),
  987. sk->sk_allocation);
  988. if (!skb)
  989. goto wait_for_memory;
  990. /*
  991. * Check whether we can use HW checksum.
  992. */
  993. if (sk->sk_route_caps & NETIF_F_ALL_CSUM)
  994. skb->ip_summed = CHECKSUM_PARTIAL;
  995. skb_entail(sk, skb);
  996. copy = size_goal;
  997. max = size_goal;
  998. }
  999. /* Try to append data to the end of skb. */
  1000. if (copy > seglen)
  1001. copy = seglen;
  1002. /* Where to copy to? */
  1003. if (skb_availroom(skb) > 0) {
  1004. /* We have some space in skb head. Superb! */
  1005. copy = min_t(int, copy, skb_availroom(skb));
  1006. err = skb_add_data_nocache(sk, skb, from, copy);
  1007. if (err)
  1008. goto do_fault;
  1009. } else {
  1010. bool merge = true;
  1011. int i = skb_shinfo(skb)->nr_frags;
  1012. struct page_frag *pfrag = sk_page_frag(sk);
  1013. if (!sk_page_frag_refill(sk, pfrag))
  1014. goto wait_for_memory;
  1015. if (!skb_can_coalesce(skb, i, pfrag->page,
  1016. pfrag->offset)) {
  1017. if (i == MAX_SKB_FRAGS || !sg) {
  1018. tcp_mark_push(tp, skb);
  1019. goto new_segment;
  1020. }
  1021. merge = false;
  1022. }
  1023. copy = min_t(int, copy, pfrag->size - pfrag->offset);
  1024. if (!sk_wmem_schedule(sk, copy))
  1025. goto wait_for_memory;
  1026. err = skb_copy_to_page_nocache(sk, from, skb,
  1027. pfrag->page,
  1028. pfrag->offset,
  1029. copy);
  1030. if (err)
  1031. goto do_error;
  1032. /* Update the skb. */
  1033. if (merge) {
  1034. skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
  1035. } else {
  1036. skb_fill_page_desc(skb, i, pfrag->page,
  1037. pfrag->offset, copy);
  1038. get_page(pfrag->page);
  1039. }
  1040. pfrag->offset += copy;
  1041. }
  1042. if (!copied)
  1043. TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
  1044. tp->write_seq += copy;
  1045. TCP_SKB_CB(skb)->end_seq += copy;
  1046. skb_shinfo(skb)->gso_segs = 0;
  1047. from += copy;
  1048. copied += copy;
  1049. if ((seglen -= copy) == 0 && iovlen == 0)
  1050. goto out;
  1051. if (skb->len < max || (flags & MSG_OOB) || unlikely(tp->repair))
  1052. continue;
  1053. if (forced_push(tp)) {
  1054. tcp_mark_push(tp, skb);
  1055. __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
  1056. } else if (skb == tcp_send_head(sk))
  1057. tcp_push_one(sk, mss_now);
  1058. continue;
  1059. wait_for_sndbuf:
  1060. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  1061. wait_for_memory:
  1062. if (copied)
  1063. tcp_push(sk, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH);
  1064. if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
  1065. goto do_error;
  1066. mss_now = tcp_send_mss(sk, &size_goal, flags);
  1067. }
  1068. }
  1069. out:
  1070. if (copied)
  1071. tcp_push(sk, flags, mss_now, tp->nonagle);
  1072. release_sock(sk);
  1073. return copied + copied_syn;
  1074. do_fault:
  1075. if (!skb->len) {
  1076. tcp_unlink_write_queue(skb, sk);
  1077. /* It is the one place in all of TCP, except connection
  1078. * reset, where we can be unlinking the send_head.
  1079. */
  1080. tcp_check_send_head(sk, skb);
  1081. sk_wmem_free_skb(sk, skb);
  1082. }
  1083. do_error:
  1084. if (copied + copied_syn)
  1085. goto out;
  1086. out_err:
  1087. err = sk_stream_error(sk, flags, err);
  1088. release_sock(sk);
  1089. return err;
  1090. }
  1091. EXPORT_SYMBOL(tcp_sendmsg);
  1092. /*
  1093. * Handle reading urgent data. BSD has very simple semantics for
  1094. * this, no blocking and very strange errors 8)
  1095. */
  1096. static int tcp_recv_urg(struct sock *sk, struct msghdr *msg, int len, int flags)
  1097. {
  1098. struct tcp_sock *tp = tcp_sk(sk);
  1099. /* No URG data to read. */
  1100. if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data ||
  1101. tp->urg_data == TCP_URG_READ)
  1102. return -EINVAL; /* Yes this is right ! */
  1103. if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE))
  1104. return -ENOTCONN;
  1105. if (tp->urg_data & TCP_URG_VALID) {
  1106. int err = 0;
  1107. char c = tp->urg_data;
  1108. if (!(flags & MSG_PEEK))
  1109. tp->urg_data = TCP_URG_READ;
  1110. /* Read urgent data. */
  1111. msg->msg_flags |= MSG_OOB;
  1112. if (len > 0) {
  1113. if (!(flags & MSG_TRUNC))
  1114. err = memcpy_toiovec(msg->msg_iov, &c, 1);
  1115. len = 1;
  1116. } else
  1117. msg->msg_flags |= MSG_TRUNC;
  1118. return err ? -EFAULT : len;
  1119. }
  1120. if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN))
  1121. return 0;
  1122. /* Fixed the recv(..., MSG_OOB) behaviour. BSD docs and
  1123. * the available implementations agree in this case:
  1124. * this call should never block, independent of the
  1125. * blocking state of the socket.
  1126. * Mike <pall@rz.uni-karlsruhe.de>
  1127. */
  1128. return -EAGAIN;
  1129. }
  1130. static int tcp_peek_sndq(struct sock *sk, struct msghdr *msg, int len)
  1131. {
  1132. struct sk_buff *skb;
  1133. int copied = 0, err = 0;
  1134. /* XXX -- need to support SO_PEEK_OFF */
  1135. skb_queue_walk(&sk->sk_write_queue, skb) {
  1136. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, skb->len);
  1137. if (err)
  1138. break;
  1139. copied += skb->len;
  1140. }
  1141. return err ?: copied;
  1142. }
  1143. /* Clean up the receive buffer for full frames taken by the user,
  1144. * then send an ACK if necessary. COPIED is the number of bytes
  1145. * tcp_recvmsg has given to the user so far, it speeds up the
  1146. * calculation of whether or not we must ACK for the sake of
  1147. * a window update.
  1148. */
  1149. void tcp_cleanup_rbuf(struct sock *sk, int copied)
  1150. {
  1151. struct tcp_sock *tp = tcp_sk(sk);
  1152. bool time_to_ack = false;
  1153. struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
  1154. WARN(skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq),
  1155. "cleanup rbuf bug: copied %X seq %X rcvnxt %X\n",
  1156. tp->copied_seq, TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt);
  1157. if (inet_csk_ack_scheduled(sk)) {
  1158. const struct inet_connection_sock *icsk = inet_csk(sk);
  1159. /* Delayed ACKs frequently hit locked sockets during bulk
  1160. * receive. */
  1161. if (icsk->icsk_ack.blocked ||
  1162. /* Once-per-two-segments ACK was not sent by tcp_input.c */
  1163. tp->rcv_nxt - tp->rcv_wup > icsk->icsk_ack.rcv_mss ||
  1164. /*
  1165. * If this read emptied read buffer, we send ACK, if
  1166. * connection is not bidirectional, user drained
  1167. * receive buffer and there was a small segment
  1168. * in queue.
  1169. */
  1170. (copied > 0 &&
  1171. ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED2) ||
  1172. ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED) &&
  1173. !icsk->icsk_ack.pingpong)) &&
  1174. !atomic_read(&sk->sk_rmem_alloc)))
  1175. time_to_ack = true;
  1176. }
  1177. /* We send an ACK if we can now advertise a non-zero window
  1178. * which has been raised "significantly".
  1179. *
  1180. * Even if window raised up to infinity, do not send window open ACK
  1181. * in states, where we will not receive more. It is useless.
  1182. */
  1183. if (copied > 0 && !time_to_ack && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
  1184. __u32 rcv_window_now = tcp_receive_window(tp);
  1185. /* Optimize, __tcp_select_window() is not cheap. */
  1186. if (2*rcv_window_now <= tp->window_clamp) {
  1187. __u32 new_window = __tcp_select_window(sk);
  1188. /* Send ACK now, if this read freed lots of space
  1189. * in our buffer. Certainly, new_window is new window.
  1190. * We can advertise it now, if it is not less than current one.
  1191. * "Lots" means "at least twice" here.
  1192. */
  1193. if (new_window && new_window >= 2 * rcv_window_now)
  1194. time_to_ack = true;
  1195. }
  1196. }
  1197. if (time_to_ack)
  1198. tcp_send_ack(sk);
  1199. }
  1200. static void tcp_prequeue_process(struct sock *sk)
  1201. {
  1202. struct sk_buff *skb;
  1203. struct tcp_sock *tp = tcp_sk(sk);
  1204. NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPPREQUEUED);
  1205. /* RX process wants to run with disabled BHs, though it is not
  1206. * necessary */
  1207. local_bh_disable();
  1208. while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
  1209. sk_backlog_rcv(sk, skb);
  1210. local_bh_enable();
  1211. /* Clear memory counter. */
  1212. tp->ucopy.memory = 0;
  1213. }
  1214. #ifdef CONFIG_NET_DMA
  1215. static void tcp_service_net_dma(struct sock *sk, bool wait)
  1216. {
  1217. dma_cookie_t done, used;
  1218. dma_cookie_t last_issued;
  1219. struct tcp_sock *tp = tcp_sk(sk);
  1220. if (!tp->ucopy.dma_chan)
  1221. return;
  1222. last_issued = tp->ucopy.dma_cookie;
  1223. dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
  1224. do {
  1225. if (dma_async_memcpy_complete(tp->ucopy.dma_chan,
  1226. last_issued, &done,
  1227. &used) == DMA_SUCCESS) {
  1228. /* Safe to free early-copied skbs now */
  1229. __skb_queue_purge(&sk->sk_async_wait_queue);
  1230. break;
  1231. } else {
  1232. struct sk_buff *skb;
  1233. while ((skb = skb_peek(&sk->sk_async_wait_queue)) &&
  1234. (dma_async_is_complete(skb->dma_cookie, done,
  1235. used) == DMA_SUCCESS)) {
  1236. __skb_dequeue(&sk->sk_async_wait_queue);
  1237. kfree_skb(skb);
  1238. }
  1239. }
  1240. } while (wait);
  1241. }
  1242. #endif
  1243. static inline struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off)
  1244. {
  1245. struct sk_buff *skb;
  1246. u32 offset;
  1247. skb_queue_walk(&sk->sk_receive_queue, skb) {
  1248. offset = seq - TCP_SKB_CB(skb)->seq;
  1249. if (tcp_hdr(skb)->syn)
  1250. offset--;
  1251. if (offset < skb->len || tcp_hdr(skb)->fin) {
  1252. *off = offset;
  1253. return skb;
  1254. }
  1255. }
  1256. return NULL;
  1257. }
  1258. /*
  1259. * This routine provides an alternative to tcp_recvmsg() for routines
  1260. * that would like to handle copying from skbuffs directly in 'sendfile'
  1261. * fashion.
  1262. * Note:
  1263. * - It is assumed that the socket was locked by the caller.
  1264. * - The routine does not block.
  1265. * - At present, there is no support for reading OOB data
  1266. * or for 'peeking' the socket using this routine
  1267. * (although both would be easy to implement).
  1268. */
  1269. int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
  1270. sk_read_actor_t recv_actor)
  1271. {
  1272. struct sk_buff *skb;
  1273. struct tcp_sock *tp = tcp_sk(sk);
  1274. u32 seq = tp->copied_seq;
  1275. u32 offset;
  1276. int copied = 0;
  1277. if (sk->sk_state == TCP_LISTEN)
  1278. return -ENOTCONN;
  1279. while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
  1280. if (offset < skb->len) {
  1281. int used;
  1282. size_t len;
  1283. len = skb->len - offset;
  1284. /* Stop reading if we hit a patch of urgent data */
  1285. if (tp->urg_data) {
  1286. u32 urg_offset = tp->urg_seq - seq;
  1287. if (urg_offset < len)
  1288. len = urg_offset;
  1289. if (!len)
  1290. break;
  1291. }
  1292. used = recv_actor(desc, skb, offset, len);
  1293. if (used < 0) {
  1294. if (!copied)
  1295. copied = used;
  1296. break;
  1297. } else if (used <= len) {
  1298. seq += used;
  1299. copied += used;
  1300. offset += used;
  1301. }
  1302. /* If recv_actor drops the lock (e.g. TCP splice
  1303. * receive) the skb pointer might be invalid when
  1304. * getting here: tcp_collapse might have deleted it
  1305. * while aggregating skbs from the socket queue.
  1306. */
  1307. skb = tcp_recv_skb(sk, seq - 1, &offset);
  1308. if (!skb)
  1309. break;
  1310. /* TCP coalescing might have appended data to the skb.
  1311. * Try to splice more frags
  1312. */
  1313. if (offset + 1 != skb->len)
  1314. continue;
  1315. }
  1316. if (tcp_hdr(skb)->fin) {
  1317. sk_eat_skb(sk, skb, false);
  1318. ++seq;
  1319. break;
  1320. }
  1321. sk_eat_skb(sk, skb, false);
  1322. if (!desc->count)
  1323. break;
  1324. tp->copied_seq = seq;
  1325. }
  1326. tp->copied_seq = seq;
  1327. tcp_rcv_space_adjust(sk);
  1328. /* Clean up data we have read: This will do ACK frames. */
  1329. if (copied > 0)
  1330. tcp_cleanup_rbuf(sk, copied);
  1331. return copied;
  1332. }
  1333. EXPORT_SYMBOL(tcp_read_sock);
  1334. /*
  1335. * This routine copies from a sock struct into the user buffer.
  1336. *
  1337. * Technical note: in 2.3 we work on _locked_ socket, so that
  1338. * tricks with *seq access order and skb->users are not required.
  1339. * Probably, code can be easily improved even more.
  1340. */
  1341. int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
  1342. size_t len, int nonblock, int flags, int *addr_len)
  1343. {
  1344. struct tcp_sock *tp = tcp_sk(sk);
  1345. int copied = 0;
  1346. u32 peek_seq;
  1347. u32 *seq;
  1348. unsigned long used;
  1349. int err;
  1350. int target; /* Read at least this many bytes */
  1351. long timeo;
  1352. struct task_struct *user_recv = NULL;
  1353. bool copied_early = false;
  1354. struct sk_buff *skb;
  1355. u32 urg_hole = 0;
  1356. lock_sock(sk);
  1357. err = -ENOTCONN;
  1358. if (sk->sk_state == TCP_LISTEN)
  1359. goto out;
  1360. timeo = sock_rcvtimeo(sk, nonblock);
  1361. /* Urgent data needs to be handled specially. */
  1362. if (flags & MSG_OOB)
  1363. goto recv_urg;
  1364. if (unlikely(tp->repair)) {
  1365. err = -EPERM;
  1366. if (!(flags & MSG_PEEK))
  1367. goto out;
  1368. if (tp->repair_queue == TCP_SEND_QUEUE)
  1369. goto recv_sndq;
  1370. err = -EINVAL;
  1371. if (tp->repair_queue == TCP_NO_QUEUE)
  1372. goto out;
  1373. /* 'common' recv queue MSG_PEEK-ing */
  1374. }
  1375. seq = &tp->copied_seq;
  1376. if (flags & MSG_PEEK) {
  1377. peek_seq = tp->copied_seq;
  1378. seq = &peek_seq;
  1379. }
  1380. target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
  1381. #ifdef CONFIG_NET_DMA
  1382. tp->ucopy.dma_chan = NULL;
  1383. preempt_disable();
  1384. skb = skb_peek_tail(&sk->sk_receive_queue);
  1385. {
  1386. int available = 0;
  1387. if (skb)
  1388. available = TCP_SKB_CB(skb)->seq + skb->len - (*seq);
  1389. if ((available < target) &&
  1390. (len > sysctl_tcp_dma_copybreak) && !(flags & MSG_PEEK) &&
  1391. !sysctl_tcp_low_latency &&
  1392. net_dma_find_channel()) {
  1393. preempt_enable_no_resched();
  1394. tp->ucopy.pinned_list =
  1395. dma_pin_iovec_pages(msg->msg_iov, len);
  1396. } else {
  1397. preempt_enable_no_resched();
  1398. }
  1399. }
  1400. #endif
  1401. do {
  1402. u32 offset;
  1403. /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */
  1404. if (tp->urg_data && tp->urg_seq == *seq) {
  1405. if (copied)
  1406. break;
  1407. if (signal_pending(current)) {
  1408. copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
  1409. break;
  1410. }
  1411. }
  1412. /* Next get a buffer. */
  1413. skb_queue_walk(&sk->sk_receive_queue, skb) {
  1414. /* Now that we have two receive queues this
  1415. * shouldn't happen.
  1416. */
  1417. if (WARN(before(*seq, TCP_SKB_CB(skb)->seq),
  1418. "recvmsg bug: copied %X seq %X rcvnxt %X fl %X\n",
  1419. *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt,
  1420. flags))
  1421. break;
  1422. offset = *seq - TCP_SKB_CB(skb)->seq;
  1423. if (tcp_hdr(skb)->syn)
  1424. offset--;
  1425. if (offset < skb->len)
  1426. goto found_ok_skb;
  1427. if (tcp_hdr(skb)->fin)
  1428. goto found_fin_ok;
  1429. WARN(!(flags & MSG_PEEK),
  1430. "recvmsg bug 2: copied %X seq %X rcvnxt %X fl %X\n",
  1431. *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, flags);
  1432. }
  1433. /* Well, if we have backlog, try to process it now yet. */
  1434. if (copied >= target && !sk->sk_backlog.tail)
  1435. break;
  1436. if (copied) {
  1437. if (sk->sk_err ||
  1438. sk->sk_state == TCP_CLOSE ||
  1439. (sk->sk_shutdown & RCV_SHUTDOWN) ||
  1440. !timeo ||
  1441. signal_pending(current))
  1442. break;
  1443. } else {
  1444. if (sock_flag(sk, SOCK_DONE))
  1445. break;
  1446. if (sk->sk_err) {
  1447. copied = sock_error(sk);
  1448. break;
  1449. }
  1450. if (sk->sk_shutdown & RCV_SHUTDOWN)
  1451. break;
  1452. if (sk->sk_state == TCP_CLOSE) {
  1453. if (!sock_flag(sk, SOCK_DONE)) {
  1454. /* This occurs when user tries to read
  1455. * from never connected socket.
  1456. */
  1457. copied = -ENOTCONN;
  1458. break;
  1459. }
  1460. break;
  1461. }
  1462. if (!timeo) {
  1463. copied = -EAGAIN;
  1464. break;
  1465. }
  1466. if (signal_pending(current)) {
  1467. copied = sock_intr_errno(timeo);
  1468. break;
  1469. }
  1470. }
  1471. tcp_cleanup_rbuf(sk, copied);
  1472. if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {
  1473. /* Install new reader */
  1474. if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
  1475. user_recv = current;
  1476. tp->ucopy.task = user_recv;
  1477. tp->ucopy.iov = msg->msg_iov;
  1478. }
  1479. tp->ucopy.len = len;
  1480. WARN_ON(tp->copied_seq != tp->rcv_nxt &&
  1481. !(flags & (MSG_PEEK | MSG_TRUNC)));
  1482. /* Ugly... If prequeue is not empty, we have to
  1483. * process it before releasing socket, otherwise
  1484. * order will be broken at second iteration.
  1485. * More elegant solution is required!!!
  1486. *
  1487. * Look: we have the following (pseudo)queues:
  1488. *
  1489. * 1. packets in flight
  1490. * 2. backlog
  1491. * 3. prequeue
  1492. * 4. receive_queue
  1493. *
  1494. * Each queue can be processed only if the next ones
  1495. * are empty. At this point we have empty receive_queue.
  1496. * But prequeue _can_ be not empty after 2nd iteration,
  1497. * when we jumped to start of loop because backlog
  1498. * processing added something to receive_queue.
  1499. * We cannot release_sock(), because backlog contains
  1500. * packets arrived _after_ prequeued ones.
  1501. *
  1502. * Shortly, algorithm is clear --- to process all
  1503. * the queues in order. We could make it more directly,
  1504. * requeueing packets from backlog to prequeue, if
  1505. * is not empty. It is more elegant, but eats cycles,
  1506. * unfortunately.
  1507. */
  1508. if (!skb_queue_empty(&tp->ucopy.prequeue))
  1509. goto do_prequeue;
  1510. /* __ Set realtime policy in scheduler __ */
  1511. }
  1512. #ifdef CONFIG_NET_DMA
  1513. if (tp->ucopy.dma_chan) {
  1514. if (tp->rcv_wnd == 0 &&
  1515. !skb_queue_empty(&sk->sk_async_wait_queue)) {
  1516. tcp_service_net_dma(sk, true);
  1517. tcp_cleanup_rbuf(sk, copied);
  1518. } else
  1519. dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
  1520. }
  1521. #endif
  1522. if (copied >= target) {
  1523. /* Do not sleep, just process backlog. */
  1524. release_sock(sk);
  1525. lock_sock(sk);
  1526. } else
  1527. sk_wait_data(sk, &timeo);
  1528. #ifdef CONFIG_NET_DMA
  1529. tcp_service_net_dma(sk, false); /* Don't block */
  1530. tp->ucopy.wakeup = 0;
  1531. #endif
  1532. if (user_recv) {
  1533. int chunk;
  1534. /* __ Restore normal policy in scheduler __ */
  1535. if ((chunk = len - tp->ucopy.len) != 0) {
  1536. NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk);
  1537. len -= chunk;
  1538. copied += chunk;
  1539. }
  1540. if (tp->rcv_nxt == tp->copied_seq &&
  1541. !skb_queue_empty(&tp->ucopy.prequeue)) {
  1542. do_prequeue:
  1543. tcp_prequeue_process(sk);
  1544. if ((chunk = len - tp->ucopy.len) != 0) {
  1545. NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
  1546. len -= chunk;
  1547. copied += chunk;
  1548. }
  1549. }
  1550. }
  1551. if ((flags & MSG_PEEK) &&
  1552. (peek_seq - copied - urg_hole != tp->copied_seq)) {
  1553. net_dbg_ratelimited("TCP(%s:%d): Application bug, race in MSG_PEEK\n",
  1554. current->comm,
  1555. task_pid_nr(current));
  1556. peek_seq = tp->copied_seq;
  1557. }
  1558. continue;
  1559. found_ok_skb:
  1560. /* Ok so how much can we use? */
  1561. used = skb->len - offset;
  1562. if (len < used)
  1563. used = len;
  1564. /* Do we have urgent data here? */
  1565. if (tp->urg_data) {
  1566. u32 urg_offset = tp->urg_seq - *seq;
  1567. if (urg_offset < used) {
  1568. if (!urg_offset) {
  1569. if (!sock_flag(sk, SOCK_URGINLINE)) {
  1570. ++*seq;
  1571. urg_hole++;
  1572. offset++;
  1573. used--;
  1574. if (!used)
  1575. goto skip_copy;
  1576. }
  1577. } else
  1578. used = urg_offset;
  1579. }
  1580. }
  1581. if (!(flags & MSG_TRUNC)) {
  1582. #ifdef CONFIG_NET_DMA
  1583. if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
  1584. tp->ucopy.dma_chan = net_dma_find_channel();
  1585. if (tp->ucopy.dma_chan) {
  1586. tp->ucopy.dma_cookie = dma_skb_copy_datagram_iovec(
  1587. tp->ucopy.dma_chan, skb, offset,
  1588. msg->msg_iov, used,
  1589. tp->ucopy.pinned_list);
  1590. if (tp->ucopy.dma_cookie < 0) {
  1591. pr_alert("%s: dma_cookie < 0\n",
  1592. __func__);
  1593. /* Exception. Bailout! */
  1594. if (!copied)
  1595. copied = -EFAULT;
  1596. break;
  1597. }
  1598. dma_async_memcpy_issue_pending(tp->ucopy.dma_chan);
  1599. if ((offset + used) == skb->len)
  1600. copied_early = true;
  1601. } else
  1602. #endif
  1603. {
  1604. err = skb_copy_datagram_iovec(skb, offset,
  1605. msg->msg_iov, used);
  1606. if (err) {
  1607. /* Exception. Bailout! */
  1608. if (!copied)
  1609. copied = -EFAULT;
  1610. break;
  1611. }
  1612. }
  1613. }
  1614. *seq += used;
  1615. copied += used;
  1616. len -= used;
  1617. tcp_rcv_space_adjust(sk);
  1618. skip_copy:
  1619. if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) {
  1620. tp->urg_data = 0;
  1621. tcp_fast_path_check(sk);
  1622. }
  1623. if (used + offset < skb->len)
  1624. continue;
  1625. if (tcp_hdr(skb)->fin)
  1626. goto found_fin_ok;
  1627. if (!(flags & MSG_PEEK)) {
  1628. sk_eat_skb(sk, skb, copied_early);
  1629. copied_early = false;
  1630. }
  1631. continue;
  1632. found_fin_ok:
  1633. /* Process the FIN. */
  1634. ++*seq;
  1635. if (!(flags & MSG_PEEK)) {
  1636. sk_eat_skb(sk, skb, copied_early);
  1637. copied_early = false;
  1638. }
  1639. break;
  1640. } while (len > 0);
  1641. if (user_recv) {
  1642. if (!skb_queue_empty(&tp->ucopy.prequeue)) {
  1643. int chunk;
  1644. tp->ucopy.len = copied > 0 ? len : 0;
  1645. tcp_prequeue_process(sk);
  1646. if (copied > 0 && (chunk = len - tp->ucopy.len) != 0) {
  1647. NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
  1648. len -= chunk;
  1649. copied += chunk;
  1650. }
  1651. }
  1652. tp->ucopy.task = NULL;
  1653. tp->ucopy.len = 0;
  1654. }
  1655. #ifdef CONFIG_NET_DMA
  1656. tcp_service_net_dma(sk, true); /* Wait for queue to drain */
  1657. tp->ucopy.dma_chan = NULL;
  1658. if (tp->ucopy.pinned_list) {
  1659. dma_unpin_iovec_pages(tp->ucopy.pinned_list);
  1660. tp->ucopy.pinned_list = NULL;
  1661. }
  1662. #endif
  1663. /* According to UNIX98, msg_name/msg_namelen are ignored
  1664. * on connected socket. I was just happy when found this 8) --ANK
  1665. */
  1666. /* Clean up data we have read: This will do ACK frames. */
  1667. tcp_cleanup_rbuf(sk, copied);
  1668. release_sock(sk);
  1669. return copied;
  1670. out:
  1671. release_sock(sk);
  1672. return err;
  1673. recv_urg:
  1674. err = tcp_recv_urg(sk, msg, len, flags);
  1675. goto out;
  1676. recv_sndq:
  1677. err = tcp_peek_sndq(sk, msg, len);
  1678. goto out;
  1679. }
  1680. EXPORT_SYMBOL(tcp_recvmsg);
  1681. void tcp_set_state(struct sock *sk, int state)
  1682. {
  1683. int oldstate = sk->sk_state;
  1684. switch (state) {
  1685. case TCP_ESTABLISHED:
  1686. if (oldstate != TCP_ESTABLISHED)
  1687. TCP_INC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
  1688. break;
  1689. case TCP_CLOSE:
  1690. if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
  1691. TCP_INC_STATS(sock_net(sk), TCP_MIB_ESTABRESETS);
  1692. sk->sk_prot->unhash(sk);
  1693. if (inet_csk(sk)->icsk_bind_hash &&
  1694. !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
  1695. inet_put_port(sk);
  1696. /* fall through */
  1697. default:
  1698. if (oldstate == TCP_ESTABLISHED)
  1699. TCP_DEC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
  1700. }
  1701. /* Change state AFTER socket is unhashed to avoid closed
  1702. * socket sitting in hash tables.
  1703. */
  1704. sk->sk_state = state;
  1705. #ifdef STATE_TRACE
  1706. SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n", sk, statename[oldstate], statename[state]);
  1707. #endif
  1708. }
  1709. EXPORT_SYMBOL_GPL(tcp_set_state);
  1710. /*
  1711. * State processing on a close. This implements the state shift for
  1712. * sending our FIN frame. Note that we only send a FIN for some
  1713. * states. A shutdown() may have already sent the FIN, or we may be
  1714. * closed.
  1715. */
  1716. static const unsigned char new_state[16] = {
  1717. /* current state: new state: action: */
  1718. /* (Invalid) */ TCP_CLOSE,
  1719. /* TCP_ESTABLISHED */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
  1720. /* TCP_SYN_SENT */ TCP_CLOSE,
  1721. /* TCP_SYN_RECV */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
  1722. /* TCP_FIN_WAIT1 */ TCP_FIN_WAIT1,
  1723. /* TCP_FIN_WAIT2 */ TCP_FIN_WAIT2,
  1724. /* TCP_TIME_WAIT */ TCP_CLOSE,
  1725. /* TCP_CLOSE */ TCP_CLOSE,
  1726. /* TCP_CLOSE_WAIT */ TCP_LAST_ACK | TCP_ACTION_FIN,
  1727. /* TCP_LAST_ACK */ TCP_LAST_ACK,
  1728. /* TCP_LISTEN */ TCP_CLOSE,
  1729. /* TCP_CLOSING */ TCP_CLOSING,
  1730. };
  1731. static int tcp_close_state(struct sock *sk)
  1732. {
  1733. int next = (int)new_state[sk->sk_state];
  1734. int ns = next & TCP_STATE_MASK;
  1735. tcp_set_state(sk, ns);
  1736. return next & TCP_ACTION_FIN;
  1737. }
  1738. /*
  1739. * Shutdown the sending side of a connection. Much like close except
  1740. * that we don't receive shut down or sock_set_flag(sk, SOCK_DEAD).
  1741. */
  1742. void tcp_shutdown(struct sock *sk, int how)
  1743. {
  1744. /* We need to grab some memory, and put together a FIN,
  1745. * and then put it into the queue to be sent.
  1746. * Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.
  1747. */
  1748. if (!(how & SEND_SHUTDOWN))
  1749. return;
  1750. /* If we've already sent a FIN, or it's a closed state, skip this. */
  1751. if ((1 << sk->sk_state) &
  1752. (TCPF_ESTABLISHED | TCPF_SYN_SENT |
  1753. TCPF_SYN_RECV | TCPF_CLOSE_WAIT)) {
  1754. /* Clear out any half completed packets. FIN if needed. */
  1755. if (tcp_close_state(sk))
  1756. tcp_send_fin(sk);
  1757. }
  1758. }
  1759. EXPORT_SYMBOL(tcp_shutdown);
  1760. bool tcp_check_oom(struct sock *sk, int shift)
  1761. {
  1762. bool too_many_orphans, out_of_socket_memory;
  1763. too_many_orphans = tcp_too_many_orphans(sk, shift);
  1764. out_of_socket_memory = tcp_out_of_memory(sk);
  1765. if (too_many_orphans)
  1766. net_info_ratelimited("too many orphaned sockets\n");
  1767. if (out_of_socket_memory)
  1768. net_info_ratelimited("out of memory -- consider tuning tcp_mem\n");
  1769. return too_many_orphans || out_of_socket_memory;
  1770. }
  1771. void tcp_close(struct sock *sk, long timeout)
  1772. {
  1773. struct sk_buff *skb;
  1774. int data_was_unread = 0;
  1775. int state;
  1776. lock_sock(sk);
  1777. sk->sk_shutdown = SHUTDOWN_MASK;
  1778. if (sk->sk_state == TCP_LISTEN) {
  1779. tcp_set_state(sk, TCP_CLOSE);
  1780. /* Special case. */
  1781. inet_csk_listen_stop(sk);
  1782. goto adjudge_to_death;
  1783. }
  1784. /* We need to flush the recv. buffs. We do this only on the
  1785. * descriptor close, not protocol-sourced closes, because the
  1786. * reader process may not have drained the data yet!
  1787. */
  1788. while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
  1789. u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq -
  1790. tcp_hdr(skb)->fin;
  1791. data_was_unread += len;
  1792. __kfree_skb(skb);
  1793. }
  1794. sk_mem_reclaim(sk);
  1795. /* If socket has been already reset (e.g. in tcp_reset()) - kill it. */
  1796. if (sk->sk_state == TCP_CLOSE)
  1797. goto adjudge_to_death;
  1798. /* As outlined in RFC 2525, section 2.17, we send a RST here because
  1799. * data was lost. To witness the awful effects of the old behavior of
  1800. * always doing a FIN, run an older 2.1.x kernel or 2.0.x, start a bulk
  1801. * GET in an FTP client, suspend the process, wait for the client to
  1802. * advertise a zero window, then kill -9 the FTP client, wheee...
  1803. * Note: timeout is always zero in such a case.
  1804. */
  1805. if (unlikely(tcp_sk(sk)->repair)) {
  1806. sk->sk_prot->disconnect(sk, 0);
  1807. } else if (data_was_unread) {
  1808. /* Unread data was tossed, zap the connection. */
  1809. NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPABORTONCLOSE);
  1810. tcp_set_state(sk, TCP_CLOSE);
  1811. tcp_send_active_reset(sk, sk->sk_allocation);
  1812. } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
  1813. /* Check zero linger _after_ checking for unread data. */
  1814. sk->sk_prot->disconnect(sk, 0);
  1815. NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
  1816. } else if (tcp_close_state(sk)) {
  1817. /* We FIN if the application ate all the data before
  1818. * zapping the connection.
  1819. */
  1820. /* RED-PEN. Formally speaking, we have broken TCP state
  1821. * machine. State transitions:
  1822. *
  1823. * TCP_ESTABLISHED -> TCP_FIN_WAIT1
  1824. * TCP_SYN_RECV -> TCP_FIN_WAIT1 (forget it, it's impossible)
  1825. * TCP_CLOSE_WAIT -> TCP_LAST_ACK
  1826. *
  1827. * are legal only when FIN has been sent (i.e. in window),
  1828. * rather than queued out of window. Purists blame.
  1829. *
  1830. * F.e. "RFC state" is ESTABLISHED,
  1831. * if Linux state is FIN-WAIT-1, but FIN is still not sent.
  1832. *
  1833. * The visible declinations are that sometimes
  1834. * we enter time-wait state, when it is not required really
  1835. * (harmless), do not send active resets, when they are
  1836. * required by specs (TCP_ESTABLISHED, TCP_CLOSE_WAIT, when
  1837. * they look as CLOSING or LAST_ACK for Linux)
  1838. * Probably, I missed some more holelets.
  1839. * --ANK
  1840. * XXX (TFO) - To start off we don't support SYN+ACK+FIN
  1841. * in a single packet! (May consider it later but will
  1842. * probably need API support or TCP_CORK SYN-ACK until
  1843. * data is written and socket is closed.)
  1844. */
  1845. tcp_send_fin(sk);
  1846. }
  1847. sk_stream_wait_close(sk, timeout);
  1848. adjudge_to_death:
  1849. state = sk->sk_state;
  1850. sock_hold(sk);
  1851. sock_orphan(sk);
  1852. /* It is the last release_sock in its life. It will remove backlog. */
  1853. release_sock(sk);
  1854. /* Now socket is owned by kernel and we acquire BH lock
  1855. to finish close. No need to check for user refs.
  1856. */
  1857. local_bh_disable();
  1858. bh_lock_sock(sk);
  1859. WARN_ON(sock_owned_by_user(sk));
  1860. percpu_counter_inc(sk->sk_prot->orphan_count);
  1861. /* Have we already been destroyed by a softirq or backlog? */
  1862. if (state != TCP_CLOSE && sk->sk_state == TCP_CLOSE)
  1863. goto out;
  1864. /* This is a (useful) BSD violating of the RFC. There is a
  1865. * problem with TCP as specified in that the other end could
  1866. * keep a socket open forever with no application left this end.
  1867. * We use a 3 minute timeout (about the same as BSD) then kill
  1868. * our end. If they send after that then tough - BUT: long enough
  1869. * that we won't make the old 4*rto = almost no time - whoops
  1870. * reset mistake.
  1871. *
  1872. * Nope, it was not mistake. It is really desired behaviour
  1873. * f.e. on http servers, when such sockets are useless, but
  1874. * consume significant resources. Let's do it with special
  1875. * linger2 option. --ANK
  1876. */
  1877. if (sk->sk_state == TCP_FIN_WAIT2) {
  1878. struct tcp_sock *tp = tcp_sk(sk);
  1879. if (tp->linger2 < 0) {
  1880. tcp_set_state(sk, TCP_CLOSE);
  1881. tcp_send_active_reset(sk, GFP_ATOMIC);
  1882. NET_INC_STATS_BH(sock_net(sk),
  1883. LINUX_MIB_TCPABORTONLINGER);
  1884. } else {
  1885. const int tmo = tcp_fin_time(sk);
  1886. if (tmo > TCP_TIMEWAIT_LEN) {
  1887. inet_csk_reset_keepalive_timer(sk,
  1888. tmo - TCP_TIMEWAIT_LEN);
  1889. } else {
  1890. tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
  1891. goto out;
  1892. }
  1893. }
  1894. }
  1895. if (sk->sk_state != TCP_CLOSE) {
  1896. sk_mem_reclaim(sk);
  1897. if (tcp_check_oom(sk, 0)) {
  1898. tcp_set_state(sk, TCP_CLOSE);
  1899. tcp_send_active_reset(sk, GFP_ATOMIC);
  1900. NET_INC_STATS_BH(sock_net(sk),
  1901. LINUX_MIB_TCPABORTONMEMORY);
  1902. }
  1903. }
  1904. if (sk->sk_state == TCP_CLOSE) {
  1905. struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
  1906. /* We could get here with a non-NULL req if the socket is
  1907. * aborted (e.g., closed with unread data) before 3WHS
  1908. * finishes.
  1909. */
  1910. if (req != NULL)
  1911. reqsk_fastopen_remove(sk, req, false);
  1912. inet_csk_destroy_sock(sk);
  1913. }
  1914. /* Otherwise, socket is reprieved until protocol close. */
  1915. out:
  1916. bh_unlock_sock(sk);
  1917. local_bh_enable();
  1918. sock_put(sk);
  1919. }
  1920. EXPORT_SYMBOL(tcp_close);
  1921. /* These states need RST on ABORT according to RFC793 */
  1922. static inline bool tcp_need_reset(int state)
  1923. {
  1924. return (1 << state) &
  1925. (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 |
  1926. TCPF_FIN_WAIT2 | TCPF_SYN_RECV);
  1927. }
  1928. int tcp_disconnect(struct sock *sk, int flags)
  1929. {
  1930. struct inet_sock *inet = inet_sk(sk);
  1931. struct inet_connection_sock *icsk = inet_csk(sk);
  1932. struct tcp_sock *tp = tcp_sk(sk);
  1933. int err = 0;
  1934. int old_state = sk->sk_state;
  1935. if (old_state != TCP_CLOSE)
  1936. tcp_set_state(sk, TCP_CLOSE);
  1937. /* ABORT function of RFC793 */
  1938. if (old_state == TCP_LISTEN) {
  1939. inet_csk_listen_stop(sk);
  1940. } else if (unlikely(tp->repair)) {
  1941. sk->sk_err = ECONNABORTED;
  1942. } else if (tcp_need_reset(old_state) ||
  1943. (tp->snd_nxt != tp->write_seq &&
  1944. (1 << old_state) & (TCPF_CLOSING | TCPF_LAST_ACK))) {
  1945. /* The last check adjusts for discrepancy of Linux wrt. RFC
  1946. * states
  1947. */
  1948. tcp_send_active_reset(sk, gfp_any());
  1949. sk->sk_err = ECONNRESET;
  1950. } else if (old_state == TCP_SYN_SENT)
  1951. sk->sk_err = ECONNRESET;
  1952. tcp_clear_xmit_timers(sk);
  1953. __skb_queue_purge(&sk->sk_receive_queue);
  1954. tcp_write_queue_purge(sk);
  1955. __skb_queue_purge(&tp->out_of_order_queue);
  1956. #ifdef CONFIG_NET_DMA
  1957. __skb_queue_purge(&sk->sk_async_wait_queue);
  1958. #endif
  1959. inet->inet_dport = 0;
  1960. if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
  1961. inet_reset_saddr(sk);
  1962. sk->sk_shutdown = 0;
  1963. sock_reset_flag(sk, SOCK_DONE);
  1964. tp->srtt = 0;
  1965. if ((tp->write_seq += tp->max_window + 2) == 0)
  1966. tp->write_seq = 1;
  1967. icsk->icsk_backoff = 0;
  1968. tp->snd_cwnd = 2;
  1969. icsk->icsk_probes_out = 0;
  1970. tp->packets_out = 0;
  1971. tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
  1972. tp->snd_cwnd_cnt = 0;
  1973. tp->bytes_acked = 0;
  1974. tp->window_clamp = 0;
  1975. tcp_set_ca_state(sk, TCP_CA_Open);
  1976. tcp_clear_retrans(tp);
  1977. inet_csk_delack_init(sk);
  1978. tcp_init_send_head(sk);
  1979. memset(&tp->rx_opt, 0, sizeof(tp->rx_opt));
  1980. __sk_dst_reset(sk);
  1981. WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
  1982. sk->sk_error_report(sk);
  1983. return err;
  1984. }
  1985. EXPORT_SYMBOL(tcp_disconnect);
  1986. void tcp_sock_destruct(struct sock *sk)
  1987. {
  1988. inet_sock_destruct(sk);
  1989. kfree(inet_csk(sk)->icsk_accept_queue.fastopenq);
  1990. }
  1991. static inline bool tcp_can_repair_sock(const struct sock *sk)
  1992. {
  1993. return ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN) &&
  1994. ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_ESTABLISHED));
  1995. }
  1996. static int tcp_repair_options_est(struct tcp_sock *tp,
  1997. struct tcp_repair_opt __user *optbuf, unsigned int len)
  1998. {
  1999. struct tcp_repair_opt opt;
  2000. while (len >= sizeof(opt)) {
  2001. if (copy_from_user(&opt, optbuf, sizeof(opt)))
  2002. return -EFAULT;
  2003. optbuf++;
  2004. len -= sizeof(opt);
  2005. switch (opt.opt_code) {
  2006. case TCPOPT_MSS:
  2007. tp->rx_opt.mss_clamp = opt.opt_val;
  2008. break;
  2009. case TCPOPT_WINDOW:
  2010. {
  2011. u16 snd_wscale = opt.opt_val & 0xFFFF;
  2012. u16 rcv_wscale = opt.opt_val >> 16;
  2013. if (snd_wscale > 14 || rcv_wscale > 14)
  2014. return -EFBIG;
  2015. tp->rx_opt.snd_wscale = snd_wscale;
  2016. tp->rx_opt.rcv_wscale = rcv_wscale;
  2017. tp->rx_opt.wscale_ok = 1;
  2018. }
  2019. break;
  2020. case TCPOPT_SACK_PERM:
  2021. if (opt.opt_val != 0)
  2022. return -EINVAL;
  2023. tp->rx_opt.sack_ok |= TCP_SACK_SEEN;
  2024. if (sysctl_tcp_fack)
  2025. tcp_enable_fack(tp);
  2026. break;
  2027. case TCPOPT_TIMESTAMP:
  2028. if (opt.opt_val != 0)
  2029. return -EINVAL;
  2030. tp->rx_opt.tstamp_ok = 1;
  2031. break;
  2032. }
  2033. }
  2034. return 0;
  2035. }
  2036. /*
  2037. * Socket option code for TCP.
  2038. */
  2039. static int do_tcp_setsockopt(struct sock *sk, int level,
  2040. int optname, char __user *optval, unsigned int optlen)
  2041. {
  2042. struct tcp_sock *tp = tcp_sk(sk);
  2043. struct inet_connection_sock *icsk = inet_csk(sk);
  2044. int val;
  2045. int err = 0;
  2046. /* These are data/string values, all the others are ints */
  2047. switch (optname) {
  2048. case TCP_CONGESTION: {
  2049. char name[TCP_CA_NAME_MAX];
  2050. if (optlen < 1)
  2051. return -EINVAL;
  2052. val = strncpy_from_user(name, optval,
  2053. min_t(long, TCP_CA_NAME_MAX-1, optlen));
  2054. if (val < 0)
  2055. return -EFAULT;
  2056. name[val] = 0;
  2057. lock_sock(sk);
  2058. err = tcp_set_congestion_control(sk, name);
  2059. release_sock(sk);
  2060. return err;
  2061. }
  2062. case TCP_COOKIE_TRANSACTIONS: {
  2063. struct tcp_cookie_transactions ctd;
  2064. struct tcp_cookie_values *cvp = NULL;
  2065. if (sizeof(ctd) > optlen)
  2066. return -EINVAL;
  2067. if (copy_from_user(&ctd, optval, sizeof(ctd)))
  2068. return -EFAULT;
  2069. if (ctd.tcpct_used > sizeof(ctd.tcpct_value) ||
  2070. ctd.tcpct_s_data_desired > TCP_MSS_DESIRED)
  2071. return -EINVAL;
  2072. if (ctd.tcpct_cookie_desired == 0) {
  2073. /* default to global value */
  2074. } else if ((0x1 & ctd.tcpct_cookie_desired) ||
  2075. ctd.tcpct_cookie_desired > TCP_COOKIE_MAX ||
  2076. ctd.tcpct_cookie_desired < TCP_COOKIE_MIN) {
  2077. return -EINVAL;
  2078. }
  2079. if (TCP_COOKIE_OUT_NEVER & ctd.tcpct_flags) {
  2080. /* Supercedes all other values */
  2081. lock_sock(sk);
  2082. if (tp->cookie_values != NULL) {
  2083. kref_put(&tp->cookie_values->kref,
  2084. tcp_cookie_values_release);
  2085. tp->cookie_values = NULL;
  2086. }
  2087. tp->rx_opt.cookie_in_always = 0; /* false */
  2088. tp->rx_opt.cookie_out_never = 1; /* true */
  2089. release_sock(sk);
  2090. return err;
  2091. }
  2092. /* Allocate ancillary memory before locking.
  2093. */
  2094. if (ctd.tcpct_used > 0 ||
  2095. (tp->cookie_values == NULL &&
  2096. (sysctl_tcp_cookie_size > 0 ||
  2097. ctd.tcpct_cookie_desired > 0 ||
  2098. ctd.tcpct_s_data_desired > 0))) {
  2099. cvp = kzalloc(sizeof(*cvp) + ctd.tcpct_used,
  2100. GFP_KERNEL);
  2101. if (cvp == NULL)
  2102. return -ENOMEM;
  2103. kref_init(&cvp->kref);
  2104. }
  2105. lock_sock(sk);
  2106. tp->rx_opt.cookie_in_always =
  2107. (TCP_COOKIE_IN_ALWAYS & ctd.tcpct_flags);
  2108. tp->rx_opt.cookie_out_never = 0; /* false */
  2109. if (tp->cookie_values != NULL) {
  2110. if (cvp != NULL) {
  2111. /* Changed values are recorded by a changed
  2112. * pointer, ensuring the cookie will differ,
  2113. * without separately hashing each value later.
  2114. */
  2115. kref_put(&tp->cookie_values->kref,
  2116. tcp_cookie_values_release);
  2117. } else {
  2118. cvp = tp->cookie_values;
  2119. }
  2120. }
  2121. if (cvp != NULL) {
  2122. cvp->cookie_desired = ctd.tcpct_cookie_desired;
  2123. if (ctd.tcpct_used > 0) {
  2124. memcpy(cvp->s_data_payload, ctd.tcpct_value,
  2125. ctd.tcpct_used);
  2126. cvp->s_data_desired = ctd.tcpct_used;
  2127. cvp->s_data_constant = 1; /* true */
  2128. } else {
  2129. /* No constant payload data. */
  2130. cvp->s_data_desired = ctd.tcpct_s_data_desired;
  2131. cvp->s_data_constant = 0; /* false */
  2132. }
  2133. tp->cookie_values = cvp;
  2134. }
  2135. release_sock(sk);
  2136. return err;
  2137. }
  2138. default:
  2139. /* fallthru */
  2140. break;
  2141. }
  2142. if (optlen < sizeof(int))
  2143. return -EINVAL;
  2144. if (get_user(val, (int __user *)optval))
  2145. return -EFAULT;
  2146. lock_sock(sk);
  2147. switch (optname) {
  2148. case TCP_MAXSEG:
  2149. /* Values greater than interface MTU won't take effect. However
  2150. * at the point when this call is done we typically don't yet
  2151. * know which interface is going to be used */
  2152. if (val < TCP_MIN_MSS || val > MAX_TCP_WINDOW) {
  2153. err = -EINVAL;
  2154. break;
  2155. }
  2156. tp->rx_opt.user_mss = val;
  2157. break;
  2158. case TCP_NODELAY:
  2159. if (val) {
  2160. /* TCP_NODELAY is weaker than TCP_CORK, so that
  2161. * this option on corked socket is remembered, but
  2162. * it is not activated until cork is cleared.
  2163. *
  2164. * However, when TCP_NODELAY is set we make
  2165. * an explicit push, which overrides even TCP_CORK
  2166. * for currently queued segments.
  2167. */
  2168. tp->nonagle |= TCP_NAGLE_OFF|TCP_NAGLE_PUSH;
  2169. tcp_push_pending_frames(sk);
  2170. } else {
  2171. tp->nonagle &= ~TCP_NAGLE_OFF;
  2172. }
  2173. break;
  2174. case TCP_THIN_LINEAR_TIMEOUTS:
  2175. if (val < 0 || val > 1)
  2176. err = -EINVAL;
  2177. else
  2178. tp->thin_lto = val;
  2179. break;
  2180. case TCP_THIN_DUPACK:
  2181. if (val < 0 || val > 1)
  2182. err = -EINVAL;
  2183. else
  2184. tp->thin_dupack = val;
  2185. if (tp->thin_dupack)
  2186. tcp_disable_early_retrans(tp);
  2187. break;
  2188. case TCP_REPAIR:
  2189. if (!tcp_can_repair_sock(sk))
  2190. err = -EPERM;
  2191. else if (val == 1) {
  2192. tp->repair = 1;
  2193. sk->sk_reuse = SK_FORCE_REUSE;
  2194. tp->repair_queue = TCP_NO_QUEUE;
  2195. } else if (val == 0) {
  2196. tp->repair = 0;
  2197. sk->sk_reuse = SK_NO_REUSE;
  2198. tcp_send_window_probe(sk);
  2199. } else
  2200. err = -EINVAL;
  2201. break;
  2202. case TCP_REPAIR_QUEUE:
  2203. if (!tp->repair)
  2204. err = -EPERM;
  2205. else if (val < TCP_QUEUES_NR)
  2206. tp->repair_queue = val;
  2207. else
  2208. err = -EINVAL;
  2209. break;
  2210. case TCP_QUEUE_SEQ:
  2211. if (sk->sk_state != TCP_CLOSE)
  2212. err = -EPERM;
  2213. else if (tp->repair_queue == TCP_SEND_QUEUE)
  2214. tp->write_seq = val;
  2215. else if (tp->repair_queue == TCP_RECV_QUEUE)
  2216. tp->rcv_nxt = val;
  2217. else
  2218. err = -EINVAL;
  2219. break;
  2220. case TCP_REPAIR_OPTIONS:
  2221. if (!tp->repair)
  2222. err = -EINVAL;
  2223. else if (sk->sk_state == TCP_ESTABLISHED)
  2224. err = tcp_repair_options_est(tp,
  2225. (struct tcp_repair_opt __user *)optval,
  2226. optlen);
  2227. else
  2228. err = -EPERM;
  2229. break;
  2230. case TCP_CORK:
  2231. /* When set indicates to always queue non-full frames.
  2232. * Later the user clears this option and we transmit
  2233. * any pending partial frames in the queue. This is
  2234. * meant to be used alongside sendfile() to get properly
  2235. * filled frames when the user (for example) must write
  2236. * out headers with a write() call first and then use
  2237. * sendfile to send out the data parts.
  2238. *
  2239. * TCP_CORK can be set together with TCP_NODELAY and it is
  2240. * stronger than TCP_NODELAY.
  2241. */
  2242. if (val) {
  2243. tp->nonagle |= TCP_NAGLE_CORK;
  2244. } else {
  2245. tp->nonagle &= ~TCP_NAGLE_CORK;
  2246. if (tp->nonagle&TCP_NAGLE_OFF)
  2247. tp->nonagle |= TCP_NAGLE_PUSH;
  2248. tcp_push_pending_frames(sk);
  2249. }
  2250. break;
  2251. case TCP_KEEPIDLE:
  2252. if (val < 1 || val > MAX_TCP_KEEPIDLE)
  2253. err = -EINVAL;
  2254. else {
  2255. tp->keepalive_time = val * HZ;
  2256. if (sock_flag(sk, SOCK_KEEPOPEN) &&
  2257. !((1 << sk->sk_state) &
  2258. (TCPF_CLOSE | TCPF_LISTEN))) {
  2259. u32 elapsed = keepalive_time_elapsed(tp);
  2260. if (tp->keepalive_time > elapsed)
  2261. elapsed = tp->keepalive_time - elapsed;
  2262. else
  2263. elapsed = 0;
  2264. inet_csk_reset_keepalive_timer(sk, elapsed);
  2265. }
  2266. }
  2267. break;
  2268. case TCP_KEEPINTVL:
  2269. if (val < 1 || val > MAX_TCP_KEEPINTVL)
  2270. err = -EINVAL;
  2271. else
  2272. tp->keepalive_intvl = val * HZ;
  2273. break;
  2274. case TCP_KEEPCNT:
  2275. if (val < 1 || val > MAX_TCP_KEEPCNT)
  2276. err = -EINVAL;
  2277. else
  2278. tp->keepalive_probes = val;
  2279. break;
  2280. case TCP_SYNCNT:
  2281. if (val < 1 || val > MAX_TCP_SYNCNT)
  2282. err = -EINVAL;
  2283. else
  2284. icsk->icsk_syn_retries = val;
  2285. break;
  2286. case TCP_LINGER2:
  2287. if (val < 0)
  2288. tp->linger2 = -1;
  2289. else if (val > sysctl_tcp_fin_timeout / HZ)
  2290. tp->linger2 = 0;
  2291. else
  2292. tp->linger2 = val * HZ;
  2293. break;
  2294. case TCP_DEFER_ACCEPT:
  2295. /* Translate value in seconds to number of retransmits */
  2296. icsk->icsk_accept_queue.rskq_defer_accept =
  2297. secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ,
  2298. TCP_RTO_MAX / HZ);
  2299. break;
  2300. case TCP_WINDOW_CLAMP:
  2301. if (!val) {
  2302. if (sk->sk_state != TCP_CLOSE) {
  2303. err = -EINVAL;
  2304. break;
  2305. }
  2306. tp->window_clamp = 0;
  2307. } else
  2308. tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
  2309. SOCK_MIN_RCVBUF / 2 : val;
  2310. break;
  2311. case TCP_QUICKACK:
  2312. if (!val) {
  2313. icsk->icsk_ack.pingpong = 1;
  2314. } else {
  2315. icsk->icsk_ack.pingpong = 0;
  2316. if ((1 << sk->sk_state) &
  2317. (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) &&
  2318. inet_csk_ack_scheduled(sk)) {
  2319. icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
  2320. tcp_cleanup_rbuf(sk, 1);
  2321. if (!(val & 1))
  2322. icsk->icsk_ack.pingpong = 1;
  2323. }
  2324. }
  2325. break;
  2326. #ifdef CONFIG_TCP_MD5SIG
  2327. case TCP_MD5SIG:
  2328. /* Read the IP->Key mappings from userspace */
  2329. err = tp->af_specific->md5_parse(sk, optval, optlen);
  2330. break;
  2331. #endif
  2332. case TCP_USER_TIMEOUT:
  2333. /* Cap the max timeout in ms TCP will retry/retrans
  2334. * before giving up and aborting (ETIMEDOUT) a connection.
  2335. */
  2336. if (val < 0)
  2337. err = -EINVAL;
  2338. else
  2339. icsk->icsk_user_timeout = msecs_to_jiffies(val);
  2340. break;
  2341. case TCP_FASTOPEN:
  2342. if (val >= 0 && ((1 << sk->sk_state) & (TCPF_CLOSE |
  2343. TCPF_LISTEN)))
  2344. err = fastopen_init_queue(sk, val);
  2345. else
  2346. err = -EINVAL;
  2347. break;
  2348. default:
  2349. err = -ENOPROTOOPT;
  2350. break;
  2351. }
  2352. release_sock(sk);
  2353. return err;
  2354. }
  2355. int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
  2356. unsigned int optlen)
  2357. {
  2358. const struct inet_connection_sock *icsk = inet_csk(sk);
  2359. if (level != SOL_TCP)
  2360. return icsk->icsk_af_ops->setsockopt(sk, level, optname,
  2361. optval, optlen);
  2362. return do_tcp_setsockopt(sk, level, optname, optval, optlen);
  2363. }
  2364. EXPORT_SYMBOL(tcp_setsockopt);
  2365. #ifdef CONFIG_COMPAT
  2366. int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
  2367. char __user *optval, unsigned int optlen)
  2368. {
  2369. if (level != SOL_TCP)
  2370. return inet_csk_compat_setsockopt(sk, level, optname,
  2371. optval, optlen);
  2372. return do_tcp_setsockopt(sk, level, optname, optval, optlen);
  2373. }
  2374. EXPORT_SYMBOL(compat_tcp_setsockopt);
  2375. #endif
  2376. /* Return information about state of tcp endpoint in API format. */
  2377. void tcp_get_info(const struct sock *sk, struct tcp_info *info)
  2378. {
  2379. const struct tcp_sock *tp = tcp_sk(sk);
  2380. const struct inet_connection_sock *icsk = inet_csk(sk);
  2381. u32 now = tcp_time_stamp;
  2382. memset(info, 0, sizeof(*info));
  2383. info->tcpi_state = sk->sk_state;
  2384. info->tcpi_ca_state = icsk->icsk_ca_state;
  2385. info->tcpi_retransmits = icsk->icsk_retransmits;
  2386. info->tcpi_probes = icsk->icsk_probes_out;
  2387. info->tcpi_backoff = icsk->icsk_backoff;
  2388. if (tp->rx_opt.tstamp_ok)
  2389. info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
  2390. if (tcp_is_sack(tp))
  2391. info->tcpi_options |= TCPI_OPT_SACK;
  2392. if (tp->rx_opt.wscale_ok) {
  2393. info->tcpi_options |= TCPI_OPT_WSCALE;
  2394. info->tcpi_snd_wscale = tp->rx_opt.snd_wscale;
  2395. info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale;
  2396. }
  2397. if (tp->ecn_flags & TCP_ECN_OK)
  2398. info->tcpi_options |= TCPI_OPT_ECN;
  2399. if (tp->ecn_flags & TCP_ECN_SEEN)
  2400. info->tcpi_options |= TCPI_OPT_ECN_SEEN;
  2401. if (tp->syn_data_acked)
  2402. info->tcpi_options |= TCPI_OPT_SYN_DATA;
  2403. info->tcpi_rto = jiffies_to_usecs(icsk->icsk_rto);
  2404. info->tcpi_ato = jiffies_to_usecs(icsk->icsk_ack.ato);
  2405. info->tcpi_snd_mss = tp->mss_cache;
  2406. info->tcpi_rcv_mss = icsk->icsk_ack.rcv_mss;
  2407. if (sk->sk_state == TCP_LISTEN) {
  2408. info->tcpi_unacked = sk->sk_ack_backlog;
  2409. info->tcpi_sacked = sk->sk_max_ack_backlog;
  2410. } else {
  2411. info->tcpi_unacked = tp->packets_out;
  2412. info->tcpi_sacked = tp->sacked_out;
  2413. }
  2414. info->tcpi_lost = tp->lost_out;
  2415. info->tcpi_retrans = tp->retrans_out;
  2416. info->tcpi_fackets = tp->fackets_out;
  2417. info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
  2418. info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime);
  2419. info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
  2420. info->tcpi_pmtu = icsk->icsk_pmtu_cookie;
  2421. info->tcpi_rcv_ssthresh = tp->rcv_ssthresh;
  2422. info->tcpi_rtt = jiffies_to_usecs(tp->srtt)>>3;
  2423. info->tcpi_rttvar = jiffies_to_usecs(tp->mdev)>>2;
  2424. info->tcpi_snd_ssthresh = tp->snd_ssthresh;
  2425. info->tcpi_snd_cwnd = tp->snd_cwnd;
  2426. info->tcpi_advmss = tp->advmss;
  2427. info->tcpi_reordering = tp->reordering;
  2428. info->tcpi_rcv_rtt = jiffies_to_usecs(tp->rcv_rtt_est.rtt)>>3;
  2429. info->tcpi_rcv_space = tp->rcvq_space.space;
  2430. info->tcpi_total_retrans = tp->total_retrans;
  2431. }
  2432. EXPORT_SYMBOL_GPL(tcp_get_info);
  2433. static int do_tcp_getsockopt(struct sock *sk, int level,
  2434. int optname, char __user *optval, int __user *optlen)
  2435. {
  2436. struct inet_connection_sock *icsk = inet_csk(sk);
  2437. struct tcp_sock *tp = tcp_sk(sk);
  2438. int val, len;
  2439. if (get_user(len, optlen))
  2440. return -EFAULT;
  2441. len = min_t(unsigned int, len, sizeof(int));
  2442. if (len < 0)
  2443. return -EINVAL;
  2444. switch (optname) {
  2445. case TCP_MAXSEG:
  2446. val = tp->mss_cache;
  2447. if (!val && ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
  2448. val = tp->rx_opt.user_mss;
  2449. if (tp->repair)
  2450. val = tp->rx_opt.mss_clamp;
  2451. break;
  2452. case TCP_NODELAY:
  2453. val = !!(tp->nonagle&TCP_NAGLE_OFF);
  2454. break;
  2455. case TCP_CORK:
  2456. val = !!(tp->nonagle&TCP_NAGLE_CORK);
  2457. break;
  2458. case TCP_KEEPIDLE:
  2459. val = keepalive_time_when(tp) / HZ;
  2460. break;
  2461. case TCP_KEEPINTVL:
  2462. val = keepalive_intvl_when(tp) / HZ;
  2463. break;
  2464. case TCP_KEEPCNT:
  2465. val = keepalive_probes(tp);
  2466. break;
  2467. case TCP_SYNCNT:
  2468. val = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
  2469. break;
  2470. case TCP_LINGER2:
  2471. val = tp->linger2;
  2472. if (val >= 0)
  2473. val = (val ? : sysctl_tcp_fin_timeout) / HZ;
  2474. break;
  2475. case TCP_DEFER_ACCEPT:
  2476. val = retrans_to_secs(icsk->icsk_accept_queue.rskq_defer_accept,
  2477. TCP_TIMEOUT_INIT / HZ, TCP_RTO_MAX / HZ);
  2478. break;
  2479. case TCP_WINDOW_CLAMP:
  2480. val = tp->window_clamp;
  2481. break;
  2482. case TCP_INFO: {
  2483. struct tcp_info info;
  2484. if (get_user(len, optlen))
  2485. return -EFAULT;
  2486. tcp_get_info(sk, &info);
  2487. len = min_t(unsigned int, len, sizeof(info));
  2488. if (put_user(len, optlen))
  2489. return -EFAULT;
  2490. if (copy_to_user(optval, &info, len))
  2491. return -EFAULT;
  2492. return 0;
  2493. }
  2494. case TCP_QUICKACK:
  2495. val = !icsk->icsk_ack.pingpong;
  2496. break;
  2497. case TCP_CONGESTION:
  2498. if (get_user(len, optlen))
  2499. return -EFAULT;
  2500. len = min_t(unsigned int, len, TCP_CA_NAME_MAX);
  2501. if (put_user(len, optlen))
  2502. return -EFAULT;
  2503. if (copy_to_user(optval, icsk->icsk_ca_ops->name, len))
  2504. return -EFAULT;
  2505. return 0;
  2506. case TCP_COOKIE_TRANSACTIONS: {
  2507. struct tcp_cookie_transactions ctd;
  2508. struct tcp_cookie_values *cvp = tp->cookie_values;
  2509. if (get_user(len, optlen))
  2510. return -EFAULT;
  2511. if (len < sizeof(ctd))
  2512. return -EINVAL;
  2513. memset(&ctd, 0, sizeof(ctd));
  2514. ctd.tcpct_flags = (tp->rx_opt.cookie_in_always ?
  2515. TCP_COOKIE_IN_ALWAYS : 0)
  2516. | (tp->rx_opt.cookie_out_never ?
  2517. TCP_COOKIE_OUT_NEVER : 0);
  2518. if (cvp != NULL) {
  2519. ctd.tcpct_flags |= (cvp->s_data_in ?
  2520. TCP_S_DATA_IN : 0)
  2521. | (cvp->s_data_out ?
  2522. TCP_S_DATA_OUT : 0);
  2523. ctd.tcpct_cookie_desired = cvp->cookie_desired;
  2524. ctd.tcpct_s_data_desired = cvp->s_data_desired;
  2525. memcpy(&ctd.tcpct_value[0], &cvp->cookie_pair[0],
  2526. cvp->cookie_pair_size);
  2527. ctd.tcpct_used = cvp->cookie_pair_size;
  2528. }
  2529. if (put_user(sizeof(ctd), optlen))
  2530. return -EFAULT;
  2531. if (copy_to_user(optval, &ctd, sizeof(ctd)))
  2532. return -EFAULT;
  2533. return 0;
  2534. }
  2535. case TCP_THIN_LINEAR_TIMEOUTS:
  2536. val = tp->thin_lto;
  2537. break;
  2538. case TCP_THIN_DUPACK:
  2539. val = tp->thin_dupack;
  2540. break;
  2541. case TCP_REPAIR:
  2542. val = tp->repair;
  2543. break;
  2544. case TCP_REPAIR_QUEUE:
  2545. if (tp->repair)
  2546. val = tp->repair_queue;
  2547. else
  2548. return -EINVAL;
  2549. break;
  2550. case TCP_QUEUE_SEQ:
  2551. if (tp->repair_queue == TCP_SEND_QUEUE)
  2552. val = tp->write_seq;
  2553. else if (tp->repair_queue == TCP_RECV_QUEUE)
  2554. val = tp->rcv_nxt;
  2555. else
  2556. return -EINVAL;
  2557. break;
  2558. case TCP_USER_TIMEOUT:
  2559. val = jiffies_to_msecs(icsk->icsk_user_timeout);
  2560. break;
  2561. default:
  2562. return -ENOPROTOOPT;
  2563. }
  2564. if (put_user(len, optlen))
  2565. return -EFAULT;
  2566. if (copy_to_user(optval, &val, len))
  2567. return -EFAULT;
  2568. return 0;
  2569. }
  2570. int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
  2571. int __user *optlen)
  2572. {
  2573. struct inet_connection_sock *icsk = inet_csk(sk);
  2574. if (level != SOL_TCP)
  2575. return icsk->icsk_af_ops->getsockopt(sk, level, optname,
  2576. optval, optlen);
  2577. return do_tcp_getsockopt(sk, level, optname, optval, optlen);
  2578. }
  2579. EXPORT_SYMBOL(tcp_getsockopt);
  2580. #ifdef CONFIG_COMPAT
  2581. int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
  2582. char __user *optval, int __user *optlen)
  2583. {
  2584. if (level != SOL_TCP)
  2585. return inet_csk_compat_getsockopt(sk, level, optname,
  2586. optval, optlen);
  2587. return do_tcp_getsockopt(sk, level, optname, optval, optlen);
  2588. }
  2589. EXPORT_SYMBOL(compat_tcp_getsockopt);
  2590. #endif
  2591. struct sk_buff *tcp_tso_segment(struct sk_buff *skb,
  2592. netdev_features_t features)
  2593. {
  2594. struct sk_buff *segs = ERR_PTR(-EINVAL);
  2595. struct tcphdr *th;
  2596. unsigned int thlen;
  2597. unsigned int seq;
  2598. __be32 delta;
  2599. unsigned int oldlen;
  2600. unsigned int mss;
  2601. if (!pskb_may_pull(skb, sizeof(*th)))
  2602. goto out;
  2603. th = tcp_hdr(skb);
  2604. thlen = th->doff * 4;
  2605. if (thlen < sizeof(*th))
  2606. goto out;
  2607. if (!pskb_may_pull(skb, thlen))
  2608. goto out;
  2609. oldlen = (u16)~skb->len;
  2610. __skb_pull(skb, thlen);
  2611. mss = skb_shinfo(skb)->gso_size;
  2612. if (unlikely(skb->len <= mss))
  2613. goto out;
  2614. if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
  2615. /* Packet is from an untrusted source, reset gso_segs. */
  2616. int type = skb_shinfo(skb)->gso_type;
  2617. if (unlikely(type &
  2618. ~(SKB_GSO_TCPV4 |
  2619. SKB_GSO_DODGY |
  2620. SKB_GSO_TCP_ECN |
  2621. SKB_GSO_TCPV6 |
  2622. 0) ||
  2623. !(type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))))
  2624. goto out;
  2625. skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
  2626. segs = NULL;
  2627. goto out;
  2628. }
  2629. segs = skb_segment(skb, features);
  2630. if (IS_ERR(segs))
  2631. goto out;
  2632. delta = htonl(oldlen + (thlen + mss));
  2633. skb = segs;
  2634. th = tcp_hdr(skb);
  2635. seq = ntohl(th->seq);
  2636. do {
  2637. th->fin = th->psh = 0;
  2638. th->check = ~csum_fold((__force __wsum)((__force u32)th->check +
  2639. (__force u32)delta));
  2640. if (skb->ip_summed != CHECKSUM_PARTIAL)
  2641. th->check =
  2642. csum_fold(csum_partial(skb_transport_header(skb),
  2643. thlen, skb->csum));
  2644. seq += mss;
  2645. skb = skb->next;
  2646. th = tcp_hdr(skb);
  2647. th->seq = htonl(seq);
  2648. th->cwr = 0;
  2649. } while (skb->next);
  2650. delta = htonl(oldlen + (skb->tail - skb->transport_header) +
  2651. skb->data_len);
  2652. th->check = ~csum_fold((__force __wsum)((__force u32)th->check +
  2653. (__force u32)delta));
  2654. if (skb->ip_summed != CHECKSUM_PARTIAL)
  2655. th->check = csum_fold(csum_partial(skb_transport_header(skb),
  2656. thlen, skb->csum));
  2657. out:
  2658. return segs;
  2659. }
  2660. EXPORT_SYMBOL(tcp_tso_segment);
  2661. struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
  2662. {
  2663. struct sk_buff **pp = NULL;
  2664. struct sk_buff *p;
  2665. struct tcphdr *th;
  2666. struct tcphdr *th2;
  2667. unsigned int len;
  2668. unsigned int thlen;
  2669. __be32 flags;
  2670. unsigned int mss = 1;
  2671. unsigned int hlen;
  2672. unsigned int off;
  2673. int flush = 1;
  2674. int i;
  2675. off = skb_gro_offset(skb);
  2676. hlen = off + sizeof(*th);
  2677. th = skb_gro_header_fast(skb, off);
  2678. if (skb_gro_header_hard(skb, hlen)) {
  2679. th = skb_gro_header_slow(skb, hlen, off);
  2680. if (unlikely(!th))
  2681. goto out;
  2682. }
  2683. thlen = th->doff * 4;
  2684. if (thlen < sizeof(*th))
  2685. goto out;
  2686. hlen = off + thlen;
  2687. if (skb_gro_header_hard(skb, hlen)) {
  2688. th = skb_gro_header_slow(skb, hlen, off);
  2689. if (unlikely(!th))
  2690. goto out;
  2691. }
  2692. skb_gro_pull(skb, thlen);
  2693. len = skb_gro_len(skb);
  2694. flags = tcp_flag_word(th);
  2695. for (; (p = *head); head = &p->next) {
  2696. if (!NAPI_GRO_CB(p)->same_flow)
  2697. continue;
  2698. th2 = tcp_hdr(p);
  2699. if (*(u32 *)&th->source ^ *(u32 *)&th2->source) {
  2700. NAPI_GRO_CB(p)->same_flow = 0;
  2701. continue;
  2702. }
  2703. goto found;
  2704. }
  2705. goto out_check_final;
  2706. found:
  2707. flush = NAPI_GRO_CB(p)->flush;
  2708. flush |= (__force int)(flags & TCP_FLAG_CWR);
  2709. flush |= (__force int)((flags ^ tcp_flag_word(th2)) &
  2710. ~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH));
  2711. flush |= (__force int)(th->ack_seq ^ th2->ack_seq);
  2712. for (i = sizeof(*th); i < thlen; i += 4)
  2713. flush |= *(u32 *)((u8 *)th + i) ^
  2714. *(u32 *)((u8 *)th2 + i);
  2715. mss = skb_shinfo(p)->gso_size;
  2716. flush |= (len - 1) >= mss;
  2717. flush |= (ntohl(th2->seq) + skb_gro_len(p)) ^ ntohl(th->seq);
  2718. if (flush || skb_gro_receive(head, skb)) {
  2719. mss = 1;
  2720. goto out_check_final;
  2721. }
  2722. p = *head;
  2723. th2 = tcp_hdr(p);
  2724. tcp_flag_word(th2) |= flags & (TCP_FLAG_FIN | TCP_FLAG_PSH);
  2725. out_check_final:
  2726. flush = len < mss;
  2727. flush |= (__force int)(flags & (TCP_FLAG_URG | TCP_FLAG_PSH |
  2728. TCP_FLAG_RST | TCP_FLAG_SYN |
  2729. TCP_FLAG_FIN));
  2730. if (p && (!NAPI_GRO_CB(skb)->same_flow || flush))
  2731. pp = head;
  2732. out:
  2733. NAPI_GRO_CB(skb)->flush |= flush;
  2734. return pp;
  2735. }
  2736. EXPORT_SYMBOL(tcp_gro_receive);
  2737. int tcp_gro_complete(struct sk_buff *skb)
  2738. {
  2739. struct tcphdr *th = tcp_hdr(skb);
  2740. skb->csum_start = skb_transport_header(skb) - skb->head;
  2741. skb->csum_offset = offsetof(struct tcphdr, check);
  2742. skb->ip_summed = CHECKSUM_PARTIAL;
  2743. skb_shinfo(skb)->gso_segs = NAPI_GRO_CB(skb)->count;
  2744. if (th->cwr)
  2745. skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
  2746. return 0;
  2747. }
  2748. EXPORT_SYMBOL(tcp_gro_complete);
  2749. #ifdef CONFIG_TCP_MD5SIG
  2750. static unsigned long tcp_md5sig_users;
  2751. static struct tcp_md5sig_pool __percpu *tcp_md5sig_pool;
  2752. static DEFINE_SPINLOCK(tcp_md5sig_pool_lock);
  2753. static void __tcp_free_md5sig_pool(struct tcp_md5sig_pool __percpu *pool)
  2754. {
  2755. int cpu;
  2756. for_each_possible_cpu(cpu) {
  2757. struct tcp_md5sig_pool *p = per_cpu_ptr(pool, cpu);
  2758. if (p->md5_desc.tfm)
  2759. crypto_free_hash(p->md5_desc.tfm);
  2760. }
  2761. free_percpu(pool);
  2762. }
  2763. void tcp_free_md5sig_pool(void)
  2764. {
  2765. struct tcp_md5sig_pool __percpu *pool = NULL;
  2766. spin_lock_bh(&tcp_md5sig_pool_lock);
  2767. if (--tcp_md5sig_users == 0) {
  2768. pool = tcp_md5sig_pool;
  2769. tcp_md5sig_pool = NULL;
  2770. }
  2771. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2772. if (pool)
  2773. __tcp_free_md5sig_pool(pool);
  2774. }
  2775. EXPORT_SYMBOL(tcp_free_md5sig_pool);
  2776. static struct tcp_md5sig_pool __percpu *
  2777. __tcp_alloc_md5sig_pool(struct sock *sk)
  2778. {
  2779. int cpu;
  2780. struct tcp_md5sig_pool __percpu *pool;
  2781. pool = alloc_percpu(struct tcp_md5sig_pool);
  2782. if (!pool)
  2783. return NULL;
  2784. for_each_possible_cpu(cpu) {
  2785. struct crypto_hash *hash;
  2786. hash = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
  2787. if (!hash || IS_ERR(hash))
  2788. goto out_free;
  2789. per_cpu_ptr(pool, cpu)->md5_desc.tfm = hash;
  2790. }
  2791. return pool;
  2792. out_free:
  2793. __tcp_free_md5sig_pool(pool);
  2794. return NULL;
  2795. }
  2796. struct tcp_md5sig_pool __percpu *tcp_alloc_md5sig_pool(struct sock *sk)
  2797. {
  2798. struct tcp_md5sig_pool __percpu *pool;
  2799. bool alloc = false;
  2800. retry:
  2801. spin_lock_bh(&tcp_md5sig_pool_lock);
  2802. pool = tcp_md5sig_pool;
  2803. if (tcp_md5sig_users++ == 0) {
  2804. alloc = true;
  2805. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2806. } else if (!pool) {
  2807. tcp_md5sig_users--;
  2808. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2809. cpu_relax();
  2810. goto retry;
  2811. } else
  2812. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2813. if (alloc) {
  2814. /* we cannot hold spinlock here because this may sleep. */
  2815. struct tcp_md5sig_pool __percpu *p;
  2816. p = __tcp_alloc_md5sig_pool(sk);
  2817. spin_lock_bh(&tcp_md5sig_pool_lock);
  2818. if (!p) {
  2819. tcp_md5sig_users--;
  2820. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2821. return NULL;
  2822. }
  2823. pool = tcp_md5sig_pool;
  2824. if (pool) {
  2825. /* oops, it has already been assigned. */
  2826. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2827. __tcp_free_md5sig_pool(p);
  2828. } else {
  2829. tcp_md5sig_pool = pool = p;
  2830. spin_unlock_bh(&tcp_md5sig_pool_lock);
  2831. }
  2832. }
  2833. return pool;
  2834. }
  2835. EXPORT_SYMBOL(tcp_alloc_md5sig_pool);
  2836. /**
  2837. * tcp_get_md5sig_pool - get md5sig_pool for this user
  2838. *
  2839. * We use percpu structure, so if we succeed, we exit with preemption
  2840. * and BH disabled, to make sure another thread or softirq handling
  2841. * wont try to get same context.
  2842. */
  2843. struct tcp_md5sig_pool *tcp_get_md5sig_pool(void)
  2844. {
  2845. struct tcp_md5sig_pool __percpu *p;
  2846. local_bh_disable();
  2847. spin_lock(&tcp_md5sig_pool_lock);
  2848. p = tcp_md5sig_pool;
  2849. if (p)
  2850. tcp_md5sig_users++;
  2851. spin_unlock(&tcp_md5sig_pool_lock);
  2852. if (p)
  2853. return this_cpu_ptr(p);
  2854. local_bh_enable();
  2855. return NULL;
  2856. }
  2857. EXPORT_SYMBOL(tcp_get_md5sig_pool);
  2858. void tcp_put_md5sig_pool(void)
  2859. {
  2860. local_bh_enable();
  2861. tcp_free_md5sig_pool();
  2862. }
  2863. EXPORT_SYMBOL(tcp_put_md5sig_pool);
  2864. int tcp_md5_hash_header(struct tcp_md5sig_pool *hp,
  2865. const struct tcphdr *th)
  2866. {
  2867. struct scatterlist sg;
  2868. struct tcphdr hdr;
  2869. int err;
  2870. /* We are not allowed to change tcphdr, make a local copy */
  2871. memcpy(&hdr, th, sizeof(hdr));
  2872. hdr.check = 0;
  2873. /* options aren't included in the hash */
  2874. sg_init_one(&sg, &hdr, sizeof(hdr));
  2875. err = crypto_hash_update(&hp->md5_desc, &sg, sizeof(hdr));
  2876. return err;
  2877. }
  2878. EXPORT_SYMBOL(tcp_md5_hash_header);
  2879. int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *hp,
  2880. const struct sk_buff *skb, unsigned int header_len)
  2881. {
  2882. struct scatterlist sg;
  2883. const struct tcphdr *tp = tcp_hdr(skb);
  2884. struct hash_desc *desc = &hp->md5_desc;
  2885. unsigned int i;
  2886. const unsigned int head_data_len = skb_headlen(skb) > header_len ?
  2887. skb_headlen(skb) - header_len : 0;
  2888. const struct skb_shared_info *shi = skb_shinfo(skb);
  2889. struct sk_buff *frag_iter;
  2890. sg_init_table(&sg, 1);
  2891. sg_set_buf(&sg, ((u8 *) tp) + header_len, head_data_len);
  2892. if (crypto_hash_update(desc, &sg, head_data_len))
  2893. return 1;
  2894. for (i = 0; i < shi->nr_frags; ++i) {
  2895. const struct skb_frag_struct *f = &shi->frags[i];
  2896. struct page *page = skb_frag_page(f);
  2897. sg_set_page(&sg, page, skb_frag_size(f), f->page_offset);
  2898. if (crypto_hash_update(desc, &sg, skb_frag_size(f)))
  2899. return 1;
  2900. }
  2901. skb_walk_frags(skb, frag_iter)
  2902. if (tcp_md5_hash_skb_data(hp, frag_iter, 0))
  2903. return 1;
  2904. return 0;
  2905. }
  2906. EXPORT_SYMBOL(tcp_md5_hash_skb_data);
  2907. int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, const struct tcp_md5sig_key *key)
  2908. {
  2909. struct scatterlist sg;
  2910. sg_init_one(&sg, key->key, key->keylen);
  2911. return crypto_hash_update(&hp->md5_desc, &sg, key->keylen);
  2912. }
  2913. EXPORT_SYMBOL(tcp_md5_hash_key);
  2914. #endif
  2915. /* Each Responder maintains up to two secret values concurrently for
  2916. * efficient secret rollover. Each secret value has 4 states:
  2917. *
  2918. * Generating. (tcp_secret_generating != tcp_secret_primary)
  2919. * Generates new Responder-Cookies, but not yet used for primary
  2920. * verification. This is a short-term state, typically lasting only
  2921. * one round trip time (RTT).
  2922. *
  2923. * Primary. (tcp_secret_generating == tcp_secret_primary)
  2924. * Used both for generation and primary verification.
  2925. *
  2926. * Retiring. (tcp_secret_retiring != tcp_secret_secondary)
  2927. * Used for verification, until the first failure that can be
  2928. * verified by the newer Generating secret. At that time, this
  2929. * cookie's state is changed to Secondary, and the Generating
  2930. * cookie's state is changed to Primary. This is a short-term state,
  2931. * typically lasting only one round trip time (RTT).
  2932. *
  2933. * Secondary. (tcp_secret_retiring == tcp_secret_secondary)
  2934. * Used for secondary verification, after primary verification
  2935. * failures. This state lasts no more than twice the Maximum Segment
  2936. * Lifetime (2MSL). Then, the secret is discarded.
  2937. */
  2938. struct tcp_cookie_secret {
  2939. /* The secret is divided into two parts. The digest part is the
  2940. * equivalent of previously hashing a secret and saving the state,
  2941. * and serves as an initialization vector (IV). The message part
  2942. * serves as the trailing secret.
  2943. */
  2944. u32 secrets[COOKIE_WORKSPACE_WORDS];
  2945. unsigned long expires;
  2946. };
  2947. #define TCP_SECRET_1MSL (HZ * TCP_PAWS_MSL)
  2948. #define TCP_SECRET_2MSL (HZ * TCP_PAWS_MSL * 2)
  2949. #define TCP_SECRET_LIFE (HZ * 600)
  2950. static struct tcp_cookie_secret tcp_secret_one;
  2951. static struct tcp_cookie_secret tcp_secret_two;
  2952. /* Essentially a circular list, without dynamic allocation. */
  2953. static struct tcp_cookie_secret *tcp_secret_generating;
  2954. static struct tcp_cookie_secret *tcp_secret_primary;
  2955. static struct tcp_cookie_secret *tcp_secret_retiring;
  2956. static struct tcp_cookie_secret *tcp_secret_secondary;
  2957. static DEFINE_SPINLOCK(tcp_secret_locker);
  2958. /* Select a pseudo-random word in the cookie workspace.
  2959. */
  2960. static inline u32 tcp_cookie_work(const u32 *ws, const int n)
  2961. {
  2962. return ws[COOKIE_DIGEST_WORDS + ((COOKIE_MESSAGE_WORDS-1) & ws[n])];
  2963. }
  2964. /* Fill bakery[COOKIE_WORKSPACE_WORDS] with generator, updating as needed.
  2965. * Called in softirq context.
  2966. * Returns: 0 for success.
  2967. */
  2968. int tcp_cookie_generator(u32 *bakery)
  2969. {
  2970. unsigned long jiffy = jiffies;
  2971. if (unlikely(time_after_eq(jiffy, tcp_secret_generating->expires))) {
  2972. spin_lock_bh(&tcp_secret_locker);
  2973. if (!time_after_eq(jiffy, tcp_secret_generating->expires)) {
  2974. /* refreshed by another */
  2975. memcpy(bakery,
  2976. &tcp_secret_generating->secrets[0],
  2977. COOKIE_WORKSPACE_WORDS);
  2978. } else {
  2979. /* still needs refreshing */
  2980. get_random_bytes(bakery, COOKIE_WORKSPACE_WORDS);
  2981. /* The first time, paranoia assumes that the
  2982. * randomization function isn't as strong. But,
  2983. * this secret initialization is delayed until
  2984. * the last possible moment (packet arrival).
  2985. * Although that time is observable, it is
  2986. * unpredictably variable. Mash in the most
  2987. * volatile clock bits available, and expire the
  2988. * secret extra quickly.
  2989. */
  2990. if (unlikely(tcp_secret_primary->expires ==
  2991. tcp_secret_secondary->expires)) {
  2992. struct timespec tv;
  2993. getnstimeofday(&tv);
  2994. bakery[COOKIE_DIGEST_WORDS+0] ^=
  2995. (u32)tv.tv_nsec;
  2996. tcp_secret_secondary->expires = jiffy
  2997. + TCP_SECRET_1MSL
  2998. + (0x0f & tcp_cookie_work(bakery, 0));
  2999. } else {
  3000. tcp_secret_secondary->expires = jiffy
  3001. + TCP_SECRET_LIFE
  3002. + (0xff & tcp_cookie_work(bakery, 1));
  3003. tcp_secret_primary->expires = jiffy
  3004. + TCP_SECRET_2MSL
  3005. + (0x1f & tcp_cookie_work(bakery, 2));
  3006. }
  3007. memcpy(&tcp_secret_secondary->secrets[0],
  3008. bakery, COOKIE_WORKSPACE_WORDS);
  3009. rcu_assign_pointer(tcp_secret_generating,
  3010. tcp_secret_secondary);
  3011. rcu_assign_pointer(tcp_secret_retiring,
  3012. tcp_secret_primary);
  3013. /*
  3014. * Neither call_rcu() nor synchronize_rcu() needed.
  3015. * Retiring data is not freed. It is replaced after
  3016. * further (locked) pointer updates, and a quiet time
  3017. * (minimum 1MSL, maximum LIFE - 2MSL).
  3018. */
  3019. }
  3020. spin_unlock_bh(&tcp_secret_locker);
  3021. } else {
  3022. rcu_read_lock_bh();
  3023. memcpy(bakery,
  3024. &rcu_dereference(tcp_secret_generating)->secrets[0],
  3025. COOKIE_WORKSPACE_WORDS);
  3026. rcu_read_unlock_bh();
  3027. }
  3028. return 0;
  3029. }
  3030. EXPORT_SYMBOL(tcp_cookie_generator);
  3031. void tcp_done(struct sock *sk)
  3032. {
  3033. struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
  3034. if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
  3035. TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
  3036. tcp_set_state(sk, TCP_CLOSE);
  3037. tcp_clear_xmit_timers(sk);
  3038. if (req != NULL)
  3039. reqsk_fastopen_remove(sk, req, false);
  3040. sk->sk_shutdown = SHUTDOWN_MASK;
  3041. if (!sock_flag(sk, SOCK_DEAD))
  3042. sk->sk_state_change(sk);
  3043. else
  3044. inet_csk_destroy_sock(sk);
  3045. }
  3046. EXPORT_SYMBOL_GPL(tcp_done);
  3047. extern struct tcp_congestion_ops tcp_reno;
  3048. static __initdata unsigned long thash_entries;
  3049. static int __init set_thash_entries(char *str)
  3050. {
  3051. ssize_t ret;
  3052. if (!str)
  3053. return 0;
  3054. ret = kstrtoul(str, 0, &thash_entries);
  3055. if (ret)
  3056. return 0;
  3057. return 1;
  3058. }
  3059. __setup("thash_entries=", set_thash_entries);
  3060. void tcp_init_mem(struct net *net)
  3061. {
  3062. unsigned long limit = nr_free_buffer_pages() / 8;
  3063. limit = max(limit, 128UL);
  3064. net->ipv4.sysctl_tcp_mem[0] = limit / 4 * 3;
  3065. net->ipv4.sysctl_tcp_mem[1] = limit;
  3066. net->ipv4.sysctl_tcp_mem[2] = net->ipv4.sysctl_tcp_mem[0] * 2;
  3067. }
  3068. void __init tcp_init(void)
  3069. {
  3070. struct sk_buff *skb = NULL;
  3071. unsigned long limit;
  3072. int max_rshare, max_wshare, cnt;
  3073. unsigned int i;
  3074. unsigned long jiffy = jiffies;
  3075. BUILD_BUG_ON(sizeof(struct tcp_skb_cb) > sizeof(skb->cb));
  3076. percpu_counter_init(&tcp_sockets_allocated, 0);
  3077. percpu_counter_init(&tcp_orphan_count, 0);
  3078. tcp_hashinfo.bind_bucket_cachep =
  3079. kmem_cache_create("tcp_bind_bucket",
  3080. sizeof(struct inet_bind_bucket), 0,
  3081. SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
  3082. /* Size and allocate the main established and bind bucket
  3083. * hash tables.
  3084. *
  3085. * The methodology is similar to that of the buffer cache.
  3086. */
  3087. tcp_hashinfo.ehash =
  3088. alloc_large_system_hash("TCP established",
  3089. sizeof(struct inet_ehash_bucket),
  3090. thash_entries,
  3091. 17, /* one slot per 128 KB of memory */
  3092. 0,
  3093. NULL,
  3094. &tcp_hashinfo.ehash_mask,
  3095. 0,
  3096. thash_entries ? 0 : 512 * 1024);
  3097. for (i = 0; i <= tcp_hashinfo.ehash_mask; i++) {
  3098. INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].chain, i);
  3099. INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].twchain, i);
  3100. }
  3101. if (inet_ehash_locks_alloc(&tcp_hashinfo))
  3102. panic("TCP: failed to alloc ehash_locks");
  3103. tcp_hashinfo.bhash =
  3104. alloc_large_system_hash("TCP bind",
  3105. sizeof(struct inet_bind_hashbucket),
  3106. tcp_hashinfo.ehash_mask + 1,
  3107. 17, /* one slot per 128 KB of memory */
  3108. 0,
  3109. &tcp_hashinfo.bhash_size,
  3110. NULL,
  3111. 0,
  3112. 64 * 1024);
  3113. tcp_hashinfo.bhash_size = 1U << tcp_hashinfo.bhash_size;
  3114. for (i = 0; i < tcp_hashinfo.bhash_size; i++) {
  3115. spin_lock_init(&tcp_hashinfo.bhash[i].lock);
  3116. INIT_HLIST_HEAD(&tcp_hashinfo.bhash[i].chain);
  3117. }
  3118. cnt = tcp_hashinfo.ehash_mask + 1;
  3119. tcp_death_row.sysctl_max_tw_buckets = cnt / 2;
  3120. sysctl_tcp_max_orphans = cnt / 2;
  3121. sysctl_max_syn_backlog = max(128, cnt / 256);
  3122. tcp_init_mem(&init_net);
  3123. /* Set per-socket limits to no more than 1/128 the pressure threshold */
  3124. limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7);
  3125. max_wshare = min(4UL*1024*1024, limit);
  3126. max_rshare = min(6UL*1024*1024, limit);
  3127. sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;
  3128. sysctl_tcp_wmem[1] = 16*1024;
  3129. sysctl_tcp_wmem[2] = max(64*1024, max_wshare);
  3130. sysctl_tcp_rmem[0] = SK_MEM_QUANTUM;
  3131. sysctl_tcp_rmem[1] = 87380;
  3132. sysctl_tcp_rmem[2] = max(87380, max_rshare);
  3133. pr_info("Hash tables configured (established %u bind %u)\n",
  3134. tcp_hashinfo.ehash_mask + 1, tcp_hashinfo.bhash_size);
  3135. tcp_metrics_init();
  3136. tcp_register_congestion_control(&tcp_reno);
  3137. memset(&tcp_secret_one.secrets[0], 0, sizeof(tcp_secret_one.secrets));
  3138. memset(&tcp_secret_two.secrets[0], 0, sizeof(tcp_secret_two.secrets));
  3139. tcp_secret_one.expires = jiffy; /* past due */
  3140. tcp_secret_two.expires = jiffy; /* past due */
  3141. tcp_secret_generating = &tcp_secret_one;
  3142. tcp_secret_primary = &tcp_secret_one;
  3143. tcp_secret_retiring = &tcp_secret_two;
  3144. tcp_secret_secondary = &tcp_secret_two;
  3145. tcp_tasklet_init();
  3146. }