diff --git a/arch_init.c b/arch_init.c
index dada6de..7633fa6 100644
--- a/arch_init.c
+++ b/arch_init.c
@@ -42,6 +42,7 @@
 #include "migration/migration.h"
 #include "exec/gdbstub.h"
 #include "hw/smbios.h"
+#include "qemu/rdma.h"
 #include "exec/address-spaces.h"
 #include "hw/pcspk.h"
 #include "migration/page_cache.h"
@@ -113,6 +114,7 @@ const uint32_t arch_type = QEMU_ARCH;
 #define RAM_SAVE_FLAG_EOS      0x10
 #define RAM_SAVE_FLAG_CONTINUE 0x20
 #define RAM_SAVE_FLAG_XBZRLE   0x40
+#define RAM_SAVE_FLAG_RDMA     0x80
 
 #ifdef __ALTIVEC__
 #include <altivec.h>
@@ -434,6 +436,7 @@ static int ram_save_block(QEMUFile *f, bool last_stage)
     int bytes_sent = 0;
     MemoryRegion *mr;
     ram_addr_t current_addr;
+    static int not_sent = 1;
 
     if (!block)
         block = QTAILQ_FIRST(&ram_list.blocks);
@@ -457,23 +460,75 @@ static int ram_save_block(QEMUFile *f, bool last_stage)
             int cont = (block == last_sent_block) ?
                 RAM_SAVE_FLAG_CONTINUE : 0;
 
+            current_addr = block->offset + offset;
             p = memory_region_get_ram_ptr(mr) + offset;
 
             /* In doubt sent page as normal */
             bytes_sent = -1;
-            if (is_dup_page(p)) {
+
+            /*
+             * RFC RDMA: The empirical cost of searching for zero pages here
+             *           plus the cost of communicating with the other side
+             *           seems to take significantly more time than simply
+             *           dumping the page into remote memory.
+             */
+            if (!qemu_rdma_migration_enabled() && is_dup_page(p)) {
                 acct_info.dup_pages++;
                 bytes_sent = save_block_hdr(f, block, offset, cont,
                                             RAM_SAVE_FLAG_COMPRESS);
                 qemu_put_byte(f, *p);
                 bytes_sent += 1;
+            /*
+             * RFC RDMA: Same comment as above. time(run-length encoding)
+             *           + time(communication) is too big. RDMA throughput tanks
+             *           when this feature is enabled. But there's no need
+             *           to change the code since the feature is optional.
+             */
             } else if (migrate_use_xbzrle()) {
-                current_addr = block->offset + offset;
                 bytes_sent = save_xbzrle_page(f, p, current_addr, block,
                                               offset, cont, last_stage);
                 if (!last_stage) {
                     p = get_cached_data(XBZRLE.cache, current_addr);
                 }
+            } else if (qemu_rdma_migration_enabled()) {
+                int ret;
+
+                /*
+                 * RFC RDMA: This bad hack was to cause the loop on the
+                 *           receiving side to break. Comments are welcome
+                 *           on how to get rid of it.
+                 */
+                if (not_sent == 1) {
+                        not_sent = 0;
+                        bytes_sent = save_block_hdr(f, block, offset,
+                                                cont, RAM_SAVE_FLAG_RDMA);
+                }
+                acct_info.norm_pages++;
+                /*
+                 * use RDMA to send page
+                 */
+                if (qemu_rdma_migration_write(&rdma_mdata, current_addr,
+                        TARGET_PAGE_SIZE)) {
+                    fprintf(stderr, "rdma migration: write error!\n");
+                    qemu_file_set_error(f, -EIO);
+                    return 0;
+                }
+
+                /*
+                 * do some polling
+                 */
+                while (1) {
+                    ret = qemu_rdma_migration_poll(&rdma_mdata);
+                    if (ret == QEMU_RDMA_MIGRATION_WRID_NONE) {
+                        break;
+                    }
+                    if (ret < 0) {
+                        fprintf(stderr, "rdma migration: polling error!\n");
+                        qemu_file_set_error(f, -EIO);
+                        return 0;
+                    }
+                }
+                bytes_sent += TARGET_PAGE_SIZE;
             }
 
             /* XBZRLE overflow or normal page */
@@ -601,12 +656,15 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
     return 0;
 }
 
+
+int tprate = 1000;
+
 static int ram_save_iterate(QEMUFile *f, void *opaque)
 {
     int ret;
     int i;
-    int64_t t0;
-    int total_sent = 0;
+    int64_t t0, tp0;
+    int total_sent = 0, last_total_sent = 0;
 
     qemu_mutex_lock_ramlist();
 
@@ -625,23 +683,55 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
             break;
         }
         total_sent += bytes_sent;
+        last_total_sent += bytes_sent;
         acct_info.iterations++;
         /* we want to check in the 1st loop, just in case it was the 1st time
            and we had to sync the dirty bitmap.
            qemu_get_clock_ns() is a bit expensive, so we only check each some
            iterations
         */
