[yocto] [PATCH 5/6][rmc] remove kernel command line usage and blob type
Jianxun Zhang
jianxun.zhang at linux.intel.com
Wed Nov 23 09:32:58 PST 2016
> On Nov 22, 2016, at 3:49 PM, Khem Raj <raj.khem at gmail.com> wrote:
>
>
>
> On 11/22/16 11:35 AM, Jianxun Zhang wrote:
>> rmc works as a generic file-based solution now. There is no need
>> to keep a special case for kernel command line type which was
>> designed in early days.
>>
>> Signed-off-by: Jianxun Zhang <jianxun.zhang at linux.intel.com>
>> ---
>> inc/rmcl.h | 27 ++++-----
>> src/lib/api.c | 4 +-
>> src/lib/common/rmcl.c | 32 +++--------
>> src/lib/efi_api.c | 2 +-
>> src/rmc.c | 150 ++++++++++++--------------------------------------
>> 5 files changed, 59 insertions(+), 156 deletions(-)
>>
>> diff --git a/inc/rmcl.h b/inc/rmcl.h
>> index 4123819..5bbad42 100644
>> --- a/inc/rmcl.h
>> +++ b/inc/rmcl.h
>> @@ -101,23 +101,20 @@ typedef struct rmc_record_header {
>> * RMC Database Meta (packed)
>> */
>> typedef struct rmc_meta_header {
>> - rmc_uint8_t type; /* type 0 command line; type 1 file blob*/
>> - rmc_uint64_t length; /* covers cmdline_filename and blob blocks. */
>> - /* char *cmdline_filename : Invisible, null-terminated string packed in mem */
>> + rmc_uint8_t type; /* RMC_GENERIC_FILE or or any other types defined later */
>> + rmc_uint64_t length; /* length of blob's name and blob */
>
> is there a need to define rmc_uint64_t and other rmc_* data types ?
> can it depends upong the c99 inttypes ? it would make it readable and simple
hmm, the current gnu90 was intendedly added in rmc EFI build but I need to recall why I did it. (And it is not strict c90 per gcc’s doc)
I will keep this note to see if we could move to C99 or a newer version after checking the most use cases. I think we have to be more conservative and self-constrained at this point.
The bottom-line is I don’t want to force any change on language or dependency in clients linking rmc just for rmc’s sake.
>
>> + /* char *blob_name : Invisible, null-terminated string packed in mem */
>> /* rmc_uint8_t *blob : Invisible, binary packed in mem */
>> } __attribute__ ((__packed__)) rmc_meta_header_t;
>>
>> -/*
>> - * input of a rmc policy file. RMCL accepts command line
>> - * and file blobs presented in this data type (sparse memory)
>> - */
>> -#define RMC_POLICY_CMDLINE 0
>> -#define RMC_POLICY_BLOB 1
>> +/* We only have one type now but keep a type field internally for extensions in the future. */
>> +#define RMC_GENERIC_FILE 1
>> +
>> typedef struct rmc_file {
>> - rmc_uint8_t type; /* RMC_POLICY_CMDLINE or RMC_POLICY_BLOB*/
>> - char *cmdline_name; /* file name of blob (type 1) or command line fragment (type 0) */
>> - struct rmc_file *next; /* next rmc file, or null as terminator for the last element */
>> - rmc_size_t blob_len; /* number of bytes of blob, excluding length of name */
>> + rmc_uint8_t type; /* RMC_GENERIC_FILE or or any other types defined later */
>> + char *blob_name; /* name of blob for type RMC_GENERIC_FILE */
>> + struct rmc_file *next; /* next rmc file, or null as terminator for the last element */
>> + rmc_size_t blob_len; /* number of bytes of blob, excluding length of name */
>> rmc_uint8_t *blob; /* blob of policy file, treated as binary, UNNECESSARILY Null terminated */
>> } rmc_file_t;
>>
>> @@ -153,11 +150,11 @@ extern int rmcl_generate_record(rmc_fingerprint_t *fingerprint, rmc_file_t *poli
>> extern int rmcl_generate_db(rmc_record_file_t *record_files, rmc_uint8_t **rmc_db, rmc_size_t *len);
>>
>> /*
>> - * Query a RMC database blob provided by caller, to get kernel command line fragment or a policy file blob.
>> + * Query a RMC database blob provided by caller
>> * (in) fingerprint : fingerprint of board
>> * (in) rmc_db : rmc database blob
>> * (in) type : type of record
>> - * (in) blob_name : name of file blob to query. Ignored when type is 0 (cmdline)
>> + * (in) blob_name : name of file blob to query
>> * (out) policy : policy file data structure provided by caller, holding returned policy data
>> * if there is a matched meta for board. Pointer members of policy hold data location
>> * in rmc_db's memory region. (This functions doesn't copy data.)
>> diff --git a/src/lib/api.c b/src/lib/api.c
>> index b7bc663..0adb390 100644
>> --- a/src/lib/api.c
>> +++ b/src/lib/api.c
>> @@ -282,12 +282,12 @@ int rmc_query_file_by_fp(rmc_fingerprint_t *fp, char *db_pathname, char *file_na
>> * read rmc database file
>> */
>> if (read_file(db_pathname, (char **)&db, &db_len)) {
>> - fprintf(stderr, "Failed to read database file for command line\n\n");
>> + fprintf(stderr, "Failed to read database file\n\n");
>> return ret;
>> }
>>
>> /* query policy in database */
>> - if(query_policy_from_db(fp, db, RMC_POLICY_BLOB, file_name, file))
>> + if(query_policy_from_db(fp, db, RMC_GENERIC_FILE, file_name, file))
>> goto free_db;
>>
>> /* the returned file blob is actually in db memory region,
>> diff --git a/src/lib/common/rmcl.c b/src/lib/common/rmcl.c
>> index e6be585..67622a0 100644
>> --- a/src/lib/common/rmcl.c
>> +++ b/src/lib/common/rmcl.c
>> @@ -77,10 +77,8 @@ int rmcl_generate_record(rmc_fingerprint_t *fingerprint, rmc_file_t *policy_file
>>
>> /* Calculate total length of record for memory allocation */
>> while (tmp) {
>> - /* for type 0 cmdline, don't take blob len into account */
>> - record_len += sizeof(rmc_meta_header_t) + strlen(tmp->cmdline_name) + 1;
>> - if (tmp->type != RMC_POLICY_CMDLINE)
>> - record_len += tmp->blob_len;
>> + record_len += sizeof(rmc_meta_header_t) + strlen(tmp->blob_name) + 1;
>> + record_len += tmp->blob_len;
>> tmp = tmp->next;
>> }
>>
>> @@ -111,18 +109,15 @@ int rmcl_generate_record(rmc_fingerprint_t *fingerprint, rmc_file_t *policy_file
>> meta->length = sizeof(rmc_meta_header_t);
>> idx += sizeof(rmc_meta_header_t);
>>
>> - cmd_len = strlen(tmp->cmdline_name) + 1;
>> + cmd_len = strlen(tmp->blob_name) + 1;
>>
>> - memcpy(idx, tmp->cmdline_name, cmd_len);
>> + memcpy(idx, tmp->blob_name, cmd_len);
>> idx += cmd_len;
>> meta->length += cmd_len;
>> + memcpy(idx, tmp->blob, tmp->blob_len);
>> + idx += tmp->blob_len;
>> + meta->length += tmp->blob_len;
>>
>> - /* only pack blob in when policy is not cmdline fragment */
>> - if (tmp->type != RMC_POLICY_CMDLINE) {
>> - memcpy(idx, tmp->blob, tmp->blob_len);
>> - idx += tmp->blob_len;
>> - meta->length += tmp->blob_len;
>> - }
>> tmp = tmp->next;
>> }
>>
>> @@ -210,7 +205,7 @@ int query_policy_from_db(rmc_fingerprint_t *fingerprint, rmc_uint8_t *rmc_db, rm
>> if (!fingerprint || !rmc_db || !policy)
>> return 1;
>>
>> - if (type != RMC_POLICY_CMDLINE && blob_name == NULL)
>> + if (type != RMC_GENERIC_FILE || blob_name == NULL)
>> return 1;
>>
>> db_header = (rmc_db_header_t *)rmc_db;
>> @@ -241,16 +236,7 @@ int query_policy_from_db(rmc_fingerprint_t *fingerprint, rmc_uint8_t *rmc_db, rm
>>
>> policy_idx = meta_idx + sizeof(rmc_meta_header_t);
>>
>> - /* set fields common among types */
>> - if (type == RMC_POLICY_CMDLINE) {
>> - policy->next = NULL;
>> - policy->type = type;
>> - policy->blob_len = 0;
>> - policy->blob = NULL;
>> - policy->cmdline_name = (char *)&rmc_db[policy_idx];
>> -
>> - return 0;
>> - } else if (type == RMC_POLICY_BLOB && !strncmp(blob_name, (char *)&rmc_db[policy_idx], strlen(blob_name) + 1)) {
>> + if (!strncmp(blob_name, (char *)&rmc_db[policy_idx], strlen(blob_name) + 1)) {
>> rmc_ssize_t cmd_name_len = strlen((char *)&rmc_db[policy_idx]) + 1;
>> policy->blob = &rmc_db[policy_idx + cmd_name_len];
>> policy->blob_len = meta_header.length - sizeof(rmc_meta_header_t) - cmd_name_len;
>> diff --git a/src/lib/efi_api.c b/src/lib/efi_api.c
>> index c4535c8..79b17a8 100644
>> --- a/src/lib/efi_api.c
>> +++ b/src/lib/efi_api.c
>> @@ -73,7 +73,7 @@ int rmc_get_fingerprint(void *sys_table, rmc_fingerprint_t *fp) {
>> }
>>
>> int rmc_query_file_by_fp(rmc_fingerprint_t *fp, rmc_uint8_t *db_blob, char *file_name, rmc_file_t *file) {
>> - return query_policy_from_db(fp, db_blob, RMC_POLICY_BLOB, file_name, file);
>> + return query_policy_from_db(fp, db_blob, RMC_GENERIC_FILE, file_name, file);
>> }
>>
>> int rmc_gimme_file(void *sys_table, rmc_uint8_t *db_blob, char *file_name, rmc_file_t *file) {
>> diff --git a/src/rmc.c b/src/rmc.c
>> index d4eb203..062dd36 100644
>> --- a/src/rmc.c
>> +++ b/src/rmc.c
>> @@ -1,10 +1,10 @@
>> -/*
>> +/* Copyright (C) 2016 Jianxun Zhang <jianxun.zhang at intel.com>
>> + *
>> * rmc tool
>> *
>> - * An executable supports:
>> - * - Provide fingerprint in human-readable RMC fragment (header) file
>> - * - Generate RMC database file from human-readable RMC fragment files
>> - * - Provide policy fragments like command line to its callers in user space
>> + * - Obtain fingerprint of the type of board it runs on
>> + * - Generate RMC records and database with fingerprint and board-specific data
>> + * - Query file blobs associated to the type of board at run time.
>> */
>>
>> #include <stdio.h>
>> @@ -16,20 +16,16 @@
>> #define USAGE "RMC (Runtime Machine configuration) Tool\n" \
>> "NOTE: Most of usages require root permission (sudo)\n" \
>> "rmc -F [-o output_fingerprint]\n" \
>> - "rmc -R [-f <fingerprint file>] -c <cmdline file> | -b <blob file list> [-o output_record]\n" \
>> + "rmc -R [-f <fingerprint file>] -b <blob file list> [-o output_record]\n" \
>> "rmc -D <rmc record file list> [-o output_database]\n" \
>> - "rmc -C <rmc database file>\n" \
>> "rmc -B <name of file blob> -d <rmc database file> -o output_file\n" \
>> "\n" \
>> "-F: generate board rmc fingerprint of board\n" \
>> - "-R: generate board rmc record of board with its fingerprint, kenrel commandline and blob files.\n" \
>> + "-R: generate board rmc record of board with its fingerprint and file blobs.\n" \
>> "-f: fingerprint file to be packed in record, rmc will create a fingerprint for board and use it internally to\n" \
>> " generate record if -f is missed.\n" \
>> - "-c: kernel command line fragment to be packed in record\n" \
>> "-b: files to be packed in record\n" \
>> - "Note: At least one of -f and -c must be provided when -R is present\n" \
>> "-G: generate rmc database file with records specified in record file list\n" \
>> - "-C: get kernel command line fragment from database file for the board rmc is running on, output to stdout\n" \
>> "-B: get a flie blob with specified name associated to the board rmc is running on\n" \
>> "-d: database file to be queried\n" \
>> "-o: path and name of output file of a specific command\n" \
>> @@ -37,13 +33,11 @@
>> "Examples (Steps in an order to add board support into rmc):\n" \
>> "generate board fingerprint:\n" \
>> "rmc -F\n\n" \
>> - "generate a rmc record for the board with a kernel command line fragment and two files, output to:\n" \
>> + "generate a rmc record for the board with two file blobs, output to:\n" \
>> "a specified file:\n" \
>> - "rmc -R -f fingerprint -c my_cmdline -b file_1 file_2 -o my_board.record\n\n" \
>> + "rmc -R -f fingerprint -b file_1 file_2 -o my_board.record\n\n" \
>> "generate a rmc database file with records from 3 different boards:\n" \
>> "rmc -D board1_record board2_record board3_record\n\n" \
>> - "output command line fragment for the board rmc is running on, from a rmc database mn_rmc.db:\n" \
>> - "rmc -C my_rmc.db\n\n" \
>> "query a file blob named audio.conf associated to the board rmc is running on in database my_rmc.db and output\n" \
>> "to /tmp/new_audio.conf:\n" \
>> "rmc -B audio.conf -d my_rmc.db -o /tmp/new_audio.conf\n\n"
>> @@ -52,13 +46,11 @@
>> #define RMC_OPT_CAP_F (1 << 0)
>> #define RMC_OPT_CAP_R (1 << 1)
>> #define RMC_OPT_CAP_D (1 << 2)
>> -#define RMC_OPT_CAP_C (1 << 3)
>> -#define RMC_OPT_CAP_B (1 << 4)
>> -#define RMC_OPT_C (1 << 5)
>> -#define RMC_OPT_F (1 << 6)
>> -#define RMC_OPT_O (1 << 7)
>> -#define RMC_OPT_B (1 << 8)
>> -#define RMC_OPT_D (1 << 9)
>> +#define RMC_OPT_CAP_B (1 << 3)
>> +#define RMC_OPT_F (1 << 4)
>> +#define RMC_OPT_O (1 << 5)
>> +#define RMC_OPT_B (1 << 6)
>> +#define RMC_OPT_D (1 << 7)
>>
>> static void usage () {
>> fprintf(stdout, USAGE);
>> @@ -211,12 +203,12 @@ read_fp_done:
>> }
>>
>> /*
>> - * Read a policy file (cmdline or a blob) into policy file structure
>> - * (in) pathname : path and name of policy file
>> - * (in) type : policy type, commandline or a file blob
>> + * Read a file blob into rmc file structure
>> + * (in) pathname : path and name of file
>> + * (in) type : policy type that must be RMC_GENERIC_FILE
>> *
>> - * return : a pointer to policy file structure. Caller shall
>> - * free memory for returned data AND cmdline or blob
>> + * return : a pointer to rmc file structure. Caller shall
>> + * free memory for returned data AND blob
>> * Null is returned for failures.
>> */
>> static rmc_file_t *read_policy_file(char *pathname, int type) {
>> @@ -226,44 +218,28 @@ static rmc_file_t *read_policy_file(char *pathname, int type) {
>> char *path_token;
>>
>> if ((tmp = calloc(1, sizeof(rmc_file_t))) == NULL) {
>> - fprintf(stderr, "Failed to allocate memory for cmdline fragment\n\n");
>> + fprintf(stderr, "Failed to allocate memory for file blob\n\n");
>> return NULL;
>> }
>>
>> tmp->type = type;
>> tmp->next = NULL;
>>
>> - if (tmp->type == RMC_POLICY_CMDLINE) {
>> - ret = read_file(pathname, &tmp->cmdline_name, &policy_len);
>> - if (ret) {
>> - fprintf(stderr, "Failed to read kernel command line file %s\n\n", pathname);
>> - free(tmp);
>> - return NULL;
>> - }
>> -
>> - if (!policy_len) {
>> - fprintf(stderr, "Empty kernel command line file %s\n\n", pathname);
>> - free(tmp);
>> - return NULL;
>> - }
>> -
>> - tmp->blob_len = 0;
>> - tmp->blob = NULL;
>> - } else if (type == RMC_POLICY_BLOB) {
>> + if (type == RMC_GENERIC_FILE) {
>> ret = read_file(pathname, (char **)&tmp->blob, &policy_len);
>> if (ret) {
>> - fprintf(stderr, "Failed to read policy file %s\n\n", pathname);
>> + fprintf(stderr, "Failed to read file %s\n\n", pathname);
>> free(tmp);
>> return NULL;
>> }
>> tmp->blob_len = policy_len;
>> path_token = strrchr(pathname, '/');
>> if (!path_token)
>> - tmp->cmdline_name = strdup(pathname);
>> + tmp->blob_name = strdup(pathname);
>> else
>> - tmp->cmdline_name = strdup(path_token + 1);
>> + tmp->blob_name = strdup(path_token + 1);
>>
>> - if (!tmp->cmdline_name) {
>> + if (!tmp->blob_name) {
>> fprintf(stderr, "Failed to allocate mem for policy file name %s\n\n", pathname);
>> free(tmp->blob);
>> free(tmp);
>> @@ -279,7 +255,7 @@ static rmc_file_t *read_policy_file(char *pathname, int type) {
>> }
>>
>> /*
>> - * Read a record file (cmdline or a blob) into record file structure
>> + * Read a record file into record file structure
>> * (in) pathname : path and name of record file
>> *
>> * return : a pointer to record file structure. Caller shall
>> @@ -311,13 +287,10 @@ int main(int argc, char **argv){
>> int c;
>> rmc_uint16_t options = 0;
>> char *output_path = NULL;
>> - /* -C and -d could be present in a single command, with different database files specified. */
>> - char *input_db_path_cap_c = NULL;
>> char *input_db_path_d = NULL;
>> char **input_file_blobs = NULL;
>> char **input_record_files = NULL;
>> char *input_fingerprint = NULL;
>> - char *input_cmdline_path = NULL;
>> char *input_blob_name = NULL;
>> rmc_fingerprint_t fingerprint;
>> rmc_file_t *policy_files = NULL;
>> @@ -338,7 +311,7 @@ int main(int argc, char **argv){
>> /* parse options */
>> opterr = 0;
>>
>> - while ((c = getopt(argc, argv, "FRD:C:B:b:c:f:o:d:")) != -1)
>> + while ((c = getopt(argc, argv, "FRD:B:b:f:o:d:")) != -1)
>> switch (c) {
>> case 'F':
>> options |= RMC_OPT_CAP_F;
>> @@ -371,10 +344,6 @@ int main(int argc, char **argv){
>>
>> options |= RMC_OPT_CAP_D;
>> break;
>> - case 'C':
>> - input_db_path_cap_c = optarg;
>> - options |= RMC_OPT_CAP_C;
>> - break;
>> case 'B':
>> input_blob_name = optarg;
>> options |= RMC_OPT_CAP_B;
>> @@ -383,10 +352,6 @@ int main(int argc, char **argv){
>> output_path = optarg;
>> options |= RMC_OPT_O;
>> break;
>> - case 'c':
>> - input_cmdline_path = optarg;
>> - options |= RMC_OPT_C;
>> - break;
>> case 'f':
>> input_fingerprint = optarg;
>> options |= RMC_OPT_F;
>> @@ -422,8 +387,8 @@ int main(int argc, char **argv){
>>
>> break;
>> case '?':
>> - if (optopt == 'F' || optopt == 'R' || optopt == 'D' || optopt == 'C' || optopt == 'B' || \
>> - optopt == 'b' || optopt == 'f' || optopt == 'c' || optopt == 'o' || optopt == 'd')
>> + if (optopt == 'F' || optopt == 'R' || optopt == 'D' || optopt == 'B' || \
>> + optopt == 'b' || optopt == 'f' || optopt == 'o' || optopt == 'd')
>> fprintf(stderr, "\nWRONG USAGE: -%c\n\n", optopt);
>> else if (isprint(optopt))
>> fprintf(stderr, "Unknown option `-%c'.\n\n", optopt);
>> @@ -450,8 +415,8 @@ int main(int argc, char **argv){
>> }
>>
>> /* sanity check for -R */
>> - if ((options & RMC_OPT_CAP_R) && (!(options & (RMC_OPT_C|RMC_OPT_B)))) {
>> - fprintf(stderr, "\nWRONG: At least one of -c or -b is required when -R is present\n\n");
>> + if ((options & RMC_OPT_CAP_R) && (!(options & RMC_OPT_B))) {
>> + fprintf(stderr, "\nWRONG: -b is required when -R is present\n\n");
>> usage();
>> return 1;
>> }
>> @@ -463,36 +428,6 @@ int main(int argc, char **argv){
>> return 1;
>> }
>>
>> - /* get cmdline */
>> - if (options & RMC_OPT_CAP_C) {
>> -
>> - rmc_size_t db_len = 0;
>> - rmc_fingerprint_t fp;
>> - rmc_file_t cmd_policy;
>> -
>> - /* read rmc database file */
>> - if (read_file(input_db_path_cap_c, (char **)&db_c, &db_len)) {
>> - fprintf(stderr, "Failed to read database file for command line\n\n");
>> - goto main_free;
>> - }
>> -
>> - /* get board fingerprint */
>> - if (rmc_get_fingerprint(&fp)) {
>> - fprintf(stderr, "-C Failed to generate fingerprint for this board\n\n");
>> - goto main_free;
>> - }
>> -
>> - /* query cmdline in database, no error message if no command line for board found */
>> - if (query_policy_from_db(&fp, db_c, RMC_POLICY_CMDLINE, NULL, &cmd_policy)) {
>> - rmc_free_fingerprint(&fp);
>> - goto main_free;
>> - }
>> -
>> - rmc_free_fingerprint(&fp);
>> -
>> - fprintf(stdout, "%s", cmd_policy.cmdline_name);
>> - }
>> -
>> /* get a file blob */
>> if (options & RMC_OPT_CAP_B) {
>> rmc_file_t file;
>> @@ -557,10 +492,7 @@ int main(int argc, char **argv){
>> }
>> }
>>
>> - /* generate RMC record file, we allow both or either of a list of config files and kenrel command line.
>> - * That means user can choose to have a single record contains both of file blob(s) and command line for
>> - * the board.
>> - */
>> + /* generate RMC record file with a list of file blobs. */
>> if (options & RMC_OPT_CAP_R) {
>> rmc_fingerprint_t fp;
>> rmc_fingerprint_t *free_fp = NULL;
>> @@ -593,11 +525,11 @@ int main(int argc, char **argv){
>> free_fp = &fp;
>> }
>>
>> - /* read command line file and policy file into a list */
>> + /* read policy file into a list */
>> while (input_file_blobs && input_file_blobs[policy_idx]) {
>> char *s = input_file_blobs[policy_idx];
>>
>> - if ((policy = read_policy_file(s, RMC_POLICY_BLOB)) == NULL) {
>> + if ((policy = read_policy_file(s, RMC_GENERIC_FILE)) == NULL) {
>> fprintf(stderr, "Failed to read policy file %s\n\n", s);
>> rmc_free_fingerprint(free_fp);
>> goto main_free;
>> @@ -614,18 +546,6 @@ int main(int argc, char **argv){
>> policy_idx++;
>> }
>>
>> - if (input_cmdline_path) {
>> - if ((policy = read_policy_file(input_cmdline_path, RMC_POLICY_CMDLINE)) == NULL) {
>> - fprintf(stderr, "Failed to read command line file %s\n\n", input_cmdline_path);
>> - rmc_free_fingerprint(free_fp);
>> - goto main_free;
>> - }
>> -
>> - /* put command line at the head of list */
>> - policy->next = policy_files;
>> - policy_files = policy;
>> - }
>> -
>> /* call rmcl to generate record blob */
>> if (rmcl_generate_record(&fp, policy_files, &record)) {
>> fprintf(stderr, "Failed to generate record for this board\n\n");
>> @@ -697,7 +617,7 @@ main_free:
>> rmc_file_t *t = policy_files;
>> policy_files = policy_files->next;
>> free(t->blob);
>> - free(t->cmdline_name);
>> + free(t->blob_name);
>> free(t);
>> }
More information about the yocto
mailing list