sock.h 42 KB

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