vold: Bugfixes & cleanups

  - Fix issue where container-names > 64 bytes were getting truncated in the
    kernel. lo_name is only 64 bytes in length, so we now hash the container
    id via md5
  - Add 'dump' command to dump loop and devicemapper status
  - Add 'debug' command to enable more detailed logging at runtime
  - Log vold IPC arguments (minus encryption keys)
  - Fix premature return from Loop::lookupActive() and friends

Change-Id: I0e833261a445ce9dc1a8187e5501d27daba1ca76
Signed-off-by: San Mehat <[email protected]>

Author: San Mehat

Android.mk

@@ -25,7 +25,8 @@ LOCAL_SRC_FILES:=                                      \
                   Loop.cpp                             \
                   Devmapper.cpp                        \
                   ResponseCode.cpp                     \
-                  Xwarp.cpp
+                  Xwarp.cpp                            \
+                  md5.c
 
 LOCAL_MODULE:= vold
 

CommandListener.cpp

@@ -23,7 +23,7 @@
 #include <errno.h>
 #include <fcntl.h>
 
-#define LOG_TAG "CommandListener"
+#define LOG_TAG "VoldCmdListener"
 #include <cutils/log.h>
 
 #include <sysutils/SocketClient.h>
@@ -33,22 +33,75 @@
 #include "ResponseCode.h"
 #include "Process.h"
 #include "Xwarp.h"
+#include "Loop.h"
+#include "Devmapper.h"
 
 CommandListener::CommandListener() :
                  FrameworkListener("vold") {
+    registerCmd(new DumpCmd());
     registerCmd(new VolumeCmd());
     registerCmd(new AsecCmd());
     registerCmd(new ShareCmd());
     registerCmd(new StorageCmd());
     registerCmd(new XwarpCmd());
 }
 
