diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs/nnnpfs.h arla-for-linux-3.5/nnpfs/linux/nnpfs/nnnpfs.h
--- arla-0.90/nnpfs/linux/nnpfs/nnnpfs.h	2002-09-07 12:47:17.000000000 +0200
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs/nnnpfs.h	2002-09-07 12:47:17.000000000 +0200
@@ -1,4 +1,4 @@
 /* $Id: nnnpfs.h,v 1.2 2002/09/07 10:47:17 lha Exp $ */
-/* $Source: /afs/stacken.kth.se/src/SourceRepository/arla/nnpfs/linux/nnpfs/nnnpfs.h,v $ */
+/* $Source: /Users/bo/tmp/ArlaSourceRepository/arla/nnpfs/linux/nnpfs/nnnpfs.h,v $ */
 
 #define NNNPFS 2
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs/nnpfs_locl.h arla-for-linux-3.5/nnpfs/linux/nnpfs/nnpfs_locl.h
--- arla-0.90/nnpfs/linux/nnpfs/nnpfs_locl.h	2007-01-08 14:52:49.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs/nnpfs_locl.h	2016-01-10 20:39:43.766920817 +0100
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  */
 
-/* $Id: nnpfs_locl.h,v 1.77 2007/01/08 13:52:49 tol Exp $ */
+/* $Id: nnpfs_locl.h,v 1.78 2010/08/08 20:43:06 tol Exp $ */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -51,7 +51,9 @@
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/namei.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 #include <linux/smp_lock.h>
+#endif
 #include <linux/wait.h>
 
 /*
@@ -138,15 +140,16 @@ typedef __u32  uint32_t;
 int
 nnpfs_fetch_root(struct inode *i);
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 int
 nnpfs_get_sb(struct file_system_type *fs_type,
 	     int flags, const char *dev_name,
 	     void *data, struct vfsmount *mnt);
 #else
-struct super_block *
-nnpfs_get_sb (struct file_system_type *fs_type,
-	      int flags, const char *dev_name, void *data);
+struct dentry*
+nnpfs_mount(struct file_system_type *fs_type,
+	     int flags, const char *dev_name,
+	     void *data);
 #endif
 
 extern struct dentry_operations nnpfs_dentry_operations;
@@ -200,16 +203,29 @@ nnpfs_iwritecount (struct inode *inode)
  * Help function to read the dentry->d_count a portable way
  */
 
+/*#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))*/
 static inline int
 nnpfs_dcount (const struct dentry *dentry)
+/*#else
+static inline int
+nnpfs_dcount (struct dentry *dentry)
+#endif*/
 {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
     return atomic_read(&dentry->d_count);
+#else
+    return atomic_read((const atomic_t*)&dentry->d_count);
+    /* TODO: the method below is not compatible with a const dentry argument */
+    /*int rval;
+    spin_lock(&dentry->d_lock);
+    rval = dentry->d_count;
+    spin_unlock(&dentry->d_lock);
+    return rval;*/
+#endif
 }
 
 extern 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 const
-#endif
 struct address_space_operations nnpfs_aops;
 
 #ifndef list_for_each
@@ -237,7 +253,12 @@ nnpfs_fixup_syscall_lossage(void);
 #endif
 
 #define nnpfs_dev_t dev_t
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
 #define nnpfs_d_entry_unhashed(d) hlist_unhashed(d)
+#else
+#define nnpfs_d_entry_unhashed(d) hlist_bl_unhashed(d)
+#endif
 
 #define NNPFS_NOOP      while(0){}
 
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs/nnpfs_node.h arla-for-linux-3.5/nnpfs/linux/nnpfs/nnpfs_node.h
--- arla-0.90/nnpfs/linux/nnpfs/nnpfs_node.h	2006-12-11 17:29:39.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs/nnpfs_node.h	2010-08-08 22:43:07.000000000 +0200
@@ -54,7 +54,7 @@ extern uint32_t nnpfs_blocksizebits;
  * flags.
  */
 
-#define NNPFS_NODE_IPUT	0x00010000   /* node is in iput(), avoid deadlock */
+#define NNPFS_NODE_IPUT	0x00010000   /* node is in iput(), avoid deadlock. Can be removed? */
 
 #define XN_HASHSIZE 1009
 #define XN_CLEANUP_ITERS 129
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_blocks.c arla-for-linux-3.5/nnpfs/linux/nnpfs_blocks.c
--- arla-0.90/nnpfs/linux/nnpfs_blocks.c	2007-01-08 14:24:24.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_blocks.c	2016-01-11 00:18:59.267560762 +0100
@@ -34,7 +34,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* $Id: nnpfs_blocks.c,v 1.3 2007/01/08 13:24:24 tol Exp $ */
+/* $Id: nnpfs_blocks.c,v 1.6 2010/08/08 20:43:04 tol Exp $ */
 
 #include <nnpfs/nnpfs_locl.h>
 #include <nnpfs/nnpfs_fs.h>
