From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 4BE27138359 for ; Fri, 18 Sep 2020 16:30:44 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 664D7E0815; Fri, 18 Sep 2020 16:30:43 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 3F00BE0815 for ; Fri, 18 Sep 2020 16:30:43 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id B7065340EC4 for ; Fri, 18 Sep 2020 16:30:41 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 2764F361 for ; Fri, 18 Sep 2020 16:30:40 +0000 (UTC) From: "Rui Huang" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Rui Huang" Message-ID: <1600446552.8cb3b1ab482d61d744c77fafa72c962c1a491474.vowstar@gentoo> Subject: [gentoo-commits] repo/proj/guru:dev commit in: sys-libs/libnvidia-container/, sys-libs/libnvidia-container/files/ X-VCS-Repository: repo/proj/guru X-VCS-Files: sys-libs/libnvidia-container/Manifest sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-c.patch sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-modprobe-utils-h.patch sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-info.patch sys-libs/libnvidia-container/files/libnvidia-container-1.3.0-fix-nvc-mount.patch sys-libs/libnvidia-container/libnvidia-container-1.3.0.ebuild X-VCS-Directories: sys-libs/libnvidia-container/files/ sys-libs/libnvidia-container/ X-VCS-Committer: vowstar X-VCS-Committer-Name: Rui Huang X-VCS-Revision: 8cb3b1ab482d61d744c77fafa72c962c1a491474 X-VCS-Branch: dev Date: Fri, 18 Sep 2020 16:30:40 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 1bc00092-bf87-477f-9d8e-0022d9bbf8e4 X-Archives-Hash: 74674c03e591f38b1f1e105387f7f8ef commit: 8cb3b1ab482d61d744c77fafa72c962c1a491474 Author: Huang Rui gmail com> AuthorDate: Fri Sep 18 16:25:43 2020 +0000 Commit: Rui Huang gmail 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 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 + + #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 + #include +-#include ++#include "nvidia-modprobe-utils.h" + #include + #include + #include 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 + #undef basename /* Use the GNU version of basename. */ + #include +-#include ++#include "nvidia-modprobe-utils.h" + #include + #include + #include 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 +)