Xen project Mailing List

[Xen-devel] [ANNOUNCE] CoW source released

To: "'xen-devel@xxxxxxxxxxxxxxxxxxx'" <xen-devel@xxxxxxxxxxxxxxxxxxx>

Date: Mon, 20 Apr 2009 12:20:12 -0700

Cc: "Andrew Warfield $cs$" <andy@xxxxxxxxx>

Delivery-date: Mon, 20 Apr 2009 12:21:37 -0700

List-id: Xen developer discussion <xen-devel.lists.xensource.com>

Hello, I've been working on VM snapshots/CoW for Xen (as seen at Xen Summit this year). I'm happy to release my first version. There are some known issues with capturing page dirties for HVM guests. I think it's related to the QEMU code (I believe I'm not catching the pages that QEMU dirties). However, it works with both 32-bit and 64-bit PV guests. This release includes modifications to Linux, Xen, and some tools (a library, FUSE fs, and testing tool). The FUSE file system will take a snapshot if you try to create a file in the directory you mount the xencowfs file system too. The testing tool pauses a domain, enables CoW, takes a dump of the CoW image, takes two live memory dumps, unpauses the domain for a bit, then takes another CoW image. It compares all the images and reports on which pages are different. These patches are against xen-unstable revision 19425, however I had no trouble patching them against the current revision of xen-unstable (19553). Please remember this is an alpha release, so there is likely to be some problems. Please let me know if you find any! Patrick

diff -r 832aac894efd drivers/xen/Kconfig --- a/drivers/xen/Kconfig Wed Nov 19 13:15:46 2008 +0000 +++ b/drivers/xen/Kconfig Mon Mar 16 00:01:12 2009 -0700 @@ -312,4 +312,7 @@ config XEN_DEVMEM def_bool y +config XEN_XENCOW + def_bool y + endif diff -r 832aac894efd drivers/xen/Makefile --- a/drivers/xen/Makefile Wed Nov 19 13:15:46 2008 +0000 +++ b/drivers/xen/Makefile Mon Mar 16 00:01:12 2009 -0700 @@ -23,3 +23,4 @@ obj-$(CONFIG_XEN_NETDEV_ACCEL_SFC_UTIL) += sfc_netutil/ obj-$(CONFIG_XEN_NETDEV_ACCEL_SFC_FRONTEND) += sfc_netfront/ obj-$(CONFIG_XEN_NETDEV_ACCEL_SFC_BACKEND) += sfc_netback/ +obj-$(CONFIG_XEN_XENCOW) += xencow/ diff -r 832aac894efd drivers/xen/xencow/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/drivers/xen/xencow/Makefile Mon Mar 16 00:01:12 2009 -0700 @@ -0,0 +1,2 @@ + +obj-m := xencow.o diff -r 832aac894efd drivers/xen/xencow/common.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/drivers/xen/xencow/common.h Mon Mar 16 00:01:12 2009 -0700 @@ -0,0 +1,74 @@ +/****************************************************************************** + * common.h + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation; or, when distributed + * separately from the Linux kernel or incorporated into other + * software packages, subject to the following license: + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this source file (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifndef __XEN_XENCOW_COMMON_H__ +#define __XEN_XENCOW_COMMON_H__ + + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/fs.h> +#include <linux/types.h> +#include <linux/err.h> +#include <linux/kernel.h> +#include <linux/gfp.h> +#include <xen/interface/platform.h> +#include <xen/driver_util.h> +#include <asm/io.h> +#include <asm/uaccess.h> +#include <linux/config.h> +#include <linux/version.h> +#include <linux/cdev.h> +#include <linux/slab.h> +#include <linux/vmalloc.h> +#include <linux/mm.h> +#include <linux/highmem.h> +#include <linux/pagemap.h> +#include <xen/interface/io/ring.h> +#include <xen/interface/io/xencow.h> + + +#define DPRINTK(_f, _a...) pr_debug("(file=%s, line=%d) " _f, \ + __FILE__ , __LINE__ , ## _a ) + +#define WPRINTK(fmt, args...) printk(KERN_WARNING "xen_cow: " fmt, ##args) + + +#endif /* __XEN_XENCOW_COMMON_H__ */ + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 832aac894efd drivers/xen/xencow/xencow.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/drivers/xen/xencow/xencow.c Mon Mar 16 00:01:12 2009 -0700 @@ -0,0 +1,246 @@ +/****************************************************************************** + * xencow.c + * + * Xen Copy-on-Write Kernel Driver - Initialises CoW buffer for userspace + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation; or, when distributed + * separately from the Linux kernel or incorporated into other + * software packages, subject to the following license: + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this source file (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + + +#include "common.h" + + +static int xencow_major; + + +static void xencow_release_user_pages(struct page *pages[], int num) +{ + int i; + + for ( i = 0; i < num; i++ ) + { + struct page *page = pages[i]; + SetPageUptodate(page); + put_page(page); + } +} + +static int xencow_get_user_pages(unsigned long addr, + int num, + struct page *pages[]) +{ + int ret; + + down_read(&current->mm->mmap_sem); + ret = get_user_pages(current, current->mm, addr, num, 0, 0, pages, NULL); + up_read(&current->mm->mmap_sem); + + if ( ret != num ) + { + if ( ret >= 0 ) + { + xencow_release_user_pages(pages, ret); + ret = -E2BIG; + } + + return ret; + } + + return 0; +} + +static inline unsigned long xencow_page_to_mfn(struct page *page) +{ + unsigned long pfn; + unsigned long mfn; + + pfn = page_to_pfn(page); + mfn = pfn_to_mfn(pfn); + + return mfn; +} + +static int xencow_get_page_mfns(unsigned long addr, + int num, + unsigned long mfns[]) +{ + struct page *pages[num]; + unsigned long mfn; + int ret; + int i; + + /* Get user pages */ + ret = xencow_get_user_pages(addr, num, pages); + if ( ret != 0 ) + return ret; + + /* Get MFNs for the pages */ + for ( i = 0; i < num; i++ ) + { + mfn = xencow_page_to_mfn(pages[i]); + if ( mfn == 0 ) + return -EFAULT; + + mfns[i] = mfn; + } + + /* Return user pages */ + xencow_release_user_pages(pages, num); + + return 0; +} + +static int xencow_ioctl(struct inode *inode, struct file *filp, + unsigned int cmd, unsigned long arg) +{ + int ret = 0; + + switch ( cmd ) + { + + case XEN_COW_IOCTL_INIT: + { + xencow_init_t *cow_init; + xencow_init_t __user *cow_init_u; + int num_mfns; + int i; + + cow_init_u = (xencow_init_t __user *)arg; + + /* Check access on user init struct */ + ret = -EFAULT; + if ( !access_ok(VERIFY_READ, cow_init_u, sizeof(xencow_init_t)) ) + break; + + /* Get the number of frames in the buffer */ + ret = __get_user(num_mfns, &cow_init_u->num_mfns); + if ( ret != 0 ) + break; + + /* Allocate space */ + ret = -ENOMEM; + cow_init = (xencow_init_t *) + kmalloc(sizeof(xencow_init_t) + + (num_mfns * sizeof(unsigned long)), + GFP_KERNEL); + if ( cow_init == NULL ) + break; + + cow_init->num_mfns = num_mfns; + + /* Get start address of buffer */ + ret = __get_user(cow_init->addr, &cow_init_u->addr); + if ( ret != 0 ) + goto init_out; + + /* Get page buffer MFNs */ + ret = xencow_get_page_mfns(cow_init->addr, + cow_init->num_mfns, + cow_init->mfns); + if ( ret != 0 ) + goto init_out; + + /* Check access on user page buffer MFNs array */ + ret = -EFAULT; + if ( !access_ok(VERIFY_WRITE, &cow_init_u->mfns, + cow_init->num_mfns * sizeof(unsigned long)) ) + goto init_out; + + /* Send page buffer MFNs to user */ + ret = 0; + for ( i = 0; i < cow_init->num_mfns; i++ ) + ret |= __put_user(cow_init->mfns[i], &cow_init_u->mfns[i]); + + init_out: + kfree(cow_init); + } + break; + + default: + ret = -ENOTTY; + break; + } + + return ret; +} + +static const struct file_operations xencow_fops = { + .owner = THIS_MODULE, + .ioctl = xencow_ioctl, +}; + +static int __init xencow_init(void) +{ + int ret; + struct class *class; + + if ( !is_running_on_xen() ) + return -ENODEV; + + ret = register_chrdev(0, "xencow", &xencow_fops); + if ( ret < 0 ) + { + WPRINTK("Couldn't register /dev/xen/xencow\n"); + return ret; + } + + xencow_major = ret; + + DPRINTK("Created misc_dev [/dev/xen/xencow%d]\n", xencow_major); + + /* Make sure the xen class exists */ + class = get_xen_class(); + if ( class != NULL ) + class_device_create(class, NULL, MKDEV(xencow_major, 0), + NULL, "xencow0"); + else + /* This is bad, but not fatal */ + WPRINTK("sysfs xen_class not created\n"); + + DPRINTK("XenCoW device successfully created\n"); + + return 0; +} + +static void __exit xencow_exit(void) +{ + int ret; + + ret = unregister_chrdev(xencow_major, "xencow"); + if ( ret < 0 ) + { + WPRINTK("Error: Couldn't unregister /dev/xen/xencow: %d\n", ret); + return; + } + + DPRINTK("XenCoW device successfully removed\n"); +} + +module_init(xencow_init); +module_exit(xencow_exit); + +MODULE_LICENSE("Dual BSD/GPL"); diff -r 832aac894efd include/xen/interface/io/xencow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/include/xen/interface/io/xencow.h Mon Mar 16 00:01:12 2009 -0700 @@ -0,0 +1,70 @@ +/***************************************************************************** + * xencow.h + * + * XenCoW Common Structures + * + * Copyright (C) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _XEN_PUBLIC_IO_XENCOW_H +#define _XEN_PUBLIC_IO_XENCOW_H + + +#include "ring.h" + + +#define XEN_COW_IOC_MAGIC 'w' +#define XEN_COW_IOCTL_INIT _IO(XEN_COW_IOC_MAGIC, 1) + + +/* Some definitions for the XenCow ring buffer. */ +typedef struct xencow_request_st { + ulong mfn; +} xencow_request_t; + +typedef struct xencow_response_st { + ulong pfn; +} xencow_response_t; + +DEFINE_RING_TYPES(xencow, xencow_request_t, xencow_response_t); + + +/* The structure used to initialise a XenCoW snapshot. */ +typedef struct xencow_init_st { + /* Start address of buffer */ + unsigned long addr; + /* Number of frames in buffer */ + int num_mfns; + /* MFNs of buffer frames */ + unsigned long mfns[]; +} xencow_init_t; + + + +#endif /* _XEN_PUBLIC_IO_XENCOW_H */ + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */

