diff --git a/lib/ioctl_wrappers.c b/lib/ioctl_wrappers.c
index ff78ef1..2bd341a 100644
--- a/lib/ioctl_wrappers.c
+++ b/lib/ioctl_wrappers.c
@@ -379,6 +379,66 @@ void gem_sync(int fd, uint32_t handle)
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 }
 
+bool gem_create__has_stolen_support(int fd)
+{
+	static int has_stolen_support = -1;
+	struct drm_i915_getparam gp;
+	int val = -1;
+
+	return 1;
+	if (has_stolen_support < 0) {
+		memset(&gp, 0, sizeof(gp));
+		gp.param = 35; /* CREATE_VERSION */
+		gp.value = &val;
+
+		/* Do we have the extended gem_create_ioctl? */
+		ioctl(fd, DRM_IOCTL_I915_GETPARAM, &gp);
+		has_stolen_support = val >= 1;
+	}
+
+	return has_stolen_support;
+}
+
+struct local_i915_gem_create_v2 {
+	uint64_t size;
+	uint32_t handle;
+	uint32_t pad;
+#define I915_CREATE_PLACEMENT_STOLEN (1<<0)
+	uint32_t flags;
+};
+
+#define LOCAL_IOCTL_I915_GEM_CREATE       DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_CREATE, struct local_i915_gem_create_v2)
+/**
+ * gem_create_stolen:
+ * @fd: open i915 drm file descriptor
+ * @size: desired size of the buffer
+ * @flags: desired placement i.e. stolen or shmem
+ *
+ * This wraps the new GEM_CREATE ioctl, which allocates a
+ * new gem buffer object of @size and placement based on @flags.
+ *
+ * Returns: The file-private handle of the created buffer object
+ */
+
+uint32_t gem_create_stolen(int fd, int size)
+{
+	struct local_i915_gem_create_v2 create;
+	int ret;
+
+	memset(&create, 0, sizeof(create));
+	create.handle = 0;
+	create.size = size;
+	create.flags = I915_CREATE_PLACEMENT_STOLEN;
+	ret = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_CREATE, &create);
+
+	if (ret < 0)
+		return 0;
+
+	errno = 0;
+	return create.handle;
+}
+
+
 uint32_t __gem_create(int fd, int size)
 {
 	struct drm_i915_gem_create create;
diff --git a/lib/ioctl_wrappers.h b/lib/ioctl_wrappers.h
index ced7ef3..cac1c11 100644
--- a/lib/ioctl_wrappers.h
+++ b/lib/ioctl_wrappers.h
@@ -56,6 +56,9 @@ void gem_read(int fd, uint32_t handle, uint32_t offset, void *buf, uint32_t leng
 void gem_set_domain(int fd, uint32_t handle,
 		    uint32_t read_domains, uint32_t write_domain);
 void gem_sync(int fd, uint32_t handle);
+
+bool gem_create__has_stolen_support(int fd);
+uint32_t gem_create_stolen(int fd, int size);
 uint32_t __gem_create(int fd, int size);
 uint32_t gem_create(int fd, int size);
 void gem_execbuf(int fd, struct drm_i915_gem_execbuffer2 *execbuf);
@@ -67,6 +70,15 @@ bool gem_mmap__has_wc(int fd);
 void *gem_mmap__wc(int fd, uint32_t handle, int offset, int size, int prot);
 
 /**
+ * gem_require_stolen_support:
+ * @fd: open i915 drm file descriptor
+ *
+ * Test macro to query whether support for allocating objects from stolen
+ * memory is available. Automatically skips through igt_require() if not.
+ */
+#define gem_require_stolen_support(fd) \
+			igt_require(gem_create__has_stolen_support(fd))
+/**
  * gem_require_mmap_wc:
  * @fd: open i915 drm file descriptor
  *
diff --git a/tests/Makefile.sources b/tests/Makefile.sources
index a165978..9b2ee90 100644
--- a/tests/Makefile.sources
+++ b/tests/Makefile.sources
@@ -23,6 +23,7 @@ TESTS_progs_M = \
 	gem_caching \
 	gem_close_race \
 	gem_concurrent_blit \
+	gem_create_stolen \
 	gem_cs_tlb \
 	gem_ctx_param_basic \
 	gem_ctx_bad_exec \
diff --git a/tests/gem_create_stolen.c b/tests/gem_create_stolen.c
new file mode 100644
index 0000000..402d42b
--- /dev/null
+++ b/tests/gem_create_stolen.c
@@ -0,0 +1,387 @@
+/*
+ * Copyright © 2011 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ *
+ * Authors:
+ *    Ankitprasad Sharma <ankitprasad.r.sharma@intel.com>
+ *
+ */
+
+/** @file gem_create_stolen.c
+ *
+ * This is a test for the extended gem_create ioctl, that includes allocation
+ * of object from stolen memory
+ *
+ * The goal is to simply ensure the basics work, and invalid input combinations
+ * are rejected.
+ */
+
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <getopt.h>
+
+#include <drm.h>
+
+#include "ioctl_wrappers.h"
+#include "intel_bufmgr.h"
+#include "intel_batchbuffer.h"
+#include "intel_io.h"
+#include "intel_chipset.h"
+#include "igt_aux.h"
+#include "drmtest.h"
+#include "drm.h"
+#include "i915_drm.h"
+
+#define CLEAR(s) memset(&s, 0, sizeof(s))
+#define SIZE 1024*1024
+
+static struct drm_intel_bufmgr *bufmgr;
+static struct intel_batchbuffer *batch;
+
+static void verify_copy_op(drm_intel_bo *src, drm_intel_bo *dest)
+{
+	uint32_t *virt, i, ret;
+	/* Fill the src BO with dwords */
+	ret = drm_intel_gem_bo_map_gtt(src);
+	igt_assert(!ret);
+
+	virt = src->virtual;
+	for (i = 0; i < SIZE/4; i++)
+		virt[i] = i;
+
+	intel_copy_bo(batch, dest, src, SIZE);
+
+	ret = drm_intel_gem_bo_map_gtt(dest);
+	igt_assert(!ret);
+
+	virt = dest->virtual;
+	/* verify */
+	for (i = 0; i < SIZE/4; i++) {
+		if (virt[i] != i) {
+			fprintf(stderr, "Expected 0x%08x, found 0x%08x "
+					"at offset 0x%08x\n",
+					i, virt[i], i * 4);
+			igt_assert(virt[i] == i);
+		}
+	}
+
+	drm_intel_bo_unmap(src);
+	drm_intel_bo_unmap(dest);
+}
+
+static void stolen_pwrite(int fd)
+{
+	drm_intel_bo *bo;
+	uint32_t buf[SIZE/4];
+	uint32_t handle = 0;
+	uint32_t *virt;
+	int i, ret = 0;
+
+	for (i = 0; i < SIZE/4; i ++)
+		buf[i] = 0xdead;
+
+	gem_require_stolen_support(fd);
+
+	handle = gem_create_stolen(fd, SIZE);
+	igt_assert(handle != 0);
+
+	gem_write(fd, handle, 0, buf, SIZE);
+	bo = gem_handle_to_libdrm_bo(bufmgr, fd, "bo", handle);
+
+	ret = drm_intel_gem_bo_map_gtt(bo);
+	igt_assert(!ret);
+
+	virt = bo->virtual;
+
+	for (i = 0; i < SIZE/4; i ++)
+		igt_assert(virt[i] == 0xdead);
+
+	drm_intel_bo_unmap(bo);
+	drm_intel_bo_unreference(bo);
+	gem_close(fd, handle);
+}
+
+static void stolen_pread(int fd)
+{
+	drm_intel_bo *bo;
+	uint32_t buf[SIZE/4];
+	uint32_t handle = 0;
+	uint32_t *virt;
+	int i, ret = 0;
+
+	CLEAR(buf);
+
+	gem_require_stolen_support(fd);
+
+	handle = gem_create_stolen(fd, SIZE);
+	igt_assert(handle != 0);
+
+	bo = gem_handle_to_libdrm_bo(bufmgr, fd, "bo", handle);
+
+	ret = drm_intel_gem_bo_map_gtt(bo);
+	igt_assert(!ret);
+
+	virt = bo->virtual;
+
+	for (i = 0; i < SIZE/4; i ++)
+		virt[i] = 0xdead;
+
+	drm_intel_bo_unmap(bo);
+	drm_intel_bo_unreference(bo);
+
+	gem_read(fd, handle, 0, buf, SIZE);
+
+	for (i = 0; i < SIZE/4; i ++)
+		igt_assert(buf[i] == 0xdead);
+
+	gem_close(fd, handle);
+}
+
+static void copy_test(int fd)
+{
+	drm_intel_bo *src, *dest;
+	uint32_t src_handle = 0, dest_handle = 0;
+	int ret = 0;
+
+	gem_require_stolen_support(fd);
+
+	src_handle = gem_create_stolen(fd, SIZE);
+	igt_assert(src_handle != 0);
+
+	dest_handle = gem_create_stolen(fd, SIZE);
+	igt_assert(dest_handle != 0);
+
+	src = gem_handle_to_libdrm_bo(bufmgr, fd, "src_bo", src_handle);
+	dest = gem_handle_to_libdrm_bo(bufmgr, fd, "dst_bo", dest_handle);
+
+	igt_assert(src != NULL);
+	igt_assert(dest != NULL);
+
+	verify_copy_op(src, dest);
+
+	drm_intel_bo_unreference(src);
+	drm_intel_bo_unreference(dest);
+	gem_close(fd, src_handle);
+	gem_close(fd, dest_handle);
+}
+
+static void verify_object_clear(int fd)
+{
+	drm_intel_bo *bo;
+	uint32_t handle = 0;
+	uint32_t *virt;
+	int i, ret = 0;
+
+	gem_require_stolen_support(fd);
+
+	handle = gem_create_stolen(fd, SIZE);
+	igt_assert(handle != 0);
+
+	bo = gem_handle_to_libdrm_bo(bufmgr, fd, "verify_bo", handle);
+	igt_assert(bo != NULL);
+
+	ret = drm_intel_gem_bo_map_gtt(bo);
+	igt_assert(ret == 0);
+
+	/* Verify if the BO is zeroed */
+	virt = bo->virtual;
+	for (i = 0; i < SIZE / 4; i++)
+		igt_assert(virt[i] == 0);
+
+	drm_intel_bo_unmap(bo);
+	drm_intel_bo_unreference(bo);
+	gem_close(fd, handle);
+}
+
+static void stolen_fill_purge_test(int fd)
+{
+	drm_intel_bo *bo;
+	int mret = 0, ret = 0, obj_count = 0, i = 0;
+	int _ret = 0, j = 0;
+	uint32_t handle[100] = {0};
+	uint32_t new_handle = 0;
+	uint32_t *virt;
+	int retained = 0;
+
+	gem_require_stolen_support(fd);
+
+	/* Exhaust Stolen space */
+	while(ret == 0) {
+		ret = -1;
+		handle[i] = gem_create_stolen(fd, SIZE);
+		if (handle[i] != 0) {
+			ret = 0;
+			bo = gem_handle_to_libdrm_bo(bufmgr, fd,
+						     "verify_bo", handle[i]);
+			igt_assert(bo != NULL);
+
+			_ret = drm_intel_gem_bo_map_gtt(bo);
+			igt_assert(_ret == 0);
+
+			virt = bo->virtual;
+			for (j = 0; j < SIZE / 4; j++)
+				virt[j] = 0xab;
+
+			drm_intel_bo_unmap(bo);
+			drm_intel_bo_unreference(bo);
+
+			obj_count++;
+		}
+
+		i++;
+	}
+
+	igt_assert(obj_count > 0);
+
+	/* Mark all stolen objects purgeable */
+	for (i = 0; i < obj_count; i++)
+		retained = gem_madvise(fd, handle[i], I915_MADV_DONTNEED);
+
+	/* Try to allocate one more object */
+	new_handle = gem_create_stolen(fd, SIZE);
+	igt_assert(new_handle != 0);
+
+	/* Check if the retained object's memory contents are intact */
+	for (i = 0; i < obj_count; i++) {
+		retained = gem_madvise(fd, handle[i], I915_MADV_WILLNEED);
+		if (retained) {
+			bo = gem_handle_to_libdrm_bo(bufmgr, fd,
+						     "verify_bo", handle[i]);
+			igt_assert(bo != NULL);
+
+			_ret = drm_intel_gem_bo_map_gtt(bo);
+			igt_assert(_ret == 0);
+
+			virt = bo->virtual;
+			for (j = 0; j < SIZE / 4; j++)
+				igt_assert(virt[j] == 0xab);
+
+			drm_intel_bo_unmap(bo);
+			drm_intel_bo_unreference(bo);
+		}
+	}
+
+	gem_close(fd, new_handle);
+	for (i = 0; i < obj_count; i++)
+		gem_close(fd, handle[i]);
+}
+
+static void
+stolen_no_mmap(int fd)
+{
+	void *addr;
+	uint32_t handle = 0;
+
+	gem_require_stolen_support(fd);
+
+	handle = gem_create_stolen(fd, SIZE);
+	igt_assert(handle != 0);
+
+	addr = gem_mmap__cpu(fd, handle, 0, SIZE, PROT_READ | PROT_WRITE);
+	igt_assert(addr == NULL);
+
+	gem_close(fd, handle);
+}
+
+static void invalid_flag_test(int fd)
+{
+	int handle = 0;
+
+struct local_i915_gem_create_v2 {
+	uint64_t size;
+	uint32_t handle;
+	uint32_t pad;
+#define I915_CREATE_PLACEMENT_STOLEN (1<<0)
+	uint32_t flags;
+} create;
+
+#define LOCAL_IOCTL_I915_GEM_CREATE       DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_CREATE, struct local_i915_gem_create_v2)
+	gem_require_stolen_support(fd);
+
+	create.handle = 0;
+	create.size = SIZE;
+	create.flags = ~I915_CREATE_PLACEMENT_STOLEN;
+	handle = drmIoctl(fd, LOCAL_IOCTL_I915_GEM_CREATE, &create);
+
+	igt_assert(handle <= 0);
+}
+
+igt_main
+{
+	int i, fd, gtt_size_total, gtt_size_mappable;
+	uint32_t devid;
+
+	igt_skip_on_simulation();
+
+	igt_fixture {
+		fd = drm_open_any();
+		devid = intel_get_drm_devid(fd);
+
+		drm_intel_get_aperture_sizes(fd, (size_t*)&gtt_size_total,
+				(size_t*)&gtt_size_mappable);
+		bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
+		batch = intel_batchbuffer_alloc(bufmgr, devid);
+	}
+
+	igt_subtest("stolen-invalid-flag")
+		invalid_flag_test(fd);
+
+	igt_subtest("stolen-clear")
+		verify_object_clear(fd);
+
+	/*
+	 * stolen mem special cases - checking for non cpu mappable
+	 */
+	igt_subtest("stolen-no-mmap")
+		stolen_no_mmap(fd);
+
+	/* checking for pread/pwrite interfaces */
+	igt_subtest("stolen-pwrite")
+		stolen_pwrite(fd);
+
+	igt_subtest("stolen-pread")
+		stolen_pread(fd);
+
+	/* Functional Test - blt copy */
+	igt_subtest("stolen-copy")
+		copy_test(fd);
+
+	/* Filling stolen completely and marking all the objects
+	 * purgeable. Then trying to add one more object, to verify
+	 * the purging logic.
+	 * Again marking all objects WILLNEED and verifying the
+	 * contents of the retained objects.
+	 */
+	igt_subtest("stolen-fill-purge")
+		stolen_fill_purge_test(fd);
+
+	igt_fixture {
+		intel_batchbuffer_free(batch);
+		drm_intel_bufmgr_destroy(bufmgr);
+	}
+}
diff --git a/tests/gem_pread.c b/tests/gem_pread.c
index cc83948..95162d5 100644
--- a/tests/gem_pread.c
+++ b/tests/gem_pread.c
@@ -41,6 +41,10 @@
 #include "drmtest.h"
 
 #define OBJECT_SIZE 16384
+#define LARGE_OBJECT_SIZE 1024 * 1024
+#define KGRN "\x1B[32m"
+#define KRED "\x1B[31m"
+#define KNRM "\x1B[0m"
 
 static void do_gem_read(int fd, uint32_t handle, void *buf, int len, int loops)
 {
@@ -76,11 +80,14 @@ static const char *bytes_per_sec(char *buf, double v)
 
 
 uint32_t *src, dst;
+uint32_t *dst_user, src_stolen, large_stolen;
+uint32_t *stolen_pf_user, *stolen_nopf_user;
 int fd, count;
 
 int main(int argc, char **argv)
 {
 	int object_size = 0;
+	int large_obj_size = LARGE_OBJECT_SIZE;
 	uint32_t buf[20];
 	const struct {
 		int level;
@@ -90,6 +97,9 @@ int main(int argc, char **argv)
 		{ 1, "snoop" },
 		{ 2, "display" },
 		{ -1 },
+		{ -1, "stolen-uncached"},
+		{ -1, "stolen-snoop"},
+		{ -1, "stolen-display"},
 	}, *c;
 
 	igt_subtest_init(argc, argv);
@@ -106,6 +116,8 @@ int main(int argc, char **argv)
 
 		dst = gem_create(fd, object_size);
 		src = malloc(object_size);
+		src_stolen = gem_create_stolen(fd, object_size);
+		dst_user = malloc(object_size);
 	}
 
 	igt_subtest("normal") {
@@ -142,9 +154,97 @@ int main(int argc, char **argv)
 		}
 	}
 
+	igt_subtest("stolen-normal") {
+		for (count = 1; count <= 1<<17; count <<= 1) {
+			struct timeval start, end;
+
+			gettimeofday(&start, NULL);
+			do_gem_read(fd, src_stolen, dst_user, object_size, count);
+			gettimeofday(&end, NULL);
+			igt_info("Time to pread %d bytes x %6d:	%7.3fµs, %s\n",
+				 object_size, count,
+				 elapsed(&start, &end, count),
+				 bytes_per_sec((char *)buf,
+				 object_size/elapsed(&start, &end, count)*1e6));
+			fflush(stdout);
+		}
+	}
+	for (c = cache; c->level != -1; c++) {
+		igt_subtest((c + 4)->name) {
+			gem_set_caching(fd, src_stolen, c->level);
+
+			for (count = 1; count <= 1<<17; count <<= 1) {
+				struct timeval start, end;
+
+				gettimeofday(&start, NULL);
+				do_gem_read(fd, src_stolen, dst_user,
+					    object_size, count);
+				gettimeofday(&end, NULL);
+				igt_info("Time to %s pread %d bytes x %6d:      %7.3fµs, %s\n",
+					 (c + 4)->name, object_size, count,
+					 elapsed(&start, &end, count),
+					 bytes_per_sec((char *)buf,
+					 object_size/elapsed(&start, &end, count)*1e6));
+				fflush(stdout);
+			}
+		}
+	}
+
+	/* List pread times for stolen area with 1 page fault (page fault only
+	 * first time) and multiple page faults (unmapping the pages at the
+	 * end of each iteration)
+	 */
+	igt_subtest("pagefault-pread") {
+		large_stolen = gem_create_stolen(fd, large_obj_size);
+		stolen_nopf_user = (uint32_t *) mmap(NULL, large_obj_size,
+						PROT_WRITE,
+						MAP_ANONYMOUS|MAP_PRIVATE,
+						-1, 0);
+
+		for (count = 1; count <= 10; count ++) {
+			struct timeval start, end;
+			uint32_t t_elapsed = 0;
+
+			gettimeofday(&start, NULL);
+			do_gem_read(fd, large_stolen, stolen_nopf_user,
+				    large_obj_size, 1);
+			gettimeofday(&end, NULL);
+			t_elapsed = elapsed(&start, &end, 1);
+			igt_info("Pagefault-N - Time to pread %d bytes: %7.3fµs, %s\n",
+				 large_obj_size,
+				 elapsed(&start, &end, 1),
+				 bytes_per_sec((char *)buf,
+				 large_obj_size/elapsed(&start, &end, 1)*1e6));
+
+			stolen_pf_user = (uint32_t *) mmap(NULL, large_obj_size,
+						      PROT_WRITE,
+						      MAP_ANONYMOUS|MAP_PRIVATE,
+						      -1, 0);
+
+			gettimeofday(&start, NULL);
+			do_gem_read(fd, large_stolen, stolen_pf_user,
+				    large_obj_size, 1);
+			gettimeofday(&end, NULL);
+			igt_info("Pagefault-Y - Time to pread %d bytes: %7.3fµs, %s%s%s\n",
+				 large_obj_size,
+				 elapsed(&start, &end, 1),
+				 t_elapsed < elapsed(&start, &end, 1) ? KGRN : KRED,
+				 bytes_per_sec((char *)buf,
+				 large_obj_size/elapsed(&start, &end, 1)*1e6),
+				 KNRM);
+			fflush(stdout);
+			munmap(stolen_pf_user, large_obj_size);
+		}
+			munmap(stolen_nopf_user, large_obj_size);
+			gem_close(fd, large_stolen);
+	}
+
+
 	igt_fixture {
 		free(src);
 		gem_close(fd, dst);
+		free(dst_user);
+		gem_close(fd, src_stolen);
 
 		close(fd);
 	}
diff --git a/tests/gem_pwrite.c b/tests/gem_pwrite.c
index 6378b0a..dd1ca95 100644
--- a/tests/gem_pwrite.c
+++ b/tests/gem_pwrite.c
@@ -82,6 +82,7 @@ static const char *bytes_per_sec(char *buf, double v)
 
 
 uint32_t *src, dst;
+uint32_t *src_user, dst_stolen;
 int fd;
 
 int main(int argc, char **argv)
@@ -97,6 +98,9 @@ int main(int argc, char **argv)
 		{ 1, "snoop" },
 		{ 2, "display" },
 		{ -1 },
+		{ -1, "stolen-uncached"},
+		{ -1, "stolen-snoop"},
+		{ -1, "stolen-display"},
 	}, *c;
 
 	igt_skip_on_simulation();
@@ -114,6 +118,8 @@ int main(int argc, char **argv)
 
 		dst = gem_create(fd, object_size);
 		src = malloc(object_size);
+		dst_stolen = gem_create_stolen(fd, object_size);
+		src_user = malloc(object_size);
 	}
 
 	igt_subtest("normal") {
@@ -150,9 +156,48 @@ int main(int argc, char **argv)
 		}
 	}
 
