Changeset 19893

Timestamp:

01/21/07 13:03:47 (22 months ago)

Author:

axeld

Message:

* Implemented the AutoMounter for Haiku - it's barely tested at this point, but

at least mounting/unmounting seems to work. This fixes bug #191.

* Also changed the way how Tracker automatically mounts/unmounts volumes: it now

only differentiates between removable and fixed storage, not between initial
scan at boot, and periodical scans during runtime. Also removed all HFS stuff.

* Got rid of _INCLUDES_CLASS_DEVICE_MAP for the BeOS build.

Location:

haiku/trunk/src/kits/tracker

Files:

• AutoMounter.cpp (modified) (43 diffs)
• AutoMounter.h (modified) (3 diffs)

haiku/trunk/src/kits/tracker/AutoMounter.cpp

@@ -41 +41 @@
 #include "Tracker.h"
 #include "TrackerSettings.h"
+
+#ifdef __HAIKU__
+#       include <DiskDeviceRoster.h>
+#       include <DiskDevice.h>
+#       include <DiskDeviceList.h>
+#       include <fs_volume.h>
+#endif
 
 #include <Alert.h>
@@ -53 +60 @@
 
 
+static const char *kAutoMounterSettings = "automounter_settings";
+
+
+#ifdef __HAIKU__
+//      #pragma mark - Haiku Disk Device API
+
+static const uint32 kMsgInitialScan = 'insc';
+
+
+AutoMounter::AutoMounter()
+        : BLooper("AutoMounter", B_LOW_PRIORITY),
+        fNormalMode(kRestorePreviousVolumes),
+        fRemovableMode(kAllVolumes)
+{
+        if (!BootedInSafeMode()) {
+                _ReadSettings();
+        } else {
+                // defeat automounter in safe mode, don't even care about the settings
+                fNormalMode = kNoVolumes;
+                fRemovableMode = kNoVolumes;
+        }
+
+        if (PostMessage(kMsgInitialScan) != B_OK)
+                debug_printf("AutoMounter: OH NO!\n");
+}
+
+
+AutoMounter::~AutoMounter()
+{
+}
+
+
+void
+AutoMounter::_MountVolumes(mount_mode normal, mount_mode removable)
+{
+        if (normal == kNoVolumes && removable == kNoVolumes)
+                return;
+
+        class InitialMountVisitor : public BDiskDeviceVisitor {
+                public:
+                        InitialMountVisitor(mount_mode normalMode, mount_mode removableMode,
+                                        BMessage& previous)
+                                :
+                                fNormalMode(normalMode),
+                                fRemovableMode(removableMode),
+                                fPrevious(previous)
+                        {
+                        }
+
+                        virtual
+                        ~InitialMountVisitor()
+                        {
+                        }
+
+                        virtual bool
+                        Visit(BDiskDevice* device)
+                        {
+                                return Visit(device, 0);
+                        }
+
+                        virtual bool
+                        Visit(BPartition* partition, int32 level)
+                        {
+                                mount_mode mode = partition->Device()->IsRemovableMedia()
+                                        ? fRemovableMode : fNormalMode;
+                                if (mode == kNoVolumes
+                                        || partition->IsMounted()
+                                        || !partition->ContainsFileSystem())
+                                        return false;
+
+                                if (mode == kRestorePreviousVolumes) {
+                                        // mount all volumes that were stored in the settings file
+                                        const char *volumeName;
+                                        BPath path;
+                                        if (partition->GetPath(&path) != B_OK
+                                                || partition->ContentName() == NULL
+                                                || fPrevious.FindString(path.Path(), &volumeName) != B_OK
+                                                || strcmp(volumeName, partition->ContentName()))
+                                                return false;
+                                } else if (mode == kOnlyBFSVolumes) {
+                                        if (partition->ContentType() == NULL
+                                                || strcmp(partition->ContentType(), "BFS"))
+                                                return false;
+                                }
+
+                                partition->Mount();
+                                return false;
+                        }
+
+                private:
+                        mount_mode      fNormalMode;
+                        mount_mode      fRemovableMode;
+                        BMessage&       fPrevious;
+        } visitor(normal, removable, fSettings);
+
+        BDiskDeviceList devices;
+        status_t status = devices.Fetch();
+        if (status == B_OK)
+                devices.VisitEachPartition(&visitor);
+}
+
+
+void
+AutoMounter::_MountVolume(BMessage *message)
+{
+        int32 id;
+        if (message->FindInt32("id", &id) != B_OK)
+                return;
+
+        BDiskDeviceRoster roster;
+        BPartition *partition;
+        BDiskDevice device;
+        if (roster.GetPartitionWithID(id, &device, &partition) != B_OK)
+                return;
+
+        status_t status = partition->Mount();
+        if (status < B_OK) {
+                BString string;
+                string << "Error mounting volume. (" << strerror(status) << ")";
+                        (new BAlert("", string.String(), "OK"))->Go(0);
+        }
+}
+
+
+bool
+AutoMounter::_ForceUnmount(const char* name, status_t error)
+{
+        BString text;
+        text << "Could not unmount disk \"" << name << "\":\n\t" << strerror(error);
+        text << "\n\nShould I force unmounting the disk?\n\n"
+                "Note: if an application is currently writing to the volume, unmounting"
+                " it now might result in loss of data.\n";
+
+        int32 choice = (new BAlert("", text.String(), "Cancel", "Force Unmount", NULL,
+                B_WIDTH_AS_USUAL, B_WARNING_ALERT))->Go();
+
+        return choice == 1;
+}
+
+
+void
+AutoMounter::_ReportUnmountError(const char* name, status_t error)
+{
+        BString text;
+        text << "Could not unmount disk \"" << name << "\":\n\t" << strerror(error);
+
+        (new BAlert("", text.String(), "OK", NULL, NULL, B_WIDTH_AS_USUAL, 
+                B_WARNING_ALERT))->Go(NULL);
+}
+
+
+void
+AutoMounter::_UnmountAndEjectVolume(BMessage *message)
+{
+        int32 id;
+        if (message->FindInt32("id", &id) == B_OK) {
+                BDiskDeviceRoster roster;
+                BPartition *partition;
+                BDiskDevice device;
+                if (roster.GetPartitionWithID(id, &device, &partition) != B_OK)
+                        return;
+
+                status_t status = partition->Unmount();
+                if (status < B_OK) {
+                        if (!_ForceUnmount(partition->ContentName(), status))
+                                return;
+
+                        status = partition->Unmount(B_FORCE_UNMOUNT);
+                }
+
+                if (status < B_OK)
+                        _ReportUnmountError(partition->ContentName(), status);
+
+                return;
+        }
+
+        // see if we got a dev_t
+
+        dev_t device;
+        if (message->FindInt32("device_id", &device) != B_OK)
+                return;
+
+        BVolume volume(device);
+        status_t status = volume.InitCheck();
+
+        char name[B_FILE_NAME_LENGTH];
+        if (status == B_OK)
+                status = volume.GetName(name);
+        if (status < B_OK)
+                snprintf(name, sizeof(name), "device:%ld", device);
+
+        BDirectory mountPoint;
+        if (status == B_OK)
+                status = volume.GetRootDirectory(&mountPoint);
+
+        BPath path;
+        if (status == B_OK)
+                status = path.SetTo(&mountPoint, ".");
+
+        if (status == B_OK) {
+                status = fs_unmount_volume(path.Path(), 0);
+                if (status < B_OK) {
+                        if (!_ForceUnmount(name, status))
+                                return;
+
+                        status = fs_unmount_volume(path.Path(), B_FORCE_UNMOUNT);
+                }
+        }
+
+        if (status == B_OK)
+                rmdir(path.Path());
+
+        if (status < B_OK)
+                _ReportUnmountError(name, status);
+}
+
+
+void
+AutoMounter::_FromMode(mount_mode mode, bool& all, bool& bfs, bool& restore)
+{
+        all = bfs = restore = false;
+
+        switch (mode) {
+                case kAllVolumes:
+                        all = true;
+                        break;
+                case kOnlyBFSVolumes:
+                        bfs = true;
+                        break;
+                case kRestorePreviousVolumes:
+                        restore = true;
+                        break;
+
+                default:
+                        break;
+        }
+}
+
+
+AutoMounter::mount_mode
+AutoMounter::_ToMode(bool all, bool bfs, bool restore)
+{
+        if (all)
+                return kAllVolumes;
+        if (bfs)
+                return kOnlyBFSVolumes;
+        if (restore)
+                return kRestorePreviousVolumes;
+
+        return kNoVolumes;
+}
+
+
+void
+AutoMounter::_ReadSettings()
+{
+        BPath directoryPath;
+        if (FSFindTrackerSettingsDir(&directoryPath) != B_OK)
+                return;
+
+        BPath path(directoryPath);
+        path.Append(kAutoMounterSettings);
+        fPrefsFile.SetTo(path.Path(), O_RDWR);
+
+        if (fPrefsFile.InitCheck() != B_OK) {
+                // no prefs file yet, create a new one
+
+                BDirectory dir(directoryPath.Path());
+                dir.CreateFile(kAutoMounterSettings, &fPrefsFile);
+                return;
+        }
+
+        ssize_t settingsSize = (ssize_t)fPrefsFile.Seek(0, SEEK_END);
+        if (settingsSize == 0)
+                return;
+
+        ASSERT(settingsSize != 0);
+        char *buffer = new char[settingsSize];
+
+        fPrefsFile.Seek(0, 0);
+        if (fPrefsFile.Read(buffer, (size_t)settingsSize) != settingsSize) {
+                PRINT(("error reading automounter settings\n"));
+                delete [] buffer;
+                return;
+        }
+
+        BMessage message('stng');
+        status_t result = message.Unflatten(buffer);
+        if (result != B_OK) {
+                PRINT(("error %s unflattening settings, size %d\n", strerror(result), 
+                        settingsSize));
+                delete [] buffer;
+                return;
+        }
+
+        delete [] buffer;
+
+        _UpdateSettingsFromMessage(&message);
+        GetSettings(&fSettings);
+}
+
+
+void
+AutoMounter::_WriteSettings()
+{
+        if (fPrefsFile.InitCheck() != B_OK)
+                return;
+
+        BMessage message('stng');
+        GetSettings(&message);
+
+        ssize_t settingsSize = message.FlattenedSize();
+
+        char *buffer = new char[settingsSize];
+        status_t result = message.Flatten(buffer, settingsSize);
+
+        fPrefsFile.Seek(0, 0);
+        result = fPrefsFile.Write(buffer, (size_t)settingsSize);
+        if (result != settingsSize)
+                PRINT(("error writing settings, %s\n", strerror(result)));
+
+        delete [] buffer;
+}
+
+
+void
+AutoMounter::_UpdateSettingsFromMessage(BMessage* message)
+{
+        // auto mounter settings
+
+        bool all, bfs, restore;
+        if (message->FindBool("autoMountAll", &all) != B_OK)
+                all = true;
+        if (message->FindBool("autoMountAllBFS", &bfs) != B_OK)
+                bfs = false;
+
+        fRemovableMode = _ToMode(all, bfs, false);
+
+        // initial mount settings
+
+        if (message->FindBool("initialMountAll", &all) != B_OK)
+                all = false;
+        if (message->FindBool("initialMountAllBFS", &bfs) != B_OK)
+                bfs = false;
+        if (message->FindBool("initialMountRestore", &restore) != B_OK)
+                restore = true;
+
+        fNormalMode = _ToMode(all, bfs, restore);
+}
+
+
+void
+AutoMounter::GetSettings(BMessage *message)
+{
+        message->MakeEmpty();
+
+        bool all, bfs, restore;
+
+        _FromMode(fNormalMode, all, bfs, restore);
+        message->AddBool("initialMountAll", all);
+        message->AddBool("initialMountAllBFS", bfs);
+        message->AddBool("initialMountRestore", restore);
+
+        _FromMode(fRemovableMode, all, bfs, restore);
+        message->AddBool("autoMountAll", all);
+        message->AddBool("autoMountAllBFS", bfs);
+
+        // Save mounted volumes so we can optionally mount them on next
+        // startup
+        BVolumeRoster volumeRoster;
+        BVolume volume;
+        while (volumeRoster.GetNextVolume(&volume) == B_OK) {
+        fs_info info;
+        if (fs_stat_dev(volume.Device(), &info) == 0
+                        && info.flags & (B_FS_IS_REMOVABLE | B_FS_IS_PERSISTENT))
+                        message->AddString(info.device_name, info.volume_name);
+        }
+}
+
+
+void
+AutoMounter::MessageReceived(BMessage *message)
+{
+        switch (message->what) {
+                case kMsgInitialScan:
+                        _MountVolumes(fNormalMode, fRemovableMode);
+                        break;
+
+                case kMountVolume:
+                        _MountVolume(message);
+                        break;
+
+                case kUnmountVolume:
+                        _UnmountAndEjectVolume(message);
+                        break;
+
+                case kSetAutomounterParams:
+                {
+                        bool rescanNow = false;
+                        message->FindBool("rescanNow", &rescanNow);
+
+                        _UpdateSettingsFromMessage(message);
+                        GetSettings(&fSettings);
+                        _WriteSettings();
+
+                        if (rescanNow)
+                                _MountVolumes(fNormalMode, fRemovableMode);
+                        break;
+                }
+
+                case kMountAllNow:
+                        _MountVolumes(kAllVolumes, kAllVolumes);
+                        break;
+
+#if 0
+                case B_NODE_MONITOR:
+                {
+                        int32 opcode;
+                        if (message->FindInt32("opcode", &opcode) != B_OK)
+                                break;
+
+                        switch (opcode) {
+                                //      The name of a mount point has changed
+                                case B_ENTRY_MOVED: {
+                                        WRITELOG(("*** Received Mount Point Renamed Notification"));
+
+                                        const char *newName;
+                                        if (message->FindString("name", &newName) != B_OK) {
+                                                WRITELOG(("ERROR: Couldn't find name field in update message"));
+                                                PRINT_OBJECT(*message);
+                                                break ;
+                                        }
+
+                                        //
+                                        // When the node monitor reports a move, it gives the
+                                        // parent device and inode that moved.  The problem is 
+                                        // that  the inode is the inode of root *in* the filesystem,
+                                        // which is generally always the same number for every 
+                                        // filesystem of a type.
+                                        //
+                                        // What we'd really like is the device that the moved   
+                                        // volume is mounted on.  Find this by using the 
+                                        // *new* name and directory, and then stat()ing that to
+                                        // find the device.
+                                        //
+                                        dev_t parentDevice;
+                                        if (message->FindInt32("device", &parentDevice) != B_OK) {
+                                                WRITELOG(("ERROR: Couldn't find 'device' field in update"
+                                                        " message"));
+                                                PRINT_OBJECT(*message);
+                                                break;
+                                        }
+
+                                        ino_t toDirectory;      
+                                        if (message->FindInt64("to directory", &toDirectory)!=B_OK){
+                                                WRITELOG(("ERROR: Couldn't find 'to directory' field in update"
+                                                  "message"));
+                                                PRINT_OBJECT(*message);
+                                                break;
+                                        }
+
+                                        entry_ref root_entry(parentDevice, toDirectory, newName);
+
+                                        BNode entryNode(&root_entry);
+                                        if (entryNode.InitCheck() != B_OK) {
+                                                WRITELOG(("ERROR: Couldn't create mount point entry node: %s/n", 
+                                                        strerror(entryNode.InitCheck())));
+                                                break;
+                                        }       
+
+                                        node_ref mountPointNode;
+                                        if (entryNode.GetNodeRef(&mountPointNode) != B_OK) {
+                                                WRITELOG(("ERROR: Couldn't get node ref for new mount point"));
+                                                break;
+                                        }
+
+                                        WRITELOG(("Attempt to rename device %li to %s", mountPointNode.device,
+                                                newName));
+
+                                        Partition *partition = FindPartition(mountPointNode.device);
+                                        if (partition != NULL) {
+                                                WRITELOG(("Found device, changing name."));
+
+                                                BVolume mountVolume(partition->VolumeDeviceID());
+                                                BDirectory mountDir;
+                                                mountVolume.GetRootDirectory(&mountDir);
+                                                BPath dirPath(&mountDir, 0);
+
+                                                partition->SetMountedAt(dirPath.Path());
+                                                partition->SetVolumeName(newName);                                      
+                                                break;
+                                        } else {
+                                                WRITELOG(("ERROR: Device %li does not appear to be present",
+                                                        mountPointNode.device));
+                                        }
+                                }
+                        }
+                        break;
+                }
+#endif
+
+                default:
+                        BLooper::MessageReceived(message);
+                        break;
+        }
+}
+
+
+bool
+AutoMounter::QuitRequested()
+{
+        if (!BootedInSafeMode()) {
+                // don't write out settings in safe mode - this would overwrite the
+                // normal, non-safe mode settings
+                _WriteSettings();
+        }
+
+        return true;
+}
+
+
+#else   // !__HAIKU__
+//      #pragma mark - R5 DeviceMap API
+
 static const uint32 kStartPolling = 'strp';
