Introduction

Anbox and Waydroid offer powerful ways to run Android applications on Linux, leveraging containerization for performance and integration. However, a common challenge users face is seamless file sharing between the host Linux system and the Android guest environment. While basic methods like ADB push/pull exist, they are cumbersome for frequent or large-scale data exchange. This article delves into an elegant and robust solution: Filesystem in Userspace (FUSE), enabling a truly integrated file sharing experience.

By harnessing FUSE, we can create virtual filesystems that present host directories directly within the Android container, complete with proper permissions and real-time synchronization. This guide provides an expert-level, step-by-step walkthrough for configuring FUSE-based file sharing for both Anbox and Waydroid.

Understanding FUSE: Filesystem in Userspace

FUSE is a powerful mechanism in Linux that allows non-privileged users to create their own filesystems without modifying kernel code. Instead of residing in the kernel, a FUSE filesystem operates in user space, communicating with the kernel through a special API. This architecture offers immense flexibility and security benefits, as a crash in a FUSE filesystem daemon won’t bring down the entire kernel.

For our purpose, FUSE acts as a bridge. We’ll use a FUSE-based utility like bindfs to create a ‘virtual’ mount point on the host that mirrors a specific host directory. This virtual mount point can then be bind-mounted into the Anbox or Waydroid container, making its contents directly accessible to the Android guest. This approach is superior to simple bind-mounts of raw host directories because FUSE allows for fine-grained control over permissions and ownership presented to the guest, crucial for containerized environments.

Prerequisites

Before we begin, ensure you have the necessary tools and kernel modules:

• Linux host system (Ubuntu, Debian, Fedora, Arch, etc.)
• Anbox or Waydroid installed and running.
• fuse kernel module loaded. You can check with lsmod | grep fuse. If not loaded, it typically loads automatically when a FUSE filesystem is mounted.
• libfuse3 development libraries and utilities.
• A FUSE-based filesystem utility, such as bindfs.

Install the required packages on your host system. For Debian/Ubuntu-based systems:

sudo apt update
sudo apt install libfuse3-dev fuse3 bindfs

For Fedora/CentOS:

sudo dnf install fuse3-libs fuse-devel bindfs

For Arch Linux:

sudo pacman -S fuse3 bindfs

Implementing FUSE for Anbox

Anbox leverages LXC containers. Our strategy involves creating a FUSE mount on the host and then instructing Anbox’s LXC container to bind-mount this FUSE point into the Android guest.

Step 1: Prepare Host Shared Directory

First, create the directory on your host that you wish to share with Anbox. Let’s call it anbox-share.

mkdir -p ~/anbox-share
echo "Hello from Host!" > ~/anbox-share/test.txt

Step 2: Create FUSE Mount Point on Host

We’ll use bindfs to create a FUSE mount point that presents ~/anbox-share. This allows us to control permissions more precisely. We’ll create another directory for the FUSE mount itself.

mkdir -p ~/.local/share/anbox/shared-fuse
bindfs --perms=0777 --create-for-user=$(id -u) --create-for-group=$(id -g) --mirror-only-set-perm --mirror-owner-id=$(id -u) --mirror-group-id=$(id -g) ~/anbox-share ~/.local/share/anbox/shared-fuse

Explanation of bindfs options:

• --perms=0777: Sets default permissions for new files/directories in the FUSE mount to be fully accessible.
• --create-for-user=$(id -u): New files/dirs created in the FUSE mount by the guest will be owned by your host user ID.
• --create-for-group=$(id -g): New files/dirs will be owned by your host group ID.
• --mirror-only-set-perm: Copies permissions from the original file/dir only if explicitly set (useful for existing files).
• --mirror-owner-id / --mirror-group-id: Ensures files inherit the owner/group from the source, or a specific ID if specified.

At this point, ~/.local/share/anbox/shared-fuse is a FUSE-backed view of ~/anbox-share.

Step 3: Configure Anbox Container

Anbox’s container configuration is typically found in /var/lib/anbox/lxc/default/lxc.conf or managed via anbox-container-manager. We need to add an lxc.mount.entry to bind-mount our FUSE share. However, directly modifying this file might be overwritten by Anbox updates. A safer approach is often to provide a custom LXC configuration snippet if Anbox allows it, or to modify the service startup. For a direct approach, we’ll edit /var/lib/anbox/lxc/default/lxc.conf. Make sure to back it up first.

sudo cp /var/lib/anbox/lxc/default/lxc.conf /var/lib/anbox/lxc/default/lxc.conf.bak
sudo nano /var/lib/anbox/lxc/default/lxc.conf

