Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 212 insertions, 0 deletions

diff --git a/include/rxrpc/call.h b/include/rxrpc/call.h
new file mode 100644
index 000000000000..f48f27e9e0ab
--- /dev/null
+++ b/include/rxrpc/call.h
@@ -0,0 +1,212 @@
+/* call.h: Rx call record
+ *
+ * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_RXRPC_CALL_H
+#define _LINUX_RXRPC_CALL_H
+
+#include <rxrpc/types.h>
+#include <rxrpc/rxrpc.h>
+#include <rxrpc/packet.h>
+#include <linux/timer.h>
+
+#define RXRPC_CALL_ACK_WINDOW_SIZE	16
+
+extern unsigned rxrpc_call_rcv_timeout;		/* receive activity timeout (secs) */
+
+/* application call state
+ * - only state 0 and ffff are reserved, the state is set to 1 after an opid is received
+ */
+enum rxrpc_app_cstate {
+	RXRPC_CSTATE_COMPLETE		= 0,	/* operation complete */
+	RXRPC_CSTATE_ERROR,			/* operation ICMP error or aborted */
+	RXRPC_CSTATE_SRVR_RCV_OPID,		/* [SERVER] receiving operation ID */
+	RXRPC_CSTATE_SRVR_RCV_ARGS,		/* [SERVER] receiving operation data */
+	RXRPC_CSTATE_SRVR_GOT_ARGS,		/* [SERVER] completely received operation data */
+	RXRPC_CSTATE_SRVR_SND_REPLY,		/* [SERVER] sending operation reply */
+	RXRPC_CSTATE_SRVR_RCV_FINAL_ACK,	/* [SERVER] receiving final ACK */
+	RXRPC_CSTATE_CLNT_SND_ARGS,		/* [CLIENT] sending operation args */
+	RXRPC_CSTATE_CLNT_RCV_REPLY,		/* [CLIENT] receiving operation reply */
+	RXRPC_CSTATE_CLNT_GOT_REPLY,		/* [CLIENT] completely received operation reply */
+} __attribute__((packed));
+
+extern const char *rxrpc_call_states[];
+
+enum rxrpc_app_estate {
+	RXRPC_ESTATE_NO_ERROR		= 0,	/* no error */
+	RXRPC_ESTATE_LOCAL_ABORT,		/* aborted locally by application layer */
+	RXRPC_ESTATE_PEER_ABORT,		/* aborted remotely by peer */
+	RXRPC_ESTATE_LOCAL_ERROR,		/* local ICMP network error */
+	RXRPC_ESTATE_REMOTE_ERROR,		/* remote ICMP network error */
+} __attribute__((packed));
+
+extern const char *rxrpc_call_error_states[];
+
+/*****************************************************************************/
+/*
+ * Rx call record and application scratch buffer
+ * - the call record occupies the bottom of a complete page
+ * - the application scratch buffer occupies the rest
+ */
+struct rxrpc_call
+{
+	atomic_t		usage;
+	struct rxrpc_connection	*conn;		/* connection upon which active */
+	spinlock_t		lock;		/* access lock */
+	struct module		*owner;		/* owner module */
+	wait_queue_head_t	waitq;		/* wait queue for events to happen */
+	struct list_head	link;		/* general internal list link */
+	struct list_head	call_link;	/* master call list link */
+	__be32			chan_ix;	/* connection channel index  */
+	__be32			call_id;	/* call ID on connection  */
+	unsigned long		cjif;		/* jiffies at call creation */
+	unsigned long		flags;		/* control flags */
+#define RXRPC_CALL_ACKS_TIMO	0x00000001	/* ACKS timeout reached */
+#define RXRPC_CALL_ACKR_TIMO	0x00000002	/* ACKR timeout reached */
+#define RXRPC_CALL_RCV_TIMO	0x00000004	/* RCV timeout reached */
+#define RXRPC_CALL_RCV_PKT	0x00000008	/* received packet */
+
+	/* transmission */
+	rxrpc_seq_t		snd_seq_count;	/* outgoing packet sequence number counter */
+	struct rxrpc_message	*snd_nextmsg;	/* next message being constructed for sending */
+	struct rxrpc_message	*snd_ping;	/* last ping message sent */
+	unsigned short		snd_resend_cnt;	/* count of resends since last ACK */
+
+	/* transmission ACK tracking */
+	struct list_head	acks_pendq;	/* messages pending ACK (ordered by seq) */
+	unsigned		acks_pend_cnt;	/* number of un-ACK'd packets */
+	rxrpc_seq_t		acks_dftv_seq;	/* highest definitively ACK'd msg seq */
+	struct timer_list	acks_timeout;	/* timeout on expected ACK */
+
+	/* reception */
+	struct list_head	rcv_receiveq;	/* messages pending reception (ordered by seq) */
+	struct list_head	rcv_krxiodq_lk;	/* krxiod queue for new inbound packets */
+	struct timer_list	rcv_timeout;	/* call receive activity timeout */
+
+	/* reception ACK'ing */
+	rxrpc_seq_t		ackr_win_bot;	/* bottom of ACK window */
+	rxrpc_seq_t		ackr_win_top;	/* top of ACK window */
+	rxrpc_seq_t		ackr_high_seq;	/* highest seqno yet received */
+	rxrpc_seq_net_t		ackr_prev_seq;	/* previous seqno received */
+	unsigned		ackr_pend_cnt;	/* number of pending ACKs */
+	struct timer_list	ackr_dfr_timo;	/* timeout on deferred ACK */
+	char			ackr_dfr_perm;	/* request for deferred ACKs permitted */
+	rxrpc_seq_t		ackr_dfr_seq;	/* seqno for deferred ACK */
+	struct rxrpc_ackpacket	ackr;		/* pending normal ACK packet */
+	uint8_t			ackr_array[RXRPC_CALL_ACK_WINDOW_SIZE];	/* ACK records */
+
+	/* presentation layer */
+	char			app_last_rcv;	/* T if received last packet from remote end */
+	enum rxrpc_app_cstate	app_call_state;	/* call state */
+	enum rxrpc_app_estate	app_err_state;	/* abort/error state */
+	struct list_head	app_readyq;	/* ordered ready received packet queue */
+	struct list_head	app_unreadyq;	/* ordered post-hole recv'd packet queue */
+	rxrpc_seq_t		app_ready_seq;	/* last seq number dropped into readyq */
+	size_t			app_ready_qty;	/* amount of data ready in readyq */
+	unsigned		app_opcode;	/* operation ID */
+	unsigned		app_abort_code;	/* abort code (when aborted) */
+	int			app_errno;	/* error number (when ICMP error received) */
+
+	/* statisics */
+	unsigned		pkt_rcv_count;	/* count of received packets on this call */
+	unsigned		pkt_snd_count;	/* count of sent packets on this call */
+	unsigned		app_read_count;	/* number of reads issued */
+
+	/* bits for the application to use */
+	rxrpc_call_attn_func_t	app_attn_func;	/* callback when attention required */
+	rxrpc_call_error_func_t	app_error_func;	/* callback when abort sent (cleanup and put) */
+	rxrpc_call_aemap_func_t	app_aemap_func;	/* callback to map abort code to/from errno */
+	void			*app_user;	/* application data */
+	struct list_head	app_link;	/* application list linkage */
+	struct list_head	app_attn_link;	/* application attention list linkage */
+	size_t			app_mark;	/* trigger callback when app_ready_qty>=app_mark */
+	char			app_async_read;	/* T if in async-read mode */
+	uint8_t			*app_read_buf;	/* application async read buffer (app_mark size) */
+	uint8_t			*app_scr_alloc;	/* application scratch allocation pointer */
+	void			*app_scr_ptr;	/* application pointer into scratch buffer */
+
+#define RXRPC_APP_MARK_EOF 0xFFFFFFFFU	/* mark at end of input */
+
+	/* application scratch buffer */
+	uint8_t			app_scratch[0] __attribute__((aligned(sizeof(long))));
+};
+
+#define RXRPC_CALL_SCRATCH_SIZE (PAGE_SIZE - sizeof(struct rxrpc_call))
+
+#define rxrpc_call_reset_scratch(CALL) \
+do { (CALL)->app_scr_alloc = (CALL)->app_scratch; } while(0)
+
+#define rxrpc_call_alloc_scratch(CALL,SIZE)						\
+({											\
+	void *ptr;									\
+	ptr = (CALL)->app_scr_alloc;							\
+	(CALL)->app_scr_alloc += (SIZE);						\
+	if ((SIZE)>RXRPC_CALL_SCRATCH_SIZE ||						\
+	    (size_t)((CALL)->app_scr_alloc - (u8*)(CALL)) > RXRPC_CALL_SCRATCH_SIZE) {	\
+		printk("rxrpc_call_alloc_scratch(%p,%Zu)\n",(CALL),(size_t)(SIZE));	\
+		BUG();									\
+	}										\
+	ptr;										\
+})
+
+#define rxrpc_call_alloc_scratch_s(CALL,TYPE)						\
+({											\
+	size_t size = sizeof(TYPE);							\
+	TYPE *ptr;									\
+	ptr = (TYPE*)(CALL)->app_scr_alloc;						\
+	(CALL)->app_scr_alloc += size;							\
+	if (size>RXRPC_CALL_SCRATCH_SIZE ||						\
+	    (size_t)((CALL)->app_scr_alloc - (u8*)(CALL)) > RXRPC_CALL_SCRATCH_SIZE) {	\
+		printk("rxrpc_call_alloc_scratch(%p,%Zu)\n",(CALL),size);		\
+		BUG();									\
+	}										\
+	ptr;										\
+})
+
+#define rxrpc_call_is_ack_pending(CALL) ((CALL)->ackr.reason != 0)
+
+extern int rxrpc_create_call(struct rxrpc_connection *conn,
+			     rxrpc_call_attn_func_t attn,
+			     rxrpc_call_error_func_t error,
+			     rxrpc_call_aemap_func_t aemap,
+			     struct rxrpc_call **_call);
+
+extern int rxrpc_incoming_call(struct rxrpc_connection *conn,
+			       struct rxrpc_message *msg,
+			       struct rxrpc_call **_call);
+
+static inline void rxrpc_get_call(struct rxrpc_call *call)
+{
+	BUG_ON(atomic_read(&call->usage)<=0);
+	atomic_inc(&call->usage);
+	/*printk("rxrpc_get_call(%p{u=%d})\n",(C),atomic_read(&(C)->usage));*/
+}
+
+extern void rxrpc_put_call(struct rxrpc_call *call);
+
+extern void rxrpc_call_do_stuff(struct rxrpc_call *call);
+
+extern int rxrpc_call_abort(struct rxrpc_call *call, int error);
+
+#define RXRPC_CALL_READ_BLOCK	0x0001	/* block if not enough data and not yet EOF */
+#define RXRPC_CALL_READ_ALL	0x0002	/* error if insufficient data received */
+extern int rxrpc_call_read_data(struct rxrpc_call *call, void *buffer, size_t size, int flags);
+
+extern int rxrpc_call_write_data(struct rxrpc_call *call,
+				 size_t sioc,
+				 struct kvec *siov,
+				 uint8_t rxhdr_flags,
+				 int alloc_flags,
+				 int dup_data,
+				 size_t *size_sent);
+
+extern void rxrpc_call_handle_error(struct rxrpc_call *conn, int local, int errno);
+
+#endif /* _LINUX_RXRPC_CALL_H */