Dynamic Mounting of Android System Partitions: A Universal Solution for Read-Write Access Management

Technical Background of Android System Partition Mounting

In Android app development, there are scenarios where files need to be written to the /system partition at runtime, such as installing system-level modules or modifying system configurations. Since the /system partition is typically mounted as read-only by default, developers must first remount it as read-write. This operation is usually performed using the mount command, but variations in hardware and kernel configurations across Android devices can lead to differences in mount parameters, posing challenges for cross-device compatibility.

Limitations of Traditional Approaches

A common mount command is shown below:

mount -o remount,rw -t yaffs2 /dev/block/mtdblock3 /system

This command specifies the filesystem type (yaffs2) and device path (/dev/block/mtdblock3). However, these parameters are not universal:

• Filesystem types may vary between devices, e.g., some use ext4 or f2fs.
• Device paths (like mtdblock3) may correspond to different storage blocks, causing command execution to fail.

Thus, applications that hardcode these parameters cannot guarantee functionality across all Android devices.

Universal Solution: Dynamic Identification of Mount Information

To address this issue, the best practice is to dynamically retrieve mount information for the /system partition at runtime. This can be achieved by executing the mount command without parameters, which outputs detailed information about all current mount points. Below is an example output (from an HTC Hero device):

$ mount
rootfs / rootfs ro 0 0
tmpfs /dev tmpfs rw,mode=755 0 0
devpts /dev/pts devpts rw,mode=600 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
tmpfs /sqlite_stmt_journals tmpfs rw,size=4096k 0 0
none /dev/cpuctl cgroup rw,cpu 0 0
/dev/block/mtdblock3 /system yaffs2 rw 0 0
/dev/block/mtdblock5 /data yaffs2 rw,nosuid,nodev 0 0
/dev/block/mtdblock4 /cache yaffs2 rw,nosuid,nodev 0 0
/dev/block//vold/179:1 /sdcard vfat rw,dirsync,nosuid,nodev,noexec,uid=1000,gid=1015,fmask=0702,dmask=0702,allow_utime=0020,codepage=cp437,iocharset=iso8859-1,shortname=mixed,utf8,errors=remount-ro 0 0

From this output, we can extract relevant information for the /system partition:

• Device path: /dev/block/mtdblock3
• Filesystem type: yaffs2
• Current mount mode: rw (read-write)

Based on this data, a universal mount command can be constructed, eliminating dependency on specific parameters.

Implementation Code Example

The following Java code example demonstrates how to dynamically retrieve and execute a mount command in an Android app. It assumes the app has already obtained root access via su.

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class SystemMountHelper {
    public static boolean remountSystemAsRW() {
        try {
            // Execute mount command to get mount information
            Process process = Runtime.getRuntime().exec("mount");
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            String devicePath = null;
            String fsType = null;

            while ((line = reader.readLine()) != null) {
                if (line.contains(" /system ")) {
                    // Parse the line to extract device path and filesystem type
                    String[] parts = line.split("\\s+");
                    if (parts.length >= 3) {
                        devicePath = parts[0];  // e.g., /dev/block/mtdblock3
                        fsType = parts[2];      // e.g., yaffs2
                        break;
                    }
                }
            }
            reader.close();
            process.waitFor();

            // Check if information was successfully extracted
            if (devicePath == null || fsType == null) {
                return false;  // /system partition information not found
            }

            // Construct and execute the mount command
            String mountCommand = "mount -o rw,remount -t " + fsType + " " + devicePath + " /system";
            Process mountProcess = Runtime.getRuntime().exec(mountCommand);
            int exitCode = mountProcess.waitFor();
            return exitCode == 0;  // Return execution result
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

This code first executes the mount command, parses the device path and filesystem type for the /system partition from the output, then dynamically builds and executes the mount command. This approach ensures cross-device compatibility, as command parameters are generated based on actual system configurations.

Supplementary Solutions and Considerations

In addition to dynamic parsing, simplified commands can serve as alternatives. For example, directly using:

mount -o rw,remount /system

This command omits the device path and filesystem type, relying on the system to handle them automatically. However, it may not work on all devices, so the dynamic parsing method is recommended for higher reliability.

When implementing, consider the following key points:

• Permission Management: Ensure the app properly obtains and handles root permissions to avoid security risks.
• Error Handling: Add appropriate exception catching and logging to debug mount failures.
• Compatibility Testing: Conduct thorough testing across different Android versions and device models to validate the solution's universality.

Conclusion

By dynamically parsing the output of the mount command, developers can create a universal solution for read-write mounting of the /system partition across Android devices. This method overcomes the limitations of hardcoded parameters, enhancing app compatibility and stability. In practice, combining it with permission management and error handling effectively supports system-level file operations.