-#if _INCLUDES_CLASS_DEVICE_MAP
-static const char *kAutoMounterSettings = "automounter_settings";
-#endif
+
+static BMessage gSettingsMessage;
+static bool gSilentAutoMounter;
 
 struct OneMountFloppyParams {
         status_t result;
 };
-
-#if _INCLUDES_CLASS_DEVICE_MAP
-static bool gSilentAutoMounter;
-#endif
-static BMessage gSettingsMessage;
-
-
-#if xDEBUG
-static Partition *
-DumpPartition(Partition *_DEVICE_MAP_ONLY(partition), void*)
-{
-#if _INCLUDES_CLASS_DEVICE_MAP
-        partition->Dump();
-#endif
-        return 0;
-}
-#endif
-
-
-#if _INCLUDES_CLASS_DEVICE_MAP
-
 
 struct MountPartitionParams {
@@ -87 +597 @@
         status_t result;
 };
+
+
+#if xDEBUG
+static Partition *
+DumpPartition(Partition *partition, void*)
+{
+        partition->Dump();
+        return 0;
+}
+#endif
 
 
@@ -303 +823 @@
 
 
+struct UnmountDeviceParams {
+        dev_t device;
+        status_t result;
+};
+
+
+static Partition *
+UnmountIfMatchingID(Partition *partition, void *castToParams)
+{
+        UnmountDeviceParams *params = (UnmountDeviceParams *)castToParams;
+
+        if (partition->VolumeDeviceID() == params->device) {
+                TTracker *tracker = dynamic_cast<TTracker *>(be_app);
+                if (tracker && tracker->QueryActiveForDevice(params->device)) {
+                        BString text;
+                        text << "To unmount " << partition->VolumeName() << " some query "
+                        "windows have to be closed. Would you like to close the query "
+                        "windows?";
+                        if ((new BAlert("", text.String(), "Cancel", "Close and unmount", NULL,
+                                B_WIDTH_FROM_LABEL))->Go() == 0)
+                                return partition;
+                        tracker->CloseActiveQueryWindows(params->device);
+                }
+
+                params->result = partition->Unmount();
+                Device *device = partition->GetDevice();
+                bool deviceHasMountedPartitions = false;
+
+                if (params->result == B_OK && device->Removable()) {
+                        for (int32 sessionIndex = 0; ; sessionIndex++) {
+                                Session *session = device->SessionAt(sessionIndex);
+                                if (!session)
+                                        break;
+
+                                for (int32 partitionIndex = 0; ; partitionIndex++) {
+                                        Partition *partition = session->PartitionAt(partitionIndex);
+                                        if (!partition)
+                                                break;
+
+                                        if (partition->Mounted() == kMounted) {
+                                                deviceHasMountedPartitions = true;
+                                                break;
+                                        }
+                                }
+                        }
+
+                        if (!deviceHasMountedPartitions
+                                && TrackerSettings().EjectWhenUnmounting())
+                                params->result = partition->GetDevice()->Eject();
+                }
+
+                return partition;
+        }
+
+        return NULL;
+}
+
+
 static Partition *
 NotifyFloppyNotMountable(Partition *partition, void *)
@@ -317 +895 @@
 
 
-#endif // #if _INCLUDES_CLASS_DEVICE_MAP
+static Device *
+FindFloppyDevice(Device *device, void *)
+{
+        if (device->IsFloppy())
+                return device;
+
+        return 0;
+}
 
 
@@ -352 +937 @@
 
 
-AutoMounter::AutoMounter(bool _DEVICE_MAP_ONLY(checkRemovableOnly),
-        bool _DEVICE_MAP_ONLY(checkCDs), bool _DEVICE_MAP_ONLY(checkFloppies),
-        bool _DEVICE_MAP_ONLY(checkOtherRemovable), bool _DEVICE_MAP_ONLY(autoMountRemovablesOnly),
-        bool _DEVICE_MAP_ONLY(autoMountAll), bool _DEVICE_MAP_ONLY(autoMountAllBFS),
-        bool _DEVICE_MAP_ONLY(autoMountAllHFS),
-        bool initialMountAll, bool initialMountAllBFS, bool initialMountRestore,
-        bool initialMountAllHFS)