[gentoo-commits] repo/proj/guru:dev commit in: sys-libs/libnvidia-container/, sys-libs/libnvidia-container/files/

["Rui Huang" <vowstar@gmail.com>]

commit:     8cb3b1ab482d61d744c77fafa72c962c1a491474
Author:     Huang Rui <vowstar <AT> gmail <DOT> com>
AuthorDate: Fri Sep 18 16:25:43 2020 +0000
Commit:     Rui Huang <vowstar <AT> gmail <DOT> com>
CommitDate: Fri Sep 18 16:29:12 2020 +0000
URL:        https://gitweb.gentoo.org/repo/proj/guru.git/commit/?id=8cb3b1ab

sys-libs/libnvidia-container: bump to 1.3.0

Package-Manager: Portage-3.0.7, Repoman-3.0.1
Signed-off-by: Huang Rui <vowstar <AT> gmail.com>

 sys-libs/libnvidia-container/Manifest              |   1 +
 ...idia-container-1.3.0-fix-modprobe-utils-c.patch | 567 +++++++++++++++++++++
 ...idia-container-1.3.0-fix-modprobe-utils-h.patch | 118 +++++
 .../libnvidia-container-1.3.0-fix-nvc-info.patch   |  11 +
 .../libnvidia-container-1.3.0-fix-nvc-mount.patch  |  11 +
 .../libnvidia-container-1.3.0.ebuild               |  53 ++
 6 files changed, 761 insertions(+)

diff --git a/sys-libs/libnvidia-container/Manifest b/sys-libs/libnvidia-container/Manifest
index e8471951..3bfcaa61 100644
--- a/sys-libs/libnvidia-container/Manifest
+++ b/sys-libs/libnvidia-container/Manifest
@@ -1 +1,2 @@
 DIST libnvidia-container-1.2.0.tar.gz 152533 BLAKE2B fb4c931abf566747bb337d6ce4a6489611248a4828f2e67821ce573c1f3259c47cc735d24f80359de559545c742c37325c3f13209fccc875f9b29fbae0699cca SHA512 75d0d0280c73d4ed830bb4315dc2d6bb8852013a30dfc533429d084ad405b5a56d718cb547d7dd07a4080702afb6bc95a9fa21cf440328e252343aa3eafc13aa
+DIST libnvidia-container-1.3.0.tar.gz 155337 BLAKE2B 987433597347d21c14a7c1437d82e45dbf48a6f284810882db44120955fe7fc582038abf1df11a71e76699b4cd30347ac92f22b97d79d15528762321e1147450 SHA512 29df0d04576ff9f425c576dbcd1d80dc85e72c8217dba553c3025c3acc83388c6d3695f26c8c86e6a7cc6a1e1328cc8985161ae4e88d6151379283ed67552bb4

