cxgbit_target.c | Explore in Territory

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

#include <linux/workqueue.h>
#include <linux/kthread.h>
#include <linux/sched/signal.h>

#include <asm/unaligned.h>
#include <net/tcp.h>
#include <target/target_core_base.h>
#include <target/target_core_fabric.h>
#include "cxgbit.h"

struct sge_opaque_hdr { … };

static const u8 cxgbit_digest_len[] = …;

#define TX_HDR_LEN …

static struct sk_buff *
__cxgbit_alloc_skb(struct cxgbit_sock *csk, u32 len, bool iso)
{ … }

static struct sk_buff *cxgbit_alloc_skb(struct cxgbit_sock *csk, u32 len)
{ … }

/*
 * cxgbit_is_ofld_imm - check whether a packet can be sent as immediate data
 * @skb: the packet
 *
 * Returns true if a packet can be sent as an offload WR with immediate
 * data.  We currently use the same limit as for Ethernet packets.
 */
static int cxgbit_is_ofld_imm(const struct sk_buff *skb)
{ … }

/*
 * cxgbit_sgl_len - calculates the size of an SGL of the given capacity
 * @n: the number of SGL entries
 * Calculates the number of flits needed for a scatter/gather list that
 * can hold the given number of entries.
 */
static inline unsigned int cxgbit_sgl_len(unsigned int n)
{ … }

/*
 * cxgbit_calc_tx_flits_ofld - calculate # of flits for an offload packet
 * @skb: the packet
 *
 * Returns the number of flits needed for the given offload packet.
 * These packets are already fully constructed and no additional headers
 * will be added.
 */
static unsigned int cxgbit_calc_tx_flits_ofld(const struct sk_buff *skb)
{ … }

#define CXGBIT_ISO_FSLICE …
#define CXGBIT_ISO_LSLICE …
static void
cxgbit_cpl_tx_data_iso(struct sk_buff *skb, struct cxgbit_iso_info *iso_info)
{ … }

static void
cxgbit_tx_data_wr(struct cxgbit_sock *csk, struct sk_buff *skb, u32 dlen,
		  u32 len, u32 credits, u32 compl)
{ … }

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

void cxgbit_push_tx_frames(struct cxgbit_sock *csk)
{ … }

static void cxgbit_unlock_sock(struct cxgbit_sock *csk)
{ … }

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

static int
cxgbit_map_skb(struct iscsit_cmd *cmd, struct sk_buff *skb, u32 data_offset,
	       u32 data_length)
{ … }

static int
cxgbit_tx_datain_iso(struct cxgbit_sock *csk, struct iscsit_cmd *cmd,
		     struct iscsi_datain_req *dr)
{ … }

static int
cxgbit_tx_datain(struct cxgbit_sock *csk, struct iscsit_cmd *cmd,
		 const struct iscsi_datain *datain)
{ … }

static int
cxgbit_xmit_datain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
		       struct iscsi_datain_req *dr,
		       const struct iscsi_datain *datain)
{ … }

static int
cxgbit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
			  const void *data_buf, u32 data_buf_len)
{ … }

int
cxgbit_xmit_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
		struct iscsi_datain_req *dr, const void *buf, u32 buf_len)
{ … }

int cxgbit_validate_params(struct iscsit_conn *conn)
{ … }

static int cxgbit_set_digest(struct cxgbit_sock *csk)
{ … }

static int cxgbit_set_iso_npdu(struct cxgbit_sock *csk)
{ … }

/*
 * cxgbit_seq_pdu_inorder()
 * @csk: pointer to cxgbit socket structure
 *
 * This function checks whether data sequence and data
 * pdu are in order.
 *
 * Return: returns -1 on error, 0 if data sequence and
 * data pdu are in order, 1 if data sequence or data pdu
 * is not in order.
 */
static int cxgbit_seq_pdu_inorder(struct cxgbit_sock *csk)
{ … }

static int cxgbit_set_params(struct iscsit_conn *conn)
{ … }

int
cxgbit_put_login_tx(struct iscsit_conn *conn, struct iscsi_login *login,
		    u32 length)
{ … }

static void
cxgbit_skb_copy_to_sg(struct sk_buff *skb, struct scatterlist *sg,
		      unsigned int nents, u32 skip)
{ … }

static struct iscsit_cmd *cxgbit_allocate_cmd(struct cxgbit_sock *csk)
{ … }

static int
cxgbit_handle_immediate_data(struct iscsit_cmd *cmd, struct iscsi_scsi_req *hdr,
			     u32 length)
{ … }

static int
cxgbit_get_immediate_data(struct iscsit_cmd *cmd, struct iscsi_scsi_req *hdr,
			  bool dump_payload)
{ … }

static int
cxgbit_handle_scsi_cmd(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
{ … }

static int cxgbit_handle_iscsi_dataout(struct cxgbit_sock *csk)
{ … }

static int cxgbit_handle_nop_out(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
{ … }

static int
cxgbit_handle_text_cmd(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
{ … }

static int cxgbit_target_rx_opcode(struct cxgbit_sock *csk)
{ … }

static int cxgbit_rx_opcode(struct cxgbit_sock *csk)
{ … }

static int cxgbit_rx_login_pdu(struct cxgbit_sock *csk)
{ … }

static int
cxgbit_process_iscsi_pdu(struct cxgbit_sock *csk, struct sk_buff *skb, int idx)
{ … }

static void cxgbit_lro_skb_dump(struct sk_buff *skb)
{ … }

static void cxgbit_lro_hskb_reset(struct cxgbit_sock *csk)
{ … }

static void
cxgbit_lro_skb_merge(struct cxgbit_sock *csk, struct sk_buff *skb, u8 pdu_idx)
{ … }

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

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

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

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

static bool cxgbit_rxq_len(struct cxgbit_sock *csk, struct sk_buff_head *rxq)
{ … }

static int cxgbit_wait_rxq(struct cxgbit_sock *csk)
{ … }

int cxgbit_get_login_rx(struct iscsit_conn *conn, struct iscsi_login *login)
{ … }

void cxgbit_get_rx_pdu(struct iscsit_conn *conn)
{ … }
linux/drivers/target/iscsi/cxgbit/cxgbit_target.c
