Initial port to linux kernel 4.4.

code/Makefile

@@ -3,28 +3,36 @@ MODULES = cow_brd.c disk_wrapper.c
 obj-m := $(addsuffix .o, $(basename $(MODULES)))
 KDIR := /lib/modules/$(shell uname -r)/build
 DEBUG_FLAGS += -g -DDEBUG
+GCC = gcc
 GPP = g++
 GOPTS = -std=c++11
 GOTPSSO = -shared -fPIC
+UTILS_OBJS = utils/utils_c.o utils/utils.o
 
 cow_brd.ko disk_wrapper.ko default: $(MODULES)
 	$(MAKE) -C $(KDIR) M=$(PWD) modules
 
-harness: harness/c_harness.cpp default utils/utils.h utils/utils.cpp \
+harness: harness/c_harness.cpp default \
 		disk_wrapper_ioctl.h harness/Tester.cpp harness/Tester.h \
 		permuter/Permuter.h permuter/RandomPermuter.so
-	$(GPP) $(GOPTS) harness/c_harness.cpp harness/Tester.cpp utils/utils.cpp \
-		-I /usr/src/linux-headers-$(shell uname -r)/include/ -ldl -o c_harness
+	$(GPP) $(GOPTS) harness/c_harness.cpp harness/Tester.cpp \
+		$(UTILS_OBJS) \
+		-ldl -o c_harness
 
 tests/%.so: tests/$(addsuffix .cpp, %) tests/BaseTestCase.h
 	$(GPP) $(GOPTS) $(GOTPSSO) -Wl,-soname,$(notdir $@) \
 		-o $@ $<
 
-permuter/RandomPermuter.so: permuter/RandomPermuter.cpp \
-		permuter/RandomPermuter.h utils/utils.h  utils/utils.cpp  \
-		disk_wrapper_ioctl.h
+permuter/RandomPermuter.so: permuter/RandomPermuter.cpp permuter/RandomPermuter.h \
+		disk_wrapper_ioctl.h $(UTILS_OBJS)
 	$(GPP) $(GOPTS) $(GOTPSSO) -Wl,-soname,RandomPermuter.so \
-		-o permuter/RandomPermuter.so permuter/RandomPermuter.cpp utils/utils.cpp \
+		-o permuter/RandomPermuter.so permuter/RandomPermuter.cpp $(UTILS_OBJS)
+
+utils/utils.o: utils/utils.h utils/utils.cpp disk_wrapper_ioctl.h
+	$(GPP) $(GOPTS) -fPIC -o utils/utils.o -c utils/utils.cpp
+
+utils/utils_c.o: utils/utils_c.h utils/utils_c.c disk_wrapper_ioctl.h
+	$(GCC) -o utils/utils_c.o -c utils/utils_c.c \
 		-I /usr/src/linux-headers-$(shell uname -r)/include/
 
 run_no_log: harness tests/echo_sub_dir.so
@@ -53,5 +61,5 @@ run_no_log_no_sync: harness tests/echo_sub_dir_no_sync.so
 
 clean:
 	$(MAKE) -C $(KDIR) M=$(PWD) clean
