sock.h 50 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782
  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/kernel.h>
  43. #include <linux/list.h>
  44. #include <linux/list_nulls.h>
  45. #include <linux/timer.h>
  46. #include <linux/cache.h>
  47. #include <linux/module.h>
  48. #include <linux/lockdep.h>
  49. #include <linux/netdevice.h>
  50. #include <linux/skbuff.h> /* struct sk_buff */
  51. #include <linux/mm.h>
  52. #include <linux/security.h>
  53. #include <linux/slab.h>
  54. #include <linux/filter.h>
  55. #include <linux/rculist_nulls.h>
  56. #include <linux/poll.h>
  57. #include <asm/atomic.h>
  58. #include <net/dst.h>
  59. #include <net/checksum.h>
  60. /*
  61. * This structure really needs to be cleaned up.
  62. * Most of it is for TCP, and not used by any of
  63. * the other protocols.
  64. */
  65. /* Define this to get the SOCK_DBG debugging facility. */
  66. #define SOCK_DEBUGGING
  67. #ifdef SOCK_DEBUGGING
  68. #define SOCK_DEBUG(sk, msg...) do { if ((sk) && sock_flag((sk), SOCK_DBG)) \
  69. printk(KERN_DEBUG msg); } while (0)
  70. #else
  71. /* Validate arguments and do nothing */
  72. static inline void __attribute__ ((format (printf, 2, 3)))
  73. SOCK_DEBUG(struct sock *sk, const char *msg, ...)
  74. {
  75. }
  76. #endif
  77. /* This is the per-socket lock. The spinlock provides a synchronization
  78. * between user contexts and software interrupt processing, whereas the
  79. * mini-semaphore synchronizes multiple users amongst themselves.
  80. */
  81. typedef struct {
  82. spinlock_t slock;
  83. int owned;
  84. wait_queue_head_t wq;
  85. /*
  86. * We express the mutex-alike socket_lock semantics
  87. * to the lock validator by explicitly managing
  88. * the slock as a lock variant (in addition to
  89. * the slock itself):
  90. */
  91. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  92. struct lockdep_map dep_map;
  93. #endif
  94. } socket_lock_t;
  95. struct sock;
  96. struct proto;
  97. struct net;
  98. /**
  99. * struct sock_common - minimal network layer representation of sockets
  100. * @skc_node: main hash linkage for various protocol lookup tables
  101. * @skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
  102. * @skc_refcnt: reference count
  103. * @skc_tx_queue_mapping: tx queue number for this connection
  104. * @skc_hash: hash value used with various protocol lookup tables
  105. * @skc_u16hashes: two u16 hash values used by UDP lookup tables
  106. * @skc_family: network address family
  107. * @skc_state: Connection state
  108. * @skc_reuse: %SO_REUSEADDR setting
  109. * @skc_bound_dev_if: bound device index if != 0
  110. * @skc_bind_node: bind hash linkage for various protocol lookup tables
  111. * @skc_portaddr_node: second hash linkage for UDP/UDP-Lite protocol
  112. * @skc_prot: protocol handlers inside a network family
  113. * @skc_net: reference to the network namespace of this socket
  114. *
  115. * This is the minimal network layer representation of sockets, the header
  116. * for struct sock and struct inet_timewait_sock.
  117. */
  118. struct sock_common {
  119. /*
  120. * first fields are not copied in sock_copy()
  121. */
  122. union {
  123. struct hlist_node skc_node;
  124. struct hlist_nulls_node skc_nulls_node;
  125. };
  126. atomic_t skc_refcnt;
  127. int skc_tx_queue_mapping;
  128. union {
  129. unsigned int skc_hash;
  130. __u16 skc_u16hashes[2];
  131. };
  132. unsigned short skc_family;
  133. volatile unsigned char skc_state;
  134. unsigned char skc_reuse;
  135. int skc_bound_dev_if;
  136. union {
  137. struct hlist_node skc_bind_node;
  138. struct hlist_nulls_node skc_portaddr_node;
  139. };
  140. struct proto *skc_prot;
  141. #ifdef CONFIG_NET_NS
  142. struct net *skc_net;
  143. #endif
  144. };
  145. /**
  146. * struct sock - network layer representation of sockets
  147. * @__sk_common: shared layout with inet_timewait_sock
  148. * @sk_shutdown: mask of %SEND_SHUTDOWN and/or %RCV_SHUTDOWN
  149. * @sk_userlocks: %SO_SNDBUF and %SO_RCVBUF settings
  150. * @sk_lock: synchronizer
  151. * @sk_rcvbuf: size of receive buffer in bytes
  152. * @sk_wq: sock wait queue and async head
  153. * @sk_dst_cache: destination cache
  154. * @sk_dst_lock: destination cache lock
  155. * @sk_policy: flow policy
  156. * @sk_rmem_alloc: receive queue bytes committed
  157. * @sk_receive_queue: incoming packets
  158. * @sk_wmem_alloc: transmit queue bytes committed
  159. * @sk_write_queue: Packet sending queue
  160. * @sk_async_wait_queue: DMA copied packets
  161. * @sk_omem_alloc: "o" is "option" or "other"
  162. * @sk_wmem_queued: persistent queue size
  163. * @sk_forward_alloc: space allocated forward
  164. * @sk_allocation: allocation mode
  165. * @sk_sndbuf: size of send buffer in bytes
  166. * @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
  167. * %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
  168. * @sk_no_check: %SO_NO_CHECK setting, wether or not checkup packets
  169. * @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
  170. * @sk_route_nocaps: forbidden route capabilities (e.g NETIF_F_GSO_MASK)
  171. * @sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
  172. * @sk_gso_max_size: Maximum GSO segment size to build
  173. * @sk_lingertime: %SO_LINGER l_linger setting
  174. * @sk_backlog: always used with the per-socket spinlock held
  175. * @sk_callback_lock: used with the callbacks in the end of this struct
  176. * @sk_error_queue: rarely used
  177. * @sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt,
  178. * IPV6_ADDRFORM for instance)
  179. * @sk_err: last error
  180. * @sk_err_soft: errors that don't cause failure but are the cause of a
  181. * persistent failure not just 'timed out'
  182. * @sk_drops: raw/udp drops counter
  183. * @sk_ack_backlog: current listen backlog
  184. * @sk_max_ack_backlog: listen backlog set in listen()
  185. * @sk_priority: %SO_PRIORITY setting
  186. * @sk_type: socket type (%SOCK_STREAM, etc)
  187. * @sk_protocol: which protocol this socket belongs in this network family
  188. * @sk_peercred: %SO_PEERCRED setting
  189. * @sk_rcvlowat: %SO_RCVLOWAT setting
  190. * @sk_rcvtimeo: %SO_RCVTIMEO setting
  191. * @sk_sndtimeo: %SO_SNDTIMEO setting
  192. * @sk_rxhash: flow hash received from netif layer
  193. * @sk_filter: socket filtering instructions
  194. * @sk_protinfo: private area, net family specific, when not using slab
  195. * @sk_timer: sock cleanup timer
  196. * @sk_stamp: time stamp of last packet received
  197. * @sk_socket: Identd and reporting IO signals
  198. * @sk_user_data: RPC layer private data
  199. * @sk_sndmsg_page: cached page for sendmsg
  200. * @sk_sndmsg_off: cached offset for sendmsg
  201. * @sk_send_head: front of stuff to transmit
  202. * @sk_security: used by security modules
  203. * @sk_mark: generic packet mark
  204. * @sk_write_pending: a write to stream socket waits to start
  205. * @sk_state_change: callback to indicate change in the state of the sock
  206. * @sk_data_ready: callback to indicate there is data to be processed
  207. * @sk_write_space: callback to indicate there is bf sending space available
  208. * @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
  209. * @sk_backlog_rcv: callback to process the backlog
  210. * @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
  211. */
  212. struct sock {
  213. /*
  214. * Now struct inet_timewait_sock also uses sock_common, so please just
  215. * don't add nothing before this first member (__sk_common) --acme
  216. */
  217. struct sock_common __sk_common;
  218. #define sk_node __sk_common.skc_node
  219. #define sk_nulls_node __sk_common.skc_nulls_node
  220. #define sk_refcnt __sk_common.skc_refcnt
  221. #define sk_tx_queue_mapping __sk_common.skc_tx_queue_mapping
  222. #define sk_copy_start __sk_common.skc_hash
  223. #define sk_hash __sk_common.skc_hash
  224. #define sk_family __sk_common.skc_family
  225. #define sk_state __sk_common.skc_state
  226. #define sk_reuse __sk_common.skc_reuse
  227. #define sk_bound_dev_if __sk_common.skc_bound_dev_if
  228. #define sk_bind_node __sk_common.skc_bind_node
  229. #define sk_prot __sk_common.skc_prot
  230. #define sk_net __sk_common.skc_net
  231. kmemcheck_bitfield_begin(flags);
  232. unsigned int sk_shutdown : 2,
  233. sk_no_check : 2,
  234. sk_userlocks : 4,
  235. sk_protocol : 8,
  236. sk_type : 16;
  237. kmemcheck_bitfield_end(flags);
  238. int sk_rcvbuf;
  239. socket_lock_t sk_lock;
  240. /*
  241. * The backlog queue is special, it is always used with
  242. * the per-socket spinlock held and requires low latency
  243. * access. Therefore we special case it's implementation.
  244. */
  245. struct {
  246. struct sk_buff *head;
  247. struct sk_buff *tail;
  248. int len;
  249. } sk_backlog;
  250. struct socket_wq *sk_wq;
  251. struct dst_entry *sk_dst_cache;
  252. #ifdef CONFIG_XFRM
  253. struct xfrm_policy *sk_policy[2];
  254. #endif
  255. spinlock_t sk_dst_lock;
  256. atomic_t sk_rmem_alloc;
  257. atomic_t sk_wmem_alloc;
  258. atomic_t sk_omem_alloc;
  259. int sk_sndbuf;
  260. struct sk_buff_head sk_receive_queue;
  261. struct sk_buff_head sk_write_queue;
  262. #ifdef CONFIG_NET_DMA
  263. struct sk_buff_head sk_async_wait_queue;
  264. #endif
  265. int sk_wmem_queued;
  266. int sk_forward_alloc;
  267. gfp_t sk_allocation;
  268. int sk_route_caps;
  269. int sk_route_nocaps;
  270. int sk_gso_type;
  271. unsigned int sk_gso_max_size;
  272. int sk_rcvlowat;
  273. #ifdef CONFIG_RPS
  274. __u32 sk_rxhash;
  275. #endif
  276. unsigned long sk_flags;
  277. unsigned long sk_lingertime;
  278. struct sk_buff_head sk_error_queue;
  279. struct proto *sk_prot_creator;
  280. rwlock_t sk_callback_lock;
  281. int sk_err,
  282. sk_err_soft;
  283. atomic_t sk_drops;
  284. unsigned short sk_ack_backlog;
  285. unsigned short sk_max_ack_backlog;
  286. __u32 sk_priority;
  287. struct ucred sk_peercred;
  288. long sk_rcvtimeo;
  289. long sk_sndtimeo;
  290. struct sk_filter *sk_filter;
  291. void *sk_protinfo;
  292. struct timer_list sk_timer;
  293. ktime_t sk_stamp;
  294. struct socket *sk_socket;
  295. void *sk_user_data;
  296. struct page *sk_sndmsg_page;
  297. struct sk_buff *sk_send_head;
  298. __u32 sk_sndmsg_off;
  299. int sk_write_pending;
  300. #ifdef CONFIG_SECURITY
  301. void *sk_security;
  302. #endif
  303. __u32 sk_mark;
  304. u32 sk_classid;
  305. void (*sk_state_change)(struct sock *sk);
  306. void (*sk_data_ready)(struct sock *sk, int bytes);
  307. void (*sk_write_space)(struct sock *sk);
  308. void (*sk_error_report)(struct sock *sk);
  309. int (*sk_backlog_rcv)(struct sock *sk,
  310. struct sk_buff *skb);
  311. void (*sk_destruct)(struct sock *sk);
  312. };
  313. /*
  314. * Hashed lists helper routines
  315. */
  316. static inline struct sock *sk_entry(const struct hlist_node *node)
  317. {
  318. return hlist_entry(node, struct sock, sk_node);
  319. }
  320. static inline struct sock *__sk_head(const struct hlist_head *head)
  321. {
  322. return hlist_entry(head->first, struct sock, sk_node);
  323. }
  324. static inline struct sock *sk_head(const struct hlist_head *head)
  325. {
  326. return hlist_empty(head) ? NULL : __sk_head(head);
  327. }
  328. static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
  329. {
  330. return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
  331. }
  332. static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
  333. {
  334. return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
  335. }
  336. static inline struct sock *sk_next(const struct sock *sk)
  337. {
  338. return sk->sk_node.next ?
  339. hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
  340. }
  341. static inline struct sock *sk_nulls_next(const struct sock *sk)
  342. {
  343. return (!is_a_nulls(sk->sk_nulls_node.next)) ?
  344. hlist_nulls_entry(sk->sk_nulls_node.next,
  345. struct sock, sk_nulls_node) :
  346. NULL;
  347. }
  348. static inline int sk_unhashed(const struct sock *sk)
  349. {
  350. return hlist_unhashed(&sk->sk_node);
  351. }
  352. static inline int sk_hashed(const struct sock *sk)
  353. {
  354. return !sk_unhashed(sk);
  355. }
  356. static __inline__ void sk_node_init(struct hlist_node *node)
  357. {
  358. node->pprev = NULL;
  359. }
  360. static __inline__ void sk_nulls_node_init(struct hlist_nulls_node *node)
  361. {
  362. node->pprev = NULL;
  363. }
  364. static __inline__ void __sk_del_node(struct sock *sk)
  365. {
  366. __hlist_del(&sk->sk_node);
  367. }
  368. /* NB: equivalent to hlist_del_init_rcu */
  369. static __inline__ int __sk_del_node_init(struct sock *sk)
  370. {
  371. if (sk_hashed(sk)) {
  372. __sk_del_node(sk);
  373. sk_node_init(&sk->sk_node);
  374. return 1;
  375. }
  376. return 0;
  377. }
  378. /* Grab socket reference count. This operation is valid only
  379. when sk is ALREADY grabbed f.e. it is found in hash table
  380. or a list and the lookup is made under lock preventing hash table
  381. modifications.
  382. */
  383. static inline void sock_hold(struct sock *sk)
  384. {
  385. atomic_inc(&sk->sk_refcnt);
  386. }
  387. /* Ungrab socket in the context, which assumes that socket refcnt
  388. cannot hit zero, f.e. it is true in context of any socketcall.
  389. */
  390. static inline void __sock_put(struct sock *sk)
  391. {
  392. atomic_dec(&sk->sk_refcnt);
  393. }
  394. static __inline__ int sk_del_node_init(struct sock *sk)
  395. {
  396. int rc = __sk_del_node_init(sk);
  397. if (rc) {
  398. /* paranoid for a while -acme */
  399. WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
  400. __sock_put(sk);
  401. }
  402. return rc;
  403. }
  404. #define sk_del_node_init_rcu(sk) sk_del_node_init(sk)
  405. static __inline__ int __sk_nulls_del_node_init_rcu(struct sock *sk)
  406. {
  407. if (sk_hashed(sk)) {
  408. hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
  409. return 1;
  410. }
  411. return 0;
  412. }
  413. static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
  414. {
  415. int rc = __sk_nulls_del_node_init_rcu(sk);
  416. if (rc) {
  417. /* paranoid for a while -acme */
  418. WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
  419. __sock_put(sk);
  420. }
  421. return rc;
  422. }
  423. static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
  424. {
  425. hlist_add_head(&sk->sk_node, list);
  426. }
  427. static __inline__ void sk_add_node(struct sock *sk, struct hlist_head *list)
  428. {
  429. sock_hold(sk);
  430. __sk_add_node(sk, list);
  431. }
  432. static __inline__ void sk_add_node_rcu(struct sock *sk, struct hlist_head *list)
  433. {
  434. sock_hold(sk);
  435. hlist_add_head_rcu(&sk->sk_node, list);
  436. }
  437. static __inline__ void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
  438. {
  439. hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
  440. }
  441. static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
  442. {
  443. sock_hold(sk);
  444. __sk_nulls_add_node_rcu(sk, list);
  445. }
  446. static __inline__ void __sk_del_bind_node(struct sock *sk)
  447. {
  448. __hlist_del(&sk->sk_bind_node);
  449. }
  450. static __inline__ void sk_add_bind_node(struct sock *sk,
  451. struct hlist_head *list)
  452. {
  453. hlist_add_head(&sk->sk_bind_node, list);
  454. }
  455. #define sk_for_each(__sk, node, list) \
  456. hlist_for_each_entry(__sk, node, list, sk_node)
  457. #define sk_for_each_rcu(__sk, node, list) \
  458. hlist_for_each_entry_rcu(__sk, node, list, sk_node)
  459. #define sk_nulls_for_each(__sk, node, list) \
  460. hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
  461. #define sk_nulls_for_each_rcu(__sk, node, list) \
  462. hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
  463. #define sk_for_each_from(__sk, node) \
  464. if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
  465. hlist_for_each_entry_from(__sk, node, sk_node)
  466. #define sk_nulls_for_each_from(__sk, node) \
  467. if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
  468. hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
  469. #define sk_for_each_continue(__sk, node) \
  470. if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
  471. hlist_for_each_entry_continue(__sk, node, sk_node)
  472. #define sk_for_each_safe(__sk, node, tmp, list) \
  473. hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
  474. #define sk_for_each_bound(__sk, node, list) \
  475. hlist_for_each_entry(__sk, node, list, sk_bind_node)
  476. /* Sock flags */
  477. enum sock_flags {
  478. SOCK_DEAD,
  479. SOCK_DONE,
  480. SOCK_URGINLINE,
  481. SOCK_KEEPOPEN,
  482. SOCK_LINGER,
  483. SOCK_DESTROY,
  484. SOCK_BROADCAST,
  485. SOCK_TIMESTAMP,
  486. SOCK_ZAPPED,
  487. SOCK_USE_WRITE_QUEUE, /* whether to call sk->sk_write_space in sock_wfree */
  488. SOCK_DBG, /* %SO_DEBUG setting */
  489. SOCK_RCVTSTAMP, /* %SO_TIMESTAMP setting */
  490. SOCK_RCVTSTAMPNS, /* %SO_TIMESTAMPNS setting */
  491. SOCK_LOCALROUTE, /* route locally only, %SO_DONTROUTE setting */
  492. SOCK_QUEUE_SHRUNK, /* write queue has been shrunk recently */
  493. SOCK_TIMESTAMPING_TX_HARDWARE, /* %SOF_TIMESTAMPING_TX_HARDWARE */
  494. SOCK_TIMESTAMPING_TX_SOFTWARE, /* %SOF_TIMESTAMPING_TX_SOFTWARE */
  495. SOCK_TIMESTAMPING_RX_HARDWARE, /* %SOF_TIMESTAMPING_RX_HARDWARE */
  496. SOCK_TIMESTAMPING_RX_SOFTWARE, /* %SOF_TIMESTAMPING_RX_SOFTWARE */
  497. SOCK_TIMESTAMPING_SOFTWARE, /* %SOF_TIMESTAMPING_SOFTWARE */
  498. SOCK_TIMESTAMPING_RAW_HARDWARE, /* %SOF_TIMESTAMPING_RAW_HARDWARE */
  499. SOCK_TIMESTAMPING_SYS_HARDWARE, /* %SOF_TIMESTAMPING_SYS_HARDWARE */
  500. SOCK_FASYNC, /* fasync() active */
  501. SOCK_RXQ_OVFL,
  502. };
  503. static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
  504. {
  505. nsk->sk_flags = osk->sk_flags;
  506. }
  507. static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
  508. {
  509. __set_bit(flag, &sk->sk_flags);
  510. }
  511. static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
  512. {
  513. __clear_bit(flag, &sk->sk_flags);
  514. }
  515. static inline int sock_flag(struct sock *sk, enum sock_flags flag)
  516. {
  517. return test_bit(flag, &sk->sk_flags);
  518. }
  519. static inline void sk_acceptq_removed(struct sock *sk)
  520. {
  521. sk->sk_ack_backlog--;
  522. }
  523. static inline void sk_acceptq_added(struct sock *sk)
  524. {
  525. sk->sk_ack_backlog++;
  526. }
  527. static inline int sk_acceptq_is_full(struct sock *sk)
  528. {
  529. return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
  530. }
  531. /*
  532. * Compute minimal free write space needed to queue new packets.
  533. */
  534. static inline int sk_stream_min_wspace(struct sock *sk)
  535. {
  536. return sk->sk_wmem_queued >> 1;
  537. }
  538. static inline int sk_stream_wspace(struct sock *sk)
  539. {
  540. return sk->sk_sndbuf - sk->sk_wmem_queued;
  541. }
  542. extern void sk_stream_write_space(struct sock *sk);
  543. static inline int sk_stream_memory_free(struct sock *sk)
  544. {
  545. return sk->sk_wmem_queued < sk->sk_sndbuf;
  546. }
  547. /* OOB backlog add */
  548. static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
  549. {
  550. /* dont let skb dst not refcounted, we are going to leave rcu lock */
  551. skb_dst_force(skb);
  552. if (!sk->sk_backlog.tail)
  553. sk->sk_backlog.head = skb;
  554. else
  555. sk->sk_backlog.tail->next = skb;
  556. sk->sk_backlog.tail = skb;
  557. skb->next = NULL;
  558. }
  559. /*
  560. * Take into account size of receive queue and backlog queue
  561. */
  562. static inline bool sk_rcvqueues_full(const struct sock *sk, const struct sk_buff *skb)
  563. {
  564. unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
  565. return qsize + skb->truesize > sk->sk_rcvbuf;
  566. }
  567. /* The per-socket spinlock must be held here. */
  568. static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *skb)
  569. {
  570. if (sk_rcvqueues_full(sk, skb))
  571. return -ENOBUFS;
  572. __sk_add_backlog(sk, skb);
  573. sk->sk_backlog.len += skb->truesize;
  574. return 0;
  575. }
  576. static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
  577. {
  578. return sk->sk_backlog_rcv(sk, skb);
  579. }
  580. static inline void sock_rps_record_flow(const struct sock *sk)
  581. {
  582. #ifdef CONFIG_RPS
  583. struct rps_sock_flow_table *sock_flow_table;
  584. rcu_read_lock();
  585. sock_flow_table = rcu_dereference(rps_sock_flow_table);
  586. rps_record_sock_flow(sock_flow_table, sk->sk_rxhash);
  587. rcu_read_unlock();
  588. #endif
  589. }
  590. static inline void sock_rps_reset_flow(const struct sock *sk)
  591. {
  592. #ifdef CONFIG_RPS
  593. struct rps_sock_flow_table *sock_flow_table;
  594. rcu_read_lock();
  595. sock_flow_table = rcu_dereference(rps_sock_flow_table);
  596. rps_reset_sock_flow(sock_flow_table, sk->sk_rxhash);
  597. rcu_read_unlock();
  598. #endif
  599. }
  600. static inline void sock_rps_save_rxhash(struct sock *sk, u32 rxhash)
  601. {
  602. #ifdef CONFIG_RPS
  603. if (unlikely(sk->sk_rxhash != rxhash)) {
  604. sock_rps_reset_flow(sk);
  605. sk->sk_rxhash = rxhash;
  606. }
  607. #endif
  608. }
  609. #define sk_wait_event(__sk, __timeo, __condition) \
  610. ({ int __rc; \
  611. release_sock(__sk); \
  612. __rc = __condition; \
  613. if (!__rc) { \
  614. *(__timeo) = schedule_timeout(*(__timeo)); \
  615. } \
  616. lock_sock(__sk); \
  617. __rc = __condition; \
  618. __rc; \
  619. })
  620. extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
  621. extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
  622. extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
  623. extern int sk_stream_error(struct sock *sk, int flags, int err);
  624. extern void sk_stream_kill_queues(struct sock *sk);
  625. extern int sk_wait_data(struct sock *sk, long *timeo);
  626. struct request_sock_ops;
  627. struct timewait_sock_ops;
  628. struct inet_hashinfo;
  629. struct raw_hashinfo;
  630. /* Networking protocol blocks we attach to sockets.
  631. * socket layer -> transport layer interface
  632. * transport -> network interface is defined by struct inet_proto
  633. */
  634. struct proto {
  635. void (*close)(struct sock *sk,
  636. long timeout);
  637. int (*connect)(struct sock *sk,
  638. struct sockaddr *uaddr,
  639. int addr_len);
  640. int (*disconnect)(struct sock *sk, int flags);
  641. struct sock * (*accept) (struct sock *sk, int flags, int *err);
  642. int (*ioctl)(struct sock *sk, int cmd,
  643. unsigned long arg);
  644. int (*init)(struct sock *sk);
  645. void (*destroy)(struct sock *sk);
  646. void (*shutdown)(struct sock *sk, int how);
  647. int (*setsockopt)(struct sock *sk, int level,
  648. int optname, char __user *optval,
  649. unsigned int optlen);
  650. int (*getsockopt)(struct sock *sk, int level,
  651. int optname, char __user *optval,
  652. int __user *option);
  653. #ifdef CONFIG_COMPAT
  654. int (*compat_setsockopt)(struct sock *sk,
  655. int level,
  656. int optname, char __user *optval,
  657. unsigned int optlen);
  658. int (*compat_getsockopt)(struct sock *sk,
  659. int level,
  660. int optname, char __user *optval,
  661. int __user *option);
  662. #endif
  663. int (*sendmsg)(struct kiocb *iocb, struct sock *sk,
  664. struct msghdr *msg, size_t len);
  665. int (*recvmsg)(struct kiocb *iocb, struct sock *sk,
  666. struct msghdr *msg,
  667. size_t len, int noblock, int flags,
  668. int *addr_len);
  669. int (*sendpage)(struct sock *sk, struct page *page,
  670. int offset, size_t size, int flags);
  671. int (*bind)(struct sock *sk,
  672. struct sockaddr *uaddr, int addr_len);
  673. int (*backlog_rcv) (struct sock *sk,
  674. struct sk_buff *skb);
  675. /* Keeping track of sk's, looking them up, and port selection methods. */
  676. void (*hash)(struct sock *sk);
  677. void (*unhash)(struct sock *sk);
  678. int (*get_port)(struct sock *sk, unsigned short snum);
  679. /* Keeping track of sockets in use */
  680. #ifdef CONFIG_PROC_FS
  681. unsigned int inuse_idx;
  682. #endif
  683. /* Memory pressure */
  684. void (*enter_memory_pressure)(struct sock *sk);
  685. atomic_t *memory_allocated; /* Current allocated memory. */
  686. struct percpu_counter *sockets_allocated; /* Current number of sockets. */
  687. /*
  688. * Pressure flag: try to collapse.
  689. * Technical note: it is used by multiple contexts non atomically.
  690. * All the __sk_mem_schedule() is of this nature: accounting
  691. * is strict, actions are advisory and have some latency.
  692. */
  693. int *memory_pressure;
  694. int *sysctl_mem;
  695. int *sysctl_wmem;
  696. int *sysctl_rmem;
  697. int max_header;
  698. struct kmem_cache *slab;
  699. unsigned int obj_size;
  700. int slab_flags;
  701. struct percpu_counter *orphan_count;
  702. struct request_sock_ops *rsk_prot;
  703. struct timewait_sock_ops *twsk_prot;
  704. union {
  705. struct inet_hashinfo *hashinfo;
  706. struct udp_table *udp_table;
  707. struct raw_hashinfo *raw_hash;
  708. } h;
  709. struct module *owner;
  710. char name[32];
  711. struct list_head node;
  712. #ifdef SOCK_REFCNT_DEBUG
  713. atomic_t socks;
  714. #endif
  715. };
  716. extern int proto_register(struct proto *prot, int alloc_slab);
  717. extern void proto_unregister(struct proto *prot);
  718. #ifdef SOCK_REFCNT_DEBUG
  719. static inline void sk_refcnt_debug_inc(struct sock *sk)
  720. {
  721. atomic_inc(&sk->sk_prot->socks);
  722. }
  723. static inline void sk_refcnt_debug_dec(struct sock *sk)
  724. {
  725. atomic_dec(&sk->sk_prot->socks);
  726. printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
  727. sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
  728. }
  729. static inline void sk_refcnt_debug_release(const struct sock *sk)
  730. {
  731. if (atomic_read(&sk->sk_refcnt) != 1)
  732. printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
  733. sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
  734. }
  735. #else /* SOCK_REFCNT_DEBUG */
  736. #define sk_refcnt_debug_inc(sk) do { } while (0)
  737. #define sk_refcnt_debug_dec(sk) do { } while (0)
  738. #define sk_refcnt_debug_release(sk) do { } while (0)
  739. #endif /* SOCK_REFCNT_DEBUG */
  740. #ifdef CONFIG_PROC_FS
  741. /* Called with local bh disabled */
  742. extern void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
  743. extern int sock_prot_inuse_get(struct net *net, struct proto *proto);
  744. #else
  745. static void inline sock_prot_inuse_add(struct net *net, struct proto *prot,
  746. int inc)
  747. {
  748. }
  749. #endif
  750. /* With per-bucket locks this operation is not-atomic, so that
  751. * this version is not worse.
  752. */
  753. static inline void __sk_prot_rehash(struct sock *sk)
  754. {
  755. sk->sk_prot->unhash(sk);
  756. sk->sk_prot->hash(sk);
  757. }
  758. /* About 10 seconds */
  759. #define SOCK_DESTROY_TIME (10*HZ)
  760. /* Sockets 0-1023 can't be bound to unless you are superuser */
  761. #define PROT_SOCK 1024
  762. #define SHUTDOWN_MASK 3
  763. #define RCV_SHUTDOWN 1
  764. #define SEND_SHUTDOWN 2
  765. #define SOCK_SNDBUF_LOCK 1
  766. #define SOCK_RCVBUF_LOCK 2
  767. #define SOCK_BINDADDR_LOCK 4
  768. #define SOCK_BINDPORT_LOCK 8
  769. /* sock_iocb: used to kick off async processing of socket ios */
  770. struct sock_iocb {
  771. struct list_head list;
  772. int flags;
  773. int size;
  774. struct socket *sock;
  775. struct sock *sk;
  776. struct scm_cookie *scm;
  777. struct msghdr *msg, async_msg;
  778. struct kiocb *kiocb;
  779. };
  780. static inline struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
  781. {
  782. return (struct sock_iocb *)iocb->private;
  783. }
  784. static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
  785. {
  786. return si->kiocb;
  787. }
  788. struct socket_alloc {
  789. struct socket socket;
  790. struct inode vfs_inode;
  791. };
  792. static inline struct socket *SOCKET_I(struct inode *inode)
  793. {
  794. return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
  795. }
  796. static inline struct inode *SOCK_INODE(struct socket *socket)
  797. {
  798. return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
  799. }
  800. /*
  801. * Functions for memory accounting
  802. */
  803. extern int __sk_mem_schedule(struct sock *sk, int size, int kind);
  804. extern void __sk_mem_reclaim(struct sock *sk);
  805. #define SK_MEM_QUANTUM ((int)PAGE_SIZE)
  806. #define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
  807. #define SK_MEM_SEND 0
  808. #define SK_MEM_RECV 1
  809. static inline int sk_mem_pages(int amt)
  810. {
  811. return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
  812. }
  813. static inline int sk_has_account(struct sock *sk)
  814. {
  815. /* return true if protocol supports memory accounting */
  816. return !!sk->sk_prot->memory_allocated;
  817. }
  818. static inline int sk_wmem_schedule(struct sock *sk, int size)
  819. {
  820. if (!sk_has_account(sk))
  821. return 1;
  822. return size <= sk->sk_forward_alloc ||
  823. __sk_mem_schedule(sk, size, SK_MEM_SEND);
  824. }
  825. static inline int sk_rmem_schedule(struct sock *sk, int size)
  826. {
  827. if (!sk_has_account(sk))
  828. return 1;
  829. return size <= sk->sk_forward_alloc ||
  830. __sk_mem_schedule(sk, size, SK_MEM_RECV);
  831. }
  832. static inline void sk_mem_reclaim(struct sock *sk)
  833. {
  834. if (!sk_has_account(sk))
  835. return;
  836. if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
  837. __sk_mem_reclaim(sk);
  838. }
  839. static inline void sk_mem_reclaim_partial(struct sock *sk)
  840. {
  841. if (!sk_has_account(sk))
  842. return;
  843. if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
  844. __sk_mem_reclaim(sk);
  845. }
  846. static inline void sk_mem_charge(struct sock *sk, int size)
  847. {
  848. if (!sk_has_account(sk))
  849. return;
  850. sk->sk_forward_alloc -= size;
  851. }
  852. static inline void sk_mem_uncharge(struct sock *sk, int size)
  853. {
  854. if (!sk_has_account(sk))
  855. return;
  856. sk->sk_forward_alloc += size;
  857. }
  858. static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
  859. {
  860. sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
  861. sk->sk_wmem_queued -= skb->truesize;
  862. sk_mem_uncharge(sk, skb->truesize);
  863. __kfree_skb(skb);
  864. }
  865. /* Used by processes to "lock" a socket state, so that
  866. * interrupts and bottom half handlers won't change it
  867. * from under us. It essentially blocks any incoming
  868. * packets, so that we won't get any new data or any
  869. * packets that change the state of the socket.
  870. *
  871. * While locked, BH processing will add new packets to
  872. * the backlog queue. This queue is processed by the
  873. * owner of the socket lock right before it is released.
  874. *
  875. * Since ~2.3.5 it is also exclusive sleep lock serializing
  876. * accesses from user process context.
  877. */
  878. #define sock_owned_by_user(sk) ((sk)->sk_lock.owned)
  879. /*
  880. * Macro so as to not evaluate some arguments when
  881. * lockdep is not enabled.
  882. *
  883. * Mark both the sk_lock and the sk_lock.slock as a
  884. * per-address-family lock class.
  885. */
  886. #define sock_lock_init_class_and_name(sk, sname, skey, name, key) \
  887. do { \
  888. sk->sk_lock.owned = 0; \
  889. init_waitqueue_head(&sk->sk_lock.wq); \
  890. spin_lock_init(&(sk)->sk_lock.slock); \
  891. debug_check_no_locks_freed((void *)&(sk)->sk_lock, \
  892. sizeof((sk)->sk_lock)); \
  893. lockdep_set_class_and_name(&(sk)->sk_lock.slock, \
  894. (skey), (sname)); \
  895. lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0); \
  896. } while (0)
  897. extern void lock_sock_nested(struct sock *sk, int subclass);
  898. static inline void lock_sock(struct sock *sk)
  899. {
  900. lock_sock_nested(sk, 0);
  901. }
  902. extern void release_sock(struct sock *sk);
  903. /* BH context may only use the following locking interface. */
  904. #define bh_lock_sock(__sk) spin_lock(&((__sk)->sk_lock.slock))
  905. #define bh_lock_sock_nested(__sk) \
  906. spin_lock_nested(&((__sk)->sk_lock.slock), \
  907. SINGLE_DEPTH_NESTING)
  908. #define bh_unlock_sock(__sk) spin_unlock(&((__sk)->sk_lock.slock))
  909. static inline void lock_sock_bh(struct sock *sk)
  910. {
  911. spin_lock_bh(&sk->sk_lock.slock);
  912. }
  913. static inline void unlock_sock_bh(struct sock *sk)
  914. {
  915. spin_unlock_bh(&sk->sk_lock.slock);
  916. }
  917. extern struct sock *sk_alloc(struct net *net, int family,
  918. gfp_t priority,
  919. struct proto *prot);
  920. extern void sk_free(struct sock *sk);
  921. extern void sk_release_kernel(struct sock *sk);
  922. extern struct sock *sk_clone(const struct sock *sk,
  923. const gfp_t priority);
  924. extern struct sk_buff *sock_wmalloc(struct sock *sk,
  925. unsigned long size, int force,
  926. gfp_t priority);
  927. extern struct sk_buff *sock_rmalloc(struct sock *sk,
  928. unsigned long size, int force,
  929. gfp_t priority);
  930. extern void sock_wfree(struct sk_buff *skb);
  931. extern void sock_rfree(struct sk_buff *skb);
  932. extern int sock_setsockopt(struct socket *sock, int level,
  933. int op, char __user *optval,
  934. unsigned int optlen);
  935. extern int sock_getsockopt(struct socket *sock, int level,
  936. int op, char __user *optval,
  937. int __user *optlen);
  938. extern struct sk_buff *sock_alloc_send_skb(struct sock *sk,
  939. unsigned long size,
  940. int noblock,
  941. int *errcode);
  942. extern struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
  943. unsigned long header_len,
  944. unsigned long data_len,
  945. int noblock,
  946. int *errcode);
  947. extern void *sock_kmalloc(struct sock *sk, int size,
  948. gfp_t priority);
  949. extern void sock_kfree_s(struct sock *sk, void *mem, int size);
  950. extern void sk_send_sigurg(struct sock *sk);
  951. #ifdef CONFIG_CGROUPS
  952. extern void sock_update_classid(struct sock *sk);
  953. #else
  954. static inline void sock_update_classid(struct sock *sk)
  955. {
  956. }
  957. #endif
  958. /*
  959. * Functions to fill in entries in struct proto_ops when a protocol
  960. * does not implement a particular function.
  961. */
  962. extern int sock_no_bind(struct socket *,
  963. struct sockaddr *, int);
  964. extern int sock_no_connect(struct socket *,
  965. struct sockaddr *, int, int);
  966. extern int sock_no_socketpair(struct socket *,
  967. struct socket *);
  968. extern int sock_no_accept(struct socket *,
  969. struct socket *, int);
  970. extern int sock_no_getname(struct socket *,
  971. struct sockaddr *, int *, int);
  972. extern unsigned int sock_no_poll(struct file *, struct socket *,
  973. struct poll_table_struct *);
  974. extern int sock_no_ioctl(struct socket *, unsigned int,
  975. unsigned long);
  976. extern int sock_no_listen(struct socket *, int);
  977. extern int sock_no_shutdown(struct socket *, int);
  978. extern int sock_no_getsockopt(struct socket *, int , int,
  979. char __user *, int __user *);
  980. extern int sock_no_setsockopt(struct socket *, int, int,
  981. char __user *, unsigned int);
  982. extern int sock_no_sendmsg(struct kiocb *, struct socket *,
  983. struct msghdr *, size_t);
  984. extern int sock_no_recvmsg(struct kiocb *, struct socket *,
  985. struct msghdr *, size_t, int);
  986. extern int sock_no_mmap(struct file *file,
  987. struct socket *sock,
  988. struct vm_area_struct *vma);
  989. extern ssize_t sock_no_sendpage(struct socket *sock,
  990. struct page *page,
  991. int offset, size_t size,
  992. int flags);
  993. /*
  994. * Functions to fill in entries in struct proto_ops when a protocol
  995. * uses the inet style.
  996. */
  997. extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
  998. char __user *optval, int __user *optlen);
  999. extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
  1000. struct msghdr *msg, size_t size, int flags);
  1001. extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
  1002. char __user *optval, unsigned int optlen);
  1003. extern int compat_sock_common_getsockopt(struct socket *sock, int level,
  1004. int optname, char __user *optval, int __user *optlen);
  1005. extern int compat_sock_common_setsockopt(struct socket *sock, int level,
  1006. int optname, char __user *optval, unsigned int optlen);
  1007. extern void sk_common_release(struct sock *sk);
  1008. /*
  1009. * Default socket callbacks and setup code
  1010. */
  1011. /* Initialise core socket variables */
  1012. extern void sock_init_data(struct socket *sock, struct sock *sk);
  1013. /**
  1014. * sk_filter_release - release a socket filter
  1015. * @fp: filter to remove
  1016. *
  1017. * Remove a filter from a socket and release its resources.
  1018. */
  1019. static inline void sk_filter_release(struct sk_filter *fp)
  1020. {
  1021. if (atomic_dec_and_test(&fp->refcnt))
  1022. kfree(fp);
  1023. }
  1024. static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
  1025. {
  1026. unsigned int size = sk_filter_len(fp);
  1027. atomic_sub(size, &sk->sk_omem_alloc);
  1028. sk_filter_release(fp);
  1029. }
  1030. static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
  1031. {
  1032. atomic_inc(&fp->refcnt);
  1033. atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
  1034. }
  1035. /*
  1036. * Socket reference counting postulates.
  1037. *
  1038. * * Each user of socket SHOULD hold a reference count.
  1039. * * Each access point to socket (an hash table bucket, reference from a list,
  1040. * running timer, skb in flight MUST hold a reference count.
  1041. * * When reference count hits 0, it means it will never increase back.
  1042. * * When reference count hits 0, it means that no references from
  1043. * outside exist to this socket and current process on current CPU
  1044. * is last user and may/should destroy this socket.
  1045. * * sk_free is called from any context: process, BH, IRQ. When
  1046. * it is called, socket has no references from outside -> sk_free
  1047. * may release descendant resources allocated by the socket, but
  1048. * to the time when it is called, socket is NOT referenced by any
  1049. * hash tables, lists etc.
  1050. * * Packets, delivered from outside (from network or from another process)
  1051. * and enqueued on receive/error queues SHOULD NOT grab reference count,
  1052. * when they sit in queue. Otherwise, packets will leak to hole, when
  1053. * socket is looked up by one cpu and unhasing is made by another CPU.
  1054. * It is true for udp/raw, netlink (leak to receive and error queues), tcp
  1055. * (leak to backlog). Packet socket does all the processing inside
  1056. * BR_NETPROTO_LOCK, so that it has not this race condition. UNIX sockets
  1057. * use separate SMP lock, so that they are prone too.
  1058. */
  1059. /* Ungrab socket and destroy it, if it was the last reference. */
  1060. static inline void sock_put(struct sock *sk)
  1061. {
  1062. if (atomic_dec_and_test(&sk->sk_refcnt))
  1063. sk_free(sk);
  1064. }
  1065. extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
  1066. const int nested);
  1067. static inline void sk_tx_queue_set(struct sock *sk, int tx_queue)
  1068. {
  1069. sk->sk_tx_queue_mapping = tx_queue;
  1070. }
  1071. static inline void sk_tx_queue_clear(struct sock *sk)
  1072. {
  1073. sk->sk_tx_queue_mapping = -1;
  1074. }
  1075. static inline int sk_tx_queue_get(const struct sock *sk)
  1076. {
  1077. return sk->sk_tx_queue_mapping;
  1078. }
  1079. static inline bool sk_tx_queue_recorded(const struct sock *sk)
  1080. {
  1081. return (sk && sk->sk_tx_queue_mapping >= 0);
  1082. }
  1083. static inline void sk_set_socket(struct sock *sk, struct socket *sock)
  1084. {
  1085. sk_tx_queue_clear(sk);
  1086. sk->sk_socket = sock;
  1087. }
  1088. static inline wait_queue_head_t *sk_sleep(struct sock *sk)
  1089. {
  1090. return &sk->sk_wq->wait;
  1091. }
  1092. /* Detach socket from process context.
  1093. * Announce socket dead, detach it from wait queue and inode.
  1094. * Note that parent inode held reference count on this struct sock,
  1095. * we do not release it in this function, because protocol
  1096. * probably wants some additional cleanups or even continuing
  1097. * to work with this socket (TCP).
  1098. */
  1099. static inline void sock_orphan(struct sock *sk)
  1100. {
  1101. write_lock_bh(&sk->sk_callback_lock);
  1102. sock_set_flag(sk, SOCK_DEAD);
  1103. sk_set_socket(sk, NULL);
  1104. sk->sk_wq = NULL;
  1105. write_unlock_bh(&sk->sk_callback_lock);
  1106. }
  1107. static inline void sock_graft(struct sock *sk, struct socket *parent)
  1108. {
  1109. write_lock_bh(&sk->sk_callback_lock);
  1110. rcu_assign_pointer(sk->sk_wq, parent->wq);
  1111. parent->sk = sk;
  1112. sk_set_socket(sk, parent);
  1113. security_sock_graft(sk, parent);
  1114. write_unlock_bh(&sk->sk_callback_lock);
  1115. }
  1116. extern int sock_i_uid(struct sock *sk);
  1117. extern unsigned long sock_i_ino(struct sock *sk);
  1118. static inline struct dst_entry *
  1119. __sk_dst_get(struct sock *sk)
  1120. {
  1121. return rcu_dereference_check(sk->sk_dst_cache, rcu_read_lock_held() ||
  1122. sock_owned_by_user(sk) ||
  1123. lockdep_is_held(&sk->sk_lock.slock));
  1124. }
  1125. static inline struct dst_entry *
  1126. sk_dst_get(struct sock *sk)
  1127. {
  1128. struct dst_entry *dst;
  1129. rcu_read_lock();
  1130. dst = rcu_dereference(sk->sk_dst_cache);
  1131. if (dst)
  1132. dst_hold(dst);
  1133. rcu_read_unlock();
  1134. return dst;
  1135. }
  1136. extern void sk_reset_txq(struct sock *sk);
  1137. static inline void dst_negative_advice(struct sock *sk)
  1138. {
  1139. struct dst_entry *ndst, *dst = __sk_dst_get(sk);
  1140. if (dst && dst->ops->negative_advice) {
  1141. ndst = dst->ops->negative_advice(dst);
  1142. if (ndst != dst) {
  1143. rcu_assign_pointer(sk->sk_dst_cache, ndst);
  1144. sk_reset_txq(sk);
  1145. }
  1146. }
  1147. }
  1148. static inline void
  1149. __sk_dst_set(struct sock *sk, struct dst_entry *dst)
  1150. {
  1151. struct dst_entry *old_dst;
  1152. sk_tx_queue_clear(sk);
  1153. /*
  1154. * This can be called while sk is owned by the caller only,
  1155. * with no state that can be checked in a rcu_dereference_check() cond
  1156. */
  1157. old_dst = rcu_dereference_raw(sk->sk_dst_cache);
  1158. rcu_assign_pointer(sk->sk_dst_cache, dst);
  1159. dst_release(old_dst);
  1160. }
  1161. static inline void
  1162. sk_dst_set(struct sock *sk, struct dst_entry *dst)
  1163. {
  1164. spin_lock(&sk->sk_dst_lock);
  1165. __sk_dst_set(sk, dst);
  1166. spin_unlock(&sk->sk_dst_lock);
  1167. }
  1168. static inline void
  1169. __sk_dst_reset(struct sock *sk)
  1170. {
  1171. __sk_dst_set(sk, NULL);
  1172. }
  1173. static inline void
  1174. sk_dst_reset(struct sock *sk)
  1175. {
  1176. spin_lock(&sk->sk_dst_lock);
  1177. __sk_dst_reset(sk);
  1178. spin_unlock(&sk->sk_dst_lock);
  1179. }
  1180. extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
  1181. extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
  1182. static inline int sk_can_gso(const struct sock *sk)
  1183. {
  1184. return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
  1185. }
  1186. extern void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
  1187. static inline void sk_nocaps_add(struct sock *sk, int flags)
  1188. {
  1189. sk->sk_route_nocaps |= flags;
  1190. sk->sk_route_caps &= ~flags;
  1191. }
  1192. static inline int skb_copy_to_page(struct sock *sk, char __user *from,
  1193. struct sk_buff *skb, struct page *page,
  1194. int off, int copy)
  1195. {
  1196. if (skb->ip_summed == CHECKSUM_NONE) {
  1197. int err = 0;
  1198. __wsum csum = csum_and_copy_from_user(from,
  1199. page_address(page) + off,
  1200. copy, 0, &err);
  1201. if (err)
  1202. return err;
  1203. skb->csum = csum_block_add(skb->csum, csum, skb->len);
  1204. } else if (copy_from_user(page_address(page) + off, from, copy))
  1205. return -EFAULT;
  1206. skb->len += copy;
  1207. skb->data_len += copy;
  1208. skb->truesize += copy;
  1209. sk->sk_wmem_queued += copy;
  1210. sk_mem_charge(sk, copy);
  1211. return 0;
  1212. }
  1213. /**
  1214. * sk_wmem_alloc_get - returns write allocations
  1215. * @sk: socket
  1216. *
  1217. * Returns sk_wmem_alloc minus initial offset of one
  1218. */
  1219. static inline int sk_wmem_alloc_get(const struct sock *sk)
  1220. {
  1221. return atomic_read(&sk->sk_wmem_alloc) - 1;
  1222. }
  1223. /**
  1224. * sk_rmem_alloc_get - returns read allocations
  1225. * @sk: socket
  1226. *
  1227. * Returns sk_rmem_alloc
  1228. */
  1229. static inline int sk_rmem_alloc_get(const struct sock *sk)
  1230. {
  1231. return atomic_read(&sk->sk_rmem_alloc);
  1232. }
  1233. /**
  1234. * sk_has_allocations - check if allocations are outstanding
  1235. * @sk: socket
  1236. *
  1237. * Returns true if socket has write or read allocations
  1238. */
  1239. static inline int sk_has_allocations(const struct sock *sk)
  1240. {
  1241. return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
  1242. }
  1243. /**
  1244. * wq_has_sleeper - check if there are any waiting processes
  1245. * @wq: struct socket_wq
  1246. *
  1247. * Returns true if socket_wq has waiting processes
  1248. *
  1249. * The purpose of the wq_has_sleeper and sock_poll_wait is to wrap the memory
  1250. * barrier call. They were added due to the race found within the tcp code.
  1251. *
  1252. * Consider following tcp code paths:
  1253. *
  1254. * CPU1 CPU2
  1255. *
  1256. * sys_select receive packet
  1257. * ... ...
  1258. * __add_wait_queue update tp->rcv_nxt
  1259. * ... ...
  1260. * tp->rcv_nxt check sock_def_readable
  1261. * ... {
  1262. * schedule rcu_read_lock();
  1263. * wq = rcu_dereference(sk->sk_wq);
  1264. * if (wq && waitqueue_active(&wq->wait))
  1265. * wake_up_interruptible(&wq->wait)
  1266. * ...
  1267. * }
  1268. *
  1269. * The race for tcp fires when the __add_wait_queue changes done by CPU1 stay
  1270. * in its cache, and so does the tp->rcv_nxt update on CPU2 side. The CPU1
  1271. * could then endup calling schedule and sleep forever if there are no more
  1272. * data on the socket.
  1273. *
  1274. */
  1275. static inline bool wq_has_sleeper(struct socket_wq *wq)
  1276. {
  1277. /*
  1278. * We need to be sure we are in sync with the
  1279. * add_wait_queue modifications to the wait queue.
  1280. *
  1281. * This memory barrier is paired in the sock_poll_wait.
  1282. */
  1283. smp_mb();
  1284. return wq && waitqueue_active(&wq->wait);
  1285. }
  1286. /**
  1287. * sock_poll_wait - place memory barrier behind the poll_wait call.
  1288. * @filp: file
  1289. * @wait_address: socket wait queue
  1290. * @p: poll_table
  1291. *
  1292. * See the comments in the wq_has_sleeper function.
  1293. */
  1294. static inline void sock_poll_wait(struct file *filp,
  1295. wait_queue_head_t *wait_address, poll_table *p)
  1296. {
  1297. if (p && wait_address) {
  1298. poll_wait(filp, wait_address, p);
  1299. /*
  1300. * We need to be sure we are in sync with the
  1301. * socket flags modification.
  1302. *
  1303. * This memory barrier is paired in the wq_has_sleeper.
  1304. */
  1305. smp_mb();
  1306. }
  1307. }
  1308. /*
  1309. * Queue a received datagram if it will fit. Stream and sequenced
  1310. * protocols can't normally use this as they need to fit buffers in
  1311. * and play with them.
  1312. *
  1313. * Inlined as it's very short and called for pretty much every
  1314. * packet ever received.
  1315. */
  1316. static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
  1317. {
  1318. skb_orphan(skb);
  1319. skb->sk = sk;
  1320. skb->destructor = sock_wfree;
  1321. /*
  1322. * We used to take a refcount on sk, but following operation
  1323. * is enough to guarantee sk_free() wont free this sock until
  1324. * all in-flight packets are completed
  1325. */
  1326. atomic_add(skb->truesize, &sk->sk_wmem_alloc);
  1327. }
  1328. static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
  1329. {
  1330. skb_orphan(skb);
  1331. skb->sk = sk;
  1332. skb->destructor = sock_rfree;
  1333. atomic_add(skb->truesize, &sk->sk_rmem_alloc);
  1334. sk_mem_charge(sk, skb->truesize);
  1335. }
  1336. extern void sk_reset_timer(struct sock *sk, struct timer_list* timer,
  1337. unsigned long expires);
  1338. extern void sk_stop_timer(struct sock *sk, struct timer_list* timer);
  1339. extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
  1340. static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
  1341. {
  1342. /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
  1343. number of warnings when compiling with -W --ANK
  1344. */
  1345. if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
  1346. (unsigned)sk->sk_rcvbuf)
  1347. return -ENOMEM;
  1348. skb_set_owner_r(skb, sk);
  1349. skb_queue_tail(&sk->sk_error_queue, skb);
  1350. if (!sock_flag(sk, SOCK_DEAD))
  1351. sk->sk_data_ready(sk, skb->len);
  1352. return 0;
  1353. }
  1354. /*
  1355. * Recover an error report and clear atomically
  1356. */
  1357. static inline int sock_error(struct sock *sk)
  1358. {
  1359. int err;
  1360. if (likely(!sk->sk_err))
  1361. return 0;
  1362. err = xchg(&sk->sk_err, 0);
  1363. return -err;
  1364. }
  1365. static inline unsigned long sock_wspace(struct sock *sk)
  1366. {
  1367. int amt = 0;
  1368. if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
  1369. amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
  1370. if (amt < 0)
  1371. amt = 0;
  1372. }
  1373. return amt;
  1374. }
  1375. static inline void sk_wake_async(struct sock *sk, int how, int band)
  1376. {
  1377. if (sock_flag(sk, SOCK_FASYNC))
  1378. sock_wake_async(sk->sk_socket, how, band);
  1379. }
  1380. #define SOCK_MIN_SNDBUF 2048
  1381. #define SOCK_MIN_RCVBUF 256
  1382. static inline void sk_stream_moderate_sndbuf(struct sock *sk)
  1383. {
  1384. if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
  1385. sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
  1386. sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
  1387. }
  1388. }
  1389. struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
  1390. static inline struct page *sk_stream_alloc_page(struct sock *sk)
  1391. {
  1392. struct page *page = NULL;
  1393. page = alloc_pages(sk->sk_allocation, 0);
  1394. if (!page) {
  1395. sk->sk_prot->enter_memory_pressure(sk);
  1396. sk_stream_moderate_sndbuf(sk);
  1397. }
  1398. return page;
  1399. }
  1400. /*
  1401. * Default write policy as shown to user space via poll/select/SIGIO
  1402. */
  1403. static inline int sock_writeable(const struct sock *sk)
  1404. {
  1405. return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
  1406. }
  1407. static inline gfp_t gfp_any(void)
  1408. {
  1409. return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
  1410. }
  1411. static inline long sock_rcvtimeo(const struct sock *sk, int noblock)
  1412. {
  1413. return noblock ? 0 : sk->sk_rcvtimeo;
  1414. }
  1415. static inline long sock_sndtimeo(const struct sock *sk, int noblock)
  1416. {
  1417. return noblock ? 0 : sk->sk_sndtimeo;
  1418. }
  1419. static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
  1420. {
  1421. return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
  1422. }
  1423. /* Alas, with timeout socket operations are not restartable.
  1424. * Compare this to poll().
  1425. */
  1426. static inline int sock_intr_errno(long timeo)
  1427. {
  1428. return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
  1429. }
  1430. extern void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
  1431. struct sk_buff *skb);
  1432. static __inline__ void
  1433. sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
  1434. {
  1435. ktime_t kt = skb->tstamp;
  1436. struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
  1437. /*
  1438. * generate control messages if
  1439. * - receive time stamping in software requested (SOCK_RCVTSTAMP
  1440. * or SOCK_TIMESTAMPING_RX_SOFTWARE)
  1441. * - software time stamp available and wanted
  1442. * (SOCK_TIMESTAMPING_SOFTWARE)
  1443. * - hardware time stamps available and wanted
  1444. * (SOCK_TIMESTAMPING_SYS_HARDWARE or
  1445. * SOCK_TIMESTAMPING_RAW_HARDWARE)
  1446. */
  1447. if (sock_flag(sk, SOCK_RCVTSTAMP) ||
  1448. sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
  1449. (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
  1450. (hwtstamps->hwtstamp.tv64 &&
  1451. sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
  1452. (hwtstamps->syststamp.tv64 &&
  1453. sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
  1454. __sock_recv_timestamp(msg, sk, skb);
  1455. else
  1456. sk->sk_stamp = kt;
  1457. }
  1458. extern void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
  1459. struct sk_buff *skb);
  1460. static inline void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
  1461. struct sk_buff *skb)
  1462. {
  1463. #define FLAGS_TS_OR_DROPS ((1UL << SOCK_RXQ_OVFL) | \
  1464. (1UL << SOCK_RCVTSTAMP) | \
  1465. (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE) | \
  1466. (1UL << SOCK_TIMESTAMPING_SOFTWARE) | \
  1467. (1UL << SOCK_TIMESTAMPING_RAW_HARDWARE) | \
  1468. (1UL << SOCK_TIMESTAMPING_SYS_HARDWARE))
  1469. if (sk->sk_flags & FLAGS_TS_OR_DROPS)
  1470. __sock_recv_ts_and_drops(msg, sk, skb);
  1471. else
  1472. sk->sk_stamp = skb->tstamp;
  1473. }
  1474. /**
  1475. * sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
  1476. * @msg: outgoing packet
  1477. * @sk: socket sending this packet
  1478. * @shtx: filled with instructions for time stamping
  1479. *
  1480. * Currently only depends on SOCK_TIMESTAMPING* flags. Returns error code if
  1481. * parameters are invalid.
  1482. */
  1483. extern int sock_tx_timestamp(struct msghdr *msg,
  1484. struct sock *sk,
  1485. union skb_shared_tx *shtx);
  1486. /**
  1487. * sk_eat_skb - Release a skb if it is no longer needed
  1488. * @sk: socket to eat this skb from
  1489. * @skb: socket buffer to eat
  1490. * @copied_early: flag indicating whether DMA operations copied this data early
  1491. *
  1492. * This routine must be called with interrupts disabled or with the socket
  1493. * locked so that the sk_buff queue operation is ok.
  1494. */
  1495. #ifdef CONFIG_NET_DMA
  1496. static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
  1497. {
  1498. __skb_unlink(skb, &sk->sk_receive_queue);
  1499. if (!copied_early)
  1500. __kfree_skb(skb);
  1501. else
  1502. __skb_queue_tail(&sk->sk_async_wait_queue, skb);
  1503. }
  1504. #else
  1505. static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
  1506. {
  1507. __skb_unlink(skb, &sk->sk_receive_queue);
  1508. __kfree_skb(skb);
  1509. }
  1510. #endif
  1511. static inline
  1512. struct net *sock_net(const struct sock *sk)
  1513. {
  1514. #ifdef CONFIG_NET_NS
  1515. return sk->sk_net;
  1516. #else
  1517. return &init_net;
  1518. #endif
  1519. }
  1520. static inline
  1521. void sock_net_set(struct sock *sk, struct net *net)
  1522. {
  1523. #ifdef CONFIG_NET_NS
  1524. sk->sk_net = net;
  1525. #endif
  1526. }
  1527. /*
  1528. * Kernel sockets, f.e. rtnl or icmp_socket, are a part of a namespace.
  1529. * They should not hold a referrence to a namespace in order to allow
  1530. * to stop it.
  1531. * Sockets after sk_change_net should be released using sk_release_kernel
  1532. */
  1533. static inline void sk_change_net(struct sock *sk, struct net *net)
  1534. {
  1535. put_net(sock_net(sk));
  1536. sock_net_set(sk, hold_net(net));
  1537. }
  1538. static inline struct sock *skb_steal_sock(struct sk_buff *skb)
  1539. {
  1540. if (unlikely(skb->sk)) {
  1541. struct sock *sk = skb->sk;
  1542. skb->destructor = NULL;
  1543. skb->sk = NULL;
  1544. return sk;
  1545. }
  1546. return NULL;
  1547. }
  1548. extern void sock_enable_timestamp(struct sock *sk, int flag);
  1549. extern int sock_get_timestamp(struct sock *, struct timeval __user *);
  1550. extern int sock_get_timestampns(struct sock *, struct timespec __user *);
  1551. /*
  1552. * Enable debug/info messages
  1553. */
  1554. extern int net_msg_warn;
  1555. #define NETDEBUG(fmt, args...) \
  1556. do { if (net_msg_warn) printk(fmt,##args); } while (0)
  1557. #define LIMIT_NETDEBUG(fmt, args...) \
  1558. do { if (net_msg_warn && net_ratelimit()) printk(fmt,##args); } while(0)
  1559. extern __u32 sysctl_wmem_max;
  1560. extern __u32 sysctl_rmem_max;
  1561. extern void sk_init(void);
  1562. extern int sysctl_optmem_max;
  1563. extern __u32 sysctl_wmem_default;
  1564. extern __u32 sysctl_rmem_default;
  1565. #endif /* _SOCK_H */