ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scsi: Remove global unmap config parameters

Browse Source 
None of these make sense as global parameters - they're
all only configurable per-disk. This is a large simplification
and removes the SCSI library's dependency on the config
file entirely.

Change-Id: I1236158a23fa49e437938c51022b13772e404561
Signed-off-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-on: https://review.gerrithub.io/371598
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Daniel Verkamp <daniel.verkamp@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
This commit is contained in:
Ben Walker 2017-07-27 10:33:04 -07:00 committed by Jim Harris
parent 8422f88644
commit c0de8a8b0e
4 changed files with 10 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
lib/scsi/scsi.c
View File

@ -34,61 +34,8 @@
#include "scsi_internal.h" #include "scsi_internal.h"
#include "spdk/conf.h"
#define DEFAULT_MAX_UNMAP_LBA_COUNT 4194304
#define DEFAULT_OPTIMAL_UNMAP_GRANULARITY 0
#define DEFAULT_UNMAP_GRANULARITY_ALIGNMENT 0
#define DEFAULT_UGAVALID 0
#define DEFAULT_MAX_WRITE_SAME_LENGTH 512
struct spdk_scsi_globals g_spdk_scsi; struct spdk_scsi_globals g_spdk_scsi;
static void
spdk_set_default_scsi_parameters(void)
{
g_spdk_scsi.scsi_params.max_unmap_lba_count = DEFAULT_MAX_UNMAP_LBA_COUNT;
g_spdk_scsi.scsi_params.optimal_unmap_granularity =
DEFAULT_OPTIMAL_UNMAP_GRANULARITY;
g_spdk_scsi.scsi_params.unmap_granularity_alignment =
DEFAULT_UNMAP_GRANULARITY_ALIGNMENT;
g_spdk_scsi.scsi_params.ugavalid = DEFAULT_UGAVALID;
g_spdk_scsi.scsi_params.max_write_same_length = DEFAULT_MAX_WRITE_SAME_LENGTH;
}
static int
spdk_read_config_scsi_parameters(void)
{
struct spdk_conf_section *sp;
const char *val;
sp = spdk_conf_find_section(NULL, "Scsi");
if (sp == NULL) {
spdk_set_default_scsi_parameters();
return 0;
}
val = spdk_conf_section_get_val(sp, "MaxUnmapLbaCount");
g_spdk_scsi.scsi_params.max_unmap_lba_count = (val == NULL) ?
DEFAULT_MAX_UNMAP_LBA_COUNT : strtoul(val, NULL, 10);
val = spdk_conf_section_get_val(sp, "OptimalUnmapGranularity");
g_spdk_scsi.scsi_params.optimal_unmap_granularity = (val == NULL) ?
DEFAULT_OPTIMAL_UNMAP_GRANULARITY : strtoul(val, NULL, 10);
val = spdk_conf_section_get_val(sp, "UnmapGranularityAlignment");
g_spdk_scsi.scsi_params.unmap_granularity_alignment = (val == NULL) ?
DEFAULT_UNMAP_GRANULARITY_ALIGNMENT : strtoul(val, NULL, 10);
g_spdk_scsi.scsi_params.ugavalid = spdk_conf_section_get_boolval(sp, "Ugavalid", DEFAULT_UGAVALID);
val = spdk_conf_section_get_val(sp, "MaxWriteSameLength");
g_spdk_scsi.scsi_params.max_write_same_length = (val == NULL) ?
DEFAULT_MAX_WRITE_SAME_LENGTH : strtoul(val, NULL, 10);
return 0;
}
int int
spdk_scsi_init(void) spdk_scsi_init(void)
{ {
@ -100,12 +47,6 @@ spdk_scsi_init(void)
return -1; return -1;
} }
rc = spdk_read_config_scsi_parameters();
if (rc < 0) {
SPDK_ERRLOG("spdk_scsi_parameters() failed\n");
return -1;
}
return 0; return 0;
} }

29
lib/scsi/scsi_bdev.c
View File

