Initial Contribution
diff --git a/mountd/Android.mk b/mountd/Android.mk
new file mode 100644
index 0000000..87bcef3
--- /dev/null
+++ b/mountd/Android.mk
@@ -0,0 +1,19 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ AutoMount.c \
+ ProcessKiller.c \
+ Server.c \
+ mountd.c
+
+LOCAL_MODULE:= mountd
+
+LOCAL_C_INCLUDES := $(KERNEL_HEADERS)
+
+LOCAL_CFLAGS := -DCREATE_MOUNT_POINTS=0
+
+LOCAL_SHARED_LIBRARIES := libcutils
+
+include $(BUILD_EXECUTABLE)
diff --git a/mountd/AutoMount.c b/mountd/AutoMount.c
new file mode 100644
index 0000000..bfe8ad1
--- /dev/null
+++ b/mountd/AutoMount.c
@@ -0,0 +1,924 @@
+/*
+ * 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.
+ */
+
+/*
+** mountd automount support
+*/
+
+#include "mountd.h"
+
+#include <pthread.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <poll.h>
+
+#include <sys/mount.h>
+#include <sys/stat.h>
+#include <linux/loop.h>
+#include <sys/inotify.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <linux/netlink.h>
+
+#define DEVPATH "/dev/block/"
+#define DEVPATHLENGTH 11 // strlen(DEVPATH)
+
+// FIXME - only one loop mount is supported at a time
+#define LOOP_DEVICE "/dev/block/loop0"
+
+// timeout value for poll() when retries are pending
+#define POLL_TIMEOUT 1000
+
+#define MAX_MOUNT_RETRIES 3
+#define MAX_UNMOUNT_RETRIES 5
+
+typedef enum {
+ // device is unmounted
+ kUnmounted,
+
+ // attempting to mount device
+ kMounting,
+
+ // device is unmounted
+ kMounted,
+
+ // attempting to unmount device
+ // so the media can be removed
+ kUnmountingForEject,
+
+ // attempting to mount device
+ // so it can be shared via USB mass storage
+ kUnmountingForUms,
+} MountState;
+
+typedef struct MountPoint {
+ // block device to mount
+ const char* device;
+
+ // mount point for device
+ const char* mountPoint;
+
+ // true if device can be shared via
+ // USB mass storage
+ boolean enableUms;
+
+ // true if the device is being shared via USB mass storage
+ boolean umsActive;
+
+ // logical unit number (for UMS)
+ int lun;
+
+ // current state of the mount point
+ MountState state;
+
+ // number of mount or unmount retries so far,
+ // when attempting to mount or unmount the device
+ int retryCount;
+
+ // next in sMountPointList linked list
+ struct MountPoint* next;
+} MountPoint;
+
+// list of our mount points (does not change after initialization)
+static MountPoint* sMountPointList = NULL;
+static int sNextLun = 0;
+boolean gMassStorageEnabled = false;
+boolean gMassStorageConnected = false;
+
+static pthread_t sAutoMountThread = 0;
+
+// number of mount points that have timeouts pending
+static int sRetriesPending = 0;
+
+// for synchronization between sAutoMountThread and the server thread
+static pthread_mutex_t sMutex = PTHREAD_MUTEX_INITIALIZER;
+
+// requests the USB mass_storage driver to begin or end sharing a block device
+// via USB mass storage.
+static void SetBackingStore(MountPoint* mp, boolean enable)
+{
+ char path[PATH_MAX];
+ int fd;
+
+ LOG_MOUNT("SetBackingStore enable: %s\n", (enable ? "true" : "false"));
+ snprintf(path, sizeof(path), "/sys/devices/platform/usb_mass_storage/lun%d/file", mp->lun);
+ fd = open(path, O_WRONLY);
+ if (fd < 0)
+ {
+ LOG_ERROR("could not open %s\n", path);
+ }
+ else
+ {
+ if (enable)
+ {
+ write(fd, mp->device, strlen(mp->device));
+ mp->umsActive = true;
+ }
+ else
+ {
+ char ch = 0;
+ write(fd, &ch, 1);
+ mp->umsActive = false;
+ }
+ close(fd);
+ }
+}
+
+static boolean ReadMassStorageState()
+{
+ FILE* file = fopen("/sys/class/switch/usb_mass_storage/state", "r");
+ if (file)
+ {
+ char buffer[20];
+ fgets(buffer, sizeof(buffer), file);
+ fclose(file);
+ return (strncmp(buffer, "online", strlen("online")) == 0);
+ }
+ else
+ {
+ LOG_ERROR("could not read initial mass storage state\n");
+ return false;
+ }
+}
+
+static boolean IsLoopMounted(const char* path)
+{
+ FILE* f;
+ int count;
+ char device[256];
+ char mount_path[256];
+ char rest[256];
+ int result = 0;
+ int path_length = strlen(path);
+
+ f = fopen("/proc/mounts", "r");
+ if (!f) {
+ LOG_ERROR("could not open /proc/mounts\n");
+ return -1;
+ }
+
+ do {
+ count = fscanf(f, "%255s %255s %255s\n", device, mount_path, rest);
+ if (count == 3) {
+ if (strcmp(LOOP_DEVICE, device) == 0 && strcmp(path, mount_path) == 0)
+ {
+ result = 1;
+ break;
+ }
+ }
+ } while (count == 3);
+
+ fclose(f);
+ LOG_MOUNT("IsLoopMounted: %s returning %d\n", path, result);
+ return result;
+}
+
+static int DoMountDevice(const char* device, const char* mountPoint)
+{
+ LOG_MOUNT("mounting %s at %s\n", device, mountPoint);
+
+#if CREATE_MOUNT_POINTS
+ // make sure mount point exists
+ mkdir(mountPoint, 0000);
+#endif
+
+ int flags = 0;
+
+ if (device && strncmp(device, "/dev/", 5))
+ {
+ // mount with the loop driver if device does not start with "/dev/"
+ int file_fd, device_fd;
+
+ // FIXME - only one loop mount supported at a time
+ file_fd = open(device, O_RDWR);
+ if (file_fd < -1) {
+ LOG_ERROR("open backing file %s failed\n", device);
+ return 1;
+ }
+ device_fd = open(LOOP_DEVICE, O_RDWR);
+ if (device_fd < -1) {
+ LOG_ERROR("open %s failed", LOOP_DEVICE);
+ close(file_fd);
+ return 1;
+ }
+ if (ioctl(device_fd, LOOP_SET_FD, file_fd) < 0)
+ {
+ LOG_ERROR("ioctl LOOP_SET_FD failed\n");
+ close(file_fd);
+ close(device_fd);
+ return 1;
+ }
+
+ close(file_fd);
+ close(device_fd);
+ device = "/dev/block/loop0";
+ }
+
+ int result = access(device, R_OK);
+ if (result != 0)
+ return result;
+
+ // Extra safety measures:
+ flags |= MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_DIRSYNC;
+ // Also, set fmask = 711 so that files cannot be marked executable,
+ // and cannot by opened by uid 1000 (system). Similar, dmask = 700
+ // so that directories cannot be accessed by uid 1000.
+ result = mount(device, mountPoint, "vfat", flags,
+ "utf8,uid=1000,gid=1000,fmask=711,dmask=700");
+ if (result && errno == EROFS) {
+ LOG_ERROR("mount failed EROFS, try again read-only\n");
+ flags |= MS_RDONLY;
+ result = mount(device, mountPoint, "vfat", flags,
+ "utf8,uid=1000,gid=1000,fmask=711,dmask=700");
+ }
+ LOG_MOUNT("mount returned %d errno: %d\n", result, errno);
+
+ if (result == 0) {
+ NotifyMediaState(mountPoint, MEDIA_MOUNTED, (flags & MS_RDONLY) != 0);
+ } else if (errno == EBUSY) {
+ // ignore EBUSY, since it usually means the device is already mounted
+ result = 0;
+ } else {
+#if CREATE_MOUNT_POINTS
+ rmdir(mountPoint);
+#endif
+ LOG_MOUNT("mount failed, errno: %d\n", errno);
+ }
+
+ return result;
+}
+
+static int DoUnmountDevice(const char* mountPoint)
+{
+ boolean loop = IsLoopMounted(mountPoint);
+ int result = umount(mountPoint);
+ LOG_MOUNT("umount returned %d errno: %d\n", result, errno);
+
+ if (result == 0)
+ {
+ if (loop)
+ {
+ // free the loop device
+ int loop_fd = open(LOOP_DEVICE, O_RDONLY);
+ if (loop_fd < -1) {
+ LOG_ERROR("open loop device failed\n");
+ }
+ if (ioctl(loop_fd, LOOP_CLR_FD, 0) < 0) {
+ LOG_ERROR("ioctl LOOP_CLR_FD failed\n");
+ }
+
+ close(loop_fd);
+ }
+
+#if CREATE_MOUNT_POINTS
+ rmdir(mountPoint);
+#endif
+ NotifyMediaState(mountPoint, MEDIA_UNMOUNTED, false);
+ }
+
+ // ignore EINVAL and ENOENT, since it usually means the device is already unmounted
+ if (result && (errno == EINVAL || errno == ENOENT))
+ result = 0;
+
+ return result;
+}
+
+static int MountPartition(const char* device, const char* mountPoint)
+{
+ char buf[100];
+ int i;
+
+ // attempt to mount subpartitions of the device
+ for (i = 1; i < 10; i++)
+ {
+ snprintf(buf, sizeof(buf), "%sp%d", device, i);
+ if (DoMountDevice(buf, mountPoint) == 0)
+ return 0;
+ }
+
+ return -1;
+}
+
+/*****************************************************
+ *
+ * AUTO-MOUNTER STATE ENGINE IMPLEMENTATION
+ *
+ *****************************************************/
+
+static void SetState(MountPoint* mp, MountState state)
+{
+ mp->state = state;
+}
+
+// Enter a state that requires retries and timeouts.
+static void SetRetries(MountPoint* mp, MountState state)
+{
+ SetState(mp, state);
+ mp->retryCount = 0;
+
+ sRetriesPending++;
+ // wake up the automounter thread if we are being called
+ // from somewhere else with no retries pending
+ if (sRetriesPending == 1 && sAutoMountThread != 0 &&
+ pthread_self() != sAutoMountThread)
+ pthread_kill(sAutoMountThread, SIGUSR1);
+}
+
+// Exit a state that requires retries and timeouts.
+static void ClearRetries(MountPoint* mp, MountState state)
+{
+ SetState(mp, state);
+ sRetriesPending--;
+}
+
+// attempt to mount the specified mount point.
+// set up retry/timeout if it does not succeed at first.
+static void RequestMount(MountPoint* mp)
+{
+ LOG_MOUNT("RequestMount %s\n", mp->mountPoint);
+
+ if (mp->state != kMounted && mp->state != kMounting &&
+ access(mp->device, R_OK) == 0) {
+ // try raw device first
+ if (DoMountDevice(mp->device, mp->mountPoint) == 0 ||
+ MountPartition(mp->device, mp->mountPoint) == 0)
+ {
+ SetState(mp, kMounted);
+ }
+ else
+ {
+ SetState(mp, kMounting);
+ mp->retryCount = 0;
+ SetRetries(mp, kMounting);
+ }
+ }
+}
+
+// Force the kernel to drop all caches.
+static void DropSystemCaches(void)
+{
+ int fd;
+
+ LOG_MOUNT("Dropping system caches\n");
+ fd = open("/proc/sys/vm/drop_caches", O_WRONLY);
+
+ if (fd > 0) {
+ char ch = 3;
+ int rc;
+
+ rc = write(fd, &ch, 1);
+ if (rc <= 0)
+ LOG_MOUNT("Error dropping caches (%d)\n", rc);
+ close(fd);
+ }
+}
+
+// attempt to unmount the specified mount point.
+// set up retry/timeout if it does not succeed at first.
+static void RequestUnmount(MountPoint* mp, MountState retryState)
+{
+ int result;
+
+ LOG_MOUNT("RequestUnmount %s retryState: %d\n", mp->mountPoint, retryState);
+
+ if (mp->state == kMounted)
+ {
+ SendUnmountRequest(mp->mountPoint);
+
+ // do this in case the user pulls the SD card before we can successfully unmount
+ sync();
+ DropSystemCaches();
+
+ if (DoUnmountDevice(mp->mountPoint) == 0)
+ {
+ SetState(mp, kUnmounted);
+ if (retryState == kUnmountingForUms)
+ {
+ SetBackingStore(mp, true);
+ NotifyMediaState(mp->mountPoint, MEDIA_SHARED, false);
+ }
+ }
+ else
+ {
+ LOG_MOUNT("unmount failed, set retry\n");
+ SetRetries(mp, retryState);
+ }
+ }
+ else if (mp->state == kMounting)
+ {
+ SetState(mp, kUnmounted);
+ }
+}
+
+// returns true if the mount point should be shared via USB mass storage
+static boolean MassStorageEnabledForMountPoint(const MountPoint* mp)
+{
+ return (gMassStorageEnabled && gMassStorageConnected && mp->enableUms);
+}
+
+// handles changes in gMassStorageEnabled and gMassStorageConnected
+static void MassStorageStateChanged()
+{
+ MountPoint* mp = sMountPointList;
+
+ boolean enable = (gMassStorageEnabled && gMassStorageConnected);
+ LOG_MOUNT("MassStorageStateChanged enable: %s\n", (enable ? "true" : "false"));
+
+ while (mp)
+ {
+ if (mp->enableUms)
+ {
+ if (enable)
+ {
+ if (mp->state == kMounting)
+ SetState(mp, kUnmounted);
+ if (mp->state == kUnmounted)
+ {
+ SetBackingStore(mp, true);
+ NotifyMediaState(mp->mountPoint, MEDIA_SHARED, false);
+ }
+ else
+ {
+ LOG_MOUNT("MassStorageStateChanged requesting unmount\n");
+ // need to successfully unmount first
+ RequestUnmount(mp, kUnmountingForUms);
+ }
+ } else if (mp->umsActive) {
+ SetBackingStore(mp, false);
+ if (mp->state == kUnmountingForUms)
+ {
+ ClearRetries(mp, kMounted);
+ NotifyMediaState(mp->mountPoint, MEDIA_MOUNTED, false);
+ }
+ else if (mp->state == kUnmounted)
+ {
+ NotifyMediaState(mp->mountPoint, MEDIA_UNMOUNTED, false);
+ RequestMount(mp);
+ }
+ }
+ }
+
+ mp = mp->next;
+ }
+}
+
+// called when USB mass storage connected state changes
+static void HandleMassStorageOnline(boolean connected)
+{
+ if (connected != gMassStorageConnected)
+ {
+ gMassStorageConnected = connected;
+ SendMassStorageConnected(connected);
+
+ // we automatically reset to mass storage off after USB is connected
+ if (!connected)
+ gMassStorageEnabled = false;
+
+ MassStorageStateChanged();
+ }
+}
+
+// called when a new block device has been created
+static void HandleMediaInserted(const char* device)
+{
+ MountPoint* mp = sMountPointList;
+
+ while (mp)
+ {
+ // see if the device matches mount point's block device
+ if (mp->state == kUnmounted &&
+ strncmp(device, mp->device + DEVPATHLENGTH, strlen(mp->device) - DEVPATHLENGTH) == 0)
+ {
+ if (MassStorageEnabledForMountPoint(mp))
+ {
+ SetBackingStore(mp, true);
+ NotifyMediaState(mp->mountPoint, MEDIA_SHARED, false);
+ }
+ else
+ RequestMount(mp);
+ }
+ mp = mp->next;
+ }
+}
+
+// called when a new block device has been deleted
+static void HandleMediaRemoved(const char* device)
+{
+ MountPoint* mp = sMountPointList;
+ while (mp)
+ {
+ if (strncmp(device, mp->device + DEVPATHLENGTH, strlen(mp->device) - DEVPATHLENGTH) == 0)
+ {
+ if (mp->enableUms)
+ SetBackingStore(mp, false);
+
+ if (mp->state == kMounted)
+ {
+ RequestUnmount(mp, kUnmountingForEject);
+ NotifyMediaState(mp->mountPoint, MEDIA_BAD_REMOVAL, false);
+ }
+
+ NotifyMediaState(mp->mountPoint, MEDIA_REMOVED, false);
+ break;
+ }
+ mp = mp->next;
+ }
+}
+
+// Handle retrying to mount or unmount devices,
+// and handle timeout condition if we have tried too many times
+static void HandleRetries()
+{
+ MountPoint* mp = sMountPointList;
+
+ while (mp)
+ {
+ if (mp->state == kMounting)
+ {
+ if (MountPartition(mp->device, mp->mountPoint) == 0)
+ {
+ // mount succeeded - clear the retry for this mount point
+ ClearRetries(mp, kMounted);
+ }
+ else
+ {
+ mp->retryCount++;
+ if (mp->retryCount == MAX_MOUNT_RETRIES)
+ {
+ // we failed to mount the device too many times
+ ClearRetries(mp, kUnmounted);
+ // notify that we failed to mount
+ NotifyMediaState(mp->mountPoint, MEDIA_UNMOUNTABLE, false);
+ }
+ }
+ }
+ else if (mp->state == kUnmountingForEject || mp->state == kUnmountingForUms)
+ {
+ if (DoUnmountDevice(mp->mountPoint) == 0)
+ {
+ // unmounting succeeded
+ // start mass storage, if state is kUnmountingForUms
+ if (mp->state == kUnmountingForUms)
+ {
+ SetBackingStore(mp, true);
+ NotifyMediaState(mp->mountPoint, MEDIA_SHARED, false);
+ }
+ // clear the retry for this mount point
+ ClearRetries(mp, kUnmounted);
+ }
+ else
+ {
+ mp->retryCount++;
+ if (mp->retryCount >= MAX_UNMOUNT_RETRIES)
+ {
+ // kill any processes that are preventing the device from unmounting
+ // send SIGKILL instead of SIGTERM if the first attempt did not succeed
+ boolean sigkill = (mp->retryCount > MAX_UNMOUNT_RETRIES);
+
+ // unmounting the device is failing, so start killing processes
+ KillProcessesWithOpenFiles(mp->mountPoint, sigkill);
+ }
+ }
+ }
+
+ mp = mp->next;
+ }
+}
+
+/*****************************************************
+ *
+ * AUTO-MOUNTER THREAD
+ *
+ *****************************************************/
+
+static void sigusr1_handler(int signo)
+{
+ // don't need to do anything here
+}
+
+// create a socket for listening to inotify events
+int CreateINotifySocket()
+{
+ // initialize inotify
+ int fd = inotify_init();
+
+ if (fd < 0) {
+ LOG_ERROR("inotify_init failed, %s\n", strerror(errno));
+ return -1;
+ }
+
+ fcntl(fd, F_SETFL, O_NONBLOCK | fcntl(fd, F_GETFL));
+
+ return fd;
+}
+
+
+// create a socket for listening to uevents
+int CreateUEventSocket()
+{
+ struct sockaddr_nl addr;
+ int sz = 64*1024;
+ int fd;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+ addr.nl_pid = getpid();
+ addr.nl_groups = 0xffffffff;
+
+ fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
+ if(fd < 0)
+ {
+ LOG_ERROR("could not create NETLINK_KOBJECT_UEVENT socket\n");
+ return -1;
+ }
+
+ setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz));
+
+ if(bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ LOG_ERROR("could not bind NETLINK_KOBJECT_UEVENT socket\n");
+ close(fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+/*
+ * Automounter main event thread.
+ * This thread listens for block devices being created and deleted via inotify,
+ * and listens for changes in the USB mass storage connected/disconnected via uevents from the
+ * power supply driver.
+ * This thread also handles retries and timeouts for requests to mount or unmount a device.
+ */
+static void* AutoMountThread(void* arg)
+{
+ int inotify_fd;
+ int uevent_fd;
+ int id;
+ struct sigaction actions;
+
+ memset(&actions, 0, sizeof(actions));
+ sigemptyset(&actions.sa_mask);
+ actions.sa_flags = 0;
+ actions.sa_handler = sigusr1_handler;
+ sigaction(SIGUSR1, &actions, NULL);
+
+ // initialize inotify
+ inotify_fd = CreateINotifySocket();
+ // watch for files created and deleted in "/dev"
+ inotify_add_watch(inotify_fd, DEVPATH, IN_CREATE|IN_DELETE);
+
+ // initialize uevent watcher
+ uevent_fd = CreateUEventSocket();
+ if (uevent_fd < 0)
+ {
+ LOG_ERROR("CreateUEventSocket failed, %s\n", strerror(errno));
+ return NULL;
+ }
+
+ while (1)
+ {
+ struct pollfd fds[2];
+ int timeout, result;
+
+#define INOTIFY_IDX 0
+#define UEVENT_IDX 1
+
+ fds[INOTIFY_IDX].fd = inotify_fd;
+ fds[INOTIFY_IDX].events = POLLIN;
+ fds[INOTIFY_IDX].revents = 0;
+ fds[UEVENT_IDX].fd = uevent_fd;
+ fds[UEVENT_IDX].events = POLLIN;
+ fds[UEVENT_IDX].revents = 0;
+
+ // wait for an event or a timeout to occur.
+ // poll() can also return in response to a SIGUSR1 signal
+ timeout = (sRetriesPending ? POLL_TIMEOUT : -1);
+ result = poll(fds, 2, timeout);
+
+ // lock the mutex while we are handling events
+ pthread_mutex_lock(&sMutex);
+
+ // handle inotify notifications for block device creation and deletion
+ if (fds[INOTIFY_IDX].revents == POLLIN)
+ {
+ struct inotify_event event;
+ char buffer[512];
+ int length = read(inotify_fd, buffer, sizeof(buffer));
+ int offset = 0;
+
+ while (length >= (int)sizeof(struct inotify_event))
+ {
+ struct inotify_event* event = (struct inotify_event *)&buffer[offset];
+
+ if (event->mask == IN_CREATE)
+ {
+ LOG_MOUNT("/dev/block/%s created\n", event->name);
+ HandleMediaInserted(event->name);
+ }
+ else if (event->mask == IN_DELETE)
+ {
+ LOG_MOUNT("/dev/block/%s deleted\n", event->name);
+ HandleMediaRemoved(event->name);
+ }
+
+ int size = sizeof(struct inotify_event) + event->len;
+ length -= size;
+ offset += size;
+ }
+ }
+
+ // handle uevent notifications for USB state changes
+ if (fds[UEVENT_IDX].revents == POLLIN)
+ {
+ char buffer[64*1024];
+ int count;
+
+ count = recv(uevent_fd, buffer, sizeof(buffer), 0);
+ if (count > 0) {
+ char* s = buffer;
+ char* end = s + count;
+ char* type = NULL;
+ char* online = NULL;
+ char* switchName = NULL;
+ char* switchState = NULL;
+
+ while (s < end) {
+ if (!strncmp("POWER_SUPPLY_TYPE=", s, strlen("POWER_SUPPLY_TYPE=")))
+ type = s + strlen("POWER_SUPPLY_TYPE=");
+ else if (!strncmp("POWER_SUPPLY_ONLINE=", s, strlen("POWER_SUPPLY_ONLINE=")))
+ online = s + strlen("POWER_SUPPLY_ONLINE=");
+ else if (!strncmp("SWITCH_NAME=", s, strlen("SWITCH_NAME=")))
+ switchName = s + strlen("SWITCH_NAME=");
+ else if (!strncmp("SWITCH_STATE=", s, strlen("SWITCH_STATE=")))
+ switchState = s + strlen("SWITCH_STATE=");
+ s += (strlen(s) + 1);
+ }
+
+ // we use the usb_mass_storage switch state to tell us when USB is online
+ if (switchName && switchState &&
+ !strcmp(switchName, "usb_mass_storage") && !strcmp(switchState, "online"))
+ {
+ LOG_MOUNT("USB online\n");
+ HandleMassStorageOnline(true);
+ }
+
+ // and we use the power supply state to tell us when USB is offline
+ // we can't rely on the switch for offline detection because we get false positives
+ // when USB is reenumerated by the host.
+ if (type && online && !strcmp(type, "USB") && !strcmp(online, "0"))
+ {
+ LOG_MOUNT("USB offline\n");
+ HandleMassStorageOnline(false);
+ }
+ }
+ }
+
+ // handle retries
+ if (sRetriesPending)
+ HandleRetries();
+
+ // done handling events, so unlock the mutex
+ pthread_mutex_unlock(&sMutex);
+ }
+
+ inotify_rm_watch(inotify_fd, id);
+ close(inotify_fd);
+ close(uevent_fd);
+
+ return NULL;
+}
+
+/*****************************************************
+ *
+ * THESE FUNCTIONS ARE CALLED FROM THE SERVER THREAD
+ *
+ *****************************************************/
+
+// Called to enable or disable USB mass storage support
+void EnableMassStorage(boolean enable)
+{
+ pthread_mutex_lock(&sMutex);
+
+ LOG_MOUNT("EnableMassStorage %s\n", (enable ? "true" : "false"));
+ gMassStorageEnabled = enable;
+ MassStorageStateChanged();
+ pthread_mutex_unlock(&sMutex);
+ }
+
+// Called to request that the specified mount point be mounted
+void MountMedia(const char* mountPoint)
+{
+ MountPoint* mp = sMountPointList;
+
+ pthread_mutex_lock(&sMutex);
+ while (mp)
+ {
+ if (strcmp(mp->mountPoint, mountPoint) == 0)
+ {
+ if (mp->state == kUnmountingForEject)
+ {
+ // handle the case where we try to remount before we actually unmounted
+ ClearRetries(mp, kMounted);
+ }
+
+ // don't attempt to mount if mass storage is active
+ if (!MassStorageEnabledForMountPoint(mp))
+ RequestMount(mp);
+ }
+
+ mp = mp->next;
+ }
+ pthread_mutex_unlock(&sMutex);
+ }
+
+// Called to request that the specified mount point be unmounted
+void UnmountMedia(const char* mountPoint)
+{
+ MountPoint* mp = sMountPointList;
+
+ pthread_mutex_lock(&sMutex);
+ while (mp)
+ {
+ if (strcmp(mp->mountPoint, mountPoint) == 0)
+ RequestUnmount(mp, kUnmountingForEject);
+
+ mp = mp->next;
+ }
+ pthread_mutex_unlock(&sMutex);
+}
+
+boolean IsMassStorageEnabled()
+{
+ return gMassStorageEnabled;
+}
+
+boolean IsMassStorageConnected()
+{
+ return gMassStorageConnected;
+}
+
+/***********************************************
+ *
+ * THESE FUNCTIONS ARE CALLED ONLY AT STARTUP
+ *
+ ***********************************************/
+
+void AddMountPoint(const char* device, const char* mountPoint, boolean enableUms)
+{
+ MountPoint* newMountPoint;
+
+ LOG_MOUNT("AddMountPoint device: %s, mountPoint: %s\n", device, mountPoint);
+ // add a new MountPoint to the head of our linked list
+ newMountPoint = (MountPoint *)malloc(sizeof(MountPoint));
+ newMountPoint->device = device;
+ newMountPoint->mountPoint = mountPoint;
+ newMountPoint->enableUms = enableUms;
+ newMountPoint->umsActive = false;
+ if (enableUms)
+ newMountPoint->lun = sNextLun++;
+ newMountPoint->state = kUnmounted;
+ newMountPoint->retryCount = 0;
+
+ // add to linked list
+ newMountPoint->next = sMountPointList;
+ sMountPointList = newMountPoint;
+}
+
+static void MountDevices()
+{
+ MountPoint* mp = sMountPointList;
+ while (mp)
+ {
+ RequestMount(mp);
+ mp = mp->next;
+ }
+}
+
+void StartAutoMounter()
+{
+ gMassStorageConnected = ReadMassStorageState();
+ LOG_MOUNT(gMassStorageConnected ? "USB online\n" : "USB offline\n");
+
+ MountDevices();
+ pthread_create(&sAutoMountThread, NULL, AutoMountThread, NULL);
+}
diff --git a/mountd/MODULE_LICENSE_APACHE2 b/mountd/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/mountd/MODULE_LICENSE_APACHE2
diff --git a/mountd/NOTICE b/mountd/NOTICE
new file mode 100644
index 0000000..c5b1efa
--- /dev/null
+++ b/mountd/NOTICE
@@ -0,0 +1,190 @@
+
+ Copyright (c) 2005-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.
+
+ 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.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
diff --git a/mountd/ProcessKiller.c b/mountd/ProcessKiller.c
new file mode 100644
index 0000000..3ce7aa8
--- /dev/null
+++ b/mountd/ProcessKiller.c
@@ -0,0 +1,209 @@
+/*
+ * 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.
+ */
+
+/*
+** mountd process killer
+*/
+
+#include "mountd.h"
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <poll.h>
+#include <sys/stat.h>
+
+
+static boolean ReadSymLink(const char* path, char* link)
+{
+ struct stat s;
+ int length;
+
+ if (lstat(path, &s) < 0)
+ return false;
+ if ((s.st_mode & S_IFMT) != S_IFLNK)
+ return false;
+
+ // we have a symlink
+ length = readlink(path, link, PATH_MAX - 1);
+ if (length <= 0)
+ return false;
+ link[length] = 0;
+ return true;
+}
+
+static boolean PathMatchesMountPoint(const char* path, const char* mountPoint)
+{
+ int length = strlen(mountPoint);
+ if (length > 1 && strncmp(path, mountPoint, length) == 0)
+ {
+ // we need to do extra checking if mountPoint does not end in a '/'
+ if (mountPoint[length - 1] == '/')
+ return true;
+ // if mountPoint does not have a trailing slash, we need to make sure
+ // there is one in the path to avoid partial matches.
+ return (path[length] == 0 || path[length] == '/');
+ }
+
+ return false;
+}
+
+static void GetProcessName(int pid, char buffer[PATH_MAX])
+{
+ int fd;
+ sprintf(buffer, "/proc/%d/cmdline", pid);
+ fd = open(buffer, O_RDONLY);
+ if (fd < 0) {
+ strcpy(buffer, "???");
+ } else {
+ int length = read(fd, buffer, PATH_MAX - 1);
+ buffer[length] = 0;
+ close(fd);
+ }
+}
+
+static boolean CheckFileDescriptorSymLinks(int pid, const char* mountPoint)
+{
+ DIR* dir;
+ struct dirent* de;
+ boolean fileOpen = false;
+ char path[PATH_MAX];
+ char link[PATH_MAX];
+ int parent_length;
+
+ // compute path to process's directory of open files
+ sprintf(path, "/proc/%d/fd", pid);
+ dir = opendir(path);
+ if (!dir)
+ return false;
+
+ // remember length of the path
+ parent_length = strlen(path);
+ // append a trailing '/'
+ path[parent_length++] = '/';
+
+ while ((de = readdir(dir)) != 0 && !fileOpen) {
+ if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
+ continue;
+
+ // append the file name, after truncating to parent directory
+ path[parent_length] = 0;
+ strcat(path, de->d_name);
+
+ if (ReadSymLink(path, link) && PathMatchesMountPoint(link, mountPoint))
+ {
+ char name[PATH_MAX];
+ GetProcessName(pid, name);
+ LOG_ERROR("process %s (%d) has open file %s\n", name, pid, link);
+ fileOpen = true;
+ }
+ }
+
+ closedir(dir);
+ return fileOpen;
+}
+
+static boolean CheckFileMaps(int pid, const char* mountPoint)
+{
+ FILE* file;
+ char buffer[PATH_MAX + 100];
+ boolean mapOpen = false;
+
+ sprintf(buffer, "/proc/%d/maps", pid);
+ file = fopen(buffer, "r");
+ if (!file)
+ return false;
+
+ while (!mapOpen && fgets(buffer, sizeof(buffer), file))
+ {
+ // skip to the path
+ const char* path = strchr(buffer, '/');
+ if (path && PathMatchesMountPoint(path, mountPoint))
+ {
+ char name[PATH_MAX];
+ GetProcessName(pid, name);
+ LOG_ERROR("process %s (%d) has open file map for %s\n", name, pid, path);
+ mapOpen = true;
+ }
+ }
+
+ fclose(file);
+ return mapOpen;
+}
+
+static boolean CheckSymLink(int pid, const char* mountPoint, const char* name, const char* message)
+{
+ char path[PATH_MAX];
+ char link[PATH_MAX];
+
+ sprintf(path, "/proc/%d/%s", pid, name);
+ if (ReadSymLink(path, link) && PathMatchesMountPoint(link, mountPoint))
+ {
+ char name[PATH_MAX];
+ GetProcessName(pid, name);
+ LOG_ERROR("process %s (%d) has %s in %s\n", name, pid, message, mountPoint);
+ return true;
+ }
+ else
+ return false;
+}
+
+static int get_pid(const char* s)
+{
+ int result = 0;
+ while (*s) {
+ if (!isdigit(*s)) return -1;
+ result = 10 * result + (*s++ - '0');
+ }
+ return result;
+}
+
+// hunt down and kill processes that have files open on the given mount point
+void KillProcessesWithOpenFiles(const char* mountPoint, boolean sigkill)
+{
+ DIR* dir;
+ struct dirent* de;
+
+ LOG_ERROR("KillProcessesWithOpenFiles %s\n", mountPoint);
+ dir = opendir("/proc");
+ if (!dir) return;
+
+ while ((de = readdir(dir)) != 0)
+ {
+ boolean killed = false;
+ // does the name look like a process ID?
+ int pid = get_pid(de->d_name);
+ if (pid == -1) continue;
+
+ if (CheckFileDescriptorSymLinks(pid, mountPoint) // check for open files
+ || CheckFileMaps(pid, mountPoint) // check for mmap()
+ || CheckSymLink(pid, mountPoint, "cwd", "working directory") // check working directory
+ || CheckSymLink(pid, mountPoint, "root", "chroot") // check for chroot()
+ || CheckSymLink(pid, mountPoint, "exe", "executable path") // check executable path
+ )
+ {
+ LOG_ERROR("Killing process %d\n", pid);
+ kill(pid, (sigkill ? SIGKILL : SIGTERM));
+ }
+ }
+
+ closedir(dir);
+}
diff --git a/mountd/Server.c b/mountd/Server.c
new file mode 100644
index 0000000..14b3830
--- /dev/null
+++ b/mountd/Server.c
@@ -0,0 +1,232 @@
+/*
+ * 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.
+ */
+
+/*
+** mountd server support
+*/
+
+#include "mountd.h"
+
+#include <cutils/properties.h>
+#include <cutils/sockets.h>
+
+#include <pthread.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include <private/android_filesystem_config.h>
+
+
+// current client file descriptor
+static int sFD = -1;
+
+// to synchronize writing to client
+static pthread_mutex_t sWriteMutex = PTHREAD_MUTEX_INITIALIZER;
+
+// path for media that failed to mount before the runtime is connected
+static char* sDeferredUnmountableMediaPath = NULL;
+
+static int Write(const char* message)
+{
+ int result = -1;
+
+ pthread_mutex_lock(&sWriteMutex);
+
+ LOG_SERVER("Write: %s\n", message);
+ if (sFD >= 0)
+ result = write(sFD, message, strlen(message) + 1);
+
+ pthread_mutex_unlock(&sWriteMutex);
+
+ return result;
+}
+
+static int Write2(const char* message, const char* data)
+{
+ int result = -1;
+
+ char* buffer = (char *)alloca(strlen(message) + strlen(data) + 1);
+ if (!buffer)
+ {
+ LOG_ERROR("alloca failed in Write2\n");
+ return -1;
+ }
+
+ strcpy(buffer, message);
+ strcat(buffer, data);
+ return Write(buffer);
+}
+
+static void SendStatus()
+{
+ Write(IsMassStorageConnected() ? MOUNTD_UMS_CONNECTED : MOUNTD_UMS_DISCONNECTED);
+ Write(IsMassStorageEnabled() ? MOUNTD_UMS_ENABLED : MOUNTD_UMS_DISABLED);
+}
+
+static void DoCommand(const char* command)
+{
+ LOG_SERVER("DoCommand %s\n", command);
+
+ if (strcmp(command, MOUNTD_ENABLE_UMS) == 0)
+ {
+ EnableMassStorage(true);
+ Write(MOUNTD_UMS_ENABLED);
+ }
+ else if (strcmp(command, MOUNTD_DISABLE_UMS) == 0)
+ {
+ EnableMassStorage(false);
+ Write(MOUNTD_UMS_DISABLED);
+ }
+ else if (strcmp(command, MOUNTD_SEND_STATUS) == 0)
+ {
+ SendStatus();
+ }
+ else if (strncmp(command, MOUNTD_MOUNT_MEDIA, strlen(MOUNTD_MOUNT_MEDIA)) == 0)
+ {
+ const char* path = command + strlen(MOUNTD_MOUNT_MEDIA);
+ MountMedia(path);
+ }
+ else if (strncmp(command, MOUNTD_EJECT_MEDIA, strlen(MOUNTD_EJECT_MEDIA)) == 0)
+ {
+ const char* path = command + strlen(MOUNTD_EJECT_MEDIA);
+ UnmountMedia(path);
+ }
+ else
+ LOGE("unknown command %s\n", command);
+}
+
+int RunServer()
+{
+ int socket = android_get_control_socket(MOUNTD_SOCKET);
+ if (socket < 0) {
+ LOGE("Obtaining file descriptor for socket '%s' failed: %s",
+ MOUNTD_SOCKET, strerror(errno));
+ return -1;
+ }
+
+ if (listen(socket, 4) < 0) {
+ LOGE("Unable to listen on file descriptor '%d' for socket '%s': %s",
+ socket, MOUNTD_SOCKET, strerror(errno));
+ return -1;
+ }
+
+ while (1)
+ {
+ struct sockaddr addr;
+ socklen_t alen;
+ struct ucred cred;
+ socklen_t size;
+
+ alen = sizeof(addr);
+ sFD = accept(socket, &addr, &alen);
+ if (sFD < 0)
+ continue;
+
+ if (sDeferredUnmountableMediaPath) {
+ NotifyMediaState(sDeferredUnmountableMediaPath, MEDIA_UNMOUNTABLE, false);
+ free(sDeferredUnmountableMediaPath);
+ sDeferredUnmountableMediaPath = NULL;
+ }
+
+ while (1)
+ {
+ char buffer[101];
+ int result = read(sFD, buffer, sizeof(buffer) - 1);
+ if (result > 0)
+ {
+ int start = 0;
+ int i;
+ // command should be zero terminated, but just in case
+ buffer[result] = 0;
+ for (i = 0; i < result; i++)
+ {
+ if (buffer[i] == 0)
+ {
+ DoCommand(buffer + start);
+ start = i + 1;
+ }
+ }
+ }
+ else
+ {
+ close(sFD);
+ sFD = -1;
+ break;
+ }
+ }
+ }
+
+ // should never get here
+ return 0;
+}
+
+void SendMassStorageConnected(boolean connected)
+{
+ Write(connected ? MOUNTD_UMS_CONNECTED : MOUNTD_UMS_DISCONNECTED);
+}
+
+void SendUnmountRequest(const char* path)
+{
+ Write2(MOUNTD_REQUEST_EJECT, path);
+}
+
+void NotifyMediaState(const char* path, MediaState state, boolean readOnly)
+{
+ const char* event = NULL;
+ const char* propertyValue = NULL;
+
+ switch (state) {
+ case MEDIA_REMOVED:
+ event = MOUNTD_MEDIA_REMOVED;
+ propertyValue = EXTERNAL_STORAGE_REMOVED;
+ break;
+ case MEDIA_UNMOUNTED:
+ event = MOUNTD_MEDIA_UNMOUNTED;
+ propertyValue = EXTERNAL_STORAGE_UNMOUNTED;
+ break;
+ case MEDIA_MOUNTED:
+ event = (readOnly ? MOUNTD_MEDIA_MOUNTED_READ_ONLY : MOUNTD_MEDIA_MOUNTED);
+ propertyValue = (readOnly ? EXTERNAL_STORAGE_MOUNTED_READ_ONLY : EXTERNAL_STORAGE_MOUNTED);
+ break;
+ case MEDIA_SHARED:
+ event = MOUNTD_MEDIA_SHARED;
+ propertyValue = EXTERNAL_STORAGE_SHARED;
+ break;
+ case MEDIA_BAD_REMOVAL:
+ event = MOUNTD_MEDIA_BAD_REMOVAL;
+ propertyValue = EXTERNAL_STORAGE_BAD_REMOVAL;
+ break;
+ case MEDIA_UNMOUNTABLE:
+ event = MOUNTD_MEDIA_UNMOUNTABLE;
+ propertyValue = EXTERNAL_STORAGE_UNMOUNTABLE;
+ break;
+ default:
+ LOG_ERROR("unknown MediaState %d in NotifyMediaState\n", state);
+ return;
+ }
+
+ property_set(EXTERNAL_STORAGE_STATE, propertyValue);
+ int result = Write2(event, path);
+ if (result < 0 && state == MEDIA_UNMOUNTABLE) {
+
+ // if we cannot communicate with the runtime, defer this message until the runtime is available
+ sDeferredUnmountableMediaPath = strdup(path);
+ }
+}
diff --git a/mountd/mountd.c b/mountd/mountd.c
new file mode 100644
index 0000000..fb54fe6
--- /dev/null
+++ b/mountd/mountd.c
@@ -0,0 +1,106 @@
+/*
+ * 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.
+ */
+
+/*
+** mountd main program
+*/
+
+#include "mountd.h"
+
+#include <cutils/config_utils.h>
+#include <cutils/cpu_info.h>
+#include <cutils/properties.h>
+
+#include <sys/mount.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <linux/capability.h>
+#include <linux/prctl.h>
+
+#include <private/android_filesystem_config.h>
+
+#ifdef MOUNTD_LOG
+FILE* logFile;
+#endif
+
+
+static void ReadConfigFile(const char* path)
+{
+ cnode* root = config_node("", "");
+ cnode* node;
+
+ config_load_file(root, path);
+ node = root->first_child;
+
+ while (node)
+ {
+ if (strcmp(node->name, "mount") == 0)
+ {
+ const char* block_device = NULL;
+ const char* mount_point = NULL;
+ boolean enable_ums = false;
+ cnode* child = node->first_child;
+
+ while (child)
+ {
+ const char* name = child->name;
+ const char* value = child->value;
+
+ if (strcmp(name, "block_device") == 0)
+ block_device = value;
+ else if (strcmp(name, "mount_point") == 0)
+ mount_point = value;
+ else if (strcmp(name, "enable_ums") == 0 &&
+ strcmp(value, "true") == 0)
+ enable_ums = true;
+
+ child = child->next;
+ }
+
+ // mount point and removable fields are optional
+ if (block_device && mount_point)
+ {
+ AddMountPoint(block_device, mount_point, enable_ums);
+ }
+ }
+
+ node = node->next;
+ }
+}
+
+int main(int argc, char* argv[])
+{
+ const char* configPath = "/system/etc/mountd.conf";
+ int i;
+
+ for (i = 1; i < argc; i++)
+ {
+ const char* arg = argv[i];
+
+ if (strcmp(arg, "-f") == 0)
+ {
+ if (i < argc - 1)
+ configPath = argv[++i];
+ }
+ }
+
+ ReadConfigFile(configPath);
+ StartAutoMounter();
+ return RunServer();
+}
diff --git a/mountd/mountd.h b/mountd/mountd.h
new file mode 100644
index 0000000..746a414
--- /dev/null
+++ b/mountd/mountd.h
@@ -0,0 +1,159 @@
+/*
+ * 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.
+ */
+
+#ifndef MOUNTD_H__
+#define MOUNTD_H__
+
+#define LOG_TAG "mountd"
+#include "cutils/log.h"
+
+typedef int boolean;
+enum {
+ false = 0,
+ true = 1
+};
+
+// Set this for logging error messages
+#define ENABLE_LOG_ERROR
+
+// set this to log automounter events
+//#define ENABLE_LOG_MOUNT
+
+// set this to log server events
+//#define ENABLE_LOG_SERVER
+
+#ifdef ENABLE_LOG_ERROR
+#define LOG_ERROR(fmt, args...) \
+ { LOGE(fmt , ## args); }
+#else
+#define LOG_ERROR(fmt, args...) \
+ do { } while (0)
+#endif /* ENABLE_LOG_ERROR */
+
+#ifdef ENABLE_LOG_MOUNT
+#define LOG_MOUNT(fmt, args...) \
+ { LOGD(fmt , ## args); }
+#else
+#define LOG_MOUNT(fmt, args...) \
+ do { } while (0)
+#endif /* ENABLE_LOG_MOUNT */
+
+#ifdef ENABLE_LOG_SERVER
+#define LOG_SERVER(fmt, args...) \
+ { LOGD(fmt , ## args); }
+#else
+#define LOG_SERVER(fmt, args...) \
+ do { } while (0)
+#endif /* ENABLE_LOG_SERVER */
+
+
+typedef enum MediaState {
+ // no media in SD card slot
+ MEDIA_REMOVED,
+
+ // media in SD card slot, but not mounted
+ MEDIA_UNMOUNTED,
+
+ // media in SD card slot and mounted at its mount point
+ MEDIA_MOUNTED,
+
+ // media in SD card slot, unmounted, and shared as a mass storage device
+ MEDIA_SHARED,
+
+ // media was removed from SD card slot, but mount point was not unmounted
+ // this state is cleared after the mount point is unmounted
+ MEDIA_BAD_REMOVAL,
+
+ // media in SD card slot could not be mounted (corrupt file system?)
+ MEDIA_UNMOUNTABLE,
+} MediaState;
+
+// socket name for connecting to mountd
+#define MOUNTD_SOCKET "mountd"
+
+// mountd commands
+// these must match the corresponding strings in //device/java/android/android/os/UsbListener.java
+#define MOUNTD_ENABLE_UMS "enable_ums"
+#define MOUNTD_DISABLE_UMS "disable_ums"
+#define MOUNTD_SEND_STATUS "send_status"
+
+// these commands should contain a mount point following the colon
+#define MOUNTD_MOUNT_MEDIA "mount_media:"
+#define MOUNTD_EJECT_MEDIA "eject_media:"
+
+// mountd events
+// these must match the corresponding strings in //device/java/android/android/os/UsbListener.java
+#define MOUNTD_UMS_ENABLED "ums_enabled"
+#define MOUNTD_UMS_DISABLED "ums_disabled"
+#define MOUNTD_UMS_CONNECTED "ums_connected"
+#define MOUNTD_UMS_DISCONNECTED "ums_disconnected"
+
+// these events correspond to the states in the MediaState enum.
+// a path to the mount point follows the colon.
+#define MOUNTD_MEDIA_REMOVED "media_removed:"
+#define MOUNTD_MEDIA_UNMOUNTED "media_unmounted:"
+#define MOUNTD_MEDIA_MOUNTED "media_mounted:"
+#define MOUNTD_MEDIA_MOUNTED_READ_ONLY "media_mounted_ro:"
+#define MOUNTD_MEDIA_SHARED "media_shared:"
+#define MOUNTD_MEDIA_BAD_REMOVAL "media_bad_removal:"
+#define MOUNTD_MEDIA_UNMOUNTABLE "media_unmountable:"
+
+// this event sent to request unmount for media mount point
+#define MOUNTD_REQUEST_EJECT "request_eject:"
+
+// system properties
+// these must match the corresponding strings in //device/java/android/android/os/Environment.java
+#define EXTERNAL_STORAGE_STATE "EXTERNAL_STORAGE_STATE"
+#define EXTERNAL_STORAGE_REMOVED "removed"
+#define EXTERNAL_STORAGE_UNMOUNTED "unmounted"
+#define EXTERNAL_STORAGE_MOUNTED "mounted"
+#define EXTERNAL_STORAGE_MOUNTED_READ_ONLY "mounted_ro"
+#define EXTERNAL_STORAGE_SHARED "shared"
+#define EXTERNAL_STORAGE_BAD_REMOVAL "bad_removal"
+#define EXTERNAL_STORAGE_UNMOUNTABLE "unmountable"
+
+// AutoMount.c
+
+boolean IsMassStorageEnabled();
+boolean IsMassStorageConnected();
+
+void MountMedia(const char* mountPoint);
+void UnmountMedia(const char* mountPoint);
+void EnableMassStorage(boolean enable);
+
+// call this before StartAutoMounter() to add a mount point to monitor
+void AddMountPoint(const char* device, const char* mountPoint, boolean enableUms);
+
+// start automounter thread
+void StartAutoMounter();
+
+// check /proc/mounts for mounted file systems, and notify mount or unmount for any that are in our automount list
+void NotifyExistingMounts();
+
+
+// ProcessKiller.c
+
+void KillProcessesWithOpenFiles(const char* mountPoint, boolean sigkill);
+
+
+// Server.c
+
+int RunServer();
+void SendMassStorageConnected(boolean connected);
+void SendUnmountRequest(const char* path);
+void NotifyMediaState(const char* path, MediaState state, boolean readOnly);
+
+#endif // MOUNTD_H__