+	igt_subtest("stolen-normal") {
+		for (count = 1; count <= 1<<17; count <<= 1) {
+			struct timeval start, end;
+
+			gettimeofday(&start, NULL);
+			do_gem_write(fd, dst_stolen, src_user,
+				     object_size, count);
+			gettimeofday(&end, NULL);
+			igt_info("Time to pwrite %d bytes x %6d:        %7.3fµs, %s\n",
+				 object_size, count,
+				 elapsed(&start, &end, count),
+				 bytes_per_sec((char *)buf,
+				 object_size/elapsed(&start, &end, count)*1e6));
+			fflush(stdout);
+		}
+	}
+
+	for (c = cache; c->level != -1; c++) {
+		igt_subtest((c + 4)->name) {
+			gem_set_caching(fd, dst, c->level);
+			for (count = 1; count <= 1<<17; count <<= 1) {
+				struct timeval start, end;
+
+				gettimeofday(&start, NULL);
+				do_gem_write(fd, dst_stolen, src_user,
+					     object_size, count);
+				gettimeofday(&end, NULL);
+				igt_info("Time to %s pwrite %d bytes x %6d:     %7.3fµs, %s\n",
+					 (c + 4)->name, object_size, count,
+					 elapsed(&start, &end, count),
+					 bytes_per_sec((char *)buf,
+					 object_size/elapsed(&start, &end, count)*1e6));
+				fflush(stdout);
+			}
+		}
+	}
+
 	igt_fixture {
 		free(src);
 		gem_close(fd, dst);
+		free(src_user);
+		gem_close(fd, dst_stolen);
 
 		close(fd);
 	}