@ -560,7 +560,8 @@ spdk_bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task,
* maximum number of LBAs that may be * maximum number of LBAs that may be
* unmapped by an UNMAP command. * unmapped by an UNMAP command.
*/ */
to_be32(&data[20], g_spdk_scsi.scsi_params.max_unmap_lba_count); /* For now, choose 4MB as the maximum. */
to_be32(&data[20], 4194304);
/* /*
* MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT: * MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT:
@ -574,28 +575,10 @@ spdk_bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task,
to_be32(&data[24], DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); to_be32(&data[24], DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT);
/* /*
* OPTIMAL UNMAP GRANULARITY: indicates the * The UGAVALID bit is left as 0 which means neither the
* optimal granularity in logical blocks * OPTIMAL UNMAP GRANULARITY nor the UNMAP GRANULARITY
* for unmap request. * ALIGNMENT fields are valid.
*/ */
to_be32(&data[28], g_spdk_scsi.scsi_params.optimal_unmap_granularity);
/*
* UNMAP GRANULARITY ALIGNMENT: indicates the
* LBA of the first logical block to which the
* OPTIMAL UNMAP GRANULARITY field applies.
*/
/* not specified */
to_be32(&data[32], g_spdk_scsi.scsi_params.unmap_granularity_alignment);
/*
* UGAVALID(7): bit set to one indicates that
* the UNMAP GRANULARITY ALIGNMENT field is
* valid.
*/
/* not specified */
if (g_spdk_scsi.scsi_params.ugavalid)
data[32] |= 1 << 7;
/* /*
* MAXIMUM WRITE SAME LENGTH: indicates the * MAXIMUM WRITE SAME LENGTH: indicates the
@ -603,7 +586,7 @@ spdk_bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task,
* that the device server allows to be unmapped * that the device server allows to be unmapped
* or written in a single WRITE SAME command. * or written in a single WRITE SAME command.
*/ */
to_be64(&data[36], g_spdk_scsi.scsi_params.max_write_same_length); to_be64(&data[36], 512);
/* Reserved */ /* Reserved */
/* not specified */ /* not specified */

9
lib/scsi/scsi_internal.h
View File

