diff -Naur qemu-2.1+dfsg.old/debian/changelog qemu-2.1+dfsg/debian/changelog
--- qemu-2.1+dfsg.old/debian/changelog	2015-08-29 16:22:05.000000000 +0200
+++ qemu-2.1+dfsg/debian/changelog	2015-09-13 18:47:22.499997759 +0200
@@ -1,3 +1,9 @@
+qemu (1:2.1+dfsg-12+deb8u2+tails1) jessie; urgency=low
+
+  * Apply test patch.
+
+ -- anonym <anonym@riseup.net>  Sun, 13 Sep 2015 18:46:36 +0200
+
 qemu (1:2.1+dfsg-12+deb8u2) jessie-security; urgency=high
 
   * Non-maintainer upload by the Security Team.
diff -Naur qemu-2.1+dfsg.old/debian/patches/qemu-9p-live-migration.patch qemu-2.1+dfsg/debian/patches/qemu-9p-live-migration.patch
--- qemu-2.1+dfsg.old/debian/patches/qemu-9p-live-migration.patch	1970-01-01 01:00:00.000000000 +0100
+++ qemu-2.1+dfsg/debian/patches/qemu-9p-live-migration.patch	2015-09-13 18:43:45.645119377 +0200
@@ -0,0 +1,238 @@
+commit 9b987fbe6e65a54cef80850c9d8fd9f5083058cb
+Author: anonym <anonym@riseup.net>
+Date:   Sun Sep 13 18:41:26 2015 +0200
+
+    WIP patch
+
+diff --git a/hw/9pfs/virtio-9p-device.c b/hw/9pfs/virtio-9p-device.c
+index 2572747..078ad39 100644
+--- a/hw/9pfs/virtio-9p-device.c
++++ b/hw/9pfs/virtio-9p-device.c
+@@ -21,6 +21,149 @@
+ #include "virtio-9p-coth.h"
+ #include "hw/virtio/virtio-access.h"
+ 
++static void virtio_9p_save_path(QEMUFile *f, V9fsPath *path)
++{
++    qemu_put_be16(f, path->size);
++    qemu_put_buffer(f, (const uint8_t *) path->data, path->size);
++}
++
++static void virtio_9p_save_string(QEMUFile *f, V9fsString *s)
++{
++    qemu_put_be16(f, s->size);
++    qemu_put_buffer(f, (const uint8_t *) s->data, s->size);
++}
++
++static void virtio_9p_save_xattr(QEMUFile *f, V9fsXattr *xattr)
++{
++    qemu_put_be64(f, xattr->copied_len);
++    qemu_put_be64(f, xattr->len);
++    qemu_put_buffer(f, (const uint8_t *) xattr->value, xattr->len);
++    virtio_9p_save_string(f, &xattr->name);
++    qemu_put_be32(f, xattr->flags);
++}
++
++static void virtio_9p_save_fid(QEMUFile *f, V9fsFidState *fid)
++{
++    /* First close the fid and mark it for reopen if migration fail */
++    if (fid->fid_type == P9_FID_FILE) {
++        close(fid->fs.fd);
++        fid->fs.fd = -1;
++    } else if (fid->fid_type == P9_FID_DIR) {
++        closedir(fid->fs.dir);
++        fid->fs.dir = NULL;
++    }
++
++    qemu_put_be32(f, fid->fid_type);
++    if (fid->fid_type == P9_FID_XATTR) {
++        /* we don't save fs_reclaim */
++        virtio_9p_save_xattr(f, &fid->fs.xattr);
++    }
++    qemu_put_be32(f, fid->fid);
++    virtio_9p_save_path(f, &fid->path);
++    qemu_put_be32(f, fid->flags);
++    qemu_put_be32(f, fid->open_flags);
++    qemu_put_be32(f, fid->uid);
++    qemu_put_be32(f, fid->ref);
++    qemu_put_be32(f, fid->clunked);
++}
++
++static void virtio_9p_save(QEMUFile *f, void *opaque)
++{
++    int fidcount = 0;
++    V9fsState *s = opaque;
++    V9fsFidState *fid;
++
++    virtio_save(VIRTIO_DEVICE(s), f);
++
++    for (fid = s->fid_list; fid; fid = fid->next) {
++        fidcount++;
++    }
++    /* Write the total number of fid structure */
++    qemu_put_be32(f, fidcount);
++
++    for (fid = s->fid_list; fid; fid = fid->next) {
++        virtio_9p_save_fid(f, fid);
++    }
++
++    qemu_put_be32(f, s->proto_version);
++    qemu_put_be32(f, s->msize);
++}
++
++static void virtio_9p_load_path(QEMUFile *f, V9fsPath *path)
++{
++    path->size = qemu_get_be16(f);
++    path->data = g_malloc0(path->size);
++    qemu_get_buffer(f, (uint8_t *) path->data, path->size);
++}
++
++static void virtio_9p_load_string(QEMUFile *f, V9fsString *s)
++{
++    s->size = qemu_get_be16(f);
++    s->data = g_malloc0(s->size);
++    qemu_get_buffer(f, (uint8_t *) s->data, s->size);
++}
++
++static void virtio_9p_load_xattr(QEMUFile *f, V9fsXattr *xattr)
++{
++    xattr->copied_len = qemu_get_be64(f);
++    xattr->len = qemu_get_be64(f);
++    qemu_get_buffer(f, (uint8_t *) xattr->value, xattr->len);
++    virtio_9p_load_string(f, &xattr->name);
++    xattr->flags = qemu_get_be32(f);
++}
++
++static V9fsFidState *virtio_9p_load_fid(QEMUFile *f)
++{
++    V9fsFidState *fid;
++    fid = g_new0(V9fsFidState, 1);
++
++    fid->fid_type    = qemu_get_be32(f);
++    if (fid->fid_type == P9_FID_XATTR) {
++        virtio_9p_load_xattr(f, &fid->fs.xattr);
++    }
++    fid->fid         = qemu_get_be32(f);
++    virtio_9p_load_path(f, &fid->path);
++    fid->flags       = qemu_get_be32(f);
++    fid->open_flags  = qemu_get_be32(f);
++    fid->uid         = qemu_get_be32(f);
++    fid->ref         = qemu_get_be32(f);
++    fid->clunked     = qemu_get_be32(f);
++
++    /* If it's a file fid mark the file descriptors as closed.
++     * DIR is null thanks to g_new0.
++     * When doing get_fid v9fs_reopen_fid will reopen the file or the directory.
++     */
++    if (fid->fid_type == P9_FID_FILE) {
++        fid->fs.fd = -1;
++    }
++    return fid;
++}
++
++static int virtio_9p_load(QEMUFile *f, void *opaque, int version_id)
++{
++    int fidcount;
++    V9fsState *s = opaque;
++    V9fsFidState **fid;
++
++    if (version_id != 2) {
++        return -EINVAL;
++    }
++    virtio_load(VIRTIO_DEVICE(s), f, version_id);
++    fidcount = qemu_get_be32(f);
++
++    fid = &s->fid_list;
++    while (fidcount) {
++        *fid = virtio_9p_load_fid(f);
++        fid = &((*fid)->next);
++        fidcount--;
++    }
++
++    s->proto_version  = qemu_get_be32(f);
++    s->msize          = qemu_get_be32(f);
++
++    return 0;
++}
++
+ static uint32_t virtio_9p_get_features(VirtIODevice *vdev, uint32_t features)
+ {
+     features |= 1 << VIRTIO_9P_MOUNT_TAG;
+@@ -50,6 +193,7 @@ static void virtio_9p_device_realize(DeviceState *dev, Error **errp)
+     struct stat stat;
+     FsDriverEntry *fse;
+     V9fsPath path;
++    static int virtio_9p_id;
+ 
+     virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P,
+                 sizeof(struct virtio_9p_config) + MAX_TAG_LEN);
+@@ -98,6 +242,14 @@ static void virtio_9p_device_realize(DeviceState *dev, Error **errp)
+     s->ops = fse->ops;
+     s->config_size = sizeof(struct virtio_9p_config) + len;
+     s->fid_list = NULL;
++
++    /* Original patch says that instance id must be derived of tag
++     * name. Hash functions do have collisions so why would it be better
++     * than an increment ?
++     */
++    register_savevm(dev, "virtio-9p", virtio_9p_id++, 2,
++                    virtio_9p_save, virtio_9p_load, s);
++
+     qemu_co_rwlock_init(&s->rename_lock);
+ 
+     if (s->ops->init(&s->ctx) < 0) {
+diff --git a/hw/9pfs/virtio-9p.c b/hw/9pfs/virtio-9p.c
+index 5861a5b..2bf3c0a 100644
+--- a/hw/9pfs/virtio-9p.c
++++ b/hw/9pfs/virtio-9p.c
+@@ -332,19 +332,6 @@ static int put_fid(V9fsPDU *pdu, V9fsFidState *fidp)
+      * Don't free the fid if it is in reclaim list
+      */
+     if (!fidp->ref && fidp->clunked) {
+-        if (fidp->fid == pdu->s->root_fid) {
+-            /*
+-             * if the clunked fid is root fid then we
+-             * have unmounted the fs on the client side.
+-             * delete the migration blocker. Ideally, this
+-             * should be hooked to transport close notification
+-             */
+-            if (pdu->s->migration_blocker) {
+-                migrate_del_blocker(pdu->s->migration_blocker);
+-                error_free(pdu->s->migration_blocker);
+-                pdu->s->migration_blocker = NULL;
+-            }
+-        }
+         return free_fid(pdu, fidp);
+     }
+     return 0;
+@@ -979,17 +966,6 @@ static void v9fs_attach(void *opaque)
+     err += offset;
+     trace_v9fs_attach_return(pdu->tag, pdu->id,
+                              qid.type, qid.version, qid.path);
+-    /*
+-     * disable migration if we haven't done already.
+-     * attach could get called multiple times for the same export.
+-     */
+-    if (!s->migration_blocker) {
+-        s->root_fid = fid;
+-        error_setg(&s->migration_blocker,
+-                   "Migration is disabled when VirtFS export path '%s' is mounted in the guest using mount_tag '%s'",
+-                   s->ctx.fs_root ? s->ctx.fs_root : "NULL", s->tag);
+-        migrate_add_blocker(s->migration_blocker);
+-    }
+ out:
+     put_fid(pdu, fidp);
+ out_nofid:
+diff --git a/hw/9pfs/virtio-9p.h b/hw/9pfs/virtio-9p.h
+index 2c3603a..23f8eba 100644
+--- a/hw/9pfs/virtio-9p.h
++++ b/hw/9pfs/virtio-9p.h
+@@ -222,8 +222,6 @@ typedef struct V9fsState
+      * on rename.
+      */
+     CoRwlock rename_lock;
+-    int32_t root_fid;
+-    Error *migration_blocker;
+     V9fsConf fsconf;
+ } V9fsState;
+ 
diff -Naur qemu-2.1+dfsg.old/debian/patches/series qemu-2.1+dfsg/debian/patches/series
--- qemu-2.1+dfsg.old/debian/patches/series	2015-08-29 16:22:05.000000000 +0200
+++ qemu-2.1+dfsg/debian/patches/series	2015-09-13 18:44:36.285793677 +0200
@@ -76,3 +76,6 @@
 0005-rtl8139-check-IP-Total-Length-field-CVE-2015-5165.patch
 0006-rtl8139-skip-offload-on-short-TCP-header-CVE-2015-51.patch
 0007-rtl8139-check-TCP-Data-Offset-field-CVE-2015-5165.patch
+
+# Test
+qemu-9p-live-migration.patch
