linux/drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_main.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2018 Chelsio Communications, Inc.
 *
 * Written by: Atul Gupta ([email protected])
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/socket.h>
#include <linux/hash.h>
#include <linux/in.h>
#include <linux/net.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <net/ipv6.h>
#include <net/transp_v6.h>
#include <net/tcp.h>
#include <net/tls.h>

#include "chtls.h"
#include "chtls_cm.h"

#define DRV_NAME …

/*
 * chtls device management
 * maintains a list of the chtls devices
 */
static LIST_HEAD(cdev_list);
static DEFINE_MUTEX(cdev_mutex);

static DEFINE_MUTEX(notify_mutex);
static RAW_NOTIFIER_HEAD(listen_notify_list);
static struct proto chtls_cpl_prot, chtls_cpl_protv6;
struct request_sock_ops chtls_rsk_ops, chtls_rsk_opsv6;
static uint send_page_order = …;

static void register_listen_notifier(struct notifier_block *nb)
{ … }

static void unregister_listen_notifier(struct notifier_block *nb)
{ … }

static int listen_notify_handler(struct notifier_block *this,
				 unsigned long event, void *data)
{ … }

static struct notifier_block listen_notifier = …;

static int listen_backlog_rcv(struct sock *sk, struct sk_buff *skb)
{ … }

static int chtls_start_listen(struct chtls_dev *cdev, struct sock *sk)
{ … }

static void chtls_stop_listen(struct chtls_dev *cdev, struct sock *sk)
{ … }

static int chtls_inline_feature(struct tls_toe_device *dev)
{ … }

static int chtls_create_hash(struct tls_toe_device *dev, struct sock *sk)
{ … }

static void chtls_destroy_hash(struct tls_toe_device *dev, struct sock *sk)
{ … }

static void chtls_free_uld(struct chtls_dev *cdev)
{ … }

static inline void chtls_dev_release(struct kref *kref)
{ … }

static void chtls_register_dev(struct chtls_dev *cdev)
{ … }

static void process_deferq(struct work_struct *task_param)
{ … }

static int chtls_get_skb(struct chtls_dev *cdev)
{ … }

static void *chtls_uld_add(const struct cxgb4_lld_info *info)
{ … }

static void chtls_free_all_uld(void)
{ … }

static int chtls_uld_state_change(void *handle, enum cxgb4_state new_state)
{ … }

static struct sk_buff *copy_gl_to_skb_pkt(const struct pkt_gl *gl,
					  const __be64 *rsp,
					  u32 pktshift)
{ … }

static int chtls_recv_packet(struct chtls_dev *cdev,
			     const struct pkt_gl *gl, const __be64 *rsp)
{ … }

static int chtls_recv_rsp(struct chtls_dev *cdev, const __be64 *rsp)
{ … }

static void chtls_recv(struct chtls_dev *cdev,
		       struct sk_buff **skbs, const __be64 *rsp)
{ … }

static int chtls_uld_rx_handler(void *handle, const __be64 *rsp,
				const struct pkt_gl *gl)
{ … }

static int do_chtls_getsockopt(struct sock *sk, char __user *optval,
			       int __user *optlen)
{ … }

static int chtls_getsockopt(struct sock *sk, int level, int optname,
			    char __user *optval, int __user *optlen)
{ … }

static int do_chtls_setsockopt(struct sock *sk, int optname,
			       sockptr_t optval, unsigned int optlen)
{ … }

static int chtls_setsockopt(struct sock *sk, int level, int optname,
			    sockptr_t optval, unsigned int optlen)
{ … }

static struct cxgb4_uld_info chtls_uld_info = …;

void chtls_install_cpl_ops(struct sock *sk)
{ … }

static void __init chtls_init_ulp_ops(void)
{ … }

static int __init chtls_register(void)
{ … }

static void __exit chtls_unregister(void)
{ … }

module_init(…) …;
module_exit(chtls_unregister);

MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;
MODULE_AUTHOR(…) …;
MODULE_VERSION(…);