diff --git a/net/Makefile.objs b/net/Makefile.objs
index 914aec0..5fa2f97 100644
--- a/net/Makefile.objs
+++ b/net/Makefile.objs
@@ -14,3 +14,4 @@ common-obj-$(CONFIG_SLIRP) += slirp.o
 common-obj-$(CONFIG_VDE) += vde.o
 common-obj-$(CONFIG_NETMAP) += netmap.o
 common-obj-y += filter.o
+common-obj-y += filter-buffer.o
diff --git a/net/filter-buffer.c b/net/filter-buffer.c
new file mode 100644
index 0000000..93f31c6
--- /dev/null
+++ b/net/filter-buffer.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2015 FUJITSU LIMITED
+ * Author: Yang Hongyang <yanghy@cn.fujitsu.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or
+ * later.  See the COPYING file in the top-level directory.
+ */
+
+#include "net/filter.h"
+#include "net/queue.h"
+#include "filters.h"
+#include "qemu-common.h"
+#include "qemu/timer.h"
+#include "qemu/iov.h"
+#include "qapi/qmp/qerror.h"
+
+typedef struct FilterBufferState {
+    NetFilterState nf;
+    NetQueue *incoming_queue;
+    uint32_t interval;
+    QEMUTimer release_timer;
+} FilterBufferState;
+
+static void filter_buffer_flush(NetFilterState *nf)
+{
+    FilterBufferState *s = DO_UPCAST(FilterBufferState, nf, nf);
+    NetQueue *queue = s->incoming_queue;
+    NetPacket *packet, *next;
+
+    QTAILQ_FOREACH_SAFE(packet, &queue->packets, entry, next) {
+        QTAILQ_REMOVE(&queue->packets, packet, entry);
+        queue->nq_count--;
+
+        if (packet->sender && packet->sender->peer) {
+            qemu_netfilter_pass_to_next(nf, packet);
+        }
+
+        /*
+         * now that we have passed the packet to next filter (or there's
+         * no receiver). If it's queued by receiver's incoming_queue, there
+         * will be a copy of the packet->data, so simply free this packet
+         * now.
+         */
+        g_free(packet);
+    }
+}
+
+static void filter_buffer_release_timer(void *opaque)
+{
+    FilterBufferState *s = opaque;
+    filter_buffer_flush(&s->nf);
+    timer_mod(&s->release_timer,
+              qemu_clock_get_us(QEMU_CLOCK_VIRTUAL) + s->interval);
+}
+
+/* filter APIs */
+static ssize_t filter_buffer_receive_iov(NetFilterState *nf,
+                                         NetClientState *sender,
+                                         unsigned flags,
+                                         const struct iovec *iov,
+                                         int iovcnt,
+                                         NetPacketSent *sent_cb)
+{
+    FilterBufferState *s = DO_UPCAST(FilterBufferState, nf, nf);
+    NetQueue *queue = s->incoming_queue;
+
+    qemu_net_queue_append_iov(queue, sender, flags, iov, iovcnt, sent_cb);
+    return iov_size(iov, iovcnt);
+}
+
+static void filter_buffer_cleanup(NetFilterState *nf)
+{
+    FilterBufferState *s = DO_UPCAST(FilterBufferState, nf, nf);
+
+    if (s->interval) {
+        timer_del(&s->release_timer);
+    }
+
+    /* flush packets */
+    filter_buffer_flush(nf);
+    g_free(s->incoming_queue);
+    return;
+}
+
+static NetFilterInfo net_filter_buffer_info = {
+    .type = NET_FILTER_TYPE_BUFFER,
+    .size = sizeof(FilterBufferState),
+    .receive_iov = filter_buffer_receive_iov,
+    .cleanup = filter_buffer_cleanup,
+};
+
+int net_init_filter_buffer(const NetFilter *netfilter, const char *name,
+                           int chain, NetClientState *netdev, Error **errp)
+{
+    NetFilterState *nf;
+    FilterBufferState *s;
+    const NetFilterBufferOptions *bufferopt;
+    int interval;
+
+    assert(netfilter->kind == NET_FILTER_TYPE_BUFFER);
+    bufferopt = netfilter->buffer;
+    interval = bufferopt->has_interval ? bufferopt->interval : 0;
+    /*
+     * this check should be dropped when there're VM FT solutions like MC
+     * or COLO use this filter to release packets on demand.
+     */
+    if (!interval) {
+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "interval",
+                   "a non-zero interval");
+        return -1;
+    }
+
+    nf = qemu_new_net_filter(&net_filter_buffer_info, netdev, name, chain);
+    s = DO_UPCAST(FilterBufferState, nf, nf);
+    s->incoming_queue = qemu_new_net_queue(nf);
+    s->interval = interval;
+    if (s->interval) {
+        timer_init_us(&s->release_timer, QEMU_CLOCK_VIRTUAL,
+                      filter_buffer_release_timer, s);
+        timer_mod(&s->release_timer,
+                  qemu_clock_get_us(QEMU_CLOCK_VIRTUAL) + s->interval);
+    }
+
+    return 0;
+}
diff --git a/net/filter.c b/net/filter.c
index 570813c..12d52e5 100644
--- a/net/filter.c
+++ b/net/filter.c
@@ -21,6 +21,7 @@
 #include "net/vhost_net.h"
 #include "filters.h"
 #include "net/queue.h"
