path: root/fs/smb/smbdirect/socket.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 *   Copyright (c) 2025 Stefan Metzmacher
 */

#ifndef __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__
#define __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__

#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/kref.h>
#include <linux/mempool.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/completion.h>
#include <rdma/rw.h>

enum smbdirect_socket_status {
	SMBDIRECT_SOCKET_CREATED,
	SMBDIRECT_SOCKET_LISTENING,
	SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED,
	SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING,
	SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED,
	SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED,
	SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING,
	SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED,
	SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED,
	SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING,
	SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED,
	SMBDIRECT_SOCKET_NEGOTIATE_NEEDED,
	SMBDIRECT_SOCKET_NEGOTIATE_RUNNING,
	SMBDIRECT_SOCKET_NEGOTIATE_FAILED,
	SMBDIRECT_SOCKET_CONNECTED,
	SMBDIRECT_SOCKET_ERROR,
	SMBDIRECT_SOCKET_DISCONNECTING,
	SMBDIRECT_SOCKET_DISCONNECTED,
	SMBDIRECT_SOCKET_DESTROYED
};

static __always_inline
const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
{
	switch (status) {
	case SMBDIRECT_SOCKET_CREATED:
		return "CREATED";
	case SMBDIRECT_SOCKET_LISTENING:
		return "LISTENING";
	case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
		return "RESOLVE_ADDR_NEEDED";
	case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
		return "RESOLVE_ADDR_RUNNING";
	case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
		return "RESOLVE_ADDR_FAILED";
	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
		return "RESOLVE_ROUTE_NEEDED";
	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
		return "RESOLVE_ROUTE_RUNNING";
	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
		return "RESOLVE_ROUTE_FAILED";
	case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
		return "RDMA_CONNECT_NEEDED";
	case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
		return "RDMA_CONNECT_RUNNING";
	case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
		return "RDMA_CONNECT_FAILED";
	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
		return "NEGOTIATE_NEEDED";
	case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
		return "NEGOTIATE_RUNNING";
	case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
		return "NEGOTIATE_FAILED";
	case SMBDIRECT_SOCKET_CONNECTED:
		return "CONNECTED";
	case SMBDIRECT_SOCKET_ERROR:
		return "ERROR";
	case SMBDIRECT_SOCKET_DISCONNECTING:
		return "DISCONNECTING";
	case SMBDIRECT_SOCKET_DISCONNECTED:
		return "DISCONNECTED";
	case SMBDIRECT_SOCKET_DESTROYED:
		return "DESTROYED";
	}

	return "<unknown>";
}

/*
 * This can be used with %1pe to print errors as strings or '0'
 * And it avoids warnings like: warn: passing zero to 'ERR_PTR'
 * from smatch -p=kernel --pedantic
 */
static __always_inline
const void * __must_check SMBDIRECT_DEBUG_ERR_PTR(long error)
{
	if (error == 0)
		return NULL;
	return ERR_PTR(error);
}

enum smbdirect_keepalive_status {
	SMBDIRECT_KEEPALIVE_NONE,
	SMBDIRECT_KEEPALIVE_PENDING,
	SMBDIRECT_KEEPALIVE_SENT
};

struct smbdirect_socket {
	enum smbdirect_socket_status status;
	wait_queue_head_t status_wait;
	int first_error;

	/*
	 * This points to the workqueues to
	 * be used for this socket.
	 */
	struct {
		struct workqueue_struct *accept;
		struct workqueue_struct *connect;
		struct workqueue_struct *idle;
		struct workqueue_struct *refill;
		struct workqueue_struct *immediate;
		struct workqueue_struct *cleanup;
	} workqueues;

	struct work_struct disconnect_work;

	/*
	 * The reference counts.
	 */
	struct {
		/*
		 * This holds the references by the
		 * frontend, typically the smb layer.
		 *
		 * It is typically 1 and a disconnect
		 * will happen if it reaches 0.
		 */
		struct kref disconnect;

		/*
		 * This holds the reference by the
		 * backend, the code that manages
		 * the lifetime of the whole
		 * struct smbdirect_socket,
		 * if this reaches 0 it can will
		 * be freed.
		 *
		 * Can be REFCOUNT_MAX is part
		 * of another structure.
		 *
		 * This is equal or higher than
		 * the disconnect refcount.
		 */
		struct kref destroy;
	} refs;

	/* RDMA related */
	struct {
		struct rdma_cm_id *cm_id;
		/*
		 * The expected event in our current
		 * cm_id->event_handler, all other events
		 * are treated as an error.
		 */
		enum rdma_cm_event_type expected_event;
		/*
		 * This is for iWarp MPA v1
		 */
		bool legacy_iwarp;
	} rdma;

	/* IB verbs related */
	struct {
		struct ib_pd *pd;
		enum ib_poll_context poll_ctx;
		struct ib_cq *send_cq;
		struct ib_cq *recv_cq;

		/*
		 * shortcuts for rdma.cm_id->{qp,device};
		 */
		struct ib_qp *qp;
		struct ib_device *dev;
	} ib;

	struct smbdirect_socket_parameters parameters;

	/*
	 * The state for connect/negotiation
	 */
	struct {
		spinlock_t lock;
		struct work_struct work;
	} connect;

	/*
	 * The state for keepalive and timeout handling
	 */
	struct {
		enum smbdirect_keepalive_status keepalive;
		struct work_struct immediate_work;
		struct delayed_work timer_work;
	} idle;

	/*
	 * The state for listen sockets
	 */
	struct {
		spinlock_t lock;
		struct list_head pending;
		struct list_head ready;
		wait_queue_head_t wait_queue;
		/*
		 * This starts as -1 and a value != -1
		 * means this socket was in LISTENING state
		 * before. Note the valid backlog can
		 * only be > 0.
		 */
		int backlog;
	} listen;

	/*
	 * The state for sockets waiting
	 * for accept, either still waiting
	 * for the negotiation to finish
	 * or already ready with a usable
	 * connection.
	 */
	struct {
		struct smbdirect_socket *listener;
		struct list_head list;
	} accept;

	/*
	 * The state for posted send buffers
	 */
	struct {
		/*
		 * Memory pools for preallocating
		 * smbdirect_send_io buffers
		 */
		struct {
			struct kmem_cache *cache;
			mempool_t *pool;
			gfp_t gfp_mask;
		} mem;

		/*
		 * This is a coordination for smbdirect_send_batch.
		 *
		 * There's only one possible credit, which means
		 * only one instance is running at a time.
		 */
		struct {
			atomic_t count;
			wait_queue_head_t wait_queue;
		} bcredits;

		/*
		 * The local credit state for ib_post_send()
		 */
		struct {
			atomic_t count;
			wait_queue_head_t wait_queue;
		} lcredits;

		/*
		 * The remote credit state for the send side
		 */
		struct {
			atomic_t count;
			wait_queue_head_t wait_queue;
		} credits;

		/*
		 * The state about posted/pending sends
		 */
		struct {
			atomic_t count;
			/*
			 * woken when count reached zero
			 */
			wait_queue_head_t zero_wait_queue;
		} pending;
	} send_io;

	/*
	 * The state for posted receive buffers