sock.c 85 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483
  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. * Generic socket support routines. Memory allocators, socket lock/release
  7. * handler for protocols to use and generic option handler.
  8. *
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Florian La Roche, <flla@stud.uni-sb.de>
  13. * Alan Cox, <A.Cox@swansea.ac.uk>
  14. *
  15. * Fixes:
  16. * Alan Cox : Numerous verify_area() problems
  17. * Alan Cox : Connecting on a connecting socket
  18. * now returns an error for tcp.
  19. * Alan Cox : sock->protocol is set correctly.
  20. * and is not sometimes left as 0.
  21. * Alan Cox : connect handles icmp errors on a
  22. * connect properly. Unfortunately there
  23. * is a restart syscall nasty there. I
  24. * can't match BSD without hacking the C
  25. * library. Ideas urgently sought!
  26. * Alan Cox : Disallow bind() to addresses that are
  27. * not ours - especially broadcast ones!!
  28. * Alan Cox : Socket 1024 _IS_ ok for users. (fencepost)
  29. * Alan Cox : sock_wfree/sock_rfree don't destroy sockets,
  30. * instead they leave that for the DESTROY timer.
  31. * Alan Cox : Clean up error flag in accept
  32. * Alan Cox : TCP ack handling is buggy, the DESTROY timer
  33. * was buggy. Put a remove_sock() in the handler
  34. * for memory when we hit 0. Also altered the timer
  35. * code. The ACK stuff can wait and needs major
  36. * TCP layer surgery.
  37. * Alan Cox : Fixed TCP ack bug, removed remove sock
  38. * and fixed timer/inet_bh race.
  39. * Alan Cox : Added zapped flag for TCP
  40. * Alan Cox : Move kfree_skb into skbuff.c and tidied up surplus code
  41. * Alan Cox : for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
  42. * Alan Cox : kfree_s calls now are kfree_skbmem so we can track skb resources
  43. * Alan Cox : Supports socket option broadcast now as does udp. Packet and raw need fixing.
  44. * Alan Cox : Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
  45. * Rick Sladkey : Relaxed UDP rules for matching packets.
  46. * C.E.Hawkins : IFF_PROMISC/SIOCGHWADDR support
  47. * Pauline Middelink : identd support
  48. * Alan Cox : Fixed connect() taking signals I think.
  49. * Alan Cox : SO_LINGER supported
  50. * Alan Cox : Error reporting fixes
  51. * Anonymous : inet_create tidied up (sk->reuse setting)
  52. * Alan Cox : inet sockets don't set sk->type!
  53. * Alan Cox : Split socket option code
  54. * Alan Cox : Callbacks
  55. * Alan Cox : Nagle flag for Charles & Johannes stuff
  56. * Alex : Removed restriction on inet fioctl
  57. * Alan Cox : Splitting INET from NET core
  58. * Alan Cox : Fixed bogus SO_TYPE handling in getsockopt()
  59. * Adam Caldwell : Missing return in SO_DONTROUTE/SO_DEBUG code
  60. * Alan Cox : Split IP from generic code
  61. * Alan Cox : New kfree_skbmem()
  62. * Alan Cox : Make SO_DEBUG superuser only.
  63. * Alan Cox : Allow anyone to clear SO_DEBUG
  64. * (compatibility fix)
  65. * Alan Cox : Added optimistic memory grabbing for AF_UNIX throughput.
  66. * Alan Cox : Allocator for a socket is settable.
  67. * Alan Cox : SO_ERROR includes soft errors.
  68. * Alan Cox : Allow NULL arguments on some SO_ opts
  69. * Alan Cox : Generic socket allocation to make hooks
  70. * easier (suggested by Craig Metz).
  71. * Michael Pall : SO_ERROR returns positive errno again
  72. * Steve Whitehouse: Added default destructor to free
  73. * protocol private data.
  74. * Steve Whitehouse: Added various other default routines
  75. * common to several socket families.
  76. * Chris Evans : Call suser() check last on F_SETOWN
  77. * Jay Schulist : Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
  78. * Andi Kleen : Add sock_kmalloc()/sock_kfree_s()
  79. * Andi Kleen : Fix write_space callback
  80. * Chris Evans : Security fixes - signedness again
  81. * Arnaldo C. Melo : cleanups, use skb_queue_purge
  82. *
  83. * To Fix:
  84. *
  85. *
  86. * This program is free software; you can redistribute it and/or
  87. * modify it under the terms of the GNU General Public License
  88. * as published by the Free Software Foundation; either version
  89. * 2 of the License, or (at your option) any later version.
  90. */
  91. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  92. #include <linux/capability.h>
  93. #include <linux/errno.h>
  94. #include <linux/errqueue.h>
  95. #include <linux/types.h>
  96. #include <linux/socket.h>
  97. #include <linux/in.h>
  98. #include <linux/kernel.h>
  99. #include <linux/module.h>
  100. #include <linux/proc_fs.h>
  101. #include <linux/seq_file.h>
  102. #include <linux/sched.h>
  103. #include <linux/sched/mm.h>
  104. #include <linux/timer.h>
  105. #include <linux/string.h>
  106. #include <linux/sockios.h>
  107. #include <linux/net.h>
  108. #include <linux/mm.h>
  109. #include <linux/slab.h>
  110. #include <linux/interrupt.h>
  111. #include <linux/poll.h>
  112. #include <linux/tcp.h>
  113. #include <linux/init.h>
  114. #include <linux/highmem.h>
  115. #include <linux/user_namespace.h>
  116. #include <linux/static_key.h>
  117. #include <linux/memcontrol.h>
  118. #include <linux/prefetch.h>
  119. #include <linux/uaccess.h>
  120. #include <linux/netdevice.h>
  121. #include <net/protocol.h>
  122. #include <linux/skbuff.h>
  123. #include <net/net_namespace.h>
  124. #include <net/request_sock.h>
  125. #include <net/sock.h>
  126. #include <linux/net_tstamp.h>
  127. #include <net/xfrm.h>
  128. #include <linux/ipsec.h>
  129. #include <net/cls_cgroup.h>
  130. #include <net/netprio_cgroup.h>
  131. #include <linux/sock_diag.h>
  132. #include <linux/filter.h>
  133. #include <net/sock_reuseport.h>
  134. #include <trace/events/sock.h>
  135. #include <net/tcp.h>
  136. #include <net/busy_poll.h>
  137. static DEFINE_MUTEX(proto_list_mutex);
  138. static LIST_HEAD(proto_list);
  139. static void sock_inuse_add(struct net *net, int val);
  140. /**
  141. * sk_ns_capable - General socket capability test
  142. * @sk: Socket to use a capability on or through
  143. * @user_ns: The user namespace of the capability to use
  144. * @cap: The capability to use
  145. *
  146. * Test to see if the opener of the socket had when the socket was
  147. * created and the current process has the capability @cap in the user
  148. * namespace @user_ns.
  149. */
  150. bool sk_ns_capable(const struct sock *sk,
  151. struct user_namespace *user_ns, int cap)
  152. {
  153. return file_ns_capable(sk->sk_socket->file, user_ns, cap) &&
  154. ns_capable(user_ns, cap);
  155. }
  156. EXPORT_SYMBOL(sk_ns_capable);
  157. /**
  158. * sk_capable - Socket global capability test
  159. * @sk: Socket to use a capability on or through
  160. * @cap: The global capability to use
  161. *
  162. * Test to see if the opener of the socket had when the socket was
  163. * created and the current process has the capability @cap in all user
  164. * namespaces.
  165. */
  166. bool sk_capable(const struct sock *sk, int cap)
  167. {
  168. return sk_ns_capable(sk, &init_user_ns, cap);
  169. }
  170. EXPORT_SYMBOL(sk_capable);
  171. /**
  172. * sk_net_capable - Network namespace socket capability test
  173. * @sk: Socket to use a capability on or through
  174. * @cap: The capability to use
  175. *
  176. * Test to see if the opener of the socket had when the socket was created
  177. * and the current process has the capability @cap over the network namespace
  178. * the socket is a member of.
  179. */
  180. bool sk_net_capable(const struct sock *sk, int cap)
  181. {
  182. return sk_ns_capable(sk, sock_net(sk)->user_ns, cap);
  183. }
  184. EXPORT_SYMBOL(sk_net_capable);
  185. /*
  186. * Each address family might have different locking rules, so we have
  187. * one slock key per address family and separate keys for internal and
  188. * userspace sockets.
  189. */
  190. static struct lock_class_key af_family_keys[AF_MAX];
  191. static struct lock_class_key af_family_kern_keys[AF_MAX];
  192. static struct lock_class_key af_family_slock_keys[AF_MAX];
  193. static struct lock_class_key af_family_kern_slock_keys[AF_MAX];
  194. /*
  195. * Make lock validator output more readable. (we pre-construct these
  196. * strings build-time, so that runtime initialization of socket
  197. * locks is fast):
  198. */
  199. #define _sock_locks(x) \
  200. x "AF_UNSPEC", x "AF_UNIX" , x "AF_INET" , \
  201. x "AF_AX25" , x "AF_IPX" , x "AF_APPLETALK", \
  202. x "AF_NETROM", x "AF_BRIDGE" , x "AF_ATMPVC" , \
  203. x "AF_X25" , x "AF_INET6" , x "AF_ROSE" , \
  204. x "AF_DECnet", x "AF_NETBEUI" , x "AF_SECURITY" , \
  205. x "AF_KEY" , x "AF_NETLINK" , x "AF_PACKET" , \
  206. x "AF_ASH" , x "AF_ECONET" , x "AF_ATMSVC" , \
  207. x "AF_RDS" , x "AF_SNA" , x "AF_IRDA" , \
  208. x "AF_PPPOX" , x "AF_WANPIPE" , x "AF_LLC" , \
  209. x "27" , x "28" , x "AF_CAN" , \
  210. x "AF_TIPC" , x "AF_BLUETOOTH", x "IUCV" , \
  211. x "AF_RXRPC" , x "AF_ISDN" , x "AF_PHONET" , \
  212. x "AF_IEEE802154", x "AF_CAIF" , x "AF_ALG" , \
  213. x "AF_NFC" , x "AF_VSOCK" , x "AF_KCM" , \
  214. x "AF_QIPCRTR", x "AF_SMC" , x "AF_XDP" , \
  215. x "AF_MAX"
  216. static const char *const af_family_key_strings[AF_MAX+1] = {
  217. _sock_locks("sk_lock-")
  218. };
  219. static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  220. _sock_locks("slock-")
  221. };
  222. static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  223. _sock_locks("clock-")
  224. };
  225. static const char *const af_family_kern_key_strings[AF_MAX+1] = {
  226. _sock_locks("k-sk_lock-")
  227. };
  228. static const char *const af_family_kern_slock_key_strings[AF_MAX+1] = {
  229. _sock_locks("k-slock-")
  230. };
  231. static const char *const af_family_kern_clock_key_strings[AF_MAX+1] = {
  232. _sock_locks("k-clock-")
  233. };
  234. static const char *const af_family_rlock_key_strings[AF_MAX+1] = {
  235. "rlock-AF_UNSPEC", "rlock-AF_UNIX" , "rlock-AF_INET" ,
  236. "rlock-AF_AX25" , "rlock-AF_IPX" , "rlock-AF_APPLETALK",
  237. "rlock-AF_NETROM", "rlock-AF_BRIDGE" , "rlock-AF_ATMPVC" ,
  238. "rlock-AF_X25" , "rlock-AF_INET6" , "rlock-AF_ROSE" ,
  239. "rlock-AF_DECnet", "rlock-AF_NETBEUI" , "rlock-AF_SECURITY" ,
  240. "rlock-AF_KEY" , "rlock-AF_NETLINK" , "rlock-AF_PACKET" ,
  241. "rlock-AF_ASH" , "rlock-AF_ECONET" , "rlock-AF_ATMSVC" ,
  242. "rlock-AF_RDS" , "rlock-AF_SNA" , "rlock-AF_IRDA" ,
  243. "rlock-AF_PPPOX" , "rlock-AF_WANPIPE" , "rlock-AF_LLC" ,
  244. "rlock-27" , "rlock-28" , "rlock-AF_CAN" ,
  245. "rlock-AF_TIPC" , "rlock-AF_BLUETOOTH", "rlock-AF_IUCV" ,
  246. "rlock-AF_RXRPC" , "rlock-AF_ISDN" , "rlock-AF_PHONET" ,
  247. "rlock-AF_IEEE802154", "rlock-AF_CAIF" , "rlock-AF_ALG" ,
  248. "rlock-AF_NFC" , "rlock-AF_VSOCK" , "rlock-AF_KCM" ,
  249. "rlock-AF_QIPCRTR", "rlock-AF_SMC" , "rlock-AF_XDP" ,
  250. "rlock-AF_MAX"
  251. };
  252. static const char *const af_family_wlock_key_strings[AF_MAX+1] = {
  253. "wlock-AF_UNSPEC", "wlock-AF_UNIX" , "wlock-AF_INET" ,
  254. "wlock-AF_AX25" , "wlock-AF_IPX" , "wlock-AF_APPLETALK",
  255. "wlock-AF_NETROM", "wlock-AF_BRIDGE" , "wlock-AF_ATMPVC" ,
  256. "wlock-AF_X25" , "wlock-AF_INET6" , "wlock-AF_ROSE" ,
  257. "wlock-AF_DECnet", "wlock-AF_NETBEUI" , "wlock-AF_SECURITY" ,
  258. "wlock-AF_KEY" , "wlock-AF_NETLINK" , "wlock-AF_PACKET" ,
  259. "wlock-AF_ASH" , "wlock-AF_ECONET" , "wlock-AF_ATMSVC" ,
  260. "wlock-AF_RDS" , "wlock-AF_SNA" , "wlock-AF_IRDA" ,
  261. "wlock-AF_PPPOX" , "wlock-AF_WANPIPE" , "wlock-AF_LLC" ,
  262. "wlock-27" , "wlock-28" , "wlock-AF_CAN" ,
  263. "wlock-AF_TIPC" , "wlock-AF_BLUETOOTH", "wlock-AF_IUCV" ,
  264. "wlock-AF_RXRPC" , "wlock-AF_ISDN" , "wlock-AF_PHONET" ,
  265. "wlock-AF_IEEE802154", "wlock-AF_CAIF" , "wlock-AF_ALG" ,
  266. "wlock-AF_NFC" , "wlock-AF_VSOCK" , "wlock-AF_KCM" ,
  267. "wlock-AF_QIPCRTR", "wlock-AF_SMC" , "wlock-AF_XDP" ,
  268. "wlock-AF_MAX"
  269. };
  270. static const char *const af_family_elock_key_strings[AF_MAX+1] = {
  271. "elock-AF_UNSPEC", "elock-AF_UNIX" , "elock-AF_INET" ,
  272. "elock-AF_AX25" , "elock-AF_IPX" , "elock-AF_APPLETALK",
  273. "elock-AF_NETROM", "elock-AF_BRIDGE" , "elock-AF_ATMPVC" ,
  274. "elock-AF_X25" , "elock-AF_INET6" , "elock-AF_ROSE" ,
  275. "elock-AF_DECnet", "elock-AF_NETBEUI" , "elock-AF_SECURITY" ,
  276. "elock-AF_KEY" , "elock-AF_NETLINK" , "elock-AF_PACKET" ,
  277. "elock-AF_ASH" , "elock-AF_ECONET" , "elock-AF_ATMSVC" ,
  278. "elock-AF_RDS" , "elock-AF_SNA" , "elock-AF_IRDA" ,
  279. "elock-AF_PPPOX" , "elock-AF_WANPIPE" , "elock-AF_LLC" ,
  280. "elock-27" , "elock-28" , "elock-AF_CAN" ,
  281. "elock-AF_TIPC" , "elock-AF_BLUETOOTH", "elock-AF_IUCV" ,
  282. "elock-AF_RXRPC" , "elock-AF_ISDN" , "elock-AF_PHONET" ,
  283. "elock-AF_IEEE802154", "elock-AF_CAIF" , "elock-AF_ALG" ,
  284. "elock-AF_NFC" , "elock-AF_VSOCK" , "elock-AF_KCM" ,
  285. "elock-AF_QIPCRTR", "elock-AF_SMC" , "elock-AF_XDP" ,
  286. "elock-AF_MAX"
  287. };
  288. /*
  289. * sk_callback_lock and sk queues locking rules are per-address-family,
  290. * so split the lock classes by using a per-AF key:
  291. */
  292. static struct lock_class_key af_callback_keys[AF_MAX];
  293. static struct lock_class_key af_rlock_keys[AF_MAX];
  294. static struct lock_class_key af_wlock_keys[AF_MAX];
  295. static struct lock_class_key af_elock_keys[AF_MAX];
  296. static struct lock_class_key af_kern_callback_keys[AF_MAX];
  297. /* Run time adjustable parameters. */
  298. __u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
  299. EXPORT_SYMBOL(sysctl_wmem_max);
  300. __u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
  301. EXPORT_SYMBOL(sysctl_rmem_max);
  302. __u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
  303. __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
  304. /* Maximal space eaten by iovec or ancillary data plus some space */
  305. int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
  306. EXPORT_SYMBOL(sysctl_optmem_max);
  307. int sysctl_tstamp_allow_data __read_mostly = 1;
  308. DEFINE_STATIC_KEY_FALSE(memalloc_socks_key);
  309. EXPORT_SYMBOL_GPL(memalloc_socks_key);
  310. /**
  311. * sk_set_memalloc - sets %SOCK_MEMALLOC
  312. * @sk: socket to set it on
  313. *
  314. * Set %SOCK_MEMALLOC on a socket for access to emergency reserves.
  315. * It's the responsibility of the admin to adjust min_free_kbytes
  316. * to meet the requirements
  317. */
  318. void sk_set_memalloc(struct sock *sk)
  319. {
  320. sock_set_flag(sk, SOCK_MEMALLOC);
  321. sk->sk_allocation |= __GFP_MEMALLOC;
  322. static_branch_inc(&memalloc_socks_key);
  323. }
  324. EXPORT_SYMBOL_GPL(sk_set_memalloc);
  325. void sk_clear_memalloc(struct sock *sk)
  326. {
  327. sock_reset_flag(sk, SOCK_MEMALLOC);
  328. sk->sk_allocation &= ~__GFP_MEMALLOC;
  329. static_branch_dec(&memalloc_socks_key);
  330. /*
  331. * SOCK_MEMALLOC is allowed to ignore rmem limits to ensure forward
  332. * progress of swapping. SOCK_MEMALLOC may be cleared while
  333. * it has rmem allocations due to the last swapfile being deactivated
  334. * but there is a risk that the socket is unusable due to exceeding
  335. * the rmem limits. Reclaim the reserves and obey rmem limits again.
  336. */
  337. sk_mem_reclaim(sk);
  338. }
  339. EXPORT_SYMBOL_GPL(sk_clear_memalloc);
  340. int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
  341. {
  342. int ret;
  343. unsigned int noreclaim_flag;
  344. /* these should have been dropped before queueing */
  345. BUG_ON(!sock_flag(sk, SOCK_MEMALLOC));
  346. noreclaim_flag = memalloc_noreclaim_save();
  347. ret = sk->sk_backlog_rcv(sk, skb);
  348. memalloc_noreclaim_restore(noreclaim_flag);
  349. return ret;
  350. }
  351. EXPORT_SYMBOL(__sk_backlog_rcv);
  352. static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
  353. {
  354. struct timeval tv;
  355. if (optlen < sizeof(tv))
  356. return -EINVAL;
  357. if (copy_from_user(&tv, optval, sizeof(tv)))
  358. return -EFAULT;
  359. if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
  360. return -EDOM;
  361. if (tv.tv_sec < 0) {
  362. static int warned __read_mostly;
  363. *timeo_p = 0;
  364. if (warned < 10 && net_ratelimit()) {
  365. warned++;
  366. pr_info("%s: `%s' (pid %d) tries to set negative timeout\n",
  367. __func__, current->comm, task_pid_nr(current));
  368. }
  369. return 0;
  370. }
  371. *timeo_p = MAX_SCHEDULE_TIMEOUT;
  372. if (tv.tv_sec == 0 && tv.tv_usec == 0)
  373. return 0;
  374. if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
  375. *timeo_p = tv.tv_sec * HZ + DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC / HZ);
  376. return 0;
  377. }
  378. static void sock_warn_obsolete_bsdism(const char *name)
  379. {
  380. static int warned;
  381. static char warncomm[TASK_COMM_LEN];
  382. if (strcmp(warncomm, current->comm) && warned < 5) {
  383. strcpy(warncomm, current->comm);
  384. pr_warn("process `%s' is using obsolete %s SO_BSDCOMPAT\n",
  385. warncomm, name);
  386. warned++;
  387. }
  388. }
  389. static bool sock_needs_netstamp(const struct sock *sk)
  390. {
  391. switch (sk->sk_family) {
  392. case AF_UNSPEC:
  393. case AF_UNIX:
  394. return false;
  395. default:
  396. return true;
  397. }
  398. }
  399. static void sock_disable_timestamp(struct sock *sk, unsigned long flags)
  400. {
  401. if (sk->sk_flags & flags) {
  402. sk->sk_flags &= ~flags;
  403. if (sock_needs_netstamp(sk) &&
  404. !(sk->sk_flags & SK_FLAGS_TIMESTAMP))
  405. net_disable_timestamp();
  406. }
  407. }
  408. int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  409. {
  410. unsigned long flags;
  411. struct sk_buff_head *list = &sk->sk_receive_queue;
  412. if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {
  413. atomic_inc(&sk->sk_drops);
  414. trace_sock_rcvqueue_full(sk, skb);
  415. return -ENOMEM;
  416. }
  417. if (!sk_rmem_schedule(sk, skb, skb->truesize)) {
  418. atomic_inc(&sk->sk_drops);
  419. return -ENOBUFS;
  420. }
  421. skb->dev = NULL;
  422. skb_set_owner_r(skb, sk);
  423. /* we escape from rcu protected region, make sure we dont leak
  424. * a norefcounted dst
  425. */
  426. skb_dst_force(skb);
  427. spin_lock_irqsave(&list->lock, flags);
  428. sock_skb_set_dropcount(sk, skb);
  429. __skb_queue_tail(list, skb);
  430. spin_unlock_irqrestore(&list->lock, flags);
  431. if (!sock_flag(sk, SOCK_DEAD))
  432. sk->sk_data_ready(sk);
  433. return 0;
  434. }
  435. EXPORT_SYMBOL(__sock_queue_rcv_skb);
  436. int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  437. {
  438. int err;
  439. err = sk_filter(sk, skb);
  440. if (err)
  441. return err;
  442. return __sock_queue_rcv_skb(sk, skb);
  443. }
  444. EXPORT_SYMBOL(sock_queue_rcv_skb);
  445. int __sk_receive_skb(struct sock *sk, struct sk_buff *skb,
  446. const int nested, unsigned int trim_cap, bool refcounted)
  447. {
  448. int rc = NET_RX_SUCCESS;
  449. if (sk_filter_trim_cap(sk, skb, trim_cap))
  450. goto discard_and_relse;
  451. skb->dev = NULL;
  452. if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
  453. atomic_inc(&sk->sk_drops);
  454. goto discard_and_relse;
  455. }
  456. if (nested)
  457. bh_lock_sock_nested(sk);
  458. else
  459. bh_lock_sock(sk);
  460. if (!sock_owned_by_user(sk)) {
  461. /*
  462. * trylock + unlock semantics:
  463. */
  464. mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
  465. rc = sk_backlog_rcv(sk, skb);
  466. mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
  467. } else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
  468. bh_unlock_sock(sk);
  469. atomic_inc(&sk->sk_drops);
  470. goto discard_and_relse;
  471. }
  472. bh_unlock_sock(sk);
  473. out:
  474. if (refcounted)
  475. sock_put(sk);
  476. return rc;
  477. discard_and_relse:
  478. kfree_skb(skb);
  479. goto out;
  480. }
  481. EXPORT_SYMBOL(__sk_receive_skb);
  482. struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
  483. {
  484. struct dst_entry *dst = __sk_dst_get(sk);
  485. if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
  486. sk_tx_queue_clear(sk);
  487. sk->sk_dst_pending_confirm = 0;
  488. RCU_INIT_POINTER(sk->sk_dst_cache, NULL);
  489. dst_release(dst);
  490. return NULL;
  491. }
  492. return dst;
  493. }
  494. EXPORT_SYMBOL(__sk_dst_check);
  495. struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
  496. {
  497. struct dst_entry *dst = sk_dst_get(sk);
  498. if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
  499. sk_dst_reset(sk);
  500. dst_release(dst);
  501. return NULL;
  502. }
  503. return dst;
  504. }
  505. EXPORT_SYMBOL(sk_dst_check);
  506. static int sock_setbindtodevice(struct sock *sk, char __user *optval,
  507. int optlen)
  508. {
  509. int ret = -ENOPROTOOPT;
  510. #ifdef CONFIG_NETDEVICES
  511. struct net *net = sock_net(sk);
  512. char devname[IFNAMSIZ];
  513. int index;
  514. /* Sorry... */
  515. ret = -EPERM;
  516. if (!ns_capable(net->user_ns, CAP_NET_RAW))
  517. goto out;
  518. ret = -EINVAL;
  519. if (optlen < 0)
  520. goto out;
  521. /* Bind this socket to a particular device like "eth0",
  522. * as specified in the passed interface name. If the
  523. * name is "" or the option length is zero the socket
  524. * is not bound.
  525. */
  526. if (optlen > IFNAMSIZ - 1)
  527. optlen = IFNAMSIZ - 1;
  528. memset(devname, 0, sizeof(devname));
  529. ret = -EFAULT;
  530. if (copy_from_user(devname, optval, optlen))
  531. goto out;
  532. index = 0;
  533. if (devname[0] != '\0') {
  534. struct net_device *dev;
  535. rcu_read_lock();
  536. dev = dev_get_by_name_rcu(net, devname);
  537. if (dev)
  538. index = dev->ifindex;
  539. rcu_read_unlock();
  540. ret = -ENODEV;
  541. if (!dev)
  542. goto out;
  543. }
  544. lock_sock(sk);
  545. sk->sk_bound_dev_if = index;
  546. sk_dst_reset(sk);
  547. release_sock(sk);
  548. ret = 0;
  549. out:
  550. #endif
  551. return ret;
  552. }
  553. static int sock_getbindtodevice(struct sock *sk, char __user *optval,
  554. int __user *optlen, int len)
  555. {
  556. int ret = -ENOPROTOOPT;
  557. #ifdef CONFIG_NETDEVICES
  558. struct net *net = sock_net(sk);
  559. char devname[IFNAMSIZ];
  560. if (sk->sk_bound_dev_if == 0) {
  561. len = 0;
  562. goto zero;
  563. }
  564. ret = -EINVAL;
  565. if (len < IFNAMSIZ)
  566. goto out;
  567. ret = netdev_get_name(net, devname, sk->sk_bound_dev_if);
  568. if (ret)
  569. goto out;
  570. len = strlen(devname) + 1;
  571. ret = -EFAULT;
  572. if (copy_to_user(optval, devname, len))
  573. goto out;
  574. zero:
  575. ret = -EFAULT;
  576. if (put_user(len, optlen))
  577. goto out;
  578. ret = 0;
  579. out:
  580. #endif
  581. return ret;
  582. }
  583. static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
  584. {
  585. if (valbool)
  586. sock_set_flag(sk, bit);
  587. else
  588. sock_reset_flag(sk, bit);
  589. }
  590. bool sk_mc_loop(struct sock *sk)
  591. {
  592. if (dev_recursion_level())
  593. return false;
  594. if (!sk)
  595. return true;
  596. switch (sk->sk_family) {
  597. case AF_INET:
  598. return inet_sk(sk)->mc_loop;
  599. #if IS_ENABLED(CONFIG_IPV6)
  600. case AF_INET6:
  601. return inet6_sk(sk)->mc_loop;
  602. #endif
  603. }
  604. WARN_ON(1);
  605. return true;
  606. }
  607. EXPORT_SYMBOL(sk_mc_loop);
  608. /*
  609. * This is meant for all protocols to use and covers goings on
  610. * at the socket level. Everything here is generic.
  611. */
  612. int sock_setsockopt(struct socket *sock, int level, int optname,
  613. char __user *optval, unsigned int optlen)
  614. {
  615. struct sock *sk = sock->sk;
  616. int val;
  617. int valbool;
  618. struct linger ling;
  619. int ret = 0;
  620. /*
  621. * Options without arguments
  622. */
  623. if (optname == SO_BINDTODEVICE)
  624. return sock_setbindtodevice(sk, optval, optlen);
  625. if (optlen < sizeof(int))
  626. return -EINVAL;
  627. if (get_user(val, (int __user *)optval))
  628. return -EFAULT;
  629. valbool = val ? 1 : 0;
  630. lock_sock(sk);
  631. switch (optname) {
  632. case SO_DEBUG:
  633. if (val && !capable(CAP_NET_ADMIN))
  634. ret = -EACCES;
  635. else
  636. sock_valbool_flag(sk, SOCK_DBG, valbool);
  637. break;
  638. case SO_REUSEADDR:
  639. sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
  640. break;
  641. case SO_REUSEPORT:
  642. sk->sk_reuseport = valbool;
  643. break;
  644. case SO_TYPE:
  645. case SO_PROTOCOL:
  646. case SO_DOMAIN:
  647. case SO_ERROR:
  648. ret = -ENOPROTOOPT;
  649. break;
  650. case SO_DONTROUTE:
  651. sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
  652. break;
  653. case SO_BROADCAST:
  654. sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
  655. break;
  656. case SO_SNDBUF:
  657. /* Don't error on this BSD doesn't and if you think
  658. * about it this is right. Otherwise apps have to
  659. * play 'guess the biggest size' games. RCVBUF/SNDBUF
  660. * are treated in BSD as hints
  661. */
  662. val = min_t(u32, val, sysctl_wmem_max);
  663. set_sndbuf:
  664. sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
  665. sk->sk_sndbuf = max_t(int, val * 2, SOCK_MIN_SNDBUF);
  666. /* Wake up sending tasks if we upped the value. */
  667. sk->sk_write_space(sk);
  668. break;
  669. case SO_SNDBUFFORCE:
  670. if (!capable(CAP_NET_ADMIN)) {
  671. ret = -EPERM;
  672. break;
  673. }
  674. goto set_sndbuf;
  675. case SO_RCVBUF:
  676. /* Don't error on this BSD doesn't and if you think
  677. * about it this is right. Otherwise apps have to
  678. * play 'guess the biggest size' games. RCVBUF/SNDBUF
  679. * are treated in BSD as hints
  680. */
  681. val = min_t(u32, val, sysctl_rmem_max);
  682. set_rcvbuf:
  683. sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
  684. /*
  685. * We double it on the way in to account for
  686. * "struct sk_buff" etc. overhead. Applications
  687. * assume that the SO_RCVBUF setting they make will
  688. * allow that much actual data to be received on that
  689. * socket.
  690. *
  691. * Applications are unaware that "struct sk_buff" and
  692. * other overheads allocate from the receive buffer
  693. * during socket buffer allocation.
  694. *
  695. * And after considering the possible alternatives,
  696. * returning the value we actually used in getsockopt
  697. * is the most desirable behavior.
  698. */
  699. sk->sk_rcvbuf = max_t(int, val * 2, SOCK_MIN_RCVBUF);
  700. break;
  701. case SO_RCVBUFFORCE:
  702. if (!capable(CAP_NET_ADMIN)) {
  703. ret = -EPERM;
  704. break;
  705. }
  706. goto set_rcvbuf;
  707. case SO_KEEPALIVE:
  708. if (sk->sk_prot->keepalive)
  709. sk->sk_prot->keepalive(sk, valbool);
  710. sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
  711. break;
  712. case SO_OOBINLINE:
  713. sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
  714. break;
  715. case SO_NO_CHECK:
  716. sk->sk_no_check_tx = valbool;
  717. break;
  718. case SO_PRIORITY:
  719. if ((val >= 0 && val <= 6) ||
  720. ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
  721. sk->sk_priority = val;
  722. else
  723. ret = -EPERM;
  724. break;
  725. case SO_LINGER:
  726. if (optlen < sizeof(ling)) {
  727. ret = -EINVAL; /* 1003.1g */
  728. break;
  729. }
  730. if (copy_from_user(&ling, optval, sizeof(ling))) {
  731. ret = -EFAULT;
  732. break;
  733. }
  734. if (!ling.l_onoff)
  735. sock_reset_flag(sk, SOCK_LINGER);
  736. else {
  737. #if (BITS_PER_LONG == 32)
  738. if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
  739. sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
  740. else
  741. #endif
  742. sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
  743. sock_set_flag(sk, SOCK_LINGER);
  744. }
  745. break;
  746. case SO_BSDCOMPAT:
  747. sock_warn_obsolete_bsdism("setsockopt");
  748. break;
  749. case SO_PASSCRED:
  750. if (valbool)
  751. set_bit(SOCK_PASSCRED, &sock->flags);
  752. else
  753. clear_bit(SOCK_PASSCRED, &sock->flags);
  754. break;
  755. case SO_TIMESTAMP:
  756. case SO_TIMESTAMPNS:
  757. if (valbool) {
  758. if (optname == SO_TIMESTAMP)
  759. sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
  760. else
  761. sock_set_flag(sk, SOCK_RCVTSTAMPNS);
  762. sock_set_flag(sk, SOCK_RCVTSTAMP);
  763. sock_enable_timestamp(sk, SOCK_TIMESTAMP);
  764. } else {
  765. sock_reset_flag(sk, SOCK_RCVTSTAMP);
  766. sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
  767. }
  768. break;
  769. case SO_TIMESTAMPING:
  770. if (val & ~SOF_TIMESTAMPING_MASK) {
  771. ret = -EINVAL;
  772. break;
  773. }
  774. if (val & SOF_TIMESTAMPING_OPT_ID &&
  775. !(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)) {
  776. if (sk->sk_protocol == IPPROTO_TCP &&
  777. sk->sk_type == SOCK_STREAM) {
  778. if ((1 << sk->sk_state) &
  779. (TCPF_CLOSE | TCPF_LISTEN)) {
  780. ret = -EINVAL;
  781. break;
  782. }
  783. sk->sk_tskey = tcp_sk(sk)->snd_una;
  784. } else {
  785. sk->sk_tskey = 0;
  786. }
  787. }
  788. if (val & SOF_TIMESTAMPING_OPT_STATS &&
  789. !(val & SOF_TIMESTAMPING_OPT_TSONLY)) {
  790. ret = -EINVAL;
  791. break;
  792. }
  793. sk->sk_tsflags = val;
  794. if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
  795. sock_enable_timestamp(sk,
  796. SOCK_TIMESTAMPING_RX_SOFTWARE);
  797. else
  798. sock_disable_timestamp(sk,
  799. (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
  800. break;
  801. case SO_RCVLOWAT:
  802. if (val < 0)
  803. val = INT_MAX;
  804. if (sock->ops->set_rcvlowat)
  805. ret = sock->ops->set_rcvlowat(sk, val);
  806. else
  807. sk->sk_rcvlowat = val ? : 1;
  808. break;
  809. case SO_RCVTIMEO:
  810. ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
  811. break;
  812. case SO_SNDTIMEO:
  813. ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
  814. break;
  815. case SO_ATTACH_FILTER:
  816. ret = -EINVAL;
  817. if (optlen == sizeof(struct sock_fprog)) {
  818. struct sock_fprog fprog;
  819. ret = -EFAULT;
  820. if (copy_from_user(&fprog, optval, sizeof(fprog)))
  821. break;
  822. ret = sk_attach_filter(&fprog, sk);
  823. }
  824. break;
  825. case SO_ATTACH_BPF:
  826. ret = -EINVAL;
  827. if (optlen == sizeof(u32)) {
  828. u32 ufd;
  829. ret = -EFAULT;
  830. if (copy_from_user(&ufd, optval, sizeof(ufd)))
  831. break;
  832. ret = sk_attach_bpf(ufd, sk);
  833. }
  834. break;
  835. case SO_ATTACH_REUSEPORT_CBPF:
  836. ret = -EINVAL;
  837. if (optlen == sizeof(struct sock_fprog)) {
  838. struct sock_fprog fprog;
  839. ret = -EFAULT;
  840. if (copy_from_user(&fprog, optval, sizeof(fprog)))
  841. break;
  842. ret = sk_reuseport_attach_filter(&fprog, sk);
  843. }
  844. break;
  845. case SO_ATTACH_REUSEPORT_EBPF:
  846. ret = -EINVAL;
  847. if (optlen == sizeof(u32)) {
  848. u32 ufd;
  849. ret = -EFAULT;
  850. if (copy_from_user(&ufd, optval, sizeof(ufd)))
  851. break;
  852. ret = sk_reuseport_attach_bpf(ufd, sk);
  853. }
  854. break;
  855. case SO_DETACH_FILTER:
  856. ret = sk_detach_filter(sk);
  857. break;
  858. case SO_LOCK_FILTER:
  859. if (sock_flag(sk, SOCK_FILTER_LOCKED) && !valbool)
  860. ret = -EPERM;
  861. else
  862. sock_valbool_flag(sk, SOCK_FILTER_LOCKED, valbool);
  863. break;
  864. case SO_PASSSEC:
  865. if (valbool)
  866. set_bit(SOCK_PASSSEC, &sock->flags);
  867. else
  868. clear_bit(SOCK_PASSSEC, &sock->flags);
  869. break;
  870. case SO_MARK:
  871. if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
  872. ret = -EPERM;
  873. else
  874. sk->sk_mark = val;
  875. break;
  876. case SO_RXQ_OVFL:
  877. sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
  878. break;
  879. case SO_WIFI_STATUS:
  880. sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
  881. break;
  882. case SO_PEEK_OFF:
  883. if (sock->ops->set_peek_off)
  884. ret = sock->ops->set_peek_off(sk, val);
  885. else
  886. ret = -EOPNOTSUPP;
  887. break;
  888. case SO_NOFCS:
  889. sock_valbool_flag(sk, SOCK_NOFCS, valbool);
  890. break;
  891. case SO_SELECT_ERR_QUEUE:
  892. sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
  893. break;
  894. #ifdef CONFIG_NET_RX_BUSY_POLL
  895. case SO_BUSY_POLL:
  896. /* allow unprivileged users to decrease the value */
  897. if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
  898. ret = -EPERM;
  899. else {
  900. if (val < 0)
  901. ret = -EINVAL;
  902. else
  903. sk->sk_ll_usec = val;
  904. }
  905. break;
  906. #endif
  907. case SO_MAX_PACING_RATE:
  908. if (val != ~0U)
  909. cmpxchg(&sk->sk_pacing_status,
  910. SK_PACING_NONE,
  911. SK_PACING_NEEDED);
  912. sk->sk_max_pacing_rate = val;
  913. sk->sk_pacing_rate = min(sk->sk_pacing_rate,
  914. sk->sk_max_pacing_rate);
  915. break;
  916. case SO_INCOMING_CPU:
  917. sk->sk_incoming_cpu = val;
  918. break;
  919. case SO_CNX_ADVICE:
  920. if (val == 1)
  921. dst_negative_advice(sk);
  922. break;
  923. case SO_ZEROCOPY:
  924. if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6) {
  925. if (sk->sk_protocol != IPPROTO_TCP)
  926. ret = -ENOTSUPP;
  927. } else if (sk->sk_family != PF_RDS) {
  928. ret = -ENOTSUPP;
  929. }
  930. if (!ret) {
  931. if (val < 0 || val > 1)
  932. ret = -EINVAL;
  933. else
  934. sock_valbool_flag(sk, SOCK_ZEROCOPY, valbool);
  935. }
  936. break;
  937. default:
  938. ret = -ENOPROTOOPT;
  939. break;
  940. }
  941. release_sock(sk);
  942. return ret;
  943. }
  944. EXPORT_SYMBOL(sock_setsockopt);
  945. static void cred_to_ucred(struct pid *pid, const struct cred *cred,
  946. struct ucred *ucred)
  947. {
  948. ucred->pid = pid_vnr(pid);
  949. ucred->uid = ucred->gid = -1;
  950. if (cred) {
  951. struct user_namespace *current_ns = current_user_ns();
  952. ucred->uid = from_kuid_munged(current_ns, cred->euid);
  953. ucred->gid = from_kgid_munged(current_ns, cred->egid);
  954. }
  955. }
  956. static int groups_to_user(gid_t __user *dst, const struct group_info *src)
  957. {
  958. struct user_namespace *user_ns = current_user_ns();
  959. int i;
  960. for (i = 0; i < src->ngroups; i++)
  961. if (put_user(from_kgid_munged(user_ns, src->gid[i]), dst + i))
  962. return -EFAULT;
  963. return 0;
  964. }
  965. int sock_getsockopt(struct socket *sock, int level, int optname,
  966. char __user *optval, int __user *optlen)
  967. {
  968. struct sock *sk = sock->sk;
  969. union {
  970. int val;
  971. u64 val64;
  972. struct linger ling;
  973. struct timeval tm;
  974. } v;
  975. int lv = sizeof(int);
  976. int len;
  977. if (get_user(len, optlen))
  978. return -EFAULT;
  979. if (len < 0)
  980. return -EINVAL;
  981. memset(&v, 0, sizeof(v));
  982. switch (optname) {
  983. case SO_DEBUG:
  984. v.val = sock_flag(sk, SOCK_DBG);
  985. break;
  986. case SO_DONTROUTE:
  987. v.val = sock_flag(sk, SOCK_LOCALROUTE);
  988. break;
  989. case SO_BROADCAST:
  990. v.val = sock_flag(sk, SOCK_BROADCAST);
  991. break;
  992. case SO_SNDBUF:
  993. v.val = sk->sk_sndbuf;
  994. break;
  995. case SO_RCVBUF:
  996. v.val = sk->sk_rcvbuf;
  997. break;
  998. case SO_REUSEADDR:
  999. v.val = sk->sk_reuse;
  1000. break;
  1001. case SO_REUSEPORT:
  1002. v.val = sk->sk_reuseport;
  1003. break;
  1004. case SO_KEEPALIVE:
  1005. v.val = sock_flag(sk, SOCK_KEEPOPEN);
  1006. break;
  1007. case SO_TYPE:
  1008. v.val = sk->sk_type;
  1009. break;
  1010. case SO_PROTOCOL:
  1011. v.val = sk->sk_protocol;
  1012. break;
  1013. case SO_DOMAIN:
  1014. v.val = sk->sk_family;
  1015. break;
  1016. case SO_ERROR:
  1017. v.val = -sock_error(sk);
  1018. if (v.val == 0)
  1019. v.val = xchg(&sk->sk_err_soft, 0);
  1020. break;
  1021. case SO_OOBINLINE:
  1022. v.val = sock_flag(sk, SOCK_URGINLINE);
  1023. break;
  1024. case SO_NO_CHECK:
  1025. v.val = sk->sk_no_check_tx;
  1026. break;
  1027. case SO_PRIORITY:
  1028. v.val = sk->sk_priority;
  1029. break;
  1030. case SO_LINGER:
  1031. lv = sizeof(v.ling);
  1032. v.ling.l_onoff = sock_flag(sk, SOCK_LINGER);
  1033. v.ling.l_linger = sk->sk_lingertime / HZ;
  1034. break;
  1035. case SO_BSDCOMPAT:
  1036. sock_warn_obsolete_bsdism("getsockopt");
  1037. break;
  1038. case SO_TIMESTAMP:
  1039. v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
  1040. !sock_flag(sk, SOCK_RCVTSTAMPNS);
  1041. break;
  1042. case SO_TIMESTAMPNS:
  1043. v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
  1044. break;
  1045. case SO_TIMESTAMPING:
  1046. v.val = sk->sk_tsflags;
  1047. break;
  1048. case SO_RCVTIMEO:
  1049. lv = sizeof(struct timeval);
  1050. if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
  1051. v.tm.tv_sec = 0;
  1052. v.tm.tv_usec = 0;
  1053. } else {
  1054. v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
  1055. v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * USEC_PER_SEC) / HZ;
  1056. }
  1057. break;
  1058. case SO_SNDTIMEO:
  1059. lv = sizeof(struct timeval);
  1060. if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
  1061. v.tm.tv_sec = 0;
  1062. v.tm.tv_usec = 0;
  1063. } else {
  1064. v.tm.tv_sec = sk->sk_sndtimeo / HZ;
  1065. v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * USEC_PER_SEC) / HZ;
  1066. }
  1067. break;
  1068. case SO_RCVLOWAT:
  1069. v.val = sk->sk_rcvlowat;
  1070. break;
  1071. case SO_SNDLOWAT:
  1072. v.val = 1;
  1073. break;
  1074. case SO_PASSCRED:
  1075. v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
  1076. break;
  1077. case SO_PEERCRED:
  1078. {
  1079. struct ucred peercred;
  1080. if (len > sizeof(peercred))
  1081. len = sizeof(peercred);
  1082. cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
  1083. if (copy_to_user(optval, &peercred, len))
  1084. return -EFAULT;
  1085. goto lenout;
  1086. }
  1087. case SO_PEERGROUPS:
  1088. {
  1089. int ret, n;
  1090. if (!sk->sk_peer_cred)
  1091. return -ENODATA;
  1092. n = sk->sk_peer_cred->group_info->ngroups;
  1093. if (len < n * sizeof(gid_t)) {
  1094. len = n * sizeof(gid_t);
  1095. return put_user(len, optlen) ? -EFAULT : -ERANGE;
  1096. }
  1097. len = n * sizeof(gid_t);
  1098. ret = groups_to_user((gid_t __user *)optval,
  1099. sk->sk_peer_cred->group_info);
  1100. if (ret)
  1101. return ret;
  1102. goto lenout;
  1103. }
  1104. case SO_PEERNAME:
  1105. {
  1106. char address[128];
  1107. lv = sock->ops->getname(sock, (struct sockaddr *)address, 2);
  1108. if (lv < 0)
  1109. return -ENOTCONN;
  1110. if (lv < len)
  1111. return -EINVAL;
  1112. if (copy_to_user(optval, address, len))
  1113. return -EFAULT;
  1114. goto lenout;
  1115. }
  1116. /* Dubious BSD thing... Probably nobody even uses it, but
  1117. * the UNIX standard wants it for whatever reason... -DaveM
  1118. */
  1119. case SO_ACCEPTCONN:
  1120. v.val = sk->sk_state == TCP_LISTEN;
  1121. break;
  1122. case SO_PASSSEC:
  1123. v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
  1124. break;
  1125. case SO_PEERSEC:
  1126. return security_socket_getpeersec_stream(sock, optval, optlen, len);
  1127. case SO_MARK:
  1128. v.val = sk->sk_mark;
  1129. break;
  1130. case SO_RXQ_OVFL:
  1131. v.val = sock_flag(sk, SOCK_RXQ_OVFL);
  1132. break;
  1133. case SO_WIFI_STATUS:
  1134. v.val = sock_flag(sk, SOCK_WIFI_STATUS);
  1135. break;
  1136. case SO_PEEK_OFF:
  1137. if (!sock->ops->set_peek_off)
  1138. return -EOPNOTSUPP;
  1139. v.val = sk->sk_peek_off;
  1140. break;
  1141. case SO_NOFCS:
  1142. v.val = sock_flag(sk, SOCK_NOFCS);
  1143. break;
  1144. case SO_BINDTODEVICE:
  1145. return sock_getbindtodevice(sk, optval, optlen, len);
  1146. case SO_GET_FILTER:
  1147. len = sk_get_filter(sk, (struct sock_filter __user *)optval, len);
  1148. if (len < 0)
  1149. return len;
  1150. goto lenout;
  1151. case SO_LOCK_FILTER:
  1152. v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
  1153. break;
  1154. case SO_BPF_EXTENSIONS:
  1155. v.val = bpf_tell_extensions();
  1156. break;
  1157. case SO_SELECT_ERR_QUEUE:
  1158. v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
  1159. break;
  1160. #ifdef CONFIG_NET_RX_BUSY_POLL
  1161. case SO_BUSY_POLL:
  1162. v.val = sk->sk_ll_usec;
  1163. break;
  1164. #endif
  1165. case SO_MAX_PACING_RATE:
  1166. v.val = sk->sk_max_pacing_rate;
  1167. break;
  1168. case SO_INCOMING_CPU:
  1169. v.val = sk->sk_incoming_cpu;
  1170. break;
  1171. case SO_MEMINFO:
  1172. {
  1173. u32 meminfo[SK_MEMINFO_VARS];
  1174. if (get_user(len, optlen))
  1175. return -EFAULT;
  1176. sk_get_meminfo(sk, meminfo);
  1177. len = min_t(unsigned int, len, sizeof(meminfo));
  1178. if (copy_to_user(optval, &meminfo, len))
  1179. return -EFAULT;
  1180. goto lenout;
  1181. }
  1182. #ifdef CONFIG_NET_RX_BUSY_POLL
  1183. case SO_INCOMING_NAPI_ID:
  1184. v.val = READ_ONCE(sk->sk_napi_id);
  1185. /* aggregate non-NAPI IDs down to 0 */
  1186. if (v.val < MIN_NAPI_ID)
  1187. v.val = 0;
  1188. break;
  1189. #endif
  1190. case SO_COOKIE:
  1191. lv = sizeof(u64);
  1192. if (len < lv)
  1193. return -EINVAL;
  1194. v.val64 = sock_gen_cookie(sk);
  1195. break;
  1196. case SO_ZEROCOPY:
  1197. v.val = sock_flag(sk, SOCK_ZEROCOPY);
  1198. break;
  1199. default:
  1200. /* We implement the SO_SNDLOWAT etc to not be settable
  1201. * (1003.1g 7).
  1202. */
  1203. return -ENOPROTOOPT;
  1204. }
  1205. if (len > lv)
  1206. len = lv;
  1207. if (copy_to_user(optval, &v, len))
  1208. return -EFAULT;
  1209. lenout:
  1210. if (put_user(len, optlen))
  1211. return -EFAULT;
  1212. return 0;
  1213. }
  1214. /*
  1215. * Initialize an sk_lock.
  1216. *
  1217. * (We also register the sk_lock with the lock validator.)
  1218. */
  1219. static inline void sock_lock_init(struct sock *sk)
  1220. {
  1221. if (sk->sk_kern_sock)
  1222. sock_lock_init_class_and_name(
  1223. sk,
  1224. af_family_kern_slock_key_strings[sk->sk_family],
  1225. af_family_kern_slock_keys + sk->sk_family,
  1226. af_family_kern_key_strings[sk->sk_family],
  1227. af_family_kern_keys + sk->sk_family);
  1228. else
  1229. sock_lock_init_class_and_name(
  1230. sk,
  1231. af_family_slock_key_strings[sk->sk_family],
  1232. af_family_slock_keys + sk->sk_family,
  1233. af_family_key_strings[sk->sk_family],
  1234. af_family_keys + sk->sk_family);
  1235. }
  1236. /*
  1237. * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
  1238. * even temporarly, because of RCU lookups. sk_node should also be left as is.
  1239. * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
  1240. */
  1241. static void sock_copy(struct sock *nsk, const struct sock *osk)
  1242. {
  1243. #ifdef CONFIG_SECURITY_NETWORK
  1244. void *sptr = nsk->sk_security;
  1245. #endif
  1246. memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
  1247. memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
  1248. osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
  1249. #ifdef CONFIG_SECURITY_NETWORK
  1250. nsk->sk_security = sptr;
  1251. security_sk_clone(osk, nsk);
  1252. #endif
  1253. }
  1254. static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
  1255. int family)
  1256. {
  1257. struct sock *sk;
  1258. struct kmem_cache *slab;
  1259. slab = prot->slab;
  1260. if (slab != NULL) {
  1261. sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
  1262. if (!sk)
  1263. return sk;
  1264. if (priority & __GFP_ZERO)
  1265. sk_prot_clear_nulls(sk, prot->obj_size);
  1266. } else
  1267. sk = kmalloc(prot->obj_size, priority);
  1268. if (sk != NULL) {
  1269. if (security_sk_alloc(sk, family, priority))
  1270. goto out_free;
  1271. if (!try_module_get(prot->owner))
  1272. goto out_free_sec;
  1273. sk_tx_queue_clear(sk);
  1274. }
  1275. return sk;
  1276. out_free_sec:
  1277. security_sk_free(sk);
  1278. out_free:
  1279. if (slab != NULL)
  1280. kmem_cache_free(slab, sk);
  1281. else
  1282. kfree(sk);
  1283. return NULL;
  1284. }
  1285. static void sk_prot_free(struct proto *prot, struct sock *sk)
  1286. {
  1287. struct kmem_cache *slab;
  1288. struct module *owner;
  1289. owner = prot->owner;
  1290. slab = prot->slab;
  1291. cgroup_sk_free(&sk->sk_cgrp_data);
  1292. mem_cgroup_sk_free(sk);
  1293. security_sk_free(sk);
  1294. if (slab != NULL)
  1295. kmem_cache_free(slab, sk);
  1296. else
  1297. kfree(sk);
  1298. module_put(owner);
  1299. }
  1300. /**
  1301. * sk_alloc - All socket objects are allocated here
  1302. * @net: the applicable net namespace
  1303. * @family: protocol family
  1304. * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
  1305. * @prot: struct proto associated with this new sock instance
  1306. * @kern: is this to be a kernel socket?
  1307. */
  1308. struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
  1309. struct proto *prot, int kern)
  1310. {
  1311. struct sock *sk;
  1312. sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
  1313. if (sk) {
  1314. sk->sk_family = family;
  1315. /*
  1316. * See comment in struct sock definition to understand
  1317. * why we need sk_prot_creator -acme
  1318. */
  1319. sk->sk_prot = sk->sk_prot_creator = prot;
  1320. sk->sk_kern_sock = kern;
  1321. sock_lock_init(sk);
  1322. sk->sk_net_refcnt = kern ? 0 : 1;
  1323. if (likely(sk->sk_net_refcnt)) {
  1324. get_net(net);
  1325. sock_inuse_add(net, 1);
  1326. }
  1327. sock_net_set(sk, net);
  1328. refcount_set(&sk->sk_wmem_alloc, 1);
  1329. mem_cgroup_sk_alloc(sk);
  1330. cgroup_sk_alloc(&sk->sk_cgrp_data);
  1331. sock_update_classid(&sk->sk_cgrp_data);
  1332. sock_update_netprioidx(&sk->sk_cgrp_data);
  1333. }
  1334. return sk;
  1335. }
  1336. EXPORT_SYMBOL(sk_alloc);
  1337. /* Sockets having SOCK_RCU_FREE will call this function after one RCU
  1338. * grace period. This is the case for UDP sockets and TCP listeners.
  1339. */
  1340. static void __sk_destruct(struct rcu_head *head)
  1341. {
  1342. struct sock *sk = container_of(head, struct sock, sk_rcu);
  1343. struct sk_filter *filter;
  1344. if (sk->sk_destruct)
  1345. sk->sk_destruct(sk);
  1346. filter = rcu_dereference_check(sk->sk_filter,
  1347. refcount_read(&sk->sk_wmem_alloc) == 0);
  1348. if (filter) {
  1349. sk_filter_uncharge(sk, filter);
  1350. RCU_INIT_POINTER(sk->sk_filter, NULL);
  1351. }
  1352. if (rcu_access_pointer(sk->sk_reuseport_cb))
  1353. reuseport_detach_sock(sk);
  1354. sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
  1355. if (atomic_read(&sk->sk_omem_alloc))
  1356. pr_debug("%s: optmem leakage (%d bytes) detected\n",
  1357. __func__, atomic_read(&sk->sk_omem_alloc));
  1358. if (sk->sk_frag.page) {
  1359. put_page(sk->sk_frag.page);
  1360. sk->sk_frag.page = NULL;
  1361. }
  1362. if (sk->sk_peer_cred)
  1363. put_cred(sk->sk_peer_cred);
  1364. put_pid(sk->sk_peer_pid);
  1365. if (likely(sk->sk_net_refcnt))
  1366. put_net(sock_net(sk));
  1367. sk_prot_free(sk->sk_prot_creator, sk);
  1368. }
  1369. void sk_destruct(struct sock *sk)
  1370. {
  1371. if (sock_flag(sk, SOCK_RCU_FREE))
  1372. call_rcu(&sk->sk_rcu, __sk_destruct);
  1373. else
  1374. __sk_destruct(&sk->sk_rcu);
  1375. }
  1376. static void __sk_free(struct sock *sk)
  1377. {
  1378. if (likely(sk->sk_net_refcnt))
  1379. sock_inuse_add(sock_net(sk), -1);
  1380. if (unlikely(sk->sk_net_refcnt && sock_diag_has_destroy_listeners(sk)))
  1381. sock_diag_broadcast_destroy(sk);
  1382. else
  1383. sk_destruct(sk);
  1384. }
  1385. void sk_free(struct sock *sk)
  1386. {
  1387. /*
  1388. * We subtract one from sk_wmem_alloc and can know if
  1389. * some packets are still in some tx queue.
  1390. * If not null, sock_wfree() will call __sk_free(sk) later
  1391. */
  1392. if (refcount_dec_and_test(&sk->sk_wmem_alloc))
  1393. __sk_free(sk);
  1394. }
  1395. EXPORT_SYMBOL(sk_free);
  1396. static void sk_init_common(struct sock *sk)
  1397. {
  1398. skb_queue_head_init(&sk->sk_receive_queue);
  1399. skb_queue_head_init(&sk->sk_write_queue);
  1400. skb_queue_head_init(&sk->sk_error_queue);
  1401. rwlock_init(&sk->sk_callback_lock);
  1402. lockdep_set_class_and_name(&sk->sk_receive_queue.lock,
  1403. af_rlock_keys + sk->sk_family,
  1404. af_family_rlock_key_strings[sk->sk_family]);
  1405. lockdep_set_class_and_name(&sk->sk_write_queue.lock,
  1406. af_wlock_keys + sk->sk_family,
  1407. af_family_wlock_key_strings[sk->sk_family]);
  1408. lockdep_set_class_and_name(&sk->sk_error_queue.lock,
  1409. af_elock_keys + sk->sk_family,
  1410. af_family_elock_key_strings[sk->sk_family]);
  1411. lockdep_set_class_and_name(&sk->sk_callback_lock,
  1412. af_callback_keys + sk->sk_family,
  1413. af_family_clock_key_strings[sk->sk_family]);
  1414. }
  1415. /**
  1416. * sk_clone_lock - clone a socket, and lock its clone
  1417. * @sk: the socket to clone
  1418. * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
  1419. *
  1420. * Caller must unlock socket even in error path (bh_unlock_sock(newsk))
  1421. */
  1422. struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
  1423. {
  1424. struct sock *newsk;
  1425. bool is_charged = true;
  1426. newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
  1427. if (newsk != NULL) {
  1428. struct sk_filter *filter;
  1429. sock_copy(newsk, sk);
  1430. newsk->sk_prot_creator = sk->sk_prot;
  1431. /* SANITY */
  1432. if (likely(newsk->sk_net_refcnt))
  1433. get_net(sock_net(newsk));
  1434. sk_node_init(&newsk->sk_node);
  1435. sock_lock_init(newsk);
  1436. bh_lock_sock(newsk);
  1437. newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
  1438. newsk->sk_backlog.len = 0;
  1439. atomic_set(&newsk->sk_rmem_alloc, 0);
  1440. /*
  1441. * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
  1442. */
  1443. refcount_set(&newsk->sk_wmem_alloc, 1);
  1444. atomic_set(&newsk->sk_omem_alloc, 0);
  1445. sk_init_common(newsk);
  1446. newsk->sk_dst_cache = NULL;
  1447. newsk->sk_dst_pending_confirm = 0;
  1448. newsk->sk_wmem_queued = 0;
  1449. newsk->sk_forward_alloc = 0;
  1450. atomic_set(&newsk->sk_drops, 0);
  1451. newsk->sk_send_head = NULL;
  1452. newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
  1453. atomic_set(&newsk->sk_zckey, 0);
  1454. sock_reset_flag(newsk, SOCK_DONE);
  1455. mem_cgroup_sk_alloc(newsk);
  1456. cgroup_sk_alloc(&newsk->sk_cgrp_data);
  1457. rcu_read_lock();
  1458. filter = rcu_dereference(sk->sk_filter);
  1459. if (filter != NULL)
  1460. /* though it's an empty new sock, the charging may fail
  1461. * if sysctl_optmem_max was changed between creation of
  1462. * original socket and cloning
  1463. */
  1464. is_charged = sk_filter_charge(newsk, filter);
  1465. RCU_INIT_POINTER(newsk->sk_filter, filter);
  1466. rcu_read_unlock();
  1467. if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk, sk))) {
  1468. /* We need to make sure that we don't uncharge the new
  1469. * socket if we couldn't charge it in the first place
  1470. * as otherwise we uncharge the parent's filter.
  1471. */
  1472. if (!is_charged)
  1473. RCU_INIT_POINTER(newsk->sk_filter, NULL);
  1474. sk_free_unlock_clone(newsk);
  1475. newsk = NULL;
  1476. goto out;
  1477. }
  1478. RCU_INIT_POINTER(newsk->sk_reuseport_cb, NULL);
  1479. newsk->sk_err = 0;
  1480. newsk->sk_err_soft = 0;
  1481. newsk->sk_priority = 0;
  1482. newsk->sk_incoming_cpu = raw_smp_processor_id();
  1483. atomic64_set(&newsk->sk_cookie, 0);
  1484. if (likely(newsk->sk_net_refcnt))
  1485. sock_inuse_add(sock_net(newsk), 1);
  1486. /*
  1487. * Before updating sk_refcnt, we must commit prior changes to memory
  1488. * (Documentation/RCU/rculist_nulls.txt for details)
  1489. */
  1490. smp_wmb();
  1491. refcount_set(&newsk->sk_refcnt, 2);
  1492. /*
  1493. * Increment the counter in the same struct proto as the master
  1494. * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
  1495. * is the same as sk->sk_prot->socks, as this field was copied
  1496. * with memcpy).
  1497. *
  1498. * This _changes_ the previous behaviour, where
  1499. * tcp_create_openreq_child always was incrementing the
  1500. * equivalent to tcp_prot->socks (inet_sock_nr), so this have
  1501. * to be taken into account in all callers. -acme
  1502. */
  1503. sk_refcnt_debug_inc(newsk);
  1504. sk_set_socket(newsk, NULL);
  1505. newsk->sk_wq = NULL;
  1506. if (newsk->sk_prot->sockets_allocated)
  1507. sk_sockets_allocated_inc(newsk);
  1508. if (sock_needs_netstamp(sk) &&
  1509. newsk->sk_flags & SK_FLAGS_TIMESTAMP)
  1510. net_enable_timestamp();
  1511. }
  1512. out:
  1513. return newsk;
  1514. }
  1515. EXPORT_SYMBOL_GPL(sk_clone_lock);
  1516. void sk_free_unlock_clone(struct sock *sk)
  1517. {
  1518. /* It is still raw copy of parent, so invalidate
  1519. * destructor and make plain sk_free() */
  1520. sk->sk_destruct = NULL;
  1521. bh_unlock_sock(sk);
  1522. sk_free(sk);
  1523. }
  1524. EXPORT_SYMBOL_GPL(sk_free_unlock_clone);
  1525. void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
  1526. {
  1527. u32 max_segs = 1;
  1528. sk_dst_set(sk, dst);
  1529. sk->sk_route_caps = dst->dev->features | sk->sk_route_forced_caps;
  1530. if (sk->sk_route_caps & NETIF_F_GSO)
  1531. sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
  1532. sk->sk_route_caps &= ~sk->sk_route_nocaps;
  1533. if (sk_can_gso(sk)) {
  1534. if (dst->header_len && !xfrm_dst_offload_ok(dst)) {
  1535. sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
  1536. } else {
  1537. sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
  1538. sk->sk_gso_max_size = dst->dev->gso_max_size;
  1539. max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
  1540. }
  1541. }
  1542. sk->sk_gso_max_segs = max_segs;
  1543. }
  1544. EXPORT_SYMBOL_GPL(sk_setup_caps);
  1545. /*
  1546. * Simple resource managers for sockets.
  1547. */
  1548. /*
  1549. * Write buffer destructor automatically called from kfree_skb.
  1550. */
  1551. void sock_wfree(struct sk_buff *skb)
  1552. {
  1553. struct sock *sk = skb->sk;
  1554. unsigned int len = skb->truesize;
  1555. if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
  1556. /*
  1557. * Keep a reference on sk_wmem_alloc, this will be released
  1558. * after sk_write_space() call
  1559. */
  1560. WARN_ON(refcount_sub_and_test(len - 1, &sk->sk_wmem_alloc));
  1561. sk->sk_write_space(sk);
  1562. len = 1;
  1563. }
  1564. /*
  1565. * if sk_wmem_alloc reaches 0, we must finish what sk_free()
  1566. * could not do because of in-flight packets
  1567. */
  1568. if (refcount_sub_and_test(len, &sk->sk_wmem_alloc))
  1569. __sk_free(sk);
  1570. }
  1571. EXPORT_SYMBOL(sock_wfree);
  1572. /* This variant of sock_wfree() is used by TCP,
  1573. * since it sets SOCK_USE_WRITE_QUEUE.
  1574. */
  1575. void __sock_wfree(struct sk_buff *skb)
  1576. {
  1577. struct sock *sk = skb->sk;
  1578. if (refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc))
  1579. __sk_free(sk);
  1580. }
  1581. void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
  1582. {
  1583. skb_orphan(skb);
  1584. skb->sk = sk;
  1585. #ifdef CONFIG_INET
  1586. if (unlikely(!sk_fullsock(sk))) {
  1587. skb->destructor = sock_edemux;
  1588. sock_hold(sk);
  1589. return;
  1590. }
  1591. #endif
  1592. skb->destructor = sock_wfree;
  1593. skb_set_hash_from_sk(skb, sk);
  1594. /*
  1595. * We used to take a refcount on sk, but following operation
  1596. * is enough to guarantee sk_free() wont free this sock until
  1597. * all in-flight packets are completed
  1598. */
  1599. refcount_add(skb->truesize, &sk->sk_wmem_alloc);
  1600. }
  1601. EXPORT_SYMBOL(skb_set_owner_w);
  1602. /* This helper is used by netem, as it can hold packets in its
  1603. * delay queue. We want to allow the owner socket to send more
  1604. * packets, as if they were already TX completed by a typical driver.
  1605. * But we also want to keep skb->sk set because some packet schedulers
  1606. * rely on it (sch_fq for example).
  1607. */
  1608. void skb_orphan_partial(struct sk_buff *skb)
  1609. {
  1610. if (skb_is_tcp_pure_ack(skb))
  1611. return;
  1612. if (skb->destructor == sock_wfree
  1613. #ifdef CONFIG_INET
  1614. || skb->destructor == tcp_wfree
  1615. #endif
  1616. ) {
  1617. struct sock *sk = skb->sk;
  1618. if (refcount_inc_not_zero(&sk->sk_refcnt)) {
  1619. WARN_ON(refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc));
  1620. skb->destructor = sock_efree;
  1621. }
  1622. } else {
  1623. skb_orphan(skb);
  1624. }
  1625. }
  1626. EXPORT_SYMBOL(skb_orphan_partial);
  1627. /*
  1628. * Read buffer destructor automatically called from kfree_skb.
  1629. */
  1630. void sock_rfree(struct sk_buff *skb)
  1631. {
  1632. struct sock *sk = skb->sk;
  1633. unsigned int len = skb->truesize;
  1634. atomic_sub(len, &sk->sk_rmem_alloc);
  1635. sk_mem_uncharge(sk, len);
  1636. }
  1637. EXPORT_SYMBOL(sock_rfree);
  1638. /*
  1639. * Buffer destructor for skbs that are not used directly in read or write
  1640. * path, e.g. for error handler skbs. Automatically called from kfree_skb.
  1641. */
  1642. void sock_efree(struct sk_buff *skb)
  1643. {
  1644. sock_put(skb->sk);
  1645. }
  1646. EXPORT_SYMBOL(sock_efree);
  1647. kuid_t sock_i_uid(struct sock *sk)
  1648. {
  1649. kuid_t uid;
  1650. read_lock_bh(&sk->sk_callback_lock);
  1651. uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
  1652. read_unlock_bh(&sk->sk_callback_lock);
  1653. return uid;
  1654. }
  1655. EXPORT_SYMBOL(sock_i_uid);
  1656. unsigned long sock_i_ino(struct sock *sk)
  1657. {
  1658. unsigned long ino;
  1659. read_lock_bh(&sk->sk_callback_lock);
  1660. ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
  1661. read_unlock_bh(&sk->sk_callback_lock);
  1662. return ino;
  1663. }
  1664. EXPORT_SYMBOL(sock_i_ino);
  1665. /*
  1666. * Allocate a skb from the socket's send buffer.
  1667. */
  1668. struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
  1669. gfp_t priority)
  1670. {
  1671. if (force || refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
  1672. struct sk_buff *skb = alloc_skb(size, priority);
  1673. if (skb) {
  1674. skb_set_owner_w(skb, sk);
  1675. return skb;
  1676. }
  1677. }
  1678. return NULL;
  1679. }
  1680. EXPORT_SYMBOL(sock_wmalloc);
  1681. static void sock_ofree(struct sk_buff *skb)
  1682. {
  1683. struct sock *sk = skb->sk;
  1684. atomic_sub(skb->truesize, &sk->sk_omem_alloc);
  1685. }
  1686. struct sk_buff *sock_omalloc(struct sock *sk, unsigned long size,
  1687. gfp_t priority)
  1688. {
  1689. struct sk_buff *skb;
  1690. /* small safe race: SKB_TRUESIZE may differ from final skb->truesize */
  1691. if (atomic_read(&sk->sk_omem_alloc) + SKB_TRUESIZE(size) >
  1692. sysctl_optmem_max)
  1693. return NULL;
  1694. skb = alloc_skb(size, priority);
  1695. if (!skb)
  1696. return NULL;
  1697. atomic_add(skb->truesize, &sk->sk_omem_alloc);
  1698. skb->sk = sk;
  1699. skb->destructor = sock_ofree;
  1700. return skb;
  1701. }
  1702. /*
  1703. * Allocate a memory block from the socket's option memory buffer.
  1704. */
  1705. void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
  1706. {
  1707. if ((unsigned int)size <= sysctl_optmem_max &&
  1708. atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
  1709. void *mem;
  1710. /* First do the add, to avoid the race if kmalloc
  1711. * might sleep.
  1712. */
  1713. atomic_add(size, &sk->sk_omem_alloc);
  1714. mem = kmalloc(size, priority);
  1715. if (mem)
  1716. return mem;
  1717. atomic_sub(size, &sk->sk_omem_alloc);
  1718. }
  1719. return NULL;
  1720. }
  1721. EXPORT_SYMBOL(sock_kmalloc);
  1722. /* Free an option memory block. Note, we actually want the inline
  1723. * here as this allows gcc to detect the nullify and fold away the
  1724. * condition entirely.
  1725. */
  1726. static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
  1727. const bool nullify)
  1728. {
  1729. if (WARN_ON_ONCE(!mem))
  1730. return;
  1731. if (nullify)
  1732. kzfree(mem);
  1733. else
  1734. kfree(mem);
  1735. atomic_sub(size, &sk->sk_omem_alloc);
  1736. }
  1737. void sock_kfree_s(struct sock *sk, void *mem, int size)
  1738. {
  1739. __sock_kfree_s(sk, mem, size, false);
  1740. }
  1741. EXPORT_SYMBOL(sock_kfree_s);
  1742. void sock_kzfree_s(struct sock *sk, void *mem, int size)
  1743. {
  1744. __sock_kfree_s(sk, mem, size, true);
  1745. }
  1746. EXPORT_SYMBOL(sock_kzfree_s);
  1747. /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
  1748. I think, these locks should be removed for datagram sockets.
  1749. */
  1750. static long sock_wait_for_wmem(struct sock *sk, long timeo)
  1751. {
  1752. DEFINE_WAIT(wait);
  1753. sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
  1754. for (;;) {
  1755. if (!timeo)
  1756. break;
  1757. if (signal_pending(current))
  1758. break;
  1759. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  1760. prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  1761. if (refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
  1762. break;
  1763. if (sk->sk_shutdown & SEND_SHUTDOWN)
  1764. break;
  1765. if (sk->sk_err)
  1766. break;
  1767. timeo = schedule_timeout(timeo);
  1768. }
  1769. finish_wait(sk_sleep(sk), &wait);
  1770. return timeo;
  1771. }
  1772. /*
  1773. * Generic send/receive buffer handlers
  1774. */
  1775. struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
  1776. unsigned long data_len, int noblock,
  1777. int *errcode, int max_page_order)
  1778. {
  1779. struct sk_buff *skb;
  1780. long timeo;
  1781. int err;
  1782. timeo = sock_sndtimeo(sk, noblock);
  1783. for (;;) {
  1784. err = sock_error(sk);
  1785. if (err != 0)
  1786. goto failure;
  1787. err = -EPIPE;
  1788. if (sk->sk_shutdown & SEND_SHUTDOWN)
  1789. goto failure;
  1790. if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
  1791. break;
  1792. sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
  1793. set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  1794. err = -EAGAIN;
  1795. if (!timeo)
  1796. goto failure;
  1797. if (signal_pending(current))
  1798. goto interrupted;
  1799. timeo = sock_wait_for_wmem(sk, timeo);
  1800. }
  1801. skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
  1802. errcode, sk->sk_allocation);
  1803. if (skb)
  1804. skb_set_owner_w(skb, sk);
  1805. return skb;
  1806. interrupted:
  1807. err = sock_intr_errno(timeo);
  1808. failure:
  1809. *errcode = err;
  1810. return NULL;
  1811. }
  1812. EXPORT_SYMBOL(sock_alloc_send_pskb);
  1813. struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
  1814. int noblock, int *errcode)
  1815. {
  1816. return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
  1817. }
  1818. EXPORT_SYMBOL(sock_alloc_send_skb);
  1819. int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
  1820. struct sockcm_cookie *sockc)
  1821. {
  1822. u32 tsflags;
  1823. switch (cmsg->cmsg_type) {
  1824. case SO_MARK:
  1825. if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
  1826. return -EPERM;
  1827. if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
  1828. return -EINVAL;
  1829. sockc->mark = *(u32 *)CMSG_DATA(cmsg);
  1830. break;
  1831. case SO_TIMESTAMPING:
  1832. if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
  1833. return -EINVAL;
  1834. tsflags = *(u32 *)CMSG_DATA(cmsg);
  1835. if (tsflags & ~SOF_TIMESTAMPING_TX_RECORD_MASK)
  1836. return -EINVAL;
  1837. sockc->tsflags &= ~SOF_TIMESTAMPING_TX_RECORD_MASK;
  1838. sockc->tsflags |= tsflags;
  1839. break;
  1840. /* SCM_RIGHTS and SCM_CREDENTIALS are semantically in SOL_UNIX. */
  1841. case SCM_RIGHTS:
  1842. case SCM_CREDENTIALS:
  1843. break;
  1844. default:
  1845. return -EINVAL;
  1846. }
  1847. return 0;
  1848. }
  1849. EXPORT_SYMBOL(__sock_cmsg_send);
  1850. int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
  1851. struct sockcm_cookie *sockc)
  1852. {
  1853. struct cmsghdr *cmsg;
  1854. int ret;
  1855. for_each_cmsghdr(cmsg, msg) {
  1856. if (!CMSG_OK(msg, cmsg))
  1857. return -EINVAL;
  1858. if (cmsg->cmsg_level != SOL_SOCKET)
  1859. continue;
  1860. ret = __sock_cmsg_send(sk, msg, cmsg, sockc);
  1861. if (ret)
  1862. return ret;
  1863. }
  1864. return 0;
  1865. }
  1866. EXPORT_SYMBOL(sock_cmsg_send);
  1867. static void sk_enter_memory_pressure(struct sock *sk)
  1868. {
  1869. if (!sk->sk_prot->enter_memory_pressure)
  1870. return;
  1871. sk->sk_prot->enter_memory_pressure(sk);
  1872. }
  1873. static void sk_leave_memory_pressure(struct sock *sk)
  1874. {
  1875. if (sk->sk_prot->leave_memory_pressure) {
  1876. sk->sk_prot->leave_memory_pressure(sk);
  1877. } else {
  1878. unsigned long *memory_pressure = sk->sk_prot->memory_pressure;
  1879. if (memory_pressure && *memory_pressure)
  1880. *memory_pressure = 0;
  1881. }
  1882. }
  1883. /* On 32bit arches, an skb frag is limited to 2^15 */
  1884. #define SKB_FRAG_PAGE_ORDER get_order(32768)
  1885. /**
  1886. * skb_page_frag_refill - check that a page_frag contains enough room
  1887. * @sz: minimum size of the fragment we want to get
  1888. * @pfrag: pointer to page_frag
  1889. * @gfp: priority for memory allocation
  1890. *
  1891. * Note: While this allocator tries to use high order pages, there is
  1892. * no guarantee that allocations succeed. Therefore, @sz MUST be
  1893. * less or equal than PAGE_SIZE.
  1894. */
  1895. bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
  1896. {
  1897. if (pfrag->page) {
  1898. if (page_ref_count(pfrag->page) == 1) {
  1899. pfrag->offset = 0;
  1900. return true;
  1901. }
  1902. if (pfrag->offset + sz <= pfrag->size)
  1903. return true;
  1904. put_page(pfrag->page);
  1905. }
  1906. pfrag->offset = 0;
  1907. if (SKB_FRAG_PAGE_ORDER) {
  1908. /* Avoid direct reclaim but allow kswapd to wake */
  1909. pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
  1910. __GFP_COMP | __GFP_NOWARN |
  1911. __GFP_NORETRY,
  1912. SKB_FRAG_PAGE_ORDER);
  1913. if (likely(pfrag->page)) {
  1914. pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
  1915. return true;
  1916. }
  1917. }
  1918. pfrag->page = alloc_page(gfp);
  1919. if (likely(pfrag->page)) {
  1920. pfrag->size = PAGE_SIZE;
  1921. return true;
  1922. }
  1923. return false;
  1924. }
  1925. EXPORT_SYMBOL(skb_page_frag_refill);
  1926. bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
  1927. {
  1928. if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
  1929. return true;
  1930. sk_enter_memory_pressure(sk);
  1931. sk_stream_moderate_sndbuf(sk);
  1932. return false;
  1933. }
  1934. EXPORT_SYMBOL(sk_page_frag_refill);
  1935. int sk_alloc_sg(struct sock *sk, int len, struct scatterlist *sg,
  1936. int sg_start, int *sg_curr_index, unsigned int *sg_curr_size,
  1937. int first_coalesce)
  1938. {
  1939. int sg_curr = *sg_curr_index, use = 0, rc = 0;
  1940. unsigned int size = *sg_curr_size;
  1941. struct page_frag *pfrag;
  1942. struct scatterlist *sge;
  1943. len -= size;
  1944. pfrag = sk_page_frag(sk);
  1945. while (len > 0) {
  1946. unsigned int orig_offset;
  1947. if (!sk_page_frag_refill(sk, pfrag)) {
  1948. rc = -ENOMEM;
  1949. goto out;
  1950. }
  1951. use = min_t(int, len, pfrag->size - pfrag->offset);
  1952. if (!sk_wmem_schedule(sk, use)) {
  1953. rc = -ENOMEM;
  1954. goto out;
  1955. }
  1956. sk_mem_charge(sk, use);
  1957. size += use;
  1958. orig_offset = pfrag->offset;
  1959. pfrag->offset += use;
  1960. sge = sg + sg_curr - 1;
  1961. if (sg_curr > first_coalesce && sg_page(sg) == pfrag->page &&
  1962. sg->offset + sg->length == orig_offset) {
  1963. sg->length += use;
  1964. } else {
  1965. sge = sg + sg_curr;
  1966. sg_unmark_end(sge);
  1967. sg_set_page(sge, pfrag->page, use, orig_offset);
  1968. get_page(pfrag->page);
  1969. sg_curr++;
  1970. if (sg_curr == MAX_SKB_FRAGS)
  1971. sg_curr = 0;
  1972. if (sg_curr == sg_start) {
  1973. rc = -ENOSPC;
  1974. break;
  1975. }
  1976. }
  1977. len -= use;
  1978. }
  1979. out:
  1980. *sg_curr_size = size;
  1981. *sg_curr_index = sg_curr;
  1982. return rc;
  1983. }
  1984. EXPORT_SYMBOL(sk_alloc_sg);
  1985. static void __lock_sock(struct sock *sk)
  1986. __releases(&sk->sk_lock.slock)
  1987. __acquires(&sk->sk_lock.slock)
  1988. {
  1989. DEFINE_WAIT(wait);
  1990. for (;;) {
  1991. prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
  1992. TASK_UNINTERRUPTIBLE);
  1993. spin_unlock_bh(&sk->sk_lock.slock);
  1994. schedule();
  1995. spin_lock_bh(&sk->sk_lock.slock);
  1996. if (!sock_owned_by_user(sk))
  1997. break;
  1998. }
  1999. finish_wait(&sk->sk_lock.wq, &wait);
  2000. }
  2001. static void __release_sock(struct sock *sk)
  2002. __releases(&sk->sk_lock.slock)
  2003. __acquires(&sk->sk_lock.slock)
  2004. {
  2005. struct sk_buff *skb, *next;
  2006. while ((skb = sk->sk_backlog.head) != NULL) {
  2007. sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
  2008. spin_unlock_bh(&sk->sk_lock.slock);
  2009. do {
  2010. next = skb->next;
  2011. prefetch(next);
  2012. WARN_ON_ONCE(skb_dst_is_noref(skb));
  2013. skb->next = NULL;
  2014. sk_backlog_rcv(sk, skb);
  2015. cond_resched();
  2016. skb = next;
  2017. } while (skb != NULL);
  2018. spin_lock_bh(&sk->sk_lock.slock);
  2019. }
  2020. /*
  2021. * Doing the zeroing here guarantee we can not loop forever
  2022. * while a wild producer attempts to flood us.
  2023. */
  2024. sk->sk_backlog.len = 0;
  2025. }
  2026. void __sk_flush_backlog(struct sock *sk)
  2027. {
  2028. spin_lock_bh(&sk->sk_lock.slock);
  2029. __release_sock(sk);
  2030. spin_unlock_bh(&sk->sk_lock.slock);
  2031. }
  2032. /**
  2033. * sk_wait_data - wait for data to arrive at sk_receive_queue
  2034. * @sk: sock to wait on
  2035. * @timeo: for how long
  2036. * @skb: last skb seen on sk_receive_queue
  2037. *
  2038. * Now socket state including sk->sk_err is changed only under lock,
  2039. * hence we may omit checks after joining wait queue.
  2040. * We check receive queue before schedule() only as optimization;
  2041. * it is very likely that release_sock() added new data.
  2042. */
  2043. int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
  2044. {
  2045. DEFINE_WAIT_FUNC(wait, woken_wake_function);
  2046. int rc;
  2047. add_wait_queue(sk_sleep(sk), &wait);
  2048. sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
  2049. rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
  2050. sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
  2051. remove_wait_queue(sk_sleep(sk), &wait);
  2052. return rc;
  2053. }
  2054. EXPORT_SYMBOL(sk_wait_data);
  2055. /**
  2056. * __sk_mem_raise_allocated - increase memory_allocated
  2057. * @sk: socket
  2058. * @size: memory size to allocate
  2059. * @amt: pages to allocate
  2060. * @kind: allocation type
  2061. *
  2062. * Similar to __sk_mem_schedule(), but does not update sk_forward_alloc
  2063. */
  2064. int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
  2065. {
  2066. struct proto *prot = sk->sk_prot;
  2067. long allocated = sk_memory_allocated_add(sk, amt);
  2068. if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
  2069. !mem_cgroup_charge_skmem(sk->sk_memcg, amt))
  2070. goto suppress_allocation;
  2071. /* Under limit. */
  2072. if (allocated <= sk_prot_mem_limits(sk, 0)) {
  2073. sk_leave_memory_pressure(sk);
  2074. return 1;
  2075. }
  2076. /* Under pressure. */
  2077. if (allocated > sk_prot_mem_limits(sk, 1))
  2078. sk_enter_memory_pressure(sk);
  2079. /* Over hard limit. */
  2080. if (allocated > sk_prot_mem_limits(sk, 2))
  2081. goto suppress_allocation;
  2082. /* guarantee minimum buffer size under pressure */
  2083. if (kind == SK_MEM_RECV) {
  2084. if (atomic_read(&sk->sk_rmem_alloc) < sk_get_rmem0(sk, prot))
  2085. return 1;
  2086. } else { /* SK_MEM_SEND */
  2087. int wmem0 = sk_get_wmem0(sk, prot);
  2088. if (sk->sk_type == SOCK_STREAM) {
  2089. if (sk->sk_wmem_queued < wmem0)
  2090. return 1;
  2091. } else if (refcount_read(&sk->sk_wmem_alloc) < wmem0) {
  2092. return 1;
  2093. }
  2094. }
  2095. if (sk_has_memory_pressure(sk)) {
  2096. int alloc;
  2097. if (!sk_under_memory_pressure(sk))
  2098. return 1;
  2099. alloc = sk_sockets_allocated_read_positive(sk);
  2100. if (sk_prot_mem_limits(sk, 2) > alloc *
  2101. sk_mem_pages(sk->sk_wmem_queued +
  2102. atomic_read(&sk->sk_rmem_alloc) +
  2103. sk->sk_forward_alloc))
  2104. return 1;
  2105. }
  2106. suppress_allocation:
  2107. if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
  2108. sk_stream_moderate_sndbuf(sk);
  2109. /* Fail only if socket is _under_ its sndbuf.
  2110. * In this case we cannot block, so that we have to fail.
  2111. */
  2112. if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
  2113. return 1;
  2114. }
  2115. trace_sock_exceed_buf_limit(sk, prot, allocated);
  2116. sk_memory_allocated_sub(sk, amt);
  2117. if (mem_cgroup_sockets_enabled && sk->sk_memcg)
  2118. mem_cgroup_uncharge_skmem(sk->sk_memcg, amt);
  2119. return 0;
  2120. }
  2121. EXPORT_SYMBOL(__sk_mem_raise_allocated);
  2122. /**
  2123. * __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
  2124. * @sk: socket
  2125. * @size: memory size to allocate
  2126. * @kind: allocation type
  2127. *
  2128. * If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
  2129. * rmem allocation. This function assumes that protocols which have
  2130. * memory_pressure use sk_wmem_queued as write buffer accounting.
  2131. */
  2132. int __sk_mem_schedule(struct sock *sk, int size, int kind)
  2133. {
  2134. int ret, amt = sk_mem_pages(size);
  2135. sk->sk_forward_alloc += amt << SK_MEM_QUANTUM_SHIFT;
  2136. ret = __sk_mem_raise_allocated(sk, size, amt, kind);
  2137. if (!ret)
  2138. sk->sk_forward_alloc -= amt << SK_MEM_QUANTUM_SHIFT;
  2139. return ret;
  2140. }
  2141. EXPORT_SYMBOL(__sk_mem_schedule);
  2142. /**
  2143. * __sk_mem_reduce_allocated - reclaim memory_allocated
  2144. * @sk: socket
  2145. * @amount: number of quanta
  2146. *
  2147. * Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc
  2148. */
  2149. void __sk_mem_reduce_allocated(struct sock *sk, int amount)
  2150. {
  2151. sk_memory_allocated_sub(sk, amount);
  2152. if (mem_cgroup_sockets_enabled && sk->sk_memcg)
  2153. mem_cgroup_uncharge_skmem(sk->sk_memcg, amount);
  2154. if (sk_under_memory_pressure(sk) &&
  2155. (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
  2156. sk_leave_memory_pressure(sk);
  2157. }
  2158. EXPORT_SYMBOL(__sk_mem_reduce_allocated);
  2159. /**
  2160. * __sk_mem_reclaim - reclaim sk_forward_alloc and memory_allocated
  2161. * @sk: socket
  2162. * @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
  2163. */
  2164. void __sk_mem_reclaim(struct sock *sk, int amount)
  2165. {
  2166. amount >>= SK_MEM_QUANTUM_SHIFT;
  2167. sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
  2168. __sk_mem_reduce_allocated(sk, amount);
  2169. }
  2170. EXPORT_SYMBOL(__sk_mem_reclaim);
  2171. int sk_set_peek_off(struct sock *sk, int val)
  2172. {
  2173. sk->sk_peek_off = val;
  2174. return 0;
  2175. }
  2176. EXPORT_SYMBOL_GPL(sk_set_peek_off);
  2177. /*
  2178. * Set of default routines for initialising struct proto_ops when
  2179. * the protocol does not support a particular function. In certain
  2180. * cases where it makes no sense for a protocol to have a "do nothing"
  2181. * function, some default processing is provided.
  2182. */
  2183. int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
  2184. {
  2185. return -EOPNOTSUPP;
  2186. }
  2187. EXPORT_SYMBOL(sock_no_bind);
  2188. int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
  2189. int len, int flags)
  2190. {
  2191. return -EOPNOTSUPP;
  2192. }
  2193. EXPORT_SYMBOL(sock_no_connect);
  2194. int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
  2195. {
  2196. return -EOPNOTSUPP;
  2197. }
  2198. EXPORT_SYMBOL(sock_no_socketpair);
  2199. int sock_no_accept(struct socket *sock, struct socket *newsock, int flags,
  2200. bool kern)
  2201. {
  2202. return -EOPNOTSUPP;
  2203. }
  2204. EXPORT_SYMBOL(sock_no_accept);
  2205. int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
  2206. int peer)
  2207. {
  2208. return -EOPNOTSUPP;
  2209. }
  2210. EXPORT_SYMBOL(sock_no_getname);
  2211. int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  2212. {
  2213. return -EOPNOTSUPP;
  2214. }
  2215. EXPORT_SYMBOL(sock_no_ioctl);
  2216. int sock_no_listen(struct socket *sock, int backlog)
  2217. {
  2218. return -EOPNOTSUPP;
  2219. }
  2220. EXPORT_SYMBOL(sock_no_listen);
  2221. int sock_no_shutdown(struct socket *sock, int how)
  2222. {
  2223. return -EOPNOTSUPP;
  2224. }
  2225. EXPORT_SYMBOL(sock_no_shutdown);
  2226. int sock_no_setsockopt(struct socket *sock, int level, int optname,
  2227. char __user *optval, unsigned int optlen)
  2228. {
  2229. return -EOPNOTSUPP;
  2230. }
  2231. EXPORT_SYMBOL(sock_no_setsockopt);
  2232. int sock_no_getsockopt(struct socket *sock, int level, int optname,
  2233. char __user *optval, int __user *optlen)
  2234. {
  2235. return -EOPNOTSUPP;
  2236. }
  2237. EXPORT_SYMBOL(sock_no_getsockopt);
  2238. int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
  2239. {
  2240. return -EOPNOTSUPP;
  2241. }
  2242. EXPORT_SYMBOL(sock_no_sendmsg);
  2243. int sock_no_sendmsg_locked(struct sock *sk, struct msghdr *m, size_t len)
  2244. {
  2245. return -EOPNOTSUPP;
  2246. }
  2247. EXPORT_SYMBOL(sock_no_sendmsg_locked);
  2248. int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
  2249. int flags)
  2250. {
  2251. return -EOPNOTSUPP;
  2252. }
  2253. EXPORT_SYMBOL(sock_no_recvmsg);
  2254. int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
  2255. {
  2256. /* Mirror missing mmap method error code */
  2257. return -ENODEV;
  2258. }
  2259. EXPORT_SYMBOL(sock_no_mmap);
  2260. ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
  2261. {
  2262. ssize_t res;
  2263. struct msghdr msg = {.msg_flags = flags};
  2264. struct kvec iov;
  2265. char *kaddr = kmap(page);
  2266. iov.iov_base = kaddr + offset;
  2267. iov.iov_len = size;
  2268. res = kernel_sendmsg(sock, &msg, &iov, 1, size);
  2269. kunmap(page);
  2270. return res;
  2271. }
  2272. EXPORT_SYMBOL(sock_no_sendpage);
  2273. ssize_t sock_no_sendpage_locked(struct sock *sk, struct page *page,
  2274. int offset, size_t size, int flags)
  2275. {
  2276. ssize_t res;
  2277. struct msghdr msg = {.msg_flags = flags};
  2278. struct kvec iov;
  2279. char *kaddr = kmap(page);
  2280. iov.iov_base = kaddr + offset;
  2281. iov.iov_len = size;
  2282. res = kernel_sendmsg_locked(sk, &msg, &iov, 1, size);
  2283. kunmap(page);
  2284. return res;
  2285. }
  2286. EXPORT_SYMBOL(sock_no_sendpage_locked);
  2287. /*
  2288. * Default Socket Callbacks
  2289. */
  2290. static void sock_def_wakeup(struct sock *sk)
  2291. {
  2292. struct socket_wq *wq;
  2293. rcu_read_lock();
  2294. wq = rcu_dereference(sk->sk_wq);
  2295. if (skwq_has_sleeper(wq))
  2296. wake_up_interruptible_all(&wq->wait);
  2297. rcu_read_unlock();
  2298. }
  2299. static void sock_def_error_report(struct sock *sk)
  2300. {
  2301. struct socket_wq *wq;
  2302. rcu_read_lock();
  2303. wq = rcu_dereference(sk->sk_wq);
  2304. if (skwq_has_sleeper(wq))
  2305. wake_up_interruptible_poll(&wq->wait, EPOLLERR);
  2306. sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
  2307. rcu_read_unlock();
  2308. }
  2309. static void sock_def_readable(struct sock *sk)
  2310. {
  2311. struct socket_wq *wq;
  2312. rcu_read_lock();
  2313. wq = rcu_dereference(sk->sk_wq);
  2314. if (skwq_has_sleeper(wq))
  2315. wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
  2316. EPOLLRDNORM | EPOLLRDBAND);
  2317. sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
  2318. rcu_read_unlock();
  2319. }
  2320. static void sock_def_write_space(struct sock *sk)
  2321. {
  2322. struct socket_wq *wq;
  2323. rcu_read_lock();
  2324. /* Do not wake up a writer until he can make "significant"
  2325. * progress. --DaveM
  2326. */
  2327. if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
  2328. wq = rcu_dereference(sk->sk_wq);
  2329. if (skwq_has_sleeper(wq))
  2330. wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
  2331. EPOLLWRNORM | EPOLLWRBAND);
  2332. /* Should agree with poll, otherwise some programs break */
  2333. if (sock_writeable(sk))
  2334. sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
  2335. }
  2336. rcu_read_unlock();
  2337. }
  2338. static void sock_def_destruct(struct sock *sk)
  2339. {
  2340. }
  2341. void sk_send_sigurg(struct sock *sk)
  2342. {
  2343. if (sk->sk_socket && sk->sk_socket->file)
  2344. if (send_sigurg(&sk->sk_socket->file->f_owner))
  2345. sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
  2346. }
  2347. EXPORT_SYMBOL(sk_send_sigurg);
  2348. void sk_reset_timer(struct sock *sk, struct timer_list* timer,
  2349. unsigned long expires)
  2350. {
  2351. if (!mod_timer(timer, expires))
  2352. sock_hold(sk);
  2353. }
  2354. EXPORT_SYMBOL(sk_reset_timer);
  2355. void sk_stop_timer(struct sock *sk, struct timer_list* timer)
  2356. {
  2357. if (del_timer(timer))
  2358. __sock_put(sk);
  2359. }
  2360. EXPORT_SYMBOL(sk_stop_timer);
  2361. void sock_init_data(struct socket *sock, struct sock *sk)
  2362. {
  2363. sk_init_common(sk);
  2364. sk->sk_send_head = NULL;
  2365. timer_setup(&sk->sk_timer, NULL, 0);
  2366. sk->sk_allocation = GFP_KERNEL;
  2367. sk->sk_rcvbuf = sysctl_rmem_default;
  2368. sk->sk_sndbuf = sysctl_wmem_default;
  2369. sk->sk_state = TCP_CLOSE;
  2370. sk_set_socket(sk, sock);
  2371. sock_set_flag(sk, SOCK_ZAPPED);
  2372. if (sock) {
  2373. sk->sk_type = sock->type;
  2374. sk->sk_wq = sock->wq;
  2375. sock->sk = sk;
  2376. sk->sk_uid = SOCK_INODE(sock)->i_uid;
  2377. } else {
  2378. sk->sk_wq = NULL;
  2379. sk->sk_uid = make_kuid(sock_net(sk)->user_ns, 0);
  2380. }
  2381. rwlock_init(&sk->sk_callback_lock);
  2382. if (sk->sk_kern_sock)
  2383. lockdep_set_class_and_name(
  2384. &sk->sk_callback_lock,
  2385. af_kern_callback_keys + sk->sk_family,
  2386. af_family_kern_clock_key_strings[sk->sk_family]);
  2387. else
  2388. lockdep_set_class_and_name(
  2389. &sk->sk_callback_lock,
  2390. af_callback_keys + sk->sk_family,
  2391. af_family_clock_key_strings[sk->sk_family]);
  2392. sk->sk_state_change = sock_def_wakeup;
  2393. sk->sk_data_ready = sock_def_readable;
  2394. sk->sk_write_space = sock_def_write_space;
  2395. sk->sk_error_report = sock_def_error_report;
  2396. sk->sk_destruct = sock_def_destruct;
  2397. sk->sk_frag.page = NULL;
  2398. sk->sk_frag.offset = 0;
  2399. sk->sk_peek_off = -1;
  2400. sk->sk_peer_pid = NULL;
  2401. sk->sk_peer_cred = NULL;
  2402. sk->sk_write_pending = 0;
  2403. sk->sk_rcvlowat = 1;
  2404. sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
  2405. sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
  2406. sk->sk_stamp = SK_DEFAULT_STAMP;
  2407. atomic_set(&sk->sk_zckey, 0);
  2408. #ifdef CONFIG_NET_RX_BUSY_POLL
  2409. sk->sk_napi_id = 0;
  2410. sk->sk_ll_usec = sysctl_net_busy_read;
  2411. #endif
  2412. sk->sk_max_pacing_rate = ~0U;
  2413. sk->sk_pacing_rate = ~0U;
  2414. sk->sk_pacing_shift = 10;
  2415. sk->sk_incoming_cpu = -1;
  2416. sk_rx_queue_clear(sk);
  2417. /*
  2418. * Before updating sk_refcnt, we must commit prior changes to memory
  2419. * (Documentation/RCU/rculist_nulls.txt for details)
  2420. */
  2421. smp_wmb();
  2422. refcount_set(&sk->sk_refcnt, 1);
  2423. atomic_set(&sk->sk_drops, 0);
  2424. }
  2425. EXPORT_SYMBOL(sock_init_data);
  2426. void lock_sock_nested(struct sock *sk, int subclass)
  2427. {
  2428. might_sleep();
  2429. spin_lock_bh(&sk->sk_lock.slock);
  2430. if (sk->sk_lock.owned)
  2431. __lock_sock(sk);
  2432. sk->sk_lock.owned = 1;
  2433. spin_unlock(&sk->sk_lock.slock);
  2434. /*
  2435. * The sk_lock has mutex_lock() semantics here:
  2436. */
  2437. mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
  2438. local_bh_enable();
  2439. }
  2440. EXPORT_SYMBOL(lock_sock_nested);
  2441. void release_sock(struct sock *sk)
  2442. {
  2443. spin_lock_bh(&sk->sk_lock.slock);
  2444. if (sk->sk_backlog.tail)
  2445. __release_sock(sk);
  2446. /* Warning : release_cb() might need to release sk ownership,
  2447. * ie call sock_release_ownership(sk) before us.
  2448. */
  2449. if (sk->sk_prot->release_cb)
  2450. sk->sk_prot->release_cb(sk);
  2451. sock_release_ownership(sk);
  2452. if (waitqueue_active(&sk->sk_lock.wq))
  2453. wake_up(&sk->sk_lock.wq);
  2454. spin_unlock_bh(&sk->sk_lock.slock);
  2455. }
  2456. EXPORT_SYMBOL(release_sock);
  2457. /**
  2458. * lock_sock_fast - fast version of lock_sock
  2459. * @sk: socket
  2460. *
  2461. * This version should be used for very small section, where process wont block
  2462. * return false if fast path is taken:
  2463. *
  2464. * sk_lock.slock locked, owned = 0, BH disabled
  2465. *
  2466. * return true if slow path is taken:
  2467. *
  2468. * sk_lock.slock unlocked, owned = 1, BH enabled
  2469. */
  2470. bool lock_sock_fast(struct sock *sk)
  2471. {
  2472. might_sleep();
  2473. spin_lock_bh(&sk->sk_lock.slock);
  2474. if (!sk->sk_lock.owned)
  2475. /*
  2476. * Note : We must disable BH
  2477. */
  2478. return false;
  2479. __lock_sock(sk);
  2480. sk->sk_lock.owned = 1;
  2481. spin_unlock(&sk->sk_lock.slock);
  2482. /*
  2483. * The sk_lock has mutex_lock() semantics here:
  2484. */
  2485. mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
  2486. local_bh_enable();
  2487. return true;
  2488. }
  2489. EXPORT_SYMBOL(lock_sock_fast);
  2490. int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
  2491. {
  2492. struct timeval tv;
  2493. if (!sock_flag(sk, SOCK_TIMESTAMP))
  2494. sock_enable_timestamp(sk, SOCK_TIMESTAMP);
  2495. tv = ktime_to_timeval(sk->sk_stamp);
  2496. if (tv.tv_sec == -1)
  2497. return -ENOENT;
  2498. if (tv.tv_sec == 0) {
  2499. sk->sk_stamp = ktime_get_real();
  2500. tv = ktime_to_timeval(sk->sk_stamp);
  2501. }
  2502. return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
  2503. }
  2504. EXPORT_SYMBOL(sock_get_timestamp);
  2505. int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
  2506. {
  2507. struct timespec ts;
  2508. if (!sock_flag(sk, SOCK_TIMESTAMP))
  2509. sock_enable_timestamp(sk, SOCK_TIMESTAMP);
  2510. ts = ktime_to_timespec(sk->sk_stamp);
  2511. if (ts.tv_sec == -1)
  2512. return -ENOENT;
  2513. if (ts.tv_sec == 0) {
  2514. sk->sk_stamp = ktime_get_real();
  2515. ts = ktime_to_timespec(sk->sk_stamp);
  2516. }
  2517. return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
  2518. }
  2519. EXPORT_SYMBOL(sock_get_timestampns);
  2520. void sock_enable_timestamp(struct sock *sk, int flag)
  2521. {
  2522. if (!sock_flag(sk, flag)) {
  2523. unsigned long previous_flags = sk->sk_flags;
  2524. sock_set_flag(sk, flag);
  2525. /*
  2526. * we just set one of the two flags which require net
  2527. * time stamping, but time stamping might have been on
  2528. * already because of the other one
  2529. */
  2530. if (sock_needs_netstamp(sk) &&
  2531. !(previous_flags & SK_FLAGS_TIMESTAMP))
  2532. net_enable_timestamp();
  2533. }
  2534. }
  2535. int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
  2536. int level, int type)
  2537. {
  2538. struct sock_exterr_skb *serr;
  2539. struct sk_buff *skb;
  2540. int copied, err;
  2541. err = -EAGAIN;
  2542. skb = sock_dequeue_err_skb(sk);
  2543. if (skb == NULL)
  2544. goto out;
  2545. copied = skb->len;
  2546. if (copied > len) {
  2547. msg->msg_flags |= MSG_TRUNC;
  2548. copied = len;
  2549. }
  2550. err = skb_copy_datagram_msg(skb, 0, msg, copied);
  2551. if (err)
  2552. goto out_free_skb;
  2553. sock_recv_timestamp(msg, sk, skb);
  2554. serr = SKB_EXT_ERR(skb);
  2555. put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
  2556. msg->msg_flags |= MSG_ERRQUEUE;
  2557. err = copied;
  2558. out_free_skb:
  2559. kfree_skb(skb);
  2560. out:
  2561. return err;
  2562. }
  2563. EXPORT_SYMBOL(sock_recv_errqueue);
  2564. /*
  2565. * Get a socket option on an socket.
  2566. *
  2567. * FIX: POSIX 1003.1g is very ambiguous here. It states that
  2568. * asynchronous errors should be reported by getsockopt. We assume
  2569. * this means if you specify SO_ERROR (otherwise whats the point of it).
  2570. */
  2571. int sock_common_getsockopt(struct socket *sock, int level, int optname,
  2572. char __user *optval, int __user *optlen)
  2573. {
  2574. struct sock *sk = sock->sk;
  2575. return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
  2576. }
  2577. EXPORT_SYMBOL(sock_common_getsockopt);
  2578. #ifdef CONFIG_COMPAT
  2579. int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
  2580. char __user *optval, int __user *optlen)
  2581. {
  2582. struct sock *sk = sock->sk;
  2583. if (sk->sk_prot->compat_getsockopt != NULL)
  2584. return sk->sk_prot->compat_getsockopt(sk, level, optname,
  2585. optval, optlen);
  2586. return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
  2587. }
  2588. EXPORT_SYMBOL(compat_sock_common_getsockopt);
  2589. #endif
  2590. int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
  2591. int flags)
  2592. {
  2593. struct sock *sk = sock->sk;
  2594. int addr_len = 0;
  2595. int err;
  2596. err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
  2597. flags & ~MSG_DONTWAIT, &addr_len);
  2598. if (err >= 0)
  2599. msg->msg_namelen = addr_len;
  2600. return err;
  2601. }
  2602. EXPORT_SYMBOL(sock_common_recvmsg);
  2603. /*
  2604. * Set socket options on an inet socket.
  2605. */
  2606. int sock_common_setsockopt(struct socket *sock, int level, int optname,
  2607. char __user *optval, unsigned int optlen)
  2608. {
  2609. struct sock *sk = sock->sk;
  2610. return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
  2611. }
  2612. EXPORT_SYMBOL(sock_common_setsockopt);
  2613. #ifdef CONFIG_COMPAT
  2614. int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
  2615. char __user *optval, unsigned int optlen)
  2616. {
  2617. struct sock *sk = sock->sk;
  2618. if (sk->sk_prot->compat_setsockopt != NULL)
  2619. return sk->sk_prot->compat_setsockopt(sk, level, optname,
  2620. optval, optlen);
  2621. return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
  2622. }
  2623. EXPORT_SYMBOL(compat_sock_common_setsockopt);
  2624. #endif
  2625. void sk_common_release(struct sock *sk)
  2626. {
  2627. if (sk->sk_prot->destroy)
  2628. sk->sk_prot->destroy(sk);
  2629. /*
  2630. * Observation: when sock_common_release is called, processes have
  2631. * no access to socket. But net still has.
  2632. * Step one, detach it from networking:
  2633. *
  2634. * A. Remove from hash tables.
  2635. */
  2636. sk->sk_prot->unhash(sk);
  2637. /*
  2638. * In this point socket cannot receive new packets, but it is possible
  2639. * that some packets are in flight because some CPU runs receiver and
  2640. * did hash table lookup before we unhashed socket. They will achieve
  2641. * receive queue and will be purged by socket destructor.
  2642. *
  2643. * Also we still have packets pending on receive queue and probably,
  2644. * our own packets waiting in device queues. sock_destroy will drain
  2645. * receive queue, but transmitted packets will delay socket destruction
  2646. * until the last reference will be released.
  2647. */
  2648. sock_orphan(sk);
  2649. xfrm_sk_free_policy(sk);
  2650. sk_refcnt_debug_release(sk);
  2651. sock_put(sk);
  2652. }
  2653. EXPORT_SYMBOL(sk_common_release);
  2654. void sk_get_meminfo(const struct sock *sk, u32 *mem)
  2655. {
  2656. memset(mem, 0, sizeof(*mem) * SK_MEMINFO_VARS);
  2657. mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
  2658. mem[SK_MEMINFO_RCVBUF] = sk->sk_rcvbuf;
  2659. mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
  2660. mem[SK_MEMINFO_SNDBUF] = sk->sk_sndbuf;
  2661. mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
  2662. mem[SK_MEMINFO_WMEM_QUEUED] = sk->sk_wmem_queued;
  2663. mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
  2664. mem[SK_MEMINFO_BACKLOG] = sk->sk_backlog.len;
  2665. mem[SK_MEMINFO_DROPS] = atomic_read(&sk->sk_drops);
  2666. }
  2667. #ifdef CONFIG_PROC_FS
  2668. #define PROTO_INUSE_NR 64 /* should be enough for the first time */
  2669. struct prot_inuse {
  2670. int val[PROTO_INUSE_NR];
  2671. };
  2672. static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
  2673. void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
  2674. {
  2675. __this_cpu_add(net->core.prot_inuse->val[prot->inuse_idx], val);
  2676. }
  2677. EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
  2678. int sock_prot_inuse_get(struct net *net, struct proto *prot)
  2679. {
  2680. int cpu, idx = prot->inuse_idx;
  2681. int res = 0;
  2682. for_each_possible_cpu(cpu)
  2683. res += per_cpu_ptr(net->core.prot_inuse, cpu)->val[idx];
  2684. return res >= 0 ? res : 0;
  2685. }
  2686. EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
  2687. static void sock_inuse_add(struct net *net, int val)
  2688. {
  2689. this_cpu_add(*net->core.sock_inuse, val);
  2690. }
  2691. int sock_inuse_get(struct net *net)
  2692. {
  2693. int cpu, res = 0;
  2694. for_each_possible_cpu(cpu)
  2695. res += *per_cpu_ptr(net->core.sock_inuse, cpu);
  2696. return res;
  2697. }
  2698. EXPORT_SYMBOL_GPL(sock_inuse_get);
  2699. static int __net_init sock_inuse_init_net(struct net *net)
  2700. {
  2701. net->core.prot_inuse = alloc_percpu(struct prot_inuse);
  2702. if (net->core.prot_inuse == NULL)
  2703. return -ENOMEM;
  2704. net->core.sock_inuse = alloc_percpu(int);
  2705. if (net->core.sock_inuse == NULL)
  2706. goto out;
  2707. return 0;
  2708. out:
  2709. free_percpu(net->core.prot_inuse);
  2710. return -ENOMEM;
  2711. }
  2712. static void __net_exit sock_inuse_exit_net(struct net *net)
  2713. {
  2714. free_percpu(net->core.prot_inuse);
  2715. free_percpu(net->core.sock_inuse);
  2716. }
  2717. static struct pernet_operations net_inuse_ops = {
  2718. .init = sock_inuse_init_net,
  2719. .exit = sock_inuse_exit_net,
  2720. };
  2721. static __init int net_inuse_init(void)
  2722. {
  2723. if (register_pernet_subsys(&net_inuse_ops))
  2724. panic("Cannot initialize net inuse counters");
  2725. return 0;
  2726. }
  2727. core_initcall(net_inuse_init);
  2728. static void assign_proto_idx(struct proto *prot)
  2729. {
  2730. prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
  2731. if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
  2732. pr_err("PROTO_INUSE_NR exhausted\n");
  2733. return;
  2734. }
  2735. set_bit(prot->inuse_idx, proto_inuse_idx);
  2736. }
  2737. static void release_proto_idx(struct proto *prot)
  2738. {
  2739. if (prot->inuse_idx != PROTO_INUSE_NR - 1)
  2740. clear_bit(prot->inuse_idx, proto_inuse_idx);
  2741. }
  2742. #else
  2743. static inline void assign_proto_idx(struct proto *prot)
  2744. {
  2745. }
  2746. static inline void release_proto_idx(struct proto *prot)
  2747. {
  2748. }
  2749. static void sock_inuse_add(struct net *net, int val)
  2750. {
  2751. }
  2752. #endif
  2753. static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
  2754. {
  2755. if (!rsk_prot)
  2756. return;
  2757. kfree(rsk_prot->slab_name);
  2758. rsk_prot->slab_name = NULL;
  2759. kmem_cache_destroy(rsk_prot->slab);
  2760. rsk_prot->slab = NULL;
  2761. }
  2762. static int req_prot_init(const struct proto *prot)
  2763. {
  2764. struct request_sock_ops *rsk_prot = prot->rsk_prot;
  2765. if (!rsk_prot)
  2766. return 0;
  2767. rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
  2768. prot->name);
  2769. if (!rsk_prot->slab_name)
  2770. return -ENOMEM;
  2771. rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
  2772. rsk_prot->obj_size, 0,
  2773. prot->slab_flags, NULL);
  2774. if (!rsk_prot->slab) {
  2775. pr_crit("%s: Can't create request sock SLAB cache!\n",
  2776. prot->name);
  2777. return -ENOMEM;
  2778. }
  2779. return 0;
  2780. }
  2781. int proto_register(struct proto *prot, int alloc_slab)
  2782. {
  2783. if (alloc_slab) {
  2784. prot->slab = kmem_cache_create_usercopy(prot->name,
  2785. prot->obj_size, 0,
  2786. SLAB_HWCACHE_ALIGN | prot->slab_flags,
  2787. prot->useroffset, prot->usersize,
  2788. NULL);
  2789. if (prot->slab == NULL) {
  2790. pr_crit("%s: Can't create sock SLAB cache!\n",
  2791. prot->name);
  2792. goto out;
  2793. }
  2794. if (req_prot_init(prot))
  2795. goto out_free_request_sock_slab;
  2796. if (prot->twsk_prot != NULL) {
  2797. prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
  2798. if (prot->twsk_prot->twsk_slab_name == NULL)
  2799. goto out_free_request_sock_slab;
  2800. prot->twsk_prot->twsk_slab =
  2801. kmem_cache_create(prot->twsk_prot->twsk_slab_name,
  2802. prot->twsk_prot->twsk_obj_size,
  2803. 0,
  2804. prot->slab_flags,
  2805. NULL);
  2806. if (prot->twsk_prot->twsk_slab == NULL)
  2807. goto out_free_timewait_sock_slab_name;
  2808. }
  2809. }
  2810. mutex_lock(&proto_list_mutex);
  2811. list_add(&prot->node, &proto_list);
  2812. assign_proto_idx(prot);
  2813. mutex_unlock(&proto_list_mutex);
  2814. return 0;
  2815. out_free_timewait_sock_slab_name:
  2816. kfree(prot->twsk_prot->twsk_slab_name);
  2817. out_free_request_sock_slab:
  2818. req_prot_cleanup(prot->rsk_prot);
  2819. kmem_cache_destroy(prot->slab);
  2820. prot->slab = NULL;
  2821. out:
  2822. return -ENOBUFS;
  2823. }
  2824. EXPORT_SYMBOL(proto_register);
  2825. void proto_unregister(struct proto *prot)
  2826. {
  2827. mutex_lock(&proto_list_mutex);
  2828. release_proto_idx(prot);
  2829. list_del(&prot->node);
  2830. mutex_unlock(&proto_list_mutex);
  2831. kmem_cache_destroy(prot->slab);
  2832. prot->slab = NULL;
  2833. req_prot_cleanup(prot->rsk_prot);
  2834. if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
  2835. kmem_cache_destroy(prot->twsk_prot->twsk_slab);
  2836. kfree(prot->twsk_prot->twsk_slab_name);
  2837. prot->twsk_prot->twsk_slab = NULL;
  2838. }
  2839. }
  2840. EXPORT_SYMBOL(proto_unregister);
  2841. int sock_load_diag_module(int family, int protocol)
  2842. {
  2843. if (!protocol) {
  2844. if (!sock_is_registered(family))
  2845. return -ENOENT;
  2846. return request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
  2847. NETLINK_SOCK_DIAG, family);
  2848. }
  2849. #ifdef CONFIG_INET
  2850. if (family == AF_INET &&
  2851. !rcu_access_pointer(inet_protos[protocol]))
  2852. return -ENOENT;
  2853. #endif
  2854. return request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
  2855. NETLINK_SOCK_DIAG, family, protocol);
  2856. }
  2857. EXPORT_SYMBOL(sock_load_diag_module);
  2858. #ifdef CONFIG_PROC_FS
  2859. static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
  2860. __acquires(proto_list_mutex)
  2861. {
  2862. mutex_lock(&proto_list_mutex);
  2863. return seq_list_start_head(&proto_list, *pos);
  2864. }
  2865. static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2866. {
  2867. return seq_list_next(v, &proto_list, pos);
  2868. }
  2869. static void proto_seq_stop(struct seq_file *seq, void *v)
  2870. __releases(proto_list_mutex)
  2871. {
  2872. mutex_unlock(&proto_list_mutex);
  2873. }
  2874. static char proto_method_implemented(const void *method)
  2875. {
  2876. return method == NULL ? 'n' : 'y';
  2877. }
  2878. static long sock_prot_memory_allocated(struct proto *proto)
  2879. {
  2880. return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
  2881. }
  2882. static char *sock_prot_memory_pressure(struct proto *proto)
  2883. {
  2884. return proto->memory_pressure != NULL ?
  2885. proto_memory_pressure(proto) ? "yes" : "no" : "NI";
  2886. }
  2887. static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
  2888. {
  2889. seq_printf(seq, "%-9s %4u %6d %6ld %-3s %6u %-3s %-10s "
  2890. "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
  2891. proto->name,
  2892. proto->obj_size,
  2893. sock_prot_inuse_get(seq_file_net(seq), proto),
  2894. sock_prot_memory_allocated(proto),
  2895. sock_prot_memory_pressure(proto),
  2896. proto->max_header,
  2897. proto->slab == NULL ? "no" : "yes",
  2898. module_name(proto->owner),
  2899. proto_method_implemented(proto->close),
  2900. proto_method_implemented(proto->connect),
  2901. proto_method_implemented(proto->disconnect),
  2902. proto_method_implemented(proto->accept),
  2903. proto_method_implemented(proto->ioctl),
  2904. proto_method_implemented(proto->init),
  2905. proto_method_implemented(proto->destroy),
  2906. proto_method_implemented(proto->shutdown),
  2907. proto_method_implemented(proto->setsockopt),
  2908. proto_method_implemented(proto->getsockopt),
  2909. proto_method_implemented(proto->sendmsg),
  2910. proto_method_implemented(proto->recvmsg),
  2911. proto_method_implemented(proto->sendpage),
  2912. proto_method_implemented(proto->bind),
  2913. proto_method_implemented(proto->backlog_rcv),
  2914. proto_method_implemented(proto->hash),
  2915. proto_method_implemented(proto->unhash),
  2916. proto_method_implemented(proto->get_port),
  2917. proto_method_implemented(proto->enter_memory_pressure));
  2918. }
  2919. static int proto_seq_show(struct seq_file *seq, void *v)
  2920. {
  2921. if (v == &proto_list)
  2922. seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
  2923. "protocol",
  2924. "size",
  2925. "sockets",
  2926. "memory",
  2927. "press",
  2928. "maxhdr",
  2929. "slab",
  2930. "module",
  2931. "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
  2932. else
  2933. proto_seq_printf(seq, list_entry(v, struct proto, node));
  2934. return 0;
  2935. }
  2936. static const struct seq_operations proto_seq_ops = {
  2937. .start = proto_seq_start,
  2938. .next = proto_seq_next,
  2939. .stop = proto_seq_stop,
  2940. .show = proto_seq_show,
  2941. };
  2942. static __net_init int proto_init_net(struct net *net)
  2943. {
  2944. if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
  2945. sizeof(struct seq_net_private)))
  2946. return -ENOMEM;
  2947. return 0;
  2948. }
  2949. static __net_exit void proto_exit_net(struct net *net)
  2950. {
  2951. remove_proc_entry("protocols", net->proc_net);
  2952. }
  2953. static __net_initdata struct pernet_operations proto_net_ops = {
  2954. .init = proto_init_net,
  2955. .exit = proto_exit_net,
  2956. };
  2957. static int __init proto_init(void)
  2958. {
  2959. return register_pernet_subsys(&proto_net_ops);
  2960. }
  2961. subsys_initcall(proto_init);
  2962. #endif /* PROC_FS */
  2963. #ifdef CONFIG_NET_RX_BUSY_POLL
  2964. bool sk_busy_loop_end(void *p, unsigned long start_time)
  2965. {
  2966. struct sock *sk = p;
  2967. return !skb_queue_empty(&sk->sk_receive_queue) ||
  2968. sk_busy_loop_timeout(sk, start_time);
  2969. }
  2970. EXPORT_SYMBOL(sk_busy_loop_end);
  2971. #endif /* CONFIG_NET_RX_BUSY_POLL */