33#include <sys/kernel.h>
36#include <sys/malloc.h>
37#include <sys/module.h>
40#include <machine/stdarg.h>
44#include <sys/iov_schema.h>
46#include <net/ethernet.h>
52 const nvlist_t *,
const char *
name);
80 .type_name =
"string",
85 .type_name =
"uint8_t",
91 .type_name =
"uint16_t",
97 .type_name =
"uint32_t",
103 .type_name =
"uint64_t",
109 .type_name =
"unicast-mac",
135 nvlist_set_error(entry, EINVAL);
138 nvlist_add_string(entry,
"type",
type);
145 if (flags & IOV_SCHEMA_REQUIRED) {
146 if (flags & IOV_SCHEMA_HASDEFAULT) {
147 nvlist_set_error(entry, EINVAL);
151 nvlist_add_bool(entry,
"required", 1);
161 entry = nvlist_create(NV_FLAG_IGNORE_CASE);
163 nvlist_set_error(schema, ENOMEM);
168 if (flags & IOV_SCHEMA_HASDEFAULT)
169 nvlist_add_bool(entry,
"default", defaultVal);
172 nvlist_move_nvlist(schema,
name, entry);
177 const char *defaultVal)
181 entry = nvlist_create(NV_FLAG_IGNORE_CASE);
183 nvlist_set_error(schema, ENOMEM);
188 if (flags & IOV_SCHEMA_HASDEFAULT)
189 nvlist_add_string(entry,
"default", defaultVal);
192 nvlist_move_nvlist(schema,
name, entry);
197 uint32_t flags, uint64_t defaultVal)
201 entry = nvlist_create(NV_FLAG_IGNORE_CASE);
203 nvlist_set_error(schema, ENOMEM);
208 if (flags & IOV_SCHEMA_HASDEFAULT)
209 nvlist_add_number(entry,
"default", defaultVal);
212 nvlist_move_nvlist(schema,
name, entry);
249 uint32_t flags,
const uint8_t * defaultVal)
253 entry = nvlist_create(NV_FLAG_IGNORE_CASE);
255 nvlist_set_error(schema, ENOMEM);
260 if (flags & IOV_SCHEMA_HASDEFAULT)
261 nvlist_add_binary(entry,
"default", defaultVal, ETHER_ADDR_LEN);
264 nvlist_move_nvlist(schema,
name, entry);
317 if (size != ETHER_ADDR_LEN)
320 if (ETHER_IS_MULTICAST(mac))
333 if (nvlist_exists_binary(param_schema,
"default")) {
334 binary = nvlist_get_binary(param_schema,
"default", &len);
336 }
else if (nvlist_exists_bool(param_schema,
"default"))
338 nvlist_get_bool(param_schema,
"default"));
339 else if (nvlist_exists_number(param_schema,
"default"))
341 nvlist_get_number(param_schema,
"default"));
342 else if (nvlist_exists_nvlist(param_schema,
"default"))
344 nvlist_get_nvlist(param_schema,
"default"));
345 else if (nvlist_exists_string(param_schema,
"default"))
347 nvlist_get_string(param_schema,
"default"));
349 panic(
"Unexpected nvlist type");
354 const nvlist_t *param)
357 if (!nvlist_exists_bool(param, DEFAULT_SCHEMA_NAME))
364 const nvlist_t *param)
367 if (!nvlist_exists_string(param, DEFAULT_SCHEMA_NAME))
374 const nvlist_t *param)
378 if (!nvlist_exists_number(param, DEFAULT_SCHEMA_NAME))
381 defaultVal = nvlist_get_number(param, DEFAULT_SCHEMA_NAME);
382 if (defaultVal > validator->
limit)
394 if (!nvlist_exists_binary(param, DEFAULT_SCHEMA_NAME))
397 mac = nvlist_get_binary(param, DEFAULT_SCHEMA_NAME, &size);
398 if (size != ETHER_ADDR_LEN)
401 if (ETHER_IS_MULTICAST(mac))
414 if (!nvlist_exists_string(schema, TYPE_SCHEMA_NAME))
416 type = nvlist_get_string(schema, TYPE_SCHEMA_NAME);
419 if (validator == NULL)
423 if (nvlist_exists(schema, DEFAULT_SCHEMA_NAME)) {
429 if (nvlist_exists(schema, REQUIRED_SCHEMA_NAME))
434 if (nvlist_exists(schema, REQUIRED_SCHEMA_NAME)) {
435 if (!nvlist_exists_bool(schema, REQUIRED_SCHEMA_NAME))
445 const nvlist_t *sub_schema, *param_schema;
446 const char *param_name;
450 if (!nvlist_exists_nvlist(dev_schema,
name))
452 sub_schema = nvlist_get_nvlist(dev_schema,
name);
455 while ((param_name = nvlist_next(sub_schema, &
type, &it)) != NULL) {
456 if (
type != NV_TYPE_NVLIST)
458 param_schema = nvlist_get_nvlist(sub_schema, param_name);
475 const nvlist_t *iov_schema, *driver_schema;
480 driver_schema = nvlist_get_nvlist(dev_schema, DRIVER_CONFIG_NAME);
481 iov_schema = nvlist_get_nvlist(dev_schema, IOV_CONFIG_NAME);
484 while ((
name = nvlist_next(driver_schema, &
type, &it)) != NULL) {
485 if (nvlist_exists(iov_schema,
name))
504 while ((
name = nvlist_next(dev_schema, &
type, &it)) != NULL) {
505 if (strcmp(
name, IOV_CONFIG_NAME) != 0 &&
506 strcmp(
name, DRIVER_CONFIG_NAME) != 0)
516 const nvlist_t *dev_schema;
519 if (!nvlist_exists_nvlist(schema,
name))
521 dev_schema = nvlist_get_nvlist(schema,
name);
548 while ((
name = nvlist_next(dev_schema, &
type, &it)) != NULL) {
549 if (strcmp(
name, PF_CONFIG_NAME) != 0 &&
550 strcmp(
name, VF_SCHEMA_NAME) != 0)
581 const nvlist_t *param_schema;
587 while ((
name = nvlist_next(schema, &
type, &cookie)) != NULL) {
588 param_schema = nvlist_get_nvlist(schema,
name);
590 if (dnvlist_get_bool(param_schema,
"required", 0)) {
595 if (nvlist_exists(param_schema,
"default") &&
600 return (nvlist_error(
config));
610 type = nvlist_get_string(schema_param,
"type");
613 KASSERT(validator != NULL,
614 (
"Schema was not validated: Unknown type %s",
type));
626 const nvlist_t *schema_param;
633 if (!nvlist_exists_nvlist(schema,
name))
636 schema_param = nvlist_get_nvlist(schema,
name);
650 const char *schema_device,
const char *config_device)
652 const nvlist_t *device_schema, *iov_schema, *driver_schema;
653 nvlist_t *device_config, *iov_config, *driver_config;
656 device_config = NULL;
658 driver_config = NULL;
660 device_schema = nvlist_get_nvlist(schema, schema_device);
661 iov_schema = nvlist_get_nvlist(device_schema, IOV_CONFIG_NAME);
662 driver_schema = nvlist_get_nvlist(device_schema, DRIVER_CONFIG_NAME);
664 device_config = dnvlist_take_nvlist(
config, config_device, NULL);
665 if (device_config == NULL) {
670 iov_config = dnvlist_take_nvlist(device_config, IOV_CONFIG_NAME, NULL);
671 if (iov_config == NULL) {
676 driver_config = dnvlist_take_nvlist(device_config, DRIVER_CONFIG_NAME,
678 if (driver_config == NULL) {
701 nvlist_move_nvlist(device_config, IOV_CONFIG_NAME, iov_config);
702 nvlist_move_nvlist(device_config, DRIVER_CONFIG_NAME, driver_config);
703 nvlist_move_nvlist(
config, config_device, device_config);
712 char device[VF_MAX_NAME];
715 for (i = 0; i <
num_vfs; i++) {
716 snprintf(device,
sizeof(device), VF_PREFIX
"%d", i);
719 VF_SCHEMA_NAME, device);
739 if (strcasecmp(
name, IOV_CONFIG_NAME) == 0)
741 else if (strcasecmp(
name, DRIVER_CONFIG_NAME) == 0)
757 const char *number_start;
761 if (strcasecmp(PF_CONFIG_NAME,
name) == 0)
765 if (strncasecmp(
name, VF_PREFIX, VF_PREFIX_LEN) != 0)
768 number_start =
name + VF_PREFIX_LEN;
771 if (number_start[0] ==
'\0')
775 if (!isdigit(number_start[0]))
778 vf_num = strtoul(number_start, &endp, 10);
783 if (vf_num != 0 && number_start[0] ==
'0')
787 if (vf_num == 0 && number_start[1] !=
'\0')
804 const nvlist_t *device;
856 const nvlist_t *
pf, *iov;
858 pf = nvlist_get_nvlist(
config, PF_CONFIG_NAME);
859 iov = nvlist_get_nvlist(
pf, IOV_CONFIG_NAME);
860 return (nvlist_get_number(iov,
"num_vfs"));
868 return (nvlist_create(NV_FLAG_IGNORE_CASE));
const struct nvlist * config
static int pci_iov_schema_validate_device(const nvlist_t *schema, nvlist_t *config, const char *schema_device, const char *config_device)
static validate_func pci_iov_schema_validate_uint
int() default_validate_t(const struct config_type_validator *, const nvlist_t *)
void pci_iov_schema_add_bool(nvlist_t *schema, const char *name, uint32_t flags, int defaultVal)
uint16_t pci_iov_config_get_num_vfs(const nvlist_t *config)
static void pci_iov_schema_int(nvlist_t *schema, const char *name, const char *type, uint32_t flags, uint64_t defaultVal)
static int pci_iov_schema_validate_param(const nvlist_t *schema_param, const char *name, const nvlist_t *config)
static int pci_iov_schema_validate_dev_name(const char *name, uint16_t num_vfs)
static int pci_iov_schema_validate_vfs(const nvlist_t *schema, nvlist_t *config, uint16_t num_vfs)
static validate_func pci_iov_schema_validate_string
void pci_iov_schema_add_uint64(nvlist_t *schema, const char *name, uint32_t flags, uint64_t defaultVal)
void pci_iov_schema_add_uint16(nvlist_t *schema, const char *name, uint32_t flags, uint16_t defaultVal)
static default_validate_t pci_iov_validate_string_default
static int pci_iov_validate_schema_devices(const nvlist_t *dev_schema)
static default_validate_t pci_iov_validate_uint_default
static int pci_iov_validate_subsystem_schema(const nvlist_t *dev_schema, const char *name)
static int pci_iov_schema_validate_types(const nvlist_t *schema, const nvlist_t *config)
void pci_iov_schema_add_uint8(nvlist_t *schema, const char *name, uint32_t flags, uint8_t defaultVal)
static struct config_type_validator pci_iov_schema_validators[]
int pci_iov_validate_schema(const nvlist_t *schema)
nvlist_t * pci_iov_schema_alloc_node(void)
static int pci_iov_validate_device_schema(const nvlist_t *schema, const char *name)
void pci_iov_schema_add_unicast_mac(nvlist_t *schema, const char *name, uint32_t flags, const uint8_t *defaultVal)
static void pci_iov_schema_add_type(nvlist_t *entry, const char *type)
static void pci_iov_config_add_default(const nvlist_t *param_schema, const char *name, nvlist_t *config)
int() validate_func(const struct config_type_validator *, const nvlist_t *, const char *name)
void pci_iov_schema_add_string(nvlist_t *schema, const char *name, uint32_t flags, const char *defaultVal)
static validate_func pci_iov_schema_validate_unicast_mac
static const struct config_type_validator * pci_iov_schema_find_validator(const char *type)
static int pci_iov_schema_validate_device_subsystems(const nvlist_t *config)
int pci_iov_schema_validate_config(const nvlist_t *schema, nvlist_t *config)
static int pci_iov_schema_validate_device_names(const nvlist_t *config, uint16_t num_vfs)
static default_validate_t pci_iov_validate_unicast_mac_default
static int pci_iov_validate_param_schema(const nvlist_t *schema)
static void pci_iov_schema_add_required(nvlist_t *entry, uint32_t flags)
static int pci_iov_validate_schema_subsystems(const nvlist_t *dev_schema)
static default_validate_t pci_iov_validate_bool_default
static int pci_iov_schema_validate_required(const nvlist_t *schema, nvlist_t *config)
void pci_iov_schema_add_uint32(nvlist_t *schema, const char *name, uint32_t flags, uint32_t defaultVal)
static int pci_iov_validate_param_collisions(const nvlist_t *dev_schema)
static validate_func pci_iov_schema_validate_bool
default_validate_t * default_validate