[ceph.git] / ceph / src / spdk / dpdk / drivers / bus / vmbus / private.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2018, Microsoft Corporation.
 * All Rights Reserved.
 */

#ifndef _VMBUS_PRIVATE_H_
#define _VMBUS_PRIVATE_H_

#include <stdbool.h>
#include <sys/uio.h>
#include <rte_log.h>
#include <rte_vmbus_reg.h>
#include <rte_bus_vmbus.h>

#ifndef PAGE_SIZE
#define PAGE_SIZE	4096
#endif

extern struct rte_vmbus_bus rte_vmbus_bus;

extern int vmbus_logtype_bus;
#define VMBUS_LOG(level, fmt, args...) \
	rte_log(RTE_LOG_ ## level, vmbus_logtype_bus, "%s(): " fmt "\n", \
		__func__, ##args)

struct vmbus_br {
	struct vmbus_bufring *vbr;
	uint32_t	dsize;
	uint32_t	windex; /* next available location */
};

#define UIO_NAME_MAX 64

struct vmbus_map {
	void *addr;	/* user mmap of resource */
	uint64_t size;	/* length */
};

/*
 * For multi-process we need to reproduce all vmbus mappings in secondary
 * processes, so save them in a tailq.
 */
struct mapped_vmbus_resource {
	TAILQ_ENTRY(mapped_vmbus_resource) next;

	rte_uuid_t id;
	int nb_maps;
	struct vmbus_channel *primary;
	struct vmbus_map maps[VMBUS_MAX_RESOURCE];
	char path[PATH_MAX];
};

TAILQ_HEAD(mapped_vmbus_res_list, mapped_vmbus_resource);

#define HV_MON_TRIG_LEN	32
#define HV_MON_TRIG_MAX	4

struct vmbus_channel {
	STAILQ_HEAD(, vmbus_channel) subchannel_list;
	STAILQ_ENTRY(vmbus_channel) next;
	const struct rte_vmbus_device *device;

	struct vmbus_br rxbr;
	struct vmbus_br txbr;

	uint16_t relid;
	uint16_t subchannel_id;
	uint8_t monitor_id;
};

#define VMBUS_MAX_CHANNELS	64

struct rte_devargs *
vmbus_devargs_lookup(struct rte_vmbus_device *dev);

int vmbus_chan_create(const struct rte_vmbus_device *device,
		      uint16_t relid, uint16_t subid, uint8_t monitor_id,
		      struct vmbus_channel **new_chan);

void vmbus_add_device(struct rte_vmbus_device *vmbus_dev);
void vmbus_insert_device(struct rte_vmbus_device *exist_vmbus_dev,
			 struct rte_vmbus_device *new_vmbus_dev);
void vmbus_remove_device(struct rte_vmbus_device *vmbus_device);

void vmbus_uio_irq_control(struct rte_vmbus_device *dev, int32_t onoff);
int vmbus_uio_irq_read(struct rte_vmbus_device *dev);

int vmbus_uio_map_resource(struct rte_vmbus_device *dev);
void vmbus_uio_unmap_resource(struct rte_vmbus_device *dev);

int vmbus_uio_alloc_resource(struct rte_vmbus_device *dev,
		struct mapped_vmbus_resource **uio_res);
void vmbus_uio_free_resource(struct rte_vmbus_device *dev,
		struct mapped_vmbus_resource *uio_res);

struct mapped_vmbus_resource *
vmbus_uio_find_resource(const struct rte_vmbus_device *dev);
int vmbus_uio_map_resource_by_index(struct rte_vmbus_device *dev, int res_idx,
				    struct mapped_vmbus_resource *uio_res,
				    int flags);

void *vmbus_map_resource(void *requested_addr, int fd, off_t offset,
		size_t size, int additional_flags);
void vmbus_unmap_resource(void *requested_addr, size_t size);

bool vmbus_uio_subchannels_supported(const struct rte_vmbus_device *dev,
				     const struct vmbus_channel *chan);
int vmbus_uio_get_subchan(struct vmbus_channel *primary,
			  struct vmbus_channel **subchan);
int vmbus_uio_map_rings(struct vmbus_channel *chan);
int vmbus_uio_map_secondary_subchan(const struct rte_vmbus_device *dev,
				    const struct vmbus_channel *chan);

void vmbus_br_setup(struct vmbus_br *br, void *buf, unsigned int blen);

/* Amount of space available for write */
static inline uint32_t
vmbus_br_availwrite(const struct vmbus_br *br, uint32_t windex)
{
	uint32_t rindex = br->vbr->rindex;

	if (windex >= rindex)
		return br->dsize - (windex - rindex);
	else
		return rindex - windex;
}

static inline uint32_t
vmbus_br_availread(const struct vmbus_br *br)
{
	return br->dsize - vmbus_br_availwrite(br, br->vbr->windex);
}

int vmbus_txbr_write(struct vmbus_br *tbr, const struct iovec iov[], int iovlen,
		     bool *need_sig);

int vmbus_rxbr_peek(const struct vmbus_br *rbr, void *data, size_t dlen);

int vmbus_rxbr_read(struct vmbus_br *rbr, void *data, size_t dlen, size_t hlen);

#endif /* _VMBUS_PRIVATE_H_ */
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright (c) 2018, Microsoft Corporation.
	3	* All Rights Reserved.
	4	*/
	5
	6	#ifndef _VMBUS_PRIVATE_H_
	7	#define _VMBUS_PRIVATE_H_
	8
	9	#include <stdbool.h>
	10	#include <sys/uio.h>
	11	#include <rte_log.h>
	12	#include <rte_vmbus_reg.h>
9f95a23c	13	#include <rte_bus_vmbus.h>
11fdf7f2 TL	14
	15	#ifndef PAGE_SIZE
	16	#define PAGE_SIZE 4096
	17	#endif
	18
9f95a23c TL	19	extern struct rte_vmbus_bus rte_vmbus_bus;
9f95a23c TL	20
11fdf7f2 TL	21	extern int vmbus_logtype_bus;
	22	#define VMBUS_LOG(level, fmt, args...) \
	23	rte_log(RTE_LOG_ ## level, vmbus_logtype_bus, "%s(): " fmt "\n", \
	24	__func__, ##args)
	25
	26	struct vmbus_br {
	27	struct vmbus_bufring *vbr;
	28	uint32_t dsize;
	29	uint32_t windex; /* next available location */
	30	};
	31
	32	#define UIO_NAME_MAX 64
	33
	34	struct vmbus_map {
	35	void addr; / user mmap of resource */
	36	uint64_t size; /* length */
	37	};
	38
	39	/*
	40	* For multi-process we need to reproduce all vmbus mappings in secondary
	41	* processes, so save them in a tailq.
	42	*/
	43	struct mapped_vmbus_resource {
	44	TAILQ_ENTRY(mapped_vmbus_resource) next;
	45
	46	rte_uuid_t id;
	47	int nb_maps;
9f95a23c	48	struct vmbus_channel *primary;
11fdf7f2 TL	49	struct vmbus_map maps[VMBUS_MAX_RESOURCE];
	50	char path[PATH_MAX];
	51	};
	52
	53	TAILQ_HEAD(mapped_vmbus_res_list, mapped_vmbus_resource);
	54
	55	#define HV_MON_TRIG_LEN 32
	56	#define HV_MON_TRIG_MAX 4
	57
	58	struct vmbus_channel {
	59	STAILQ_HEAD(, vmbus_channel) subchannel_list;
	60	STAILQ_ENTRY(vmbus_channel) next;
	61	const struct rte_vmbus_device *device;
	62
	63	struct vmbus_br rxbr;
	64	struct vmbus_br txbr;
	65
	66	uint16_t relid;
	67	uint16_t subchannel_id;
	68	uint8_t monitor_id;
	69	};
	70
	71	#define VMBUS_MAX_CHANNELS 64
	72
9f95a23c TL	73	struct rte_devargs *
	74	vmbus_devargs_lookup(struct rte_vmbus_device *dev);
	75
11fdf7f2 TL	76	int vmbus_chan_create(const struct rte_vmbus_device *device,
	77	uint16_t relid, uint16_t subid, uint8_t monitor_id,
	78	struct vmbus_channel **new_chan);
	79
	80	void vmbus_add_device(struct rte_vmbus_device *vmbus_dev);
	81	void vmbus_insert_device(struct rte_vmbus_device *exist_vmbus_dev,
	82	struct rte_vmbus_device *new_vmbus_dev);
	83	void vmbus_remove_device(struct rte_vmbus_device *vmbus_device);
	84
	85	void vmbus_uio_irq_control(struct rte_vmbus_device *dev, int32_t onoff);
	86	int vmbus_uio_irq_read(struct rte_vmbus_device *dev);
	87
	88	int vmbus_uio_map_resource(struct rte_vmbus_device *dev);
	89	void vmbus_uio_unmap_resource(struct rte_vmbus_device *dev);
	90
	91	int vmbus_uio_alloc_resource(struct rte_vmbus_device *dev,
	92	struct mapped_vmbus_resource **uio_res);
	93	void vmbus_uio_free_resource(struct rte_vmbus_device *dev,
	94	struct mapped_vmbus_resource *uio_res);
	95
	96	struct mapped_vmbus_resource *
	97	vmbus_uio_find_resource(const struct rte_vmbus_device *dev);
	98	int vmbus_uio_map_resource_by_index(struct rte_vmbus_device *dev, int res_idx,
	99	struct mapped_vmbus_resource *uio_res,
	100	int flags);
	101
	102	void vmbus_map_resource(void requested_addr, int fd, off_t offset,
	103	size_t size, int additional_flags);
	104	void vmbus_unmap_resource(void *requested_addr, size_t size);
	105
	106	bool vmbus_uio_subchannels_supported(const struct rte_vmbus_device *dev,
	107	const struct vmbus_channel *chan);
	108	int vmbus_uio_get_subchan(struct vmbus_channel *primary,
	109	struct vmbus_channel **subchan);
	110	int vmbus_uio_map_rings(struct vmbus_channel *chan);
9f95a23c TL	111	int vmbus_uio_map_secondary_subchan(const struct rte_vmbus_device *dev,
9f95a23c TL	112	const struct vmbus_channel *chan);
11fdf7f2 TL	113
	114	void vmbus_br_setup(struct vmbus_br br, void buf, unsigned int blen);
	115
	116	/* Amount of space available for write */
	117	static inline uint32_t
	118	vmbus_br_availwrite(const struct vmbus_br *br, uint32_t windex)
	119	{
	120	uint32_t rindex = br->vbr->rindex;
	121
	122	if (windex >= rindex)
	123	return br->dsize - (windex - rindex);
	124	else
	125	return rindex - windex;
	126	}
	127
	128	static inline uint32_t
	129	vmbus_br_availread(const struct vmbus_br *br)
	130	{
	131	return br->dsize - vmbus_br_availwrite(br, br->vbr->windex);
	132	}
	133
	134	int vmbus_txbr_write(struct vmbus_br *tbr, const struct iovec iov[], int iovlen,
	135	bool *need_sig);
	136
	137	int vmbus_rxbr_peek(const struct vmbus_br rbr, void data, size_t dlen);
	138
	139	int vmbus_rxbr_read(struct vmbus_br rbr, void data, size_t dlen, size_t hlen);
	140
	141	#endif /* _VMBUS_PRIVATE_H_ */