sock.h 61 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189
  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. * Definitions for the AF_INET socket handler.
  7. *
  8. * Version: @(#)sock.h 1.0.4 05/13/93
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  13. * Florian La Roche <flla@stud.uni-sb.de>
  14. *
  15. * Fixes:
  16. * Alan Cox : Volatiles in skbuff pointers. See
  17. * skbuff comments. May be overdone,
  18. * better to prove they can be removed
  19. * than the reverse.
  20. * Alan Cox : Added a zapped field for tcp to note
  21. * a socket is reset and must stay shut up
  22. * Alan Cox : New fields for options
  23. * Pauline Middelink : identd support
  24. * Alan Cox : Eliminate low level recv/recvfrom
  25. * David S. Miller : New socket lookup architecture.
  26. * Steve Whitehouse: Default routines for sock_ops
  27. * Arnaldo C. Melo : removed net_pinfo, tp_pinfo and made
  28. * protinfo be just a void pointer, as the
  29. * protocol specific parts were moved to
  30. * respective headers and ipv4/v6, etc now
  31. * use private slabcaches for its socks
  32. * Pedro Hortas : New flags field for socket options
  33. *
  34. *
  35. * This program is free software; you can redistribute it and/or
  36. * modify it under the terms of the GNU General Public License
  37. * as published by the Free Software Foundation; either version
  38. * 2 of the License, or (at your option) any later version.
  39. */
  40. #ifndef _SOCK_H
  41. #define _SOCK_H
  42. #include <linux/hardirq.h>
  43. #include <linux/kernel.h>
  44. #include <linux/list.h>
  45. #include <linux/list_nulls.h>
  46. #include <linux/timer.h>
  47. #include <linux/cache.h>
  48. #include <linux/bitops.h>
  49. #include <linux/lockdep.h>
  50. #include <linux/netdevice.h>
  51. #include <linux/skbuff.h> /* struct sk_buff */
  52. #include <linux/mm.h>
  53. #include <linux/security.h>
  54. #include <linux/slab.h>
  55. #include <linux/uaccess.h>
  56. #include <linux/memcontrol.h>
  57. #include <linux/res_counter.h>
  58. #include <linux/static_key.h>
  59. #include <linux/aio.h>
  60. #include <linux/sched.h>
  61. #include <linux/filter.h>
  62. #include <linux/rculist_nulls.h>
  63. #include <linux/poll.h>
  64. #include <linux/atomic.h>
  65. #include <net/dst.h>
  66. #include <net/checksum.h>
  67. struct cgroup;
  68. struct cgroup_subsys;
  69. #ifdef CONFIG_NET
  70. int mem_cgroup_sockets_init(struct mem_cgroup *memcg, struct cgroup_subsys *ss);
  71. void mem_cgroup_sockets_destroy(struct mem_cgroup *memcg);
  72. #else
  73. static inline
  74. int mem_cgroup_sockets_init(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
  75. {
  76. return 0;
  77. }
  78. static inline
  79. void mem_cgroup_sockets_destroy(struct mem_cgroup *memcg)
  80. {
  81. }
  82. #endif
  83. /*
  84. * This structure really needs to be cleaned up.
  85. * Most of it is for TCP, and not used by any of
  86. * the other protocols.
  87. */
  88. /* Define this to get the SOCK_DBG debugging facility. */
  89. #define SOCK_DEBUGGING
  90. #ifdef SOCK_DEBUGGING
  91. #define SOCK_DEBUG(sk, msg...) do { if ((sk) && sock_flag((sk), SOCK_DBG)) \
  92. printk(KERN_DEBUG msg); } while (0)
  93. #else
  94. /* Validate arguments and do nothing */
  95. static inline __printf(2, 3)
  96. void SOCK_DEBUG(const struct sock *sk, const char *msg, ...)
  97. {
  98. }
  99. #endif
  100. /* This is the per-socket lock. The spinlock provides a synchronization
  101. * between user contexts and software interrupt processing, whereas the
  102. * mini-semaphore synchronizes multiple users amongst themselves.
  103. */
  104. typedef struct {
  105. spinlock_t slock;
  106. int owned;
  107. wait_queue_head_t wq;
  108. /*
  109. * We express the mutex-alike socket_lock semantics
  110. * to the lock validator by explicitly managing
  111. * the slock as a lock variant (in addition to
  112. * the slock itself):
  113. */
  114. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  115. struct lockdep_map dep_map;
  116. #endif
  117. } socket_lock_t;
  118. struct sock;
  119. struct proto;
  120. struct net;
  121. /**
  122. * struct sock_common - minimal network layer representation of sockets
  123. * @skc_daddr: Foreign IPv4 addr
  124. * @skc_rcv_saddr: Bound local IPv4 addr
  125. * @skc_hash: hash value used with various protocol lookup tables
  126. * @skc_u16hashes: two u16 hash values used by UDP lookup tables
  127. * @skc_family: network address family
  128. * @skc_state: Connection state
  129. * @skc_reuse: %SO_REUSEADDR setting
  130. * @skc_bound_dev_if: bound device index if != 0
  131. * @skc_bind_node: bind hash linkage for various protocol lookup tables
  132. * @skc_portaddr_node: second hash linkage for UDP/UDP-Lite protocol
  133. * @skc_prot: protocol handlers inside a network family
  134. * @skc_net: reference to the network namespace of this socket
  135. * @skc_node: main hash linkage for various protocol lookup tables
  136. * @skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
  137. * @skc_tx_queue_mapping: tx queue number for this connection
  138. * @skc_refcnt: reference count
  139. *
  140. * This is the minimal network layer representation of sockets, the header
  141. * for struct sock and struct inet_timewait_sock.
  142. */
  143. struct sock_common {
  144. /* skc_daddr and skc_rcv_saddr must be grouped :
  145. * cf INET_MATCH() and INET_TW_MATCH()
  146. */
  147. __be32 skc_daddr;
  148. __be32 skc_rcv_saddr;
  149. union {
  150. unsigned int skc_hash;
  151. __u16 skc_u16hashes[2];
  152. };
  153. unsigned short skc_family;
  154. volatile unsigned char skc_state;
  155. unsigned char skc_reuse;
  156. int skc_bound_dev_if;
  157. union {
  158. struct hlist_node skc_bind_node;
  159. struct hlist_nulls_node skc_portaddr_node;
  160. };
  161. struct proto *skc_prot;
  162. #ifdef CONFIG_NET_NS
  163. struct net *skc_net;
  164. #endif
  165. /*
  166. * fields between dontcopy_begin/dontcopy_end
  167. * are not copied in sock_copy()
  168. */
  169. /* private: */
  170. int skc_dontcopy_begin[0];
  171. /* public: */
  172. union {
  173. struct hlist_node skc_node;
  174. struct hlist_nulls_node skc_nulls_node;
  175. };
  176. int skc_tx_queue_mapping;
  177. atomic_t skc_refcnt;
  178. /* private: */
  179. int skc_dontcopy_end[0];
  180. /* public: */
  181. };
  182. struct cg_proto;
  183. /**
  184. * struct sock - network layer representation of sockets
  185. * @__sk_common: shared layout with inet_timewait_sock
  186. * @sk_shutdown: mask of %SEND_SHUTDOWN and/or %RCV_SHUTDOWN
  187. * @sk_userlocks: %SO_SNDBUF and %SO_RCVBUF settings
  188. * @sk_lock: synchronizer
  189. * @sk_rcvbuf: size of receive buffer in bytes
  190. * @sk_wq: sock wait queue and async head
  191. * @sk_dst_cache: destination cache
  192. * @sk_dst_lock: destination cache lock
  193. * @sk_policy: flow policy
  194. * @sk_receive_queue: incoming packets
  195. * @sk_wmem_alloc: transmit queue bytes committed
  196. * @sk_write_queue: Packet sending queue
  197. * @sk_async_wait_queue: DMA copied packets
  198. * @sk_omem_alloc: "o" is "option" or "other"
  199. * @sk_wmem_queued: persistent queue size
  200. * @sk_forward_alloc: space allocated forward
  201. * @sk_allocation: allocation mode
  202. * @sk_sndbuf: size of send buffer in bytes
  203. * @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
  204. * %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
  205. * @sk_no_check: %SO_NO_CHECK setting, wether or not checkup packets
  206. * @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
  207. * @sk_route_nocaps: forbidden route capabilities (e.g NETIF_F_GSO_MASK)
  208. * @sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
  209. * @sk_gso_max_size: Maximum GSO segment size to build
  210. * @sk_lingertime: %SO_LINGER l_linger setting
  211. * @sk_backlog: always used with the per-socket spinlock held
  212. * @sk_callback_lock: used with the callbacks in the end of this struct
  213. * @sk_error_queue: rarely used
  214. * @sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt,
  215. * IPV6_ADDRFORM for instance)
  216. * @sk_err: last error
  217. * @sk_err_soft: errors that don't cause failure but are the cause of a
  218. * persistent failure not just 'timed out'
  219. * @sk_drops: raw/udp drops counter
  220. * @sk_ack_backlog: current listen backlog
  221. * @sk_max_ack_backlog: listen backlog set in listen()
  222. * @sk_priority: %SO_PRIORITY setting
  223. * @sk_cgrp_prioidx: socket group's priority map index
  224. * @sk_type: socket type (%SOCK_STREAM, etc)
  225. * @sk_protocol: which protocol this socket belongs in this network family
  226. * @sk_peer_pid: &struct pid for this socket's peer
  227. * @sk_peer_cred: %SO_PEERCRED setting
  228. * @sk_rcvlowat: %SO_RCVLOWAT setting
  229. * @sk_rcvtimeo: %SO_RCVTIMEO setting
  230. * @sk_sndtimeo: %SO_SNDTIMEO setting
  231. * @sk_rxhash: flow hash received from netif layer
  232. * @sk_filter: socket filtering instructions
  233. * @sk_protinfo: private area, net family specific, when not using slab
  234. * @sk_timer: sock cleanup timer
  235. * @sk_stamp: time stamp of last packet received
  236. * @sk_socket: Identd and reporting IO signals
  237. * @sk_user_data: RPC layer private data
  238. * @sk_sndmsg_page: cached page for sendmsg
  239. * @sk_sndmsg_off: cached offset for sendmsg
  240. * @sk_peek_off: current peek_offset value
  241. * @sk_send_head: front of stuff to transmit
  242. * @sk_security: used by security modules
  243. * @sk_mark: generic packet mark
  244. * @sk_classid: this socket's cgroup classid
  245. * @sk_cgrp: this socket's cgroup-specific proto data
  246. * @sk_write_pending: a write to stream socket waits to start
  247. * @sk_state_change: callback to indicate change in the state of the sock
  248. * @sk_data_ready: callback to indicate there is data to be processed
  249. * @sk_write_space: callback to indicate there is bf sending space available
  250. * @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
  251. * @sk_backlog_rcv: callback to process the backlog
  252. * @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
  253. */
  254. struct sock {
  255. /*
  256. * Now struct inet_timewait_sock also uses sock_common, so please just
  257. * don't add nothing before this first member (__sk_common) --acme
  258. */
  259. struct sock_common __sk_common;
  260. #define sk_node __sk_common.skc_node
  261. #define sk_nulls_node __sk_common.skc_nulls_node
  262. #define sk_refcnt __sk_common.skc_refcnt
  263. #define sk_tx_queue_mapping __sk_common.skc_tx_queue_mapping
  264. #define sk_dontcopy_begin __sk_common.skc_dontcopy_begin
  265. #define sk_dontcopy_end __sk_common.skc_dontcopy_end
  266. #define sk_hash __sk_common.skc_hash
  267. #define sk_family __sk_common.skc_family
  268. #define sk_state __sk_common.skc_state
  269. #define sk_reuse __sk_common.skc_reuse
  270. #define sk_bound_dev_if __sk_common.skc_bound_dev_if
  271. #define sk_bind_node __sk_common.skc_bind_node
  272. #define sk_prot __sk_common.skc_prot
  273. #define sk_net __sk_common.skc_net
  274. socket_lock_t sk_lock;
  275. struct sk_buff_head sk_receive_queue;
  276. /*
  277. * The backlog queue is special, it is always used with
  278. * the per-socket spinlock held and requires low latency
  279. * access. Therefore we special case it's implementation.
  280. * Note : rmem_alloc is in this structure to fill a hole
  281. * on 64bit arches, not because its logically part of
  282. * backlog.
  283. */
  284. struct {
  285. atomic_t rmem_alloc;
  286. int len;
  287. struct sk_buff *head;
  288. struct sk_buff *tail;
  289. } sk_backlog;
  290. #define sk_rmem_alloc sk_backlog.rmem_alloc
  291. int sk_forward_alloc;
  292. #ifdef CONFIG_RPS
  293. __u32 sk_rxhash;
  294. #endif
  295. atomic_t sk_drops;
  296. int sk_rcvbuf;
  297. struct sk_filter __rcu *sk_filter;
  298. struct socket_wq __rcu *sk_wq;
  299. #ifdef CONFIG_NET_DMA
  300. struct sk_buff_head sk_async_wait_queue;
  301. #endif
  302. #ifdef CONFIG_XFRM
  303. struct xfrm_policy *sk_policy[2];
  304. #endif
  305. unsigned long sk_flags;
  306. struct dst_entry *sk_dst_cache;
  307. spinlock_t sk_dst_lock;
  308. atomic_t sk_wmem_alloc;
  309. atomic_t sk_omem_alloc;
  310. int sk_sndbuf;
  311. struct sk_buff_head sk_write_queue;
  312. kmemcheck_bitfield_begin(flags);
  313. unsigned int sk_shutdown : 2,
  314. sk_no_check : 2,
  315. sk_userlocks : 4,
  316. sk_protocol : 8,
  317. sk_type : 16;
  318. kmemcheck_bitfield_end(flags);
  319. int sk_wmem_queued;
  320. gfp_t sk_allocation;
  321. netdev_features_t sk_route_caps;
  322. netdev_features_t sk_route_nocaps;
  323. int sk_gso_type;
  324. unsigned int sk_gso_max_size;
  325. int sk_rcvlowat;
  326. unsigned long sk_lingertime;
  327. struct sk_buff_head sk_error_queue;
  328. struct proto *sk_prot_creator;
  329. rwlock_t sk_callback_lock;
  330. int sk_err,
  331. sk_err_soft;
  332. unsigned short sk_ack_backlog;
  333. unsigned short sk_max_ack_backlog;
  334. __u32 sk_priority;
  335. #ifdef CONFIG_CGROUPS
  336. __u32 sk_cgrp_prioidx;
  337. #endif
  338. struct pid *sk_peer_pid;
  339. const struct cred *sk_peer_cred;
  340. long sk_rcvtimeo;
  341. long sk_sndtimeo;
  342. void *sk_protinfo;
  343. struct timer_list sk_timer;
  344. ktime_t sk_stamp;
  345. struct socket *sk_socket;
  346. void *sk_user_data;
  347. struct page *sk_sndmsg_page;
  348. struct sk_buff *sk_send_head;
  349. __u32 sk_sndmsg_off;
  350. __s32 sk_peek_off;
  351. int sk_write_pending;
  352. #ifdef CONFIG_SECURITY
  353. void *sk_security;
  354. #endif
  355. __u32 sk_mark;
  356. u32 sk_classid;
  357. struct cg_proto *sk_cgrp;
  358. void (*sk_state_change)(struct sock *sk);
  359. void (*sk_data_ready)(struct sock *sk, int bytes);
  360. void (*sk_write_space)(struct sock *sk);
  361. void (*sk_error_report)(struct sock *sk);
  362. int (*sk_backlog_rcv)(struct sock *sk,
  363. struct sk_buff *skb);
  364. void (*sk_destruct)(struct sock *sk);
  365. };
  366. /*
  367. * SK_CAN_REUSE and SK_NO_REUSE on a socket mean that the socket is OK
  368. * or not whether his port will be reused by someone else. SK_FORCE_REUSE
  369. * on a socket means that the socket will reuse everybody else's port
  370. * without looking at the other's sk_reuse value.
  371. */
  372. #define SK_NO_REUSE 0
  373. #define SK_CAN_REUSE 1
  374. #define SK_FORCE_REUSE 2
  375. static inline int sk_peek_offset(struct sock *sk, int flags)
  376. {
  377. if ((flags & MSG_PEEK) && (sk->sk_peek_off >= 0))
  378. return sk->sk_peek_off;
  379. else
  380. return 0;
  381. }
  382. static inline void sk_peek_offset_bwd(struct sock *sk, int val)
  383. {
  384. if (sk->sk_peek_off >= 0) {
  385. if (sk->sk_peek_off >= val)
  386. sk->sk_peek_off -= val;
  387. else
  388. sk->sk_peek_off = 0;
  389. }
  390. }
  391. static inline void sk_peek_offset_fwd(struct sock *sk, int val)
  392. {
  393. if (sk->sk_peek_off >= 0)
  394. sk->sk_peek_off += val;
  395. }
  396. /*
  397. * Hashed lists helper routines
  398. */
  399. static inline struct sock *sk_entry(const struct hlist_node *node)
  400. {
  401. return hlist_entry(node, struct sock, sk_node);
  402. }
  403. static inline struct sock *__sk_head(const struct hlist_head *head)
  404. {
  405. return hlist_entry(head->first, struct sock, sk_node);
  406. }
  407. static inline struct sock *sk_head(const struct hlist_head *head)
  408. {
  409. return hlist_empty(head) ? NULL : __sk_head(head);
  410. }
  411. static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
  412. {
  413. return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
  414. }
  415. static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
  416. {
  417. return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
  418. }
  419. static inline struct sock *sk_next(const struct sock *sk)
  420. {
  421. return sk->sk_node.next ?
  422. hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
  423. }
  424. static inline struct sock *sk_nulls_next(const struct sock *sk)
  425. {
  426. return (!is_a_nulls(sk->sk_nulls_node.next)) ?
  427. hlist_nulls_entry(sk->sk_nulls_node.next,
  428. struct sock, sk_nulls_node) :
  429. NULL;
  430. }
  431. static inline bool sk_unhashed(const struct sock *sk)
  432. {
  433. return hlist_unhashed(&sk->sk_node);
  434. }
  435. static inline bool sk_hashed(const struct sock *sk)
  436. {
  437. return !sk_unhashed(sk);
  438. }
  439. static inline void sk_node_init(struct hlist_node *node)
  440. {
  441. node->pprev = NULL;
  442. }
  443. static inline void sk_nulls_node_init(struct hlist_nulls_node *node)
  444. {
  445. node->pprev = NULL;
  446. }
  447. static inline void __sk_del_node(struct sock *sk)
  448. {
  449. __hlist_del(&sk->sk_node);
  450. }
  451. /* NB: equivalent to hlist_del_init_rcu */
  452. static inline bool __sk_del_node_init(struct sock *sk)
  453. {
  454. if (sk_hashed(sk)) {
  455. __sk_del_node(sk);
  456. sk_node_init(&sk->sk_node);
  457. return true;
  458. }
  459. return false;
  460. }
  461. /* Grab socket reference count. This operation is valid only
  462. when sk is ALREADY grabbed f.e. it is found in hash table
  463. or a list and the lookup is made under lock preventing hash table
  464. modifications.
  465. */
  466. static inline void sock_hold(struct sock *sk)
  467. {
  468. atomic_inc(&sk->sk_refcnt);
  469. }
  470. /* Ungrab socket in the context, which assumes that socket refcnt
  471. cannot hit zero, f.e. it is true in context of any socketcall.
  472. */
  473. static inline void __sock_put(struct sock *sk)
  474. {
  475. atomic_dec(&sk->sk_refcnt);
  476. }
  477. static inline bool sk_del_node_init(struct sock *sk)
  478. {
  479. bool rc = __sk_del_node_init(sk);
  480. if (rc) {
  481. /* paranoid for a while -acme */
  482. WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
  483. __sock_put(sk);
  484. }
  485. return rc;
  486. }
  487. #define sk_del_node_init_rcu(sk) sk_del_node_init(sk)
  488. static inline bool __sk_nulls_del_node_init_rcu(struct sock *sk)
  489. {
  490. if (sk_hashed(sk)) {
  491. hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
  492. return true;
  493. }
  494. return false;
  495. }
  496. static inline bool sk_nulls_del_node_init_rcu(struct sock *sk)
  497. {
  498. bool rc = __sk_nulls_del_node_init_rcu(sk);
  499. if (rc) {
  500. /* paranoid for a while -acme */
  501. WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
  502. __sock_put(sk);
  503. }
  504. return rc;
  505. }
  506. static inline void __sk_add_node(struct sock *sk, struct hlist_head *list)
  507. {
  508. hlist_add_head(&sk->sk_node, list);
  509. }
  510. static inline void sk_add_node(struct sock *sk, struct hlist_head *list)
  511. {
  512. sock_hold(sk);
  513. __sk_add_node(sk, list);
  514. }
  515. static inline void sk_add_node_rcu(struct sock *sk, struct hlist_head *list)
  516. {
  517. sock_hold(sk);
  518. hlist_add_head_rcu(&sk->sk_node, list);
  519. }
  520. static inline void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
  521. {
  522. hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
  523. }
  524. static inline void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
  525. {
  526. sock_hold(sk);
  527. __sk_nulls_add_node_rcu(sk, list);
  528. }
  529. static inline void __sk_del_bind_node(struct sock *sk)
  530. {
  531. __hlist_del(&sk->sk_bind_node);
  532. }
  533. static inline void sk_add_bind_node(struct sock *sk,
  534. struct hlist_head *list)
  535. {
  536. hlist_add_head(&sk->sk_bind_node, list);
  537. }
  538. #define sk_for_each(__sk, node, list) \
  539. hlist_for_each_entry(__sk, node, list, sk_node)
  540. #define sk_for_each_rcu(__sk, node, list) \
  541. hlist_for_each_entry_rcu(__sk, node, list, sk_node)
  542. #define sk_nulls_for_each(__sk, node, list) \
  543. hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
  544. #define sk_nulls_for_each_rcu(__sk, node, list) \
  545. hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
  546. #define sk_for_each_from(__sk, node) \
  547. if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
  548. hlist_for_each_entry_from(__sk, node, sk_node)
  549. #define sk_nulls_for_each_from(__sk, node) \
  550. if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
  551. hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
  552. #define sk_for_each_safe(__sk, node, tmp, list) \
  553. hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
  554. #define sk_for_each_bound(__sk, node, list) \
  555. hlist_for_each_entry(__sk, node, list, sk_bind_node)
  556. /* Sock flags */
  557. enum sock_flags {
  558. SOCK_DEAD,
  559. SOCK_DONE,
  560. SOCK_URGINLINE,
  561. SOCK_KEEPOPEN,
  562. SOCK_LINGER,
  563. SOCK_DESTROY,
  564. SOCK_BROADCAST,
  565. SOCK_TIMESTAMP,
  566. SOCK_ZAPPED,
  567. SOCK_USE_WRITE_QUEUE, /* whether to call sk->sk_write_space in sock_wfree */
  568. SOCK_DBG, /* %SO_DEBUG setting */
  569. SOCK_RCVTSTAMP, /* %SO_TIMESTAMP setting */
  570. SOCK_RCVTSTAMPNS, /* %SO_TIMESTAMPNS setting */
  571. SOCK_LOCALROUTE, /* route locally only, %SO_DONTROUTE setting */
  572. SOCK_QUEUE_SHRUNK, /* write queue has been shrunk recently */
  573. SOCK_TIMESTAMPING_TX_HARDWARE, /* %SOF_TIMESTAMPING_TX_HARDWARE */
  574. SOCK_TIMESTAMPING_TX_SOFTWARE, /* %SOF_TIMESTAMPING_TX_SOFTWARE */
  575. SOCK_TIMESTAMPING_RX_HARDWARE, /* %SOF_TIMESTAMPING_RX_HARDWARE */
  576. SOCK_TIMESTAMPING_RX_SOFTWARE, /* %SOF_TIMESTAMPING_RX_SOFTWARE */
  577. SOCK_TIMESTAMPING_SOFTWARE, /* %SOF_TIMESTAMPING_SOFTWARE */
  578. SOCK_TIMESTAMPING_RAW_HARDWARE, /* %SOF_TIMESTAMPING_RAW_HARDWARE */
  579. SOCK_TIMESTAMPING_SYS_HARDWARE, /* %SOF_TIMESTAMPING_SYS_HARDWARE */
  580. SOCK_FASYNC, /* fasync() active */
  581. SOCK_RXQ_OVFL,
  582. SOCK_ZEROCOPY, /* buffers from userspace */
  583. SOCK_WIFI_STATUS, /* push wifi status to userspace */
  584. SOCK_NOFCS, /* Tell NIC not to do the Ethernet FCS.
  585. * Will use last 4 bytes of packet sent from
  586. * user-space instead.
  587. */
  588. };
  589. static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
  590. {
  591. nsk->sk_flags = osk->sk_flags;
  592. }
  593. static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
  594. {
  595. __set_bit(flag, &sk->sk_flags);
  596. }
  597. static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
  598. {
  599. __clear_bit(flag, &sk->sk_flags);
  600. }
  601. static inline bool sock_flag(const struct sock *sk, enum sock_flags flag)
  602. {
  603. return test_bit(flag, &sk->sk_flags);
  604. }
  605. static inline void sk_acceptq_removed(struct sock *sk)
  606. {
  607. sk->sk_ack_backlog--;
  608. }
  609. static inline void sk_acceptq_added(struct sock *sk)
  610. {
  611. sk->sk_ack_backlog++;
  612. }
  613. static inline bool sk_acceptq_is_full(const struct sock *sk)
  614. {
  615. return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
  616. }
  617. /*
  618. * Compute minimal free write space needed to queue new packets.
  619. */
  620. static inline int sk_stream_min_wspace(const struct sock *sk)
  621. {
  622. return sk->sk_wmem_queued >> 1;
  623. }
  624. static inline int sk_stream_wspace(const struct sock *sk)
  625. {
  626. return sk->sk_sndbuf - sk->sk_wmem_queued;
  627. }
  628. extern void sk_stream_write_space(struct sock *sk);
  629. static inline bool sk_stream_memory_free(const struct sock *sk)
  630. {
  631. return sk->sk_wmem_queued < sk->sk_sndbuf;
  632. }
  633. /* OOB backlog add */
  634. static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
  635. {
  636. /* dont let skb dst not refcounted, we are going to leave rcu lock */
  637. skb_dst_force(skb);
  638. if (!sk->sk_backlog.tail)
  639. sk->sk_backlog.head = skb;
  640. else
  641. sk->sk_backlog.tail->next = skb;
  642. sk->sk_backlog.tail = skb;
  643. skb->next = NULL;
  644. }
  645. /*
  646. * Take into account size of receive queue and backlog queue
  647. * Do not take into account this skb truesize,
  648. * to allow even a single big packet to come.
  649. */
  650. static inline bool sk_rcvqueues_full(const struct sock *sk, const struct sk_buff *skb,
  651. unsigned int limit)
  652. {
  653. unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
  654. return qsize > limit;
  655. }
  656. /* The per-socket spinlock must be held here. */
  657. static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *skb,
  658. unsigned int limit)
  659. {
  660. if (sk_rcvqueues_full(sk, skb, limit))
  661. return -ENOBUFS;
  662. __sk_add_backlog(sk, skb);
  663. sk->sk_backlog.len += skb->truesize;
  664. return 0;
  665. }
  666. static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
  667. {
  668. return sk->sk_backlog_rcv(sk, skb);
  669. }
  670. static inline void sock_rps_record_flow(const struct sock *sk)
  671. {
  672. #ifdef CONFIG_RPS
  673. struct rps_sock_flow_table *sock_flow_table;
  674. rcu_read_lock();
  675. sock_flow_table = rcu_dereference(rps_sock_flow_table);
  676. rps_record_sock_flow(sock_flow_table, sk->sk_rxhash);
  677. rcu_read_unlock();
  678. #endif
  679. }
  680. static inline void sock_rps_reset_flow(const struct sock *sk)
  681. {
  682. #ifdef CONFIG_RPS
  683. struct rps_sock_flow_table *sock_flow_table;
  684. rcu_read_lock();
  685. sock_flow_table = rcu_dereference(rps_sock_flow_table);
  686. rps_reset_sock_flow(sock_flow_table, sk->sk_rxhash);
  687. rcu_read_unlock();
  688. #endif
  689. }
  690. static inline void sock_rps_save_rxhash(struct sock *sk,
  691. const struct sk_buff *skb)
  692. {
  693. #ifdef CONFIG_RPS
  694. if (unlikely(sk->sk_rxhash != skb->rxhash)) {
  695. sock_rps_reset_flow(sk);
  696. sk->sk_rxhash = skb->rxhash;
  697. }
  698. #endif
  699. }
  700. static inline void sock_rps_reset_rxhash(struct sock *sk)
  701. {
  702. #ifdef CONFIG_RPS
  703. sock_rps_reset_flow(sk);
  704. sk->sk_rxhash = 0;
  705. #endif
  706. }
  707. #define sk_wait_event(__sk, __timeo, __condition) \
  708. ({ int __rc; \
  709. release_sock(__sk); \
  710. __rc = __condition; \
  711. if (!__rc) { \
  712. *(__timeo) = schedule_timeout(*(__timeo)); \
  713. } \
  714. lock_sock(__sk); \
  715. __rc = __condition; \
  716. __rc; \
  717. })
  718. extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
  719. extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
  720. extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
  721. extern int sk_stream_error(struct sock *sk, int flags, int err);
  722. extern void sk_stream_kill_queues(struct sock *sk);
  723. extern int sk_wait_data(struct sock *sk, long *timeo);
  724. struct request_sock_ops;
  725. struct timewait_sock_ops;
  726. struct inet_hashinfo;
  727. struct raw_hashinfo;
  728. struct module;
  729. /* Networking protocol blocks we attach to sockets.
  730. * socket layer -> transport layer interface
  731. * transport -> network interface is defined by struct inet_proto
  732. */
  733. struct proto {
  734. void (*close)(struct sock *sk,
  735. long timeout);
  736. int (*connect)(struct sock *sk,
  737. struct sockaddr *uaddr,
  738. int addr_len);
  739. int (*disconnect)(struct sock *sk, int flags);
  740. struct sock * (*accept)(struct sock *sk, int flags, int *err);
  741. int (*ioctl)(struct sock *sk, int cmd,
  742. unsigned long arg);
  743. int (*init)(struct sock *sk);
  744. void (*destroy)(struct sock *sk);
  745. void (*shutdown)(struct sock *sk, int how);
  746. int (*setsockopt)(struct sock *sk, int level,
  747. int optname, char __user *optval,
  748. unsigned int optlen);
  749. int (*getsockopt)(struct sock *sk, int level,
  750. int optname, char __user *optval,
  751. int __user *option);
  752. #ifdef CONFIG_COMPAT
  753. int (*compat_setsockopt)(struct sock *sk,
  754. int level,
  755. int optname, char __user *optval,
  756. unsigned int optlen);
  757. int (*compat_getsockopt)(struct sock *sk,
  758. int level,
  759. int optname, char __user *optval,
  760. int __user *option);
  761. int (*compat_ioctl)(struct sock *sk,
  762. unsigned int cmd, unsigned long arg);
  763. #endif
  764. int (*sendmsg)(struct kiocb *iocb, struct sock *sk,
  765. struct msghdr *msg, size_t len);
  766. int (*recvmsg)(struct kiocb *iocb, struct sock *sk,
  767. struct msghdr *msg,
  768. size_t len, int noblock, int flags,
  769. int *addr_len);
  770. int (*sendpage)(struct sock *sk, struct page *page,
  771. int offset, size_t size, int flags);
  772. int (*bind)(struct sock *sk,
  773. struct sockaddr *uaddr, int addr_len);
  774. int (*backlog_rcv) (struct sock *sk,
  775. struct sk_buff *skb);
  776. /* Keeping track of sk's, looking them up, and port selection methods. */
  777. void (*hash)(struct sock *sk);
  778. void (*unhash)(struct sock *sk);
  779. void (*rehash)(struct sock *sk);
  780. int (*get_port)(struct sock *sk, unsigned short snum);
  781. void (*clear_sk)(struct sock *sk, int size);
  782. /* Keeping track of sockets in use */
  783. #ifdef CONFIG_PROC_FS
  784. unsigned int inuse_idx;
  785. #endif
  786. /* Memory pressure */
  787. void (*enter_memory_pressure)(struct sock *sk);
  788. atomic_long_t *memory_allocated; /* Current allocated memory. */
  789. struct percpu_counter *sockets_allocated; /* Current number of sockets. */
  790. /*
  791. * Pressure flag: try to collapse.
  792. * Technical note: it is used by multiple contexts non atomically.
  793. * All the __sk_mem_schedule() is of this nature: accounting
  794. * is strict, actions are advisory and have some latency.
  795. */
  796. int *memory_pressure;
  797. long *sysctl_mem;
  798. int *sysctl_wmem;
  799. int *sysctl_rmem;
  800. int max_header;
  801. bool no_autobind;
  802. struct kmem_cache *slab;
  803. unsigned int obj_size;
  804. int slab_flags;
  805. struct percpu_counter *orphan_count;
  806. struct request_sock_ops *rsk_prot;
  807. struct timewait_sock_ops *twsk_prot;
  808. union {
  809. struct inet_hashinfo *hashinfo;
  810. struct udp_table *udp_table;
  811. struct raw_hashinfo *raw_hash;
  812. } h;
  813. struct module *owner;
  814. char name[32];
  815. struct list_head node;
  816. #ifdef SOCK_REFCNT_DEBUG
  817. atomic_t socks;
  818. #endif
  819. #ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
  820. /*
  821. * cgroup specific init/deinit functions. Called once for all
  822. * protocols that implement it, from cgroups populate function.
  823. * This function has to setup any files the protocol want to
  824. * appear in the kmem cgroup filesystem.
  825. */
  826. int (*init_cgroup)(struct mem_cgroup *memcg,
  827. struct cgroup_subsys *ss);
  828. void (*destroy_cgroup)(struct mem_cgroup *memcg);
  829. struct cg_proto *(*proto_cgroup)(struct mem_cgroup *memcg);
  830. #endif
  831. };
  832. /*
  833. * Bits in struct cg_proto.flags
  834. */
  835. enum cg_proto_flags {
  836. /* Currently active and new sockets should be assigned to cgroups */
  837. MEMCG_SOCK_ACTIVE,
  838. /* It was ever activated; we must disarm static keys on destruction */
  839. MEMCG_SOCK_ACTIVATED,
  840. };
  841. struct cg_proto {
  842. void (*enter_memory_pressure)(struct sock *sk);
  843. struct res_counter *memory_allocated; /* Current allocated memory. */
  844. struct percpu_counter *sockets_allocated; /* Current number of sockets. */
  845. int *memory_pressure;
  846. long *sysctl_mem;
  847. unsigned long flags;
  848. /*
  849. * memcg field is used to find which memcg we belong directly
  850. * Each memcg struct can hold more than one cg_proto, so container_of
  851. * won't really cut.
  852. *
  853. * The elegant solution would be having an inverse function to
  854. * proto_cgroup in struct proto, but that means polluting the structure
  855. * for everybody, instead of just for memcg users.
  856. */
  857. struct mem_cgroup *memcg;
  858. };
  859. extern int proto_register(struct proto *prot, int alloc_slab);
  860. extern void proto_unregister(struct proto *prot);
  861. static inline bool memcg_proto_active(struct cg_proto *cg_proto)
  862. {
  863. return test_bit(MEMCG_SOCK_ACTIVE, &cg_proto->flags);
  864. }
  865. static inline bool memcg_proto_activated(struct cg_proto *cg_proto)
  866. {
  867. return test_bit(MEMCG_SOCK_ACTIVATED, &cg_proto->flags);
  868. }
  869. #ifdef SOCK_REFCNT_DEBUG
  870. static inline void sk_refcnt_debug_inc(struct sock *sk)
  871. {
  872. atomic_inc(&sk->sk_prot->socks);
  873. }
  874. static inline void sk_refcnt_debug_dec(struct sock *sk)
  875. {
  876. atomic_dec(&sk->sk_prot->socks);
  877. printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
  878. sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
  879. }
  880. inline void sk_refcnt_debug_release(const struct sock *sk)
  881. {
  882. if (atomic_read(&sk->sk_refcnt) != 1)
  883. printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
  884. sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
  885. }
  886. #else /* SOCK_REFCNT_DEBUG */
  887. #define sk_refcnt_debug_inc(sk) do { } while (0)
  888. #define sk_refcnt_debug_dec(sk) do { } while (0)
  889. #define sk_refcnt_debug_release(sk) do { } while (0)
  890. #endif /* SOCK_REFCNT_DEBUG */
  891. #if defined(CONFIG_CGROUP_MEM_RES_CTLR_KMEM) && defined(CONFIG_NET)
  892. extern struct static_key memcg_socket_limit_enabled;
  893. static inline struct cg_proto *parent_cg_proto(struct proto *proto,
  894. struct cg_proto *cg_proto)
  895. {
  896. return proto->proto_cgroup(parent_mem_cgroup(cg_proto->memcg));
  897. }
  898. #define mem_cgroup_sockets_enabled static_key_false(&memcg_socket_limit_enabled)
  899. #else
  900. #define mem_cgroup_sockets_enabled 0
  901. static inline struct cg_proto *parent_cg_proto(struct proto *proto,
  902. struct cg_proto *cg_proto)
  903. {
  904. return NULL;
  905. }
  906. #endif
  907. static inline bool sk_has_memory_pressure(const struct sock *sk)
  908. {
  909. return sk->sk_prot->memory_pressure != NULL;
  910. }
  911. static inline bool sk_under_memory_pressure(const struct sock *sk)
  912. {
  913. if (!sk->sk_prot->memory_pressure)
  914. return false;
  915. if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
  916. return !!*sk->sk_cgrp->memory_pressure;
  917. return !!*sk->sk_prot->memory_pressure;
  918. }
  919. static inline void sk_leave_memory_pressure(struct sock *sk)
  920. {
  921. int *memory_pressure = sk->sk_prot->memory_pressure;
  922. if (!memory_pressure)
  923. return;
  924. if (*memory_pressure)
  925. *memory_pressure = 0;
  926. if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
  927. struct cg_proto *cg_proto = sk->sk_cgrp;
  928. struct proto *prot = sk->sk_prot;
  929. for (; cg_proto; cg_proto = parent_cg_proto(prot, cg_proto))
  930. if (*cg_proto->memory_pressure)
  931. *cg_proto->memory_pressure = 0;
  932. }
  933. }
  934. static inline void sk_enter_memory_pressure(struct sock *sk)
  935. {
  936. if (!sk->sk_prot->enter_memory_pressure)
  937. return;
  938. if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
  939. struct cg_proto *cg_proto = sk->sk_cgrp;
  940. struct proto *prot = sk->sk_prot;
  941. for (; cg_proto; cg_proto = parent_cg_proto(prot, cg_proto))
  942. cg_proto->enter_memory_pressure(sk);
  943. }
  944. sk->sk_prot->enter_memory_pressure(sk);
  945. }
  946. static inline long sk_prot_mem_limits(const struct sock *sk, int index)
  947. {
  948. long *prot = sk->sk_prot->sysctl_mem;
  949. if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
  950. prot = sk->sk_cgrp->sysctl_mem;
  951. return prot[index];
  952. }
  953. static inline void memcg_memory_allocated_add(struct cg_proto *prot,
  954. unsigned long amt,
  955. int *parent_status)
  956. {
  957. struct res_counter *fail;
  958. int ret;
  959. ret = res_counter_charge_nofail(prot->memory_allocated,
  960. amt << PAGE_SHIFT, &fail);
  961. if (ret < 0)
  962. *parent_status = OVER_LIMIT;
  963. }
  964. static inline void memcg_memory_allocated_sub(struct cg_proto *prot,
  965. unsigned long amt)
  966. {
  967. res_counter_uncharge(prot->memory_allocated, amt << PAGE_SHIFT);
  968. }
  969. static inline u64 memcg_memory_allocated_read(struct cg_proto *prot)
  970. {
  971. u64 ret;
  972. ret = res_counter_read_u64(prot->memory_allocated, RES_USAGE);
  973. return ret >> PAGE_SHIFT;
  974. }
  975. static inline long
  976. sk_memory_allocated(const struct sock *sk)
  977. {
  978. struct proto *prot = sk->sk_prot;
  979. if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
  980. return memcg_memory_allocated_read(sk->sk_cgrp);
  981. return atomic_long_read(prot->memory_allocated);
  982. }
  983. static inline long
  984. sk_memory_allocated_add(struct sock *sk, int amt, int *parent_status)
  985. {
  986. struct proto *prot = sk->sk_prot;
  987. if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
  988. memcg_memory_allocated_add(sk->sk_cgrp, amt, parent_status);
  989. /* update the root cgroup regardless */
  990. atomic_long_add_return(amt, prot->memory_allocated);
  991. return memcg_memory_allocated_read(sk->sk_cgrp);
  992. }
  993. return atomic_long_add_return(amt, prot->memory_allocated);
  994. }
  995. static inline void
  996. sk_memory_allocated_sub(struct sock *sk, int amt)
  997. {
  998. struct proto *prot = sk->sk_prot;
  999. if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
  1000. memcg_memory_allocated_sub(sk->sk_cgrp, amt);
  1001. atomic_long_sub(amt, prot->memory_allocated);
  1002. }
  1003. static inline void sk_sockets_allocated_dec(struct sock *sk)
  1004. {
  1005. struct proto *prot = sk->sk_prot;
  1006. if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
  1007. struct cg_proto *cg_proto = sk->sk_cgrp;
  1008. for (; cg_proto; cg_proto = parent_cg_proto(prot, cg_proto))
  1009. percpu_counter_dec(cg_proto->sockets_allocated);
  1010. }
  1011. percpu_counter_dec(prot->sockets_allocated);
  1012. }
  1013. static inline void sk_sockets_allocated_inc(struct sock *sk)
  1014. {
  1015. struct proto *prot = sk->sk_prot;
  1016. if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
  1017. struct cg_proto *cg_proto = sk->sk_cgrp;
  1018. for (; cg_proto; cg_proto = parent_cg_proto(prot, cg_proto))
  1019. percpu_counter_inc(cg_proto->sockets_allocated);
  1020. }
  1021. percpu_counter_inc(prot->sockets_allocated);
  1022. }
  1023. static inline int
  1024. sk_sockets_allocated_read_positive(struct sock *sk)
  1025. {
  1026. struct proto *prot = sk->sk_prot;
  1027. if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
  1028. return percpu_counter_read_positive(sk->sk_cgrp->sockets_allocated);
  1029. return percpu_counter_read_positive(prot->sockets_allocated);
  1030. }
  1031. static inline int
  1032. proto_sockets_allocated_sum_positive(struct proto *prot)
  1033. {
  1034. return percpu_counter_sum_positive(prot->sockets_allocated);
  1035. }
  1036. static inline long
  1037. proto_memory_allocated(struct proto *prot)
  1038. {
  1039. return atomic_long_read(prot->memory_allocated);
  1040. }
  1041. static inline bool
  1042. proto_memory_pressure(struct proto *prot)
  1043. {
  1044. if (!prot->memory_pressure)
  1045. return false;
  1046. return !!*prot->memory_pressure;
  1047. }
  1048. #ifdef CONFIG_PROC_FS
  1049. /* Called with local bh disabled */
  1050. extern void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
  1051. extern int sock_prot_inuse_get(struct net *net, struct proto *proto);
  1052. #else
  1053. static inline void sock_prot_inuse_add(struct net *net, struct proto *prot,
  1054. int inc)
  1055. {
  1056. }
  1057. #endif
  1058. /* With per-bucket locks this operation is not-atomic, so that
  1059. * this version is not worse.
  1060. */
  1061. static inline void __sk_prot_rehash(struct sock *sk)
  1062. {
  1063. sk->sk_prot->unhash(sk);
  1064. sk->sk_prot->hash(sk);
  1065. }
  1066. void sk_prot_clear_portaddr_nulls(struct sock *sk, int size);
  1067. /* About 10 seconds */
  1068. #define SOCK_DESTROY_TIME (10*HZ)
  1069. /* Sockets 0-1023 can't be bound to unless you are superuser */
  1070. #define PROT_SOCK 1024
  1071. #define SHUTDOWN_MASK 3
  1072. #define RCV_SHUTDOWN 1
  1073. #define SEND_SHUTDOWN 2
  1074. #define SOCK_SNDBUF_LOCK 1
  1075. #define SOCK_RCVBUF_LOCK 2
  1076. #define SOCK_BINDADDR_LOCK 4
  1077. #define SOCK_BINDPORT_LOCK 8
  1078. /* sock_iocb: used to kick off async processing of socket ios */
  1079. struct sock_iocb {
  1080. struct list_head list;
  1081. int flags;
  1082. int size;
  1083. struct socket *sock;
  1084. struct sock *sk;
  1085. struct scm_cookie *scm;
  1086. struct msghdr *msg, async_msg;
  1087. struct kiocb *kiocb;
  1088. };
  1089. static inline struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
  1090. {
  1091. return (struct sock_iocb *)iocb->private;
  1092. }
  1093. static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
  1094. {
  1095. return si->kiocb;
  1096. }
  1097. struct socket_alloc {
  1098. struct socket socket;
  1099. struct inode vfs_inode;
  1100. };
  1101. static inline struct socket *SOCKET_I(struct inode *inode)
  1102. {
  1103. return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
  1104. }
  1105. static inline struct inode *SOCK_INODE(struct socket *socket)
  1106. {
  1107. return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
  1108. }
  1109. /*
  1110. * Functions for memory accounting
  1111. */
  1112. extern int __sk_mem_schedule(struct sock *sk, int size, int kind);
  1113. extern void __sk_mem_reclaim(struct sock *sk);
  1114. #define SK_MEM_QUANTUM ((int)PAGE_SIZE)
  1115. #define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
  1116. #define SK_MEM_SEND 0
  1117. #define SK_MEM_RECV 1
  1118. static inline int sk_mem_pages(int amt)
  1119. {
  1120. return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
  1121. }
  1122. static inline bool sk_has_account(struct sock *sk)
  1123. {
  1124. /* return true if protocol supports memory accounting */
  1125. return !!sk->sk_prot->memory_allocated;
  1126. }
  1127. static inline bool sk_wmem_schedule(struct sock *sk, int size)
  1128. {
  1129. if (!sk_has_account(sk))
  1130. return true;
  1131. return size <= sk->sk_forward_alloc ||
  1132. __sk_mem_schedule(sk, size, SK_MEM_SEND);
  1133. }
  1134. static inline bool sk_rmem_schedule(struct sock *sk, int size)
  1135. {
  1136. if (!sk_has_account(sk))
  1137. return true;
  1138. return size <= sk->sk_forward_alloc ||
  1139. __sk_mem_schedule(sk, size, SK_MEM_RECV);
  1140. }
  1141. static inline void sk_mem_reclaim(struct sock *sk)
  1142. {
  1143. if (!sk_has_account(sk))
  1144. return;
  1145. if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
  1146. __sk_mem_reclaim(sk);
  1147. }
  1148. static inline void sk_mem_reclaim_partial(struct sock *sk)
  1149. {
  1150. if (!sk_has_account(sk))
  1151. return;
  1152. if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
  1153. __sk_mem_reclaim(sk);
  1154. }
  1155. static inline void sk_mem_charge(struct sock *sk, int size)
  1156. {
  1157. if (!sk_has_account(sk))
  1158. return;
  1159. sk->sk_forward_alloc -= size;
  1160. }
  1161. static inline void sk_mem_uncharge(struct sock *sk, int size)
  1162. {
  1163. if (!sk_has_account(sk))
  1164. return;
  1165. sk->sk_forward_alloc += size;
  1166. }
  1167. static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
  1168. {
  1169. sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
  1170. sk->sk_wmem_queued -= skb->truesize;
  1171. sk_mem_uncharge(sk, skb->truesize);
  1172. __kfree_skb(skb);
  1173. }
  1174. /* Used by processes to "lock" a socket state, so that
  1175. * interrupts and bottom half handlers won't change it
  1176. * from under us. It essentially blocks any incoming
  1177. * packets, so that we won't get any new data or any
  1178. * packets that change the state of the socket.
  1179. *
  1180. * While locked, BH processing will add new packets to
  1181. * the backlog queue. This queue is processed by the
  1182. * owner of the socket lock right before it is released.
  1183. *
  1184. * Since ~2.3.5 it is also exclusive sleep lock serializing
  1185. * accesses from user process context.
  1186. */
  1187. #define sock_owned_by_user(sk) ((sk)->sk_lock.owned)
  1188. /*
  1189. * Macro so as to not evaluate some arguments when
  1190. * lockdep is not enabled.
  1191. *
  1192. * Mark both the sk_lock and the sk_lock.slock as a
  1193. * per-address-family lock class.
  1194. */
  1195. #define sock_lock_init_class_and_name(sk, sname, skey, name, key) \
  1196. do { \
  1197. sk->sk_lock.owned = 0; \
  1198. init_waitqueue_head(&sk->sk_lock.wq); \
  1199. spin_lock_init(&(sk)->sk_lock.slock); \
  1200. debug_check_no_locks_freed((void *)&(sk)->sk_lock, \
  1201. sizeof((sk)->sk_lock)); \
  1202. lockdep_set_class_and_name(&(sk)->sk_lock.slock, \
  1203. (skey), (sname)); \
  1204. lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0); \
  1205. } while (0)
  1206. extern void lock_sock_nested(struct sock *sk, int subclass);
  1207. static inline void lock_sock(struct sock *sk)
  1208. {
  1209. lock_sock_nested(sk, 0);
  1210. }
  1211. extern void release_sock(struct sock *sk);
  1212. /* BH context may only use the following locking interface. */
  1213. #define bh_lock_sock(__sk) spin_lock(&((__sk)->sk_lock.slock))
  1214. #define bh_lock_sock_nested(__sk) \
  1215. spin_lock_nested(&((__sk)->sk_lock.slock), \
  1216. SINGLE_DEPTH_NESTING)
  1217. #define bh_unlock_sock(__sk) spin_unlock(&((__sk)->sk_lock.slock))
  1218. extern bool lock_sock_fast(struct sock *sk);
  1219. /**
  1220. * unlock_sock_fast - complement of lock_sock_fast
  1221. * @sk: socket
  1222. * @slow: slow mode
  1223. *
  1224. * fast unlock socket for user context.
  1225. * If slow mode is on, we call regular release_sock()
  1226. */
  1227. static inline void unlock_sock_fast(struct sock *sk, bool slow)
  1228. {
  1229. if (slow)
  1230. release_sock(sk);
  1231. else
  1232. spin_unlock_bh(&sk->sk_lock.slock);
  1233. }
  1234. extern struct sock *sk_alloc(struct net *net, int family,
  1235. gfp_t priority,
  1236. struct proto *prot);
  1237. extern void sk_free(struct sock *sk);
  1238. extern void sk_release_kernel(struct sock *sk);
  1239. extern struct sock *sk_clone_lock(const struct sock *sk,
  1240. const gfp_t priority);
  1241. extern struct sk_buff *sock_wmalloc(struct sock *sk,
  1242. unsigned long size, int force,
  1243. gfp_t priority);
  1244. extern struct sk_buff *sock_rmalloc(struct sock *sk,
  1245. unsigned long size, int force,
  1246. gfp_t priority);
  1247. extern void sock_wfree(struct sk_buff *skb);
  1248. extern void sock_rfree(struct sk_buff *skb);
  1249. extern int sock_setsockopt(struct socket *sock, int level,
  1250. int op, char __user *optval,
  1251. unsigned int optlen);
  1252. extern int sock_getsockopt(struct socket *sock, int level,
  1253. int op, char __user *optval,
  1254. int __user *optlen);
  1255. extern struct sk_buff *sock_alloc_send_skb(struct sock *sk,
  1256. unsigned long size,
  1257. int noblock,
  1258. int *errcode);
  1259. extern struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
  1260. unsigned long header_len,
  1261. unsigned long data_len,
  1262. int noblock,
  1263. int *errcode);
  1264. extern void *sock_kmalloc(struct sock *sk, int size,
  1265. gfp_t priority);
  1266. extern void sock_kfree_s(struct sock *sk, void *mem, int size);
  1267. extern void sk_send_sigurg(struct sock *sk);
  1268. #ifdef CONFIG_CGROUPS
  1269. extern void sock_update_classid(struct sock *sk);
  1270. #else
  1271. static inline void sock_update_classid(struct sock *sk)
  1272. {
  1273. }
  1274. #endif
  1275. /*
  1276. * Functions to fill in entries in struct proto_ops when a protocol
  1277. * does not implement a particular function.
  1278. */
  1279. extern int sock_no_bind(struct socket *,
  1280. struct sockaddr *, int);
  1281. extern int sock_no_connect(struct socket *,
  1282. struct sockaddr *, int, int);
  1283. extern int sock_no_socketpair(struct socket *,
  1284. struct socket *);
  1285. extern int sock_no_accept(struct socket *,
  1286. struct socket *, int);
  1287. extern int sock_no_getname(struct socket *,
  1288. struct sockaddr *, int *, int);
  1289. extern unsigned int sock_no_poll(struct file *, struct socket *,
  1290. struct poll_table_struct *);
  1291. extern int sock_no_ioctl(struct socket *, unsigned int,
  1292. unsigned long);
  1293. extern int sock_no_listen(struct socket *, int);
  1294. extern int sock_no_shutdown(struct socket *, int);
  1295. extern int sock_no_getsockopt(struct socket *, int , int,
  1296. char __user *, int __user *);
  1297. extern int sock_no_setsockopt(struct socket *, int, int,
  1298. char __user *, unsigned int);
  1299. extern int sock_no_sendmsg(struct kiocb *, struct socket *,
  1300. struct msghdr *, size_t);
  1301. extern int sock_no_recvmsg(struct kiocb *, struct socket *,
  1302. struct msghdr *, size_t, int);
  1303. extern int sock_no_mmap(struct file *file,
  1304. struct socket *sock,
  1305. struct vm_area_struct *vma);
  1306. extern ssize_t sock_no_sendpage(struct socket *sock,
  1307. struct page *page,
  1308. int offset, size_t size,
  1309. int flags);
  1310. /*
  1311. * Functions to fill in entries in struct proto_ops when a protocol
  1312. * uses the inet style.
  1313. */
  1314. extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
  1315. char __user *optval, int __user *optlen);
  1316. extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
  1317. struct msghdr *msg, size_t size, int flags);
  1318. extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
  1319. char __user *optval, unsigned int optlen);
  1320. extern int compat_sock_common_getsockopt(struct socket *sock, int level,
  1321. int optname, char __user *optval, int __user *optlen);
  1322. extern int compat_sock_common_setsockopt(struct socket *sock, int level,
  1323. int optname, char __user *optval, unsigned int optlen);
  1324. extern void sk_common_release(struct sock *sk);
  1325. /*
  1326. * Default socket callbacks and setup code
  1327. */
  1328. /* Initialise core socket variables */
  1329. extern void sock_init_data(struct socket *sock, struct sock *sk);
  1330. extern void sk_filter_release_rcu(struct rcu_head *rcu);
  1331. /**
  1332. * sk_filter_release - release a socket filter
  1333. * @fp: filter to remove
  1334. *
  1335. * Remove a filter from a socket and release its resources.
  1336. */
  1337. static inline void sk_filter_release(struct sk_filter *fp)
  1338. {
  1339. if (atomic_dec_and_test(&fp->refcnt))
  1340. call_rcu(&fp->rcu, sk_filter_release_rcu);
  1341. }
  1342. static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
  1343. {
  1344. unsigned int size = sk_filter_len(fp);
  1345. atomic_sub(size, &sk->sk_omem_alloc);
  1346. sk_filter_release(fp);
  1347. }
  1348. static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
  1349. {
  1350. atomic_inc(&fp->refcnt);
  1351. atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
  1352. }
  1353. /*
  1354. * Socket reference counting postulates.
  1355. *
  1356. * * Each user of socket SHOULD hold a reference count.
  1357. * * Each access point to socket (an hash table bucket, reference from a list,
  1358. * running timer, skb in flight MUST hold a reference count.
  1359. * * When reference count hits 0, it means it will never increase back.
  1360. * * When reference count hits 0, it means that no references from
  1361. * outside exist to this socket and current process on current CPU
  1362. * is last user and may/should destroy this socket.
  1363. * * sk_free is called from any context: process, BH, IRQ. When
  1364. * it is called, socket has no references from outside -> sk_free
  1365. * may release descendant resources allocated by the socket, but
  1366. * to the time when it is called, socket is NOT referenced by any
  1367. * hash tables, lists etc.
  1368. * * Packets, delivered from outside (from network or from another process)
  1369. * and enqueued on receive/error queues SHOULD NOT grab reference count,
  1370. * when they sit in queue. Otherwise, packets will leak to hole, when
  1371. * socket is looked up by one cpu and unhasing is made by another CPU.
  1372. * It is true for udp/raw, netlink (leak to receive and error queues), tcp
  1373. * (leak to backlog). Packet socket does all the processing inside
  1374. * BR_NETPROTO_LOCK, so that it has not this race condition. UNIX sockets
  1375. * use separate SMP lock, so that they are prone too.
  1376. */
  1377. /* Ungrab socket and destroy it, if it was the last reference. */
  1378. static inline void sock_put(struct sock *sk)
  1379. {
  1380. if (atomic_dec_and_test(&sk->sk_refcnt))
  1381. sk_free(sk);
  1382. }
  1383. extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
  1384. const int nested);
  1385. static inline void sk_tx_queue_set(struct sock *sk, int tx_queue)
  1386. {
  1387. sk->sk_tx_queue_mapping = tx_queue;
  1388. }
  1389. static inline void sk_tx_queue_clear(struct sock *sk)
  1390. {
  1391. sk->sk_tx_queue_mapping = -1;
  1392. }
  1393. static inline int sk_tx_queue_get(const struct sock *sk)
  1394. {
  1395. return sk ? sk->sk_tx_queue_mapping : -1;
  1396. }
  1397. static inline void sk_set_socket(struct sock *sk, struct socket *sock)
  1398. {
  1399. sk_tx_queue_clear(sk);
  1400. sk->sk_socket = sock;
  1401. }
  1402. static inline wait_queue_head_t *sk_sleep(struct sock *sk)
  1403. {
  1404. BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0);
  1405. return &rcu_dereference_raw(sk->sk_wq)->wait;
  1406. }
  1407. /* Detach socket from process context.
  1408. * Announce socket dead, detach it from wait queue and inode.
  1409. * Note that parent inode held reference count on this struct sock,
  1410. * we do not release it in this function, because protocol
  1411. * probably wants some additional cleanups or even continuing
  1412. * to work with this socket (TCP).
  1413. */
  1414. static inline void sock_orphan(struct sock *sk)
  1415. {
  1416. write_lock_bh(&sk->sk_callback_lock);
  1417. sock_set_flag(sk, SOCK_DEAD);
  1418. sk_set_socket(sk, NULL);
  1419. sk->sk_wq = NULL;
  1420. write_unlock_bh(&sk->sk_callback_lock);
  1421. }
  1422. static inline void sock_graft(struct sock *sk, struct socket *parent)
  1423. {
  1424. write_lock_bh(&sk->sk_callback_lock);
  1425. sk->sk_wq = parent->wq;
  1426. parent->sk = sk;
  1427. sk_set_socket(sk, parent);
  1428. security_sock_graft(sk, parent);
  1429. write_unlock_bh(&sk->sk_callback_lock);
  1430. }
  1431. extern int sock_i_uid(struct sock *sk);
  1432. extern unsigned long sock_i_ino(struct sock *sk);
  1433. static inline struct dst_entry *
  1434. __sk_dst_get(struct sock *sk)
  1435. {
  1436. return rcu_dereference_check(sk->sk_dst_cache, sock_owned_by_user(sk) ||
  1437. lockdep_is_held(&sk->sk_lock.slock));
  1438. }
  1439. static inline struct dst_entry *
  1440. sk_dst_get(struct sock *sk)
  1441. {
  1442. struct dst_entry *dst;
  1443. rcu_read_lock();
  1444. dst = rcu_dereference(sk->sk_dst_cache);
  1445. if (dst)
  1446. dst_hold(dst);
  1447. rcu_read_unlock();
  1448. return dst;
  1449. }
  1450. extern void sk_reset_txq(struct sock *sk);
  1451. static inline void dst_negative_advice(struct sock *sk)
  1452. {
  1453. struct dst_entry *ndst, *dst = __sk_dst_get(sk);
  1454. if (dst && dst->ops->negative_advice) {
  1455. ndst = dst->ops->negative_advice(dst);
  1456. if (ndst != dst) {
  1457. rcu_assign_pointer(sk->sk_dst_cache, ndst);
  1458. sk_reset_txq(sk);
  1459. }
  1460. }
  1461. }
  1462. static inline void
  1463. __sk_dst_set(struct sock *sk, struct dst_entry *dst)
  1464. {
  1465. struct dst_entry *old_dst;
  1466. sk_tx_queue_clear(sk);
  1467. /*
  1468. * This can be called while sk is owned by the caller only,
  1469. * with no state that can be checked in a rcu_dereference_check() cond
  1470. */
  1471. old_dst = rcu_dereference_raw(sk->sk_dst_cache);
  1472. rcu_assign_pointer(sk->sk_dst_cache, dst);
  1473. dst_release(old_dst);
  1474. }
  1475. static inline void
  1476. sk_dst_set(struct sock *sk, struct dst_entry *dst)
  1477. {
  1478. spin_lock(&sk->sk_dst_lock);
  1479. __sk_dst_set(sk, dst);
  1480. spin_unlock(&sk->sk_dst_lock);
  1481. }
  1482. static inline void
  1483. __sk_dst_reset(struct sock *sk)
  1484. {
  1485. __sk_dst_set(sk, NULL);
  1486. }
  1487. static inline void
  1488. sk_dst_reset(struct sock *sk)
  1489. {
  1490. spin_lock(&sk->sk_dst_lock);
  1491. __sk_dst_reset(sk);
  1492. spin_unlock(&sk->sk_dst_lock);
  1493. }
  1494. extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
  1495. extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
  1496. static inline bool sk_can_gso(const struct sock *sk)
  1497. {
  1498. return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
  1499. }
  1500. extern void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
  1501. static inline void sk_nocaps_add(struct sock *sk, netdev_features_t flags)
  1502. {
  1503. sk->sk_route_nocaps |= flags;
  1504. sk->sk_route_caps &= ~flags;
  1505. }
  1506. static inline int skb_do_copy_data_nocache(struct sock *sk, struct sk_buff *skb,
  1507. char __user *from, char *to,
  1508. int copy, int offset)
  1509. {
  1510. if (skb->ip_summed == CHECKSUM_NONE) {
  1511. int err = 0;
  1512. __wsum csum = csum_and_copy_from_user(from, to, copy, 0, &err);
  1513. if (err)
  1514. return err;
  1515. skb->csum = csum_block_add(skb->csum, csum, offset);
  1516. } else if (sk->sk_route_caps & NETIF_F_NOCACHE_COPY) {
  1517. if (!access_ok(VERIFY_READ, from, copy) ||
  1518. __copy_from_user_nocache(to, from, copy))
  1519. return -EFAULT;
  1520. } else if (copy_from_user(to, from, copy))
  1521. return -EFAULT;
  1522. return 0;
  1523. }
  1524. static inline int skb_add_data_nocache(struct sock *sk, struct sk_buff *skb,
  1525. char __user *from, int copy)
  1526. {
  1527. int err, offset = skb->len;
  1528. err = skb_do_copy_data_nocache(sk, skb, from, skb_put(skb, copy),
  1529. copy, offset);
  1530. if (err)
  1531. __skb_trim(skb, offset);
  1532. return err;
  1533. }
  1534. static inline int skb_copy_to_page_nocache(struct sock *sk, char __user *from,
  1535. struct sk_buff *skb,
  1536. struct page *page,
  1537. int off, int copy)
  1538. {
  1539. int err;
  1540. err = skb_do_copy_data_nocache(sk, skb, from, page_address(page) + off,
  1541. copy, skb->len);
  1542. if (err)
  1543. return err;
  1544. skb->len += copy;
  1545. skb->data_len += copy;
  1546. skb->truesize += copy;
  1547. sk->sk_wmem_queued += copy;
  1548. sk_mem_charge(sk, copy);
  1549. return 0;
  1550. }
  1551. static inline int skb_copy_to_page(struct sock *sk, char __user *from,
  1552. struct sk_buff *skb, struct page *page,
  1553. int off, int copy)
  1554. {
  1555. if (skb->ip_summed == CHECKSUM_NONE) {
  1556. int err = 0;
  1557. __wsum csum = csum_and_copy_from_user(from,
  1558. page_address(page) + off,
  1559. copy, 0, &err);
  1560. if (err)
  1561. return err;
  1562. skb->csum = csum_block_add(skb->csum, csum, skb->len);
  1563. } else if (copy_from_user(page_address(page) + off, from, copy))
  1564. return -EFAULT;
  1565. skb->len += copy;
  1566. skb->data_len += copy;
  1567. skb->truesize += copy;
  1568. sk->sk_wmem_queued += copy;
  1569. sk_mem_charge(sk, copy);
  1570. return 0;
  1571. }
  1572. /**
  1573. * sk_wmem_alloc_get - returns write allocations
  1574. * @sk: socket
  1575. *
  1576. * Returns sk_wmem_alloc minus initial offset of one
  1577. */
  1578. static inline int sk_wmem_alloc_get(const struct sock *sk)
  1579. {
  1580. return atomic_read(&sk->sk_wmem_alloc) - 1;
  1581. }
  1582. /**
  1583. * sk_rmem_alloc_get - returns read allocations
  1584. * @sk: socket
  1585. *
  1586. * Returns sk_rmem_alloc
  1587. */
  1588. static inline int sk_rmem_alloc_get(const struct sock *sk)
  1589. {
  1590. return atomic_read(&sk->sk_rmem_alloc);
  1591. }
  1592. /**
  1593. * sk_has_allocations - check if allocations are outstanding
  1594. * @sk: socket
  1595. *
  1596. * Returns true if socket has write or read allocations
  1597. */
  1598. static inline bool sk_has_allocations(const struct sock *sk)
  1599. {
  1600. return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
  1601. }
  1602. /**
  1603. * wq_has_sleeper - check if there are any waiting processes
  1604. * @wq: struct socket_wq
  1605. *
  1606. * Returns true if socket_wq has waiting processes
  1607. *
  1608. * The purpose of the wq_has_sleeper and sock_poll_wait is to wrap the memory
  1609. * barrier call. They were added due to the race found within the tcp code.
  1610. *
  1611. * Consider following tcp code paths:
  1612. *
  1613. * CPU1 CPU2
  1614. *
  1615. * sys_select receive packet
  1616. * ... ...
  1617. * __add_wait_queue update tp->rcv_nxt
  1618. * ... ...
  1619. * tp->rcv_nxt check sock_def_readable
  1620. * ... {
  1621. * schedule rcu_read_lock();
  1622. * wq = rcu_dereference(sk->sk_wq);
  1623. * if (wq && waitqueue_active(&wq->wait))
  1624. * wake_up_interruptible(&wq->wait)
  1625. * ...
  1626. * }
  1627. *
  1628. * The race for tcp fires when the __add_wait_queue changes done by CPU1 stay
  1629. * in its cache, and so does the tp->rcv_nxt update on CPU2 side. The CPU1
  1630. * could then endup calling schedule and sleep forever if there are no more
  1631. * data on the socket.
  1632. *
  1633. */
  1634. static inline bool wq_has_sleeper(struct socket_wq *wq)
  1635. {
  1636. /* We need to be sure we are in sync with the
  1637. * add_wait_queue modifications to the wait queue.
  1638. *
  1639. * This memory barrier is paired in the sock_poll_wait.
  1640. */
  1641. smp_mb();
  1642. return wq && waitqueue_active(&wq->wait);
  1643. }
  1644. /**
  1645. * sock_poll_wait - place memory barrier behind the poll_wait call.
  1646. * @filp: file
  1647. * @wait_address: socket wait queue
  1648. * @p: poll_table
  1649. *
  1650. * See the comments in the wq_has_sleeper function.
  1651. */
  1652. static inline void sock_poll_wait(struct file *filp,
  1653. wait_queue_head_t *wait_address, poll_table *p)
  1654. {
  1655. if (!poll_does_not_wait(p) && wait_address) {
  1656. poll_wait(filp, wait_address, p);
  1657. /* We need to be sure we are in sync with the
  1658. * socket flags modification.
  1659. *
  1660. * This memory barrier is paired in the wq_has_sleeper.
  1661. */
  1662. smp_mb();
  1663. }
  1664. }
  1665. /*
  1666. * Queue a received datagram if it will fit. Stream and sequenced
  1667. * protocols can't normally use this as they need to fit buffers in
  1668. * and play with them.
  1669. *
  1670. * Inlined as it's very short and called for pretty much every
  1671. * packet ever received.
  1672. */
  1673. static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
  1674. {
  1675. skb_orphan(skb);
  1676. skb->sk = sk;
  1677. skb->destructor = sock_wfree;
  1678. /*
  1679. * We used to take a refcount on sk, but following operation
  1680. * is enough to guarantee sk_free() wont free this sock until
  1681. * all in-flight packets are completed
  1682. */
  1683. atomic_add(skb->truesize, &sk->sk_wmem_alloc);
  1684. }
  1685. static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
  1686. {
  1687. skb_orphan(skb);
  1688. skb->sk = sk;
  1689. skb->destructor = sock_rfree;
  1690. atomic_add(skb->truesize, &sk->sk_rmem_alloc);
  1691. sk_mem_charge(sk, skb->truesize);
  1692. }
  1693. extern void sk_reset_timer(struct sock *sk, struct timer_list *timer,
  1694. unsigned long expires);
  1695. extern void sk_stop_timer(struct sock *sk, struct timer_list *timer);
  1696. extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
  1697. extern int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb);
  1698. /*
  1699. * Recover an error report and clear atomically
  1700. */
  1701. static inline int sock_error(struct sock *sk)
  1702. {
  1703. int err;
  1704. if (likely(!sk->sk_err))
  1705. return 0;
  1706. err = xchg(&sk->sk_err, 0);
  1707. return -err;
  1708. }
  1709. static inline unsigned long sock_wspace(struct sock *sk)
  1710. {
  1711. int amt = 0;
  1712. if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
  1713. amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
  1714. if (amt < 0)
  1715. amt = 0;
  1716. }
  1717. return amt;
  1718. }
  1719. static inline void sk_wake_async(struct sock *sk, int how, int band)
  1720. {
  1721. if (sock_flag(sk, SOCK_FASYNC))
  1722. sock_wake_async(sk->sk_socket, how, band);
  1723. }
  1724. #define SOCK_MIN_SNDBUF 2048
  1725. /*
  1726. * Since sk_rmem_alloc sums skb->truesize, even a small frame might need
  1727. * sizeof(sk_buff) + MTU + padding, unless net driver perform copybreak
  1728. */
  1729. #define SOCK_MIN_RCVBUF (2048 + sizeof(struct sk_buff))
  1730. static inline void sk_stream_moderate_sndbuf(struct sock *sk)
  1731. {
  1732. if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
  1733. sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
  1734. sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
  1735. }
  1736. }
  1737. struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
  1738. static inline struct page *sk_stream_alloc_page(struct sock *sk)
  1739. {
  1740. struct page *page = NULL;
  1741. page = alloc_pages(sk->sk_allocation, 0);
  1742. if (!page) {
  1743. sk_enter_memory_pressure(sk);
  1744. sk_stream_moderate_sndbuf(sk);
  1745. }
  1746. return page;
  1747. }
  1748. /*
  1749. * Default write policy as shown to user space via poll/select/SIGIO
  1750. */
  1751. static inline bool sock_writeable(const struct sock *sk)
  1752. {
  1753. return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
  1754. }
  1755. static inline gfp_t gfp_any(void)
  1756. {
  1757. return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
  1758. }
  1759. static inline long sock_rcvtimeo(const struct sock *sk, bool noblock)
  1760. {
  1761. return noblock ? 0 : sk->sk_rcvtimeo;
  1762. }
  1763. static inline long sock_sndtimeo(const struct sock *sk, bool noblock)
  1764. {
  1765. return noblock ? 0 : sk->sk_sndtimeo;
  1766. }
  1767. static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
  1768. {
  1769. return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
  1770. }
  1771. /* Alas, with timeout socket operations are not restartable.
  1772. * Compare this to poll().
  1773. */
  1774. static inline int sock_intr_errno(long timeo)
  1775. {
  1776. return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
  1777. }
  1778. extern void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
  1779. struct sk_buff *skb);
  1780. extern void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
  1781. struct sk_buff *skb);
  1782. static inline void
  1783. sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
  1784. {
  1785. ktime_t kt = skb->tstamp;
  1786. struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
  1787. /*
  1788. * generate control messages if
  1789. * - receive time stamping in software requested (SOCK_RCVTSTAMP
  1790. * or SOCK_TIMESTAMPING_RX_SOFTWARE)
  1791. * - software time stamp available and wanted
  1792. * (SOCK_TIMESTAMPING_SOFTWARE)
  1793. * - hardware time stamps available and wanted
  1794. * (SOCK_TIMESTAMPING_SYS_HARDWARE or
  1795. * SOCK_TIMESTAMPING_RAW_HARDWARE)
  1796. */
  1797. if (sock_flag(sk, SOCK_RCVTSTAMP) ||
  1798. sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
  1799. (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
  1800. (hwtstamps->hwtstamp.tv64 &&
  1801. sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
  1802. (hwtstamps->syststamp.tv64 &&
  1803. sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
  1804. __sock_recv_timestamp(msg, sk, skb);
  1805. else
  1806. sk->sk_stamp = kt;
  1807. if (sock_flag(sk, SOCK_WIFI_STATUS) && skb->wifi_acked_valid)
  1808. __sock_recv_wifi_status(msg, sk, skb);
  1809. }
  1810. extern void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
  1811. struct sk_buff *skb);
  1812. static inline void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
  1813. struct sk_buff *skb)
  1814. {
  1815. #define FLAGS_TS_OR_DROPS ((1UL << SOCK_RXQ_OVFL) | \
  1816. (1UL << SOCK_RCVTSTAMP) | \
  1817. (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE) | \
  1818. (1UL << SOCK_TIMESTAMPING_SOFTWARE) | \
  1819. (1UL << SOCK_TIMESTAMPING_RAW_HARDWARE) | \
  1820. (1UL << SOCK_TIMESTAMPING_SYS_HARDWARE))
  1821. if (sk->sk_flags & FLAGS_TS_OR_DROPS)
  1822. __sock_recv_ts_and_drops(msg, sk, skb);
  1823. else
  1824. sk->sk_stamp = skb->tstamp;
  1825. }
  1826. /**
  1827. * sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
  1828. * @sk: socket sending this packet
  1829. * @tx_flags: filled with instructions for time stamping
  1830. *
  1831. * Currently only depends on SOCK_TIMESTAMPING* flags. Returns error code if
  1832. * parameters are invalid.
  1833. */
  1834. extern int sock_tx_timestamp(struct sock *sk, __u8 *tx_flags);
  1835. /**
  1836. * sk_eat_skb - Release a skb if it is no longer needed
  1837. * @sk: socket to eat this skb from
  1838. * @skb: socket buffer to eat
  1839. * @copied_early: flag indicating whether DMA operations copied this data early
  1840. *
  1841. * This routine must be called with interrupts disabled or with the socket
  1842. * locked so that the sk_buff queue operation is ok.
  1843. */
  1844. #ifdef CONFIG_NET_DMA
  1845. static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, bool copied_early)
  1846. {
  1847. __skb_unlink(skb, &sk->sk_receive_queue);
  1848. if (!copied_early)
  1849. __kfree_skb(skb);
  1850. else
  1851. __skb_queue_tail(&sk->sk_async_wait_queue, skb);
  1852. }
  1853. #else
  1854. static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, bool copied_early)
  1855. {
  1856. __skb_unlink(skb, &sk->sk_receive_queue);
  1857. __kfree_skb(skb);
  1858. }
  1859. #endif
  1860. static inline
  1861. struct net *sock_net(const struct sock *sk)
  1862. {
  1863. return read_pnet(&sk->sk_net);
  1864. }
  1865. static inline
  1866. void sock_net_set(struct sock *sk, struct net *net)
  1867. {
  1868. write_pnet(&sk->sk_net, net);
  1869. }
  1870. /*
  1871. * Kernel sockets, f.e. rtnl or icmp_socket, are a part of a namespace.
  1872. * They should not hold a reference to a namespace in order to allow
  1873. * to stop it.
  1874. * Sockets after sk_change_net should be released using sk_release_kernel
  1875. */
  1876. static inline void sk_change_net(struct sock *sk, struct net *net)
  1877. {
  1878. put_net(sock_net(sk));
  1879. sock_net_set(sk, hold_net(net));
  1880. }
  1881. static inline struct sock *skb_steal_sock(struct sk_buff *skb)
  1882. {
  1883. if (unlikely(skb->sk)) {
  1884. struct sock *sk = skb->sk;
  1885. skb->destructor = NULL;
  1886. skb->sk = NULL;
  1887. return sk;
  1888. }
  1889. return NULL;
  1890. }
  1891. extern void sock_enable_timestamp(struct sock *sk, int flag);
  1892. extern int sock_get_timestamp(struct sock *, struct timeval __user *);
  1893. extern int sock_get_timestampns(struct sock *, struct timespec __user *);
  1894. /*
  1895. * Enable debug/info messages
  1896. */
  1897. extern int net_msg_warn;
  1898. #define NETDEBUG(fmt, args...) \
  1899. do { if (net_msg_warn) printk(fmt,##args); } while (0)
  1900. #define LIMIT_NETDEBUG(fmt, args...) \
  1901. do { if (net_msg_warn && net_ratelimit()) printk(fmt,##args); } while(0)
  1902. extern __u32 sysctl_wmem_max;
  1903. extern __u32 sysctl_rmem_max;
  1904. extern void sk_init(void);
  1905. extern int sysctl_optmem_max;
  1906. extern __u32 sysctl_wmem_default;
  1907. extern __u32 sysctl_rmem_default;
  1908. #endif /* _SOCK_H */