+#include "filters.h"
 
 static QTAILQ_HEAD(, NetFilterState) net_filters;
 
@@ -214,7 +215,7 @@ typedef int (NetFilterInit)(const NetFilter *netfilter,
 
 static
 NetFilterInit * const net_filter_init_fun[NET_FILTER_TYPE_MAX] = {
-    [NET_FILTER_TYPE_DUMMY] = net_init_filter_dummy,
+    [NET_FILTER_TYPE_BUFFER] = net_init_filter_buffer,
 };
 
 static int net_filter_init1(const NetFilter *netfilter, Error **errp)
diff --git a/net/filters.h b/net/filters.h
index 7c1f30d..8dd9970 100644
--- a/net/filters.h
+++ b/net/filters.h
@@ -11,13 +11,7 @@
 #include "net/net.h"
 #include "net/filter.h"
 
-int net_init_filter_dummy(const NetFilter *netfilter, const char *name,
-                          int chain, NetClientState *netdev, Error **errp);
-
-int net_init_filter_dummy(const NetFilter *netfilter, const char *name,
-                          int chain, NetClientState *netdev, Error **errp)
-{
-    return 0;
-}
+int net_init_filter_buffer(const NetFilter *netfilter, const char *name,
+                           int chain, NetClientState *netdev, Error **errp);
 
 #endif /* QEMU_NET_FILTERS_H */
diff --git a/qapi-schema.json b/qapi-schema.json
index d961ac8..0e8dc17 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -2566,14 +2566,20 @@
 { 'command': 'netfilter-del', 'data': {'id': 'str'} }
 
 ##
-# @NetFilterDummyOptions:
+# @NetFilterBufferOptions
 #
-# An dummy filter for network backend
+# a netbuffer filter for network backend.
 #
-# Since: 2.5
+# @interval: #optional release packets by interval, if no interval supplied,
+#            packets will be buffered forever unless internal APIs been called
+#            to release the packets or filter been removed. Use with caution.
+#            scale: microsecond
+#
+# Since 2.5
 ##
-{ 'struct': 'NetFilterDummyOptions',
-  'data': { } }
+{ 'struct': 'NetFilterBufferOptions',
+  'data': {
+    '*interval':     'uint32' } }
 
 ##
 # @NetFilterType:
@@ -2583,7 +2589,7 @@
 # Since: 2.5
 ##
 { 'enum': 'NetFilterType',
-  'data': ['dummy'] }
+  'data': ['buffer'] }
 
 ##
 # @NetFilterBase
@@ -2623,7 +2629,7 @@
   'base': 'NetFilterBase',
   'discriminator': 'type',
   'data': {
-    'dummy': 'NetFilterDummyOptions' } }
+    'buffer': 'NetFilterBufferOptions' } }
 
 ##
 # @InetSocketAddress