-	rm -f $(TESTING) tests/*.so c_harness permute *.o *.so permuter/*.so \
+	rm -f $(TESTING) tests/*.so c_harness permute *.o *.so utils/*.o permuter/*.so \
 		ioctl_test

code/cow_brd.c

@@ -379,12 +379,12 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
   struct block_device *bdev = bio->bi_bdev;
   struct brd_device *brd = bdev->bd_disk->private_data;
   int rw;
-  struct bio_vec *bvec;
+  struct bio_vec bvec;
   sector_t sector;
-  int i;
+  struct bvec_iter iter;
   int err = -EIO;
 
-  sector = bio->bi_sector;
+  sector = bio->bi_iter.bi_sector;
   if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) {
     printk(KERN_INFO DEVICE_NAME ": cow_brd%d past end of disk, EIO\n",
         brd->brd_number);
@@ -399,7 +399,7 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
 
   if (unlikely(bio->bi_rw & REQ_DISCARD)) {
     err = 0;
-    discard_from_brd(brd, sector, bio->bi_size);
+    discard_from_brd(brd, sector, bio->bi_iter.bi_size);
     goto out;
   }
 
@@ -408,18 +408,19 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
     rw = READ;
   }
 
-  bio_for_each_segment(bvec, bio, i) {
-    unsigned int len = bvec->bv_len;
-    err = brd_do_bvec(brd, bvec->bv_page, len,
-          bvec->bv_offset, rw, sector);
+  bio_for_each_segment(bvec, bio, iter) {
+    unsigned int len = bvec.bv_len;
+    err = brd_do_bvec(brd, bvec.bv_page, len,
+          bvec.bv_offset, rw, sector);
     if (err) {
       break;
     }
     sector += len >> SECTOR_SHIFT;
   }
 
 out:
-  bio_endio(bio, err);
+  bio->bi_error = err;
+  bio_endio(bio);
 }
 
 #ifdef CONFIG_BLK_DEV_XIP

code/disk_wrapper.c

@@ -169,13 +169,13 @@ static void print_rw_flags(unsigned long rw, unsigned long flags) {
 // TODO(ashmrtn): Currently not thread safe/reentrant. Make it so.
 static void disk_wrapper_bio(struct request_queue* q, struct bio* bio) {
   int copied_data;
-  int i;
+  struct  bvec_iter iter;
   struct disk_write_op *write;
   struct hwm_device* hwm;
 
   /*
   printk(KERN_INFO "hwm: bio rw of size %u headed for 0x%lx (sector 0x%lx)"
-      " has flags:\n", bio->bi_size, bio->bi_sector * 512, bio->bi_sector);
+      " has flags:\n", bio->bi_iter.bi_size, bio->bi_iter.bi_sector * 512, bio->bi_iter.bi_sector);
   print_rw_flags(bio->bi_rw, bio->bi_flags);
   */
   // Log information about writes, fua, and flush/flush_seq events in kernel