diff --git a/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-c.patch b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-c.patch
new file mode 100644
index 00000000..5aa8d265
--- /dev/null
+++ b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-c.patch
@@ -0,0 +1,567 @@
+--- a/src/nvidia-modprobe-utils.c	2020-09-18 18:11:57.042187266 +0800
++++ b/src/nvidia-modprobe-utils.c	2020-09-18 18:25:49.318472815 +0800
+@@ -1,3 +1,29 @@
++/*
++ * Copyright (c) 2013, NVIDIA CORPORATION.
++ *
++ * Permission is hereby granted, free of charge, to any person
++ * obtaining a copy of this software and associated documentation
++ * files (the "Software"), to deal in the Software without
++ * restriction, including without limitation the rights to use, copy,
++ * modify, merge, publish, distribute, sublicense, and/or sell copies
++ * of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be
++ * included in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
++ * SOFTWARE.
++ *
++ * This file provides utility functions on Linux for loading the
++ * NVIDIA kernel module and creating NVIDIA device files.
++ */
+ 
+ #if defined(NV_LINUX)
+ 
+@@ -27,9 +53,6 @@
+ #define NV_NVIDIA_MODULE_NAME "nvidia"
+ #define NV_PROC_REGISTRY_PATH "/proc/driver/nvidia/params"
+ 
+-#define NV_NMODULE_NVIDIA_MODULE_NAME "nvidia%d"
+-#define NV_NMODULE_PROC_REGISTRY_PATH "/proc/driver/nvidia/%d/params"
+-
+ #define NV_UVM_MODULE_NAME "nvidia-uvm"
+ #define NV_UVM_DEVICE_NAME "/dev/nvidia-uvm"
+ #define NV_UVM_TOOLS_DEVICE_NAME "/dev/nvidia-uvm-tools"
+@@ -41,12 +64,16 @@
+ #define NV_NVLINK_MODULE_NAME "nvidia-nvlink"
+ #define NV_NVLINK_PROC_PERM_PATH "/proc/driver/nvidia-nvlink/permissions"
+ 
++#define NV_NVSWITCH_MODULE_NAME "nvidia-nvswitch"
++#define NV_NVSWITCH_PROC_PERM_PATH "/proc/driver/nvidia-nvswitch/permissions"
++
+ #define NV_DEVICE_FILE_MODE_MASK (S_IRWXU|S_IRWXG|S_IRWXO)
+ #define NV_DEVICE_FILE_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
+ #define NV_DEVICE_FILE_UID 0
+ #define NV_DEVICE_FILE_GID 0
+ 
+-#define NV_MAKE_DEVICE(x,y) ((dev_t)((x) << 8 | (y)))
++#define NV_MAKE_DEVICE(major, minor) \
++    ((dev_t)((minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12)))
+ 
+ #define NV_MAJOR_DEVICE_NUMBER 195
+ 
+@@ -55,84 +82,6 @@
+ #define NV_MIN(a, b) (((a) < (b)) ? (a) : (b))
+ 
+ /*
+- * Construct the nvidia kernel module name based on the input
+- * module instance provided.  If an error occurs, the null
+- * terminator will be written to nv_module_name[0].
+- */
+-static __inline__ void assign_nvidia_kernel_module_name
+-(
+-    char nv_module_name[NV_MAX_MODULE_NAME_SIZE],
+-    int module_instance
+-)
+-{
+-    int ret;
+-
+-    if (is_multi_module(module_instance))
+-    {
+-        ret = snprintf(nv_module_name, NV_MAX_MODULE_NAME_SIZE,
+-                       NV_NMODULE_NVIDIA_MODULE_NAME, module_instance);
+-    }
+-    else
+-    {
+-        ret = snprintf(nv_module_name, NV_MAX_MODULE_NAME_SIZE,
+-                       NV_NVIDIA_MODULE_NAME);
+-    }
+-
+-    if (ret <= 0)
+-    {
+-        goto fail;
+-    }
+-
+-    nv_module_name[NV_MAX_MODULE_NAME_SIZE - 1] = '\0';
+-
+-    return;
+-
+-fail:
+-
+-    nv_module_name[0] = '\0';
+-}
+-
+-
+-/*
+- * Construct the proc registry path name based on the input
+- * module instance provided.  If an error occurs, the null
+- * terminator will be written to proc_path[0].
+- */
+-static __inline__ void assign_proc_registry_path
+-(
+-    char proc_path[NV_MAX_PROC_REGISTRY_PATH_SIZE],
+-    int module_instance
+-)
+-{
+-    int ret;
+-
+-    if (is_multi_module(module_instance))
+-    {
+-        ret = snprintf(proc_path, NV_MAX_PROC_REGISTRY_PATH_SIZE,
+-                       NV_NMODULE_PROC_REGISTRY_PATH, module_instance);
+-    }
+-    else
+-    {
+-        ret = snprintf(proc_path, NV_MAX_PROC_REGISTRY_PATH_SIZE,
+-                       NV_PROC_REGISTRY_PATH);
+-    }
+-
+-    if (ret <= 0)
+-    {
+-        goto fail;
+-    }
+-
+-    proc_path[NV_MAX_PROC_REGISTRY_PATH_SIZE - 1] = '\0';
+-
+-    return;
+-
+-fail:
+-
+-    proc_path[0] = '\0';
+-}
+-
+-
+-/*
+  * Just like strcmp(3), except that differences between '-' and '_' are
+  * ignored. This is useful for comparing module names, where '-' and '_'
+  * are supposed to be treated interchangeably.
+@@ -370,18 +319,20 @@
+             return 0;
+ 
+         default:
+-            if (waitpid(pid, &status, 0) < 0)
+-            {
+-                return 0;
+-            }
+-            if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
+-            {
+-                return 1;
+-            }
+-            else
+-            {
+-                return 0;
+-            }
++            /*
++             * waitpid(2) is not always guaranteed to return success even if
++             * the child terminated normally.  For example, if the process
++             * explicitly configured the handling of the SIGCHLD signal
++             * to SIG_IGN, then waitpid(2) will instead block until all
++             * children terminate and return the error ECHILD, regardless
++             * of the child's exit codes.
++             *
++             * Hence, ignore waitpid(2) error codes and instead check
++             * whether the desired kernel module is loaded.
++             */
++            waitpid(pid, NULL, 0);
++
++            return is_kernel_module_loaded(module_name);
+     }
+ 
+     return 1;
+@@ -391,13 +342,9 @@
+ /*
+  * Attempt to load an NVIDIA kernel module
+  */
+-int nvidia_modprobe(const int print_errors, int module_instance)
++int nvidia_modprobe(const int print_errors)
+ {
+-    char nv_module_name[NV_MAX_MODULE_NAME_SIZE];
+-
+-    assign_nvidia_kernel_module_name(nv_module_name, module_instance);
+-
+-    return modprobe_helper(print_errors, nv_module_name);
++    return modprobe_helper(print_errors, NV_NVIDIA_MODULE_NAME);
+ }
+ 
+ 
+@@ -447,7 +394,8 @@
+         {
+             *mode = value;
+         }
+-        if (strcmp(name, "ModifyDeviceFiles") == 0)
++        if ((strcmp(name, "ModifyDeviceFiles") == 0) ||
++            (strcmp(name, "DeviceFileModify") == 0))
+         {
+             *modify = value;
+         }
+@@ -456,7 +404,7 @@
+     fclose(fp);
+ }
+ 
+-/* 
++/*
+  * A helper to query device file states.
+  */
+ static int get_file_state_helper(
+@@ -494,24 +442,22 @@
+     return state;
+ }
+ 
+-int nvidia_get_file_state(int minor, int module_instance)
++int nvidia_get_file_state(int minor)
+ {
+     char path[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
+-    char proc_path[NV_MAX_PROC_REGISTRY_PATH_SIZE];
+     mode_t mode;
+     uid_t uid;
+     gid_t gid;
+     int modification_allowed;
+     int state = 0;
+ 
+-    assign_device_file_name(path, minor, module_instance);
+-    assign_proc_registry_path(proc_path, module_instance);
++    assign_device_file_name(path, minor);
+ 
+     init_device_file_parameters(&uid, &gid, &mode, &modification_allowed,
+-                                proc_path);
++                                NV_PROC_REGISTRY_PATH);
+ 
+     state = get_file_state_helper(path, NV_MAJOR_DEVICE_NUMBER, minor,
+-                                  proc_path, uid, gid, mode);
++                                  NV_PROC_REGISTRY_PATH, uid, gid, mode);
+ 
+     return state;
+ }
+@@ -522,8 +468,8 @@
+  * permissions.  Returns 1 if the file is successfully created; returns 0
+  * if the file could not be created.
+  */
+-int mknod_helper(int major, int minor, const char *path,
+-                 const char *proc_path)
++static int mknod_helper(int major, int minor, const char *path,
++                        const char *proc_path)
+ {
+     dev_t dev = NV_MAKE_DEVICE(major, minor);
+     mode_t mode;
+@@ -616,15 +562,13 @@
+  * Attempt to create a device file with the specified minor number for
+  * the specified NVIDIA module instance.
+  */
+-int nvidia_mknod(int minor, int module_instance)
++int nvidia_mknod(int minor)
+ {
+     char path[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
+-    char proc_path[NV_MAX_PROC_REGISTRY_PATH_SIZE];
+ 
+-    assign_device_file_name(path, minor, module_instance);
+-    assign_proc_registry_path(proc_path, module_instance);
++    assign_device_file_name(path, minor);
+ 
+-    return mknod_helper(NV_MAJOR_DEVICE_NUMBER, minor, path, proc_path);
++    return mknod_helper(NV_MAJOR_DEVICE_NUMBER, minor, path, NV_PROC_REGISTRY_PATH);
+ }
+ 
+ 
+@@ -633,7 +577,7 @@
+  * device with the specified name.  Returns the major number on success,
+  * or -1 on failure.
+  */
+-int get_chardev_major(const char *name)
++int nvidia_get_chardev_major(const char *name)
+ {
+     int ret = -1;
+     char line[NV_MAX_LINE_LENGTH];
+@@ -702,13 +646,86 @@
+     return ret;
+ }
+ 
++int nvidia_nvlink_get_file_state(void)
++{
++    char path[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
++    mode_t mode;
++    uid_t uid;
++    gid_t gid;
++    int modification_allowed;
++    int ret;
++    int major = nvidia_get_chardev_major(NV_NVLINK_MODULE_NAME);
++
++    if (major < 0)
++    {
++        path[0] = '\0';
++        goto done;
++    }
++
++    ret = snprintf(path, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                   NV_NVLINK_DEVICE_NAME);
++
++    if (ret < 0 || ret >= NV_MAX_CHARACTER_DEVICE_FILE_STRLEN)
++    {
++        path[0] = '\0';
++    }
++
++done:
++
++    init_device_file_parameters(&uid, &gid, &mode, &modification_allowed,
++                                NV_NVLINK_PROC_PERM_PATH);
++
++    return get_file_state_helper(path, major, 0,
++                                 NV_NVLINK_PROC_PERM_PATH, uid, gid, mode);
++}
++
++int nvidia_nvswitch_get_file_state(int minor)
++{
++    char path[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
++    mode_t mode;
++    uid_t uid;
++    gid_t gid;
++    int modification_allowed;
++    int ret;
++    int major = nvidia_get_chardev_major(NV_NVSWITCH_MODULE_NAME);
++
++    if ((major < 0) || (minor < 0) || (minor > NV_NVSWITCH_CTL_MINOR))
++    {
++        path[0] = '\0';
++        goto done;
++    }
++
++    if (minor == NV_NVSWITCH_CTL_MINOR)
++    {
++        ret = snprintf(path, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                       NV_NVSWITCH_CTL_NAME);
++    }
++    else
++    {
++        ret = snprintf(path, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                       NV_NVSWITCH_DEVICE_NAME, minor);
++    }
++
++    if (ret < 0 || ret >= NV_MAX_CHARACTER_DEVICE_FILE_STRLEN)
++    {
++        path[0] = '\0';
++    }
++
++done:
++
++    init_device_file_parameters(&uid, &gid, &mode, &modification_allowed,
++                                NV_NVSWITCH_PROC_PERM_PATH);
++
++    return get_file_state_helper(path, major, minor,
++                                 NV_NVSWITCH_PROC_PERM_PATH, uid, gid, mode);
++}
+ 
+ /*
+  * Attempt to create the NVIDIA Unified Memory device file
+  */
+ int nvidia_uvm_mknod(int base_minor)
+ {
+-    int major = get_chardev_major(NV_UVM_MODULE_NAME);
++    int major = nvidia_get_chardev_major(NV_UVM_MODULE_NAME);
+ 
+     if (major < 0)
+     {
+@@ -743,13 +760,9 @@
+  */
+ int nvidia_modeset_mknod(void)
+ {
+-    char proc_path[NV_MAX_PROC_REGISTRY_PATH_SIZE];
+-
+-    assign_proc_registry_path(proc_path, NV_MODULE_INSTANCE_NONE);
+-
+     return mknod_helper(NV_MAJOR_DEVICE_NUMBER,
+                         NV_MODESET_MINOR_DEVICE_NUM,
+-                        NV_MODESET_DEVICE_NAME, proc_path);
++                        NV_MODESET_DEVICE_NAME, NV_PROC_REGISTRY_PATH);
+ }
+ 
+ /*
+@@ -757,7 +770,7 @@
+  */
+ int nvidia_nvlink_mknod(void)
+ {
+-    int major = get_chardev_major(NV_NVLINK_MODULE_NAME);
++    int major = nvidia_get_chardev_major(NV_NVLINK_MODULE_NAME);
+ 
+     if (major < 0)
+     {
+@@ -770,25 +783,164 @@
+                         NV_NVLINK_PROC_PERM_PATH);
+ }
+ 
++/*
++ * Attempt to create the NVIDIA NVSwitch driver device files.
++ */
++int nvidia_nvswitch_mknod(int minor)
++{
++    int major = 0;
++    char name[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
++    int ret;
++
++    major = nvidia_get_chardev_major(NV_NVSWITCH_MODULE_NAME);
++
++    if (major < 0)
++    {
++        return 0;
++    }
++
++    if (minor == NV_NVSWITCH_CTL_MINOR)
++    {
++        ret = snprintf(name, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                       NV_NVSWITCH_CTL_NAME);
++    }
++    else
++    {
++        ret = snprintf(name, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                       NV_NVSWITCH_DEVICE_NAME, minor);
++    }
++
++    if (ret < 0 || ret >= NV_MAX_CHARACTER_DEVICE_FILE_STRLEN)
++    {
++        return 0;
++    }
++
++    return mknod_helper(major, minor, name, NV_NVSWITCH_PROC_PERM_PATH);
++}
++
+ int nvidia_vgpu_vfio_mknod(int minor_num)
+ {
+-    int major = get_chardev_major(NV_VGPU_VFIO_MODULE_NAME);
++    int major = nvidia_get_chardev_major(NV_VGPU_VFIO_MODULE_NAME);
+     char vgpu_dev_name[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
+-    char proc_path[NV_MAX_PROC_REGISTRY_PATH_SIZE];
++    int ret;
+ 
+     if (major < 0)
+     {
+         return 0;
+     }
+ 
+-    assign_proc_registry_path(proc_path, NV_MODULE_INSTANCE_NONE);
+-
+-    snprintf(vgpu_dev_name, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
+-             NV_VGPU_VFIO_DEVICE_NAME, minor_num);
++    ret = snprintf(vgpu_dev_name, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                   NV_VGPU_VFIO_DEVICE_NAME, minor_num);
++    if (ret <= 0)
++    {
++        return 0;
++    }
+ 
+     vgpu_dev_name[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN - 1] = '\0';
+ 
+-    return mknod_helper(major, minor_num, vgpu_dev_name, proc_path);
++    return mknod_helper(major, minor_num, vgpu_dev_name, NV_PROC_REGISTRY_PATH);
++}
++
++int nvidia_cap_get_device_file_attrs(const char* cap_file_path,
++                                            int *major,
++                                            int *minor,
++                                            char *name)
++{
++    char field[32];
++    FILE *fp;
++    int value;
++    int ret;
++
++    *major = nvidia_get_chardev_major(NV_CAPS_MODULE_NAME);
++
++    if (*major < 0)
++    {
++        return 0;
++    }
++
++    fp = fopen(cap_file_path, "r");
++
++    if (fp == NULL)
++    {
++        return 0;
++    }
++
++    *minor = -1;
++
++    while (fscanf(fp, "%31[^:]: %d\n", field, &value) == 2)
++    {
++        field[31] = '\0';
++        if (strcmp(field, "DeviceFileMinor") == 0)
++        {
++            *minor = value;
++            break;
++        }
++    }
++
++    fclose(fp);
++
++    if (*minor < 0)
++    {
++        return 0;
++    }
++
++    ret = snprintf(name, NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
++                   NV_CAP_DEVICE_NAME, *minor);
++
++    if (ret < 0 || ret >= NV_MAX_CHARACTER_DEVICE_FILE_STRLEN)
++    {
++        return 0;
++    }
++
++    return 1;
++}
++
++/*
++ * Attempt to create the NVIDIA capability device files.
++ */
++int nvidia_cap_mknod(const char* cap_file_path, int *minor)
++{
++    int major;
++    char name[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
++    int ret;
++
++    ret = nvidia_cap_get_device_file_attrs(cap_file_path, &major, minor, name);
++    if (ret == 0)
++    {
++        return 0;
++    }
++
++    ret = mkdir("/dev/"NV_CAPS_MODULE_NAME, 0755);
++    if ((ret != 0) && (errno != EEXIST))
++    {
++        return 0;
++    }
++
++    return mknod_helper(major, *minor, name, cap_file_path);
++}
++
++int nvidia_cap_get_file_state(const char* cap_file_path)
++{
++    char path[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN];
++    mode_t mode;
++    uid_t uid;
++    gid_t gid;
++    int modification_allowed;
++    int ret;
++    int major;
++    int minor;
++
++    ret = nvidia_cap_get_device_file_attrs(cap_file_path, &major, &minor, path);
++    if (ret == 0)
++    {
++        path[0] = '\0';
++    }
++
++    init_device_file_parameters(&uid, &gid, &mode, &modification_allowed,
++                                cap_file_path);
++
++    return get_file_state_helper(path, major, minor,
++                                 cap_file_path, uid, gid, mode);
+ }
+ 
+-#endif /* NV_LINUX */
+\ No newline at end of file
++#endif /* NV_LINUX */

diff --git a/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-h.patch b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-h.patch
new file mode 100644
index 00000000..ee0ffbe0
--- /dev/null
+++ b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-h.patch
@@ -0,0 +1,118 @@
+--- a/src/nvidia-modprobe-utils.h	2020-09-18 18:11:57.046187358 +0800
++++ b/src/nvidia-modprobe-utils.h	2020-09-18 23:35:14.062948666 +0800
+@@ -31,29 +31,20 @@
+ #include <stdio.h>
+ 
+ #define NV_MAX_CHARACTER_DEVICE_FILE_STRLEN  128
+-#define NV_MODULE_INSTANCE_NONE              -1
+-#define NV_MODULE_INSTANCE_ZERO              0
+-#define NV_MAX_MODULE_INSTANCES              8
+ #define NV_CTL_DEVICE_NUM                    255
+ #define NV_MODESET_MINOR_DEVICE_NUM          254
+-
+-#define NV_FRONTEND_CONTROL_DEVICE_MINOR_MAX NV_CTL_DEVICE_NUM
++#define NV_NVSWITCH_CTL_MINOR                255
+ 
+ #define NV_DEVICE_FILE_PATH "/dev/nvidia%d"
+ #define NV_CTRL_DEVICE_FILE_PATH "/dev/nvidiactl"
+ #define NV_MODESET_DEVICE_NAME "/dev/nvidia-modeset"
+ #define NV_VGPU_VFIO_DEVICE_NAME "/dev/nvidia-vgpu%d"
+ #define NV_NVLINK_DEVICE_NAME "/dev/nvidia-nvlink"
++#define NV_NVSWITCH_CTL_NAME "/dev/nvidia-nvswitchctl"
++#define NV_NVSWITCH_DEVICE_NAME "/dev/nvidia-nvswitch%d"
+ 
+-#define NV_NMODULE_CTRL_DEVICE_FILE_PATH "/dev/nvidiactl%d"
+-
+-#define NV_FRONTEND_CONTROL_DEVICE_MINOR_MIN \
+-    (NV_FRONTEND_CONTROL_DEVICE_MINOR_MAX - \
+-     NV_MAX_MODULE_INSTANCES)
+-
+-#define NV_FRONTEND_IS_CONTROL_DEVICE(x) \
+-    ((x <= NV_FRONTEND_CONTROL_DEVICE_MINOR_MAX) && \
+-     (x > NV_FRONTEND_CONTROL_DEVICE_MINOR_MIN))
++#define NV_CAPS_MODULE_NAME "nvidia-caps"
++#define NV_CAP_DEVICE_NAME "/dev/" NV_CAPS_MODULE_NAME "/nvidia-cap%d"
+ 
+ #if defined(NV_LINUX)
+ 
+@@ -76,40 +67,33 @@
+     return !!(state & (1 << value));
+ }
+ 
+-int nvidia_get_file_state(int minor, int module_instance);
+-int nvidia_modprobe(const int print_errors, int module_instance);
+-int nvidia_mknod(int minor, int module_instance);
++int nvidia_get_file_state(int minor);
++int nvidia_modprobe(const int print_errors);
++int nvidia_mknod(int minor);
+ int nvidia_uvm_modprobe(void);
+ int nvidia_uvm_mknod(int base_minor);
+ int nvidia_modeset_modprobe(void);
+ int nvidia_modeset_mknod(void);
+ int nvidia_vgpu_vfio_mknod(int minor_num);
+ int nvidia_nvlink_mknod(void);
+-
+-int mknod_helper(int major, int minor, const char *path, const char *proc_path);
+-int get_chardev_major(const char *name);
++int nvidia_nvlink_get_file_state(void);
++int nvidia_nvswitch_mknod(int minor);
++int nvidia_nvswitch_get_file_state(int minor);
++int nvidia_cap_mknod(const char* cap_file_path, int *minor);
++int nvidia_cap_get_file_state(const char* cap_file_path);
++int nvidia_cap_get_device_file_attrs(const char* cap_file_path, int *major, int *minor, char *name);
++int nvidia_get_chardev_major(const char *name);
+ 
+ #endif /* NV_LINUX */
+ 
+ /*
+- * Detect use of multiple kernel module instances. Use a single 
+- * module instance unless instance != NV_MODULE_INSTANCE_NONE
+- */
+-static __inline__ int is_multi_module(int module_instance)
+-{
+-    return (module_instance != NV_MODULE_INSTANCE_NONE);
+-}
+-
+-
+-/*
+  * Construct the device file name, based on 'minor'.  If an error
+  * occurs, the nul terminator will be written to name[0].
+  */
+ static __inline__ void assign_device_file_name
+ (
+     char name[NV_MAX_CHARACTER_DEVICE_FILE_STRLEN],
+-    int minor,
+-    int module_instance
++    int minor
+ )
+ {
+     int ret;
+@@ -119,20 +102,12 @@
+         goto fail;
+     }
+ 
+-    if (!is_multi_module(module_instance) && minor == NV_CTL_DEVICE_NUM)
++    if (minor == NV_CTL_DEVICE_NUM)
+     {
+         ret = snprintf(name,
+                        NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
+                        NV_CTRL_DEVICE_FILE_PATH);
+     }
+-    else if (is_multi_module(module_instance) && 
+-             NV_FRONTEND_IS_CONTROL_DEVICE(minor))
+-    {
+-        ret = snprintf(name,
+-                       NV_MAX_CHARACTER_DEVICE_FILE_STRLEN,
+-                       NV_NMODULE_CTRL_DEVICE_FILE_PATH,
+-                       module_instance);
+-    }
+     else
+     {
+         ret = snprintf(name,
+@@ -154,4 +129,4 @@
+     name[0] = '\0';
+ }
+ 
+-#endif /* __NVIDIA_MODPROBE_UTILS_H__ */
+\ No newline at end of file
++#endif /* __NVIDIA_MODPROBE_UTILS_H__ */

diff --git a/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-info.patch b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-info.patch
new file mode 100644
index 00000000..bdac1e98
--- /dev/null
+++ b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-info.patch
@@ -0,0 +1,11 @@
+--- a/src/nvc_info.c	2020-09-16 20:30:14.000000000 +0800
++++ b/src/nvc_info.c	2020-09-18 18:06:55.562176348 +0800
+@@ -6,7 +6,7 @@
+ 
+ #include <errno.h>
+ #include <limits.h>
+-#include <nvidia-modprobe-utils.h>
++#include "nvidia-modprobe-utils.h"
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>

diff --git a/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-mount.patch b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-mount.patch
new file mode 100644
index 00000000..af35372d
--- /dev/null
+++ b/sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-mount.patch
@@ -0,0 +1,11 @@
+--- a/src/nvc_mount.c	2020-09-16 20:30:14.000000000 +0800
++++ b/src/nvc_mount.c	2020-09-18 18:00:17.984906768 +0800
+@@ -10,7 +10,7 @@
+ #include <libgen.h>
+ #undef basename /* Use the GNU version of basename. */
+ #include <limits.h>
+-#include <nvidia-modprobe-utils.h>
++#include "nvidia-modprobe-utils.h"
+ #include <stdio.h>
+ #include <string.h>
+ #include <sched.h>

diff --git a/sys-libs/libnvidia-container/libnvidia-container-1.3.0.ebuild b/sys-libs/libnvidia-container/libnvidia-container-1.3.0.ebuild
new file mode 100644
index 00000000..243b06d4
--- /dev/null
+++ b/sys-libs/libnvidia-container/libnvidia-container-1.3.0.ebuild
@@ -0,0 +1,53 @@
+# Copyright 1999-2020 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+EAPI=7
+
+DESCRIPTION="NVIDIA container runtime library"
+HOMEPAGE="https://github.com/NVIDIA/libnvidia-container"
+
+if [[ "${PV}" == "9999" ]] ; then
+	inherit git-r3
+	EGIT_REPO_URI="https://github.com/NVIDIA/${PN}.git"
+else
+	SRC_URI="
+		https://github.com/NVIDIA/${PN}/archive/v${PV}.tar.gz -> ${P}.tar.gz
+	"
+	KEYWORDS="~amd64"
+fi
+
+LICENSE="Apache-2.0"
+SLOT="0"
+
+IUSE=""
+
+RDEPEND="
+	net-libs/libtirpc
+	sys-libs/libcap
+	sys-libs/libseccomp
+	x11-drivers/nvidia-drivers
+"
+
+DEPEND="${RDEPEND}"
+
+BDEPEND="
+	net-libs/rpcsvc-proto
+	sys-apps/lsb-release
+	sys-devel/bmake
+	virtual/pkgconfig
+"
+
+PATCHES=(
+	"${FILESDIR}"/${PN}-1.1.1-add-enum-h.patch
+	"${FILESDIR}"/${PN}-1.1.1-add-sysfs-c.patch
+	"${FILESDIR}"/${PN}-1.1.1-add-sysfs-h.patch
+	"${FILESDIR}"/${PN}-1.1.1-add-utils-c.patch
+	"${FILESDIR}"/${PN}-1.1.1-add-utils-h.patch
+	"${FILESDIR}"/${PN}-1.1.1-fix-git.patch
+	"${FILESDIR}"/${PN}-1.1.1-fix-makefile.patch
+	"${FILESDIR}"/${PN}-1.1.1-fix-nvc.patch
+	"${FILESDIR}"/${PN}-1.3.0-fix-nvc-info.patch
+	"${FILESDIR}"/${PN}-1.3.0-fix-nvc-mount.patch
+	"${FILESDIR}"/${PN}-1.3.0-fix-modprobe-utils-c.patch
+	"${FILESDIR}"/${PN}-1.3.0-fix-modprobe-utils-h.patch
+)