/**

  *	struct sock - network layer representation of sockets

  *	@__sk_common: shared layout with inet_timewait_sock

  *	@sk_shutdown: mask of %SEND_SHUTDOWN and/or %RCV_SHUTDOWN

  *	@sk_userlocks: %SO_SNDBUF and %SO_RCVBUF settings

  *	@sk_lock:	synchronizer

  *	@sk_rcvbuf: size of receive buffer in bytes

  *	@sk_sleep: sock wait queue

  *	@sk_dst_cache: destination cache

  *	@sk_dst_lock: destination cache lock

  *	@sk_policy: flow policy

  *	@sk_rmem_alloc: receive queue bytes committed

  *	@sk_receive_queue: incoming packets

  *	@sk_wmem_alloc: transmit queue bytes committed

  *	@sk_write_queue: Packet sending queue

  *	@sk_async_wait_queue: DMA copied packets

  *	@sk_omem_alloc: "o" is "option" or "other"

  *	@sk_wmem_queued: persistent queue size

  *	@sk_forward_alloc: space allocated forward

  *	@sk_allocation: allocation mode

  *	@sk_sndbuf: size of send buffer in bytes

  *	@sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,

  *		   %SO_OOBINLINE settings, %SO_TIMESTAMPING settings

  *	@sk_no_check: %SO_NO_CHECK setting, wether or not checkup packets

  *	@sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)

  *	@sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)

  *	@sk_gso_max_size: Maximum GSO segment size to build

  *	@sk_lingertime: %SO_LINGER l_linger setting

  *	@sk_backlog: always used with the per-socket spinlock held

  *	@sk_callback_lock: used with the callbacks in the end of this struct

  *	@sk_error_queue: rarely used

  *	@sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt,

  *			  IPV6_ADDRFORM for instance)

  *	@sk_err: last error

  *	@sk_err_soft: errors that don't cause failure but are the cause of a

  *		      persistent failure not just 'timed out'

  *	@sk_drops: raw/udp drops counter

  *	@sk_ack_backlog: current listen backlog

  *	@sk_max_ack_backlog: listen backlog set in listen()

  *	@sk_priority: %SO_PRIORITY setting

  *	@sk_type: socket type (%SOCK_STREAM, etc)

  *	@sk_protocol: which protocol this socket belongs in this network family

  *	@sk_peercred: %SO_PEERCRED setting

  *	@sk_rcvlowat: %SO_RCVLOWAT setting

  *	@sk_rcvtimeo: %SO_RCVTIMEO setting

  *	@sk_sndtimeo: %SO_SNDTIMEO setting

  *	@sk_filter: socket filtering instructions

  *	@sk_protinfo: private area, net family specific, when not using slab

  *	@sk_timer: sock cleanup timer

  *	@sk_stamp: time stamp of last packet received

  *	@sk_socket: Identd and reporting IO signals

  *	@sk_user_data: RPC layer private data

  *	@sk_sndmsg_page: cached page for sendmsg

  *	@sk_sndmsg_off: cached offset for sendmsg

  *	@sk_send_head: front of stuff to transmit

  *	@sk_security: used by security modules

  *	@sk_mark: generic packet mark

  *	@sk_write_pending: a write to stream socket waits to start

  *	@sk_state_change: callback to indicate change in the state of the sock

  *	@sk_data_ready: callback to indicate there is data to be processed

  *	@sk_write_space: callback to indicate there is bf sending space available

  *	@sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)

  *	@sk_backlog_rcv: callback to process the backlog

  *	@sk_destruct: called at sock freeing time, i.e. when all refcnt == 0

 */

struct sock {

	/*

	 * Now struct inet_timewait_sock also uses sock_common, so please just

	 * don't add nothing before this first member (__sk_common) --acme

	 */

	struct sock_common	__sk_common;

#define sk_family		__sk_common.skc_family

#define sk_state		__sk_common.skc_state

#define sk_reuse		__sk_common.skc_reuse

#define sk_bound_dev_if		__sk_common.skc_bound_dev_if

#define sk_node			__sk_common.skc_node

#define sk_nulls_node		__sk_common.skc_nulls_node

#define sk_bind_node		__sk_common.skc_bind_node

#define sk_refcnt		__sk_common.skc_refcnt

#define sk_hash			__sk_common.skc_hash

#define sk_prot			__sk_common.skc_prot

#define sk_net			__sk_common.skc_net

	unsigned char		sk_shutdown : 2,

				sk_no_check : 2,

				sk_userlocks : 4;

	unsigned char		sk_protocol;

	unsigned short		sk_type;

	int			sk_rcvbuf;

	socket_lock_t		sk_lock;

	/*

	 * The backlog queue is special, it is always used with

	 * the per-socket spinlock held and requires low latency

	 * access. Therefore we special case it's implementation.

	 */

	struct {

		struct sk_buff *head;

		struct sk_buff *tail;

	} sk_backlog;

	wait_queue_head_t	*sk_sleep;

	struct dst_entry	*sk_dst_cache;

#ifdef CONFIG_XFRM

	struct xfrm_policy	*sk_policy[2];

#endif

	rwlock_t		sk_dst_lock;

	atomic_t		sk_rmem_alloc;

	atomic_t		sk_wmem_alloc;

	atomic_t		sk_omem_alloc;

	int			sk_sndbuf;

	struct sk_buff_head	sk_receive_queue;

	struct sk_buff_head	sk_write_queue;

#ifdef CONFIG_NET_DMA

	struct sk_buff_head	sk_async_wait_queue;

#endif

	int			sk_wmem_queued;

	int			sk_forward_alloc;

	gfp_t			sk_allocation;

	int			sk_route_caps;

	int			sk_gso_type;

	unsigned int		sk_gso_max_size;

	int			sk_rcvlowat;

	unsigned long 		sk_flags;

	unsigned long	        sk_lingertime;

	struct sk_buff_head	sk_error_queue;

	struct proto		*sk_prot_creator;

	rwlock_t		sk_callback_lock;

	int			sk_err,

				sk_err_soft;

	atomic_t		sk_drops;

	unsigned short		sk_ack_backlog;

	unsigned short		sk_max_ack_backlog;

	__u32			sk_priority;

	struct ucred		sk_peercred;

	long			sk_rcvtimeo;

	long			sk_sndtimeo;

	struct sk_filter      	*sk_filter;

	void			*sk_protinfo;

	struct timer_list	sk_timer;

	ktime_t			sk_stamp;

	struct socket		*sk_socket;

	void			*sk_user_data;

	struct page		*sk_sndmsg_page;

	struct sk_buff		*sk_send_head;

	__u32			sk_sndmsg_off;

	int			sk_write_pending;

#ifdef CONFIG_SECURITY

	void			*sk_security;

#endif

	__u32			sk_mark;

	/* XXX 4 bytes hole on 64 bit */

	void			(*sk_state_change)(struct sock *sk);

	void			(*sk_data_ready)(struct sock *sk, int bytes);

	void			(*sk_write_space)(struct sock *sk);

	void			(*sk_error_report)(struct sock *sk);

  	int			(*sk_backlog_rcv)(struct sock *sk,

						  struct sk_buff *skb);  

	void                    (*sk_destruct)(struct sock *sk);

};

您可能感兴趣的文章: