nouveau: add command-line GSP-RM registry support
Subsystems (3)
PATCH v4 1/1 nouveau: add command-line GSP-RM registry support
Add the NVreg_RegistryDwords command line parameter, which allows specifying additional registry keys to be sent to GSP-RM. This allows additional configuration, debugging, and experimentation with GSP-RM, which uses these keys to alter its behavior.
Note that these keys are passed as-is to GSP-RM, and Nouveau does not parse them. This is in contrast to the Nvidia driver, which may parse some of the keys to configure some functionality in concert with GSP-RM. Therefore, any keys which also require action by the driver may not function correctly when passed by Nouveau. Caveat emptor.
The name and format of NVreg_RegistryDwords is the same as used by the Nvidia driver, to maintain compatibility.
--- .../gpu/drm/nouveau/include/nvkm/subdev/gsp.h | 6 + .../gpu/drm/nouveau/nvkm/subdev/gsp/r535.c | 375 ++++++++++++++++-- 2 files changed, 357 insertions(+), 24 deletions(-)
drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h +6 -0
@@ -211,6 +211,12 @@ struct nvkm_gsp {struct mutex mutex;;struct idr idr; } client_id; + +/* A linked list of registry items. The registry RPC will be built from it. */ +struct list_head registry_list; + +/* The size of the registry RPC */ +size_t registry_rpc_size; }; static inline bool
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +351 -24
408 lines not on this page · raw message
Signature · 1 line
2.34.1
On Tue, 2024-02-20 at 15:58 -0600, Timur Tabi wrote:
+static int add_registry(struct nvkm_gsp *gsp, const char *key,
+ enum registry_type type, const void *data, size_t length)
+{
+ struct registry_list_entry *reg;
+ size_t nlen = strlen(key) + 1;
+ size_t vlen; /* value length, non-zero if binary or string */
+
+ /* Set an arbitrary limit to avoid problems with broken command lines */
+ if (nlen > 64)
+ return -EFBIG;
Oops, I forgot to change this to -EINVAL.
Quoted 11 lines · Timur Tabi
Add the
NVreg_RegistryDwordscommand line parameter, which allows specifying additional registry keys to be sent to GSP-RM. This allows additional configuration, debugging, and experimentation with GSP-RM, which uses these keys to alter its behavior.Note that these keys are passed as-is to GSP-RM, and Nouveau does not parse them. This is in contrast to the Nvidia driver, which may parse some of the keys to configure some functionality in concert with GSP-RM. Therefore, any keys which also require action by the driver may not function correctly when passed by Nouveau. Caveat emptor.
Quoted 4 lines
The name and format of
NVreg_RegistryDwordsis the same as used by the Nvidia driver, to maintain compatibility.Signed-off-by Timur Tabi <[email protected]>
Thanks for sending a new version of the patch.
Please make sure that for future patches you include a changelog, such that it's easier for reviewers to keep track of what has changed.
Quoted 4 lines
--- .../gpu/drm/nouveau/include/nvkm/subdev/gsp.h | 6 + .../gpu/drm/nouveau/nvkm/subdev/gsp/r535.c | 375 ++++++++++++++++-- 2 files changed, 357 insertions(+), 24 deletions(-)
There are a few issues pointed out by checkpatch.pl, that I think should be fixed.
Quoted 115 lines
drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h +6
-0@@ -211,6 +211,12 @@ struct nvkm_gsp {struct mutex mutex;;struct idr idr; } client_id; + +/* A linked list of registry items. The registry RPC will be built from it. */ +struct list_head registry_list; + +/* The size of the registry RPC */ +size_t registry_rpc_size; }; static inline booldrivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +82
-0@@ -54,6 +54,8 @@#include <nvrm/535.113.01/nvidia/kernel/inc/vgpu/rpc_global_enums.h> #include <linux/acpi.h> +#include <linux/ctype.h> +#include <linux/parser.h> #define GSP_MSG_MIN_SIZE GSP_PAGE_SIZE#define GSP_MSG_MAX_SIZE GSP_PAGE_MIN_SIZE * 16@@ -1082,51 +1084,376 @@ r535_gsp_rpc_unloading_guest_driver(struct nvkm_gsp *gsp, bool suspend)return nvkm_gsp_rpc_wr (gsp, rpc, true); } +enum registry_type { +REGISTRY_TABLE_ENTRY_TYPE_DWORD =1 ,/* 32-bit unsigned integer */ +REGISTRY_TABLE_ENTRY_TYPE_BINARY =2 ,/* Binary blob */ +REGISTRY_TABLE_ENTRY_TYPE_STRING =3 ,/* Null-terminated string */ +}; + +/** +* registry_list_entry - linked list member for a registry key/value +* @head: list_head struct +* @type: dword, binary, or string +* @klen: the length of name of the key +* @vlen: the length of the value +* @v.dword: the data, if REGISTRY_TABLE_ENTRY_TYPE_DWORD +* @v.binary: the data, if TYPE_BINARY or TYPE_STRING +* @key: the key name +* +* Every registry key/value is represented internally by this struct. +* +* Type DWORD is a simple 32-bit unsigned integer, and its value is stored in +* v.dword. +* +* Types BINARY and STRING are variable-length binary blobs. The only real +* difference between BINARY and STRING is that STRING is null-terminated and +* is expected to contain only printable characters. +* +* To avoid having to kmalloc multiple objects, the value for BINARY and +* STRING is appended after the key[] in memory, and v.binary just points to +* that block. +* +* Note: it is technically possible to have multiple keys with the same name +* but different types, but this is not useful since GSP-RM expects keys to +* have only one specific type. +*/ +struct registry_list_entry { +struct list_head head; +enum registry_type type; +size_t klen; +size_t vlen; +union { +u32 dword;/* TYPE_DWORD */ +void *binary;/* TYPE_BINARY or TYPE_STRING */ + } v; + char key[] __counted_by(klen); +}; + +/** +* add_registry -- adds a registry entry +* @gsp: gsp pointer +* @key: name of the registry key +* @type: type of data +* @data: pointer to value +* @length: size of data, in bytes +* +* Adds a registry key/value pair to the registry database. +* +* This function collects the registry information in a linked list. After +* all registry keys have been added, build_registry() is used to create the +* RPC data structure. +* +* registry_rpc_size is a running total of the size of all registry keys. +* It's used to avoid an O(n) calculation of the size when the RPC is built. +* +* Returns 0 on success, or negative error code on error. +*/ +static int add_registry (struct nvkm_gsp *gsp,const char *key, +enum registry_type type,const void *data,size_t length) +{ +struct registry_list_entry *reg; +size_t nlen =strlen (key) +1 ; +size_t vlen;/* value length, non-zero if binary or string */ + +/* Set an arbitrary limit to avoid problems with broken command lines */ +if (nlen >64 ) +return -EFBIG ; + + vlen = (type ==REGISTRY_TABLE_ENTRY_TYPE_DWORD ) ?0 : length; + + reg =kmalloc (sizeof (struct registry_list_entry ) + nlen + vlen,GFP_KERNEL ); +if (!reg) +return -ENOMEM ;
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c r535_gsp_rpc_unloading_guest_driver(struct nvkm_gsp *gsp, bool suspend) · line 1176
Quoted 10 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +10
-0+ +switch (type) { +case REGISTRY_TABLE_ENTRY_TYPE_DWORD : + reg->v.dword = *(const u32 *)(data); +nvkm_debug (&gsp->subdev,"adding GSP-RM registry '%s=%u'\n" , + key, reg->v.dword); +break ; +case REGISTRY_TABLE_ENTRY_TYPE_BINARY : +case REGISTRY_TABLE_ENTRY_TYPE_STRING : + reg->v.binary = (void *)®->key + nlen;
I see, you just append the binary at the end of the struct. However, that messes with the __counted_by() of reg->key. I think we should do a separate allocation for binary and string types.
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c r535_gsp_rpc_unloading_guest_driver(struct nvkm_gsp *gsp, bool suspend) · line 1179
Quoted 3 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +3
-0+memcpy (reg->v.binary, data, length); + vlen = length; +if (type ==REGISTRY_TABLE_ENTRY_TYPE_BINARY )
If you want a debug print for each type, you could move them to a separate function with it's own switch case.
Quoted 304 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +256
-24+nvkm_debug (&gsp->subdev, +"adding GSP-RM registry '%s' blob of %zu bytes\n" , + key, length); + else + nvkm_debug(&gsp->subdev, +"adding GSP-RM registry string '%s=%s'\n" , + key, (char *)reg->v.binary); +break ; +default : +nvkm_error (&gsp->subdev,"unrecognized registry type %u for '%s'\n" , + type, key); +kfree (reg); +return -EINVAL ; + } + +memcpy (reg->key, key, nlen); + reg->klen = nlen; + reg->vlen = length; + reg->type = type; + +list_add_tail (®->head, &gsp->registry_list); + gsp->registry_rpc_size +=sizeof (PACKED_REGISTRY_ENTRY ) + nlen + vlen; + +return 0 ; +} + +static int add_registry_num (struct nvkm_gsp *gsp,const char *key,u32 value) +{ +return add_registry (gsp, key,REGISTRY_TABLE_ENTRY_TYPE_DWORD , + &value,sizeof (u32)); +} + +static int add_registry_string (struct nvkm_gsp *gsp,const char *key,const char *value) +{ +return add_registry (gsp, key,REGISTRY_TABLE_ENTRY_TYPE_STRING , + value,strlen (value) +1 ); +} + + +/** +* build_registry -- create the registry RPC data +* @gsp: gsp pointer +* @registry: pointer to the RPC payload to fill +* +* After all registry key/value pairs have been added, call this function to +* build the RPC. +* +* The registry RPC looks like this: +* +* +-----------------+ +* |NvU32 size; | +* |NvU32 numEntries;| +* +-----------------+ +* +---------------------+ +* |PACKED_REGISTRY_ENTRY| +* +---------------------+ +* |PACKED_REGISTRY_ENTRY| +* +---------------------+ +* ... (one copy for each entry) +* +* +----------------------------------------+ +* |Null-terminated key (string) for entry 0| +* +----------------------------------------+ +* |Binary/string data value for entry 0 | (only if necessary) +* +----------------------------------------+ +* |Null-terminated key (string) for entry 1| +* +----------------------------------------+ +* |Binary/string data value for entry 1 | (only if necessary) +* +----------------------------------------+ +* ... (one copy for each entry) +* +* +* The 'data' field of an entry is either a 32-bit integer (for type DWORD) +* or an offset into the PACKED_REGISTRY_TABLE (for types BINARY and STRING). +* +* All memory allocated by add_registry() is released. +*/ +static void build_registry (struct nvkm_gsp *gsp,PACKED_REGISTRY_TABLE *registry) +{ +struct registry_list_entry *reg, *n; +size_t str_offset; +unsigned int i =0 ; + + registry->numEntries =list_count_nodes (&gsp->registry_list); + str_offset =struct_size (registry, entries, registry->numEntries); + +list_for_each_entry_safe (reg, n, &gsp->registry_list, head) { + registry->entries[i].type = reg->type; + registry->entries[i].length = reg->klen; + +/* Copy the key name to the table */ + registry->entries[i].nameOffset = str_offset; +memcpy ((void *)registry + str_offset, reg->key, reg->klen); + str_offset += reg->klen; + +switch (reg->type) { +case REGISTRY_TABLE_ENTRY_TYPE_DWORD : + registry->entries[i].data = reg->v.dword; +break ; +case REGISTRY_TABLE_ENTRY_TYPE_BINARY : +case REGISTRY_TABLE_ENTRY_TYPE_STRING : +/* If the type is binary or string, copy the value */ +memcpy ((void *)registry + str_offset, reg->v.binary, reg->vlen); + registry->entries[i].data = str_offset; + str_offset += reg->vlen; +break ; +default : + } + + i++; +list_del (®->head); +kfree (reg); + } + +/* Double-check that we calculated the sizes correctly */ +WARN_ON (gsp->registry_rpc_size != str_offset); + + registry->size = gsp->registry_rpc_size; +} + +/** +* clean_registry -- clean up registry memory in case of error +* @gsp: gsp pointer +* +* Call this function to clean up all memory allocated by add_registry() +* in case of error and build_registry() is not called. +*/ +static void clean_registry (struct nvkm_gsp *gsp) +{ +struct registry_list_entry *reg, *n; + +list_for_each_entry_safe (reg, n, &gsp->registry_list, head) { +list_del (®->head); +kfree (reg); + } + + gsp->registry_rpc_size =sizeof (PACKED_REGISTRY_TABLE ); +} + +MODULE_PARM_DESC (NVreg_RegistryDwords, +"A semicolon-separated list of key=integer pairs of GSP-RM registry keys" ); +static char *NVreg_RegistryDwords; +module_param (NVreg_RegistryDwords, charp,0400 ); +/* dword only */ struct nv_gsp_registry_entries {const char *name;u32 value; }; +/** +* r535_registry_entries - required registry entries for GSP-RM +* +* This array lists registry entries that are required for GSP-RM to +* function correctly. +* +* RMSecBusResetEnable - enables PCI secondary bus reset +* RMForcePcieConfigSave - forces GSP-RM to preserve PCI configuration +* registers on any PCI reset. +*/ static const struct nv_gsp_registry_entries r535_registry_entries[] = { {"RMSecBusResetEnable" ,1 }, {"RMForcePcieConfigSave" ,1 }, };#define NV_GSP_REG_NUM_ENTRIES ARRAY_SIZE(r535_registry_entries) +/** +* strip - strips all characters in 'reject' from 's' +* @s: string to strip +* @reject: string of characters to remove +* +* 's' is modified. +* +* Returns the length of the new string. +*/ +static size_t strip (char *s,const char *reject) +{ +char *p = s, *p2 = s; +size_t length =0 ; +char c; + +do { +while ((c = *p2) &&strchr (reject, c)) + p2++; + + *p++ = c = *p2++; + length++; + }while (c); + +return length; +} + +/** +* r535_gsp_rpc_set_registry - build registry RPC and call GSP-RM +* @gsp: gsp pointer +* +* The GSP-RM registry is a set of key/value pairs that configure some aspects +* of GSP-RM. The keys are strings, and the values are 32-bit integers. +* +* The registry is built from a combination of a static hard-coded list (see +* above) and entries passed on the driver's command line. +*/ static int r535_gsp_rpc_set_registry (struct nvkm_gsp *gsp) {PACKED_REGISTRY_TABLE *rpc; -char *strings; -int str_offset; -int i; -size_t rpc_size =struct_size (rpc, entries,NV_GSP_REG_NUM_ENTRIES ); +unsigned int i; +int ret; -/* add strings + null terminator */ -for (i =0 ; i <NV_GSP_REG_NUM_ENTRIES ; i++) - rpc_size +=strlen (r535_registry_entries[i].name) +1 ; +INIT_LIST_HEAD (&gsp->registry_list); + gsp->registry_rpc_size =sizeof (PACKED_REGISTRY_TABLE ); - rpc =nvkm_gsp_rpc_get (gsp,NV_VGPU_MSG_FUNCTION_SET_REGISTRY , rpc_size); -if (IS_ERR (rpc)) -return PTR_ERR (rpc); +/* Add the required registry entries first */ +for (i =0 ; i <NV_GSP_REG_NUM_ENTRIES ; i++) { + ret =add_registry_num (gsp, r535_registry_entries[i].name, + r535_registry_entries[i].value); +if (ret) { +clean_registry (gsp); +return ret; + } + } + +/* +* The NVreg_RegistryDwords parameter is a string of key=value +* pairs separated by semicolons. We need to extract and trim each +* substring, and then parse the substring to extract the key and +* value. +*/ +if (NVreg_RegistryDwords) { +char *p =kstrdup (NVreg_RegistryDwords,GFP_KERNEL ); +char *start, *next = p, *equal; +size_t length; + +/* Remove any whitespace from the parameter string */ + length =strip (p," \t\n" ); + +while ((start =strsep (&next,";" ))) { +long value; + + equal =strchr (start,'=' ); +if (!equal || (equal == start) || (equal[1 ] ==0 )) { +nvkm_error (&gsp->subdev, +"ignoring invalid registry string '%s'\n" , start); +continue ; + } - rpc->numEntries =NV_GSP_REG_NUM_ENTRIES ; +/* Truncate the key=value string to just key */ + *equal =0 ; - str_offset = offsetof(typeof(*rpc), entries[NV_GSP_REG_NUM_ENTRIES]); - strings = (char *)&rpc->entries[NV_GSP_REG_NUM_ENTRIES ]; -for (i =0 ; i <NV_GSP_REG_NUM_ENTRIES ; i++) { -int name_len =strlen (r535_registry_entries[i].name) +1 ; - - rpc->entries[i].nameOffset = str_offset; - rpc->entries[i].type =1 ; - rpc->entries[i].data = r535_registry_entries[i].value; - rpc->entries[i].length =4 ; -memcpy (strings, r535_registry_entries[i].name, name_len); - strings += name_len; - str_offset += name_len; + ret =kstrtol (equal +1 ,0 , &value); +if (!ret) { + ret =add_registry_num (gsp, start, value); + }else { +/* Not a number, so treat it as a string */ + ret =add_registry_string (gsp, start, equal +1 ); + } + +if (ret) { +nvkm_error (&gsp->subdev, +"ignoring invalid registry key/value '%s=%s'\n" , + start, equal +1 ); +continue ; + } + + + } + +kfree (p); } - rpc->size = str_offset; + + rpc =nvkm_gsp_rpc_get (gsp,NV_VGPU_MSG_FUNCTION_SET_REGISTRY , gsp->registry_rpc_size); +if (IS_ERR (rpc)) { +clean_registry (gsp); +return PTR_ERR (rpc); + } + +build_registry (gsp, rpc);return nvkm_gsp_rpc_wr (gsp, rpc, false); }
Quoted 5 lines · Danilo Krummrich
Thanks for sending a new version of the patch.
Please make sure that for future patches you include a changelog, such that it's easier for reviewers to keep track of what has changed.
Will do.
Quoted 5 lines
Quoted 3 lines
.../gpu/drm/nouveau/include/nvkm/subdev/gsp.h | 6 + .../gpu/drm/nouveau/nvkm/subdev/gsp/r535.c | 375 ++++++++++++++++-- 2 files changed, 357 insertions(+), 24 deletions(-)There are a few issues pointed out by checkpatch.pl, that I think should be fixed.
checkpatch showed me nothing:
$ scripts/checkpatch.pl 0001-v4-nouveau-add-command-line-GSP-RM-registry- support.patch total: 0 errors, 0 warnings, 420 lines checked
0001-v4-nouveau-add-command-line-GSP-RM-registry-support.patch has no obvious style problems and is ready for submission.
Quoted 144 lines
Quoted 144 lines
drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h +2
-0@@ -211,6 +211,12 @@ struct nvkm_gsp { struct mutex mutex;; struct idr idr; } client_id; + +/* A linked list of registry items. The registry RPC will be built from it. */
drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h +4
-0+struct list_head registry_list; + +/* The size of the registry RPC */ +size_t registry_rpc_size;};
static inline booldrivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +0
-0@@ -54,6 +54,8 @@ #include <nvrm/535.113.01/nvidia/kernel/inc/vgpu/rpc_global_enums.h>
#include <linux/acpi.h>drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +2
-0+#include <linux/ctype.h> +#include <linux/parser.h>
#defineGSP_MSG_MIN_SIZEGSP_PAGE_SIZE
#defineGSP_MSG_MAX_SIZEGSP_PAGE_MIN_SIZE* 16drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +0
-0@@ -1082,51 +1084,376 @@ r535_gsp_rpc_unloading_guest_driver(struct nvkm_gsp *gsp, bool suspend) return nvkm_gsp_rpc_wr(gsp, rpc, true); }drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +2
-0+enum registry_type { +REGISTRY_TABLE_ENTRY_TYPE_DWORD =1 ,/* 32-bit unsigned integer */
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +2
-0+REGISTRY_TABLE_ENTRY_TYPE_BINARY =2 ,/* Binary blob */ + REGISTRY_TABLE_ENTRY_TYPE_STRING = 3, /* Null-terminated string*/
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +15
-0+}; + +/** +* registry_list_entry - linked list member for a registry key/value +* @head: list_head struct +* @type: dword, binary, or string +* @klen: the length of name of the key +* @vlen: the length of the value +* @v.dword: the data, if REGISTRY_TABLE_ENTRY_TYPE_DWORD +* @v.binary: the data, if TYPE_BINARY or TYPE_STRING +* @key: the key name +* +* Every registry key/value is represented internally by this struct. +* +* Type DWORD is a simple 32-bit unsigned integer, and its value is stored in
+ * v.dword.
+ *
+ * Types BINARY and STRING are variable-length binary blobs. The only real
+ * difference between BINARY and STRING is that STRING is null- terminated and
+ * is expected to contain only printable characters.
+ *
+ * To avoid having to kmalloc multiple objects, the value for BINARY and
+ * STRING is appended after the key[] in memory, and v.binary just points to
+ * that block.
+ *
+ * Note: it is technically possible to have multiple keys with the same name
+ * but different types, but this is not useful since GSP-RM expects keys to
+ * have only one specific type.
+ */drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +23
-0+struct registry_list_entry { +struct list_head head; +enum registry_type type; +size_t klen; +size_t vlen; +union { +u32 dword;/* TYPE_DWORD */ +void *binary;/* TYPE_BINARY or TYPE_STRING */ + } v; + char key[] __counted_by(klen); +}; + +/** +* add_registry -- adds a registry entry +* @gsp: gsp pointer +* @key: name of the registry key +* @type: type of data +* @data: pointer to value +* @length: size of data, in bytes +* +* Adds a registry key/value pair to the registry database. +* +* This function collects the registry information in a linked list. After
+ * all registry keys have been added,build_registry()is used to create the
+ * RPC data structure.
+ *
+ *registry_rpc_sizeis a running total of the size of all registry keys.
+ * It's used to avoid an O(n) calculation of the size when the RPC is built.
+ *
+ * Returns 0 on success, or negative error code on error.
+ */drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +2
-0+static int add_registry(struct nvkm_gsp *gsp, const char *key, + enum registry_type type, const void *data,
size_tlength)drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +6
-0+{ +struct registry_list_entry *reg; +size_t nlen =strlen (key) +1 ; +size_t vlen;/* value length, non-zero if binary or string */ + +/* Set an arbitrary limit to avoid problems with broken command lines */
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +6
-0+if (nlen >64 ) +return -EFBIG ; + + vlen = (type ==REGISTRY_TABLE_ENTRY_TYPE_DWORD ) ?0 : length; + + reg = kmalloc(sizeof(struct registry_list_entry) + nlen + vlen,
GFP_KERNEL);drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +7
-0+if (!reg) +return -ENOMEM ; + +switch (type) { +case REGISTRY_TABLE_ENTRY_TYPE_DWORD : + reg->v.dword = *(const u32 *)(data); + nvkm_debug(&gsp->subdev, "adding GSP-RM registry'%s=%u'\n",
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +3
-0+ key, reg->v.dword); +break ; +case REGISTRY_TABLE_ENTRY_TYPE_BINARY :
Quoted 8 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c r535_gsp_rpc_unloading_guest_driver(struct nvkm_gsp *gsp, bool suspend) · line 1176
Quoted 2 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +2
-0+case REGISTRY_TABLE_ENTRY_TYPE_STRING : + reg->v.binary = (void *)®->key + nlen;I see, you just append the binary at the end of the struct. However, that messes with
the__counted_by()ofreg->key. I think we should do a separate allocation for binary
and string types.
Since I arbitrarily restrict the key name to 64 characters, and since this is a small temporary struct, I can do this:
struct registry_list_entry {
struct list_head head;
enum registry_type type;
size_t klen;
size_t vlen;
u32 dword; /* if TYPE_DWORD */
char key[64] __counted_by(klen);
uint8_t value[] __counted_by(vlen); /* if TYPE_STRING or BINARY */
};Quoted 7 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c r535_gsp_rpc_unloading_guest_driver(struct nvkm_gsp *gsp, bool suspend) · line 1179
Quoted 3 lines
drivers/gpu/drm/nouveau/nvkm/subdev/gsp/r535.c +3
-0+memcpy (reg->v.binary, data, length); + vlen = length; +if (type ==REGISTRY_TABLE_ENTRY_TYPE_BINARY )If you want a debug print for each type, you could move them to a separate function with
it's own switch case.
I'll just remove them.
Quoted 15 lines · Timur Tabi
Quoted 5 lines · Danilo Krummrich
Thanks for sending a new version of the patch.
Please make sure that for future patches you include a changelog, such that it's easier for reviewers to keep track of what has changed.
Will do.
Quoted 5 lines
Quoted 3 lines
.../gpu/drm/nouveau/include/nvkm/subdev/gsp.h | 6 + .../gpu/drm/nouveau/nvkm/subdev/gsp/r535.c | 375 ++++++++++++++++-- 2 files changed, 357 insertions(+), 24 deletions(-)There are a few issues pointed out by checkpatch.pl, that I think should be fixed.
Quoted 8 lines
checkpatch showed me nothing:
$ scripts/checkpatch.pl 0001-v4-nouveau-add-command-line-GSP-RM-registry- support.patch total: 0 errors, 0 warnings, 420 lines checked0001-v4-nouveau-add-command-line-GSP-RM-registry-support.patch has no obvious style problems and is ready for submission.
I used '--strict'. I think we should get the kmalloc(), the blank lines and the alignment ones fixed.
- Danilo