auto import from //branches/cupcake/...@127101

1 files changed, 792 insertions, 0 deletions

diff --git a/vold/volmgr.c b/vold/volmgr.c
new file mode 100644
index 0000000..8ceb1dd
--- /dev/null
+++ b/vold/volmgr.c
@@ -0,0 +1,792 @@
+
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sched.h>
+
+#include <sys/mount.h>
+
+#include <cutils/config_utils.h>
+#include <cutils/properties.h>
+
+#include "vold.h"
+#include "volmgr.h"
+#include "blkdev.h"
+#include "ums.h"
+
+#include "volmgr_ext3.h"
+#include "volmgr_vfat.h"
+
+#define DEBUG_VOLMGR 0
+
+static volume_t        *vol_root = NULL;
+
+static struct volmgr_fstable_entry fs_table[] = {
+    { "ext3", ext3_identify, ext3_check, ext3_mount },
+    { "vfat", vfat_identify, vfat_check, vfat_mount },
+    { NULL, NULL, NULL, NULL }
+};
+
+struct _volume_state_event_map {
+    volume_state_t state;
+    char           *event;
+    char           *property_val;
+};
+
+static struct _volume_state_event_map volume_state_strings[] = {
+    { volstate_unknown,     "volstate_unknown:",  "unknown" },
+    { volstate_nomedia,     VOLD_EVT_NOMEDIA,     VOLD_ES_PVAL_NOMEDIA },
+    { volstate_unmounted,   VOLD_EVT_UNMOUNTED,   VOLD_ES_PVAL_UNMOUNTED },
+    { volstate_checking,    VOLD_EVT_CHECKING,    VOLD_ES_PVAL_CHECKING },
+    { volstate_mounted,     VOLD_EVT_MOUNTED,     VOLD_ES_PVAL_MOUNTED },
+    { volstate_mounted_ro,  VOLD_EVT_MOUNTED_RO,  VOLD_ES_PVAL_MOUNTED_RO },
+    { volstate_badremoval,  VOLD_EVT_BADREMOVAL,  VOLD_ES_PVAL_BADREMOVAL },
+    { volstate_damaged,     VOLD_EVT_DAMAGED,     VOLD_ES_PVAL_DAMAGED },
+    { volstate_nofs,        VOLD_EVT_NOFS,        VOLD_ES_PVAL_NOFS },
+    { volstate_ums,         VOLD_EVT_UMS,         VOLD_ES_PVAL_UMS },
+    { 0, NULL, NULL }
+};
+
+
+static int volmgr_readconfig(char *cfg_path);
+static int volmgr_config_volume(cnode *node);
+static volume_t *volmgr_lookup_volume_by_mediapath(char *media_path, boolean fuzzy);
+static volume_t *volmgr_lookup_volume_by_dev(blkdev_t *dev);
+static int _volmgr_start(volume_t *vol, blkdev_t *dev);
+static int volmgr_start_fs(struct volmgr_fstable_entry *fs, volume_t *vol, blkdev_t *dev);
+static void *volmgr_start_fs_thread(void *arg);
+static void volmgr_start_fs_thread_sighandler(int signo);
+static void volume_setstate(volume_t *vol, volume_state_t state);
+static char *conv_volstate_to_eventstr(volume_state_t state);
+static char *conv_volstate_to_propstr(volume_state_t state);
+static int volume_send_state(volume_t *vol);
+static void _cb_volstopped_for_ums_enable(volume_t *v);
+static int _volmgr_enable_ums(volume_t *);
+static int volmgr_shutdown_volume(volume_t *v, void (* cb) (volume_t *));
+static int volmgr_stop_volume(volume_t *v, void (*cb) (volume_t *, void *), void *arg, int emit_statechange);
+static void _cb_volume_stopped_for_eject(volume_t *v, void *arg);
+static void _cb_volume_stopped_for_shutdown(volume_t *v, void *arg);
+static int _volmgr_consider_disk_and_vol(volume_t *vol, blkdev_t *dev);
+static void volmgr_uncage_reaper(volume_t *vol);
+static void volmgr_reaper_thread_sighandler(int signo);
+
+/*
+ * Public functions
+ */
+int volmgr_bootstrap(void)
+{
+    int rc;
+
+    if ((rc = volmgr_readconfig("/system/etc/vold.conf")) < 0) {
+        LOGE("Unable to process config\n");
+        return rc;
+    }
+
+    return 0;
+}
+
+int volmgr_send_states(void)
+{
+    volume_t *vol_scan = vol_root;
+    int rc;
+
+    while (vol_scan) {
+        pthread_mutex_lock(&vol_scan->lock);
+        if ((rc = volume_send_state(vol_scan)) < 0) {
+            LOGE("Error sending state to framework (%d)\n", rc);
+        }
+        pthread_mutex_unlock(&vol_scan->lock);
+        vol_scan = vol_scan->next;
+    }
+
+    return 0;
+}
+
+/*
+ * Called when a block device is ready to be
+ * evaluated by the volume manager.
+ */
+int volmgr_consider_disk(blkdev_t *dev)
+{
+    volume_t *vol;
+
+    if (!(vol = volmgr_lookup_volume_by_mediapath(dev->media->devpath, true))) {
+        LOG_VOL("volmgr ignoring '%s' - no matching volume found\n", dev->media->devpath);
+        return 0;
+    }
+
+    pthread_mutex_lock(&vol->lock);
+    int rc =  _volmgr_consider_disk_and_vol(vol, dev);
+    pthread_mutex_unlock(&vol->lock);
+    return rc;
+}
+
+int volmgr_start_volume_by_mountpoint(char *mount_point)
+{
+    volume_t *v = vol_root;
+
+    while(v) {
+        if (!strcmp(v->mount_point, mount_point)) {
+            pthread_mutex_lock(&v->lock);
+            if (!v->dev) {
+                LOGE("Cannot start volume '%s' (volume is not bound to a blkdev)\n", mount_point);
+                pthread_mutex_unlock(&v->lock);
+                return -ENOENT;
+            }
+
+            if (_volmgr_consider_disk_and_vol(v, v->dev->disk) < 0) {
+                LOGE("volmgr failed to start volume '%s'\n", v->mount_point);
+            }
+            pthread_mutex_unlock(&v->lock);
+            return 0;
+        }
+        v = v->next;
+    }
+
+    return -ENOENT;
+}
+
+int volmgr_stop_volume_by_mountpoint(char *mount_point)
+{
+    volume_t *v = vol_root;
+
+    while(v) {
+        if (!strcmp(v->mount_point, mount_point)) {
+            pthread_mutex_lock(&v->lock);
+            if (volmgr_shutdown_volume(v, _cb_volstopped_for_ums_enable) < 0)
+                LOGE("unable to shutdown volume '%s'\n", v->mount_point);
+            pthread_mutex_unlock(&v->lock);
+            return 0;
+        }
+        v = v->next;
+    }
+
+    return -ENOENT;
+}
+
+int volmgr_notify_eject(blkdev_t *dev, void (* cb) (blkdev_t *))
+{
+#if DEBUG_VOLMGR
+    LOG_VOL("volmgr_notify_eject(%s)\n", dev->dev_fspath);
+#endif
+
+    volume_t *v;
+
+    // XXX: Partitioning support is going to need us to stop *all*
+    // devices in this volume
+    if (!(v = volmgr_lookup_volume_by_dev(dev))) {
+        if (cb)
+            cb(dev);
+        return 0;
+    }
+    
+    pthread_mutex_lock(&v->lock);
+    if (v->state == volstate_mounted) 
+        volume_setstate(v, volstate_badremoval);
+
+    int rc = volmgr_stop_volume(v, _cb_volume_stopped_for_eject, cb, false);
+
+    pthread_mutex_unlock(&v->lock);
+    return rc;
+}
+
+static void _cb_volume_stopped_for_eject(volume_t *v, void *arg)
+{
+    void (* eject_cb) (blkdev_t *) = arg;
+    LOG_VOL("Volume %s has been stopped for eject\n", v->mount_point);
+
+    eject_cb(v->dev);
+    v->dev = NULL; // Clear dev because its being ejected
+}
+
+/*
+ * Instructs the volume manager to enable or disable USB mass storage
+ * on any volumes configured to use it.
+ */
+int volmgr_enable_ums(boolean enable)
+{
+    volume_t *v = vol_root;
+
+    while(v) {
+        if (v->ums_path) {
+            int rc;
+
+            pthread_mutex_lock(&v->lock);
+            if (enable) {
+                // Stop the volume, and enable UMS in the callback
+                if ((rc = volmgr_shutdown_volume(v, _cb_volstopped_for_ums_enable)) < 0)
+                    LOGE("unable to shutdown volume '%s'\n", v->mount_point);
+            } else {
+                // Disable UMS
+                if ((rc = ums_disable(v->ums_path)) < 0) {
+                    LOGE("unable to disable ums on '%s'\n", v->mount_point);
+                    pthread_mutex_unlock(&v->lock);
+                    continue;
+                }
+                volume_setstate(v, volstate_unmounted);
+
+                LOG_VOL("Kick-starting volume '%s' after UMS disable\n", v->dev->disk->dev_fspath);
+                // Start volume
+                if ((rc = _volmgr_consider_disk_and_vol(v, v->dev->disk)) < 0) {
+                    LOGE("volmgr failed to consider disk '%s'\n", v->dev->disk->dev_fspath);
+                }
+            }
+            pthread_mutex_unlock(&v->lock);
+        }
+        v = v->next;
+    }
+    return 0;
+}
+
+/*
+ * Static functions
+ */
+
+// vol->lock must be held!
+static int _volmgr_consider_disk_and_vol(volume_t *vol, blkdev_t *dev)
+{
+    int rc = 0;
+
+#if DEBUG_VOLMGR
+    LOG_VOL("volmgr_consider_disk_and_vol(%s, %s):\n", vol->mount_point, dev->dev_fspath);
+#endif
+
+    if (vol->state != volstate_nomedia && vol->state != volstate_unmounted) {
+        LOGE("Volume manager is already handling volume '%s' (currently in state %d)\n", vol->mount_point, vol->state);
+        return -EADDRINUSE;
+    }
+
+    volume_setstate(vol, volstate_unmounted);
+
+    LOG_VOL("Evaluating dev '%s' for mountable filesystems for '%s'\n", dev->devpath, vol->mount_point);
+
+    if (dev->nr_parts == 0) {
+        rc = _volmgr_start(vol, dev);
+#if DEBUG_VOLMGR
+        LOG_VOL("_volmgr_start(%s, %s) rc = %d\n", vol->mount_point, dev->dev_fspath ,rc);
+#endif
+    } else {
+        /*
+         * Device has multiple partitions
+         * This is where interesting partition policies could be implemented.
+         * For now just try them in sequence until one succeeds
+         */
+   
+        rc = -ENODEV;
+        int i;
+        for (i = 0; i < dev->nr_parts; i++) {
+            blkdev_t *part = blkdev_lookup_by_devno(dev->major, (i+1));
+            if (!part) {
+                LOGE("Error - unable to lookup partition for blkdev %d:%d\n", dev->major, (i+1));
+                continue;
+            }
+            rc = _volmgr_start(vol, part);
+#if DEBUG_VOLMGR
+            LOG_VOL("_volmgr_start(%s, %s) rc = %d\n", vol->mount_point, part->dev_fspath, rc);
+#endif
+            if (!rc) 
+                break;
+        }
+
+        if (rc == -ENODEV) {
+            // Assert to make sure each partition had a backing blkdev
+            LOGE("Internal consistency error\n");
+            return 0;
+        }
+    }
+
+    if (rc == -ENODATA) {
+        LOGE("Device %s contains no usable filesystems\n", dev->dev_fspath);
+        rc = 0;
+    }
+
+    return rc;
+}
+
+static void volmgr_reaper_thread_sighandler(int signo)
+{
+    LOGE("volmgr reaper thread got signal %d\n", signo);
+}
+
+static void __reaper_cleanup(void *arg)
+{
+    volume_t *vol = (volume_t *) arg;
+
+    LOG_VOL("__reaper_cleanup(%s):\n", vol->mount_point);
+
+    vol->worker_running = false;
+
+    // Wake up anyone that was waiting on this thread
+    pthread_mutex_unlock(&vol->worker_sem);
+
+    // Unlock the volume
+    pthread_mutex_unlock(&vol->lock);
+}
+
+static void *volmgr_reaper_thread(void *arg)
+{
+    volume_t *vol = (volume_t *) arg;
+
+    pthread_cleanup_push(__reaper_cleanup, arg);
+    pthread_mutex_lock(&vol->lock);
+
+    vol->worker_running = true;
+    vol->worker_pid = getpid();
+
+    struct sigaction actions;
+
+    memset(&actions, 0, sizeof(actions));
+    sigemptyset(&actions.sa_mask);
+    actions.sa_flags = 0;
+    actions.sa_handler = volmgr_reaper_thread_sighandler;
+    sigaction(SIGUSR1, &actions, NULL);
+
+    LOG_VOL("Worker thread pid %d reaping %s\n", getpid(), vol->mount_point);
+
+    boolean send_sig_kill = false;
+    int i, rc;
+
+    for (i = 0; i < 10; i++) {
+        rc = umount(vol->mount_point);
+        LOG_VOL("volmngr reaper umount(%s) attempt %d rc = %d\n",
+                vol->mount_point, i + 1, rc);
+        if (!rc)
+            break;
+        if (rc && (errno == EINVAL || errno == ENOENT)) {
+            rc = 0;
+            break;
+        }
+        KillProcessesWithOpenFiles(vol->mount_point, send_sig_kill, NULL, 0);
+        sleep(1);
+        if (!send_sig_kill)
+            send_sig_kill = true;
+    }
+
+    if (!rc) {
+        LOG_VOL("Reaper sucessfully unmounted %s\n", vol->mount_point);
+        volume_setstate(vol, volstate_unmounted);
+    } else {
+        LOGE("Unable to unmount!! (%d)\n", rc);
+    }
+
+ out:
+    pthread_cleanup_pop(1);
+    pthread_exit(NULL);
+    return NULL;
+}
+
+static void volmgr_uncage_reaper(volume_t *vol)
+{
+    if (vol->worker_running) {
+        LOGE("Worker thread is currently running.. waiting..\n");
+        pthread_mutex_lock(&vol->worker_sem);
+        LOG_VOL("Worker thread now available\n");
+    }
+
+    vol->worker_args.fs = NULL;
+    vol->worker_args.dev = NULL;
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+
+    pthread_create(&vol->worker_thread, &attr, volmgr_reaper_thread, vol);
+}
+
+static int volmgr_stop_volume(volume_t *v, void (*cb) (volume_t *, void *), void *arg, boolean emit_statechange)
+{
+    int i, rc;
+
+    if (v->state == volstate_mounted || v->state == volstate_badremoval) {
+        // Try to unmount right away (5 retries)
+        for (i = 0; i < 5; i++) {
+            rc = umount(v->mount_point);
+            LOG_VOL("volmngr quick stop umount(%s) attempt %d rc = %d\n",
+                    v->mount_point, i + 1, rc);
+            if (!rc)
+                break;
+            if (rc && (errno == EINVAL || errno == ENOENT)) {
+                rc = 0;
+                break;
+            }
+            sched_yield();
+        }
+
+        if (!rc) {
+            LOG_VOL("volmgr_stop_volume(%s): Volume unmounted sucessfully\n",
+                    v->mount_point);
+            if (emit_statechange)
+                volume_setstate(v, volstate_unmounted);
+            goto out_cb_immed;
+        }
+
+        /*
+         * Since the volume is still in use, dispatch the stopping to
+         * a thread
+         */
+        LOG_VOL("Volume %s is busy (%d) - uncaging the reaper\n", v->mount_point, rc);
+        volmgr_uncage_reaper(v);
+        return -EINPROGRESS;
+    } else if (v->state == volstate_checking) {
+        volume_setstate(v, volstate_unmounted);
+        if (v->worker_running) {
+            LOG_VOL("Cancelling worker thread\n");
+            pthread_kill(v->worker_thread, SIGUSR1);
+        } else
+            LOGE("Strange... we were in checking state but worker thread wasn't running..\n");
+        goto out_cb_immed;
+    }
+
+    LOGE("volmgr: nothing to do to stop vol '%s' (in state %d)\n",
+             v->mount_point, v->state);
+ out_cb_immed:
+    if (cb)
+        cb(v, arg);
+    return 0;
+}
+
+
+/*
+ * Gracefully stop a volume
+ */
+static int volmgr_shutdown_volume(volume_t *v, void (* cb) (volume_t *))
+{
+    return volmgr_stop_volume(v, NULL, cb, true);
+}
+
+static void _cb_volume_stopped_for_shutdown(volume_t *v, void *arg)
+{
+    void (* shutdown_cb) (volume_t *) = arg;
+
+    LOG_VOL("Volume %s has been stopped for shutdown\n", v->mount_point);
+    shutdown_cb(v);
+}
+
+/*
+ * Called when a volume is sucessfully unmounted for UMS enable
+ */
+static void _cb_volstopped_for_ums_enable(volume_t *v)
+{
+    int rc;
+
+    if ((rc = ums_enable(v->dev->dev_fspath, v->ums_path)) < 0) {
+        LOGE("Error enabling ums (%d)\n", rc);
+        return;
+    }
+    volume_setstate(v, volstate_ums);
+}
+
+static int volmgr_readconfig(char *cfg_path)
+{
+    cnode *root = config_node("", "");
+    cnode *node;
+
+    config_load_file(root, cfg_path);
+    node = root->first_child;
+
+    while (node) {
+        if (!strcmp(node->name, "volume"))
+            volmgr_config_volume(node);
+        else
+            LOGE("Skipping unknown configuration node '%s'\n", node->name);
+        node = node->next;
+    }
+    return 0;
+}
+
+static int volmgr_config_volume(cnode *node)
+{
+    volume_t *new;
+    int rc = 0;
+
+    if (!(new = malloc(sizeof(volume_t))))
+        return -ENOMEM;
+    memset(new, 0, sizeof(volume_t));
+
+    new->state = volstate_nomedia;
+    pthread_mutex_init(&new->lock, NULL);
+    pthread_mutex_init(&new->worker_sem, NULL);
+
+    cnode *child = node->first_child;
+
+    while (child) {
+        if (!strcmp(child->name, "media_path"))
+            new->media_path = strdup(child->value);
+        else if (!strcmp(child->name, "media_type")) {
+            if (!strcmp(child->value, "mmc"))
+                new->media_type = media_mmc;
+            else {
+                LOGE("Invalid media type '%s'\n", child->value);
+                rc = -EINVAL;
+                goto out_free;
+            }
+        } else if (!strcmp(child->name, "mount_point"))
+            new->mount_point = strdup(child->value);
+        else if (!strcmp(child->name, "ums_path"))
+            new->ums_path = strdup(child->value);
+        else
+            LOGE("Ignoring unknown config entry '%s'\n", child->name);
+        child = child->next;
+    }
+
+    if (!new->media_path || !new->mount_point || new->media_type == media_unknown) {
+        LOGE("Required configuration parameter missing for volume\n");
+        rc = -EINVAL;
+        goto out_free;
+    }
+
+    if (!vol_root)
+        vol_root = new;
+    else {
+        volume_t *scan = vol_root;
+        while (scan->next)
+            scan = scan->next;
+        scan->next = new;
+    }
+
+    return rc;
+
+ out_free:
+    if (new->media_path)
+        free(new->media_path);
+    if (new->mount_point)
+        free(new->mount_point);
+    if (new->ums_path)
+        free(new->ums_path);
+    return rc;
+}
+
+static volume_t *volmgr_lookup_volume_by_dev(blkdev_t *dev)
+{
+    volume_t *scan = vol_root;
+    while(scan) {
+        if (scan->dev == dev)
+            return scan;
+        scan = scan->next;
+    }
+    return NULL;
+}
+
+static volume_t *volmgr_lookup_volume_by_mediapath(char *media_path, boolean fuzzy)
+{
+    volume_t *scan = vol_root;
+    volume_t *res = NULL;
+
+    while (scan) {
+        if (fuzzy) {
+            if (!strncmp(media_path, scan->media_path, strlen(scan->media_path))) {
+                if (!res)
+                    res = scan;
+                else {
+                    LOGE("Warning - multiple matching volumes for media '%s' - using first\n", media_path);
+                    break;
+                }
+            }
+        } else if (!strcmp(media_path, scan->media_path))
+            return scan;
+
+        scan = scan->next;
+    }
+    return res;
+}
+
+/*
+ * Attempt to bring a volume online
+ * Returns: 0 on success, errno on failure, with the following exceptions:
+ *     - ENODATA - Unsupported filesystem type / blank
+ * vol->lock MUST be held!
+ */
+static int _volmgr_start(volume_t *vol, blkdev_t *dev)
+{
+    struct volmgr_fstable_entry *fs;
+    int rc = ENODATA;
+
+#if DEBUG_VOLMGR
+    LOG_VOL("_volmgr_start(%s, %s):\n", vol->mount_point, dev->dev_fspath);
+#endif
+
+    for (fs = fs_table; fs->name; fs++) {
+        if (!fs->identify_fn(dev))
+            break;
+    }
+
+    if (!fs) {
+        LOGE("No supported filesystems on %s\n", dev->dev_fspath);
+        volume_setstate(vol, volstate_nofs);
+        return -ENODATA;
+    }
+
+    return volmgr_start_fs(fs, vol, dev);
+}
+
+// vol->lock MUST be held!
+static int volmgr_start_fs(struct volmgr_fstable_entry *fs, volume_t *vol, blkdev_t *dev)
+{
+    /*
+     * Spawn a thread to do the actual checking / mounting in
+     */
+
+    if (vol->worker_running) {
+        LOGE("Worker thread is currently running.. waiting..\n");
+        pthread_mutex_lock(&vol->worker_sem);
+        LOG_VOL("Worker thread now available\n");
+    }
+
+    vol->dev = dev; 
+
+    vol->worker_args.fs = fs;
+    vol->worker_args.dev = dev;
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+
+    pthread_create(&vol->worker_thread, &attr, volmgr_start_fs_thread, vol);
+
+    return 0;
+}
+
+static void __start_fs_thread_lock_cleanup(void *arg)
+{
+    volume_t *vol = (volume_t *) arg;
+
+    LOG_VOL("__start_fs_thread_lock_cleanup(%s):\n", vol->mount_point);
+
+    vol->worker_running = false;
+
+    // Wake up anyone that was waiting on this thread
+    pthread_mutex_unlock(&vol->worker_sem);
+
+    // Unlock the volume
+    pthread_mutex_unlock(&vol->lock);
+}
+
+static void *volmgr_start_fs_thread(void *arg)
+{
+    volume_t *vol = (volume_t *) arg;
+
+    pthread_cleanup_push(__start_fs_thread_lock_cleanup, arg);
+    pthread_mutex_lock(&vol->lock);
+
+    vol->worker_running = true;
+    vol->worker_pid = getpid();
+
+    struct sigaction actions;
+
+    memset(&actions, 0, sizeof(actions));
+    sigemptyset(&actions.sa_mask);
+    actions.sa_flags = 0;
+    actions.sa_handler = volmgr_start_fs_thread_sighandler;
+    sigaction(SIGUSR1, &actions, NULL);
+
+    struct volmgr_fstable_entry *fs = vol->worker_args.fs;
+    blkdev_t                    *dev = vol->worker_args.dev;
+    int                          rc;
+  
+    LOG_VOL("Worker thread pid %d starting %s fs %s on %s\n", getpid(), fs->name, dev->dev_fspath, vol->mount_point);
+
+    if (fs->check_fn) {
+        LOG_VOL("Starting %s filesystem check on %s\n", fs->name, dev->dev_fspath);
+        volume_setstate(vol, volstate_checking);
+        pthread_mutex_unlock(&vol->lock);
+        rc = fs->check_fn(dev);
+        pthread_mutex_lock(&vol->lock);
+        if (vol->state != volstate_checking) {
+            LOG_VOL("filesystem check aborted\n");
+            goto out;
+        }
+        
+        if (rc < 0) {
+            LOG_VOL("%s filesystem check failed on %s\n", fs->name, dev->dev_fspath);
+            goto out_unmountable;
+        }
+        LOG_VOL("%s filesystem check of %s OK\n", fs->name, dev->dev_fspath);
+    }
+
+    rc = fs->mount_fn(dev, vol);
+    if (!rc) {
+        LOG_VOL("Sucessfully mounted %s filesystem %s on %s\n", fs->name, dev->devpath, vol->mount_point);
+        volume_setstate(vol, volstate_mounted);
+        goto out;
+    }
+
+    LOGE("%s filesystem mount of %s failed (%d)\n", fs->name, dev->devpath, rc);
+
+ out_unmountable:
+    volume_setstate(vol, volstate_damaged);
+ out:
+    pthread_cleanup_pop(1);
+    pthread_exit(NULL);
+    return NULL;
+}
+
+static void volmgr_start_fs_thread_sighandler(int signo)
+{
+    LOGE("volmgr thread got signal %d\n", signo);
+}
+
+static void volume_setstate(volume_t *vol, volume_state_t state)
+{
+    LOG_VOL("Volume %s state change from %d -> %d\n", vol->mount_point, vol->state, state);
+    
+    vol->state = state;
+    
+    char *prop_val = conv_volstate_to_propstr(vol->state);
+
+    property_set(PROP_EXTERNAL_STORAGE_STATE, prop_val);
+    volume_send_state(vol);
+}
+
+static int volume_send_state(volume_t *vol)
+{
+    char *event = conv_volstate_to_eventstr(vol->state);
+
+    return send_msg_with_data(event, vol->mount_point);
+}
+
+static char *conv_volstate_to_eventstr(volume_state_t state)
+{
+    int i;
+
+    for (i = 0; volume_state_strings[i].event != NULL; i++) {
+        if (volume_state_strings[i].state == state)
+            break;
+    }
+
+    if (!volume_state_strings[i].event)
+        LOGE("conv_volstate_to_eventstr(%d): Invalid state\n", state);
+    return volume_state_strings[i].event;
+}
+
+static char *conv_volstate_to_propstr(volume_state_t state)
+{
+    int i;
+
+    for (i = 0; volume_state_strings[i].event != NULL; i++) {
+        if (volume_state_strings[i].state == state)
+            break;
+    }
+
+    if (!volume_state_strings[i].event)
+        LOGE("conv_volstate_to_propval(%d): Invalid state\n", state);
+    return volume_state_strings[i].property_val;
+}
+