Commit 895ad892 authored by Jim Harris's avatar Jim Harris Committed by Tomasz Zawadzki
Browse files

ioat: remove whitelist/blacklist functionality 



This can be done via explicit options on the
application command line instead.

This has the added benefit of removing a usage of
whitelist/blacklist which we are working to
remove from the SPDK repository.

Signed-off-by: default avatarJim Harris <james.r.harris@intel.com>
Change-Id: I5739e281f1c29fc8a5d175f5bbc916cd7d926fe4
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/5274


Community-CI: Broadcom CI
Community-CI: Mellanox Build Bot
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
parent 6b6ae3a2

CHANGELOG.md

+6 −0
Original line number Diff line number Diff line
@@ -24,6 +24,12 @@ listening on portals for a portal group until all associated target nodes are cr 
at startup, otherwise some iSCSI initiators may fail to re-login when SPDK iSCSI

target application restarts.



## ioat



The PCI BDF whitelist option has been removed from the ioat_scan_accel_engine RPC.

ioat PCI functions can still be allowed or denied using SPDK application command

line options.



## v20.10:



### accel

mk/spdk.lib_deps.mk

+1 −1
Original line number Diff line number Diff line
@@ -107,7 +107,7 @@ DEPDIRS-blobfs_bdev += event 
endif



# module/accel

DEPDIRS-accel_ioat := log ioat thread $(JSON_LIBS) accel

DEPDIRS-accel_ioat := log ioat thread jsonrpc rpc accel

DEPDIRS-accel_idxd := log idxd thread $(JSON_LIBS) accel



# module/env_dpdk

module/accel/ioat/accel_engine_ioat.c

+1 −67
Original line number Diff line number Diff line
@@ -46,13 +46,6 @@ 
static bool g_ioat_enable = false;

static bool g_ioat_initialized = false;



struct ioat_probe_ctx {

	int num_whitelist_devices;

	struct spdk_pci_addr whitelist[IOAT_MAX_CHANNELS];

};



static struct ioat_probe_ctx g_probe_ctx;



struct ioat_device {

	struct spdk_ioat_chan *ioat;

