summaryrefslogtreecommitdiff
path: root/include/rxrpc/call.h
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 15:20:36 -0700
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 15:20:36 -0700
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /include/rxrpc/call.h
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!
Diffstat (limited to 'include/rxrpc/call.h')
-rw-r--r--include/rxrpc/call.h212
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 */