Probably also should run this through Clang format when you're done with it.

Okay, a slightly larger review this time. I should have thought about this more earlier, but basically it doesn't make sense given the current implementation to have anything that takes a path argument (as opposed to a file descriptor argument) to the fs_driver struct.

there's two ways I see that we could go about this:

• do what we did with open, and explicitly delegate to a function like *_open_r
• change the fs_driver's semantics so that each function taking a path name is called having stripped off the driver-descriptive part of the path

I would have said that the first option is the easiest, however given the number of functions being added here I don't actually think that's the case. Plus, the second option would make #178 easier to work on in the future.

So let me elaborate on the second point. Let's consider mkdir as an example.

int mkdir(const char* pathname, mode_t mode) {
    struct _reent* r = _REENT;
    // check length of pathname
    size_t len = 0;
    if ((len = strnlen(pathname, MAX_FILELEN)) == MAX_FILELEN) {
        r->_errno = ENAMETOOLONG;
        return -1;
    }
    if (len <= 3) {
        // this means that it's too short to be meaningful (needs to at least have "/a/")
        r->_errno = ENOENT;
        return -1;
    } else if (*pathname != '/') {
        // our paths need to start with '/' by convention. this check is delayed so that we
        // can ensure dereferencing the pathname is safe
        r->_errno = ENOENT;
        return -1;
    }
    // now we've established there's some meaningful path
    // by convention, a path should be of the form `/drv/path...` where `drv` is the driver id
    // so we want to find the first substring that starts and ends with '/' to extract this id
    char* path = strchr(pathname + 1, '/'); // skip the first character as we already know it
    size_t drvlen = len - strlen(path);
    char* drv = malloc(drvlen * sizeof(*drv)); // allocate some space for the driver id
    strncpy(drv, pathname, drvlen);
    // at this point we have everything we need, so look up the driver for the driver id
    struct fs_driver* driver;
    if (!(driver = driver_lookup(drv)) {
        free(drv); // make sure to free up memory
        r->_errno = EFAULT; // this errno value is up for debate
        return -1;
    }
    free(drv);
    return driver->mkdir_r(r, pathname + drvlen, mode);
}

A lot of that path extraction stuff could definitely be refactored into its own function. driver_lookup and associated storage would also need to be defined and implemented. Since we currently only support the three drivers (usd, ser, and dev), this would be as simple as checking the driver id and returning a pointer to the right driver (this can be easily extended later).

Newlib supports namespace clean functions for some of these. The ones it does I think you should be doing. There's a list hotel put on the original issue with the function names you should be matching, and it includes which ones have underscores and which ones don't.