Fixed TCP compatability with newer kernel versions.

LiME is not less restrictive.  If it fails to read a page for whatever reason it just NULL pads that page

src/disk.c

@@ -24,7 +24,7 @@
 #include "lime.h"
 
 
-int write_vaddr_disk(void *, size_t);
+ssize_t write_vaddr_disk(void *, size_t);
 int setup_disk(void);
 void cleanup_disk(void);
 
@@ -84,10 +84,10 @@ void cleanup_disk() {
 	set_fs(fs);
 }
 
-int write_vaddr_disk(void * v, size_t is) {
+ssize_t write_vaddr_disk(void * v, size_t is) {
 	mm_segment_t fs;
 
-	long s;
+	ssize_t s;
 	loff_t pos;
 
 	fs = get_fs();

src/main.c

@@ -25,9 +25,9 @@
 
 // This file
 static int write_lime_header(struct resource *);
-static int write_padding(size_t);
-static int write_range(struct resource *);
-static int write_vaddr(void *, size_t);
+static ssize_t write_padding(size_t);
+static void write_range(struct resource *);
+static ssize_t write_vaddr(void *, size_t);
 static int setup(void);
 static void cleanup(void);
 static int init(void);
@@ -116,10 +116,7 @@ static int init() {
 			break;
 		}
 
-		if ((err = write_range(p))) {
-			DBG("Error writing range 0x%lx - 0x%lx", (long) p->start, (long) p->end);
-			break;
-		}
+		write_range(p);
 
 		p_last = p->end;
 	}
@@ -131,7 +128,7 @@ static int init() {
 }
 
 static int write_lime_header(struct resource * res) {
-	long s;
+	ssize_t s;
 
 	lime_mem_range_header header;
 
@@ -151,25 +148,25 @@ static int write_lime_header(struct resource * res) {
 	return 0;
 }
 
-static int write_padding(size_t s) {
+static ssize_t write_padding(size_t s) {
 	size_t i = 0;
-	int r;
+	ssize_t r;
 
 	while(s -= i) {
 
 		i = min((size_t) PAGE_SIZE, s);
 		r = write_vaddr(zero_page, i);
 
 		if (r != i) {
-			DBG("Error sending zero page: %d", r);
+			DBG("Error sending zero page: %zd", r);
 			return r;
 		}
 	}
 
 	return 0;
 }
 
-static int write_range(struct resource * res) {
+static void write_range(struct resource * res) {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 	resource_size_t i, is;
 #else
@@ -178,7 +175,7 @@ static int write_range(struct resource * res) {
 	struct page * p;
 	void * v;
 
-	int s;
+	ssize_t s;
 
 	for (i = res->start; i <= res->end; i += is) {
 
@@ -189,24 +186,25 @@ static int write_range(struct resource * res) {
         if (is < PAGE_SIZE) {
         	// We can't map partial pages and 
         	// the linux kernel doesn't use them anyway
-        	DBG("Padding partial page: vaddr %p size: %lu", (void *) i, is);
+        	DBG("Padding partial page: vaddr %p size: %lu", (void *) i, (unsigned long) is);
         	write_padding(is);
         } else {
 			v = kmap(p);
 			s = write_vaddr(v, is);
 			kunmap(p);
 
-			if (s != is) {
-				DBG("Error writing page: vaddr %p ret: %d", v, s);
-				return (int) s;
+			if (s < 0) {
+				DBG("Error writing page: vaddr %p ret: %zd.  Null padding.", v, s);
+				write_padding(is);
+			} else if (s != is) {
+				DBG("Short Read %zu instead of %lu.  Null padding.", s, (unsigned long) is);
+				write_padding(is - s);
 			}
 		}
 	}
-
-	return 0;
 }
 
-static int write_vaddr(void * v, size_t is) {
+static ssize_t write_vaddr(void * v, size_t is) {
 	return (method == LIME_METHOD_TCP) ? write_vaddr_tcp(v, is) : write_vaddr_disk(v, is);
 }
 

src/tcp.c

@@ -34,7 +34,7 @@
 
 #include "lime.h"
 
-int write_vaddr_tcp(void *, size_t);
+ssize_t write_vaddr_tcp(void *, size_t);
 int setup_tcp(void);
 void cleanup_tcp(void);
 
@@ -124,27 +124,18 @@ void cleanup_tcp() {
 	}
 }
 
-int write_vaddr_tcp(void * v, size_t is) {
-	mm_segment_t fs;
+ssize_t write_vaddr_tcp(void * v, size_t is) {
+	ssize_t s;
+	struct kvec iov;
+	struct msghdr msg;
 
-	long s;
-
-	struct iovec iov;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0)
-	struct msghdr msg  = { .msg_iov = &iov, .msg_iovlen = 1 };
-#else
-	struct user_msghdr msg  = { .msg_iov = &iov, .msg_iovlen = 1 };
-#endif
-
-	fs = get_fs();
-	set_fs(KERNEL_DS);
+	memset(&iov, 0, sizeof(struct iovec));
+	memset(&msg, 0, sizeof(struct msghdr));
 
 	iov.iov_base = v;	
 	iov.iov_len = is;
 
-	s = sock_sendmsg(accept, &msg, is);
-
-	set_fs(fs);
+	s = kernel_sendmsg(accept, &msg, &iov, 1, is);
 
 	return s;
 }