	bool is_allocated;
@@ -76,21 +69,6 @@ struct ioat_io_channel { 
	struct spdk_poller		*poller;

};



static int

ioat_find_dev_by_whitelist_bdf(const struct spdk_pci_addr *pci_addr,

			       const struct spdk_pci_addr *whitelist,

			       int num_whitelist_devices)

{

	int i;



	for (i = 0; i < num_whitelist_devices; i++) {

		if (spdk_pci_addr_compare(pci_addr, &whitelist[i]) == 0) {

			return 1;

		}

	}

	return 0;

}



static struct ioat_device *

ioat_allocate_device(void)

{
@@ -242,7 +220,6 @@ ioat_get_io_channel(void) 
static bool

probe_cb(void *cb_ctx, struct spdk_pci_device *pci_dev)

{

	struct ioat_probe_ctx *ctx = cb_ctx;

	struct spdk_pci_addr pci_addr = spdk_pci_device_get_addr(pci_dev);

	struct pci_device *pdev;
@@ -262,11 +239,6 @@ probe_cb(void *cb_ctx, struct spdk_pci_device *pci_dev) 
	pdev->pci_dev = pci_dev;

	TAILQ_INSERT_TAIL(&g_pci_devices, pdev, tailq);



	if (ctx->num_whitelist_devices > 0 &&

	    !ioat_find_dev_by_whitelist_bdf(&pci_addr, ctx->whitelist, ctx->num_whitelist_devices)) {

		return false;

	}



	/* Claim the device in case conflict with other process */

	if (spdk_pci_device_claim(pci_dev) < 0) {

		return false;
@@ -296,44 +268,6 @@ accel_engine_ioat_enable_probe(void) 
	g_ioat_enable = true;

}



static int

accel_engine_ioat_add_whitelist_device(const char *pci_bdf)

{

	if (pci_bdf == NULL) {

		return -1;

	}



	if (g_probe_ctx.num_whitelist_devices >= IOAT_MAX_CHANNELS) {

		SPDK_ERRLOG("Ioat whitelist is full (max size is %d)\n",

			    IOAT_MAX_CHANNELS);

		return -1;

	}



	if (spdk_pci_addr_parse(&g_probe_ctx.whitelist[g_probe_ctx.num_whitelist_devices],

				pci_bdf) < 0) {

		SPDK_ERRLOG("Invalid address %s\n", pci_bdf);

		return -1;

	}



	g_probe_ctx.num_whitelist_devices++;



	return 0;

}



int

accel_engine_ioat_add_whitelist_devices(const char *pci_bdfs[], size_t num_pci_bdfs)

{

	size_t i;



	for (i = 0; i < num_pci_bdfs; i++) {

		if (accel_engine_ioat_add_whitelist_device(pci_bdfs[i]) < 0) {

			return -1;

		}

	}



	return 0;

}



static int

accel_engine_ioat_init(void)

{
@@ -341,7 +275,7 @@ accel_engine_ioat_init(void) 
		return 0;

	}



	if (spdk_ioat_probe(&g_probe_ctx, probe_cb, attach_cb) != 0) {

	if (spdk_ioat_probe(NULL, probe_cb, attach_cb) != 0) {

		SPDK_ERRLOG("spdk_ioat_probe() failed\n");

		return -1;

	}

module/accel/ioat/accel_engine_ioat.h

+0 −1
Original line number Diff line number Diff line
@@ -38,7 +38,6 @@ 


#define IOAT_MAX_CHANNELS	64



int accel_engine_ioat_add_whitelist_devices(const char *pci_bdfs[], size_t num_pci_bdfs);

void accel_engine_ioat_enable_probe(void);



#endif /* SPDK_ACCEL_ENGINE_IOAT_H */

module/accel/ioat/accel_engine_ioat_rpc.c

+3 −60
Original line number Diff line number Diff line
@@ -37,73 +37,16 @@ 
#include "spdk/util.h"

#include "spdk/event.h"



struct rpc_pci_whitelist {

	size_t num_bdfs;

	char *bdfs[IOAT_MAX_CHANNELS];

};



static int

decode_rpc_pci_whitelist(const struct spdk_json_val *val, void *out)

{

	struct rpc_pci_whitelist *pci_whitelist = out;



	return spdk_json_decode_array(val, spdk_json_decode_string, pci_whitelist->bdfs,

				      IOAT_MAX_CHANNELS, &pci_whitelist->num_bdfs, sizeof(char *));

}



static void

free_rpc_pci_whitelist(struct rpc_pci_whitelist *list)

{

	size_t i;



	for (i = 0; i < list->num_bdfs; i++) {

		free(list->bdfs[i]);

	}

}



struct rpc_ioat_scan_accel_engine {

	struct rpc_pci_whitelist pci_whitelist;

};



static void

free_rpc_ioat_scan_accel_engine(struct rpc_ioat_scan_accel_engine *p)

{

	free_rpc_pci_whitelist(&p->pci_whitelist);

}



static const struct spdk_json_object_decoder rpc_ioat_scan_accel_engine_decoder[] = {

	{"pci_whitelist", offsetof(struct rpc_ioat_scan_accel_engine, pci_whitelist), decode_rpc_pci_whitelist},

};



static void

rpc_ioat_scan_accel_engine(struct spdk_jsonrpc_request *request,

			   const struct spdk_json_val *params)

{

	struct rpc_ioat_scan_accel_engine req = {};

	int rc;



	if (params != NULL) {

		if (spdk_json_decode_object(params, rpc_ioat_scan_accel_engine_decoder,

					    SPDK_COUNTOF(rpc_ioat_scan_accel_engine_decoder),

					    &req)) {

			free_rpc_ioat_scan_accel_engine(&req);

			SPDK_ERRLOG("spdk_json_decode_object() failed\n");

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

							 "Invalid parameters");

						 "ioat_scan_accel_engine requires no parameters");

		return;

	}



		rc = accel_engine_ioat_add_whitelist_devices((const char **)req.pci_whitelist.bdfs,

				req.pci_whitelist.num_bdfs);

		free_rpc_ioat_scan_accel_engine(&req);

		if (rc < 0) {

			SPDK_ERRLOG("accel_engine_ioat_add_whitelist_devices() failed\n");

			spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,

							 "Invalid parameters");

			return;

		}

	}



	accel_engine_ioat_enable_probe();



	spdk_jsonrpc_send_bool_response(request, true);