Revision 03cd4655

b/monitor.c
2533 2533 

  		





  2534
  2534
  
    
    vm_stop(0);


  		





  2535
  2535
  
    

  		





  2536
  
  
    
    if (load_vmstate(mon, name) >= 0 && saved_vm_running)


  		





  
  2536
  
    
    if (load_vmstate(name) >= 0 && saved_vm_running)


  		





  2537
  2537
  
    
        vm_start();


  		





  2538
  2538
  
    
}


  		





  2539
  2539
  
    

  		












  

    
      b/savevm.c
    
  






  1737
  1737
  
    
        vm_start();


  		





  1738
  1738
  
    
}


  		





  1739
  1739
  
    

  		





  1740
  
  
    
int load_vmstate(Monitor *mon, const char *name)


  		





  
  1740
  
    
int load_vmstate(const char *name)


  		





  1741
  1741
  
    
{


  		





  1742
  1742
  
    
    DriveInfo *dinfo;


  		





  1743
  1743
  
    
    BlockDriverState *bs, *bs1;


  		





  ......




  1747
  1747
  
    

  		





  1748
  1748
  
    
    bs = get_bs_snapshots();


  		





  1749
  1749
  
    
    if (!bs) {


  		





  1750
  
  
    
        monitor_printf(mon, "No block device supports snapshots\n");


  		





  
  1750
  
    
        qemu_error("No block device supports snapshots\n");


  		





  1751
  1751
  
    
        return -EINVAL;


  		





  1752
  1752
  
    
    }


  		





  1753
  1753
  
    

  		





  ......




  1760
  1760
  
    
            ret = bdrv_snapshot_goto(bs1, name);


  		





  1761
  1761
  
    
            if (ret < 0) {


  		





  1762
  1762
  
    
                if (bs != bs1)


  		





  1763
  
  
    
                    monitor_printf(mon, "Warning: ");


  		





  
  1763
  
    
                    qemu_error("Warning: ");


  		





  1764
  1764
  
    
                switch(ret) {


  		





  1765
  1765
  
    
                case -ENOTSUP:


  		





  1766
  
  
    
                    monitor_printf(mon,


  		





  1767
  
  
    
                                   "Snapshots not supported on device '%s'\n",


  		





  1768
  
  
    
                                   bdrv_get_device_name(bs1));


  		





  
  1766
  
    
                    qemu_error("Snapshots not supported on device '%s'\n",


  		





  
  1767
  
    
                               bdrv_get_device_name(bs1));


  		





  1769
  1768
  
    
                    break;


  		





  1770
  1769
  
    
                case -ENOENT:


  		





  1771
  
  
    
                    monitor_printf(mon, "Could not find snapshot '%s' on "


  		





  1772
  
  
    
                                   "device '%s'\n",


  		





  1773
  
  
    
                                   name, bdrv_get_device_name(bs1));


  		





  
  1770
  
    
                    qemu_error("Could not find snapshot '%s' on device '%s'\n",


  		





  
  1771
  
    
                               name, bdrv_get_device_name(bs1));


  		





  1774
  1772
  
    
                    break;


  		





  1775
  1773
  
    
                default:


  		





  1776
  
  
    
                    monitor_printf(mon, "Error %d while activating snapshot on"


  		





  1777
  
  
    
                                   " '%s'\n", ret, bdrv_get_device_name(bs1));


  		





  
  1774
  
    
                    qemu_error("Error %d while activating snapshot on '%s'\n",


  		





  
  1775
  
    
                               ret, bdrv_get_device_name(bs1));


  		





  1778
  1776
  
    
                    break;


  		





  1779
  1777
  
    
                }


  		





  1780
  1778
  
    
                /* fatal on snapshot block device */


  		





  ......




  1792
  1790
  
    
    /* restore the VM state */


  		





  1793
  1791
  
    
    f = qemu_fopen_bdrv(bs, 0);


  		





  1794
  1792
  
    
    if (!f) {


  		





  1795
  
  
    
        monitor_printf(mon, "Could not open VM state file\n");


  		





  
  1793
  
    
        qemu_error("Could not open VM state file\n");


  		





  1796
  1794
  
    
        return -EINVAL;


  		





  1797
  1795
  
    
    }


  		





  1798
  1796
  
    
    ret = qemu_loadvm_state(f);


  		





  1799
  1797
  
    
    qemu_fclose(f);


  		





  1800
  1798
  
    
    if (ret < 0) {


  		





  1801
  
  
    
        monitor_printf(mon, "Error %d while loading VM state\n", ret);


  		





  
  1799
  
    
        qemu_error("Error %d while loading VM state\n", ret);


  		





  1802
  1800
  
    
        return ret;


  		





  1803
  1801
  
    
    }


  		





  1804
  1802
  
    
    return 0;


  		












  

    
      b/sysemu.h
    
  






  54
  54
  
    
void qemu_system_reset(void);


  		





  55
  55
  
    

  		





  56
  56
  
    
void do_savevm(Monitor *mon, const QDict *qdict);


  		





  57
  
  
    
int load_vmstate(Monitor *mon, const char *name);


  		





  
  57
  
    
int load_vmstate(const char *name);


  		





  58
  58
  
    
void do_delvm(Monitor *mon, const QDict *qdict);


  		





  59
  59
  
    
void do_info_snapshots(Monitor *mon);


  		





  60
  60
  
    

  		












  

    
      b/vl.c
    
  






  6072
  6072
  
    

  		





  6073
  6073
  
    
    qemu_system_reset();


  		





  6074
  6074
  
    
    if (loadvm) {


  		





  6075
  
  
    
        if (load_vmstate(cur_mon, loadvm) < 0) {


  		





  
  6075
  
    
        if (load_vmstate(loadvm) < 0) {


  		





  6076
  6076
  
    
            autostart = 0;


  		





  6077
  6077
  
    
        }


  		





  6078
  6078
  
    
    }


  		












Also available in:
  Unified diff