@ -163,17 +163,8 @@ int spdk_scsi_port_construct(struct spdk_scsi_port *port, uint64_t id,
int spdk_bdev_scsi_execute(struct spdk_bdev *bdev, struct spdk_scsi_task *task); int spdk_bdev_scsi_execute(struct spdk_bdev *bdev, struct spdk_scsi_task *task);
int spdk_bdev_scsi_reset(struct spdk_bdev *bdev, struct spdk_scsi_task *task); int spdk_bdev_scsi_reset(struct spdk_bdev *bdev, struct spdk_scsi_task *task);
struct spdk_scsi_parameters {
uint32_t max_unmap_lba_count;
uint32_t optimal_unmap_granularity;
uint32_t unmap_granularity_alignment;
uint32_t ugavalid;
uint64_t max_write_same_length;
};
struct spdk_scsi_globals { struct spdk_scsi_globals {
pthread_mutex_t mutex; pthread_mutex_t mutex;
struct spdk_scsi_parameters scsi_params;
}; };
extern struct spdk_scsi_globals g_spdk_scsi; extern struct spdk_scsi_globals g_spdk_scsi;

298
test/unit/lib/scsi/scsi.c/scsi_ut.c
View File

@ -39,286 +39,13 @@
#include "scsi.c" #include "scsi.c"
static int
null_init(void)
{
return 0;
}
static int
null_clean(void)
{
return 0;
}
static struct spdk_conf *
spdk_config_init_scsi_params(char *key, char *value)
{
struct spdk_conf *spdk_config;
FILE *f;
int fd, rc;
char filename[] = "/tmp/scsi_init_ut.XXXXXX";
/* Create temporary file to hold config */
fd = mkstemp(filename);
SPDK_CU_ASSERT_FATAL(fd != -1);
f = fdopen(fd, "wb+");
SPDK_CU_ASSERT_FATAL(f != NULL);
fprintf(f, "[Scsi]\n");
fprintf(f, "%s %s\n", key, value);
fclose(f);
spdk_config = spdk_conf_allocate();
SPDK_CU_ASSERT_FATAL(spdk_config != NULL);
rc = spdk_conf_read(spdk_config, filename);
SPDK_CU_ASSERT_FATAL(rc == 0);
spdk_conf_set_as_default(spdk_config);
remove(filename);
return spdk_config;
}
static void static void
set_default_scsi_params(struct spdk_scsi_parameters *params) scsi_init(void)
{ {
memset(params, 0, sizeof(*params));
params->max_unmap_lba_count = DEFAULT_MAX_UNMAP_LBA_COUNT;
params->optimal_unmap_granularity = DEFAULT_OPTIMAL_UNMAP_GRANULARITY;
params->unmap_granularity_alignment = DEFAULT_UNMAP_GRANULARITY_ALIGNMENT;
params->ugavalid = DEFAULT_UGAVALID;
params->max_write_same_length = DEFAULT_MAX_WRITE_SAME_LENGTH;
}
static void
scsi_init_sp_null(void)
{
struct spdk_conf *config;
int rc; int rc;
config = spdk_conf_allocate();
SPDK_CU_ASSERT_FATAL(config != NULL);
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
/* sp = null; set default scsi params */
CU_ASSERT_EQUAL(rc, 0);
spdk_conf_set_as_default(NULL);
spdk_conf_free(config);
}
static void
scsi_init_set_max_unmap_lba_count_config_param(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.max_unmap_lba_count = 65536 of Scsi section */
config = spdk_config_init_scsi_params("MaxUnmapLbaCount", "65536");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init(); rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0); CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.max_unmap_lba_count == 65536 and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.max_unmap_lba_count = 65536;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_set_optimal_unmap_granularity_config_param(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.optimal_unmap_granularity = 0
* of Scsi section */
config = spdk_config_init_scsi_params("OptimalUnmapGranularity", "0");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.optimal_unmap_granularity == 0 and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.optimal_unmap_granularity = 0;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_set_unmap_granularity_alignment_config_param(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.unmap_granularity_alignment = 0
* of Scsi section */
config = spdk_config_init_scsi_params("UnmapGranularityAlignment", "0");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.unmap_granularity_alignment == 0 and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.unmap_granularity_alignment = 0;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_ugavalid_yes(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.ugavalid = Yes
* of Scsi section */
config = spdk_config_init_scsi_params("Ugavalid", "Yes");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.ugavalid == 1 and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.ugavalid = 1;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_ugavalid_no(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.ugavalid = No
* of Scsi section */
config = spdk_config_init_scsi_params("Ugavalid", "No");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.ugavalid == 0 and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.ugavalid = 0;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_ugavalid_unknown_value_failure(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.ugavalid = unknown value
* of Scsi section */
config = spdk_config_init_scsi_params("Ugavalid", "unknown value");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.ugavalid == DEFAULT_UGAVALID and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.ugavalid = DEFAULT_UGAVALID;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_max_write_same_length(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* set scsi_params.max_write_same_length = 512
* of Scsi section */
config = spdk_config_init_scsi_params("MaxWriteSameLength", "512");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Assert the scsi_params.max_write_same_length == 512 and
* assert the rest of the params are set to their default values */
set_default_scsi_params(&params);
params.max_write_same_length = 512;
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_read_config_scsi_params(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* Set null for item's key and value;
* set default scsi parameters */
config = spdk_config_init_scsi_params("", "");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Sets the default values for all the parameters
* of the Scsi section and returns success */
set_default_scsi_params(&params);
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
}
static void
scsi_init_success(void)
{
struct spdk_scsi_parameters params;
struct spdk_conf *config;
int rc;
/* Set null for item's key and value;
* set default scsi parameters */
config = spdk_config_init_scsi_params("", "");
spdk_conf_set_as_default(config);
rc = spdk_scsi_init();
CU_ASSERT_EQUAL(rc, 0);
/* Sets the default values for all the parameters
* of the Scsi section, initialize th device
* and returns success */
set_default_scsi_params(&params);
CU_ASSERT(memcmp(&g_spdk_scsi.scsi_params, &params, sizeof(params)) == 0);
spdk_conf_free(config);
} }
int int
@ -331,32 +58,15 @@ main(int argc, char **argv)
return CU_get_error(); return CU_get_error();
} }
suite = CU_add_suite("scsi_suite", null_init, null_clean); suite = CU_add_suite("scsi_suite", NULL, NULL);
if (suite == NULL) { if (suite == NULL) {
CU_cleanup_registry(); CU_cleanup_registry();
return CU_get_error(); return CU_get_error();
} }
if ( if (
CU_add_test(suite, "scsi init - set default scsi params", \ CU_add_test(suite, "scsi init", \
scsi_init_sp_null) == NULL scsi_init) == NULL
|| CU_add_test(suite, "scsi init - set max_unmap_lba_count", \
scsi_init_set_max_unmap_lba_count_config_param) == NULL
|| CU_add_test(suite, "scsi init - set optimal_unmap_granularity", \
scsi_init_set_optimal_unmap_granularity_config_param) == NULL
|| CU_add_test(suite, "scsi init - set unmap_granularity_alignment", \
scsi_init_set_unmap_granularity_alignment_config_param) == NULL
|| CU_add_test(suite, "scsi init - ugavalid value yes", \
scsi_init_ugavalid_yes) == NULL
|| CU_add_test(suite, "scsi init - ugavalid value no", \
scsi_init_ugavalid_no) == NULL
|| CU_add_test(suite, "scsi init - ugavalid unknown value", \
scsi_init_ugavalid_unknown_value_failure) == NULL
|| CU_add_test(suite, "scsi init - set max_write_same_length", \
scsi_init_max_write_same_length) == NULL
|| CU_add_test(suite, "scsi init - read config scsi parameters", \
scsi_init_read_config_scsi_params) == NULL
|| CU_add_test(suite, "scsi init - success", scsi_init_success) == NULL
) { ) {
CU_cleanup_registry(); CU_cleanup_registry();
return CU_get_error(); return CU_get_error();