Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 741ea4f1 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "ueventd: add support for driver section in ueventd.rc" into main am: 8b7d0aa8 

Original change: https://android-review.googlesource.com/c/platform/system/core/+/3357138



Change-Id: Iebd84185a6db7a1f3d2df6e8c37d121230c22e3f
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 4915189f 8b7d0aa8

init/README.ueventd.md

+10 −6
Original line number Diff line number Diff line
@@ -76,17 +76,17 @@ For example 
When `/dev/null` is created, its mode will be set to `0666`, its user to `root` and its group to

`root`.



The path can be modified using a ueventd.rc script and a `subsystem` section. There are three to set

for a subsystem: the subsystem name, which device name to use, and which directory to place the

device in. The section takes the below format of

The path can be modified using a ueventd.rc script and a `subsystem` and/or `driver` section.

There are three options to set for a subsystem or driver: the name, which device name to use,

and which directory to place the device in. The section takes the below format of



    subsystem <subsystem_name>

      devname uevent_devname|uevent_devpath

      [dirname <directory>]



`subsystem_name` is used to match uevent `SUBSYSTEM` value

`subsystem_name` is used to match the uevent `SUBSYSTEM` value.



`devname` takes one of three options

`devname` takes one of three options:

  1. `uevent_devname` specifies that the name of the node will be the uevent `DEVNAME`

  2. `uevent_devpath` specifies that the name of the node will be basename uevent `DEVPATH`

  3. `sys_name` specifies that the name of the node will be the contents of `/sys/DEVPATH/name`
@@ -99,9 +99,13 @@ For example 
    subsystem sound

      devname uevent_devpath

      dirname /dev/snd

Indicates that all uevents with `SUBSYSTEM=sound` will create nodes as `/dev/snd/<basename uevent

indicates that all uevents with `SUBSYSTEM=sound` will create nodes as `/dev/snd/<basename uevent

