diff --git a/src/dm/DispatchManagerActions.cc b/src/dm/DispatchManagerActions.cc
index b8e86d951b..280308f417 100644
--- a/src/dm/DispatchManagerActions.cc
+++ b/src/dm/DispatchManagerActions.cc
@@ -148,7 +148,8 @@ int DispatchManager::migrate(
     if ((vm->get_state()     == VirtualMachine::ACTIVE &&
          (vm->get_lcm_state() == VirtualMachine::RUNNING ||
           vm->get_lcm_state() == VirtualMachine::UNKNOWN )) ||
-         vm->get_state() == VirtualMachine::POWEROFF)
+         vm->get_state() == VirtualMachine::POWEROFF ||
+         vm->get_state() == VirtualMachine::SUSPENDED)
     {
         Nebula&             nd  = Nebula::instance();
         LifeCycleManager *  lcm = nd.get_lcm();
diff --git a/src/dm/DispatchManagerStates.cc b/src/dm/DispatchManagerStates.cc
index b49f7de541..00bdf95fe7 100644
--- a/src/dm/DispatchManagerStates.cc
+++ b/src/dm/DispatchManagerStates.cc
@@ -31,7 +31,9 @@ void  DispatchManager::suspend_success_action(int vid)
     }
 
     if ((vm->get_state() == VirtualMachine::ACTIVE) &&
-        (vm->get_lcm_state() == VirtualMachine::SAVE_SUSPEND))
+        (vm->get_lcm_state() == VirtualMachine::SAVE_SUSPEND ||
+         vm->get_lcm_state() == VirtualMachine::PROLOG_MIGRATE_SUSPEND ||
+         vm->get_lcm_state() == VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE))
     {
         vm->set_state(VirtualMachine::SUSPENDED);
 
diff --git a/src/lcm/LifeCycleActions.cc b/src/lcm/LifeCycleActions.cc
index b47165abd6..5afdecbb5d 100644
--- a/src/lcm/LifeCycleActions.cc
+++ b/src/lcm/LifeCycleActions.cc
@@ -203,6 +203,13 @@ void  LifeCycleManager::migrate_action(int vid)
 {
     VirtualMachine *    vm;
 
+	Nebula& nd = Nebula::instance();
+	TransferManager *       tm  = nd.get_tm();
+	VirtualMachineManager * vmm = nd.get_vmm();
+
+	int    cpu, mem, disk;
+	time_t the_time = time(0);
+
     vm = vmpool->get(vid,true);
 
     if ( vm == 0 )
@@ -213,10 +220,6 @@ void  LifeCycleManager::migrate_action(int vid)
     if (vm->get_state()     == VirtualMachine::ACTIVE &&
         vm->get_lcm_state() == VirtualMachine::RUNNING)
     {
-        Nebula&                 nd  = Nebula::instance();
-        VirtualMachineManager * vmm = nd.get_vmm();
-        int                     cpu,mem,disk;
-
         //----------------------------------------------------
         //                SAVE_MIGRATE STATE
         //----------------------------------------------------
@@ -227,7 +230,7 @@ void  LifeCycleManager::migrate_action(int vid)
 
         vmpool->update(vm);
 
-        vm->set_stime(time(0));
+        vm->set_stime(the_time);
 
         vm->set_previous_action(History::MIGRATE_ACTION);
 
@@ -243,14 +246,9 @@ void  LifeCycleManager::migrate_action(int vid)
 
         vmm->trigger(VirtualMachineManager::SAVE,vid);
     }
-    else if (vm->get_state() == VirtualMachine::POWEROFF)
+    else if (vm->get_state() == VirtualMachine::POWEROFF ||
+		     vm->get_state() == VirtualMachine::SUSPENDED )
     {
-        Nebula& nd = Nebula::instance();
-        TransferManager * tm = nd.get_tm();
-
-        int    cpu, mem, disk;
-        time_t the_time = time(0);
-
         //------------------------------------------------------
         //   Bypass SAVE_MIGRATE & go to PROLOG_MIGRATE_POWEROFF
         //------------------------------------------------------
@@ -259,9 +257,16 @@ void  LifeCycleManager::migrate_action(int vid)
 
         vm->set_state(VirtualMachine::ACTIVE);
 
-        vm->set_state(VirtualMachine::PROLOG_MIGRATE_POWEROFF);
-
-        vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_POWEROFF");
+	 	if (vm->get_state() == VirtualMachine::POWEROFF)
+		{
+			vm->set_state(VirtualMachine::PROLOG_MIGRATE_POWEROFF);
+			vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_POWEROFF");
+		}
+		else //if (vm->get_state() == VirtualMachine::SUSPENDED)
+		{
+			vm->set_state(VirtualMachine::PROLOG_MIGRATE_SUSPEND);
+			vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_SUSPEND");
+		}
 
         vm->delete_snapshots();
 
@@ -270,7 +275,7 @@ void  LifeCycleManager::migrate_action(int vid)
 
         vmpool->update(vm);
 
-        vm->set_stime(time(0));
+        vm->set_stime(the_time);
 
         vm->set_prolog_stime(the_time);
 
@@ -293,12 +298,6 @@ void  LifeCycleManager::migrate_action(int vid)
         //   Bypass SAVE_MIGRATE & PROLOG_MIGRATE goto BOOT
         //----------------------------------------------------
 
-        Nebula& nd = Nebula::instance();
-        VirtualMachineManager * vmm = nd.get_vmm();
-
-        int    cpu, mem, disk;
-        time_t the_time = time(0);
-
         vm->set_resched(false);
 
         vm->set_state(VirtualMachine::BOOT);
@@ -306,7 +305,6 @@ void  LifeCycleManager::migrate_action(int vid)
         vm->delete_snapshots();
 
         map<string, string> empty;
-
         vm->update_info(0, 0, -1, -1, empty);
 
         vmpool->update(vm);
@@ -1093,6 +1091,8 @@ void  LifeCycleManager::clean_up_vm(VirtualMachine * vm, bool dispose, int& imag
         case VirtualMachine::PROLOG_MIGRATE_FAILURE:
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF_FAILURE:
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE:
             vm->set_prolog_etime(the_time);
             vmpool->update_history(vm);
 
@@ -1163,6 +1163,8 @@ void  LifeCycleManager::recover(VirtualMachine * vm, bool success)
         case VirtualMachine::PROLOG_FAILURE:
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF_FAILURE:
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE:
             if (success)
             {
                 lcm_action = LifeCycleManager::PROLOG_SUCCESS;
@@ -1386,6 +1388,17 @@ void LifeCycleManager::retry(VirtualMachine * vm)
             tm->trigger(TransferManager::PROLOG_MIGR, vid);
             break;
 
+
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE:
+            vm->set_state(VirtualMachine::PROLOG_MIGRATE_SUSPEND);
+
+            vmpool->update(vm);
+
+            vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_SUSPEND");
+
+            tm->trigger(TransferManager::PROLOG_MIGR, vid);
+            break;
+
         case VirtualMachine::PROLOG_FAILURE:
             vm->set_state(VirtualMachine::PROLOG);
 
@@ -1451,6 +1464,7 @@ void LifeCycleManager::retry(VirtualMachine * vm)
         case VirtualMachine::PROLOG:
         case VirtualMachine::PROLOG_MIGRATE:
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
         case VirtualMachine::PROLOG_RESUME:
         case VirtualMachine::PROLOG_UNDEPLOY:
         case VirtualMachine::MIGRATE:
diff --git a/src/lcm/LifeCycleStates.cc b/src/lcm/LifeCycleStates.cc
index ba54e7ec09..620a2e952e 100644
--- a/src/lcm/LifeCycleStates.cc
+++ b/src/lcm/LifeCycleStates.cc
@@ -706,7 +706,9 @@ void LifeCycleManager::prolog_success_action(int vid)
         return;
     }
 
-    switch (vm->get_lcm_state())
+	VirtualMachine::LcmState lcm_state = vm->get_lcm_state();
+
+    switch (lcm_state)
     {
         //---------------------------------------------------------------------
         //                             BOOT STATE
@@ -717,7 +719,7 @@ void LifeCycleManager::prolog_success_action(int vid)
         case VirtualMachine::PROLOG_MIGRATE_FAILURE: //recover success
         case VirtualMachine::PROLOG:
         case VirtualMachine::PROLOG_FAILURE: //recover success
-            switch (vm->get_lcm_state())
+            switch (lcm_state)
             {
                 case VirtualMachine::PROLOG_RESUME:
                     action = VirtualMachineManager::RESTORE;
@@ -761,10 +763,12 @@ void LifeCycleManager::prolog_success_action(int vid)
             break;
 
         //---------------------------------------------------------------------
-        //                          POWEROFF STATE
+        //                      POWEROFF/SUSPEND STATE
         //---------------------------------------------------------------------
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF:
         case VirtualMachine::PROLOG_MIGRATE_POWEROFF_FAILURE: //recover success
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND:
+        case VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE: //recover success
             vm->delete_snapshots();
 
             vm->update_info(0, 0, -1, -1, empty);
@@ -784,7 +788,15 @@ void LifeCycleManager::prolog_success_action(int vid)
 
             vmpool->update_history(vm);
 
-            dm->trigger(DispatchManager::POWEROFF_SUCCESS,vid);
+			if (lcm_state == VirtualMachine::PROLOG_MIGRATE_POWEROFF||
+			    lcm_state == VirtualMachine::PROLOG_MIGRATE_POWEROFF_FAILURE)
+			{
+				dm->trigger(DispatchManager::POWEROFF_SUCCESS,vid);
+			}
+			else //PROLOG_MIGRATE_SUSPEND, PROLOG_MIGRATE_SUSPEND_FAILURE
+			{
+				dm->trigger(DispatchManager::POWEROFF_SUCCESS,vid);
+			}
             break;
 
         default:
@@ -838,6 +850,13 @@ void  LifeCycleManager::prolog_failure_action(int vid)
 
         vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_POWEROFF_FAILURE");
     }
+    else if ( state == VirtualMachine::PROLOG_MIGRATE_SUSPEND )
+    {
+        vm->set_state(VirtualMachine::PROLOG_MIGRATE_SUSPEND_FAILURE);
+        vmpool->update(vm);
+
+        vm->log("LCM", Log::INFO, "New VM state is PROLOG_MIGRATE_SUSPEND_FAILURE");
+    }
     else if ( state == VirtualMachine::PROLOG_RESUME )
     {
         //----------------------------------------------------