/******************************************************************************* * mm_l4if.h - L4 mm interface ******************************************************************************/ #ifndef _MM_L4IF_H #define _MM_L4IF_H /* per OS methods */ #if defined(DOS) #include "sync.h" #define MM_INIT_TCP_LOCK_HANDLE() #define mm_acquire_tcp_lock(_pdev, con) LOCK() #define mm_release_tcp_lock(_pdev, con) UNLOCK() #define MM_ACQUIRE_TOE_LOCK(_pdev) LOCK() #define MM_RELEASE_TOE_LOCK(_pdev) UNLOCK() #define MM_ACQUIRE_TOE_GRQ_LOCK(_pdev, idx) LOCK() #define MM_RELEASE_TOE_GRQ_LOCK(_pdev, idx) UNLOCK() #define MM_ACQUIRE_TOE_GRQ_LOCK_DPC(_pdev, idx) LOCK() #define MM_RELEASE_TOE_GRQ_LOCK_DPC(_pdev, idx) UNLOCK() #elif defined(__LINUX) || defined(__SunOS) void mm_acquire_tcp_lock( struct _lm_device_t *pdev, lm_tcp_con_t *tcp_con); void mm_release_tcp_lock( struct _lm_device_t *pdev, lm_tcp_con_t *tcp_con); #define MM_INIT_TCP_LOCK_HANDLE() void MM_ACQUIRE_TOE_LOCK(struct _lm_device_t *_pdev); void MM_RELEASE_TOE_LOCK(struct _lm_device_t *_pdev); void MM_ACQUIRE_TOE_GRQ_LOCK(struct _lm_device_t *_pdev, u8_t idx); void MM_RELEASE_TOE_GRQ_LOCK(struct _lm_device_t *_pdev, u8_t idx); void MM_ACQUIRE_TOE_GRQ_LOCK_DPC(struct _lm_device_t *_pdev, u8_t idx); void MM_RELEASE_TOE_GRQ_LOCK_DPC(struct _lm_device_t *_pdev, u8_t idx); #elif defined(_VBD_) || defined(_VBD_CMD_) #if USE_QUEUED_SLOCK void mm_acquire_tcp_q_lock( lm_device_t *pdev, lm_tcp_con_t *tcp_con, void *ql_hdl); void mm_release_tcp_q_lock( lm_device_t *pdev, lm_tcp_con_t *tcp_con, void *ql_hdl); /* MM_INIT_TCP_LOCK_HANDLE: * a macro for decleration of KLOCK_QUEUE_HANDLE in stack, to be declared * in stack by every lm/um caller to mm_acquire_tcp_q_lock. * since KLOCK_QUEUE_HANDLE is a WDM structure that can't be compiled * in lm, we define a size SIZEOF_QL_HDL that should be larger/equal to * sizeof(KLOCK_QUEUE_HANDLE) */ #define SIZEOF_QL_HDL 24 // 24 is the size KLOCK_QUEUE_HANDLE structure in Win 64 bit, so it supossed to be good enough for both 32 & 64 #define MM_INIT_TCP_LOCK_HANDLE() u8_t __ql_hdl[SIZEOF_QL_HDL] = {0} #define mm_acquire_tcp_lock(pdev,tcp_con) mm_acquire_tcp_q_lock((pdev),(tcp_con),__ql_hdl) #define mm_release_tcp_lock(pdev,tcp_con) mm_release_tcp_q_lock((pdev),(tcp_con),__ql_hdl) #else /* USE_QUEUED_SLOCK */ #define MM_INIT_TCP_LOCK_HANDLE() void mm_acquire_tcp_lock( lm_device_t *pdev, lm_tcp_con_t *tcp_con); void mm_release_tcp_lock( lm_device_t *pdev, lm_tcp_con_t *tcp_con); #endif /* USE_QUEUED_SLOCK */ void MM_ACQUIRE_TOE_LOCK(lm_device_t *_pdev); void MM_RELEASE_TOE_LOCK(lm_device_t *_pdev); void MM_ACQUIRE_TOE_GRQ_LOCK(lm_device_t *_pdev, u8_t idx); void MM_RELEASE_TOE_GRQ_LOCK(lm_device_t *_pdev, u8_t idx); void MM_ACQUIRE_TOE_GRQ_LOCK_DPC(lm_device_t *_pdev, u8_t idx); void MM_RELEASE_TOE_GRQ_LOCK_DPC(lm_device_t *_pdev, u8_t idx); #elif defined(__USER_MODE_DEBUG) #define MM_INIT_TCP_LOCK_HANDLE() __inline static void mm_acquire_tcp_lock( struct _lm_device_t *pdev, lm_tcp_con_t *tcp_con) { DbgMessage(pdev, INFORMl4, "Acquiring tcp lock for con %p\n", tcp_con); } __inline static void mm_release_tcp_lock( struct _lm_device_t *pdev, lm_tcp_con_t *tcp_con) { DbgMessage(pdev, INFORMl4, "Releasing tcp lock for con %p\n", tcp_con); } #define MM_ACQUIRE_TOE_LOCK(_pdev) DbgMessage(pdev, INFORMl4, "Acquiring global toe lock\n"); #define MM_RELEASE_TOE_LOCK(_pdev) DbgMessage(pdev, INFORMl4, "Releasing global toe lock\n"); #define MM_ACQUIRE_TOE_GRQ_LOCK(_pdev, idx) DbgMessage(pdev, INFORMl4, "Acquiring global toe grq lock\n"); #define MM_RELEASE_TOE_GRQ_LOCK(_pdev, idx) DbgMessage(pdev, INFORMl4, "Releasing global toe grq lock\n"); #define MM_ACQUIRE_TOE_GRQ_LOCK_DPC(_pdev, idx) DbgMessage(pdev, INFORMl4, "Acquiring global toe grq lock\n"); #define MM_RELEASE_TOE_GRQ_LOCK_DPC(_pdev, idx) DbgMessage(pdev, INFORMl4, "Releasing global toe grq lock\n"); #elif defined (NDISMONO) /* * stubs for NDIS */ #define MM_INIT_TCP_LOCK_HANDLE() void mm_acquire_tcp_lock( lm_device_t *pdev, lm_tcp_con_t *tcp_con); void mm_release_tcp_lock( lm_device_t *pdev, lm_tcp_con_t *tcp_con); void MM_ACQUIRE_TOE_LOCK(lm_device_t *_pdev); void MM_RELEASE_TOE_LOCK(lm_device_t *_pdev); void MM_ACQUIRE_TOE_GRQ_LOCK(lm_device_t *_pdev, u8_t idx); void MM_RELEASE_TOE_GRQ_LOCK(lm_device_t *_pdev, u8_t idx); void MM_ACQUIRE_TOE_GRQ_LOCK_DPC(lm_device_t *_pdev, u8_t idx); void MM_RELEASE_TOE_GRQ_LOCK_DPC(lm_device_t *_pdev, u8_t idx); #endif /* NDISMONO */ u32_t mm_tcp_rx_peninsula_to_rq_copy_dmae( struct _lm_device_t * pdev, lm_tcp_state_t * tcp, lm_address_t gen_buf_phys, /* Memory buffer to copy from */ u32_t gen_buf_offset, lm_tcp_buffer_t * tcp_buf, /* TCP buffer to copy to */ u32_t tcp_buf_offset, u32_t nbytes ); void mm_tcp_comp_slow_path_request( struct _lm_device_t *pdev, lm_tcp_state_t *tcp, lm_tcp_slow_path_request_t *sp_request); /** Description: * - complete Tx and Rx application buffers towards the client * (with any kind of completion status) * - handle various pending ‘down stream’ tasks: post more application buffers, * post graceful disconnect request (Tx only) * Assumptions: * - in each given lm buffer with flag BUFFER_END the field ‘app_buf_xferred’ * was correctly set by the caller */ void mm_tcp_complete_bufs( struct _lm_device_t *pdev, lm_tcp_state_t *tcp, lm_tcp_con_t *tcp_con, /* Rx OR Tx connection */ s_list_t *buf_list, /* list of lm_tcp_buffer_t */ lm_status_t lm_status /* completion status for all given TBs */ ); /** * Description: * Returns TRUE if generic data OR preposted buffer is being indicated to the client * for the given connection and FALSE otherwise. * */ u8_t mm_tcp_indicating_bufs( lm_tcp_con_t * con ); /** Description: * - Completes graceful disconnect request towards client with the given status. * Assumptions: * - Assumptions described in client.disconnect_tcp_done() (see design doc) * - The connection's lock is already taken by the caller */ void mm_tcp_abort_bufs ( IN struct _lm_device_t * pdev, /* device handle */ IN lm_tcp_state_t * tcp, /* L4 state handle */ IN lm_tcp_con_t * con, /* connection handle */ IN lm_status_t status /* status to abort buffers with */ ); /** * Description: * Indicates toward the client reception of the remote FIN. * */ void mm_tcp_indicate_fin_received( IN struct _lm_device_t * pdev, /* device handle */ IN lm_tcp_state_t * tcp ); /** * Description: * Indicates toward the client reception of the remote RST. * */ void mm_tcp_indicate_rst_received( IN struct _lm_device_t * pdev, /* device handle */ IN lm_tcp_state_t * tcp ); /** * Description: * Indicates toward the client the completion of the FIN request. */ void mm_tcp_graceful_disconnect_done( IN struct _lm_device_t * pdev, /* device handle */ IN lm_tcp_state_t * tcp, /* L4 state handle */ IN lm_status_t status /* May be SUCCESS, ABORTED or UPLOAD IN PROGRESS */ ); /** Description * This function is called by lm when there are generic buffers that need indication * - indicate received data using generic buffers to the client (client.indicate_tcp_rx_buf) * - receive the buffered data by calling lm_get_buffered_data, and notify the lm of the * status by calling lm_buffer_data_indicated after returning from client.indicate_tcp_rx_buf */ void mm_tcp_rx_indicate_gen ( struct _lm_device_t * pdev, lm_tcp_state_t * tcp ); /** Description * Removes Generic Buffers from the generic buffer pool and passes them to the LM. * * Returns: * - The actual number of buffers returned (may be less than required_bufs in case there are not * enough buffers in the pool) */ u32_t mm_tcp_get_gen_bufs( struct _lm_device_t * pdev, d_list_t * gb_list, u32_t nbufs, u8_t sb_idx ); /** Description * Returns a list of generic buffers to the generic buffer pool * Assumption: * gen_buf is a list of generic buffers that ALL need to be returned to the pool */ #define MM_TCP_RGB_COMPENSATE_GRQS 0x01 #define MM_TCP_RGB_COLLECT_GEN_BUFS 0x02 #define MM_TCP_RGB_USE_ALL_GEN_BUFS 0x80 #define NON_EXISTENT_SB_IDX 0xFF void mm_tcp_return_gen_bufs( struct _lm_device_t * pdev, lm_tcp_gen_buf_t * gen_buf, u32_t flags, u8_t grq_idx ); void mm_tcp_return_list_of_gen_bufs( struct _lm_device_t * pdev, d_list_t * gen_buf_list, u32_t flags, u8_t grq_idx ); /** Description * Copys data from a memory buffer to the tcp buffer using client_if.copy_l4buffer * Assumptions: * - size of mem_buf is larger than nbytes * Returns: * - The actual number of bytes copied */ u32_t mm_tcp_copy_to_tcp_buf( struct _lm_device_t * pdev, lm_tcp_state_t * tcp_state, lm_tcp_buffer_t * tcp_buf, /* TCP buffer to copy to */ u8_t * mem_buf, /* Memory buffer to copy from */ u32_t tcp_buf_offset, u32_t nbytes ); void mm_tcp_indicate_retrieve_indication( struct _lm_device_t *pdev, lm_tcp_state_t *tcp_state, l4_upload_reason_t upload_reason); /** Description * This function is used for updating the required number of generic buffer pools * given an old and new mss and initial receive window. It is called as a result of an * update to one of these parameters */ void mm_tcp_update_required_gen_bufs( struct _lm_device_t * pdev, u32_t new_mss, u32_t old_mss, u32_t new_initial_rcv_wnd, u32_t old_initial_rcv_wnd); /** Description * completes a path upload request. It completes the request to the client * only if coplete_to_client is true... */ void mm_tcp_complete_path_upload_request( struct _lm_device_t * pdev, lm_path_state_t * path); /** Description * called when the upload neigh request is completed. This occurs when the last path dependent * of a path state that is in the upload_pending state has been upload completed * Assumptions * - caller holds the TOE LOCK */ void mm_tcp_complete_neigh_upload_request( struct _lm_device_t * pdev, lm_neigh_state_t * neigh ); /* Post an empty ramrod initiated by TOE. */ lm_status_t mm_tcp_post_empty_slow_path_request( struct _lm_device_t * pdev, lm_tcp_state_t * tcp, u32_t request_type); /* Delete the tcp state (initiated from lm) */ void mm_tcp_del_tcp_state( struct _lm_device_t * pdev, lm_tcp_state_t * tcp); #endif /* _MM_L4IF_H */