linux/drivers/target/iscsi/cxgbit/cxgbit_cm.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2016 Chelsio Communications, Inc.
 */

#include <linux/module.h>
#include <linux/list.h>
#include <linux/workqueue.h>
#include <linux/skbuff.h>
#include <linux/timer.h>
#include <linux/notifier.h>
#include <linux/inetdevice.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/if_vlan.h>

#include <net/neighbour.h>
#include <net/netevent.h>
#include <net/route.h>
#include <net/tcp.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>

#include <libcxgb_cm.h>
#include "cxgbit.h"
#include "clip_tbl.h"

static void cxgbit_init_wr_wait(struct cxgbit_wr_wait *wr_waitp)
{}

static void
cxgbit_wake_up(struct cxgbit_wr_wait *wr_waitp, const char *func, u8 ret)
{}

static int
cxgbit_wait_for_reply(struct cxgbit_device *cdev,
		      struct cxgbit_wr_wait *wr_waitp, u32 tid, u32 timeout,
		      const char *func)
{}

static int cxgbit_np_hashfn(const struct cxgbit_np *cnp)
{}

static struct np_info *
cxgbit_np_hash_add(struct cxgbit_device *cdev, struct cxgbit_np *cnp,
		   unsigned int stid)
{}

static int
cxgbit_np_hash_find(struct cxgbit_device *cdev, struct cxgbit_np *cnp)
{}

static int cxgbit_np_hash_del(struct cxgbit_device *cdev, struct cxgbit_np *cnp)
{}

void _cxgbit_free_cnp(struct kref *kref)
{}

static int
cxgbit_create_server6(struct cxgbit_device *cdev, unsigned int stid,
		      struct cxgbit_np *cnp)
{}

static int
cxgbit_create_server4(struct cxgbit_device *cdev, unsigned int stid,
		      struct cxgbit_np *cnp)
{}

struct cxgbit_device *cxgbit_find_device(struct net_device *ndev, u8 *port_id)
{}

static struct net_device *cxgbit_get_real_dev(struct net_device *ndev)
{}

static struct net_device *cxgbit_ipv4_netdev(__be32 saddr)
{}

static struct net_device *cxgbit_ipv6_netdev(struct in6_addr *addr6)
{}

static struct cxgbit_device *cxgbit_find_np_cdev(struct cxgbit_np *cnp)
{}

static bool cxgbit_inaddr_any(struct cxgbit_np *cnp)
{}

static int
__cxgbit_setup_cdev_np(struct cxgbit_device *cdev, struct cxgbit_np *cnp)
{}

static int cxgbit_setup_cdev_np(struct cxgbit_np *cnp)
{}

static int cxgbit_setup_all_np(struct cxgbit_np *cnp)
{}

int cxgbit_setup_np(struct iscsi_np *np, struct sockaddr_storage *ksockaddr)
{}

static void
cxgbit_set_conn_info(struct iscsi_np *np, struct iscsit_conn *conn,
		     struct cxgbit_sock *csk)
{}

int cxgbit_accept_np(struct iscsi_np *np, struct iscsit_conn *conn)
{}

static int
__cxgbit_free_cdev_np(struct cxgbit_device *cdev, struct cxgbit_np *cnp)
{}

static void cxgbit_free_all_np(struct cxgbit_np *cnp)
{}

static void cxgbit_free_cdev_np(struct cxgbit_np *cnp)
{}

static void __cxgbit_free_conn(struct cxgbit_sock *csk);

void cxgbit_free_np(struct iscsi_np *np)
{}

static void cxgbit_send_halfclose(struct cxgbit_sock *csk)
{}

static void cxgbit_arp_failure_discard(void *handle, struct sk_buff *skb)
{}

static void cxgbit_abort_arp_failure(void *handle, struct sk_buff *skb)
{}

static int cxgbit_send_abort_req(struct cxgbit_sock *csk)
{}

static void
__cxgbit_abort_conn(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

void cxgbit_abort_conn(struct cxgbit_sock *csk)
{}

static void __cxgbit_free_conn(struct cxgbit_sock *csk)
{}

void cxgbit_free_conn(struct iscsit_conn *conn)
{}

static void cxgbit_set_emss(struct cxgbit_sock *csk, u16 opt)
{}

static void cxgbit_free_skb(struct cxgbit_sock *csk)
{}

void _cxgbit_free_csk(struct kref *kref)
{}

static void cxgbit_set_tcp_window(struct cxgbit_sock *csk, struct port_info *pi)
{}

#ifdef CONFIG_CHELSIO_T4_DCB
static u8 cxgbit_get_iscsi_dcb_state(struct net_device *ndev)
{}

static int cxgbit_select_priority(int pri_mask)
{}

static u8 cxgbit_get_iscsi_dcb_priority(struct net_device *ndev, u16 local_port)
{}
#endif

static int
cxgbit_offload_init(struct cxgbit_sock *csk, int iptype, __u8 *peer_ip,
		    u16 local_port, struct dst_entry *dst,
		    struct cxgbit_device *cdev)
{}

int cxgbit_ofld_send(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static void cxgbit_release_tid(struct cxgbit_device *cdev, u32 tid)
{}

int
cxgbit_l2t_send(struct cxgbit_device *cdev, struct sk_buff *skb,
		struct l2t_entry *l2e)
{}

static void cxgbit_send_rx_credits(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

/*
 * CPL connection rx data ack: host ->
 * Send RX credits through an RX_DATA_ACK CPL message.
 * Returns the number of credits sent.
 */
int cxgbit_rx_data_ack(struct cxgbit_sock *csk)
{}

#define FLOWC_WR_NPARAMS_MIN
#define FLOWC_WR_NPARAMS_MAX
static int cxgbit_alloc_csk_skb(struct cxgbit_sock *csk)
{}

static void
cxgbit_pass_accept_rpl(struct cxgbit_sock *csk, struct cpl_pass_accept_req *req)
{}

static void
cxgbit_pass_accept_req(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static u32
cxgbit_tx_flowc_wr_credits(struct cxgbit_sock *csk, u32 *nparamsp,
			   u32 *flowclenp)
{}

u32 cxgbit_send_tx_flowc_wr(struct cxgbit_sock *csk)
{}

static int
cxgbit_send_tcb_skb(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

int cxgbit_setup_conn_digest(struct cxgbit_sock *csk)
{}

int cxgbit_setup_conn_pgidx(struct cxgbit_sock *csk, u32 pg_idx)
{}

static void
cxgbit_pass_open_rpl(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static void
cxgbit_close_listsrv_rpl(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static void
cxgbit_pass_establish(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static void cxgbit_queue_rx_skb(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_peer_close(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_close_con_rpl(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_abort_req_rss(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_abort_rpl_rss(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static bool cxgbit_credit_err(const struct cxgbit_sock *csk)
{}

static void cxgbit_fw4_ack(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_set_tcb_rpl(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static void cxgbit_rx_data(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

static void
__cxgbit_process_rx_cpl(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_process_rx_cpl(struct cxgbit_sock *csk, struct sk_buff *skb)
{}

static void cxgbit_rx_cpl(struct cxgbit_device *cdev, struct sk_buff *skb)
{}

cxgbit_cplhandler_func cxgbit_cplhandlers[NUM_CPL_CMDS] =;