sock.h 40 KB

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