Ticket #3723: vm_kernel_29102011.patch

src/system/kernel/vm/VMAnonymousCache.cpp

@@ -17 +17 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <FindDirectory.h>
 #include <KernelExport.h>
 #include <NodeMonitor.h>
 
 #include <arch_config.h>
 #include <boot_device.h>
+#include <disk_device_manager/KDiskDevice.h>
+#include <disk_device_manager/KDiskDeviceManager.h>
+#include <disk_device_manager/KDiskSystem.h>
+#include <disk_device_manager/KPartitionVisitor.h>
 #include <driver_settings.h>
 #include <fs/fd.h>
+#include <fs/KPath.h>
+#include <fs_info.h>
 #include <fs_interface.h>
 #include <heap.h>
 #include <kernel_daemon.h>
@@ -53 +60 @@
 #   define TRACE(x...) do { } while (false)
 #endif
 
+static const char* const kDefaultSwapPath = "/var/swap";
+static const char* const kSwapErrorFilePath = "swaperr";
 
 // number of free swap blocks the object cache shall minimally have
 #define MIN_SWAP_BLOCK_RESERVE  4096
@@ -1323 +1332 @@
 }
 
 
+struct VolumeInfo {
+    char name[B_FILE_NAME_LENGTH];
+    char device[B_FILE_NAME_LENGTH];
+    char filesystem[B_OS_NAME_LENGTH];
+    off_t capacity;
+};
+
+
+class PartitionScorer : public KPartitionVisitor {
+public:
+    PartitionScorer(VolumeInfo& volumeInfo)
+        :
+        fBestPartition(NULL),
+        fBestScore(-1),
+        fVolumeInfo(volumeInfo)
+    {
+    }
+
+    virtual bool VisitPre(KPartition* partition)
+    {
+        if (!partition->ContainsFileSystem())
+            return false;
+
+        KPath path;
+        partition->GetPath(&path);
+
+        int score = 0;
+        if (strcmp(fVolumeInfo.name, partition->ContentName()) == 0)
+            score += 4;
+        if (strcmp(fVolumeInfo.device, path.Path()) == 0)
+            score += 3;
+        if (fVolumeInfo.capacity == partition->Size())
+            score += 2;
+        if (strcmp(fVolumeInfo.filesystem, partition->DiskSystem()
+            ->ShortName()) == 0)
+            score += 1;
+        if (score >= 4 && score > fBestScore) {
+            fBestPartition = partition;
+            fBestScore = score;
+        }
+
+        return false;
+    }
+
+    KPartition* fBestPartition;
+private:
+    int32       fBestScore;
+    VolumeInfo  fVolumeInfo;
+};
+
+
+status_t
+get_mount_point(KPartition* partition, KPath* mountPoint)
+{
+    if (!mountPoint || !partition->ContainsFileSystem())
+        return B_BAD_VALUE;
+
+    const char* volumeName = partition->ContentName();
+    if (!volumeName || strlen(volumeName) == 0)
+        volumeName = partition->Name();
+    if (!volumeName || strlen(volumeName) == 0)
+        volumeName = "unnamed volume";
+
+    char basePath[B_PATH_NAME_LENGTH];
+    int32 len = snprintf(basePath, sizeof(basePath), "/%s", volumeName);
+    for (int32 i = 1; i < len; i++)
+        if (basePath[i] == '/')
+            basePath[i] = '-';
+    char* path = mountPoint->LockBuffer();
+    int32 pathLen = mountPoint->BufferSize();
+    strncpy(path, basePath, pathLen);
+
+    struct stat dummy;
+    for (int i = 1; ; i++) {
+        if (stat(path, &dummy) != 0)
+            break;
+        snprintf(path, pathLen, "%s%d", basePath, i);
+    }
+
+    mountPoint->UnlockBuffer();
+    return B_OK;
+}
+
+
 void
 swap_init_post_modules()
 {
@@ -1331 +1424 @@
     if (gReadOnlyBootDevice)
         return;
 
-    off_t size = 0;
+    bool swapEnabled = true;
+    off_t swapSize = 0;
+    VolumeInfo selectedVolume = {};
 
+    bool loadDefaults = true;
     void* settings = load_driver_settings("virtual_memory");
     if (settings != NULL) {
-        if (!get_driver_boolean_parameter(settings, "vm", false, false))
-            return;
-
-        const char* string = get_driver_parameter(settings, "swap_size", NULL,
+        const char* enabled = get_driver_parameter(settings, "vm", NULL, NULL);
+        const char* size = get_driver_parameter(settings, "swap_size", NULL,
             NULL);
-        size = string ? atoll(string) : 0;
+        const char* volume = get_driver_parameter(settings, "swap_volume_name",
+            NULL, NULL);
+        const char* device = get_driver_parameter(settings,
+            "swap_volume_device", NULL, NULL);
+        const char* filesystem = get_driver_parameter(settings,
+            "swap_volume_filesystem", NULL, NULL);
+        const char* capacity = get_driver_parameter(settings,
+            "swap_volume_capacity", NULL, NULL);
 
+        if (enabled != NULL && size != NULL && device != NULL
+            && volume != NULL && filesystem != NULL && capacity != NULL) {
+            swapEnabled = get_driver_boolean_parameter(settings, "vm",
+                false, false);
+            swapSize = atoll(size);
+            strncpy(selectedVolume.name, volume, sizeof(selectedVolume.name));
+            strncpy(selectedVolume.device, device,
+                sizeof(selectedVolume.device));
+            strncpy(selectedVolume.filesystem, filesystem,
+                sizeof(selectedVolume.filesystem));
+            selectedVolume.capacity = atoll(capacity);
+            loadDefaults = false;
+        }
         unload_driver_settings(settings);
-    } else
-        size = (off_t)vm_page_num_pages() * B_PAGE_SIZE * 2;
+    }
 
-    if (size < B_PAGE_SIZE)
+    if (loadDefaults) {
+        swapEnabled = true;
+        swapSize = (off_t)vm_page_num_pages() * B_PAGE_SIZE * 2;
+    }
+
+    if (!swapEnabled || swapSize < B_PAGE_SIZE)
         return;
 
-    int fd = open("/var/swap", O_RDWR | O_CREAT | O_NOCACHE, S_IRUSR | S_IWUSR);
+    dev_t dev = -1;
+    if (!loadDefaults) {
+        KDiskDeviceManager::CreateDefault();
+        KDiskDeviceManager* manager = KDiskDeviceManager::Default();
+        PartitionScorer visitor(selectedVolume);
+
+        KDiskDevice* device;
+        int32 cookie = 0;
+        while ((device = manager->NextDevice(&cookie)) != NULL) {
+            if (device->IsReadOnlyMedia() || device->IsWriteOnce()
+                || device->IsRemovable())
+                continue;
+            device->VisitEachDescendant(&visitor);
+        }
+
+        const char* error = NULL;
+        if (!visitor.fBestPartition)
+            error = "nfnd";
+        else {
+            if (visitor.fBestPartition->IsMounted())
+                dev = visitor.fBestPartition->VolumeID();
+            else {
+                KPath devPath, mountPoint;
+                visitor.fBestPartition->GetPath(&devPath);
+                get_mount_point(visitor.fBestPartition, &mountPoint);
+                const char* mountPath = mountPoint.Path();
+                mkdir(mountPath, S_IRWXU | S_IRWXG | S_IRWXO);
+                dev = _kern_mount(mountPath, devPath.Path(),
+                    NULL, 0, NULL, 0);
+                if (dev < 0)
+                    error = "nmnt";
+            }
+        }
+        if (error != NULL) {
+            KPath path;
+            if (find_directory(B_COMMON_SETTINGS_DIRECTORY, gBootDevice,
+                false, path.LockBuffer(), path.BufferSize()) == B_OK) {
+                path.UnlockBuffer();
+                path.Append(kSwapErrorFilePath);
+                int errorFile = open(path.Path(), O_WRONLY | O_CREAT
+                    | O_TRUNC, S_IRUSR | S_IWUSR);
+                if (errorFile >= 0) {
+                    write(errorFile, error, strlen(error));
+                    close(errorFile);
+                }
+            }
+        }
+    }
+
+    if (dev < 0)
+        dev = gBootDevice;
+
+    KPath path;
+    struct fs_info info;
+    _kern_read_fs_info(dev, &info);
+    if (dev == gBootDevice)
+        path = kDefaultSwapPath;
+    else {
+        vfs_entry_ref_to_path(info.dev, info.root,
+            ".", path.LockBuffer(), path.BufferSize());
+        path.UnlockBuffer();
+        path.Append("swap");
+    }
+
+    const char* swapPath = path.Path();
+    off_t existingSwapSize = 0;
+    struct stat swapStat;
+    if (stat(swapPath, &swapStat) == 0)
+        existingSwapSize = swapStat.st_size;
+
+    off_t freeSpace = info.free_blocks * info.block_size + existingSwapSize;
+    off_t safeSpace = freeSpace - (off_t)(0.15 * freeSpace);
+    if (safeSpace < swapSize)
+        swapSize = safeSpace;
+
+    int fd = open(swapPath, O_RDWR | O_CREAT | O_NOCACHE, S_IRUSR |
+        S_IWUSR);
     if (fd < 0) {
-        dprintf("Can't open/create /var/swap: %s\n", strerror(errno));
+        dprintf("Can't open/create %s: %s\n", swapPath, strerror(errno));
         return;
     }
 
     struct stat stat;
-    stat.st_size = size;
+    stat.st_size = swapSize;
     status_t error = _kern_write_stat(fd, NULL, false, &stat,
         sizeof(struct stat), B_STAT_SIZE | B_STAT_SIZE_INSECURE);
-    if (error != B_OK) {
-        dprintf("Failed to resize /var/swap to %lld bytes: %s\n", size,
-            strerror(error));
-    }
+    if (error != B_OK)
+        dprintf("Failed to resize %s to %lld bytes: %s\n", swapPath,
+            swapSize, strerror(error));
 
     close(fd);
 
-    error = swap_file_add("/var/swap");
+    error = swap_file_add(swapPath);
     if (error != B_OK)
-        dprintf("Failed to add swap file /var/swap: %s\n", strerror(error));
+        dprintf("Failed to add swap file %s: %s\n", swapPath,
+            strerror(error));
 }
 
 

src/system/kernel/vm/Jamfile

@@ -1 +1 @@
 SubDir HAIKU_TOP src system kernel vm ;
 
 UsePrivateHeaders shared ;
+UsePrivateHeaders [ FDirName kernel disk_device_manager ] ;
+UsePrivateHeaders [ FDirName kernel util ] ;
 
 UseHeaders [ FDirName $(SUBDIR) $(DOTDOT) device_manager ] ;