mm/memory_hotplug: prepare passing flags to add_memory() and friends

[linux-2.6-microblaze.git] / drivers / virtio / virtio_mem.c

diff --git a/drivers/virtio/virtio_mem.c b/drivers/virtio/virtio_mem.c
index c08512f..ed99e43 100644 (file)
--- a/drivers/virtio/virtio_mem.c
+++ b/drivers/virtio/virtio_mem.c
@@ -36,18 +36,10 @@ enum virtio_mem_mb_state {
        VIRTIO_MEM_MB_STATE_OFFLINE,
        /* Partially plugged, fully added to Linux, offline. */
        VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL,
-       /* Fully plugged, fully added to Linux, online (!ZONE_MOVABLE). */
+       /* Fully plugged, fully added to Linux, online. */
        VIRTIO_MEM_MB_STATE_ONLINE,
-       /* Partially plugged, fully added to Linux, online (!ZONE_MOVABLE). */
+       /* Partially plugged, fully added to Linux, online. */
        VIRTIO_MEM_MB_STATE_ONLINE_PARTIAL,
-       /*
-        * Fully plugged, fully added to Linux, online (ZONE_MOVABLE).
-        * We are not allowed to allocate (unplug) parts of this block that
-        * are not movable (similar to gigantic pages). We will never allow
-        * to online OFFLINE_PARTIAL to ZONE_MOVABLE (as they would contain
-        * unmovable parts).
-        */
-       VIRTIO_MEM_MB_STATE_ONLINE_MOVABLE,
        VIRTIO_MEM_MB_STATE_COUNT
 };
 
@@ -432,7 +424,7 @@ static int virtio_mem_mb_add(struct virtio_mem *vm, unsigned long mb_id)
 
        dev_dbg(&vm->vdev->dev, "adding memory block: %lu\n", mb_id);
        return add_memory_driver_managed(nid, addr, memory_block_size_bytes(),
-                                        vm->resource_name);
+                                        vm->resource_name, MHP_NONE);
 }
 
 /*
@@ -526,21 +518,10 @@ static bool virtio_mem_owned_mb(struct virtio_mem *vm, unsigned long mb_id)
 }
 
 static int virtio_mem_notify_going_online(struct virtio_mem *vm,
-                                         unsigned long mb_id,
-                                         enum zone_type zone)
+                                         unsigned long mb_id)
 {
        switch (virtio_mem_mb_get_state(vm, mb_id)) {
        case VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL:
-               /*
-                * We won't allow to online a partially plugged memory block
-                * to the MOVABLE zone - it would contain unmovable parts.
-                */
-               if (zone == ZONE_MOVABLE) {
-                       dev_warn_ratelimited(&vm->vdev->dev,
-                                            "memory block has holes, MOVABLE not supported\n");
-                       return NOTIFY_BAD;
-               }
-               return NOTIFY_OK;
        case VIRTIO_MEM_MB_STATE_OFFLINE:
                return NOTIFY_OK;
        default:
@@ -560,7 +541,6 @@ static void virtio_mem_notify_offline(struct virtio_mem *vm,
                                        VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL);
                break;
        case VIRTIO_MEM_MB_STATE_ONLINE:
-       case VIRTIO_MEM_MB_STATE_ONLINE_MOVABLE:
                virtio_mem_mb_set_state(vm, mb_id,
                                        VIRTIO_MEM_MB_STATE_OFFLINE);
                break;
@@ -579,24 +559,17 @@ static void virtio_mem_notify_offline(struct virtio_mem *vm,
        virtio_mem_retry(vm);
 }
 
-static void virtio_mem_notify_online(struct virtio_mem *vm, unsigned long mb_id,
-                                    enum zone_type zone)
+static void virtio_mem_notify_online(struct virtio_mem *vm, unsigned long mb_id)
 {
        unsigned long nb_offline;
 
        switch (virtio_mem_mb_get_state(vm, mb_id)) {
        case VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL:
-               BUG_ON(zone == ZONE_MOVABLE);
                virtio_mem_mb_set_state(vm, mb_id,
                                        VIRTIO_MEM_MB_STATE_ONLINE_PARTIAL);
                break;
        case VIRTIO_MEM_MB_STATE_OFFLINE:
-               if (zone == ZONE_MOVABLE)
-                       virtio_mem_mb_set_state(vm, mb_id,
-                                           VIRTIO_MEM_MB_STATE_ONLINE_MOVABLE);
-               else
-                       virtio_mem_mb_set_state(vm, mb_id,
-                                               VIRTIO_MEM_MB_STATE_ONLINE);
+               virtio_mem_mb_set_state(vm, mb_id, VIRTIO_MEM_MB_STATE_ONLINE);
                break;
        default:
                BUG();
@@ -675,7 +648,6 @@ static int virtio_mem_memory_notifier_cb(struct notifier_block *nb,
        const unsigned long start = PFN_PHYS(mhp->start_pfn);
        const unsigned long size = PFN_PHYS(mhp->nr_pages);
        const unsigned long mb_id = virtio_mem_phys_to_mb_id(start);
-       enum zone_type zone;
        int rc = NOTIFY_OK;
 
        if (!virtio_mem_overlaps_range(vm, start, size))
@@ -717,8 +689,7 @@ static int virtio_mem_memory_notifier_cb(struct notifier_block *nb,
                        break;
                }
                vm->hotplug_active = true;
-               zone = page_zonenum(pfn_to_page(mhp->start_pfn));
-               rc = virtio_mem_notify_going_online(vm, mb_id, zone);
+               rc = virtio_mem_notify_going_online(vm, mb_id);
                break;
        case MEM_OFFLINE:
                virtio_mem_notify_offline(vm, mb_id);
@@ -726,8 +697,7 @@ static int virtio_mem_memory_notifier_cb(struct notifier_block *nb,
                mutex_unlock(&vm->hotplug_mutex);
                break;
        case MEM_ONLINE:
-               zone = page_zonenum(pfn_to_page(mhp->start_pfn));
-               virtio_mem_notify_online(vm, mb_id, zone);
+               virtio_mem_notify_online(vm, mb_id);
                vm->hotplug_active = false;
                mutex_unlock(&vm->hotplug_mutex);
                break;
@@ -1906,8 +1876,7 @@ static void virtio_mem_remove(struct virtio_device *vdev)
        if (vm->nb_mb_state[VIRTIO_MEM_MB_STATE_OFFLINE] ||
            vm->nb_mb_state[VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL] ||
            vm->nb_mb_state[VIRTIO_MEM_MB_STATE_ONLINE] ||
-           vm->nb_mb_state[VIRTIO_MEM_MB_STATE_ONLINE_PARTIAL] ||
-           vm->nb_mb_state[VIRTIO_MEM_MB_STATE_ONLINE_MOVABLE]) {
+           vm->nb_mb_state[VIRTIO_MEM_MB_STATE_ONLINE_PARTIAL]) {
                dev_warn(&vdev->dev, "device still has system memory added\n");
        } else {
                virtio_mem_delete_resource(vm);