+void CommandListener::dumpArgs(int argc, char **argv, int argObscure) {
+    char buffer[4096];
+    char *p = buffer;
+
+    memset(buffer, 0, sizeof(buffer));
+    int i;
+    for (i = 0; i < argc; i++) {
+        int len = strlen(argv[i]) + 1; // Account for space
+        if (i == argObscure) {
+            len += 2; // Account for {}
+        }
+        if (((p - buffer) + len) < (sizeof(buffer)-1)) {
+            if (i == argObscure) {
+                *p++ = '{';
+                *p++ = '}';
+                *p++ = ' ';
+                continue;
+            }
+            strcpy(p, argv[i]);
+            p+= strlen(argv[i]);
+            if (i != (argc -1)) {
+                *p++ = ' ';
+            }
+        }
+    }
+    LOGD("%s", buffer);
+}
+
+CommandListener::DumpCmd::DumpCmd() :
+                 VoldCommand("dump") {
+}
+
+int CommandListener::DumpCmd::runCommand(SocketClient *cli,
+                                         int argc, char **argv) {
+    cli->sendMsg(0, "Dumping loop status", false);
+    if (Loop::dumpState(cli)) {
+        cli->sendMsg(ResponseCode::CommandOkay, "Loop dump failed", true);
+    }
+    cli->sendMsg(0, "Dumping DM status", false);
+    if (Devmapper::dumpState(cli)) {
+        cli->sendMsg(ResponseCode::CommandOkay, "Devmapper dump failed", true);
+    }
+
+    cli->sendMsg(ResponseCode::CommandOkay, "dump complete", false);
+    return 0;
+}
+
+
 CommandListener::VolumeCmd::VolumeCmd() :
                  VoldCommand("volume") {
 }
 
 int CommandListener::VolumeCmd::runCommand(SocketClient *cli,
                                                       int argc, char **argv) {
+    dumpArgs(argc, argv, -1);
+
     if (argc < 2) {
         cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);
         return 0;
@@ -59,6 +112,8 @@ int CommandListener::VolumeCmd::runCommand(SocketClient *cli,
 
     if (!strcmp(argv[1], "list")) {
         return vm->listVolumes(cli);
+    } else if (!strcmp(argv[1], "debug")) {
+        vm->setDebug(true);
     } else if (!strcmp(argv[1], "mount")) {
         rc = vm->mountVolume(argv[2]);
     } else if (!strcmp(argv[1], "unmount")) {
@@ -105,6 +160,8 @@ CommandListener::ShareCmd::ShareCmd() :
 
 int CommandListener::ShareCmd::runCommand(SocketClient *cli,
                                                       int argc, char **argv) {
+    dumpArgs(argc, argv, -1);
+
     if (argc < 2) {
         cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);
         return 0;
@@ -136,6 +193,8 @@ CommandListener::StorageCmd::StorageCmd() :
 
 int CommandListener::StorageCmd::runCommand(SocketClient *cli,
                                                       int argc, char **argv) {
+    dumpArgs(argc, argv, -1);
+
     if (argc < 2) {
         cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);
         return 0;
@@ -194,6 +253,7 @@ int CommandListener::AsecCmd::runCommand(SocketClient *cli,
     int rc = 0;
 
     if (!strcmp(argv[1], "list")) {
+        dumpArgs(argc, argv, -1);
         DIR *d = opendir(Volume::SEC_ASECDIR);
 
         if (!d) {
@@ -214,6 +274,7 @@ int CommandListener::AsecCmd::runCommand(SocketClient *cli,
         }
         closedir(d);
     } else if (!strcmp(argv[1], "create")) {
+        dumpArgs(argc, argv, 5);
         if (argc != 7) {
             cli->sendMsg(ResponseCode::CommandSyntaxError,
                     "Usage: asec create <container-id> <size_mb> <fstype> <key> <ownerUid>", false);
@@ -223,12 +284,14 @@ int CommandListener::AsecCmd::runCommand(SocketClient *cli,
         unsigned int numSectors = (atoi(argv[3]) * (1024 * 1024)) / 512;
         rc = vm->createAsec(argv[2], numSectors, argv[4], argv[5], atoi(argv[6]));
     } else if (!strcmp(argv[1], "finalize")) {
+        dumpArgs(argc, argv, -1);
         if (argc != 3) {
             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec finalize <container-id>", false);
             return 0;
         }
         rc = vm->finalizeAsec(argv[2]);
     } else if (!strcmp(argv[1], "destroy")) {
+        dumpArgs(argc, argv, -1);
         if (argc < 3) {
             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec destroy <container-id> [force]", false);
             return 0;
@@ -239,13 +302,15 @@ int CommandListener::AsecCmd::runCommand(SocketClient *cli,
         }
         rc = vm->destroyAsec(argv[2], force);
     } else if (!strcmp(argv[1], "mount")) {
+        dumpArgs(argc, argv, 3);
         if (argc != 5) {
             cli->sendMsg(ResponseCode::CommandSyntaxError,
                     "Usage: asec mount <namespace-id> <key> <ownerUid>", false);
             return 0;
         }
         rc = vm->mountAsec(argv[2], argv[3], atoi(argv[4]));
     } else if (!strcmp(argv[1], "unmount")) {
+        dumpArgs(argc, argv, -1);
         if (argc < 3) {
             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec unmount <container-id> [force]", false);
             return 0;
@@ -256,13 +321,15 @@ int CommandListener::AsecCmd::runCommand(SocketClient *cli,
         }
         rc = vm->unmountAsec(argv[2], force);
     } else if (!strcmp(argv[1], "rename")) {
+        dumpArgs(argc, argv, -1);
         if (argc != 4) {
             cli->sendMsg(ResponseCode::CommandSyntaxError,
                     "Usage: asec rename <old_id> <new_id>", false);
             return 0;
         }
         rc = vm->renameAsec(argv[2], argv[3]);
     } else if (!strcmp(argv[1], "path")) {
+        dumpArgs(argc, argv, -1);
         if (argc != 3) {
             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: asec path <container-id>", false);
             return 0;
@@ -276,6 +343,7 @@ int CommandListener::AsecCmd::runCommand(SocketClient *cli,
         }
         return 0;
     } else {
+        dumpArgs(argc, argv, -1);
         cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown asec cmd", false);
     }
 

CommandListener.h

@@ -26,6 +26,14 @@ class CommandListener : public FrameworkListener {
     virtual ~CommandListener() {}
 
 private:
+    static void dumpArgs(int argc, char **argv, int argObscure);
+
+    class DumpCmd : public VoldCommand {
+    public:
+        DumpCmd();
+        virtual ~DumpCmd() {}
+        int runCommand(SocketClient *c, int argc, char ** argv);
+    };
 
     class VolumeCmd : public VoldCommand {
     public:

Devmapper.cpp

@@ -24,12 +24,92 @@
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 
+#include <linux/kdev_t.h>
+
 #define LOG_TAG "Vold"
 
 #include <cutils/log.h>
 
+#include <sysutils/SocketClient.h>
+
 #include "Devmapper.h"
 
+int Devmapper::dumpState(SocketClient *c) {
+
+    char *buffer = (char *) malloc(1024 * 64);
+    if (!buffer) {
+        LOGE("Error allocating memory (%s)", strerror(errno));
+        return -1;
+    }
+    memset(buffer, 0, (1024 * 64));
+
+    char *buffer2 = (char *) malloc(4096);
+    if (!buffer2) {
+        LOGE("Error allocating memory (%s)", strerror(errno));
+        free(buffer);
+        return -1;
+    }
+
+    int fd;
+    if ((fd = open("/dev/device-mapper", O_RDWR)) < 0) {
+        LOGE("Error opening devmapper (%s)", strerror(errno));
+        free(buffer);
+        free(buffer2);
+        return -1;
+    }
+
+    struct dm_ioctl *io = (struct dm_ioctl *) buffer;
+    ioctlInit(io, (1024 * 64), NULL, 0);
+
+    if (ioctl(fd, DM_LIST_DEVICES, io)) {
+        LOGE("DM_LIST_DEVICES ioctl failed (%s)", strerror(errno));
+        free(buffer);
+        free(buffer2);
+        close(fd);
+        return -1;
+    }
+
+    struct dm_name_list *n = (struct dm_name_list *) (((char *) buffer) + io->data_start);
+    if (!n->dev) {
+        free(buffer);
+        free(buffer2);
+        close(fd);
+        return 0;
+    }
+
+    unsigned nxt = 0;
+    do {
+        n = (struct dm_name_list *) (((char *) n) + nxt);
+
+        memset(buffer2, 0, 4096);
+        struct dm_ioctl *io2 = (struct dm_ioctl *) buffer2;
+        ioctlInit(io2, 4096, n->name, 0);
+        if (ioctl(fd, DM_DEV_STATUS, io2)) {
+            if (errno != ENXIO) {
+                LOGE("DM_DEV_STATUS ioctl failed (%s)", strerror(errno));
+            }
+            io2 = NULL;
+        }
+
+        char *tmp;
+        if (!io2) {
+            asprintf(&tmp, "%s %llu:%llu (no status available)", n->name, MAJOR(n->dev), MINOR(n->dev));
+        } else {
+            asprintf(&tmp, "%s %llu:%llu %d %d 0x%.8x %llu:%llu", n->name, MAJOR(n->dev),
+                    MINOR(n->dev), io2->target_count, io2->open_count, io2->flags, MAJOR(io2->dev),
+                            MINOR(io2->dev));
+        }
+        c->sendMsg(0, tmp, false);
+        free(tmp);
+        nxt = n->next;
+    } while (nxt);
+
+    free(buffer);
+    free(buffer2);
+    close(fd);
+    return 0;
+}
+
 void Devmapper::ioctlInit(struct dm_ioctl *io, size_t dataSize,
                           const char *name, unsigned flags) {
     memset(io, 0, dataSize);
@@ -39,7 +119,9 @@ void Devmapper::ioctlInit(struct dm_ioctl *io, size_t dataSize,
     io->version[1] = 0;
     io->version[2] = 0;
     io->flags = flags;
-    strncpy(io->name, name, sizeof(io->name));
+    if (name) {
+        strncpy(io->name, name, sizeof(io->name));
+    }
 }
 
 int Devmapper::lookupActive(const char *name, char *ubuffer, size_t len) {

Devmapper.h

@@ -20,12 +20,16 @@
 #include <unistd.h>
 #include <linux/dm-ioctl.h>
 
+class SocketClient;
+
 class Devmapper {
 public:
     static int create(const char *name, const char *loopFile, const char *key,
                       unsigned int numSectors, char *buffer, size_t len);
     static int destroy(const char *name);
     static int lookupActive(const char *name, char *buffer, size_t len);
+    static int dumpState(SocketClient *c);
+
 private:
     static void *_align(void *ptr, unsigned int a);
     static void ioctlInit(struct dm_ioctl *io, size_t data_size,