diff -r 0477f9061c8a tools/Makefile --- a/tools/Makefile Fri Mar 20 17:42:46 2009 +0000 +++ b/tools/Makefile Mon Apr 20 10:21:49 2009 -0700 @@ -26,6 +26,7 @@ SUBDIRS-$(CONFIG_Linux) += fs-back SUBDIRS-$(CONFIG_IOEMU) += ioemu-dir SUBDIRS-y += xenpmd +SUBDIRS-y += xencow # These don't cross-compile ifeq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) diff -r 0477f9061c8a tools/xencow/COPYING --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/COPYING Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff -r 0477f9061c8a tools/xencow/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/Makefile Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,10 @@ +XEN_ROOT=../.. +include $(XEN_ROOT)/tools/Rules.mk + +SUBDIRS-y := +SUBDIRS-y += lib +SUBDIRS-y += xencowfs +SUBDIRS-y += test + +.PHONY: all clean install +all install clean: %: subdirs-% diff -r 0477f9061c8a tools/xencow/README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/README Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,19 @@ +Xen Copy on Write +----------------------- +Provide copy on write functionality for the memory of Xen domains. + + + + +Usage Notes and issues +---------------------- + + +Future Work +----------- + +Authors +------- +Chris Matthews <cmatthew@xxxxxxxxxx> +Geoffrey Lifebvre <geoffrey@xxxxxxxxx> +Brendan Cully <brendan@xxxxxxxxx> diff -r 0477f9061c8a tools/xencow/lib/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/lib/Makefile Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,66 @@ +XEN_ROOT=../../.. +include $(XEN_ROOT)/tools/Rules.mk + +MAKE_LINK=ln -sf + +MAJOR = 0 +MINOR = 0 +SONAME = libxencow.so.$(MAJOR) + +CFLAGS += -I $(XEN_XC) +CFLAGS += -I ./ +CFLAGS += $(CFLAGS_libxenctrl) +LDFLAGS += $(LDFLAGS_libxenctrl) + +SRCS := +SRCS += xc.c xencow.c + +CFLAGS += -Werror +CFLAGS += -Wno-unused +CFLAGS += -fPIC +CFLAGS += -g + +CTRL_LIB_OBJS := $(patsubst %.c,%.o,$(CTRL_SRCS-y)) +CTRL_PIC_OBJS += $(patsubst %.c,%.opic,$(CTRL_SRCS-y)) + +# Get gcc to generate the dependencies for us. +CFLAGS += -Wp,-MD,.$(@F).d +DEPS = .*.d + +OBJS = $(SRCS:.c=.o) +OBJS_PIC = $(SRCS:.c=.opic) +IBINS := + +LIB = libxencow.a libxencow.so.$(MAJOR).$(MINOR) + +.PHONY: all +all: $(LIB) + +.PHONY: install +install: all + $(INSTALL_DIR) $(DESTDIR)$(LIBDIR) + $(INSTALL_DIR) $(DESTDIR)$(INCLUDEDIR) + $(INSTALL_DATA) $(LIB) $(DESTDIR)$(LIBDIR) + $(MAKE_LINK) libxencow.so.$(MAJOR).$(MINOR) $(DESTDIR)$(LIBDIR)/libxencow.so.$(MAJOR) + $(MAKE_LINK) libxencow.so.$(MAJOR) $(DESTDIR)$(LIBDIR)/libxencow.so + $(INSTALL_DATA) xencow.h $(DESTDIR)$(INCLUDEDIR) + $(INSTALL_DATA) xencow_list.h $(DESTDIR)$(INCLUDEDIR) + +.PHONY: clean +clean: + rm -rf *.a *.so* *.o *.opic $(LIB) *~ $(DEPS) xen TAGS + +libxencow.so.$(MAJOR).$(MINOR): $(OBJS_PIC) + $(CC) $(CFLAGS) $(LDFLAGS) -Wl,$(SONAME_LDFLAG) -Wl,libxencow.so.$(MAJOR) $(SHLIB_CFLAGS) -o $@ $^ + $(MAKE_LINK) libxencow.so.$(MAJOR).$(MINOR) libxencow.so.$(MAJOR) + $(MAKE_LINK) libxencow.so.$(MAJOR) libxencow.so + +libxencow.a: $(OBJS) + $(AR) rcs $@ $^ + +.PHONY: TAGS +TAGS: + etags -t $(SRCS) *.h + +-include $(DEPS) + diff -r 0477f9061c8a tools/xencow/lib/xc.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/lib/xc.c Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,357 @@ +/****************************************************************************** + * tools/xencow/lib/xc.c + * + * libxc refactorisation. This should be put in libxc ultimately. + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include <xg_private.h> +#include <xg_save_restore.h> +#include "xc.h" + + +/* + * Returns TRUE if the given machine frame number has a unique mapping + * in the guest's pseudophysical map. + */ +#define MFN_IS_IN_PSEUDOPHYS_MAP(_mfn) \ + (((_mfn) < (max_mfn)) && \ + ((mfn_to_pfn(_mfn) < (p2m_size)) && \ + (pfn_to_mfn(mfn_to_pfn(_mfn)) == (_mfn)))) + + +xen_pfn_t *xc_map_m2p(int xc_handle, unsigned long max_mfn, int prot, + unsigned long *m2p_mfn0) +{ + struct xen_machphys_mfn_list xmml; + privcmd_mmap_entry_t *entries; + unsigned long m2p_chunks; + unsigned long m2p_size; + xen_pfn_t *m2p; + xen_pfn_t *extent_start; + int i; + + m2p = NULL; + m2p_size = M2P_SIZE(max_mfn); + m2p_chunks = M2P_CHUNKS(max_mfn); + + xmml.max_extents = m2p_chunks; + + extent_start = calloc(m2p_chunks, sizeof(xen_pfn_t)); + if ( !extent_start ) + { + ERROR("failed to allocate space for m2p mfns"); + goto err0; + } + set_xen_guest_handle(xmml.extent_start, extent_start); + + if ( xc_memory_op(xc_handle, XENMEM_machphys_mfn_list, &xmml) + || (xmml.nr_extents != m2p_chunks) ) + { + ERROR("xc_get_m2p_mfns"); + goto err1; + } + + entries = calloc(m2p_chunks, sizeof(privcmd_mmap_entry_t)); + if (entries == NULL) + { + ERROR("failed to allocate space for mmap entries"); + goto err1; + } + + for ( i = 0; i < m2p_chunks; i++ ) + entries[i].mfn = extent_start[i]; + + m2p = xc_map_foreign_ranges(xc_handle, DOMID_XEN, m2p_size, prot, + M2P_CHUNK_SIZE, entries, m2p_chunks); + if (m2p == NULL) + { + ERROR("xc_mmap_foreign_ranges failed"); + goto err2; + } + + *m2p_mfn0 = entries[0].mfn; + + err2: + free(entries); + err1: + free(extent_start); + err0: + return m2p; +} + +/* During transfer (or in the state file), all page-table pages must be + * converted into a 'canonical' form where references to actual mfns + * are replaced with references to the corresponding pfns. + * + * This function performs the appropriate conversion, taking into account + * which entries do not require canonicalisation (in particular, those + * entries which map the virtual address reserved for the hypervisor). */ +int xc_canonicalise_pagetable(unsigned long type, unsigned long pfn, + const void *spage, void *dpage, + xen_pfn_t *live_p2m_table, + xen_pfn_t *live_m2p_table, unsigned long m2p_mfn0, + unsigned long p2m_size, unsigned long max_mfn, + unsigned long hvirt_start, unsigned int pt_levels, + unsigned int guest_width) +{ + uint64_t pte; + int pte_last; + int xen_start; + int xen_end; + int i; + int race = 0; + + /* + * We need to determine which entries in this page table hold + * reserved hypervisor mappings. This depends on the current + * page table type as well as the number of paging levels. + */ + xen_start = xen_end = pte_last = PAGE_SIZE / ((pt_levels == 2) ? 4 : 8); + + if ( (pt_levels == 2) && (type == XEN_DOMCTL_PFINFO_L2TAB) ) + xen_start = (hvirt_start >> L2_PAGETABLE_SHIFT); + + if ( (pt_levels == 3) && (type == XEN_DOMCTL_PFINFO_L3TAB) ) + xen_start = L3_PAGETABLE_ENTRIES_PAE; + + /* + * In PAE only the L2 mapping the top 1GB contains Xen mappings. + * We can spot this by looking for the guest's mapping of the m2p. + * Guests must ensure that this check will fail for other L2s. + */ + if ( (pt_levels == 3) && (type == XEN_DOMCTL_PFINFO_L2TAB) ) + { + int hstart; + uint64_t he; + + hstart = (hvirt_start >> L2_PAGETABLE_SHIFT_PAE) & 0x1ff; + he = ((const uint64_t *)spage)[hstart]; + + if ( ((he >> PAGE_SHIFT) & MFN_MASK_X86) == m2p_mfn0 ) + { + /* hvirt starts with xen stuff... */ + xen_start = hstart; + } + else if ( hvirt_start != 0xf5800000 ) + { + /* old L2s from before hole was shrunk... */ + hstart = (0xf5800000 >> L2_PAGETABLE_SHIFT_PAE) & 0x1ff; + he = ((const uint64_t *)spage)[hstart]; + if ( ((he >> PAGE_SHIFT) & MFN_MASK_X86) == m2p_mfn0 ) + xen_start = hstart; + } + } + + if ( (pt_levels == 4) && (type == XEN_DOMCTL_PFINFO_L4TAB) ) + { + /* + * XXX SMH: should compute these from hvirt_start (which we have) + * and hvirt_end (which we don't) + */ + xen_start = 256; + xen_end = 272; + } + + /* Now iterate through the page table, canonicalising each PTE */ + for ( i = 0; i < pte_last; i++ ) + { + unsigned long pfn; + unsigned long mfn; + + if ( pt_levels == 2 ) + pte = ((const uint32_t*)spage)[i]; + else + pte = ((const uint64_t*)spage)[i]; + + if ( (i >= xen_start) && (i < xen_end) ) + pte = 0; + + if ( pte & _PAGE_PRESENT ) + { + mfn = (pte >> PAGE_SHIFT) & MFN_MASK_X86; + if ( !MFN_IS_IN_PSEUDOPHYS_MAP(mfn) ) + { + /* + * This will happen if the type info is stale which + * is quite feasible under live migration + */ + pfn = 0; /* zap it - we'll retransmit this page later */ + /* + * XXX: We can't spot Xen mappings in compat-mode L2es + * from 64-bit tools, but the only thing in them is the + * compat m2p, so we quietly zap them. This doesn't + * count as a race, so don't report it. + */ + if ( !(type == XEN_DOMCTL_PFINFO_L2TAB + && sizeof(unsigned long) > guest_width) ) + race = 1; /* inform the caller; fatal if !live */ + } + else + pfn = mfn_to_pfn(mfn); + + pte &= ~MADDR_MASK_X86; + pte |= (uint64_t)pfn << PAGE_SHIFT; + + /* + * PAE guest L3Es can contain these flags when running on + * a 64bit hypervisor. We zap these here to avoid any + * surprise at restore time... + */ + if ( (pt_levels == 3) + && (type == XEN_DOMCTL_PFINFO_L3TAB) + && (pte & (_PAGE_USER|_PAGE_RW|_PAGE_ACCESSED)) ) + pte &= ~(_PAGE_USER|_PAGE_RW|_PAGE_ACCESSED); + } + + if ( pt_levels == 2 ) + ((uint32_t*)dpage)[i] = pte; + else + ((uint64_t*)dpage)[i] = pte; + } + + return race; +} + +xen_pfn_t *xc_get_live_p2m_table(int xc_handle, domid_t domain_id, + unsigned long p2m_size, + unsigned int guest_width) +{ + xc_dominfo_t info; + shared_info_t *live_shared_info = NULL; + xen_pfn_t *live_p2m_frame_list_list = NULL; + xen_pfn_t *live_p2m_frame_list = NULL; + xen_pfn_t *p2m_frame_list_list = NULL; + xen_pfn_t *p2m_frame_list = NULL; + xen_pfn_t *live_p2m_table = NULL; + int i; + + /* Map the shared info frame */ + if ( xc_domain_getinfo(xc_handle, domain_id, 1, &info) != 1 ) + { + ERROR("could not get domain info"); + goto out; + } + + live_shared_info = xc_map_foreign_range(xc_handle, domain_id, + PAGE_SIZE, PROT_READ, + info.shared_info_frame); + if ( live_shared_info == NULL ) + { + ERROR("could not map live shared info"); + goto out; + } + + /* Get the p2m frame list list */ + live_p2m_frame_list_list = + xc_map_foreign_range(xc_handle, domain_id, PAGE_SIZE, PROT_READ, + live_shared_info->arch.pfn_to_mfn_frame_list_list); + if ( live_p2m_frame_list_list == NULL ) + { + ERROR("could not map live p2m frame list list"); + goto out; + } + + /* Get a local copy of the live_P2M_frame_list_list */ + p2m_frame_list_list = malloc(PAGE_SIZE); + if ( !p2m_frame_list_list ) + { + ERROR("could not allocate p2m_frame_list_list array"); + goto out; + } + memcpy(p2m_frame_list_list, live_p2m_frame_list_list, PAGE_SIZE); + + /* Canonicalise guest's unsigned long vs ours */ + if ( guest_width > sizeof(unsigned long) ) + for ( i = 0; i < PAGE_SIZE/sizeof(unsigned long); i++ ) + if ( i < PAGE_SIZE/guest_width ) + p2m_frame_list_list[i] = ((uint64_t *)p2m_frame_list_list)[i]; + else + p2m_frame_list_list[i] = 0; + else if ( guest_width < sizeof(unsigned long) ) + for ( i = PAGE_SIZE/sizeof(unsigned long) - 1; i >= 0; i-- ) + p2m_frame_list_list[i] = ((uint32_t *)p2m_frame_list_list)[i]; + + /* Get the p2m frame list */ + live_p2m_frame_list = xc_map_foreign_batch(xc_handle, domain_id, PROT_READ, + p2m_frame_list_list, + P2M_FLL_ENTRIES); + if ( live_p2m_frame_list == NULL ) + { + ERROR("could not map live p2m frame list"); + goto out; + } + + /* Get a local copy of the live p2m frame_list */ + p2m_frame_list = malloc(P2M_TOOLS_FL_SIZE); + if ( !p2m_frame_list ) + { + ERROR("could not allocate p2m frame list array"); + goto out; + } + memset(p2m_frame_list, 0, P2M_TOOLS_FL_SIZE); + memcpy(p2m_frame_list, live_p2m_frame_list, P2M_GUEST_FL_SIZE); + + /* Canonicalise guest's unsigned long vs ours */ + if ( guest_width > sizeof(unsigned long) ) + for ( i = 0; i < P2M_FL_ENTRIES; i++ ) + p2m_frame_list[i] = ((uint64_t *)p2m_frame_list)[i]; + else if ( guest_width < sizeof(unsigned long) ) + for ( i = P2M_FL_ENTRIES - 1; i >= 0; i-- ) + p2m_frame_list[i] = ((uint32_t *)p2m_frame_list)[i]; + + /* Get the p2m table */ + live_p2m_table = xc_map_foreign_batch(xc_handle, domain_id, PROT_READ, + p2m_frame_list, + P2M_FL_ENTRIES); + if ( live_p2m_table == NULL ) + { + ERROR("could not map live p2m table"); + goto out; + } + + out: + if ( live_p2m_frame_list ) + munmap(live_p2m_frame_list, P2M_FLL_ENTRIES * PAGE_SIZE); + + if ( live_p2m_frame_list_list ) + munmap(live_p2m_frame_list_list, PAGE_SIZE); + + if ( live_shared_info ) + munmap(live_shared_info, PAGE_SIZE); + + if ( p2m_frame_list ) + free(p2m_frame_list); + + if ( p2m_frame_list_list ) + free(p2m_frame_list_list); + + return live_p2m_table; +} + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a tools/xencow/lib/xc.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/lib/xc.h Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,72 @@ +/****************************************************************************** + * tools/xencow/lib/xc.h + * + * libxc refactorisation. This should be put in libxc ultimately. + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#define mfn_to_pfn(_mfn) (live_m2p_table[(_mfn)]) + +#define pfn_to_mfn(_pfn) \ + ((xen_pfn_t) (((guest_width)==8) \ + ? (((uint64_t *)live_p2m_table)[(_pfn)]) \ + : ((((uint32_t *)live_p2m_table)[(_pfn)]) == 0xffffffffU \ + ? (-1UL) : (((uint32_t *)live_p2m_table)[(_pfn)])))) + + +#if 0 +typedef struct xc_domain_st { + domid_t domain_id + xen_pfn_t *live_p2m_table; + xen_pfn_t *live_m2p_table; + unsigned long m2p_mfn0; + unsigned long p2m_size; + unsigned long max_mfn; + unsigned long hvirt_start; + unsigned int pt_levels; + unsigned int guest_width; +} xc_domain_t; +#endif + + +xen_pfn_t *xc_map_m2p(int xc_handle, unsigned long max_mfn, int prot, + unsigned long *m2p_mfn0); + +int xc_canonicalise_pagetable(unsigned long type, unsigned long pfn, + const void *spage, void *dpage, + xen_pfn_t *live_p2m_table, + xen_pfn_t *live_m2p_table, unsigned long m2p_mfn0, + unsigned long p2m_size, unsigned long max_mfn, + unsigned long hvirt_start, unsigned int pt_levels, + unsigned int guest_width); + +xen_pfn_t *xc_get_live_p2m_table(int xc_handle, domid_t domain_id, + unsigned long p2m_size, + unsigned int guest_width); + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a tools/xencow/lib/xencow.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/lib/xencow.c Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,1072 @@ +/****************************************************************************** + * tools/xencow/lib/xencow.c + * + * VM memory Copy-on-Write library. + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include <stdio.h> +#include <fcntl.h> +#include <inttypes.h> +#include <errno.h> +#include <sys/ioctl.h> +#include <sys/poll.h> + +#include <pthread.h> +#include <signal.h> + +#include <xen/domctl.h> + +#include <xc_private.h> +#include <xg_save_restore.h> + +#include "xc.h" +#include "xencow.h" + + +static int xencow_create_file(const char *filename) +{ + mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; + int flags = O_CREAT | O_TRUNC | O_RDWR; + int fd; + + fd = open(filename, flags, mode); + if ( fd < 0 ) + { + ERROR("Error opening file %s", filename); + return -EIO; + } + close(fd); + + return 0; +} + +/* Send an ioctl to the xencow device. */ +static int xencow_send_ioctl(int cmd, unsigned long arg) +{ + int fd; + int ret; + + ret = -EIO; + fd = open("/dev/xencow0", O_RDWR); + if ( fd < 0 ) + { + ERROR("Failed to open xencow device (/dev/xencow0)"); + goto out; + } + + ret = ioctl(fd, cmd, arg); + if ( ret != 0 ) + ERROR("Error during ioctl of xencow device"); + + close(fd); + + out: + return ret; +} + +static void xencow_free(xencow_t *cow) +{ + munlock(cow->buffer, BUFFER_SIZE); + free(cow->buffer); + free(cow->mfns); + + if ( cow->live_p2m_table ) + free(cow->live_p2m_table); +} + +static int xencow_alloc_bitmap(unsigned long **bitmap, unsigned long bitmap_size) +{ + if ( *bitmap == NULL ) + { + *bitmap = calloc(bitmap_size / BITS_PER_LONG, sizeof(unsigned long)); + if ( *bitmap == NULL ) + return -ENOMEM; + } + + memset(*bitmap, 0, bitmap_size / 8); + + return 0; +} + +static void *xencow_handle_events(void *c) +{ + xencow_t *cow = (xencow_t *)c; + + IPRINTF("Starting resume thread\n"); + + while (1) + { + int port = xencow_wait_for_event_or_timeout(cow, 10); + + if ( port == cow->buffer_port || port == -1 ) + { + if ( port == cow->buffer_port ) + DPRINTF("Got buffer event\n"); + xencow_flush_buffer(cow); + } + else if ( port == cow->pause_port ) + { + /* If it was a pause event, flush buffer and resume domain */ + int rc; + + DPRINTF("Got pause event\n"); + + xencow_flush_buffer(cow); + + rc = xencow_resume(cow); + if ( rc != 0 ) + ERROR("Failed to resume domain"); + } + else + ERROR("Unknown event"); + } +} + +static int xencow_start_thread(xencow_t *cow, void *(*__start_routine) (void *)) +{ + pthread_t thread; + sigset_t oldset; + sigset_t newset; + int ret; + + sigemptyset(&newset); + sigaddset(&newset, SIGTERM); + sigaddset(&newset, SIGINT); + sigaddset(&newset, SIGHUP); + sigaddset(&newset, SIGQUIT); + pthread_sigmask(SIG_BLOCK, &newset, &oldset); + + ret = pthread_create(&thread, NULL, __start_routine, cow); + if ( ret != 0 ) + { + ERROR("Failed to create thread"); + return -EIO; + } + + pthread_detach(thread); + pthread_sigmask(SIG_SETMASK, &oldset, NULL); + + return 0; +} + +static int xencow_init_buffer(xencow_t *cow) +{ + void *buffer; + cow_init_t *cow_init; + cow_request_t req; + RING_IDX req_prod; + int num_pages; + int i; + int ret; + + DPRINTF("buffer size: %ld\n", BUFFER_SIZE); + + /* Allocated page aligned buffer */ + ret = posix_memalign(&buffer, PAGE_SIZE, BUFFER_SIZE); + if ( ret != 0 ) + goto out_alloc; + + /* Lock buffer in memory so it can't be paged out */ + ret = mlock(buffer, BUFFER_SIZE); + if ( ret != 0 ) + goto out_lock; + + cow->buffer = buffer; + cow->page_buffer = buffer + XEN_COW_RING_SIZE; + + /* Initialise ring */ + SHARED_RING_INIT((cow_sring_t *)cow->buffer); + FRONT_RING_INIT(&cow->front_ring, (cow_sring_t *)cow->buffer, XEN_COW_RING_SIZE); + + num_pages = XEN_COW_RING_PAGES + RING_SIZE(&cow->front_ring); + + DPRINTF("number of ring entries: %u\n", RING_SIZE(&cow->front_ring)); + + /* Allocate memory for ioctl struct */ + ret = -ENOMEM; + cow_init = malloc(sizeof(cow_init_t) + (sizeof(unsigned long) * num_pages)); + if ( cow_init == NULL ) + goto out_lock; + + /* Initialise ioctl struct */ + cow_init->addr = (unsigned long)(cow->buffer); + cow_init->num_mfns = num_pages; + + /* Get MFNs */ + ret = xencow_send_ioctl(XEN_COW_IOCTL_INIT, (unsigned long)cow_init); + if ( ret != 0 ) + goto out; + + /* Allocate memory for CoW struct */ + cow->num_mfns = RING_SIZE(&cow->front_ring); + cow->mfns = calloc(cow->num_mfns, sizeof(unsigned long)); + + /* Copy MFNs */ + cow->sring_mfn = cow_init->mfns[0]; + memcpy(cow->mfns, &cow_init->mfns[XEN_COW_RING_PAGES], + sizeof(unsigned long) * cow->num_mfns); + + /* Fill ring with page buffer MFNs */ + req_prod = cow->front_ring.req_prod_pvt; + for ( i = 0; i < cow->num_mfns; i++ ) + { + req.mfn = cow->mfns[i]; + memcpy(RING_GET_REQUEST(&cow->front_ring, req_prod + i), &req, + sizeof(cow_request_t)); + } + + cow->front_ring.req_prod_pvt = req_prod + i; + RING_PUSH_REQUESTS(&cow->front_ring); + + free(cow_init); + return 0; + + out: + free(cow_init); + out_init: + munlock(buffer, BUFFER_SIZE); + out_lock: + free(buffer); + out_alloc: + return ret; +} + +static int xencow_init_xen(xencow_t *cow) +{ + /* Open connection to Xen */ + cow->xc_handle = xc_interface_open(); + if ( cow->xc_handle < 0 ) + { + ERROR("Failed to connect to Xen"); + goto err; + } + + /* Open event channel */ + cow->xce_handle = xc_evtchn_open(); + if ( cow->xce_handle < 0 ) + { + ERROR("Failed to open event channel"); + goto err; + } + + /* Bind VIRQ ports for event notification */ + cow->buffer_port = xc_evtchn_bind_virq(cow->xce_handle, VIRQ_COW_BUFFER); + if ( cow->buffer_port < 0 ) + { + ERROR("Failed to bind VIRQ"); + goto err; + } + + cow->pause_port = xc_evtchn_bind_virq(cow->xce_handle, VIRQ_COW_PAUSE); + if ( cow->pause_port < 0 ) + { + ERROR("Failed to bind VIRQ"); + goto err; + } + + return 0; + + err: + return -EINVAL; +} + +static int xencow_init_domain_info(xencow_t *cow) +{ + xc_dominfo_t info; + int rc; + + /* Get HVM info */ + rc = xc_domain_getinfo(cow->xc_handle, cow->domain_id, 1, &info); + if ( rc != 1 ) + { + ERROR("Failed to get domain info"); + goto err; + } + cow->is_hvm = info.hvm; + + /* Get memory size */ + cow->p2m_size = xc_memory_op(cow->xc_handle, XENMEM_maximum_gpfn, + &cow->domain_id) + 1; + + /* Get platform info */ + rc = get_platform_info(cow->xc_handle, cow->domain_id, + &cow->platform_info.max_mfn, + &cow->platform_info.hvirt_start, + &cow->platform_info.pt_levels, + &cow->platform_info.guest_width); + if ( rc != 1 ) + { + ERROR("Failed to get platform info"); + goto err; + } + + return 0; + + err: + return -EINVAL; +} + +xencow_t *xencow_init(domid_t domid) +{ + xencow_t *cow; + int rc; + + /* Initialise CoW struct */ + cow = malloc(sizeof(xencow_t)); + if ( cow == NULL) + { + errno = ENOMEM; + goto cow_out; + } + + memset(cow, 0, sizeof(xencow_t)); + + cow->domain_id = domid; + cow->xc_handle = -1; + cow->xce_handle = -1; + + INIT_LIST_HEAD(&cow->snapshots); + + /* Initialise locks */ + cow_ring_lock_init(cow); + cow_snapshots_lock_init(cow); + + /* Initialise buffer */ + IPRINTF("Initialising buffer\n"); + rc = xencow_init_buffer(cow); + if ( rc != 0 ) + { + ERROR("Failed to initialise buffer"); + goto out; + } + + /* Initialise connection to Xen */ + rc = xencow_init_xen(cow); + if ( rc != 0 ) + { + ERROR("Failed to initialise connection to Xen"); + goto out; + } + + /* Get domain info */ + rc = xencow_init_domain_info(cow); + if ( rc != 0 ) + { + ERROR("Failed to get domain info"); + goto out; + } + + /* Start event handler thread */ + xencow_start_thread(cow, xencow_handle_events); + + return cow; + + out: + xencow_free(cow); + cow_out: + return NULL; +} + +static int xencow_open_snapshot_file_for_reading(xencow_snapshot_t *snapshot, + unsigned long pfn) +{ + int open_flags = O_RDONLY; + mode_t open_mode = S_IRUSR | S_IRGRP | S_IROTH; + char *filename; + + /* Open file */ + if ( state_pfn(pfn) ) + filename = snapshot->state_file; + else + filename = snapshot->backing_file; + + return open(filename, open_flags, open_mode); +} + +static int xencow_open_snapshot_file_for_writing(xencow_t *cow, + xencow_snapshot_t **snapshot, + RING_IDX now, + unsigned long pfn) +{ + int open_flags = O_RDWR; + mode_t open_mode = S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH; + char *filename; + + /* Get the right snapshot to copy this page to */ + list_for_each_entry_reverse ( (*snapshot), &cow->snapshots, list ) + if ( (*snapshot)->when <= now ) + break; + + /* Open file */ + if ( state_pfn(pfn) ) + filename = (*snapshot)->state_file; + else + filename = (*snapshot)->backing_file; + + return open(filename, open_flags, open_mode); +} + +static int xencow_read_page(int fd, unsigned long pfn, void *buffer_page) +{ + off_t offset; + off_t seek_ret; + int total_read; + int ret; + + offset = pfn_offset(pfn); + + seek_ret = lseek64(fd, offset, SEEK_SET); +#if 0 + if ( ret < 0 ) + { + ERROR("Error seeking: %ld (%lx)", (long)offset, offset_pfn(offset)); + ret = -errno; + goto err; + } +#endif + + total_read = 0; + while ( total_read < PAGE_SIZE ) + { + void *p = buffer_page + total_read; + int bytes_read = read(fd, p, PAGE_SIZE - total_read); + if ( bytes_read <= 0 ) + { + ret = -errno; + goto err; + } + + total_read += bytes_read; + } + + return 0; + + err: + ERROR("Read error"); + return ret; +} + +static int xencow_read_live_page(xencow_t *cow, unsigned long pfn, void *buffer_page) +{ + unsigned long mfn; + int ret; + + /* Get MFN */ + mfn = xencow_p2m(cow, pfn); + + /* Check if MFN is mapped */ + if ( is_mapped(mfn) ) + { + void *page = xc_map_foreign_batch(cow->xc_handle, cow->domain_id, PROT_READ, &mfn, 1); + int copy_frame = 0; + + if ( cow->is_hvm ) + { + if ( (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) != XEN_DOMCTL_PFINFO_XTAB ) + copy_frame = 1; + } + else + { + ((uint32_t *)(&mfn))[0] = mfn; + + ret = xc_get_pfn_type_batch(cow->xc_handle, cow->domain_id, 1, (uint32_t *)(&mfn)); + if ( ret != 0 ) + { + ERROR("get_pfn_type_batch failed"); + goto err; + } + mfn = (uint32_t)mfn; + + if ( (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) != XEN_DOMCTL_PFINFO_XTAB ) + { + /* Canonicalise mfn -> pfn */ + mfn = (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) | pfn; + copy_frame = 1; + } + } + + if ( copy_frame ) + { + /* Copy live page */ + if ( page != NULL ) + memcpy(buffer_page, page, PAGE_SIZE); + else + memset(buffer_page, 0, PAGE_SIZE); + } + else + /* Copy blank page */ + memset(buffer_page, 0, PAGE_SIZE); + + munmap(page, PAGE_SIZE); + } + else + /* Copy blank page */ + memset(buffer_page, 0, PAGE_SIZE); + + return 0; + + err: + return ret; +} + +static int xencow_read_snapshot_page(xencow_snapshot_t *snapshot, + unsigned long pfn, + void *buffer_page) +{ + int ret; + + if ( test_bit(pfn, snapshot->bitmap) ) + { + /* Open file for reading */ + int fd = xencow_open_snapshot_file_for_reading(snapshot, pfn); + if ( fd < 0 ) + { + ERROR("Error opening file"); + ret = -errno; + goto out; + } + + /* Read file and close */ + ret = xencow_read_page(fd, pfn, buffer_page); + close(fd); + } + else + ret = -ENOENT; + + out: + return ret; +} + +int xencow_read_buffer(xencow_t *cow, int snapshot_num, unsigned long start_pfn, + int num_pages, void *buffer) +{ + int open_flags = O_RDONLY; + mode_t open_mode = S_IRUSR | S_IRGRP | S_IROTH; + xencow_snapshot_t *snapshot; + int current_num; + int fd; + int i; + int ret; + + cow_snapshots_lock(cow); + + current_num = 0; + list_for_each_entry ( snapshot, &cow->snapshots, list ) + { + if ( current_num == snapshot_num ) + break; + current_num++; + } + + /* Open file */ + fd = xencow_open_snapshot_file_for_reading(snapshot, start_pfn); + if ( fd < 0 ) + { + ret = -errno; + goto out_open; + } + + /* Read pages */ + for ( i = 0; i < num_pages; i++ ) + { + void *buffer_page = buffer + (i * PAGE_SIZE); + unsigned long pfn = start_pfn + i; + + /* Check bitmap for page */ + if ( test_bit(pfn, snapshot->bitmap) ) + { + ret = xencow_read_page(fd, pfn, buffer_page); + if ( ret != 0 ) + goto out; + } + else + { + int found = 0; + + /* Check later snapshots */ + list_for_each_entry_continue ( snapshot, &cow->snapshots, list ) + { + ret = xencow_read_snapshot_page(snapshot, pfn, buffer_page); + if ( ret == 0 ) + { + found = 1; + break; + } + } + + if ( !found ) + { + /* If not found, read page from live domain */ + ret = xencow_read_live_page(cow, pfn, buffer_page); + if ( ret != 0 ) + goto out; + + /* Flush buffer */ + cow_snapshots_unlock(cow); + xencow_flush_buffer(cow); + cow_snapshots_lock(cow); + + /* Check (latest) bitmap for page again */ + snapshot = list_bottom(&cow->snapshots, xencow_snapshot_t, list); + + ret = xencow_read_snapshot_page(snapshot, pfn, buffer_page); + if ( ret == 0 ) + DPRINTF("Page dirtied since read from live\n"); + } + } + } + + ret = 0; + + out: + close(fd); + out_open: + cow_snapshots_unlock(cow); + return ret; +} + +static int xencow_write_page(int fd, off_t offset, void *page) +{ + int total_written; + int ret; + off_t seek_ret; + + seek_ret = lseek64(fd, offset, SEEK_SET); +#if 0 + if ( ret < 0 ) + { + ERROR("Error seeking: %ld (%lx)\n", (long)offset, offset_pfn(offset)); + ret = -errno; + goto out; + } +#endif + + /* Write page */ + total_written = 0; + while ( total_written < PAGE_SIZE ) + { + void *p = page + total_written; + int bytes_written = write(fd, p, PAGE_SIZE - total_written); + + DPRINTF("Writing first chunk: %lx\n", *((unsigned long *)p)); + + if ( bytes_written <= 0 ) + { + ERROR("Error writing"); + ret = -errno; + goto out; + } + + total_written += bytes_written; + + DPRINTF("Wrote %d bytes\n", bytes_written); + } + + ret = 0; + + out: + return ret; +} + +static int xencow_flush_page(xencow_t *cow, xencow_snapshot_t *snapshot, + RING_IDX now, int fd, unsigned long pfn, + void *page) +{ + off_t offset; + int ret; + + if ( state_pfn(pfn) ) + offset = pfn_offset(now - snapshot->when); + else if ( !test_and_set_bit(pfn, snapshot->bitmap) ) + offset = pfn_offset(pfn); + else + return -1; + + /* Write to file */ + ret = xencow_write_page(fd, offset, page); + if ( ret != 0 && !state_pfn(pfn) ) + clear_bit(pfn, snapshot->bitmap); + + return ret; +} + +#define BATCH_REQS 1 + +void xencow_flush_buffer(xencow_t *cow) +{ + cow_request_t req; + RING_IDX req_prod; + RING_IDX rsp_prod; + RING_IDX i; + xencow_snapshot_t *snapshot = NULL; + char *filename; + int fd = -1; + int fd_is_state = 0; + + if ( cow->next_snapshot == 0 ) + return; + + cow_ring_lock(cow); + + rsp_prod = cow->front_ring.sring->rsp_prod; + req_prod = cow->front_ring.sring->req_prod; + + /* Flush buffer pages */ + for ( i = cow->front_ring.rsp_cons; i != rsp_prod; i++ ) + { + cow_response_t rsp; + void *page = cow->page_buffer + + (RING_MASK(&cow->front_ring, i) << PAGE_SHIFT); + + memcpy(&rsp, RING_GET_RESPONSE(&cow->front_ring, i), + sizeof(cow_response_t)); + + DPRINTF("num: %lx; pfn: %lx; page first chunk: %lx\n", + (unsigned long)i, rsp.pfn, *((unsigned long *)page)); + + /* Open appropriate file */ + cow_snapshots_lock(cow); + + if ( (fd < 0) || + (state_pfn(rsp.pfn) && !fd_is_state) || + (!state_pfn(rsp.pfn) && fd_is_state)) + { + if ( fd >= 0 ) + close(fd); + + fd = xencow_open_snapshot_file_for_writing(cow, &snapshot, i, rsp.pfn); + if ( fd < 0 ) + { + ERROR("Error opening file"); + return; + } + + fd_is_state = state_pfn(rsp.pfn); + if ( fd_is_state ) + DPRINTF("state page: %d\n", i); + else + DPRINTF("normal page: %d\n", i); + } + + cow_snapshots_unlock(cow); + + /* Flush buffer page */ + xencow_flush_page(cow, snapshot, i, fd, rsp.pfn, page); + +#if !BATCH_REQS + cow->front_ring.rsp_cons = i + 1; + cow->front_ring.sring->rsp_event = i + 2; +#endif + + /* Put buffer page MFN in ring */ + req.mfn = cow->mfns[RING_MASK(&cow->front_ring, i)]; + memcpy(RING_GET_REQUEST(&cow->front_ring, req_prod), &req, + sizeof(cow_request_t)); + req_prod++; + +#if !BATCH_REQS + /* Push added MFN out */ + cow->front_ring.req_prod_pvt = req_prod; + RING_PUSH_REQUESTS(&cow->front_ring); +#endif + } + + if ( fd >= 0 ) + close(fd); + +#if BATCH_REQS + cow->front_ring.rsp_cons = i; + cow->front_ring.sring->rsp_event = i + 1; + + /* Push added MFNs out */ + cow->front_ring.req_prod_pvt = req_prod; + RING_PUSH_REQUESTS(&cow->front_ring); +#endif + + cow_ring_unlock(cow); +} + +int xencow_resume(xencow_t *cow) +{ + DECLARE_DOMCTL; + + domctl.cmd = XEN_DOMCTL_cow_resume; + domctl.domain = cow->domain_id; + + return do_domctl(cow->xc_handle, &domctl); +} + +int xencow_enable(xencow_t *cow) +{ + DECLARE_DOMCTL; + + domctl.cmd = XEN_DOMCTL_cow_enable; + domctl.domain = cow->domain_id; + domctl.u.cow_enable.mfn = cow->sring_mfn; + + return do_domctl(cow->xc_handle, &domctl); +} + +int xencow_disable(xencow_t *cow) +{ + DECLARE_DOMCTL; + + domctl.cmd = XEN_DOMCTL_cow_disable; + domctl.domain = cow->domain_id; + + return do_domctl(cow->xc_handle, &domctl); +} + +unsigned long xencow_p2m(xencow_t *cow, unsigned long pfn) +{ + unsigned long mnf; + unsigned long *live_p2m_table; + + if ( cow->is_hvm ) + return pfn; + + if ( cow->live_p2m_table == NULL ) + cow->live_p2m_table = + xc_get_live_p2m_table(cow->xc_handle, cow->domain_id, cow->p2m_size, + cow->platform_info.guest_width); + + return cow->live_p2m_table[pfn]; +} + +static int xencow_create_snapshot_files(xencow_t *cow, xencow_snapshot_t *snapshot) +{ + char *fuse_file = malloc(8 * sizeof(int) + 4); + char *backing_file = malloc(200); + char *state_file = malloc(200); + int ret; + + /* FIXME: Don't hardcode the path */ + /* Get file names */ + sprintf(fuse_file, "%d.%d", cow->domain_id, cow->next_snapshot); + sprintf(backing_file, "/tmp/xencow%s", fuse_file); + sprintf(state_file, "%s.state", backing_file); + + DPRINTF("fuse: %s; backing: %s; state: %s\n", fuse_file, backing_file, state_file); + + /* Create backing files */ + ret = xencow_create_file(backing_file); + if ( ret != 0 ) + return ret; + + ret = xencow_create_file(state_file); + if ( ret != 0 ) + return ret; + + /* Store file names */ + snapshot->xencowfs_file = malloc(strlen(fuse_file) + 1); + strncpy(snapshot->xencowfs_file, fuse_file, strlen(fuse_file) + 1); + + snapshot->backing_file = malloc(strlen(backing_file) + 1); + strncpy(snapshot->backing_file, backing_file, strlen(backing_file) + 1); + + snapshot->state_file = malloc(strlen(state_file) + 1); + strncpy(snapshot->state_file, state_file, strlen(state_file) + 1); + + return 0; +} + +static int xencow_init_snapshot(xencow_t *cow) +{ + xencow_snapshot_t *snapshot = malloc(sizeof(xencow_snapshot_t)); + int ret; + + memset(snapshot, 0, sizeof(xencow_snapshot_t)); + + ret = xencow_alloc_bitmap(&snapshot->bitmap, cow->p2m_size); + if ( ret != 0 ) + { + ERROR("Error allocating bitmap"); + return ret; + } + + ret = xencow_create_snapshot_files(cow, snapshot); + if ( ret != 0 ) + { + ERROR("Error creating backing files"); + return ret; + } + + list_add_tail(&snapshot->list, &cow->snapshots); + + return 0; +} + +static int xencow_take_snapshot(xencow_t *cow) +{ + struct timeval before; + struct timeval after; + double time_diff; + xencow_snapshot_t *snapshot; + int ret; + DECLARE_DOMCTL; + + domctl.cmd = XEN_DOMCTL_cow_snapshot; + domctl.domain = cow->domain_id; + + gettimeofday(&before, NULL); + + ret = do_domctl(cow->xc_handle, &domctl); + if ( ret != 0 ) + { + ERROR("Error taking snapshot"); + return ret; + } + + gettimeofday(&after, NULL); + + time_diff = difftime(after.tv_usec, before.tv_usec); + IPRINTF("Time spent paused: %fus\n", time_diff); + + ret = xencow_init_snapshot(cow); + if ( ret != 0 ) + { + ERROR("Error initialising snapshot"); + return ret; + } + + snapshot = list_bottom(&cow->snapshots, xencow_snapshot_t, list); + snapshot->when = domctl.u.cow_snapshot.when; + + cow->next_snapshot++; + + DPRINTF("when = %d\n", snapshot->when); + + return ret; +} + +void xencow_cleanup(xencow_t *cow) +{ + /* Disable CoW */ + xencow_disable(cow); + + /* Reset variables */ + cow->p2m_size = 0; + cow->num_mfns = 0; + cow->sring_mfn = 0; + + /* Close event channel */ + xc_evtchn_close(cow->xce_handle); + cow->xce_handle = -1; + + /* Close connection to Xen */ + xc_interface_close(cow->xc_handle); + cow->xc_handle = -1; + + /* Free memory */ + xencow_free(cow); +} + +int xencow_snapshot(xencow_t *cow) +{ + int ret = -1; + + cow_snapshots_lock(cow); + ret = xencow_take_snapshot(cow); + cow_snapshots_unlock(cow); + + if ( ret != 0 ) + { + ERROR("Error taking snapshot"); + return ret; + } + + return 0; +} + +int xencow_wait_for_event_or_timeout(xencow_t *cow, unsigned long ms) +{ + struct pollfd fd = { .fd = cow->xce_handle, .events = POLLIN | POLLERR }; + int port; + int rc; + + rc = poll(&fd, 1, ms); + if ( rc == -1 ) + { + if (errno == EINTR) + return 0; + ERROR("Poll exited with an error"); + return -2; + } + + if ( rc == 1 ) + { + port = xc_evtchn_pending(cow->xce_handle); + if ( port == -1 ) + { + ERROR("Failed to read port from event channel"); + return -2; + } + + rc = xc_evtchn_unmask(cow->xce_handle, port); + if ( rc == -1 ) + { + ERROR("Failed to unmask event channel port"); + return -2; + } + } + else + port = -1; + + return port; +} + +int xencow_wait_for_event(xencow_t *cow) +{ + return xencow_wait_for_event_or_timeout(cow, -1); +} + +int xencow_page_type(xencow_t *cow, unsigned long pfn, + unsigned long *count_info, unsigned long *type_info) +{ + unsigned long mfn; + int ret; + DECLARE_DOMCTL; + + mfn = xencow_p2m(cow, pfn); + + domctl.cmd = XEN_DOMCTL_cow_page_type; + domctl.domain = cow->domain_id; + domctl.u.cow_page_type.mfn = mfn; + + ret = do_domctl(cow->xc_handle, &domctl); + if ( ret != 0 ) + { + *count_info = domctl.u.cow_page_type.count_info; + *type_info = domctl.u.cow_page_type.type_info; + } + + return ret; +} + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a tools/xencow/lib/xencow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/lib/xencow.h Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,284 @@ +/****************************************************************************** + * tools/xencow/lib/xencow.h + * + * VM memory Copy-on-Write library. + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef __XEN_COW_H__ +#define __XEN_COW_H__ + + +#include <inttypes.h> +#include <xen/xen.h> +#include <xen/io/cow.h> +#include <xen/event_channel.h> +#include <xen/domctl.h> +#include <xenctrl.h> +#include <xc_private.h> +#include "xencow_list.h" + + +#define STATE_MFN ((unsigned long)(-1)) + +#define state_pfn(_pfn) ((_pfn) == STATE_MFN) + +#define BUFFER_SIZE \ + ((((PAGE_SIZE >> 1) / sizeof(unsigned long)) + XEN_COW_RING_PAGES) \ + << PAGE_SHIFT) + + +#define offset_pfn(_offset) ((_offset) >> PAGE_SHIFT) + +#define pfn_offset(_pfn) (((off_t)(_pfn)) << PAGE_SHIFT) + + +#define BITS_PER_LONG (sizeof(unsigned long) * 8) + +/* XXX: stolen from xen/asm/bitops.h */ +/* XXX: should these be in here? are they required to work externally? */ +#ifdef CONFIG_SMP +#define LOCK_PREFIX "lock ; " +#else +#define LOCK_PREFIX "" +#endif + +#define ADDR (*(volatile long *) addr) +#define CONST_ADDR (*(const volatile long *) addr) + +/** + * clear_bit - Clears a bit in memory + * @nr: Bit to clear + * @addr: Address to start counting from + * + * clear_bit() is atomic and may not be reordered. However, it does + * not contain a memory barrier, so if it is used for locking purposes, + * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit() + * in order to ensure changes are visible on other processors. + */ +static inline void clear_bit(int nr, volatile void *addr) +{ + asm volatile ( + LOCK_PREFIX + "btrl %1,%0" + : "=m" (ADDR) + : "Ir" (nr), "m" (ADDR) : "memory"); +} + +/** + * test_and_set_bit - Set a bit and return its old value + * @nr: Bit to set + * @addr: Address to count from + * + * This operation is atomic and cannot be reordered. + * It also implies a memory barrier. + */ +static inline int test_and_set_bit(int nr, volatile void *addr) +{ + int oldbit; + + asm volatile ( + LOCK_PREFIX + "btsl %2,%1\n\tsbbl %0,%0" + : "=r" (oldbit), "=m" (ADDR) + : "Ir" (nr), "m" (ADDR) : "memory"); + return oldbit; +} + +static inline int test_bit(int nr, const volatile void *addr) +{ + int oldbit; + + asm volatile ( + "btl %2,%1\n\tsbbl %0,%0" + : "=r" (oldbit) + : "m" (CONST_ADDR), "Ir" (nr) : "memory" ); + return oldbit; +} + +static inline int testandset (int *p) +{ + long int readval = 0; + + __asm__ __volatile__ ("lock; cmpxchgl %2, %0" + : "+m" (*p), "+a" (readval) + : "r" (1) + : "cc"); + return readval; +} + + +/* Spin lock */ +typedef int spinlock_t; + +#define SPIN_LOCK_UNLOCKED 0 + +static inline void spin_lock(spinlock_t *lock) +{ +// while ( test_and_set_bit(1, lock) ); + while ( testandset(lock) ); +} + +static inline void spin_lock_init(spinlock_t *lock) +{ + *lock = SPIN_LOCK_UNLOCKED; +} + +static inline void spin_unlock(spinlock_t *lock) +{ + *lock = SPIN_LOCK_UNLOCKED; +} + +static inline int spin_trylock(spinlock_t *lock) +{ + return !testandset(lock); +} + +/* CoW ring lock */ +#define cow_ring_lock_init(_c) spin_lock_init(&(_c)->ring_lock) +#define cow_ring_lock(_c) spin_lock(&(_c)->ring_lock) +#define cow_ring_unlock(_c) spin_unlock(&(_c)->ring_lock) + +/* CoW snapshots list */ +#define cow_snapshots_lock_init(_c) spin_lock_init(&(_c)->snapshots_lock) +#define cow_snapshots_lock(_c) spin_lock(&(_c)->snapshots_lock) +#define cow_snapshots_unlock(_c) spin_unlock(&(_c)->snapshots_lock) + + +typedef struct xencow_snapshot_st { + struct list_head list; + + /* bitmap of PFNs that have been saved */ + unsigned long *bitmap; + + /* when the snapshot was taken */ + RING_IDX when; + + /* files for snapshot image */ + char *xencowfs_file; + char *state_file; + char *backing_file; +} xencow_snapshot_t; + +typedef struct platform_info_st { + unsigned long max_mfn; + unsigned long hvirt_start; + unsigned int pt_levels; + unsigned int guest_width; +} platform_info_t; + +typedef struct xencow_st { + domid_t domain_id; + int is_hvm; + unsigned long p2m_size; + unsigned long *live_p2m_table; + + int xc_handle; + int xce_handle; + + evtchn_port_t buffer_port; + evtchn_port_t pause_port; + + platform_info_t platform_info; + + size_t buffer_size; + void *buffer; + + int num_mfns; + unsigned long *mfns; + + unsigned long sring_mfn; + cow_front_ring_t front_ring; + + spinlock_t ring_lock; + + void *page_buffer; + + struct list_head snapshots; + unsigned int next_snapshot; + + spinlock_t snapshots_lock; +} xencow_t; + + +xen_pfn_t *xc_map_m2p(int xc_handle, unsigned long max_mfn, int prot, + unsigned long *m2p_mfn0); + +int xc_canonicalise_pagetable(unsigned long type, unsigned long pfn, + const void *spage, void *dpage, + xen_pfn_t *live_p2m_table, + xen_pfn_t *live_m2p_table, unsigned long m2p_mfn0, + unsigned long p2m_size, unsigned long max_mfn, + unsigned long hvirt_start, unsigned int pt_levels, + unsigned int guest_width); + +xen_pfn_t *xc_get_live_p2m_table(int xc_handle, domid_t domain_id, + unsigned long p2m_size, + unsigned int guest_width); + + +/* Initialise CoW for a domain */ +xencow_t *xencow_init(domid_t domid); + +/* Enable CoW */ +int xencow_enable(xencow_t *cow); + +/* Disable CoW */ +int xencow_disable(xencow_t *cow); + +/* Take a snapshot */ +int xencow_snapshot(xencow_t *cow); + +/* Resume a domain paused because of CoW */ +int xencow_resume(xencow_t *cow); + +/* Get the MFN for a PFN */ +unsigned long xencow_p2m(xencow_t *cow, unsigned long pfn); + +/* Cleanup a CoW struct */ +void xencow_cleanup(xencow_t *cow); + +/* Wait for an event */ +int xencow_wait_for_event(xencow_t *cow); +int xencow_wait_for_event_or_timeout(xencow_t *cow, unsigned long ms); + +/* Flush the pre-dirtied page buffer */ +void xencow_flush_buffer(xencow_t *cow); + +/* Read pages from the pre-dirtied buffer */ +int xencow_read_buffer(xencow_t *cow, int snapshot_num, unsigned long start_pfn, + int num_pages, void *buffer); + +/* Get info for a page */ +int xencow_page_type(xencow_t *cow, unsigned long pfn, + unsigned long *count_info, unsigned long *type_info); + + +#endif /* __XEN_COW_H__ */ + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a tools/xencow/lib/xencow_list.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/lib/xencow_list.h Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,555 @@ +/****************************************************************************** + * tools/xencow/lib/xencow_list.h + * + * Linked list. + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef __XEN_COW_LIST_H__ +#define __XEN_COW_LIST_H__ + + +/* Taken from Linux kernel code, but de-kernelized for userspace. */ +#include <stddef.h> + +#undef LIST_HEAD_INIT +#undef LIST_HEAD +#undef INIT_LIST_HEAD + +/* + * These are non-NULL pointers that will result in page faults + * under normal circumstances, used to verify that nobody uses + * non-initialized list entries. + */ +#define LIST_POISON1 ((void *) 0x00100100) +#define LIST_POISON2 ((void *) 0x00200200) + +#define container_of(ptr, type, member) ({ \ + typeof( ((type *)0)->member ) *__mptr = (ptr); \ + (type *)( (char *)__mptr - offsetof(type,member) );}) + +/* + * Simple doubly linked list implementation. + * + * Some of the internal functions ("__xxx") are useful when + * manipulating whole lists rather than single entries, as + * sometimes we already know the next/prev entries and we can + * generate better code by using them directly rather than + * using the generic single-entry routines. + */ + +struct list_head { + struct list_head *next, *prev; +}; + +#define LIST_HEAD_INIT(name) { &(name), &(name) } + +#define LIST_HEAD(name) \ + struct list_head name = LIST_HEAD_INIT(name) + +#define INIT_LIST_HEAD(ptr) do { \ + (ptr)->next = (ptr); (ptr)->prev = (ptr); \ +} while (0) + +#define list_top(head, type, member) \ +({ \ + struct list_head *_head = (head); \ + list_empty(_head) ? NULL : list_entry(_head->next, type, member); \ +}) + +#define list_bottom(head, type, member) \ +({ \ + struct list_head *_head = (head); \ + list_empty(_head) ? NULL : list_entry(_head->prev, type, member); \ +}) + +/* + * Insert a new entry between two known consecutive entries. + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static inline void __list_add(struct list_head *new, + struct list_head *prev, + struct list_head *next) +{ + next->prev = new; + new->next = next; + new->prev = prev; + prev->next = new; +} + +/** + * list_add - add a new entry + * @new: new entry to be added + * @head: list head to add it after + * + * Insert a new entry after the specified head. + * This is good for implementing stacks. + */ +static inline void list_add(struct list_head *new, struct list_head *head) +{ + __list_add(new, head, head->next); +} + +/** + * list_add_tail - add a new entry + * @new: new entry to be added + * @head: list head to add it before + * + * Insert a new entry before the specified head. + * This is useful for implementing queues. + */ +static inline void list_add_tail(struct list_head *new, struct list_head *head) +{ + __list_add(new, head->prev, head); +} + +/* + * Insert a new entry between two known consecutive entries. + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static __inline__ void __list_add_rcu(struct list_head * new, + struct list_head * prev, + struct list_head * next) +{ + new->next = next; + new->prev = prev; + next->prev = new; + prev->next = new; +} + +/** + * list_add_rcu - add a new entry to rcu-protected list + * @new: new entry to be added + * @head: list head to add it after + * + * Insert a new entry after the specified head. + * This is good for implementing stacks. + */ +static __inline__ void list_add_rcu(struct list_head *new, struct list_head *head) +{ + __list_add_rcu(new, head, head->next); +} + +/** + * list_add_tail_rcu - add a new entry to rcu-protected list + * @new: new entry to be added + * @head: list head to add it before + * + * Insert a new entry before the specified head. + * This is useful for implementing queues. + */ +static __inline__ void list_add_tail_rcu(struct list_head *new, struct list_head *head) +{ + __list_add_rcu(new, head->prev, head); +} + +/* + * Delete a list entry by making the prev/next entries + * point to each other. + * + * This is only for internal list manipulation where we know + * the prev/next entries already! + */ +static inline void __list_del(struct list_head * prev, struct list_head * next) +{ + next->prev = prev; + prev->next = next; +} + +/** + * list_del - deletes entry from list. + * @entry: the element to delete from the list. + * Note: list_empty on entry does not return true after this, the entry is + * in an undefined state. + */ +static inline void list_del(struct list_head *entry) +{ + __list_del(entry->prev, entry->next); + entry->next = LIST_POISON1; + entry->prev = LIST_POISON2; +} + +/** + * list_del_rcu - deletes entry from list without re-initialization + * @entry: the element to delete from the list. + * + * Note: list_empty on entry does not return true after this, + * the entry is in an undefined state. It is useful for RCU based + * lockfree traversal. + * + * In particular, it means that we can not poison the forward + * pointers that may still be used for walking the list. + */ +static inline void list_del_rcu(struct list_head *entry) +{ + __list_del(entry->prev, entry->next); + entry->prev = LIST_POISON2; +} + +/** + * list_del_init - deletes entry from list and reinitialize it. + * @entry: the element to delete from the list. + */ +static inline void list_del_init(struct list_head *entry) +{ + __list_del(entry->prev, entry->next); + INIT_LIST_HEAD(entry); +} + +/** + * list_move - delete from one list and add as another's head + * @list: the entry to move + * @head: the head that will precede our entry + */ +static inline void list_move(struct list_head *list, struct list_head *head) +{ + __list_del(list->prev, list->next); + list_add(list, head); +} + +/** + * list_move_tail - delete from one list and add as another's tail + * @list: the entry to move + * @head: the head that will follow our entry + */ +static inline void list_move_tail(struct list_head *list, + struct list_head *head) +{ + __list_del(list->prev, list->next); + list_add_tail(list, head); +} + +/** + * list_empty - tests whether a list is empty + * @head: the list to test. + */ +static inline int list_empty(struct list_head *head) +{ + return head->next == head; +} + +static inline void __list_splice(struct list_head *list, + struct list_head *head) +{ + struct list_head *first = list->next; + struct list_head *last = list->prev; + struct list_head *at = head->next; + + first->prev = head; + head->next = first; + + last->next = at; + at->prev = last; +} + +/** + * list_splice - join two lists + * @list: the new list to add. + * @head: the place to add it in the first list. + */ +static inline void list_splice(struct list_head *list, struct list_head *head) +{ + if (!list_empty(list)) + __list_splice(list, head); +} + +/** + * list_splice_init - join two lists and reinitialise the emptied list. + * @list: the new list to add. + * @head: the place to add it in the first list. + * + * The list at @list is reinitialised + */ +static inline void list_splice_init(struct list_head *list, + struct list_head *head) +{ + if (!list_empty(list)) { + __list_splice(list, head); + INIT_LIST_HEAD(list); + } +} + +/** + * list_entry - get the struct for this entry + * @ptr: the &struct list_head pointer. + * @type: the type of the struct this is embedded in. + * @member: the name of the list_struct within the struct. + */ +#define list_entry(ptr, type, member) \ + container_of(ptr, type, member) + +/** + * list_for_each - iterate over a list + * @pos: the &struct list_head to use as a loop counter. + * @head: the head for your list. + */ +#define list_for_each(pos, head) \ + for (pos = (head)->next; pos != (head); pos = pos->next) + +/** + * list_for_each_prev - iterate over a list backwards + * @pos: the &struct list_head to use as a loop counter. + * @head: the head for your list. + */ +#define list_for_each_prev(pos, head) \ + for (pos = (head)->prev; pos != (head); pos = pos->prev) + +/** + * list_for_each_safe - iterate over a list safe against removal of list entry + * @pos: the &struct list_head to use as a loop counter. + * @n: another &struct list_head to use as temporary storage + * @head: the head for your list. + */ +#define list_for_each_safe(pos, n, head) \ + for (pos = (head)->next, n = pos->next; pos != (head); \ + pos = n, n = pos->next) + +/** + * list_for_each_entry - iterate over list of given type + * @pos: the type * to use as a loop counter. + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry(pos, head, member) \ + for (pos = list_entry((head)->next, typeof(*pos), member); \ + &pos->member != (head); \ + pos = list_entry(pos->member.next, typeof(*pos), member)) + +/** + * list_for_each_entry_reverse - iterate backwards over list of given type. + * @pos: the type * to use as a loop counter. + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry_reverse(pos, head, member) \ + for (pos = list_entry((head)->prev, typeof(*pos), member); \ + &pos->member != (head); \ + pos = list_entry(pos->member.prev, typeof(*pos), member)) + + +/** + * list_for_each_entry_continue - iterate over list of given type + * continuing after existing point + * @pos: the type * to use as a loop counter. + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry_continue(pos, head, member) \ + for (pos = list_entry(pos->member.next, typeof(*pos), member); \ + &pos->member != (head); \ + pos = list_entry(pos->member.next, typeof(*pos), member)) + +/** + * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry + * @pos: the type * to use as a loop counter. + * @n: another type * to use as temporary storage + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry_safe(pos, n, head, member) \ + for (pos = list_entry((head)->next, typeof(*pos), member), \ + n = list_entry(pos->member.next, typeof(*pos), member); \ + &pos->member != (head); \ + pos = n, n = list_entry(n->member.next, typeof(*n), member)) + + +/* + * Double linked lists with a single pointer list head. + * Mostly useful for hash tables where the two pointer list head is + * too wasteful. + * You lose the ability to access the tail in O(1). + */ + +struct hlist_head { + struct hlist_node *first; +}; + +struct hlist_node { + struct hlist_node *next, **pprev; +}; + +#define HLIST_HEAD_INIT { .first = NULL } +#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL } +#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) +#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL) + +static __inline__ int hlist_unhashed(struct hlist_node *h) +{ + return !h->pprev; +} + +static __inline__ int hlist_empty(struct hlist_head *h) +{ + return !h->first; +} + +static __inline__ void __hlist_del(struct hlist_node *n) +{ + struct hlist_node *next = n->next; + struct hlist_node **pprev = n->pprev; + *pprev = next; + if (next) + next->pprev = pprev; +} + +static __inline__ void hlist_del(struct hlist_node *n) +{ + __hlist_del(n); + n->next = LIST_POISON1; + n->pprev = LIST_POISON2; +} + +/** + * hlist_del_rcu - deletes entry from hash list without re-initialization + * @entry: the element to delete from the hash list. + * + * Note: list_unhashed() on entry does not return true after this, + * the entry is in an undefined state. It is useful for RCU based + * lockfree traversal. + * + * In particular, it means that we can not poison the forward + * pointers that may still be used for walking the hash list. + */ +static inline void hlist_del_rcu(struct hlist_node *n) +{ + __hlist_del(n); + n->pprev = LIST_POISON2; +} + +static __inline__ void hlist_del_init(struct hlist_node *n) +{ + if (n->pprev) { + __hlist_del(n); + INIT_HLIST_NODE(n); + } +} + +#define hlist_del_rcu_init hlist_del_init + +static __inline__ void hlist_add_head(struct hlist_node *n, struct hlist_head *h) +{ + struct hlist_node *first = h->first; + n->next = first; + if (first) + first->pprev = &n->next; + h->first = n; + n->pprev = &h->first; +} + +static __inline__ void hlist_add_head_rcu(struct hlist_node *n, struct hlist_head *h) +{ + struct hlist_node *first = h->first; + n->next = first; + n->pprev = &h->first; + if (first) + first->pprev = &n->next; + h->first = n; +} + +/* next must be != NULL */ +static __inline__ void hlist_add_before(struct hlist_node *n, struct hlist_node *next) +{ + n->pprev = next->pprev; + n->next = next; + next->pprev = &n->next; + *(n->pprev) = n; +} + +static __inline__ void hlist_add_after(struct hlist_node *n, + struct hlist_node *next) +{ + next->next = n->next; + *(next->pprev) = n; + n->next = next; +} + +#define hlist_entry(ptr, type, member) container_of(ptr,type,member) + +/* Cannot easily do prefetch unfortunately */ +#define hlist_for_each(pos, head) \ + for (pos = (head)->first; pos; pos = pos->next) + +#define hlist_for_each_safe(pos, n, head) \ + for (pos = (head)->first; n = pos ? pos->next : 0, pos; \ + pos = n) + +/** + * hlist_for_each_entry - iterate over list of given type + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry(tpos, pos, head, member) \ + for (pos = (head)->first; \ + pos && ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + pos = pos->next) + +/** + * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry_continue(tpos, pos, member) \ + for (pos = (pos)->next; \ + pos && ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + pos = pos->next) + +/** + * hlist_for_each_entry_from - iterate over a hlist continuing from existing point + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry_from(tpos, pos, member) \ + for (; pos && ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + pos = pos->next) + +/** + * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @n: another &struct hlist_node to use as temporary storage + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \ + for (pos = (head)->first; \ + pos && ({ n = pos->next; 1; }) && \ + ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + pos = n) + + +#endif /* __XEN_COW_LIST_H__ */ + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a tools/xencow/test/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/test/Makefile Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,32 @@ +XEN_ROOT=../../.. +include $(XEN_ROOT)/tools/Rules.mk + +CFLAGS += -I $(XEN_XC) +CFLAGS += $(CFLAGS_libxenctrl) + +SRCS += cow_compare.c + +CFLAGS += -Werror +CFLAGS += -g +CFLAGS += -Wl,-rpath,.. + +LDFLAGS += $(LDFLAGS_libxenctrl) -lxencow + +OBJS = $(SRCS:.c=.o) +IBINS = cow_compare + +all: $(IBINS) + +cow_compare: $(OBJS) + $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) + +install: all + $(INSTALL_DIR) $(DESTDIR)$(SBINDIR) + $(INSTALL_PROG) $(IBINS) $(DESTDIR)$(SBINDIR) + +clean: + rm -f *.o *~ $(DEPS) xen TAGS $(IBINS) $(LIB) + +.PHONY: clean install + +-include $(DEPS) diff -r 0477f9061c8a tools/xencow/test/cow_compare.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/test/cow_compare.c Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,896 @@ +/****************************************************************************** + * tools/xencow/test/cow_compare.c + * + * Test application to compare CoW iamge and live memory dumps + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include <sys/types.h> +#include <unistd.h> + +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> + +#include <string.h> +#include <errno.h> +#include <sys/mman.h> + +#if 0 +#include <xen/xen.h> +#include <xc_private.h> +#endif +#include <xg_private.h> +#include <xg_save_restore.h> +#include <xenctrl.h> + +#include "../lib/xc.h" +#include "../lib/xencow.h" + + +#define COW 1 + +#if COW +#define COW_FILE1 "vm_dump.cow1" +#define COW_FILE2 "vm_dump.cow2" +#endif +#define LIVE_FILE1 "vm_dump.live1" +#define LIVE_FILE2 "vm_dump.live2" + + +#define SLEEP_TIME (10 * 1) /* 1 min */ + + +/* Printing functions */ +#if 1 +#define pr_debug(_f, _a...) \ + printf("%s(): " _f, __func__, ##_a) +#else +#define pr_debug(_f, _a...) ((void)0) +#endif + +#define warning(_f, _a...) \ + fprintf(stderr, "%s(): " _f, __func__, ##_a) + + +static int debug_mode = 0; + +#if 0 +typedef struct page_info_st { + unsigned long count_info; + unsigned long type_info; +} page_info_t; + +page_info_t get_page_type_info(int xc_handle, domid_t domain_id, xen_pfn_t mfn) +{ + page_info_t page_info; + int rc; + DECLARE_DOMCTL; + + domctl.cmd = XEN_DOMCTL_cow_page_type; + domctl.domain = domain_id; + domctl.u.cow_page_type.mfn = mfn; + + rc = do_domctl(xc_handle, &domctl); + if ( rc != 0 ) + { + printf("error getting page type for %lx\n", mfn); + page_info.count_info = 0; + page_info.type_info = 0; + return page_info; + } + + page_info.count_info = domctl.u.cow_page_type.count_info; + page_info.type_info = domctl.u.cow_page_type.type_info; + + return page_info; +} +#endif + +int compare_pages(void *page1, void *page2, uint32_t page_size) +{ + uint32_t i; + int rc = 0; + + for ( i = 0; i < page_size; i++ ) + { + if ( ((char *)page1)[i] != ((char *)page2)[i] ) + { + rc--; +#if VERBOSE + printf("images do not match at offset %x (%u): ", i, i); + printf("(%x) (%x)\n", ((char *)page1)[i], ((char *)page2)[i]); +#endif + } + } + + return rc; +} + +int compare(char *file1, char *file2, int xc_handle, domid_t domain_id, + xen_pfn_t *live_p2m_table, xen_pfn_t *live_m2p_table, + unsigned long m2p_mfn0, + unsigned long p2m_size, unsigned long max_mfn, + unsigned long hvirt_start, unsigned int pt_levels, + unsigned int guest_width) +{ + int open_flags = O_RDONLY; + mode_t open_mode = S_IRUSR | S_IRGRP | S_IROTH; + int fd1; + int fd2; + void *page1 = malloc(PAGE_SIZE); + void *page2 = malloc(PAGE_SIZE); + unsigned long pfn; + int hvm = 0; + int rc; + int ret = 0; + + if ( !live_p2m_table ) + hvm = 1; + + /* Open image files */ + fd1 = open(file1, open_flags, open_mode); + if ( fd1 < 0 ) + { + perror("failed to open file1"); + return -1; + } + + fd2 = open(file2, open_flags, open_mode); + if ( fd2 < 0 ) + { + perror("failed to open file2"); + return -1; + } + + /* Read images */ + pfn = 0; + while ( pfn < p2m_size ) + { + /* Read pages */ + off64_t offset = pfn_offset(pfn); + off64_t ret_seek; + int total_read; + + ret_seek = lseek64(fd1, offset, SEEK_SET); +#if 0 + if ( ret_fd1 < 0 ) + { + perror("failed to seek file1"); + return -1; + } +#endif + + ret_seek = lseek64(fd2, offset, SEEK_SET); +#if 0 + if ( ret_fd2 < 0 ) + { + perror("failed to seek file2"); + return -1; + } +#endif + + total_read = 0; + while ( total_read < PAGE_SIZE ) + { + void *p = page1 + total_read; + int bytes_read = read(fd1, p, PAGE_SIZE - total_read); + if ( bytes_read <= 0 ) + { + perror("failed to read from file1"); + return -1; + } + total_read += bytes_read; + } + + total_read = 0; + while ( total_read < PAGE_SIZE ) + { + void *p = page2 + total_read; + int bytes_read = read(fd2, p, PAGE_SIZE - total_read); + if ( bytes_read <= 0 ) + { + perror("failed to read from file2"); + return -1; + } + total_read += bytes_read; + } + + rc = compare_pages(page1, page2, PAGE_SIZE); + + /* Check if the pages are different */ + if ( rc != 0 ) + { + xen_pfn_t mfn; + int check_frame = 0; + int nonhypervisor_bytes = 0; + + /* Get MFN */ + if ( hvm ) + mfn = pfn; + else + mfn = pfn_to_mfn(pfn); + +#if 1 + if ( is_mapped(mfn) ) + { +#endif + if ( hvm ) + { + if ( (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) != XEN_DOMCTL_PFINFO_XTAB ) + check_frame = 1; + } + else + { + ((uint32_t *)(&mfn))[0] = mfn; + mfn = (uint32_t)mfn; + + if ( (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) != XEN_DOMCTL_PFINFO_XTAB ) + { + /* Canonicalise mfn -> pfn */ + mfn = (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) | pfn; + check_frame = 1; + } + } + + if ( check_frame ) + { + unsigned long addr; + unsigned long type; + + addr = mfn & ~XEN_DOMCTL_PFINFO_LTAB_MASK; + type = mfn & XEN_DOMCTL_PFINFO_LTAB_MASK; + + /* Check if the page is present */ + if ( type != XEN_DOMCTL_PFINFO_XTAB ) + { + type &= XEN_DOMCTL_PFINFO_LTABTYPE_MASK; + + if ( (type >= XEN_DOMCTL_PFINFO_L1TAB) && + (type <= XEN_DOMCTL_PFINFO_L4TAB) ) + { + int pte_last; + int xen_start; + int xen_end; + int i; + + printf("page table page: %lx\n", pfn); + + /* + * We need to determine which entries in this page table hold + * reserved hypervisor mappings. This depends on the current + * page table type as well as the number of paging levels. + */ + xen_start = xen_end = pte_last = PAGE_SIZE / ((pt_levels == 2) ? 4 : 8); + + if ( (pt_levels == 2) && (type == XEN_DOMCTL_PFINFO_L2TAB) ) + xen_start = (hvirt_start >> L2_PAGETABLE_SHIFT); + + if ( (pt_levels == 3) && (type == XEN_DOMCTL_PFINFO_L3TAB) ) + xen_start = L3_PAGETABLE_ENTRIES_PAE; + + /* + * In PAE only the L2 mapping the top 1GB contains Xen mappings. + * We can spot this by looking for the guest's mapping of the m2p. + * Guests must ensure that this check will fail for other L2s. + */ + if ( (pt_levels == 3) && (type == XEN_DOMCTL_PFINFO_L2TAB) ) + { + int hstart; + uint64_t he; + + hstart = (hvirt_start >> L2_PAGETABLE_SHIFT_PAE) & 0x1ff; + he = ((const uint64_t *)page1)[hstart]; + + if ( ((he >> PAGE_SHIFT) & MFN_MASK_X86) == m2p_mfn0 ) + { + /* hvirt starts with xen stuff... */ + xen_start = hstart; + } + else if ( hvirt_start != 0xf5800000 ) + { + /* old L2s from before hole was shrunk... */ + hstart = (0xf5800000 >> L2_PAGETABLE_SHIFT_PAE) & 0x1ff; + he = ((const uint64_t *)page1)[hstart]; + if ( ((he >> PAGE_SHIFT) & MFN_MASK_X86) == m2p_mfn0 ) + xen_start = hstart; + } + } + + if ( (pt_levels == 4) && (type == XEN_DOMCTL_PFINFO_L4TAB) ) + { + /* + * XXX SMH: should compute these from hvirt_start (which we have) + * and hvirt_end (which we don't) + */ + xen_start = 256; + xen_end = 272; + } + + /* + * Scan for changed bytes that aren't reserved by + * the hypervisor + */ + for ( i = 0; i < pte_last; i++ ) + if ( ((char *)page1)[i] != ((char *)page2)[i] ) + if ( !((i >= xen_start) && (i < xen_end)) ) + nonhypervisor_bytes++; + } + + switch (type) + { + + case XEN_DOMCTL_PFINFO_NOTAB: + { + printf(" normal page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + case XEN_DOMCTL_PFINFO_L1TAB: + { + printf(" l1 table page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + case XEN_DOMCTL_PFINFO_L2TAB: + { + printf(" l2 table page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + case XEN_DOMCTL_PFINFO_L3TAB: + { + printf(" l3 table page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + case XEN_DOMCTL_PFINFO_L4TAB: + { + printf(" l4 table page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + case XEN_DOMCTL_PFINFO_LPINTAB: + { + printf(" pin page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + case XEN_DOMCTL_PFINFO_XTAB: + { + printf(" invalid page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + break; + + default: + printf(" unknown page: %lx: %d %d\n", pfn, -rc, nonhypervisor_bytes); + } + + } + } +#if 1 + } +#endif + + if ( debug_mode ) + printf("images do not match at page %lx (%lx): %d (%d) bytes different\n", + pfn, mfn, -rc, nonhypervisor_bytes); + + if ( nonhypervisor_bytes + rc != 0) + ret--; + } + + /* Move to next page */ + pfn++; + } + + close(fd1); + close(fd2); + + return ret; +} + +int dump_memory(char *filename, int xc_handle, domid_t domain_id, + xen_pfn_t *live_p2m_table, xen_pfn_t *live_m2p_table, + unsigned long m2p_mfn0, + unsigned long p2m_size, unsigned long max_mfn, + unsigned long hvirt_start, unsigned int pt_levels, + unsigned int guest_width) +{ + int open_flags = O_CREAT | O_TRUNC | O_RDWR; + mode_t open_mode = S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH; + int fd; + unsigned long pfn; + void *page; + int hvm = 0; +#if 1 + int rc; +#endif + + if ( !live_p2m_table ) + hvm = 1; + + /* Open file */ + fd = open(filename, open_flags, open_mode); + if ( fd < 0 ) + { + perror("failed to open file"); + return -1; + } + + /* Write out memory contents */ + pfn = 0; + while ( pfn < p2m_size ) + { + size_t bytes_written; + xen_pfn_t mfn; + int copy_frame = 0; + int pt_page = 0; + + page = NULL; + + if ( hvm ) + mfn = pfn; + else + mfn = pfn_to_mfn(pfn); + + /* Read page */ + if ( is_mapped(mfn) ) + { + if ( hvm ) + { + if ( (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) != XEN_DOMCTL_PFINFO_XTAB ) + { + page = xc_map_foreign_batch(xc_handle, domain_id, PROT_READ, &mfn, 1); + copy_frame = 1; + } + } + else + { + page = xc_map_foreign_range(xc_handle, domain_id, PAGE_SIZE, PROT_READ, mfn); + + ((uint32_t *)(&mfn))[0] = mfn; + + rc = xc_get_pfn_type_batch(xc_handle, domain_id, 1, (uint32_t *)(&mfn)); + if ( rc ) + { + ERROR("get_pfn_type_batch failed"); + goto out; + } + mfn = (uint32_t)mfn; + + if ( (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) != XEN_DOMCTL_PFINFO_XTAB ) + { + /* Canonicalise mfn -> pfn */ + mfn = (mfn & XEN_DOMCTL_PFINFO_LTAB_MASK) | pfn; + copy_frame = 1; + } + else + { + munmap(page, PAGE_SIZE); + page = NULL; + } + } + +#if 0 + if ( copy_frame ) + { + unsigned long addr; + unsigned long type; + + addr = mfn & ~XEN_DOMCTL_PFINFO_LTAB_MASK; + type = mfn & XEN_DOMCTL_PFINFO_LTAB_MASK; + + /* Check if the page is present */ + if ( type != XEN_DOMCTL_PFINFO_XTAB ) + { + type &= XEN_DOMCTL_PFINFO_LTABTYPE_MASK; + + if ( (type >= XEN_DOMCTL_PFINFO_L1TAB) && + (type <= XEN_DOMCTL_PFINFO_L4TAB) ) + { + int race; + void *dpage = malloc(PAGE_SIZE); + + race = xc_canonicalise_pagetable(type, addr, page, dpage, + live_p2m_table, + live_m2p_table, + m2p_mfn0, + p2m_size, max_mfn, + hvirt_start, pt_levels, + guest_width); + + munmap(page, PAGE_SIZE); + page = dpage; + pt_page = 1; + } + } + else + { + munmap(page, PAGE_SIZE); + copy_frame = 0; + } + } +#endif + if ( copy_frame ) + { + off64_t seek_ret; + int total_written = 0; + + seek_ret = lseek64(fd, pfn_offset(pfn), SEEK_SET); + + while ( total_written < PAGE_SIZE ) + { + void *p = page + total_written; + bytes_written = write(fd, p, PAGE_SIZE - total_written); + + if ( bytes_written <= 0 ) + { + perror("failed to write to file"); + return -1; + } + + total_written += bytes_written; + } + + /* Free or unmap page if needed */ + if ( pt_page ) + free(page); + else + munmap(page, PAGE_SIZE); + } + } + + pfn++; + } + +#if 1 + out: +#endif + close(fd); + + return 0; +} + +#if COW +int dump_cow(char *filename, unsigned long p2m_size, char *cow_file) +{ + int open_flags = O_CREAT | O_TRUNC | O_RDWR; + mode_t open_mode = S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH; + int fd_cow; + int fd_dump; + unsigned long pfn; + void *page = malloc(PAGE_SIZE); + + /* Open files */ + fd_cow = open(cow_file, O_RDONLY, open_mode); + if ( fd_cow < 0 ) + { + perror("failed to open cow file"); + return -1; + } + + fd_dump = open(filename, open_flags, open_mode); + if ( fd_dump < 0 ) + { + perror("failed to open dump file"); + return -1; + } + + /* Write out memory contents */ + pfn = 0; + while ( pfn < p2m_size ) + { + off64_t seek_ret; + int total_read; + int total_written; + + /* Read page */ + seek_ret = lseek64(fd_cow, pfn_offset(pfn), SEEK_SET); +#if 0 + if ( ret < 0 ) + { + perror("failed to seek cow file"); + return -1; + } +#endif + + total_read = 0; + while ( total_read < PAGE_SIZE ) + { + void *p = page + total_read; + int bytes_read = read(fd_cow, p, PAGE_SIZE - total_read); + if ( bytes_read <= 0 ) + { + perror("failed to read cow file"); + return -1; + } + + total_read += bytes_read; + } + + /* Write memory contents to file */ + seek_ret = lseek64(fd_dump, pfn_offset(pfn), SEEK_SET); +#if 0 + if ( ret < 0 ) + { + perror("failed to seek cow file"); + return -1; + } +#endif + + total_written = 0; + while ( total_written < PAGE_SIZE ) + { + void *p = page + total_written; + int bytes_written = write(fd_dump, p, PAGE_SIZE - total_written); + if ( bytes_written <= 0 ) + { + perror("failed to write dump file"); + return -1; + } + + total_written += bytes_written; + } + + pfn++; + } + + close(fd_dump); + close(fd_cow); + + return 0; +} +#endif + +int main(int argc, char *argv[]) +{ + xc_dominfo_t info; + domid_t domain_id; + int snapshot_num; + int xc_handle; + xen_pfn_t *live_m2p_table; + xen_pfn_t *live_p2m_table; + unsigned long m2p_mfn0; + unsigned long p2m_size; + unsigned long max_mfn; + unsigned long hvirt_start; + unsigned int pt_levels; + unsigned int guest_width; +#if 1 +#if COW + char fuse_file[200]; +#endif +#endif + int rc; + + domain_id = atoi(argv[1]); + /* TODO: find this automatically */ + snapshot_num = atoi(argv[2]); + + if ( argc > 3 ) + { + if ( strcmp(argv[3], "-d") == 0 ) + debug_mode = 1; + } + + /* Open connection to Xen */ + rc = xc_interface_open(); + if ( rc < 0 ) + { + warning("failed to connect to Xen\n"); + goto out; + } + xc_handle = rc; + + /* Get some info */ + p2m_size = xc_memory_op(xc_handle, XENMEM_maximum_gpfn, &domain_id) + 1; + + rc = get_platform_info(xc_handle, domain_id, &max_mfn, &hvirt_start, + &pt_levels, &guest_width); + if ( rc != 1 ) + { + warning("failed to get platform info\n"); + goto out; + } + + /* Get HVM info */ + rc = xc_domain_getinfo(xc_handle, domain_id, 1, &info); + if ( rc != 1 ) + { + warning("failed to get domain info\n"); + goto out; + } + + /* Print info */ + if ( debug_mode ) + { + printf("p2m_size: %lu\n", p2m_size); + printf("max_mfn: %lx (%lu)\n", max_mfn, max_mfn); + printf("hvirt_start: %lx (%lu)\n", hvirt_start, hvirt_start); + printf("pt_levels: %x (%u)\n", pt_levels, pt_levels); + printf("guest_width: %x (%u)\n", guest_width, guest_width); + printf("shared_info_frame: %lx (%lu)\n", info.shared_info_frame, info.shared_info_frame); + } + + /* Setup the ofn to mfn table mapping */ + if ( info.hvm ) + { + if ( debug_mode ) + printf("HVM guest\n"); + + live_p2m_table = NULL; + } + else + { + if ( debug_mode ) + printf("PV guest\n"); + + /* Get live p2m table */ + live_p2m_table = xc_get_live_p2m_table(xc_handle, domain_id, p2m_size, + guest_width); + if ( !live_p2m_table ) + { + warning("failed to get live p2m table\n"); + goto out; + } + } + + /* Setup the mfn to pfn table mapping */ + live_m2p_table = xc_map_m2p(xc_handle, max_mfn, PROT_READ, &m2p_mfn0); + if ( !live_m2p_table ) + { + warning("failed to map live m2p table\n"); + goto out; + } + + /* Pause domain */ + printf("Pausing domain\n"); + rc = xc_domain_pause(xc_handle, domain_id); + if ( rc != 0 ) + { + warning("failed to pause domain"); + goto out; + } + sleep(1); + +#if 1 +#if COW + /* Take snapshot */ + printf("Taking snapshot\n"); + rc = system("touch /tmp/foo/1"); + sleep(1); + + /* Dump CoW image */ + printf("Dumping CoW image (1)... "); + fflush(stdout); + sprintf(fuse_file, "/tmp/foo/%d.%d", domain_id, snapshot_num); + dump_cow(COW_FILE1, p2m_size, fuse_file); + printf("done\n"); +#endif +#endif + + /* Dump live VM image */ + printf("Dumping live VM image (1)... "); + fflush(stdout); + dump_memory(LIVE_FILE1, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + printf("done\n"); + + /* Dump another live VM image */ + printf("Dumping live VM image (2)... "); + fflush(stdout); + dump_memory(LIVE_FILE2, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + printf("done\n"); + + /* Unpause domain */ + printf("Unpausing domain\n"); + rc = xc_domain_unpause(xc_handle, domain_id); + if ( rc != 0 ) + { + warning("failed to unpause domain"); + goto out; + } + +#if 1 +#if COW + /* Let domain run for a bit */ + printf("Sleeping for %d seconds\n", SLEEP_TIME); + sleep(SLEEP_TIME); + + /* Dump CoW image */ + printf("Dumping CoW image (2)... "); + fflush(stdout); + sprintf(fuse_file, "/tmp/foo/%d.0", domain_id); + dump_cow(COW_FILE2, p2m_size, fuse_file); + printf("done\n"); +#endif +#endif + + /* Compare images*/ + printf("-- Comparing images --\n"); + + printf("Comparing live1 live2...\n"); + rc = compare(LIVE_FILE1, LIVE_FILE2, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + if ( rc != 0 ) + printf("Images do not match (%d pages different)\n", -rc); + else + printf("Images match\n"); + +#if COW + printf("Comparing cow1 cow2...\n"); + rc = compare(COW_FILE1, COW_FILE2, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + if ( rc != 0 ) + printf("Images do not match (%d pages different)\n", -rc); + else + printf("Images match\n"); + + printf("Comparing live1 cow1...\n"); + rc = compare(LIVE_FILE1, COW_FILE1, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + if ( rc != 0 ) + printf("Images do not match (%d pages different)\n", -rc); + else + printf("Images match\n"); + + printf("Comparing live1 cow2...\n"); +// rc = compare(LIVE_FILE1, COW_FILE2, PAGE_SIZE, p2m_size, xc_handle, domain_id, live_p2m_table); + rc = compare(LIVE_FILE1, COW_FILE2, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + if ( rc != 0 ) + printf("Images do not match (%d pages different)\n", -rc); + else + printf("Images match\n"); + + printf("Comparing live2 cow1...\n"); +// rc = compare(LIVE_FILE2, COW_FILE1, PAGE_SIZE, p2m_size, xc_handle, domain_id, live_p2m_table); + rc = compare(LIVE_FILE2, COW_FILE1, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + if ( rc != 0 ) + printf("Images do not match (%d pages different)\n", -rc); + else + printf("Images match\n"); + + printf("Comparing live2 cow2...\n"); +// rc = compare(LIVE_FILE2, COW_FILE2, PAGE_SIZE, p2m_size, xc_handle, domain_id, live_p2m_table); + rc = compare(LIVE_FILE2, COW_FILE2, xc_handle, domain_id, live_p2m_table, live_m2p_table, + m2p_mfn0, p2m_size, max_mfn, hvirt_start, pt_levels, guest_width); + if ( rc != 0 ) + printf("Images do not match (%d pages different)\n", -rc); + else + printf("Images match\n"); +#endif + + out: + return 0; +} + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a tools/xencow/xencowfs/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/xencowfs/Makefile Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,35 @@ +XEN_ROOT=../../.. +include $(XEN_ROOT)/tools/Rules.mk + +CFLAGS += -I $(XEN_XC) +CFLAGS += -I ../lib +CFLAGS += $(CFLAGS_libxenctrl) + +SRCS += xencowfs.c + +CFLAGS += -Werror +CFLAGS += -Wno-unused +CFLAGS += -D_FILE_OFFSET_BITS=64 +CFLAGS += -g +CFLAGS += -Wl,-rpath,.. + +LDFLAGS += $(LDFLAGS_libxenctrl) $(LDFLAGS_libxenguest) -L../lib -lxencow -lfuse -lpthread + +OBJS = $(SRCS:.c=.o) +IBINS = xencowfs + +all: $(IBINS) + +xencowfs: $(OBJS) + $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) + +install: all + $(INSTALL_DIR) $(DESTDIR)$(SBINDIR) + $(INSTALL_PROG) $(IBINS) $(DESTDIR)$(SBINDIR) + +clean: + rm -f *.o *~ $(DEPS) xen TAGS $(IBINS) $(LIB) + +.PHONY: clean install + +-include $(DEPS) diff -r 0477f9061c8a tools/xencow/xencowfs/README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/xencowfs/README Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,24 @@ + + +First, launch the desired target domain. Create a mount point for the xencow FUSE module to use and from the tools/xencow/xencowfs directory, run: + +sudo ./xencowfs <mount point> <domid> + +This will initialise CoW for the domain. To take a snapshot, simply poke the FUSE mount point (e.g. touch <mount point>/1). The file name doesn't matter as FUSE will create it's own file named: + +<mount point>/<domid>.<snapshot> + +e.g. xencow/1.0, xencow/1.1 + +Currently, the backing files are hardcoded to appear in /tmp with the following names: + +/tmp/xencow<domid>.<snapshot> +/tmp/xencow<domid>.<snapshot>.state + +The <domid>.<snapshot> pair corresponds to the FUSE file. The .state file contains state pages (e.g. CPU registers), while the other file contains the pre-dirtied pages for that domain. + +It is possible to use XenAccess in file mode to access the snapshot image. A slightly modified version of the memory-dump example from XenAccess 0.5 is included which is designed to work on the CoW image. To use it, run (I've only tried running it from the xenaccess-0.5/examples/): + +sudo dump-memory-cow <FUSE image file> <output file> + +This will create a complete memory image of the running domain at the time the snapshot was taken. \ No newline at end of file diff -r 0477f9061c8a tools/xencow/xencowfs/xencowfs.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/xencow/xencowfs/xencowfs.c Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,253 @@ +/****************************************************************************** + * tools/xencow/xencowfs/xencowfs.c + * + * VM memory Copy-on-Write FUSE module + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#define FUSE_USE_VERSION 26 + + +#include <fuse.h> +#include <string.h> +#include <errno.h> +//#include <xc_private.h> + +#include "../lib/xencow.h" + + +#define DEBUG_OUTPUT 0 + + +static xencow_t *cow; + +static inline int get_snapshot_num(const char *path) +{ + return atoi(strrchr(path, '.')); +} + +static int path_exists(const char *path) +{ + xencow_snapshot_t *snapshot; + + list_for_each_entry ( snapshot, &cow->snapshots, list ) + if ( (strcmp(snapshot->xencowfs_file, path) == 0) + || ((path[0] == '/') + && (strcmp(snapshot->xencowfs_file, path + 1) == 0)) ) + return 1; + + return 0; +} + +static int xencowfs_create(const char *path, mode_t mode, + struct fuse_file_info *fi) +{ + return xencow_snapshot(cow); +} + +static void xencowfs_destroy(void *data) +{ + (void) data; + + xencow_disable(cow); +} + +static int xencowfs_getattr(const char *path, struct stat *stat) +{ + int res = 0; + + memset(stat, 0, sizeof(struct stat)); + + if ( strcmp(path, "/") == 0 ) + { + stat->st_mode = S_IFDIR | 0755; + stat->st_nlink = 2; + } + else if ( path_exists(path) ) + { + stat->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH; + stat->st_nlink = 1; + stat->st_size = cow->p2m_size << PAGE_SHIFT; + stat->st_blksize = PAGE_SIZE; + stat->st_blocks = cow->p2m_size; + } + else + res = -ENOENT; + + return res; +} + +static void *xencowfs_init(struct fuse_conn_info *conn) +{ + return NULL; +} + +static int xencowfs_open(const char *path, struct fuse_file_info *fi) +{ + if ( !path_exists(path) ) + return -ENOENT; + + if ( (fi->flags & 3) != O_RDONLY ) + return -EACCES; + + return 0; +} + +static int xencowfs_read(const char *path, char *buffer, size_t size, + off_t offset, struct fuse_file_info *fi) +{ + int snapshot_num; + unsigned long start_pfn; + int num_pages; + int ret; + + (void) fi; + + /* TODO: Worry about offsets not page aligned */ + start_pfn = offset_pfn(offset); + num_pages = size >> PAGE_SHIFT; + + /* Page align check */ + if ( pfn_offset(start_pfn) != offset ) + ERROR("Offset not page aligned!"); + + /* Check that it doesn't read past the end of the domain's memory */ + if ( start_pfn + num_pages > cow->p2m_size ) + num_pages = cow->p2m_size - start_pfn; + + IPRINTF("size = %lx; offset = %lx; num_pages = %d\n", + (unsigned long)size, (unsigned long)offset, num_pages); + + /* Get the appropriate snapshot */ + snapshot_num = get_snapshot_num(path); + + ret = xencow_read_buffer(cow, snapshot_num, start_pfn, num_pages, buffer); + if ( ret != 0 ) + goto out; + + ret = size; + + out: + return ret; +} + +static int xencowfs_readdir(const char *path, void *buffer, + fuse_fill_dir_t filler, off_t offset, + struct fuse_file_info *fi) +{ + xencow_snapshot_t *snapshot; + + (void) offset; + (void) fi; + + if ( strcmp(path, "/") != 0) + return -ENOENT; + + filler(buffer, ".", NULL, 0); + filler(buffer, "..", NULL, 0); + + list_for_each_entry(snapshot, &cow->snapshots, list) + filler(buffer, snapshot->xencowfs_file, NULL, 0); + + return 0; +} + +static int xencowfs_statfs(const char *path, struct statvfs *buf) +{ + (void) path; + + buf->f_bsize = PAGE_SIZE; + buf->f_blocks = cow->p2m_size; + buf->f_bfree = 0; + buf->f_bavail = 0; + buf->f_files = 0; + buf->f_ffree = 0; + buf->f_fsid = 0; + buf->f_namemax = 255; + buf->f_favail = 0; + buf->f_frsize = buf->f_blocks; + buf->f_flag = 0; + + return 0; +} + +static struct fuse_operations xencowfs_oper = { + .create = xencowfs_create, + .destroy = xencowfs_destroy, + .getattr = xencowfs_getattr, + .init = xencowfs_init, + .open = xencowfs_open, + .read = xencowfs_read, + .readdir = xencowfs_readdir, + .statfs = xencowfs_statfs, +}; + +int main(int argc, char *argv[]) +{ + domid_t domid; + int rc; + + IPRINTF("Start\n"); + + /* The last arg is the domain number */ + rc = -EINVAL; + domid = atoi(argv[argc - 1]); + if ( domid == 0 ) + { + ERROR("Invalid domain"); + exit(rc); + } + + /* Initialise CoW */ + IPRINTF("Initialise CoW\n"); + rc = -ENOMEM; + cow = xencow_init(domid); + if ( cow == NULL ) + { + ERROR("Could not initialise CoW"); + exit(rc); + } + + /* Enable CoW */ + IPRINTF("Enable CoW\n"); + rc = xencow_enable(cow); + if ( rc != 0 ) + { + ERROR("Could not enable CoW: rc = %d", rc); + exit(rc); + } + IPRINTF("CoW enabled\n"); + + rc = fuse_main(argc - 1, argv, &xencowfs_oper, NULL); + if ( rc != 0 ) + xencow_disable(cow); + + return rc; +} + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */

diff -r 0477f9061c8a xen/arch/x86/domctl.c --- a/xen/arch/x86/domctl.c Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/arch/x86/domctl.c Mon Apr 20 10:21:49 2009 -0700 @@ -28,6 +28,7 @@ #include <asm/processor.h> #include <xsm/xsm.h> #include <xen/iommu.h> +#include <asm/cow.h> long arch_do_domctl( struct xen_domctl *domctl, @@ -1087,6 +1088,132 @@ } break; + /* TODO: replace with XEN_DOMCTL_cow_op */ + case XEN_DOMCTL_cow_enable: + { + struct domain *d; + void *ring_page; + + ret = -EINVAL; + if ( domctl->domain == current->domain->domain_id ) + break; + + ret = -ESRCH; + d = rcu_lock_domain_by_id(domctl->domain); + if ( d == NULL ) + break; + + /* FIXME: Some other error code? */ + ret = -EINVAL; + ring_page = map_domain_page_global(domctl->u.cow_enable.mfn); + if ( ring_page == NULL ) + goto cow_enable_out; + + BACK_RING_INIT(&d->arch.paging.cow.back_ring, (cow_sring_t *)ring_page, PAGE_SIZE); + + ret = 0; + + cow_enable_out: + printk("CoW: enabled: ret: %ld\n", ret); + rcu_unlock_domain(d); + } + break; + + case XEN_DOMCTL_cow_snapshot: + { + struct domain *d; + RING_IDX when; + + ret = -EINVAL; + if ( domctl->domain == current->domain->domain_id ) + break; + + ret = -ESRCH; + d = rcu_lock_domain_by_id(domctl->domain); + if ( d == NULL ) + break; + + ret = cow_snapshot(d, &when); + if ( ret != 0 ) + goto cow_snapshot_out; + + domctl->u.cow_snapshot.when = when; + ret = 0; + + if ( copy_to_guest(u_domctl, domctl, 1) ) + ret = -EFAULT; + + cow_snapshot_out: + rcu_unlock_domain(d); + } + break; + + case XEN_DOMCTL_cow_resume: + { + struct domain *d; + + + ret = -EINVAL; + if ( domctl->domain == current->domain->domain_id ) + break; + + ret = -ESRCH; + d = rcu_lock_domain_by_id(domctl->domain); + if ( d == NULL ) + break; + + ret = cow_resume(d); + + rcu_unlock_domain(d); + } + break; + + case XEN_DOMCTL_cow_disable: + { + struct domain *d; + + ret = -EINVAL; + if ( domctl->domain == current->domain->domain_id ) + break; + + ret = -ESRCH; + d = rcu_lock_domain_by_id(domctl->domain); + if ( d == NULL ) + break; + + ret = paging_log_dirty_disable(d); + + rcu_unlock_domain(d); + } + break; + + case XEN_DOMCTL_cow_page_type: + { + struct domain *d; + struct page_info *page; + + ret = -EINVAL; + if ( domctl->domain == current->domain->domain_id ) + break; + + ret = -ESRCH; + d = rcu_lock_domain_by_id(domctl->domain); + if ( d == NULL ) + break; + + page = mfn_to_page(domctl->u.cow_page_type.mfn); + + domctl->u.cow_page_type.count_info = page->count_info; + domctl->u.cow_page_type.type_info = page->u.inuse.type_info; + ret = 0; + + if ( copy_to_guest(u_domctl, domctl, 1) ) + ret = -EFAULT; + + rcu_unlock_domain(d); + } + break; + default: ret = -ENOSYS; break; diff -r 0477f9061c8a xen/arch/x86/hvm/hvm.c --- a/xen/arch/x86/hvm/hvm.c Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/arch/x86/hvm/hvm.c Mon Apr 20 10:21:49 2009 -0700 @@ -1542,8 +1542,8 @@ } else { + paging_mark_dirty(curr->domain, mfn); memcpy(p, buf, count); - paging_mark_dirty(curr->domain, mfn); } } else diff -r 0477f9061c8a xen/arch/x86/mm/Makefile --- a/xen/arch/x86/mm/Makefile Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/arch/x86/mm/Makefile Mon Apr 20 10:21:49 2009 -0700 @@ -6,6 +6,7 @@ obj-y += guest_walk_2.o obj-y += guest_walk_3.o obj-$(x86_64) += guest_walk_4.o +obj-y += cow.o guest_walk_%.o: guest_walk.c Makefile $(CC) $(CFLAGS) -DGUEST_PAGING_LEVELS=$* -c $< -o $@ diff -r 0477f9061c8a xen/arch/x86/mm/cow.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xen/arch/x86/mm/cow.c Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,832 @@ +/****************************************************************************** + * arch/x86/mm/cow.c + * + * CoW paging support + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * Parts based on earlier work by Geoffrey Lefebvre + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include <asm/cow.h> +#include <asm/paging.h> +#include <xen/event.h> + + +#define COW_DOMAIN_PAUSE 0 +#define COW_DEBUG_OUTPUT 0 + + +/* Printouts */ +#define PAGING_PRINTK(_f, _a...) \ + debugtrace_printk("pg: %s(): " _f, __func__, ##_a) +#define PAGING_ERROR(_f, _a...) \ + printk("pg error: %s(): " _f, __func__, ##_a) +#if COW_DEBUG_OUTPUT +#define PAGING_DEBUG(flag, _f, _a...) \ + do { \ + if (PAGING_DEBUG_ ## flag) \ + printk("pgdebug: %s(): " _f, __func__, ##_a); \ + } while (0) +#else +#define PAGING_DEBUG(flag, _f, _a...) \ + do { \ + if (PAGING_DEBUG_ ## flag) \ + debugtrace_printk("pgdebug: %s(): " _f, __func__, ##_a); \ + } while (0) +#endif + + +#define STATE_MFN ((unsigned long)(-1)) + +#define xen_mb() mb() +#define xen_rmb() rmb() +#define xen_wmb() wmb() + +/* Override macros from asm/page.h to make them work with mfn_t */ +#undef mfn_to_page +#define mfn_to_page(_m) (frame_table + mfn_x(_m)) +#undef mfn_valid +#define mfn_valid(_mfn) (mfn_x(_mfn) < max_page) +#undef page_to_mfn +#define page_to_mfn(_pg) (_mfn((_pg) - frame_table)) + +/* The CoW lock. This protects the log-dirty bitmap from concurrent accesses + * (and teardowns, etc). + * + * Locking discipline: always acquire log dirty lock before this one. */ + +#define cow_lock_init(_d) \ + do { \ + spin_lock_init(&(_d)->arch.paging.cow.lock); \ + (_d)->arch.paging.cow.locker = -1; \ + (_d)->arch.paging.cow.locker_function = "nobody"; \ + } while (0) + +#define cow_lock(_d) \ + do { \ + if (unlikely((_d)->arch.paging.cow.locker==current->processor)) \ + { \ + printk("Error: paging cow lock held by %s\n", \ + (_d)->arch.paging.cow.locker_function); \ + BUG(); \ + } \ + spin_lock(&(_d)->arch.paging.cow.lock); \ + ASSERT((_d)->arch.paging.cow.locker == -1); \ + (_d)->arch.paging.cow.locker = current->processor; \ + (_d)->arch.paging.cow.locker_function = __func__; \ + } while (0) + +#define cow_unlock(_d) \ + do { \ + ASSERT((_d)->arch.paging.cow.locker == current->processor); \ + (_d)->arch.paging.cow.locker = -1; \ + (_d)->arch.paging.cow.locker_function = "nobody"; \ + spin_unlock(&(_d)->arch.paging.cow.lock); \ + } while (0) + + +/* XXX: ugly cut and paste from common/grant_table.c */ +#define ACGNT_PER_PAGE (PAGE_SIZE / sizeof(struct active_grant_entry)) +#define active_entry(t, e) ((t)->active[(e)/ACGNT_PER_PAGE][(e)%ACGNT_PER_PAGE]) + + +static void cow_notify_dom0_pause(unsigned long unused) +{ + printk("cow: notifying dom0 that domain is paused\n"); + send_guest_global_virq(dom0, VIRQ_COW_PAUSE); +} +static DECLARE_TASKLET(cow_notify_dom0_pause_tasklet, cow_notify_dom0_pause, 0); + +static void cow_notify_dom0_high_water(unsigned long flag_addr) +{ + printk("cow: notifying dom0 that ring buffer passed high water mark\n"); + send_guest_global_virq(dom0, VIRQ_COW_BUFFER); + (*(bool_t *)flag_addr) = 0; +} +static DECLARE_TASKLET(cow_notify_dom0_high_water_tasklet, cow_notify_dom0_high_water, 0); + +static void paging_free_cow_bitmap(unsigned long **bitmap) +{ + if ( likely(*bitmap != NULL) ) + { + printk("cow: freeing bitmap\n"); + xfree(*bitmap); + *bitmap = NULL; + } +} + +static void paging_free_cow(struct domain *d) +{ + printk("cow: freeing bitmaps\n"); + paging_free_cow_bitmap(&d->arch.paging.cow.precow_foreign_bitmap); + paging_free_cow_bitmap(&d->arch.paging.cow.bitmap); +} + +static int paging_alloc_cow_bitmap(unsigned long **bitmap, + unsigned long bitmap_size) +{ + BUG_ON(bitmap_size == 0); + + if ( unlikely(*bitmap == NULL) ) + { + *bitmap = xmalloc_array(unsigned long, bitmap_size / BITS_PER_LONG); + + if ( unlikely(*bitmap == NULL) ) + return -ENOMEM; + } + + memset(*bitmap, 0, bitmap_size / 8); + + return 0; +} + +/* Get address of current buffer page for a given domain */ +static unsigned long cow_get_buffer_page(struct domain *d) +{ + cow_request_t req; + cow_back_ring_t *back_ring; + RING_IDX req_cons; + + cow_ring_lock(d); + + back_ring = &d->arch.paging.cow.back_ring; + req_cons = back_ring->req_cons; + +#if COW_DEBUG_OUTPUT + printk("cow: xen_page_for_domain %d\n", d->domain_id); +#endif + + /* Get buffer page */ + memcpy(&req, (RING_GET_REQUEST(back_ring, req_cons)), sizeof(req)); + req_cons++; + + back_ring->req_cons = req_cons; + back_ring->sring->req_event = req_cons + 1; + +#if COW_DEBUG_OUTPUT + printk("cow: num: %ld buffer mfn %" PRI_mfn "\n", (unsigned long)req_cons, req.mfn); +#endif + + cow_ring_unlock(d); + + return req.mfn; +} + +static void cow_copy_page(struct domain *d, unsigned long guest_mfn, + void *guest_page) +{ + mfn_t gmfn; + unsigned long pfn; + unsigned long buffer_mfn; + void *buffer_page; + cow_response_t rsp; + cow_back_ring_t *back_ring; + +#if COW_DEBUG_OUTPUT + printk("cow: copy page: start\n"); +#endif + + /* We /really/ mean PFN here, even for non-translated guests. */ + if ( guest_mfn != STATE_MFN ) + { + gmfn = _mfn(guest_mfn); + pfn = get_gpfn_from_mfn(mfn_x(gmfn)); + + BUG_ON(!VALID_M2P(pfn)); + } + else + pfn = STATE_MFN; + +#if COW_DEBUG_OUTPUT + printk("cow: copy page: locking ring\n"); +#endif + + buffer_mfn = cow_get_buffer_page(d); + buffer_page = map_domain_page(buffer_mfn); + +#if COW_DEBUG_OUTPUT + printk("cow: copy page: mapped buffer page\n"); +#endif + + /* Copy page */ +#if COW_DEBUG_OUTPUT + printk("cow: copy guest page\n"); +#endif + memcpy(buffer_page, guest_page, PAGE_SIZE); + + PAGING_DEBUG(COW, + "copied page: mfn %" PRI_mfn + "; pfn %lx; page first chunk (%lx, %lx) from dom %d\n", + guest_mfn, pfn, *((unsigned long*)guest_page), + *((unsigned long*)buffer_page), d->domain_id); + + /* Unmap pages */ + unmap_domain_page(buffer_page); + + /* Replace mfn in ring with pfn */ + cow_ring_lock(d); + + back_ring = &d->arch.paging.cow.back_ring; + + rsp.pfn = pfn; + memcpy(RING_GET_RESPONSE(back_ring, back_ring->rsp_prod_pvt), + &rsp, sizeof(rsp)); + + /* Update number of pages copied */ + back_ring->rsp_prod_pvt++; + RING_PUSH_RESPONSES(back_ring); + + cow_ring_unlock(d); +} + +/* Save a page into a buffer */ +static void cow_save_page(struct domain *d, unsigned long guest_mfn) +{ + void *guest_page; + + guest_page = map_domain_page(guest_mfn); + cow_copy_page(d, guest_mfn, guest_page); + unmap_domain_page(guest_page); +} + +static void cow_pause_domain(struct domain *d, unsigned long guest_mfn, + bool_t is_pre_dirty) +{ +#if !COW_DOMAIN_PAUSE + struct vcpu *v; +#endif + + if ( d->arch.paging.cow.is_paused ) + { + PAGING_DEBUG(COW, + "domain already paused domain %d; mfn: %" PRI_mfn "\n", + d->domain_id, guest_mfn); + return; + } + + d->arch.paging.cow.is_paused = 1; + d->arch.paging.cow.is_paused_pre_dirty = is_pre_dirty; + d->arch.paging.cow.paused_guest_mfn = guest_mfn; + + PAGING_DEBUG(COW, + "not enough buffer space, pausing domain %d; mfn: %" + PRI_mfn "\n", d->domain_id, guest_mfn); + + printk("cow: pausing domain\n"); + +#if COW_DOMAIN_PAUSE + domain_pause(d); +#else + atomic_inc(&d->pause_count); + + for_each_vcpu( d, v ) +// vcpu_pause_nosync(v); + vcpu_sleep_nosync(v); +#endif + + tasklet_schedule(&cow_notify_dom0_pause_tasklet); +} + +static int cow_new_snapshot(struct domain *d) +{ + int ret; + + ret = paging_alloc_cow_bitmap(&d->arch.paging.cow.precow_foreign_bitmap, + d->arch.paging.cow.bitmap_size); + if ( unlikely(ret != 0) ) + goto free_log_dirty; + + ret = paging_alloc_cow_bitmap(&d->arch.paging.cow.bitmap, + d->arch.paging.cow.bitmap_size); + if ( unlikely(ret != 0) ) + goto free_precow_foreign; + +#if COW_DEBUG_OUTPUT + printk("cow enabled for dom %d\n", d->domain_id); +#endif + + return 0; + + free_precow_foreign: + paging_free_cow_bitmap(&d->arch.paging.cow.precow_foreign_bitmap); + free_log_dirty: + /* FIXME: This probably shouldn't be here any more... */ + paging_free_log_dirty_bitmap(d); + return ret; +} + +/* Check to make sure there's enough space in the buffer to continue */ +static int cow_check_threshold(struct domain *d) +{ + RING_IDX req_prod; + RING_IDX req_cons; + RING_IDX free_slots; + + req_prod = d->arch.paging.cow.back_ring.sring->req_prod; + req_cons = d->arch.paging.cow.back_ring.req_cons; + + if ( unlikely(d->arch.paging.cow.is_paused) ) + { + printk("cow_paging: check_threshold: domain still paused\n"); + return -EBUSY; + } + + free_slots = req_prod - req_cons; + + if ( unlikely(free_slots < XEN_COW_RING_THRESHOLD) ) + { + printk("cow_paging: check_threshold: no space left: req_prod = %d;" + "req_cons = %d; free_slots = %d\n", + req_prod, req_cons, free_slots); + return -ENOSPC; + } + + /* Notify ring buffer consumer that we've crossed the high water mark */ + if ( !d->arch.paging.cow.notified_high_water + && (free_slots < d->arch.paging.cow.ring_high_water) ) + { +#if COW_DEBUG_OUTPUT + printk("cow: check_threshold: passed high water mark\n"); +#endif + + d->arch.paging.cow.notified_high_water = 1; + cow_notify_dom0_high_water_tasklet.data = (unsigned long)&d->arch.paging.cow.notified_high_water; + tasklet_schedule(&cow_notify_dom0_high_water_tasklet); + } + + return 0; +} + +static int cow_save_state(struct domain *d) +{ + struct vcpu *v; + void *vcpu_page; + int i = 0; + +#if COW_DEBUG_OUTPUT + printk("cow: save state: start\n"); +#endif + + vcpu_page = xmalloc_bytes(PAGE_SIZE); + if ( unlikely(vcpu_page == NULL) ) + return -ENOMEM; + +#if COW_DEBUG_OUTPUT + printk("cow: save state: allocated page\n"); +#endif + + memset(vcpu_page, 0, PAGE_SIZE); + +#if COW_DEBUG_OUTPUT + printk("cow: save state: cleared page\n"); +#endif + + /* Save state for each vcpu */ + for_each_vcpu(d, v) + { + void *p = vcpu_page + (i * sizeof(v->arch.guest_context.user_regs)); + memcpy(p, &v->arch.guest_context.user_regs, + sizeof(v->arch.guest_context.user_regs)); + + i++; + } + +#if COW_DEBUG_OUTPUT + printk("cow: save state: copied CPU info\n"); +#endif + +#if 0 + cow_copy_page(d, STATE_MFN, d->shared_info); +#endif + cow_copy_page(d, STATE_MFN, vcpu_page); + +#if COW_DEBUG_OUTPUT + printk("cow: save state: copied pages\n"); +#endif + + xfree(vcpu_page); + +#if COW_DEBUG_OUTPUT + printk("cow: save state: done\n"); +#endif + + return 0; +} + +static int cow_scan_foreign_mapping(struct domain *d) +{ + RING_IDX req_prod; + RING_IDX req_cons; + int free_slots; + unsigned int num_entries; + unsigned int i; + int ret; + + ASSERT(d->arch.paging.cow.precow_foreign_bitmap != NULL); + + /* Get the grant table lock */ + spin_lock(&d->grant_table->lock); + + /* Find active entires */ + num_entries = 0; + for ( i = 0; i < nr_grant_entries(d->grant_table); i++ ) + { + struct active_grant_entry *act = &active_entry(d->grant_table, i); + + /* XXX: Is pin guaranteed to be zero for an inactive grant? */ + /* XXX: Do I need to worry about device mapping? */ + if ( act->pin & GNTPIN_hstw_mask || act->pin & GNTPIN_devw_mask ) + num_entries++; + } + + /* Make sure there's enough buffer space for this */ + req_prod = d->arch.paging.cow.back_ring.sring->req_prod; + req_cons = d->arch.paging.cow.back_ring.req_cons; + free_slots = req_prod - req_cons; + + ret = -ENOSPC; + if ( unlikely(free_slots < num_entries + XEN_COW_RING_THRESHOLD) ) + { + printk("cow_paging: scan_foreign: not enough space left\n"); + d->arch.paging.cow.is_paused_scan_foreign = 1; + goto out; + } + + /* For each entry in the active list, save the page */ + for ( i = 0; i < nr_grant_entries(d->grant_table); i++ ) + { + struct active_grant_entry *act = &active_entry(d->grant_table, i); + + if ( act->pin & GNTPIN_hstw_mask || act->pin & GNTPIN_devw_mask ) + { + mfn_t gmfn; + unsigned long pfn; + + gmfn = _mfn(act->frame); + + /* We /really/ mean PFN here, even for non-translated guests. */ + pfn = get_gpfn_from_mfn(mfn_x(gmfn)); + + ASSERT(VALID_M2P(pfn)); + ASSERT(mfn_valid(gmfn)); + + /* Set the bit in the precow bitmap */ +#if 1 + __set_bit(pfn, d->arch.paging.cow.precow_foreign_bitmap); +#else + set_bit(pfn, d->arch.paging.cow.precow_foreign_bitmap); +#endif + + /* + * If we have mapping with other domain, we won't be able + * to coordinate with them so just save page to be safe + */ + cow_save_page(d, act->frame); + } + } + + ret = 0; + out: + /* Release lock */ + spin_unlock(&d->grant_table->lock); + return ret; +} + +static int cow_take_snapshot(struct domain *d) +{ + int ret; + +#if COW_DEBUG_OUTPUT + printk("cow checking threshold\n"); +#endif + + ret = cow_check_threshold(d); + if ( unlikely(ret != 0) ) + return ret; + +#if COW_DEBUG_OUTPUT + printk("cow new snapshot\n"); +#endif + + ret = cow_new_snapshot(d); + if ( unlikely(ret != 0) ) + return ret; + +#if COW_DEBUG_OUTPUT + printk("cow saving state\n"); +#endif + + ret = cow_save_state(d); + if ( unlikely(ret != 0) ) + return ret; + +#if COW_DEBUG_OUTPUT + printk("cow scan foreign\n"); +#endif + + /* + * Fill the precow bitmap by scanning the active grant list. + * We are racing with devices here, so we need to coordinate + * We will probably only coordinate with dom0. + */ + cow_scan_foreign_mapping(d); + +#if COW_DEBUG_OUTPUT + printk("cow snapshot taken\n"); +#endif + + return 0; +} + +void cow_init(struct domain *d) +{ + cow_lock_init(d); + cow_ring_lock_init(d); + disable_cow(d); +} + +void cow_teardown(struct domain *d) +{ + cow_lock(d); + paging_free_cow(d); + cow_unlock(d); +} + +int cow_enable(struct domain *d) +{ + int ret; + + cow_lock(d); + + ret = -EINVAL; + if ( cow_enabled(d) ) + goto out; + + d->arch.paging.cow.bitmap_size = + (domain_get_maximum_gpfn(d) + BITS_PER_LONG) & ~(BITS_PER_LONG - 1); + + /* 50% high water mark */ + d->arch.paging.cow.ring_high_water = RING_SIZE(&d->arch.paging.cow.back_ring) >> 1; + d->arch.paging.cow.notified_high_water = 0; + + d->arch.paging.cow.is_paused = 0; + d->arch.paging.cow.is_paused_pre_dirty = 0; + d->arch.paging.cow.is_paused_scan_foreign = 0; + d->arch.paging.cow.paused_guest_mfn = 0; + + enable_cow(d); + + ret = 0; + + out: + cow_unlock(d); + return ret; +} + +void cow_disable(struct domain *d) +{ + printk("cow: disable cow for domain %d\n", d->domain_id); + + disable_cow(d); + + cow_lock(d); + paging_free_cow(d); + cow_unlock(d); +} + +/* Take proper action when a page is mapped writable in a foreign domain */ +void cow_pre_dirty(struct domain *d, unsigned long guest_mfn) +{ + unsigned long pfn; + mfn_t gmfn; + int rc; + + gmfn = _mfn(guest_mfn); + + /* We /really/ mean PFN here, even for non-translated guests. */ + pfn = get_gpfn_from_mfn(mfn_x(gmfn)); + + BUG_ON(!VALID_M2P(pfn)); + + cow_lock(d); + + ASSERT(d->arch.paging.cow.precow_foreign_bitmap != NULL); + ASSERT(d->arch.paging.cow.bitmap != NULL); + BUG_ON( test_bit(pfn, d->arch.paging.cow.precow_foreign_bitmap) ); + + if ( !__test_and_set_bit(pfn, d->arch.paging.cow.bitmap) ) + { +#if COW_DEBUG_OUTPUT + printk("cow: pre dirty: mfn = %lx\n", guest_mfn); +#endif + + rc = cow_check_threshold(d); + if ( rc != 0 ) + { + __clear_bit(pfn, d->arch.paging.cow.bitmap); + cow_pause_domain(d, guest_mfn, 1); + goto out; + } + + cow_save_page(d, guest_mfn); + } + + out: + cow_unlock(d); +} + +void cow_mark_dirty(struct domain *d, unsigned long guest_mfn) +{ + unsigned long pfn; + mfn_t gmfn; + int rc; + + cow_lock(d); + + ASSERT(d->arch.paging.cow.precow_foreign_bitmap != NULL); + ASSERT(d->arch.paging.cow.bitmap != NULL); + + gmfn = _mfn(guest_mfn); + + /* We /really/ mean PFN here, even for non-translated guests. */ + pfn = get_gpfn_from_mfn(mfn_x(gmfn)); + + /* + * Values with the MSB set denote MFNs that aren't really part of the + * domain's pseudo-physical memory map (e.g., the shared info frame). + * Nothing to do here... + */ + if ( unlikely(!VALID_M2P(pfn)) ) + goto out; + + /* Test saved_page bitmap */ +#if 0 +#if COW_DEBUG_OUTPUT + if ( test_bit(pfn, d->arch.paging.cow.bitmap) ) + printk("cow: already marked dirty: mfn = %lx\n", guest_mfn); +#endif +#endif + + /* Test precow bitmap */ + if ( test_bit(pfn, d->arch.paging.cow.precow_foreign_bitmap) ) + { + /* + * This is either a ring page(ok) or + * the guest is racing with a device to + * write to the page but since we are racing + * with a device, we can really save the page either. + * In the latter case, the checkpoint will most + * likely be broken. + */ + PAGING_DEBUG(COW, + "write to precow foreign page %" PRI_mfn + " (pfn=%lx), dom %d\n", + mfn_x(gmfn), pfn, d->domain_id); + + /* + * We clear this bit, since the state of the page is now defined + * and part of the snapshot, so we want to protect the page if we + * write to it. + */ + __clear_bit(pfn, d->arch.paging.cow.precow_foreign_bitmap); + + if ( !__test_and_set_bit(pfn, d->arch.paging.cow.bitmap) ) + { + PAGING_DEBUG(COW, + "marked precow foreign mfn %" + PRI_mfn " (pfn=%lx), dom %d\n", + mfn_x(gmfn), pfn, d->domain_id); + } + } + else if ( !__test_and_set_bit(pfn, d->arch.paging.cow.bitmap) ) + { + /* Save the page */ +#if COW_DEBUG_OUTPUT + printk("cow: mark dirty: mfn = %lx\n", guest_mfn); +#endif + rc = cow_check_threshold(d); + if ( rc != 0 ) + { + __clear_bit(pfn, d->arch.paging.cow.bitmap); + cow_pause_domain(d, guest_mfn, 0); + goto out; + } + + cow_save_page(d, guest_mfn); + } + + out: + cow_unlock(d); +} + +int cow_snapshot(struct domain *d, RING_IDX *when) +{ + int ret; + + /* FIXME: Try not to pause/unpause all the time */ + domain_pause(d); + + /* FIXME: Try not to disable/enable log dirty all the time */ + if ( cow_enabled(d) ) + paging_log_dirty_disable(d); + + if ( !cow_enabled(d) ) + { + ret = paging_log_dirty_enable(d, 1); + if ( ret != 0 ) + goto out; + } + + cow_lock(d); + *when = d->arch.paging.cow.back_ring.sring->rsp_prod; +#if COW_DEBUG_OUTPUT + printk("cow: snapshot: when = %d\n", *when); +#endif + ret = cow_take_snapshot(d); +#if COW_DEBUG_OUTPUT + printk("cow: snapshot: took snapshot = %d\n", ret); +#endif + cow_unlock(d); + + out: + domain_unpause(d); + + return ret; +} + +int cow_resume(struct domain *d) +{ +#if !COW_DOMAIN_PAUSE + struct vcpu *v; +#endif + int ret; + + cow_lock(d); + + ret = -EINVAL; + if ( !cow_enabled(d) ) + goto out; + + if ( d->arch.paging.cow.is_paused == 0 ) + { + ret = 0; + goto out; + } + + d->arch.paging.cow.is_paused = 0; + ret = cow_check_threshold(d); + if ( ret != 0 ) + { + d->arch.paging.cow.is_paused = 1; + goto out; + } + + if ( d->arch.paging.cow.is_paused_pre_dirty ) + { + d->arch.paging.cow.is_paused_pre_dirty = 0; + cow_unlock(d); + cow_pre_dirty(d, d->arch.paging.cow.paused_guest_mfn); + } + else if ( d->arch.paging.cow.is_paused_scan_foreign ) + { + d->arch.paging.cow.is_paused_scan_foreign = 0; + cow_scan_foreign_mapping(d); + cow_unlock(d); + } + else + { + cow_unlock(d); + cow_mark_dirty(d, d->arch.paging.cow.paused_guest_mfn); + } + + d->arch.paging.cow.paused_guest_mfn = 0; + +#if COW_DOMAIN_PAUSE + domain_unpause(d); +#else + if ( atomic_dec_and_test(&d->pause_count) ) + for_each_vcpu( d, v ) +// vcpu_unpause(v); + vcpu_wake(v); +#endif + + return 0; + + out: + cow_unlock(d); + return ret; +} diff -r 0477f9061c8a xen/arch/x86/mm/paging.c --- a/xen/arch/x86/mm/paging.c Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/arch/x86/mm/paging.c Mon Apr 20 10:21:49 2009 -0700 @@ -26,8 +26,10 @@ #include <asm/p2m.h> #include <asm/hap.h> #include <asm/guest_access.h> +#include <asm/cow.h> #include <xen/numa.h> #include <xsm/xsm.h> +#include <xen/grant_table.h> #define hap_enabled(d) (is_hvm_domain(d) && (d)->arch.hvm_domain.hap_enabled) @@ -158,7 +160,7 @@ { d->arch.paging.log_dirty.allocs--; free_domheap_page(mfn_to_page(mfn)); -} +} void paging_free_log_dirty_bitmap(struct domain *d) { @@ -207,7 +209,7 @@ d->arch.paging.log_dirty.failed_allocs = 0; } -int paging_log_dirty_enable(struct domain *d) +int paging_log_dirty_enable(struct domain *d, bool_t enable_cow) { int ret; @@ -226,6 +228,9 @@ paging_free_log_dirty_bitmap(d); goto out; } + + if ( enable_cow ) + cow_enable(d); log_dirty_unlock(d); @@ -253,11 +258,33 @@ ret = d->arch.paging.log_dirty.disable_log_dirty(d); log_dirty_lock(d); if ( !paging_mode_log_dirty(d) ) + { paging_free_log_dirty_bitmap(d); + + if ( cow_enabled(d) ) + cow_disable(d); + } log_dirty_unlock(d); domain_unpause(d); return ret; +} + +void paging_pre_dirty(struct domain *d, unsigned long guest_mfn) +{ + mfn_t gmfn; + + gmfn = _mfn(guest_mfn); + + if ( !paging_mode_log_dirty(d) || !mfn_valid(gmfn) ) + return; + + log_dirty_lock(d); + + if ( cow_enabled(d) ) + cow_pre_dirty(d, guest_mfn); + + log_dirty_unlock(d); } /* Mark a page as dirty */ @@ -327,11 +354,14 @@ unmap_domain_page(l1); if ( changed ) { - PAGING_DEBUG(LOGDIRTY, + PAGING_DEBUG(LOGDIRTY, "marked mfn %" PRI_mfn " (pfn=%lx), dom %d\n", mfn_x(gmfn), pfn, d->domain_id); d->arch.paging.log_dirty.dirty_count++; } + + if ( cow_enabled(d) ) + cow_mark_dirty(d, guest_mfn); out: log_dirty_unlock(d); @@ -471,13 +501,20 @@ d->arch.paging.log_dirty.disable_log_dirty = disable_log_dirty; d->arch.paging.log_dirty.clean_dirty_bitmap = clean_dirty_bitmap; d->arch.paging.log_dirty.top = _mfn(INVALID_MFN); + + cow_init(d); } /* This function fress log dirty bitmap resources. */ void paging_log_dirty_teardown(struct domain*d) { log_dirty_lock(d); + paging_free_log_dirty_bitmap(d); + + if ( cow_enabled(d) ) + cow_teardown(d); + log_dirty_unlock(d); } /************************************************/ @@ -552,11 +589,11 @@ switch ( sc->op ) { case XEN_DOMCTL_SHADOW_OP_ENABLE_LOGDIRTY: - return paging_log_dirty_enable(d); + return paging_log_dirty_enable(d, 0); case XEN_DOMCTL_SHADOW_OP_ENABLE: if ( sc->mode & XEN_DOMCTL_SHADOW_ENABLE_LOG_DIRTY ) - return paging_log_dirty_enable(d); + return paging_log_dirty_enable(d, 0); case XEN_DOMCTL_SHADOW_OP_OFF: if ( paging_mode_log_dirty(d) ) diff -r 0477f9061c8a xen/arch/x86/mm/shadow/multi.c --- a/xen/arch/x86/mm/shadow/multi.c Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/arch/x86/mm/shadow/multi.c Mon Apr 20 10:21:49 2009 -0700 @@ -36,6 +36,7 @@ #include <asm/hvm/cacheattr.h> #include <asm/mtrr.h> #include <asm/guest_pt.h> +#include <asm/paging.h> #include "private.h" #include "types.h" @@ -4598,6 +4599,8 @@ } #endif + paging_pre_dirty(v->domain, mfn_x(sh_ctxt->mfn1)); + /* Unaligned writes mean probably this isn't a pagetable */ if ( vaddr & (bytes - 1) ) sh_remove_shadows(v, sh_ctxt->mfn1, 0, 0 /* Slow, can fail */ ); @@ -4623,6 +4626,8 @@ MAPPING_EXCEPTION : (mfn_x(sh_ctxt->mfn2) == READONLY_GFN) ? MAPPING_SILENT_FAIL : MAPPING_UNHANDLEABLE); + + paging_pre_dirty(v->domain, mfn_x(sh_ctxt->mfn2)); /* Cross-page writes mean probably not a pagetable */ sh_remove_shadows(v, sh_ctxt->mfn2, 0, 0 /* Slow, can fail */ ); diff -r 0477f9061c8a xen/common/grant_table.c --- a/xen/common/grant_table.c Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/common/grant_table.c Mon Apr 20 10:21:49 2009 -0700 @@ -352,6 +352,15 @@ goto undo_out; } + /* + * If the mapping is writable, do something before the page is mapped. + * We may end up doing something useless if the mapping fails but + * otherwise we could end up racing with the guest + * (altough very unlikely) + */ + if ( !(op->flags & GNTMAP_readonly) ) + gnttab_pre_dirty(rd, frame); + rc = create_grant_host_mapping( op->host_addr, frame, op->flags, cache_flags); if ( rc != GNTST_okay ) @@ -582,7 +591,7 @@ /* If just unmapped a writable mapping, mark as dirtied */ if ( !(op->flags & GNTMAP_readonly) ) - gnttab_mark_dirty(rd, op->frame); + gnttab_post_dirty(rd, op->frame); unmap_out: op->status = rc; @@ -1255,7 +1264,7 @@ } else { - gnttab_mark_dirty(rd, r_frame); + gnttab_post_dirty(rd, r_frame); act->pin -= GNTPIN_hstw_inc; if ( !(act->pin & (GNTPIN_devw_mask|GNTPIN_hstw_mask)) ) @@ -1444,6 +1453,8 @@ goto error_out; } + gnttab_pre_dirty(dd, d_frame); + sp = map_domain_page(s_frame); dp = map_domain_page(d_frame); @@ -1452,7 +1463,7 @@ unmap_domain_page(dp); unmap_domain_page(sp); - gnttab_mark_dirty(dd, d_frame); + gnttab_post_dirty(dd, d_frame); put_page_and_type(mfn_to_page(d_frame)); error_out: diff -r 0477f9061c8a xen/include/asm-x86/cow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xen/include/asm-x86/cow.h Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,83 @@ +/****************************************************************************** + * include/asm-x86/cow.h + * + * Common interface for cow support. + * + * Copyright (c) 2009 University of British Columbia (Patrick Colp) + * Parts based on earlier work by Geoffrey Lefebvre + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef __COW_H__ +#define __COW_H__ + + +#include <xen/sched.h> + + +/* Flag used for CoW debug */ +#define PAGING_DEBUG_COW 1 + + +/* CoW helper functions */ +#define cow_enabled(_d) ((_d)->is_cow) +#define enable_cow(_d) ((_d)->is_cow = 1) +#define disable_cow(_d) ((_d)->is_cow = 0) + +/* CoW lock */ +#define cow_ring_lock_init(_d) spin_lock_init(&(_d)->arch.paging.cow.ring_lock) +#define cow_ring_lock(_d) spin_lock(&(_d)->arch.paging.cow.ring_lock) +#define cow_ring_unlock(_d) spin_unlock(&(_d)->arch.paging.cow.ring_lock) + + +/* Enable CoW */ +int cow_enable(struct domain *d); + +/* Disable CoW */ +void cow_disable(struct domain *d); + +/* CoW initialisation */ +void cow_init(struct domain *d); + +/* CoW teardown */ +void cow_teardown(struct domain *d); + +/* Take a CoW snapshot */ +int cow_snapshot(struct domain *d, RING_IDX *when); + +/* Resume a domain paused because of CoW (buffer was full) */ +int cow_resume(struct domain *d); + +/* We use the mapping and unmaping of the page as conservative boundary + * on the page being written to by the foreign domain */ +void cow_pre_dirty(struct domain *d, unsigned long guest_mfn); + +/* Copy pages out and mark them as dirty so they don't get copied again */ +void cow_mark_dirty(struct domain *d, unsigned long guest_mfn); + + +#endif /* __COW_H__ */ + + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a xen/include/asm-x86/domain.h --- a/xen/include/asm-x86/domain.h Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/include/asm-x86/domain.h Mon Apr 20 10:21:49 2009 -0700 @@ -6,6 +6,7 @@ #include <asm/hvm/vcpu.h> #include <asm/hvm/domain.h> #include <asm/e820.h> +#include <public/io/cow.h> #define has_32bit_shinfo(d) ((d)->arch.has_32bit_shinfo) #define is_pv_32bit_domain(d) ((d)->arch.is_32bit_pv) @@ -149,6 +150,41 @@ }; /************************************************/ +/* copy-on-write */ +/************************************************/ +struct cow_domain { + /* cow lock */ + spinlock_t lock; + int locker; /* processor that holds the lock */ + const char *locker_function; /* func that took it */ + + /* ring lock */ + spinlock_t ring_lock; + + /* size of the cow bitmaps */ + unsigned long bitmap_size; + + /* cow bitmap to record foreign pages before cow was enabled */ + unsigned long *precow_foreign_bitmap; + + /* cow bitmap to record pages that have been saved */ + unsigned long *bitmap; + + /* back-end ring for reading mfns and storing pfns */ + cow_back_ring_t back_ring; + + /* high water mark for ring */ + RING_IDX ring_high_water; + bool_t notified_high_water; + + /* paused domain */ + bool_t is_paused; + bool_t is_paused_pre_dirty; + bool_t is_paused_scan_foreign; + unsigned long paused_guest_mfn; +}; + +/************************************************/ /* common paging data structure */ /************************************************/ struct log_dirty_domain { @@ -181,6 +217,8 @@ struct hap_domain hap; /* log dirty support */ struct log_dirty_domain log_dirty; + /* cow support */ + struct cow_domain cow; }; struct paging_vcpu { diff -r 0477f9061c8a xen/include/asm-x86/grant_table.h --- a/xen/include/asm-x86/grant_table.h Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/include/asm-x86/grant_table.h Mon Apr 20 10:21:49 2009 -0700 @@ -31,7 +31,8 @@ #define gnttab_shared_gmfn(d, t, i) \ (mfn_to_gmfn(d, gnttab_shared_mfn(d, t, i))) -#define gnttab_mark_dirty(d, f) paging_mark_dirty((d), (f)) +#define gnttab_pre_dirty(d, f) paging_pre_dirty((d), (f)) +#define gnttab_post_dirty(d, f) paging_mark_dirty((d), (f)) static inline void gnttab_clear_flag(unsigned long nr, uint16_t *addr) { diff -r 0477f9061c8a xen/include/asm-x86/paging.h --- a/xen/include/asm-x86/paging.h Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/include/asm-x86/paging.h Mon Apr 20 10:21:49 2009 -0700 @@ -140,7 +140,7 @@ void paging_free_log_dirty_bitmap(struct domain *d); /* enable log dirty */ -int paging_log_dirty_enable(struct domain *d); +int paging_log_dirty_enable(struct domain *d, bool_t enable_cow); /* disable log dirty */ int paging_log_dirty_disable(struct domain *d); @@ -152,6 +152,7 @@ void (*clean_dirty_bitmap)(struct domain *d)); /* mark a page as dirty */ +void paging_pre_dirty(struct domain *d, unsigned long guest_mfn); void paging_mark_dirty(struct domain *d, unsigned long guest_mfn); /* diff -r 0477f9061c8a xen/include/public/domctl.h --- a/xen/include/public/domctl.h Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/include/public/domctl.h Mon Apr 20 10:21:49 2009 -0700 @@ -33,6 +33,7 @@ #endif #include "xen.h" +#include "io/ring.h" #define XEN_DOMCTL_INTERFACE_VERSION 0x00000005 @@ -645,6 +646,41 @@ } xen_domctl_hvmcontext_partial_t; DEFINE_XEN_GUEST_HANDLE(xen_domctl_hvmcontext_partial_t); +/* FIXME: use types instead of different domctls */ +/* + * Enable/disable Copy-on-write for a domain. + */ +#define XEN_DOMCTL_cow_enable 56 +#define XEN_DOMCTL_cow_snapshot 57 +#define XEN_DOMCTL_cow_resume 58 +#define XEN_DOMCTL_cow_disable 59 +#define XEN_DOMCTL_cow_page_type 60 + +struct xen_domctl_cow_enable { + /* IN: mfn of the ring buffer */ + unsigned long mfn; +}; +typedef struct xen_domctl_cow_enable xen_domctl_cow_enable_t; +DEFINE_XEN_GUEST_HANDLE(xen_domctl_cow_enable_t); + +struct xen_domctl_cow_snapshot { + /* OUT: when the snapshot took place (rsp_prod) */ + RING_IDX when; +}; +typedef struct xen_domctl_cow_snapshot xen_domctl_cow_snapshot_t; +DEFINE_XEN_GUEST_HANDLE(xen_domctl_cow_snapshot_t); + +struct xen_domctl_cow_page_type { + /* IN: mfn of the page */ + unsigned long mfn; + /* OUT: count info */ + unsigned long count_info; + /* OUT: page type info */ + unsigned long type_info; +}; +typedef struct xen_domctl_cow_page_type xen_domctl_cow_page_type_t; +DEFINE_XEN_GUEST_HANDLE(xen_domctl_cow_page_type_t); + struct xen_domctl { uint32_t cmd; @@ -687,6 +723,9 @@ struct xen_domctl_set_target set_target; struct xen_domctl_subscribe subscribe; struct xen_domctl_debug_op debug_op; + struct xen_domctl_cow_enable cow_enable; + struct xen_domctl_cow_snapshot cow_snapshot; + struct xen_domctl_cow_page_type cow_page_type; #if defined(__i386__) || defined(__x86_64__) struct xen_domctl_cpuid cpuid; #endif diff -r 0477f9061c8a xen/include/public/io/cow.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xen/include/public/io/cow.h Mon Apr 20 10:21:49 2009 -0700 @@ -0,0 +1,82 @@ +/***************************************************************************** + * cow.h + * + * CoW common structures + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright (C) 2009 University of British Columbia (Patrick Colp) + */ + +#ifndef _XEN_PUBLIC_IO_COW_H +#define _XEN_PUBLIC_IO_COW_H + + +#include "ring.h" + + +#define RING_MASK(_r, _i) ((_i) & (RING_SIZE(_r) - 1)) + + +#define XEN_COW_IOC_MAGIC 'w' +#define XEN_COW_IOCTL_INIT _IO(XEN_COW_IOC_MAGIC, 1) + +#define XEN_COW_RING_PAGES 1 /* TODO: 2+ pages? */ +#define XEN_COW_RING_SIZE (XEN_COW_RING_PAGES << PAGE_SHIFT) + +#define XEN_COW_RING_THRESHOLD 16 + + +/* Some definitions for the XenCow ring buffer. */ +typedef struct cow_request_st { + unsigned long mfn; +} cow_request_t; + +typedef struct cow_response_st { + unsigned long pfn; +} cow_response_t; + + +DEFINE_RING_TYPES(cow, cow_request_t, cow_response_t); + + +/* + * The structure used to initialise CoW. + */ +typedef struct cow_init_st { + /* Start address of buffer */ + unsigned long addr; + /* Number of frames in buffer */ + int num_mfns; + /* MFNs of buffer frames */ + unsigned long mfns[]; +} cow_init_t; + + +#endif /* _XEN_PUBLIC_IO_COW_H */ + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 0477f9061c8a xen/include/public/xen.h --- a/xen/include/public/xen.h Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/include/public/xen.h Mon Apr 20 10:21:49 2009 -0700 @@ -143,6 +143,8 @@ #define VIRQ_DEBUGGER 6 /* G. (DOM0) A domain has paused for debugging. */ #define VIRQ_XENOPROF 7 /* V. XenOprofile interrupt: new sample available */ #define VIRQ_CON_RING 8 /* G. (DOM0) Bytes received on console */ +#define VIRQ_COW_BUFFER 9 /* G. (DOM0) CoW buffer has pages available */ +#define VIRQ_COW_PAUSE 10 /* G. (DOM0) CoW domain has been paused */ /* Architecture-specific VIRQ definitions. */ #define VIRQ_ARCH_0 16 diff -r 0477f9061c8a xen/include/xen/sched.h --- a/xen/include/xen/sched.h Fri Mar 20 17:42:46 2009 +0000 +++ b/xen/include/xen/sched.h Mon Apr 20 10:21:49 2009 -0700 @@ -223,6 +223,8 @@ bool_t is_paused_by_controller; /* Domain's VCPUs are pinned 1:1 to physical CPUs? */ bool_t is_pinned; + /* Is this guest doing CoW? */ + bool_t is_cow; /* Are any VCPUs polling event channels (SCHEDOP_poll)? */ DECLARE_BITMAP(poll_mask, MAX_VIRT_CPUS);

_______________________________________________ Xen-devel mailing list Xen-devel@xxxxxxxxxxxxxxxxxxx http://lists.xensource.com/xen-devel

©2013 Xen Project, A Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation.
Xen Project is a trademark of The Linux Foundation.