Add the following line to the end of the file, replacing <YOUR_USER> with your actual username:

lxc.mount.entry = /home/<YOUR_USER>/.local/share/anbox/shared-fuse data/shared none bind,create=dir 0 0

This mounts the FUSE directory from your host into /data/shared inside the Anbox container.

Step 4: Restart Anbox and Verify

Restart the Anbox service to apply the changes:

sudo systemctl restart anbox-container-manager.service

Launch Anbox. Inside Anbox, you can use a file manager app (like Files from F-Droid or any other) or an ADB shell to verify:

adb shell
ls -l /data/shared
cat /data/shared/test.txt

You should see test.txt and its content. You can now create files in /data/shared from Anbox, and they will appear in your host’s ~/anbox-share directory.

Implementing FUSE for Waydroid

Waydroid also uses LXC containers, but its setup is often more dynamic. The approach is similar: create a FUSE mount on the host, then instruct Waydroid’s container to bind-mount it.

Step 1: Prepare Host Shared Directory

Create a dedicated directory for Waydroid sharing:

mkdir -p ~/waydroid-share
echo "Hello from Waydroid Host!" > ~/waydroid-share/sample.txt

Step 2: Create FUSE Mount Point on Host

Similar to Anbox, we create a FUSE mount point using bindfs. Let’s put it under Waydroid’s default data path to keep things organized.

mkdir -p /var/lib/waydroid/shared-fuse
sudo bindfs --perms=0777 --create-for-user=1000 --create-for-group=1000 --mirror-only-set-perm --mirror-owner-id=1000 --mirror-group-id=1000 ~/waydroid-share /var/lib/waydroid/shared-fuse

Note: We use sudo because we’re mounting into /var/lib/waydroid. Also, --create-for-user=1000 --create-for-group=1000 is important. In many Android guests, the primary user and group ID is 1000 (aid_system or root if using a root image, or the primary app user). Using your host user ID directly might cause permission issues inside Waydroid if it’s running with different UIDs. This ensures newly created files/directories inside the guest will appear owned by your host user in ~/waydroid-share.

Step 3: Configure Waydroid Container

Waydroid often manages its LXC configuration more directly. The recommended way to add custom LXC configuration is via a file that Waydroid includes. This can be done by creating a file in Waydroid’s LXC configuration directory.

sudo nano /var/lib/waydroid/lxc/waydroid.conf.d/00-share.conf

Add the following content:

lxc.mount.entry = /var/lib/waydroid/shared-fuse /data/media/0/shared none bind,create=dir 0 0

We choose /data/media/0/shared as the mount point inside Waydroid, as this path is commonly accessible by file managers and user applications without requiring root.

Step 4: Restart Waydroid and Verify

Restart the Waydroid container to apply the changes:

sudo systemctl restart waydroid-container.service

Launch Waydroid. Inside Waydroid, open a file manager app. Navigate to Internal Storage (which is typically /data/media/0) and you should find a new directory named shared. Inside it, you’ll see sample.txt and its content.

waydroid shell
ls -l /data/media/0/shared
cat /data/media/0/shared/sample.txt

You can now seamlessly exchange files between your host and Waydroid!

Troubleshooting Common Issues

• Permission Denied: This is the most frequent issue. Double-check your bindfs options, especially --perms, --create-for-user, and --create-for-group. Ensure the Android guest has appropriate permissions (often u:media_rw,g:media_rw or similar).
• Mount Point Not Visible: Verify the host FUSE mount is active using mount | grep fuse. Check the lxc.mount.entry path and target in the container’s config. Ensure the container service was restarted.
• fuse module not found: Ensure fuse kernel module is loaded (sudo modprobe fuse).
• Changes not persistent: Ensure your LXC configuration changes are saved and picked up by the container’s startup scripts. For Anbox, directly editing lxc.conf might be overwritten; consider systemd mount units for the FUSE mount if you want it to be persistent across reboots.

Security Considerations

Exposing host directories to containers, even through FUSE, always carries a security risk. A compromised Android app could potentially write malicious content to your host’s shared directory. Therefore:

• Only share directories containing non-sensitive data.
• Use bindfs options to restrict permissions as much as possible.
• Do not share your entire home directory. Create specific, isolated shared folders.
• Regularly review the contents of your shared directories for unexpected files.

Conclusion

Mastering FUSE for host-guest file sharing in Anbox and Waydroid significantly enhances the usability and integration of these powerful Android environments. By following this detailed guide, you can establish robust, real-time file synchronization, making your Android development and usage workflows much more efficient. While it requires careful configuration of FUSE and LXC parameters, the benefits of seamless file access far outweigh the initial setup effort.