+
+        /*
+         * RFC RDMA: Can we have something like this to periodically print
+         * out throughput.
+         * This is just a rough-sketch that partially worked for me.
+         * I assume there a better way that everyone would prefer.
+         * Perhaps we could set a QMP command that toggled a "periodic printing"
+         * option that allowed more details to be printed on stdout.....?
+         */
         if ((i & 63) == 0) {
-            uint64_t t1 = (qemu_get_clock_ns(rt_clock) - t0) / 1000000;
+            uint64_t curr = qemu_get_clock_ns(rt_clock);
+            uint64_t t1 = (curr - t0) / 1000000;
+            double tp;
             if (t1 > MAX_WAIT) {
                 DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
                         t1, i);
                 break;
             }
+
+            if ((i % tprate) == 0) {
+                uint64_t tp1 = (curr - tp0) / 1000000;
+                tp = ((double) last_total_sent * 8.0 /
+                               ((double) tp1 / 1000.0)) / 1000.0 / 1000.0;
+                printf("throughput: %f mbps\n", tp);
+                last_total_sent = 0;
+                tp0 = curr;
+            }
         }
         i++;
     }
 
+    /* flush buffer write */
+    if (qemu_rdma_migration_enabled()) {
+        int resp;
+        resp = qemu_rdma_migration_write_flush(&rdma_mdata);
+        if (resp < 0) {
+            fprintf(stderr, "rdma migration: write flush error!\n");
+            qemu_file_set_error(f, -EIO);
+            return 0;
+        }
+    }
+
     qemu_mutex_unlock_ramlist();
 
     if (ret < 0) {
@@ -863,6 +953,22 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)
                 ret = -EINVAL;
                 goto done;
             }
+        } else if (flags & RAM_SAVE_FLAG_RDMA) {
+            /*
+             * RFC RDMA: This bad hack was to cause the loop break.
+             *           Comments are welcome on how to get rid of it.
+             *           Communicating here is unnecessary because the
+             *           RDMA page has already arrived.
+             *           Comments are welcome on how to get rif of this.
+             */
+            if (!qemu_rdma_migration_enabled()) {
+                return -EINVAL;
+            }
+            void *host = host_from_stream_offset(f, addr, flags);
+            if (!host) {
+                return -EINVAL;
+            }
+            /* rdma page is already here, nothing to do */
         }
         error = qemu_file_get_error(f);
         if (error) {
diff --git a/include/migration/qemu-file.h b/include/migration/qemu-file.h
index 68deefb..7c9968e 100644
--- a/include/migration/qemu-file.h
+++ b/include/migration/qemu-file.h
@@ -112,6 +112,7 @@ int qemu_file_rate_limit(QEMUFile *f);
 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate);
 int64_t qemu_file_get_rate_limit(QEMUFile *f);
 int qemu_file_get_error(QEMUFile *f);
+void qemu_file_set_error(QEMUFile *f, int ret);
 
 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
 {
diff --git a/savevm.c b/savevm.c
index 304d1ef..071196e 100644
--- a/savevm.c
+++ b/savevm.c
@@ -24,6 +24,7 @@
 
 #include "config-host.h"
 #include "qemu-common.h"
+#include "qemu/rdma.h"
 #include "hw/hw.h"
 #include "hw/qdev.h"
 #include "net/net.h"
@@ -50,7 +51,7 @@
 #define ARP_OP_REQUEST_REV 0x3
 
 static int announce_self_create(uint8_t *buf,
-				uint8_t *mac_addr)
+                                uint8_t *mac_addr)
 {
     /* Ethernet header. */
     memset(buf, 0xff, 6);         /* destination MAC addr */
@@ -97,16 +98,16 @@ static void qemu_announce_self_once(void *opaque)
         qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
                        50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
     } else {
-	    qemu_del_timer(timer);
-	    qemu_free_timer(timer);
+            qemu_del_timer(timer);
+            qemu_free_timer(timer);
     }
 }
 
 void qemu_announce_self(void)
 {
-	static QEMUTimer *timer;
-	timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
-	qemu_announce_self_once(&timer);
+        static QEMUTimer *timer;
+        timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
+        qemu_announce_self_once(&timer);
 }
 
 /***********************************************************/
@@ -299,8 +300,8 @@ QEMUFile *qemu_fdopen(int fd, const char *mode)
     QEMUFileStdio *s;
 
     if (mode == NULL ||
-	(mode[0] != 'r' && mode[0] != 'w') ||
-	mode[1] != 'b' || mode[2] != 0) {
+        (mode[0] != 'r' && mode[0] != 'w') ||
+        mode[1] != 'b' || mode[2] != 0) {
         fprintf(stderr, "qemu_fdopen: Argument validity check failed\n");
         return NULL;
     }
