Merge pull request #32 from r-burns/opengl-driver-link

Author: Mic92

README.md

@@ -103,6 +103,20 @@ The nix config is not in `/etc/nix` but in `/nix/etc/nix`, so that you can
 modify it. This is done with the `NIX_CONF_DIR`, which you can override at any
 time.
 
+Libraries and applications from Nixpkgs with OpenGL or CUDA support need to
+load libraries from /run/opengl-driver/lib. For convenience, nix-user-chroot
+will bind mount /nix/var/nix/opengl-driver/lib (if it exists) to this location.
+You will still need to link the system libraries here, as their original
+locations are distro-dependent. For example, for CUDA support on Ubuntu 20.04:
+
+```console
+$ mkdir -p /nix/var/nix/opengl-driver/lib
+$ ln -s /usr/lib/x86_64-linux-gnu/libcuda.so.1 /nix/var/nix/opengl-driver/lib
+```
+
+If this directory didn't exist when you first entered the nix user chroot, you
+will need to reenter for /run/opengl-driver/lib to be mounted.
+
 ## Whishlist
 
 These are features the author would like to see, let me know, if you want to work

src/main.rs

@@ -1,4 +1,3 @@
-use nix;
 use nix::mount::{mount, MsFlags};
 use nix::sched::{unshare, CloneFlags};
 use nix::sys::signal::{kill, Signal};
@@ -46,28 +45,52 @@ impl<'a> RunChroot<'a> {
 
     fn bind_mount_directory(&self, entry: &fs::DirEntry) {
         let mountpoint = self.rootdir.join(entry.file_name());
-        if let Err(e) = fs::create_dir(&mountpoint) {
-            if e.kind() != io::ErrorKind::AlreadyExists {
-                panic!("failed to create {}: {}", &mountpoint.display(), e);
+
+        // if the destination doesn't exist we can proceed as normal
+        if !mountpoint.exists() {
+            if let Err(e) = fs::create_dir(&mountpoint) {
+                if e.kind() != io::ErrorKind::AlreadyExists {
+                    panic!("failed to create {}: {}", &mountpoint.display(), e);
+                }
             }
-        }
 
-        bind_mount(&entry.path(), &mountpoint)
+            bind_mount(&entry.path(), &mountpoint)
+        } else {
+            // otherwise, if the dest is also a dir, we can recurse into it
+            // and mount subdirectory siblings of existing paths
+            if mountpoint.is_dir() {
+                let dir = fs::read_dir(entry.path()).unwrap_or_else(|err| {
+                    panic!("failed to list dir {}: {}", entry.path().display(), err)
+                });
+
+                let child = RunChroot::new(&mountpoint);
+                for entry in dir {
+                    let entry = entry.expect("error while listing subdir");
+                    child.bind_mount_direntry(&entry);
+                }
+            }
+        }
     }
 
     fn bind_mount_file(&self, entry: &fs::DirEntry) {
         let mountpoint = self.rootdir.join(entry.file_name());
+        if mountpoint.exists() {
+            return;
+        }
         fs::File::create(&mountpoint)
             .unwrap_or_else(|err| panic!("failed to create {}: {}", &mountpoint.display(), err));
 
         bind_mount(&entry.path(), &mountpoint)
     }
 
     fn mirror_symlink(&self, entry: &fs::DirEntry) {
+        let link_path = self.rootdir.join(entry.file_name());
+        if link_path.exists() {
+            return;
+        }
         let path = entry.path();
         let target = fs::read_link(&path)
             .unwrap_or_else(|err| panic!("failed to resolve symlink {}: {}", &path.display(), err));
-        let link_path = self.rootdir.join(entry.file_name());
         symlink(&target, &link_path).unwrap_or_else(|_| {
             panic!(
                 "failed to create symlink {} -> {}",
@@ -77,16 +100,12 @@ impl<'a> RunChroot<'a> {
         });
     }
 
-    fn bind_mount_direntry(&self, entry: io::Result<fs::DirEntry>) {
-        let entry = entry.expect("error while listing from /nix directory");
-        // do not bind mount an existing nix installation
-        if entry.file_name() == PathBuf::from("nix") {
-            return;
-        }
+    fn bind_mount_direntry(&self, entry: &fs::DirEntry) {
         let path = entry.path();
         let stat = entry
             .metadata()
             .unwrap_or_else(|err| panic!("cannot get stat of {}: {}", path.display(), err));
+
         if stat.is_dir() {
             self.bind_mount_directory(&entry);
         } else if stat.is_file() {
@@ -104,11 +123,26 @@ impl<'a> RunChroot<'a> {
 
         unshare(CloneFlags::CLONE_NEWNS | CloneFlags::CLONE_NEWUSER).expect("unshare failed");
 
-        // bind mount all / stuff into rootdir
+        // create /run/opengl-driver/lib in chroot, to behave like NixOS
+        // (needed for nix pkgs with OpenGL or CUDA support to work)
+        let ogldir = nixdir.join("var/nix/opengl-driver/lib");
+        if ogldir.is_dir() {
+            let ogl_mount = self.rootdir.join("run/opengl-driver/lib");
+            fs::create_dir_all(&ogl_mount)
+                .unwrap_or_else(|err| panic!("failed to create {}: {}", &ogl_mount.display(), err));
+            bind_mount(&ogldir, &ogl_mount);
+        }
+
+        // bind the rest of / stuff into rootdir
         let nix_root = PathBuf::from("/");
         let dir = fs::read_dir(&nix_root).expect("failed to list /nix directory");
         for entry in dir {
-            self.bind_mount_direntry(entry);
+            let entry = entry.expect("error while listing from /nix directory");
+            // do not bind mount an existing nix installation
+            if entry.file_name() == PathBuf::from("nix") {
+                continue;
+            }
+            self.bind_mount_direntry(&entry);
         }
 
         // mount the store

src/mkdtemp.rs

@@ -3,7 +3,6 @@ use std::env;
 use std::ffi::OsString;
 use std::os::unix::ffi::OsStringExt;
 use std::path::PathBuf;
-use std::ptr;
 
 mod ffi {
     extern "C" {
@@ -18,7 +17,7 @@ pub fn mkdtemp(template: &str) -> nix::Result<PathBuf> {
     buf.push(b'\0'); // make a c string
 
     let res = unsafe { ffi::mkdtemp(buf.as_mut_ptr() as *mut libc::c_char) };
-    if res == ptr::null_mut() {
+    if res.is_null() {
         Err(nix::Error::Sys(Errno::last()))
     } else {
         buf.pop(); // strip null byte