@@ -191,11 +191,11 @@ static void disk_wrapper_bio(struct request_queue* q, struct bio* bio) {
     if (bio->bi_rw & REQ_FLUSH ||
         bio->bi_rw & REQ_FUA || bio->bi_rw & REQ_FLUSH_SEQ ||
         bio->bi_rw & REQ_WRITE || bio->bi_rw & REQ_DISCARD) {
-      struct bio_vec* vec;
+      struct bio_vec vec;
 
       //printk(KERN_INFO "hwm: logging above bio\n");
       printk(KERN_INFO "hwm: bio rw of size %u headed for 0x%lx (sector 0x%lx)"
-          " has flags:\n", bio->bi_size, bio->bi_sector * 512, bio->bi_sector);
+          " has flags:\n", bio->bi_iter.bi_size, bio->bi_iter.bi_sector * 512, bio->bi_iter.bi_sector);
       print_rw_flags(bio->bi_rw, bio->bi_flags);
 
       // Log data to disk logs.
@@ -206,8 +206,8 @@ static void disk_wrapper_bio(struct request_queue* q, struct bio* bio) {
       }
       write->metadata.bi_flags = bio->bi_flags;
       write->metadata.bi_rw = bio->bi_rw;
-      write->metadata.write_sector = bio->bi_sector;
-      write->metadata.size = bio->bi_size;
+      write->metadata.write_sector = bio->bi_iter.bi_sector;
+      write->metadata.size = bio->bi_iter.bi_size;
 
       if (Device.current_write == NULL) {
         // This is the first write in the log.
@@ -229,15 +229,14 @@ static void disk_wrapper_bio(struct request_queue* q, struct bio* bio) {
       }
       copied_data = 0;
 
-      i = 0;
-      bio_for_each_segment(vec, bio, i) {
+      bio_for_each_segment(vec, bio, iter) {
         //printk(KERN_INFO "hwm: making new page for segment of data\n");
 
-        void *bio_data = kmap(vec->bv_page);
-        memcpy((void*) (write->data + copied_data), bio_data + vec->bv_offset,
-            vec->bv_len);
+        void *bio_data = kmap(vec.bv_page);
+        memcpy((void*) (write->data + copied_data), bio_data + vec.bv_offset,
+            vec.bv_len);
         kunmap(bio_data);
-        copied_data += vec->bv_len;
+        copied_data += vec.bv_len;
       }
 
       // Sanity check which prints data copied to the log.

code/utils/utils.cpp

@@ -1,6 +1,5 @@
 // Very messy hack to get the defines for different bio operations. Should be
 // changed to something more palatable if possible.
-#include <linux/blk_types.h>
 
 #include <cassert>
 #include <cstring>
@@ -16,6 +15,7 @@
 #include <vector>
 
 #include "utils.h"
+#include "utils_c.h"
 
 namespace fs_testing {
 namespace utils {
@@ -33,26 +33,15 @@ using std::uniform_int_distribution;
 using std::vector;
 
 bool disk_write::is_async_write() {
-  return (
-      !((metadata.bi_rw & REQ_SYNC) ||
-        (metadata.bi_rw & REQ_FUA) ||
-        (metadata.bi_rw & REQ_FLUSH) ||
-        (metadata.bi_rw & REQ_FLUSH_SEQ) ||
-        (metadata.bi_rw & REQ_SOFTBARRIER)) &&
-        metadata.bi_rw & REQ_WRITE);
+  return __c_is_async_write(&metadata);
 }
 
 bool disk_write::is_barrier_write() {
-  return (
-      ((metadata.bi_rw & REQ_FUA) ||
-        (metadata.bi_rw & REQ_FLUSH) ||
-        (metadata.bi_rw & REQ_FLUSH_SEQ) ||
-        (metadata.bi_rw & REQ_SOFTBARRIER)) &&
-        metadata.bi_rw & REQ_WRITE);
+  return __c_is_barrier_write(&metadata);
 }
 
 bool disk_write::is_meta() {
-  return (metadata.bi_rw & REQ_META);
+  return __c_is_meta(&metadata);
 }
 
 disk_write::disk_write(const struct disk_write_op_meta& m,
@@ -162,7 +151,7 @@ ostream& operator<<(ostream& os, const disk_write& dw) {
 }
 
 bool disk_write::has_write_flag() {
-  return metadata.bi_rw & REQ_WRITE;
+  return __c_has_write_flag(&metadata);
 }
 
 shared_ptr<char> disk_write::set_data(const char *d) {

code/utils/utils_c.c

@@ -0,0 +1,31 @@
+//
+// Created by Fábio Domingues on 19/07/17.
+//
+
+#include "utils_c.h"
+#include <linux/blk_types.h>
+
+bool __c_is_async_write(struct disk_write_op_meta *m) {
+    return !((m->bi_rw & REQ_SYNC) ||
+             (m->bi_rw & REQ_FUA) ||
+             (m->bi_rw & REQ_FLUSH) ||
+             (m->bi_rw & REQ_FLUSH_SEQ) ||
+             (m->bi_rw & REQ_SOFTBARRIER)) &&
+           (m->bi_rw & REQ_WRITE);
+}
+
+bool __c_is_barrier_write(struct disk_write_op_meta *m) {
+    return ((m->bi_rw & REQ_FUA) ||
+            (m->bi_rw & REQ_FLUSH) ||
+            (m->bi_rw & REQ_FLUSH_SEQ) ||
+            (m->bi_rw & REQ_SOFTBARRIER)) &&
+           (m->bi_rw & REQ_WRITE);
+}
+
+bool __c_is_meta(struct disk_write_op_meta *m) {
+    return (m->bi_rw & REQ_META) && true;
+}
+
+bool __c_has_write_flag(struct disk_write_op_meta *m) {
+    return (m->bi_rw & REQ_WRITE) && true;
+}

code/utils/utils_c.h

@@ -0,0 +1,25 @@
+//
+// Created by Fábio Domingues on 19/07/17.
+//
+
+#ifndef CRASHMONKEY_UTILS_C_H
+#define CRASHMONKEY_UTILS_C_H
+#ifdef __cplusplus
+extern "C"
+{
+#else
+// get bool type definition
+#include <linux/types.h>
+#endif
+
+#include "../disk_wrapper_ioctl.h"
+
+bool __c_is_async_write(struct disk_write_op_meta* m);
+bool __c_is_barrier_write(struct disk_write_op_meta* m);
+bool __c_is_meta(struct disk_write_op_meta* m);
+bool __c_has_write_flag(struct disk_write_op_meta* m);
+
+#ifdef __cplusplus
+}
+#endif
+#endif //CRASHMONKEY_UTILS_C_H