@@ -342,8 +343,8 @@ QEMUFile *qemu_fopen(const char *filename, const char *mode)
     QEMUFileStdio *s;
 
     if (mode == NULL ||
-	(mode[0] != 'r' && mode[0] != 'w') ||
-	mode[1] != 'b' || mode[2] != 0) {
+        (mode[0] != 'r' && mode[0] != 'w') ||
+        mode[1] != 'b' || mode[2] != 0) {
         fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
         return NULL;
     }
@@ -417,7 +418,7 @@ int qemu_file_get_error(QEMUFile *f)
     return f->last_error;
 }
 
-static void qemu_file_set_error(QEMUFile *f, int ret)
+void qemu_file_set_error(QEMUFile *f, int ret)
 {
     if (f->last_error == 0) {
         f->last_error = ret;
@@ -1613,6 +1614,7 @@ int qemu_savevm_state_iterate(QEMUFile *f)
 {
     SaveStateEntry *se;
     int ret = 1;
+    static int first_time = 1;
 
     QTAILQ_FOREACH(se, &savevm_handlers, entry) {
         if (!se->ops || !se->ops->save_live_iterate) {
@@ -1643,8 +1645,36 @@ int qemu_savevm_state_iterate(QEMUFile *f)
         }
     }
     if (ret != 0) {
+#ifdef QEMU_RDMA_MIGRATION_EXTRA_SYNC
+        /*
+         * We use two "sync" infiniband messages happen during migration.
+         * One at the beginning and one at the end, just to be thorough.
+         * This is the first one.
+         */
+        if (first_time && qemu_rdma_migration_enabled()) {
+            int r;
+            first_time = 0;
+            if (qemu_rdma_migration_post_send_sync(&rdma_mdata,
+                        QEMU_RDMA_MIGRATION_WRID_SEND_EXTRA_SYNC)) {
+                fprintf(stderr,
+                        "rdma migration: error posting extra send sync!\n");
+                return -EIO;
+            }
+
+            r = qemu_rdma_migration_wait_for_wrid(&rdma_mdata,
+                        QEMU_RDMA_MIGRATION_WRID_SEND_EXTRA_SYNC);
+            if (r < 0) {
+                fprintf(stderr,
+                        "rdma migration: qemu_savevm_state_iterate"
+                        " sync polling error!\n");
+                return -EIO;
+            }
+        }
+#endif
+
         return ret;
     }
+
     ret = qemu_file_get_error(f);
     if (ret != 0) {
         qemu_savevm_state_cancel();
@@ -1684,7 +1714,7 @@ int qemu_savevm_state_complete(QEMUFile *f)
         int len;
 
         if ((!se->ops || !se->ops->save_state) && !se->vmsd) {
-	    continue;
+            continue;
         }
         trace_savevm_section_start();
         /* Section type */
@@ -1703,8 +1733,32 @@ int qemu_savevm_state_complete(QEMUFile *f)
         trace_savevm_section_end(se->section_id);
     }
 
+    /*
+     * We use two "sync" infiniband messages happen during migration.
+     * One at the beginning and one at the end, just to be thorough.
+     * This is the second one.
+     */
+    if (qemu_rdma_migration_enabled()) {
+        if (qemu_rdma_migration_post_send_sync(&rdma_mdata,
+                    QEMU_RDMA_MIGRATION_WRID_SEND_SYNC)) {
+            fprintf(stderr, "rdma migration: error posting send sync!\n");
+            return -EIO;
+        }
+    }
+
     qemu_put_byte(f, QEMU_VM_EOF);
 
+    /* wait for RDMA sync message to complete */
+    if (qemu_rdma_migration_enabled()) {
+        int ret = qemu_rdma_migration_wait_for_wrid(&rdma_mdata,
+                QEMU_RDMA_MIGRATION_WRID_SEND_SYNC);
+        if (ret < 0) {
+            fprintf(stderr, "rdma migration: qemu_savevm_state_full"
+                            " sync polling error!\n");
+            return -EIO;
+        }
+     }
+
     return qemu_file_get_error(f);
 }
 
@@ -2014,8 +2068,18 @@ int qemu_loadvm_state(QEMUFile *f)
 
     cpu_synchronize_all_post_init();
 
-    ret = 0;
+    /* wait for RDMA sync message */
+    if (qemu_rdma_migration_enabled()) {
+        ret = qemu_rdma_migration_wait_for_wrid(&rdma_mdata,
+                QEMU_RDMA_MIGRATION_WRID_RECV_SYNC);
+        if (ret < 0) {
+            fprintf(stderr, "rdma migration: qemu_loadvm_state_no_header"
+                            " sync polling error!\n");
+            goto out;
+        }
+    }
 
+    ret = 0;
 out:
     QLIST_FOREACH_SAFE(le, &loadvm_handlers, entry, new_le) {
         QLIST_REMOVE(le, entry);