DEVPATH>`.



The `driver` section has the exact same structure as a `subsystem` section, but

will instead match the `DRIVER` value in a `bind`/`unbind` uevent. However, the

`driver` section will be ignored for block devices.



## /sys

----

Ueventd by default takes no action for `/sys`, however it can be instructed to set permissions for

init/block_dev_initializer.cpp

+2 −1
Original line number Diff line number Diff line
@@ -33,7 +33,8 @@ BlockDevInitializer::BlockDevInitializer() : uevent_listener_(16 * 1024 * 1024) 
    auto boot_devices = android::fs_mgr::GetBootDevices();

    device_handler_ = std::make_unique<DeviceHandler>(

            std::vector<Permissions>{}, std::vector<SysfsPermissions>{}, std::vector<Subsystem>{},

            std::move(boot_devices), android::fs_mgr::GetBootPartUuid(), false);

            std::vector<Subsystem>{}, std::move(boot_devices), android::fs_mgr::GetBootPartUuid(),

            false);

}



// If boot_part_uuid is specified, use it to set boot_devices

init/devices.cpp

+69 −3
Original line number Diff line number Diff line
@@ -345,6 +345,26 @@ bool DeviceHandler::FindScsiDevice(const std::string& path, std::string* scsi_de 
    return FindSubsystemDevice(path, scsi_device_path, subsystem_paths);

}



void DeviceHandler::TrackDeviceUevent(const Uevent& uevent) {

    // No need to track any events if we won't bother handling any bind events

    // later.

    if (drivers_.size() == 0) return;



    // Only track add, and not for block devices. We don't track remove because

    // unbind events may arrive after remove events, so unbind will be the

    // trigger to untrack those events.

    if ((uevent.action != "add") || uevent.subsystem == "block" ||

        (uevent.major < 0 || uevent.minor < 0)) {

        return;

    }



    std::string path = sysfs_mount_point_ + uevent.path + "/device";

    std::string device;

    if (!Realpath(path, &device)) return;



    tracked_uevents_.emplace_back(uevent, device);

}



void DeviceHandler::FixupSysPermissions(const std::string& upath,

                                        const std::string& subsystem) const {

    // upaths omit the "/sys" that paths in this list
@@ -664,12 +684,53 @@ bool DeviceHandler::CheckUeventForBootPartUuid(const Uevent& uevent) { 
    return true;

}



void DeviceHandler::HandleBindInternal(std::string driver_name, std::string action,

                                       const Uevent& uevent) {

    if (uevent.subsystem == "block") {

        LOG(FATAL) << "Tried to handle bind event for block device";

    }



    // Get tracked uevents for all devices that have this uevent's path as

    // their canonical device path. Then handle those again if their driver

    // is one of the ones we're interested in.

    const auto driver = std::find(drivers_.cbegin(), drivers_.cend(), driver_name);

    if (driver == drivers_.cend()) return;



    std::string bind_path = sysfs_mount_point_ + uevent.path;

    for (const TrackedUevent& tracked : tracked_uevents_) {

        if (tracked.canonical_device_path != bind_path) continue;



        LOG(VERBOSE) << "Propagating " << uevent.action << " as " << action << " for "

                     << uevent.path;



        std::string devpath = driver->ParseDevPath(tracked.uevent);

        mkdir_recursive(Dirname(devpath), 0755);

        HandleDevice(action, devpath, false, tracked.uevent.major, tracked.uevent.minor,

                     std::vector<std::string>{});

    }

}



void DeviceHandler::HandleUevent(const Uevent& uevent) {

    if (uevent.action == "add" || uevent.action == "change" || uevent.action == "bind" ||

        uevent.action == "online") {

        FixupSysPermissions(uevent.path, uevent.subsystem);

    }



    if (uevent.action == "bind") {

        bound_drivers_[uevent.path] = uevent.driver;

        HandleBindInternal(uevent.driver, "add", uevent);

        return;

    } else if (uevent.action == "unbind") {

        if (bound_drivers_.count(uevent.path) == 0) return;

        HandleBindInternal(bound_drivers_[uevent.path], "remove", uevent);



        std::string sys_path = sysfs_mount_point_ + uevent.path;

        std::erase_if(tracked_uevents_, [&sys_path](const TrackedUevent& tracked) {

            return sys_path == tracked.canonical_device_path;

        });

        return;

    }



    // if it's not a /dev device, nothing to do

    if (uevent.major < 0 || uevent.minor < 0) return;
@@ -677,6 +738,8 @@ void DeviceHandler::HandleUevent(const Uevent& uevent) { 
    std::vector<std::string> links;

    bool block = false;



    TrackDeviceUevent(uevent);



    if (uevent.subsystem == "block") {

        block = true;

        devpath = "/dev/block/" + Basename(uevent.path);
@@ -725,10 +788,12 @@ void DeviceHandler::ColdbootDone() { 


DeviceHandler::DeviceHandler(std::vector<Permissions> dev_permissions,

                             std::vector<SysfsPermissions> sysfs_permissions,

                             std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,

                             std::string boot_part_uuid, bool skip_restorecon)

                             std::vector<Subsystem> drivers, std::vector<Subsystem> subsystems,

                             std::set<std::string> boot_devices, std::string boot_part_uuid,

                             bool skip_restorecon)

    : dev_permissions_(std::move(dev_permissions)),

      sysfs_permissions_(std::move(sysfs_permissions)),

      drivers_(std::move(drivers)),

      subsystems_(std::move(subsystems)),

      boot_devices_(std::move(boot_devices)),

      boot_part_uuid_(boot_part_uuid),
@@ -744,7 +809,8 @@ DeviceHandler::DeviceHandler(std::vector<Permissions> dev_permissions, 


DeviceHandler::DeviceHandler()

    : DeviceHandler(std::vector<Permissions>{}, std::vector<SysfsPermissions>{},

                    std::vector<Subsystem>{}, std::set<std::string>{}, "", false) {}

                    std::vector<Subsystem>{}, std::vector<Subsystem>{}, std::set<std::string>{}, "",

                    false) {}



}  // namespace init

}  // namespace android

init/devices.h

+14 −1
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <sys/types.h>



#include <algorithm>

#include <map>

#include <set>

#include <string>

#include <vector>
@@ -128,7 +129,7 @@ class DeviceHandler : public UeventHandler { 


    DeviceHandler();

    DeviceHandler(std::vector<Permissions> dev_permissions,

                  std::vector<SysfsPermissions> sysfs_permissions,

                  std::vector<SysfsPermissions> sysfs_permissions, std::vector<Subsystem> drivers,

                  std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,

                  std::string boot_part_uuid, bool skip_restorecon);

    virtual ~DeviceHandler() = default;
@@ -145,6 +146,11 @@ class DeviceHandler : public UeventHandler { 
    bool IsBootDevice(const Uevent& uevent) const;



  private:

    struct TrackedUevent {

        Uevent uevent;

        std::string canonical_device_path;

    };



    void ColdbootDone() override;

    BlockDeviceInfo GetBlockDeviceInfo(const std::string& uevent_path) const;

    bool FindSubsystemDevice(std::string path, std::string* device_path,
@@ -163,14 +169,21 @@ class DeviceHandler : public UeventHandler { 
    void FixupSysPermissions(const std::string& upath, const std::string& subsystem) const;

    void HandleAshmemUevent(const Uevent& uevent);



    void TrackDeviceUevent(const Uevent& uevent);

    void HandleBindInternal(std::string driver_name, std::string action, const Uevent& uevent);



    std::vector<Permissions> dev_permissions_;

    std::vector<SysfsPermissions> sysfs_permissions_;

    std::vector<Subsystem> drivers_;

    std::vector<Subsystem> subsystems_;

    std::set<std::string> boot_devices_;

    std::string boot_part_uuid_;

    bool found_boot_part_uuid_;

    bool skip_restorecon_;

    std::string sysfs_mount_point_;



    std::vector<TrackedUevent> tracked_uevents_;

    std::map<std::string, std::string> bound_drivers_;

};



// Exposed for testing

init/uevent.h

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ struct Uevent { 
    std::string action;

    std::string path;

    std::string subsystem;

    std::string driver;

    std::string firmware;

    std::string partition_name;

    std::string partition_uuid;