@@ -322,6 +322,13 @@ nnpfs_block_open(struct nnpfs_node *node
     uid_t saveuid;
     gid_t savegid;
     int ret;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+    const struct cred *old_cred;
+    struct cred *override_cred;
+#endif
+
+    (void)saveuid;
+    (void)savegid;
 
     BUG_ON(!nnpfsp);
     BUG_ON(flags & O_CREAT && file != NULL);
@@ -346,22 +353,34 @@ nnpfs_block_open(struct nnpfs_node *node
     BUG_ON(!nnpfsp->cachedir || !nnpfsp->cacheroot);
     
     /* use the nfsd trick to give us access */
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     saveuid = current->fsuid;
     savegid = current->fsgid;
     current->fsuid = nnpfsp->uid;
     current->fsgid = nnpfsp->gid;
-
-    nd.dentry = dget(nnpfsp->cachedir);
-    nd.mnt = mntget(nnpfsp->cacheroot);
-    nd.last_type = LAST_NORM;
-    nd.depth = 0;
-    nd.flags = 0;
-    
-    if (flags & O_CREAT)
-	nd.flags = LOOKUP_PARENT;
-    
-    ret = path_walk(cachename, &nd);
-    if (ret) {
+#else
+    saveuid = current_fsuid();
+    savegid = current_fsgid();
+    override_cred = prepare_creds();
+    if (override_cred == NULL)
+        return -ENOMEM;
+    override_cred->fsuid = nnpfsp->uid;
+    override_cred->fsgid = nnpfsp->gid;
+    old_cred = override_creds(override_cred);
+#endif
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
+    ret = vfs_path_lookup(nnpfsp->cachedir, nnpfsp->cacheroot,
+			  cachename,
+			  flags & O_CREAT ? LOOKUP_PARENT : 0,
+			  &nd);
+#else
+    ret = vfs_path_lookup(nnpfsp->cachedir, nnpfsp->cacheroot,
+			  cachename,
+			  flags & O_CREAT ? LOOKUP_PARENT : 0,
+			  &nd.path);
+#endif
+     if (ret) {
 	uint32_t nmasks = node->data.nmasks;
 	uint32_t mask;
 
@@ -387,16 +406,21 @@ nnpfs_block_open(struct nnpfs_node *node
     
     if (flags & O_CREAT) {
 	/* XXX mode bits on create -- S_IRUSR|S_IWUSR */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
 	struct dentry *dentry = lookup_create(&nd, 0);	
+#else
+	/* TODO: check the call to kern_path_create() */
+	struct dentry *dentry = kern_path_create(AT_FDCWD, NULL, &nd.path, 0);	
+#endif
 	if (IS_ERR(dentry)) {
 	    ret = PTR_ERR(dentry);
 	} else {
-	    ret = vfs_create(nd.dentry->d_inode, dentry, S_IRUSR|S_IWUSR, &nd);
+	    ret = vfs_create(nd.path.dentry->d_inode, dentry, S_IRUSR|S_IWUSR, &nd);
 	    dput(dentry);
 	}
 
-	mutex_unlock(&nd.dentry->d_inode->i_mutex);
-	path_release(&nd);
+	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
+	path_put(&nd.path);
 
 	if (ret) {
 	    printk("nnpfs_block_open(%s) create failed: %d\n", cachename, -ret);
@@ -410,12 +434,16 @@ nnpfs_block_open(struct nnpfs_node *node
 	    ret = nnpfs_block_extend(node, offset);
 	}
     } else {
-	struct file *f = dentry_open(nd.dentry, nd.mnt, flags);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
+	struct file *f = dentry_open(nd.path.dentry, nd.path.mnt, flags);
+#else
+        struct file *f = dentry_open(nd.path.dentry, nd.path.mnt, flags, current_cred());
+#endif
 	if (IS_ERR(f)) {
 	    ret = PTR_ERR(f);
 	    printk("nnpfs_block_open(%s) open failed: %d\n", cachename, -ret);
 	    nnpfs_debug_oops();
-	    path_release(&nd);
+	    path_put(&nd.path);
 	} else {
 	    *file = f;
 	}
@@ -424,8 +452,13 @@ nnpfs_block_open(struct nnpfs_node *node
     /* path_release() is usually handled on close */
 
  out:
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     current->fsuid = saveuid;
     current->fsgid = savegid;
+#else
+    revert_creds(old_cred);
+    put_cred(override_cred);
+#endif
 
     return ret;
 }
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_dev.c arla-for-linux-3.5/nnpfs/linux/nnpfs_dev.c
--- arla-0.90/nnpfs/linux/nnpfs_dev.c	2006-10-24 18:33:36.000000000 +0200
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_dev.c	2016-01-10 16:51:25.462254468 +0100
@@ -300,8 +300,10 @@ nnpfs_invalidate_all(struct nnpfs *nnpfs
     NNPFSDEB(XDEBNODE, ("free_all_nnpfs_nodes starting\n"));
 
     shrink_dcache_sb(nnpfs->sb);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
     invalidate_inodes(nnpfs->sb);
-    
+#endif
+
     NNPFSDEB(XDEBNODE, ("free_all_nnpfs_nodes done\n"));
 }
 
@@ -505,12 +507,23 @@ nnpfs_devwrite(struct file *file, const
 /*
  * Not used.
  */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36))
 static int
 nnpfs_devioctl(struct inode *inode, struct file *file,
 	       unsigned int cmd, unsigned long arg)
+#else
+static long
+nnpfs_devioctl(struct file *file,
+	       unsigned int cmd, unsigned long arg)
+#endif
 {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36))
     NNPFSDEB(XDEBDEV, ("nnpfs_devioctl dev = %d, flags = %d\n",
 		       inode->i_rdev, file->f_flags));
+#else
+    NNPFSDEB(XDEBDEV, ("nnpfs_devioctl dev = %d, flags = %d\n",
+		       file->f_dentry->d_inode->i_rdev, file->f_flags));
+#endif
     return -EINVAL;
 }
 
@@ -953,7 +966,11 @@ struct file_operations nnpfs_fops = {
     read:		nnpfs_devread,
     write:		nnpfs_devwrite,
     poll:		nnpfs_devpoll,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36))
     ioctl:		nnpfs_devioctl,
+#else
+    unlocked_ioctl:	nnpfs_devioctl,
+#endif
     release:		nnpfs_devclose,
     open:		nnpfs_devopen,
 };
@@ -968,8 +985,16 @@ nnpfs_init_device(void)
 	init_waitqueue_head(&(nnpfs[i].wait_queue));
 	nnpfs_initq(&nnpfs[i].messageq);
 	nnpfs_initq(&nnpfs[i].sleepq);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
 	init_MUTEX(&nnpfs[i].inactive_sem);
+#else
+	sema_init(&nnpfs[i].inactive_sem, 1);
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
 	init_MUTEX(&nnpfs[i].channel_sem);
+#else
+	sema_init(&nnpfs[i].channel_sem, 1);
+#endif
 	INIT_LIST_HEAD(&nnpfs[i].inactive_list);
 	nnpfs[i].nnodes = 0;
     }
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_inodeops.c arla-for-linux-3.5/nnpfs/linux/nnpfs_inodeops.c
--- arla-0.90/nnpfs/linux/nnpfs_inodeops.c	2006-12-11 17:35:26.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_inodeops.c	2016-01-11 01:38:22.315792459 +0100
@@ -48,7 +48,7 @@
 #include <asm/fcntl.h>
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_inodeops.c,v 1.223 2006/12/11 16:35:26 tol Exp $");
+RCSID("$Id: nnpfs_inodeops.c,v 1.226 2010/08/08 20:43:04 tol Exp $");
 #endif
 
 static int
@@ -57,8 +57,15 @@ nnpfs_fsync_int(struct file *file, u_int
 static int
 nnpfs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
 
-static int
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
+static
+int
 nnpfs_d_delete(struct dentry *dentry);
+#else
+static
+int
+nnpfs_d_delete(const struct dentry *dentry);
+#endif
 
 static void
 nnpfs_d_release(struct dentry *dentry);
@@ -105,7 +112,7 @@ nnpfs_vma_close (struct vm_area_struct *
 }
 
 static struct vm_operations_struct nnpfs_file_vm_ops = {
-    .nopage	= filemap_nopage,
+    .fault      = filemap_fault,
     .close	= nnpfs_vma_close,
 };
 
@@ -134,12 +141,14 @@ nnpfs_print_path(struct dentry *dentry)
  *
  */
 
+#if 0
 void
 nnpfs_print_lock(char *s, struct semaphore *sem)
 {
     NNPFSDEB(XDEBLOCK, ("lock: %s sem: %p count: %d\n",
 		      s, sem, (int)atomic_read(&sem->count)));
 }
+#endif
 
 /*
  *
@@ -185,7 +194,7 @@ nnpfs_d_iput(struct dentry *dentry, stru
     NNPFSDEB(XDEBVNOPS,
 	     ("nnpfs_d_iput: dentry %p, inode %p\n", dentry, inode));
     
-    if (node->flags & NNPFS_NODE_IPUT) /* XXX locking */
+    if (node->flags & NNPFS_NODE_IPUT) /* XXX locking. never set? */
 	nnpfs_irele(inode);
     else
 	iput(inode);
@@ -240,7 +249,11 @@ nnpfs_lookup (struct inode *dir, struct
 
 	msg.header.opcode = NNPFS_MSG_GETNODE;
         
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 	msg.cred.pag = nnpfs_get_pag();
 	msg.parent_handle = d->handle;
         
@@ -310,7 +323,11 @@ nnpfs_open_valid(struct inode *vp, u_int
       {
 	struct nnpfs_message_open msg;
 	msg.header.opcode = NNPFS_MSG_OPEN;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 	msg.cred.pag = nnpfs_get_pag();
 	msg.handle = xn->handle;
 	msg.tokens = tok;
@@ -425,7 +442,11 @@ nnpfs_fsync_int(struct file *file, u_int
 
 	msg.header.opcode = NNPFS_MSG_PUTDATA;
 	msg.cred.pag = nnpfs_get_pag();
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 	msg.handle = xn->handle;
 	msg.flag   = flag;
 	msg.offset = off;
@@ -460,14 +481,27 @@ nnpfs_fsync_int(struct file *file, u_int
  *
  */
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
 static int
 nnpfs_fsync(struct file *file, struct dentry *dentry, int datasync)
+#elseif (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
+static int
+nnpfs_fsync(struct file *file, int datasync)
+#else
+static int
+nnpfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
+#endif
 {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
+    struct dentry *dentry = file->f_path.dentry;
+#endif
     struct inode *inode = DENTRY_TO_INODE(dentry);
     struct nnpfs *nnpfsp;
     struct nnpfs_node *xn;
     int error = 0;
 
+    (void)nnpfsp;
+
     error = nnpfs_inode_valid(inode);
     if (error)
 	return error;
@@ -511,7 +545,11 @@ nnpfs_attr_valid(struct inode * vp, u_in
             struct nnpfs_message_getattr msg;
 
             msg.header.opcode = NNPFS_MSG_GETATTR;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
             msg.cred.uid = current->uid;
+#else
+            msg.cred.uid = current_uid();
+#endif
             msg.cred.pag = pag;
             msg.handle = xn->handle;
             error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
@@ -551,7 +589,11 @@ nnpfs_rights_valid(struct inode * vp, nn
             struct nnpfs_message_getattr msg;
 
             msg.header.opcode = NNPFS_MSG_GETATTR;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
             msg.cred.uid = current->uid;
+#else
+            msg.cred.uid = current_uid();
+#endif
             msg.cred.pag = pag;
             msg.handle = xn->handle;
             error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
@@ -592,11 +634,26 @@ check_rights (nnpfs_rights rights, int m
  * We don't hold i_mutex.
  */
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) || LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
 static int
-nnpfs_permission(struct inode *inode, int mode, struct nameidata *nd)
+nnpfs_permission(struct inode *inode, int mode)
+#else
+static int
+nnpfs_permission(struct inode *inode, int mode, unsigned int flags)
+#endif
 {
     int error = 0;
-    nnpfs_pag_t pag = nnpfs_get_pag();
+    nnpfs_pag_t pag;
+    /* TODO: verify this */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38) && LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
+    if (flags & IPERM_FLAG_RCU)
+        return -ECHILD;
+#else
+    if (mode & MAY_NOT_BLOCK)
+        return -ECHILD;
+#endif
+
+    pag = nnpfs_get_pag();
     
     NNPFSDEB(XDEBVNOPS, ("nnpfs_access (%p) mode = 0%o aliases:", inode, mode));
     nnpfs_print_aliases(inode);
@@ -636,7 +693,11 @@ nnpfs_do_getdata(struct nnpfs_node *xn,
     int error;
 
     msg.header.opcode = NNPFS_MSG_GETDATA;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     msg.handle = xn->handle;
     msg.tokens = tok;
@@ -791,18 +852,12 @@ int nnpfs_file_mmap(struct file * file,
 
 static ssize_t
 nnpfs_aio_read(struct kiocb *iocb,
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
 	       const struct iovec *iov, unsigned long nr_segs,
-#else
-	       char __user *buf, size_t count,
-#endif
 	       loff_t pos)
 {
     int error = 0;
     struct file *file = iocb->ki_filp;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
     ssize_t count = iocb->ki_left;
-#endif
     struct inode *inode = file->f_dentry->d_inode;
     struct nnpfs_node *xn = VNODE_TO_XNODE(inode);
     
@@ -816,11 +871,7 @@ nnpfs_aio_read(struct kiocb *iocb,
 	return error;
     }
     
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
     error = generic_file_aio_read(iocb, iov, nr_segs, pos);
-#else
-    error = generic_file_aio_read(iocb, buf, count, pos);
-#endif
     NNPFSDEB(XDEBVNOPS, ("nnpfs_read_file: error = %d\n", error));
     return error;
 }
@@ -831,18 +882,12 @@ nnpfs_aio_read(struct kiocb *iocb,
 
 static ssize_t
 nnpfs_aio_write(struct kiocb *iocb,
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
 		const struct iovec *iov, unsigned long nr_segs,
-#else
-		const char __user *buf, size_t count, 
-#endif
 		loff_t pos)
 {
     int error = 0;
     struct file *file = iocb->ki_filp;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
     ssize_t count = iocb->ki_left;
-#endif
     struct inode *inode = file->f_dentry->d_inode;
     struct nnpfs_node *xn = VNODE_TO_XNODE(inode);
     loff_t realpos = pos;
@@ -859,11 +904,7 @@ nnpfs_aio_write(struct kiocb *iocb,
 	return error;
     }
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
     error = generic_file_aio_write(iocb, iov, nr_segs, pos);
-#else
-    error = generic_file_aio_write(iocb, buf, count, pos);
-#endif
     if (!IS_ERR_VALUE(error))
 	xn->flags |= NNPFS_DATA_DIRTY; /* XXX race */
 
@@ -871,9 +912,15 @@ nnpfs_aio_write(struct kiocb *iocb,
     return error;
 }
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 static int
 nnpfs_create(struct inode *dir, struct dentry *dentry,
 	     int mode, struct nameidata *nd)
+#else
+static int
+nnpfs_create(struct inode *dir, struct dentry *dentry,
+	     umode_t mode, struct nameidata *nd)
+#endif
 {
     struct nnpfs *nnpfsp;
     struct nnpfs_node *xn;
@@ -903,9 +950,17 @@ nnpfs_create(struct inode *dir, struct d
     XA_CLEAR(&msg.attr);
     XA_SET_MODE(&msg.attr, mode);
     XA_SET_TYPE(&msg.attr, NNPFS_FILE_REG);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     XA_SET_GID(&msg.attr, current->fsgid);
+#else
+    XA_SET_GID(&msg.attr, current_fsgid());
+#endif
     msg.mode = 0;		/* XXX */
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
@@ -946,7 +1001,11 @@ nnpfs_unlink (struct inode * dir, struct
     if (strlcpy(msg.name, dentry->d_name.name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
 	return -ENAMETOOLONG;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
@@ -991,7 +1050,11 @@ nnpfs_rename (struct inode * old_dir, st
     if (strlcpy(msg.new_name, new_dentry->d_name.name, sizeof(msg.new_name)) >= NNPFS_MAX_NAME)
 	return -ENAMETOOLONG;
 	
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
@@ -1008,8 +1071,13 @@ nnpfs_rename (struct inode * old_dir, st
     return error;
 }
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0))
 static int
 nnpfs_mkdir(struct inode * dir, struct dentry *dentry, int mode)
+#else
+static int
+nnpfs_mkdir(struct inode * dir, struct dentry *dentry, umode_t mode)
+#endif
 {
     struct nnpfs *nnpfsp;
     struct nnpfs_node *xn;
@@ -1040,9 +1108,17 @@ nnpfs_mkdir(struct inode * dir, struct d
 	XA_CLEAR(&msg.attr);
 	XA_SET_MODE(&msg.attr, mode);
 	XA_SET_TYPE(&msg.attr, NNPFS_FILE_DIR);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	XA_SET_GID(&msg.attr, current->fsgid);
+#else
+        XA_SET_GID(&msg.attr, current_fsgid());
+#endif
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 	msg.cred.pag = nnpfs_get_pag();
 	error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
 	if (error == 0)
@@ -1083,7 +1159,11 @@ nnpfs_rmdir(struct inode * dir, struct d
     msg.parent_handle = xn->handle;
     if (strlcpy(msg.name, dentry->d_name.name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
 	    return -ENAMETOOLONG;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
@@ -1128,7 +1208,11 @@ static int nnpfs_link(struct dentry *old
 	if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
 	    return -ENAMETOOLONG;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 	msg.cred.pag = nnpfs_get_pag();
 	error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
 	if (error == 0)
@@ -1157,29 +1241,47 @@ static int nnpfs_symlink(struct inode *d
     xn = VNODE_TO_XNODE(dir);
 
     {
-	struct nnpfs_message_symlink msg;
+	struct nnpfs_message_symlink *msg = NULL;
 
-	msg.header.opcode = NNPFS_MSG_SYMLINK;
-	msg.parent_handle = xn->handle;
-	if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
-	    return -ENAMETOOLONG;
-	if (strlcpy(msg.contents, symname, sizeof(msg.contents)) >= NNPFS_MAX_SYMLINK_CONTENT)
-	    return -ENAMETOOLONG;
-	XA_CLEAR(&msg.attr);
-	XA_SET_MODE(&msg.attr, 0777);
-	XA_SET_TYPE(&msg.attr, NNPFS_FILE_LNK);
-	XA_SET_GID(&msg.attr, current->fsgid);
+	msg = kmalloc(sizeof(*msg), GFP_KERNEL);
 
-	msg.cred.uid = current->uid;
-	msg.cred.pag = nnpfs_get_pag();
-	error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
+	if (msg == NULL)
+	  return -ENOMEM;
+
+	msg->header.opcode = NNPFS_MSG_SYMLINK;
+	msg->parent_handle = xn->handle;
+	if (strlcpy(msg->name, name, sizeof(msg->name)) >= NNPFS_MAX_NAME) {
+	  kfree(msg);
+	  return -ENAMETOOLONG;
+	}
+	if (strlcpy(msg->contents, symname, sizeof(msg->contents)) >= NNPFS_MAX_SYMLINK_CONTENT) {
+	  kfree(msg);
+	  return -ENAMETOOLONG;
+	}
+	XA_CLEAR(&msg->attr);
+	XA_SET_MODE(&msg->attr, 0777);
+	XA_SET_TYPE(&msg->attr, NNPFS_FILE_LNK);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+	XA_SET_GID(&msg->attr, current->fsgid);
+#else
+        XA_SET_GID(&msg->attr, current_fsgid());
+#endif
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+	msg->cred.uid = current->uid;
+#else
+        msg->cred.uid = current_uid();
+#endif
+	msg->cred.pag = nnpfs_get_pag();
+	error = nnpfs_message_rpc(nnpfsp, &msg->header, sizeof(*msg));
 	if (error == 0)
-	    error = NNPFS_MSG_WAKEUP_ERROR(&msg);
+	    error = NNPFS_MSG_WAKEUP_ERROR(msg);
 
 	/* XXX should this really be here */
 	if (DENTRY_TO_XDENTRY(dentry)->xd_flags == 0) {
 	    printk(KERN_EMERG "NNPFS Panic: nnpfs_symlink: dentry not valid\n");
 	}
+	kfree(msg);
     }
 
     return error;
@@ -1398,7 +1500,11 @@ nnpfs_setattr (struct dentry *dentry, st
         struct nnpfs_message_putattr msg;
 
         msg.header.opcode = NNPFS_MSG_PUTATTR;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 	msg.cred.pag = nnpfs_get_pag();
         msg.handle = xn->handle;
         nnpfs_iattr2attr(xn, attr, &msg.attr);
@@ -1422,6 +1528,8 @@ nnpfs_release_file (struct inode *inode,
     struct nnpfs_node *xn;
     int error = 0;
 
+    (void)nnpfsp;
+
     NNPFSDEB(XDEBVNOPS, ("nnpfs_release_file\n"));
 
     error = nnpfs_inode_valid(inode);
@@ -1450,13 +1558,8 @@ nnpfs_release_file (struct inode *inode,
  *
  */
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 static int
 nnpfs_flush(struct file *file, fl_owner_t id)
-#else
-static int
-nnpfs_flush(struct file *file)
-#endif
 {
     NNPFSDEB(XDEBVNOPS, ("nnpfs_flush\n"));
 
@@ -1519,9 +1622,15 @@ nnpfs_d_revalidate(struct dentry *dentry
     return 0;
 }
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
 static
 int
 nnpfs_d_delete(struct dentry *dentry)
+#else
+static
+int
+nnpfs_d_delete(const struct dentry *dentry)
+#endif
 {
     struct inode *inode;
     struct nnpfs_node *xn;
@@ -1546,8 +1655,9 @@ nnpfs_d_delete(struct dentry *dentry)
 }
 
 static ssize_t
-nnpfs_sendfile(struct file *file, loff_t *ppos, size_t count,
-	       read_actor_t actor, void *target)
+nnpfs_splice_read(struct file *file, loff_t *ppos,
+		  struct pipe_inode_info *pipe, size_t count,
+		  unsigned int flags)
 {
     int error = 0;
     struct inode *inode = file->f_dentry->d_inode;
@@ -1561,8 +1671,7 @@ nnpfs_sendfile(struct file *file, loff_t
 	NNPFSDEB(XDEBVNOPS, ("nnpfs_sendfile: data not valid %d\n", error));
 	return error;
     }
-
-    error = generic_file_sendfile(file, ppos, count, actor, target);
+    error = file->f_op->splice_read(file, ppos, pipe, count, flags);
 
     NNPFSDEB(XDEBVNOPS, ("nnpfs_sendfile: error = %d\n", error));
     return error;
@@ -1639,34 +1748,31 @@ nnpfs_write_backpage(struct page *page,
 	struct address_space *mapping = backfile->f_mapping;
 	unsigned len = PAGE_CACHE_SIZE;
 	struct page *backpage;
+	void *fsdata;
 	unsigned long offset;
 
 	int error;
-	
-	do {
-		backpage = grab_cache_page(mapping, nnpfs_get_backindex(page));
-		if (!backpage) {
-			printk("nnpfs_write_backpage: no page\n");
-			return -EIO;
-		}
 
-		error = mapping->a_ops->prepare_write(backfile, backpage,
-						      0, len);
+	(void)offset;
+
+	do {
+		error = pagecache_write_begin(backfile, mapping, 0, len,
+					      AOP_FLAG_UNINTERRUPTIBLE,
+					      &backpage, &fsdata);
 		if (!error) {
 			copy_highpage(backpage, page);
 			flush_dcache_page(backpage);
-			error = mapping->a_ops->commit_write(backfile, backpage,
-							     0, len);
+			error = pagecache_write_end(backfile, mapping, 0, len,
+					len, backpage, fsdata);
+			if (error > 0)
+				error = 0;
 		}
 		if (error == AOP_TRUNCATED_PAGE) {
-			page_cache_release(backpage);
 			continue;
 		}
 	} while (0);
 
 	offset = page_offset(backpage);
-	unlock_page(backpage);
-	page_cache_release(backpage);
 
 	if (error)
 		printk("nnpfs_write_backpage: EIO\n");
@@ -1689,13 +1795,9 @@ nnpfs_read_backpage(struct page *page, s
 	struct page *backpage;
 	unsigned long offset;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+	(void)offset;
+
 	backpage = read_mapping_page(mapping, n, backfile);
-#else
-	backpage = read_cache_page(mapping, n,
-				   (filler_t *)mapping->a_ops->readpage,
-				   backfile);
-#endif
 	if (!IS_ERR(backpage)) {
 		wait_on_page_locked(backpage);
 
@@ -1872,8 +1974,37 @@ nnpfs_prepare_write(struct file *file, s
 	return ret;
 }
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+
+static int
+nnpfs_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
+unsigned len, unsigned flags, struct page **pagep, void **fsdata)
+{
+	struct page *page;
+	pgoff_t index;
+	unsigned from;
+
+	index = pos >> PAGE_CACHE_SHIFT;
+	from = pos & (PAGE_CACHE_SIZE - 1);
+
+#ifdef AOP_FLAG_NOFS
+	page = grab_cache_page_write_begin(mapping, index, flags);
+#else
+	page = __grab_cache_page(mapping, index);
+#endif
+	if (page == NULL)
+		return -ENOMEM;
+
+	*pagep = page;
+
+	return nnpfs_prepare_write(file, page, from, from + len);
+}
+
+#endif
+
 static int
-nnpfs_commit_write(struct file *file, struct page *page, unsigned from, unsigned to)
+nnpfs_commit_write(struct file *file, struct page *page,
+		   unsigned from, unsigned to)
 {
     struct inode *inode = page->mapping->host;
     loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
@@ -1902,14 +2033,43 @@ nnpfs_commit_write(struct file *file, st
     return 0;
 }
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
-const
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+
+static int
+nnpfs_write_end(struct file *file, struct address_space *mapping, loff_t pos,
+		unsigned len, unsigned copied, struct page *page, void *fsdata)
+{
+	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+
+	/* zero the stale part of the page if we did a short copy */
+	if (copied < len) {
+		void *kaddr = kmap_atomic(page, KM_USER0);
+		memset(kaddr + from + copied, 0, len - copied);
+		flush_dcache_page(page);
+		kunmap_atomic(kaddr, KM_USER0);
+	}
+
+	nnpfs_commit_write(file, page, from, from + copied);
+
+	unlock_page(page);
+	page_cache_release(page);
+
+	return copied;
+}
+
 #endif
+
+const
 struct address_space_operations nnpfs_aops = {
 	.readpage = nnpfs_readpage,
 	.writepage = nnpfs_writepage,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 	.prepare_write = nnpfs_prepare_write,
 	.commit_write = nnpfs_commit_write,
+#else
+	.write_begin = nnpfs_write_begin,
+	.write_end = nnpfs_write_end,
+#endif
 };
 
 /*
@@ -1924,7 +2084,7 @@ struct file_operations nnpfs_file_operat
     .flush	= nnpfs_flush,
     .release	= nnpfs_release_file,
     .fsync	= nnpfs_fsync,
-    .sendfile	= nnpfs_sendfile,
+    .splice_read = nnpfs_splice_read,
 };
 
 struct file_operations nnpfs_dead_operations = {
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_load.c arla-for-linux-3.5/nnpfs/linux/nnpfs_load.c
--- arla-0.90/nnpfs/linux/nnpfs_load.c	2006-10-31 11:02:41.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_load.c	2016-01-10 20:33:16.062901957 +0100
@@ -54,7 +54,11 @@ extern struct file_operations nnpfs_fops
 
 struct file_system_type nnpfs_fs_type = {
        name:           "nnpfs",
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
        get_sb:         nnpfs_get_sb,
+#else
+       mount:          nnpfs_mount,
+#endif
        kill_sb:        kill_litter_super,
        owner:          THIS_MODULE,
 };
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_message.c arla-for-linux-3.5/nnpfs/linux/nnpfs_message.c
--- arla-0.90/nnpfs/linux/nnpfs_message.c	2007-01-09 17:33:31.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_message.c	2016-01-10 21:51:44.231130984 +0100
@@ -45,7 +45,7 @@
 #include <linux/mount.h>
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_message.c,v 1.143.2.1 2007/01/09 16:33:31 tol Exp $");
+RCSID("$Id: nnpfs_message.c,v 1.145 2010/08/08 20:43:05 tol Exp $");
 #endif
 
 static void
@@ -55,9 +55,15 @@ static void
 nnpfs_d_remove(struct dentry *dentry)
 {
     NNPFSDEB(XDEBMSG, ("nnpfs_d_remove %p\n", dentry));
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
     spin_lock(&dcache_lock);
     dget_locked(dentry);
     spin_unlock(&dcache_lock);
+#else
+    spin_lock(&dentry->d_lock);
+    dget_dlock(dentry);
+    spin_unlock(&dentry->d_lock);
+#endif
     d_drop(dentry);
     dput(dentry);
 }
@@ -179,9 +185,15 @@ nnpfs_message_installnode(struct nnpfs *
     alias = di->i_dentry.next;
     while (alias != &di->i_dentry) {
 	parent = list_entry(alias, struct dentry, d_alias);
-	spin_lock(&dcache_lock);
-	dget_locked(parent);
-	spin_unlock(&dcache_lock);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
+    spin_lock(&dcache_lock);
+    dget_locked(parent);
+    spin_unlock(&dcache_lock);
+#else
+    spin_lock(&parent->d_lock);
+    dget_dlock(parent);
+    spin_unlock(&parent->d_lock);
+#endif
 	dentry = d_lookup(parent, &sqstr);
 	NNPFSDEB(XDEBMSG,
 		 ("nnpfs_message_installnode: alias %p, lookup %p\n",
@@ -399,7 +411,12 @@ clear_all_children (struct inode *inode,
     struct list_head *alias;
 
  again:
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
     spin_lock(&dcache_lock);
+#else
+    /* TODO: find the dentry to lock */
+    /*spin_lock(&dentry->d_lock);*/
+#endif
     alias = inode->i_dentry.next;
     while (alias != &inode->i_dentry) {
 	struct dentry *dentry;
@@ -442,14 +459,24 @@ clear_all_children (struct inode *inode,
 
 	    /* Throw immediately */
 	    if (nnpfs_dcount(child) == 0) {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
 	        spin_unlock(&dcache_lock);
+#else
+		/* TODO: unlock the dentry */
+		/*spin_unlock(&dentry->d_lock);*/
+#endif
 		nnpfs_d_remove(child);
 		goto again;
 	    }
 	}
 	alias = alias->next;
     }
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38))
     spin_unlock(&dcache_lock);
+#else
+    /* TODO: unlock the dentry */
+    /*spin_unlock(&dentry->d_lock);*/
+#endif
 }
 
 static void
@@ -605,12 +632,10 @@ gc_block(struct nnpfs *nnpfsp,
     }
 
     if (!nnpfs_block_have_p(xn, offset)) {
-#if 0   /* happens when daemon sends several messages for same block */
 	printk(KERN_EMERG "NNPFS/gc_block: "
 	       "ENOENT (%d,%d,%d,%d) 0x%llx\n", 
 	       xn->handle.a, xn->handle.b, xn->handle.c, xn->handle.d, 
 	       (unsigned long long)offset);
-#endif
 	return -ENOENT;
     }
 
@@ -726,7 +751,11 @@ nnpfs_message_version(struct nnpfs *nnpf
 
 	uint64_t blocksize = message->blocksize;
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 	error = path_lookup(".", 0, &nd);
+#else
+	error = kern_path(".", 0, &nd.path);
+#endif
 	if (error) {
 	    /*
 	     * Bad cache root, just return.
@@ -737,12 +766,16 @@ nnpfs_message_version(struct nnpfs *nnpf
 		   "nnpfs_message_version failed path_lookup, "
 		   "errno: %d\n", error);
 	} else {
-	    nnpfsp->cacheroot = mntget(nd.mnt);
-	    nnpfsp->cachedir = dget(nd.dentry);
-	    path_release(&nd);
-	    
+	    nnpfsp->cacheroot = mntget(nd.path.mnt);
+	    nnpfsp->cachedir = dget(nd.path.dentry);
+	    path_put(&nd.path);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 	    nnpfsp->uid = current->fsuid;
 	    nnpfsp->gid = current->fsgid;
+#else
+            nnpfsp->uid = current_fsuid();
+            nnpfsp->gid = current_fsgid();
+#endif
 
 	    /* XXX we should validate these values */
 	    nnpfs_blocksize = blocksize;
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_node.c arla-for-linux-3.5/nnpfs/linux/nnpfs_node.c
--- arla-0.90/nnpfs/linux/nnpfs_node.c	2007-01-03 14:52:02.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_node.c	2016-01-11 01:13:17.479719256 +0100
@@ -152,7 +152,11 @@ nnpfs_attr2inode(const struct nnpfs_attr
 	inode->i_mode   = 0;
 	inode->i_uid    = 0;
 	inode->i_gid    = 0;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0))
 	inode->i_nlink  = 1;
+#else
+	set_nlink(inode, 1);
+#endif
 	inode->i_atime  = notime;
 	inode->i_mtime  = notime;
 	inode->i_ctime  = notime;
@@ -169,7 +173,11 @@ nnpfs_attr2inode(const struct nnpfs_attr
     if (XA_VALID_GID(attr))
 	inode->i_gid    = attr->xa_gid;
     if (XA_VALID_NLINK(attr))
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0))
 	inode->i_nlink  = attr->xa_nlink;
+#else
+	set_nlink(inode, attr->xa_nlink);
+#endif
     
     if (XA_VALID_SIZE(attr)) {
 	nnpfs_setsize(inode, attr->xa_size);
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_syscalls.c arla-for-linux-3.5/nnpfs/linux/nnpfs_syscalls.c
--- arla-0.90/nnpfs/linux/nnpfs_syscalls.c	2007-01-03 15:26:27.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_syscalls.c	2016-01-10 21:52:47.371134056 +0100
@@ -42,7 +42,9 @@
 #include <nnpfs/nnpfs_syscalls.h>
 #include <nnpfs/nnpfs_common.h>
 #include <linux/file.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 #include <linux/smp_lock.h>
+#endif
 #include <linux/smp.h>
 #include <linux/proc_fs.h>
 
@@ -64,7 +66,7 @@
 #undef NEED_VICEIOCTL32
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_syscalls.c,v 1.122 2007/01/03 14:26:27 tol Exp $");
+RCSID("$Id: nnpfs_syscalls.c,v 1.125 2010/08/08 20:43:06 tol Exp $");
 #endif
 
 static struct proc_dir_entry *nnpfs_procfs_dir;
@@ -82,12 +84,22 @@ typedef struct afsprocdata {
     unsigned long syscall;
 } afsprocdata;
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36))
 static int
 nnpfs_procfs_ioctl(struct inode *inode, struct file *file,
 		   unsigned int cmd, unsigned long arg);
+#else
+static long
+nnpfs_procfs_ioctl(struct file *file,
+		   unsigned int cmd, unsigned long arg);
+#endif
 
 static struct file_operations nnpfs_procfs_fops = {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36))
     .ioctl = nnpfs_procfs_ioctl,
+#else
+    .unlocked_ioctl = nnpfs_procfs_ioctl,
+#endif
 };
 
 
@@ -147,53 +159,46 @@ static int nnpfs_sec_registered = 0;
 #define SEC2PAG(s) (nnpfs_pag_t)(unsigned long)(s)
 #define PAG2SEC(p) (void *)(unsigned long)(p)
 
-static int
-nnpfs_sec_task_alloc(struct task_struct *p)
-{
-    nnpfs_pag_t pag = SEC2PAG(current->security);
-    if (pag)
-	p->security = PAG2SEC(pag);
-    return 0;
-}
-
-static void
-nnpfs_sec_task_free(struct task_struct *p)
-{
-    nnpfs_pag_t pag = SEC2PAG(p->security);
-    if (pag)
-	p->security = NULL;
-}
-
 static nnpfs_pag_t
 nnpfs_get_pag_sec(void)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     nnpfs_pag_t pag = SEC2PAG(current->security);
+#else
+    nnpfs_pag_t pag = SEC2PAG(current_security());
+#endif
     if (pag)
 	return pag;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     return current->uid;
+#else
+    return current_uid();
+#endif
 }
 
 static int
 nnpfs_set_pag_sec(void)
 {
     static nnpfs_pag_t pagnum = NNPFS_PAG_LLIM;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+    struct cred *cred;
+#endif
 
     if (pagnum == NNPFS_PAG_ULIM)
 	return -ENOMEM;
     /* pagnum = NNPFS_PAG_LLIM; */
     
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     current->security = PAG2SEC(pagnum);
+#else
+    cred = (struct cred *) current->cred;
+    cred->security = PAG2SEC(pagnum);
+#endif
     pagnum++;
     return 0;
 }
 
-static struct security_operations nnpfs_sec_ops = {
-    .task_alloc_security = nnpfs_sec_task_alloc,
-    .task_free_security = nnpfs_sec_task_free,
-//    .task_reparent_to_init = nnpfs_sec_reparent_to_init,
-};
-
 #endif /* CONFIG_SECURITY */
 
 #ifdef GROUPPAGS
@@ -222,11 +227,18 @@ find_pag(struct group_info *gi)
 static nnpfs_pag_t
 nnpfs_get_pag_group(void)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     struct group_info *gi = current->group_info;
     nnpfs_pag_t ret = current->uid;
+#else
+    struct group_info *gi = get_current_groups();
+    nnpfs_pag_t ret = current_uid();
+#endif
     int i;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     get_group_info(gi);
+#endif
 
     i = find_pag(gi);
     if (i != NNPFS_PAG_NOTFOUND)
@@ -242,13 +254,19 @@ nnpfs_get_pag_group(void)
 static int
 store_pag(nnpfs_pag_t pagnum)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     struct group_info *old_gi = current->group_info;
+#else
+   struct group_info *old_gi = get_current_groups();
+#endif
     struct group_info *new_gi;
-    int nblocks, count;
+    unsigned int nblocks, count;
     int found = 0;
     int i, k;
     
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)    
     get_group_info(old_gi);
+#endif
 
     i = find_pag(old_gi);
     if (i != NNPFS_PAG_NOTFOUND)
@@ -317,7 +335,11 @@ nnpfs_get_pag()
     return nnpfs_get_pag_group();
 #endif /* GROUPPAGS */
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     return current->uid;
+#else
+    return current_uid();
+#endif
 }
 
 static inline int
@@ -422,7 +444,7 @@ nnpfs_setgroups16 (int gidsetsize, old_g
 #endif /* SYSCALLHACK */
 #endif /* GROUPPAGS */
 
-struct file_handle {
+struct nnpfs_file_handle {
     nnpfs_dev_t dev;
     ino_t inode;
     __u32 gen;
@@ -524,11 +546,15 @@ user_path2dentry (struct nameidata *nd,
 
     NNPFSDEB(XDEBMSG, ("nnpfs_syscall: looking up: %s\n", kname));
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
     error = path_lookup(kname, flags, nd);
+#else
+    error = kern_path(kname, flags, &(nd->path));
+#endif
     putname(kname);
     if (error)
 	return ERR_PTR(error);
-    return nd->dentry;
+    return nd->path.dentry;
 }
 
 asmlinkage long
@@ -540,12 +566,20 @@ sys_afs_int (int operation,
 {
     long error = 0;
     struct arlaViceIoctl vice_ioctl; 
-    struct nnpfs_message_pioctl msg;
+    struct nnpfs_message_pioctl *msg = NULL;
     struct nnpfs_message_wakeup *msg2;
     struct dentry *dentry = NULL;
     struct nameidata nd;
     
+    msg = kmalloc(sizeof(*msg), GFP_KERNEL);
+    if (msg == NULL)
+      return -ENOMEM;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
     lock_kernel();
+#else
+    /* TODO: lock something */
+#endif
 
     NNPFSDEB(XDEBSYS, ("sys_afs kernel locked\n"));
 
@@ -575,7 +609,7 @@ sys_afs_int (int operation,
 	    goto unlock;
 	}
 	if (vice_ioctl.in_size != 0) {
-	    if(copy_from_user(&msg.msg,
+	    if(copy_from_user(&msg->msg,
 			      vice_ioctl.in,
 			      vice_ioctl.in_size) != 0) {
 		error = -EFAULT;
@@ -628,19 +662,23 @@ sys_afs_int (int operation,
 		error = -EINVAL;
 		goto unlock;
 	    }
-	    msg.handle = xn->handle;
+	    msg->handle = xn->handle;
 	}
 
-	msg.header.opcode = NNPFS_MSG_PIOCTL;
-	msg.opcode = a_opcode;
+	msg->header.opcode = NNPFS_MSG_PIOCTL;
+	msg->opcode = a_opcode;
 	
-	msg.insize   = vice_ioctl.in_size;
-	msg.outsize  = vice_ioctl.out_size;
-	msg.cred.uid = current->uid;
-	msg.cred.pag = nnpfs_get_pag();
+	msg->insize   = vice_ioctl.in_size;
+	msg->outsize  = vice_ioctl.out_size;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+	msg->cred.uid = current->uid;
+#else
+        msg->cred.uid = current_uid();
+#endif
+	msg->cred.pag = nnpfs_get_pag();
 	
-	error = nnpfs_message_rpc(&nnpfs[0], &msg.header, sizeof(msg)); /* XXX */
-	msg2 = (struct nnpfs_message_wakeup *) &msg;
+	error = nnpfs_message_rpc(&nnpfs[0], &msg->header, sizeof(*msg)); /* XXX */
+	msg2 = (struct nnpfs_message_wakeup *) msg;
 	if (error == 0)
 	    error = msg2->error;
 
@@ -675,12 +713,17 @@ sys_afs_int (int operation,
     
  unlock:
     if (dentry)
-	path_release(&nd);
+	path_put(&nd.path);
 
     NNPFSDEB(XDEBSYS, ("nnpfs_syscall returns error: %ld\n", error));
 
     NNPFSDEB(XDEBSYS, ("sys_afs kernel unlock\n"));
+    kfree(msg);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
     unlock_kernel();
+#else
+    /* TODO: unlock the thing locked above */
+#endif
 
     return error;
 }
@@ -729,9 +772,15 @@ sys_afs (int operation,
 		       a_followSymlinks);
 }
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36))
 static int
 nnpfs_procfs_ioctl(struct inode *inode, struct file *file,
 		   unsigned int cmd, unsigned long arg)
+#else
+static long
+nnpfs_procfs_ioctl(struct file *file,
+		   unsigned int cmd, unsigned long arg)
+#endif
 {
     afsprocdata args;
     long ret;
@@ -780,20 +829,24 @@ static int nnpfs_init_procfs(void)
 {
     struct proc_dir_entry *entry;
     
-    nnpfs_procfs_dir = proc_mkdir(NNPFS_PROC_DIR, proc_root_fs);
+    nnpfs_procfs_dir = proc_mkdir("fs/" NNPFS_PROC_DIR, NULL);
     if (nnpfs_procfs_dir == NULL)
 	return -ENOMEM;
     
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
     nnpfs_procfs_dir->owner = THIS_MODULE;
+#endif
     
     entry = create_proc_entry(NNPFS_PROC_NODE, 0666, nnpfs_procfs_dir);
     if (entry == NULL) {
 	NNPFSDEB(XDEBSYS, ("nnpfs_init_procfs: no node\n"));
-	remove_proc_entry(NNPFS_PROC_DIR, proc_root_fs);
+	remove_proc_entry("fs/" NNPFS_PROC_DIR, NULL);
 	return -ENOMEM;
     }
     
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
     entry->owner = THIS_MODULE;
+#endif
     entry->proc_fops = &nnpfs_procfs_fops;
 
 #ifdef SYSCALLCOMPAT
@@ -815,7 +868,7 @@ static void nnpfs_exit_procfs(void)
     }
 #endif /* SYSCALLCOMPAT */
     remove_proc_entry(NNPFS_PROC_NODE, nnpfs_procfs_dir);
-    remove_proc_entry(NNPFS_PROC_DIR, proc_root_fs);
+    remove_proc_entry("fs/" NNPFS_PROC_DIR, NULL);
 }
 
 #ifdef GROUPPAGS
@@ -839,14 +892,6 @@ install_setgroups(void)
 void
 install_afs_syscall(void)
 {
-#ifdef CONFIG_SECURITY
-    if (register_security(&nnpfs_sec_ops))
-	NNPFSDEB(XDEBSYS,
-		 ("install_afs_syscall: nnpfs_init_sec failed\n"));
-    else
-	nnpfs_sec_registered = 1;
-#endif
-
     nnpfs_init_procfs();
 
 #ifdef SYSCALLHACK
@@ -887,12 +932,6 @@ restore_afs_syscall (void)
 #endif
 #endif /* SYSCALLHACK */
 
-#ifdef CONFIG_SECURITY
-    if (nnpfs_sec_registered)
-	if (unregister_security(&nnpfs_sec_ops))
-	    printk(KERN_EMERG "nnpfs_exit_sec: couldn't unregister\n");
-#endif /* !CONFIG_SECURITY */
-
 #ifdef GROUPPAGS
 #ifdef SYSCALLHACK
     if (old_setgroups) {
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_syscalls-lossage.c arla-for-linux-3.5/nnpfs/linux/nnpfs_syscalls-lossage.c
--- arla-0.90/nnpfs/linux/nnpfs_syscalls-lossage.c	2006-12-11 17:31:45.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_syscalls-lossage.c	2010-08-08 22:43:05.000000000 +0200
@@ -47,7 +47,7 @@
 #include <linux/unistd.h>
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_syscalls-lossage.c,v 1.17 2006/12/11 16:31:45 tol Exp $");
+RCSID("$Id: nnpfs_syscalls-lossage.c,v 1.19 2010/08/08 20:43:05 tol Exp $");
 #endif
 
 #include <linux/kallsyms.h>
@@ -63,6 +63,9 @@ const char * __attribute__((weak))
 		    unsigned long *offset,
 		    char **modname, char *namebuf);
 
+#ifdef __x86_64__
+extern rwlock_t tasklist_lock __attribute__((weak));
+#endif
 static void **
 get_start_addr(void) {
 #ifdef __x86_64__
diff -uprN -Xnodiff.txt arla-0.90/nnpfs/linux/nnpfs_vfsops.c arla-for-linux-3.5/nnpfs/linux/nnpfs_vfsops.c
--- arla-0.90/nnpfs/linux/nnpfs_vfsops.c	2006-12-11 17:43:35.000000000 +0100
+++ arla-for-linux-3.5/nnpfs/linux/nnpfs_vfsops.c	2016-01-11 01:46:00.911814767 +0100
@@ -44,25 +44,17 @@
 #include <linux/mm.h>
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_vfsops.c,v 1.109 2006/12/11 16:43:35 tol Exp $");
+RCSID("$Id: nnpfs_vfsops.c,v 1.111 2010/08/08 20:43:06 tol Exp $");
 #endif
 
 struct nnpfs nnpfs[NNNPFS];
 
-static void nnpfs_read_inode(struct inode *inode);
 static void nnpfs_put_super(struct super_block *sb);
-static void nnpfs_put_inode(struct inode *inode);
 static void nnpfs_write_super(struct super_block * sb);
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 static int nnpfs_statfs(struct dentry *dentry, struct kstatfs *buf);
-#else
-static int nnpfs_statfs(struct super_block *sb, struct kstatfs *buf);
-#endif
 
 static struct super_operations nnpfs_sops = { 
-    read_inode		: nnpfs_read_inode,
-    put_inode		: nnpfs_put_inode,
     alloc_inode		: nnpfs_node_alloc,
     destroy_inode	: nnpfs_node_free,
     drop_inode		: generic_delete_inode,
@@ -159,7 +151,11 @@ make_root (struct super_block *sb)
     nnpfs->root = inode;
 
     /* XXX error handling */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0))
     dp = d_alloc_root(inode);
+#else
+    dp = d_make_root(inode);
+#endif
     nnpfs_d_init(dp);
     sb->s_root = dp;
     return 0;
@@ -185,11 +181,15 @@ nnpfs_read_super (struct super_block * s
     if (data != NULL) {
 	struct nameidata nd;
 	
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 	error = path_lookup(data, 0, &nd);
+#else
+	error = kern_path(data, 0, &nd.path);
+#endif
 	if (error)
 	    ddev = ERR_PTR(error);
 	else
-	    ddev = nd.dentry;
+	    ddev = nd.path.dentry;
 
 	if (!IS_ERR(ddev)) {
 	    minordevice = MINOR(ddev->d_inode->i_rdev);
@@ -233,7 +233,7 @@ nnpfs_fill_super (struct super_block *sb
     return 0;
 }
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 int
 nnpfs_get_sb(struct file_system_type *fs_type,
 	     int flags, const char *dev_name,
@@ -242,11 +242,12 @@ nnpfs_get_sb(struct file_system_type *fs
     return get_sb_nodev(fs_type, flags, data, nnpfs_fill_super, mnt);
 }
 #else
-struct super_block *
-nnpfs_get_sb (struct file_system_type *fs_type,
-	      int flags, const char *dev_name, void *data) 
+struct dentry*
+nnpfs_mount(struct file_system_type *fs_type,
+	     int flags, const char *dev_name,
+	     void *data) 
 {
-    return get_sb_nodev(fs_type, flags, data, nnpfs_fill_super);
+    return mount_nodev(fs_type, flags, data, nnpfs_fill_super);
 }
 #endif
 
@@ -273,73 +274,6 @@ nnpfs_put_super(struct super_block *sb)
     NNPFSDEB(XDEBVFOPS, ("nnpfs_put_super exiting\n"));
 }
 
-static void
-nnpfs_read_inode(struct inode *inode)
-{
-    NNPFSDEB(XDEBVFOPS,("nnpfs_read_inode starting inode: %p\n",inode));
-    NNPFSDEB(XDEBVFOPS,("nnpfs_read_inode inode->i_ino: %ld\n",inode->i_ino));
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
-    inode->i_blksize = 1024;
-#endif
-    inode->i_mode = 0;
-    inode->i_op = NULL;
-    NNPFSDEB(XDEBVFOPS,("nnpfs_read_inode exiting\n"));
-}
- 
-/*
- * Called when `inode' is de-referenced, ie when iput is called.
- */
-
-static void
-nnpfs_put_inode(struct inode *inode)
-{
-    struct nnpfs_node *xn = VNODE_TO_XNODE(inode);
-    struct nnpfs *nnpfsp = NNPFS_FROM_VNODE(inode);
-    int bad;
-
-    NNPFSDEB(XDEBVFOPS,("nnpfs_put_inode: inode: %p count: %d aliases:",
-			inode, nnpfs_icount(inode)));
-    nnpfs_print_aliases(inode);
-    
-    down(&nnpfsp->inactive_sem);
-
-    if ((nnpfsp->status & NNPFS_DEVOPEN) == 0) {
-	if (!is_bad_inode(inode)) {
-	    if (inode != nnpfsp->root) {
-		make_bad_inode(inode);
-		nnpfs_irele(inode); /* see nnpfs_node_add() */
-	    }
-	    xn->flags |= NNPFS_STALE;
-	}
-	bad = 1; /* or root, really */
-    } else {
-	bad = is_bad_inode(inode);
-    }
-
-    if (xn->flags & NNPFS_STALE && !nnpfs_node_users(inode)) {
-	xn->flags |= NNPFS_NODE_IPUT; /* XXX locking */
-  	nnpfs_force_invalid_node(xn);
-	xn->flags &= ~NNPFS_NODE_IPUT;
-    }
-    
-    if (bad) {
-	if (nnpfs_icount(inode) == 1)
-	    nnpfs_node_clear(xn);
-    } else if (nnpfs_icount(inode) == 2) {
-	/* 
-	 * The last external reference is being dropped, only the one
-	 * from nnpfs_node_add() is left. Time to let daemon release
-	 * this node properly.
-	 */
-	if ((xn->flags & NNPFS_LIMBO) == 0) {
-	    nnpfs_node_clear(xn);
-	    nnpfs_queue_inactive(xn);
-	}
-    }
-
-    up(&nnpfsp->inactive_sem);
-}
-
 static int
 nnpfs_statfs_int(struct super_block *sb, struct kstatfs *buf)
 {
@@ -352,25 +286,21 @@ nnpfs_statfs_int(struct super_block *sb,
     tmp.f_bavail  = 1024*1024*2-50;
     tmp.f_files   = 1024*1024;
     tmp.f_ffree   = 1024*1024-100;
+    tmp.f_fsid.val[0] = 0;
+    tmp.f_fsid.val[1] = 0;
     tmp.f_namelen = NAME_MAX;
+    tmp.f_frsize  = 0;
+    tmp.f_spare[0] = 0;
+    tmp.f_spare[1] = 0;
+    tmp.f_spare[2] = 0;
+    tmp.f_spare[3] = 0;
+    tmp.f_spare[4] = 0;
     *buf = tmp;
     return 0;
 }
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
-
 static int
 nnpfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
     return nnpfs_statfs_int(dentry->d_sb, buf);
 }
-
-#else
-
-static int
-nnpfs_statfs(struct super_block *sb, struct kstatfs *buf)
-{
-    return nnpfs_statfs_int(sb, buf);
-}
-
-#endif