PATCH: Arla CVS Current on Linux 2.6.34 to 3.18
Bo Branten
bosse at acc.umu.se
Wed Jan 13 03:01:05 CET 2016
PATCH: Arla CVS Current on Linux 2.6.34 to 3.18
-------------- next part --------------
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs/nnpfs_fs.h arla-for-linux-3.18/nnpfs/linux/nnpfs/nnpfs_fs.h
--- arla-cvs/nnpfs/linux/nnpfs/nnpfs_fs.h 2006-10-24 18:33:48.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs/nnpfs_fs.h 2016-01-12 19:06:34.518025609 +0100
@@ -84,8 +84,13 @@ struct nnpfs {
struct vfsmount *cacheroot; /* simplify open of cache blocks */
struct dentry *cachedir;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
uid_t uid; /* keep track of daemon's identity */
gid_t gid;
+#else
+ kuid_t uid; /* keep track of daemon's identity */
+ kgid_t gid;
+#endif
struct {
int recurse;
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs/nnpfs_locl.h arla-for-linux-3.18/nnpfs/linux/nnpfs/nnpfs_locl.h
--- arla-cvs/nnpfs/linux/nnpfs/nnpfs_locl.h 2010-08-08 22:43:06.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs/nnpfs_locl.h 2016-01-11 21:17:42.878326124 +0100
@@ -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,10 +140,17 @@ typedef __u32 uint32_t;
int
nnpfs_fetch_root(struct inode *i);
+#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 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;
@@ -194,10 +203,23 @@ 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
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0))
+ return atomic_read((const atomic_t*)&dentry->d_count);
+#else
+ return d_count(dentry);;
+#endif
+#endif
}
extern
@@ -229,7 +251,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-cvs/nnpfs/linux/nnpfs_blocks.c arla-for-linux-3.18/nnpfs/linux/nnpfs_blocks.c
--- arla-cvs/nnpfs/linux/nnpfs_blocks.c 2010-08-08 22:43:04.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_blocks.c 2016-01-13 01:19:18.514770143 +0100
@@ -43,6 +43,36 @@
#include <linux/mount.h>
#include <linux/mm.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
+/* TODO: implement a replacement for vfs_path_lookup on kernels later than 3.12 */
+/**
+ * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
+ * @dentry: pointer to dentry of the base directory
+ * @mnt: pointer to vfs mount of the base directory
+ * @name: pointer to file name
+ * @flags: lookup flags
+ * @path: pointer to struct path to fill
+ */
+int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
+ const char *name, unsigned int flags,
+ struct path *path)
+{
+#if 0
+ struct nameidata nd;
+ int err;
+ nd.root.dentry = dentry;
+ nd.root.mnt = mnt;
+ BUG_ON(flags & LOOKUP_PARENT);
+ /* the first argument of do_path_lookup() is ignored with LOOKUP_ROOT */
+ err = do_path_lookup(AT_FDCWD, name, flags | LOOKUP_ROOT, &nd);
+ if (!err)
+ *path = nd.path;
+ return err;
+#endif
+ return -1;
+}
+#endif
+
/*
* return true if block is in cache
*/
@@ -290,7 +320,13 @@ nnpfs_block_extend(struct nnpfs_node *no
backnode = backfile->f_mapping->host;
mutex_lock(&backnode->i_mutex);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0))
ret = vmtruncate(backnode, nnpfs_blocksize);
+#else
+ if(!inode_newsize_ok(backnode, nnpfs_blocksize)) {
+ truncate_setsize(backnode, nnpfs_blocksize);
+ }
+#endif
mutex_unlock(&backnode->i_mutex);
filp_close(backfile, NULL);
@@ -319,14 +355,22 @@ nnpfs_block_open(struct nnpfs_node *node
struct inode *inode = XNODE_TO_VNODE(node);
int flags = O_LARGEFILE | flag;
struct nameidata nd;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
uid_t saveuid;
gid_t savegid;
+#else
+ kuid_t saveuid;
+ kgid_t savegid;
+#endif
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);
@@ -366,11 +410,18 @@ nnpfs_block_open(struct nnpfs_node *node
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);
- if (ret) {
+#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;
@@ -396,11 +447,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(), is the second argument optional? */
+ struct dentry *dentry = kern_path_create(AT_FDCWD, NULL, &nd.path, 0);
+#endif
if (IS_ERR(dentry)) {
ret = PTR_ERR(dentry);
} else {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
ret = vfs_create(nd.path.dentry->d_inode, dentry, S_IRUSR|S_IWUSR, &nd);
+#else
+ /* TODO: should the last argument to vfs_create: bool want_excl, be 0 or 1? */
+ ret = vfs_create(nd.path.dentry->d_inode, dentry, S_IRUSR|S_IWUSR, 0);
+#endif
dput(dentry);
}
@@ -419,10 +480,15 @@ nnpfs_block_open(struct nnpfs_node *node
ret = nnpfs_block_extend(node, offset);
}
} else {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
struct file *f = dentry_open(nd.path.dentry, nd.path.mnt, flags);
#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
struct file *f = dentry_open(nd.path.dentry, nd.path.mnt, flags, current_cred());
+#else
+ struct path path = { .mnt = nd.path.mnt, .dentry = nd.path.dentry };
+ struct file *f = dentry_open(&path, flags, current_cred());
+#endif
#endif
if (IS_ERR(f)) {
ret = PTR_ERR(f);
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_common.c arla-for-linux-3.18/nnpfs/linux/nnpfs_common.c
--- arla-cvs/nnpfs/linux/nnpfs_common.c 2006-12-11 17:31:46.000000000 +0100
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_common.c 2016-01-11 20:47:22.874406174 +0100
@@ -112,10 +112,17 @@ nnpfs_print_aliases(const struct inode *
void
nnpfs_print_aliases_real(const struct inode *inode)
{
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
struct list_head *alias;
+#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0))
+ struct hlist_node *alias;
+#endif
+#endif
struct dentry *dentry;
int bailout = 100;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
alias = inode->i_dentry.next;
while (alias != &inode->i_dentry) {
if (--bailout < 0) {
@@ -131,6 +138,24 @@ nnpfs_print_aliases_real(const struct in
}
alias = alias->next;
}
+#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0))
+ hlist_for_each_entry(dentry, alias, &inode->i_dentry, d_alias) {
+#else
+ hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+#endif
+ if (--bailout < 0) {
+ printk(" ...");
+ break;
+ }
+ if (dentry) {
+ printk(" %.*s(%p)", (int)dentry->d_name.len,
+ dentry->d_name.name, dentry);
+ if (nnpfs_d_entry_unhashed(&dentry->d_hash))
+ printk("(unhashed)");
+ }
+ }
+#endif
printk("\n");
}
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_dev.c arla-for-linux-3.18/nnpfs/linux/nnpfs_dev.c
--- arla-cvs/nnpfs/linux/nnpfs_dev.c 2006-10-24 18:33:36.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_dev.c 2016-01-13 01:00:51.486733288 +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_unlocked_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_unlocked_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-cvs/nnpfs/linux/nnpfs_inodeops.c arla-for-linux-3.18/nnpfs/linux/nnpfs_inodeops.c
--- arla-cvs/nnpfs/linux/nnpfs_inodeops.c 2010-08-08 22:43:04.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_inodeops.c 2016-01-13 00:53:21.754718316 +0100
@@ -40,6 +40,7 @@
#include <nnpfs/nnpfs_dev.h>
#include <nnpfs/nnpfs_dirent.h>
#include <nnpfs/nnpfs_syscalls.h>
+#include <linux/aio.h>
#include <linux/binfmts.h>
#include <linux/file.h>
#include <linux/pagemap.h>
@@ -54,11 +55,23 @@ RCSID("$Id: nnpfs_inodeops.c,v 1.226 201
static int
nnpfs_fsync_int(struct file *file, u_int flag);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
static int
nnpfs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
-
+#else
static int
+nnpfs_d_revalidate(struct dentry *dentry, unsigned int flags);
+#endif
+
+#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);
@@ -214,8 +227,13 @@ nnpfs_inode_valid(struct inode *inode)
* nnpfs_lookup now returns a dentry.
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
static struct dentry *
nnpfs_lookup (struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+#else
+static struct dentry *
+nnpfs_lookup (struct inode *dir, struct dentry *dentry, unsigned int flags)
+#endif
{
struct nnpfs_message_getnode msg;
struct nnpfs *nnpfsp;
@@ -474,12 +492,17 @@ nnpfs_fsync_int(struct file *file, u_int
*
*/
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
static int
nnpfs_fsync(struct file *file, struct dentry *dentry, int datasync)
#else
+#if (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
#endif
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
@@ -490,6 +513,8 @@ nnpfs_fsync(struct file *file, int datas
struct nnpfs_node *xn;
int error = 0;
+ (void)nnpfsp;
+
error = nnpfs_inode_valid(inode);
if (error)
return error;
@@ -622,11 +647,28 @@ 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)
+#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 the use of IPERM_FLAG_RCU and MAY_NOT_BLOCK */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
+ if (flags & IPERM_FLAG_RCU)
+ return -ECHILD;
+#else
+ if (mode & MAY_NOT_BLOCK)
+ return -ECHILD;
+#endif
+#endif
+
+ pag = nnpfs_get_pag();
NNPFSDEB(XDEBVNOPS, ("nnpfs_access (%p) mode = 0%o aliases:", inode, mode));
nnpfs_print_aliases(inode);
@@ -823,14 +865,23 @@ int nnpfs_file_mmap(struct file * file,
*
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
static ssize_t
nnpfs_aio_read(struct kiocb *iocb,
const struct iovec *iov, unsigned long nr_segs,
loff_t pos)
+#else
+static ssize_t
+nnpfs_read_iter(struct kiocb *iocb, struct iov_iter *to)
+#endif
{
int error = 0;
struct file *file = iocb->ki_filp;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0))
ssize_t count = iocb->ki_left;
+#else
+ ssize_t count = iocb->ki_nbytes;
+#endif
struct inode *inode = file->f_dentry->d_inode;
struct nnpfs_node *xn = VNODE_TO_XNODE(inode);
@@ -838,13 +889,21 @@ nnpfs_aio_read(struct kiocb *iocb,
NNPFSDEB(XDEBVNOPS, ("nnpfs_read_file(%p): tokens: 0x%x\n",
inode, xn->tokens));
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
error = nnpfs_data_valid(inode, NNPFS_DATA_R, pos, pos + count);
+#else
+ error = nnpfs_data_valid(inode, NNPFS_DATA_R, iocb->ki_pos, iocb->ki_pos + count);
+#endif
if (error) {
NNPFSDEB(XDEBVNOPS, ("nnpfs_read_file: data not valid %d\n", error));
return error;
}
-
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
error = generic_file_aio_read(iocb, iov, nr_segs, pos);
+#else
+ error = generic_file_read_iter(iocb, to);
+#endif
NNPFSDEB(XDEBVNOPS, ("nnpfs_read_file: error = %d\n", error));
return error;
}
@@ -853,17 +912,30 @@ nnpfs_aio_read(struct kiocb *iocb,
*
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
static ssize_t
nnpfs_aio_write(struct kiocb *iocb,
const struct iovec *iov, unsigned long nr_segs,
loff_t pos)
+#else
+static ssize_t
+nnpfs_write_iter(struct kiocb *iocb, struct iov_iter *from)
+#endif
{
int error = 0;
struct file *file = iocb->ki_filp;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,12,0))
ssize_t count = iocb->ki_left;
+#else
+ ssize_t count = iocb->ki_nbytes;
+#endif
struct inode *inode = file->f_dentry->d_inode;
struct nnpfs_node *xn = VNODE_TO_XNODE(inode);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
loff_t realpos = pos;
+#else
+ loff_t realpos = iocb->ki_pos;
+#endif
NNPFSDEB(XDEBVNOPS, ("nnpfs_aio_write(%p): tokens: 0x%x\n",
inode, xn->tokens));
@@ -877,7 +949,11 @@ nnpfs_aio_write(struct kiocb *iocb,
return error;
}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
error = generic_file_aio_write(iocb, iov, nr_segs, pos);
+#else
+ error = generic_file_write_iter(iocb, from);
+#endif
if (!IS_ERR_VALUE(error))
xn->flags |= NNPFS_DATA_DIRTY; /* XXX race */
@@ -885,9 +961,21 @@ 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
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
+static int
+nnpfs_create(struct inode *dir, struct dentry *dentry,
+ umode_t mode, struct nameidata *nd)
+#else
+static int
+nnpfs_create(struct inode *dir, struct dentry *dentry,
+ umode_t mode, bool excl)
+#endif
+#endif
{
struct nnpfs *nnpfsp;
struct nnpfs_node *xn;
@@ -1038,8 +1126,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;
@@ -1252,8 +1345,13 @@ static int nnpfs_symlink(struct inode *d
/*
* We hold i_mutex.
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0))
static int
nnpfs_readdir(struct file * file, void * dirent, filldir_t filldir)
+#else
+static int
+nnpfs_iterate(struct file * file, struct dir_context *ctx)
+#endif
{
int error;
loff_t offset, begin_offset;
@@ -1328,6 +1426,7 @@ nnpfs_readdir(struct file * file, void *
(int) xdirent->d_namlen,
(int) (offset+begin_offset)));
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0))
if (xdirent->d_fileno != 0
&& (filldir_error = filldir (dirent,
xdirent->d_name,
@@ -1339,6 +1438,18 @@ nnpfs_readdir(struct file * file, void *
("nnpfs_readdir filldir: %d\n", filldir_error));
break;
}
+#else
+ if (xdirent->d_fileno != 0
+ && (filldir_error = dir_emit (ctx,
+ xdirent->d_name,
+ xdirent->d_namlen,
+ xdirent->d_fileno,
+ DT_UNKNOWN)) < 0) {
+ NNPFSDEB(XDEBREADDIR,
+ ("nnpfs_readdir filldir: %d\n", filldir_error));
+ break;
+ }
+#endif
offset += xdirent->d_reclen;
if (xdirent->d_reclen == 0) {
@@ -1490,6 +1601,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);
@@ -1533,8 +1646,13 @@ nnpfs_flush(struct file *file, fl_owner_
* Return 1 if `dentry' is still valid, otherwise 0.
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
+static int
+nnpfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+#else
static int
-nnpfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
+nnpfs_d_revalidate(struct dentry *dentry, unsigned int flags)
+#endif
{
struct inode *inode = DENTRY_TO_INODE(dentry);
NNPFSDEB(XDEBVNOPS, ("nnpfs_d_revalidate %p \"%.*s\" (inode %p)\n",
@@ -1582,9 +1700,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;
@@ -1706,7 +1830,9 @@ nnpfs_write_backpage(struct page *page,
unsigned long offset;
int error;
-
+
+ (void)offset;
+
do {
error = pagecache_write_begin(backfile, mapping, 0, len,
AOP_FLAG_UNINTERRUPTIBLE,
@@ -1747,6 +1873,8 @@ nnpfs_read_backpage(struct page *page, s
struct page *backpage;
unsigned long offset;
+ (void)offset;
+
backpage = read_mapping_page(mapping, n, backfile);
if (!IS_ERR(backpage)) {
wait_on_page_locked(backpage);
@@ -1893,12 +2021,18 @@ nnpfs_prepare_write(struct file *file, s
modsize = nnpfs_blocksize;
if (modsize > i_size_read(inode)) {
- int error;
+ int error=0;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0))
error = vmtruncate(inode, modsize);
+#else
+ if(!inode_newsize_ok(inode, modsize)) {
+ truncate_setsize(inode, modsize);
+ }
+#endif
if (error) {
printk("nnpfs_prepare_write: truncate(%llu) -> %d\n",
modsize, -error);
- BUG(); /* XXX not correct */
+ /*BUG();*/ /* XXX not correct */
}
}
@@ -1993,10 +2127,18 @@ nnpfs_write_end(struct file *file, struc
/* zero the stale part of the page if we did a short copy */
if (copied < len) {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
void *kaddr = kmap_atomic(page, KM_USER0);
+#else
+ void *kaddr = kmap_atomic(page);
+#endif
memset(kaddr + from + copied, 0, len - copied);
flush_dcache_page(page);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
kunmap_atomic(kaddr, KM_USER0);
+#else
+ kunmap_atomic(kaddr);
+#endif
}
nnpfs_commit_write(file, page, from, from + copied);
@@ -2027,8 +2169,13 @@ struct address_space_operations nnpfs_ao
*/
struct file_operations nnpfs_file_operations = {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,16,0))
.aio_read = nnpfs_aio_read,
.aio_write = nnpfs_aio_write,
+#else
+ .read_iter = nnpfs_read_iter,
+ .write_iter = nnpfs_write_iter,
+#endif
.mmap = nnpfs_file_mmap,
.open = nnpfs_open,
.flush = nnpfs_flush,
@@ -2041,7 +2188,11 @@ struct file_operations nnpfs_dead_operat
};
struct file_operations nnpfs_dir_operations = {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0))
.readdir = nnpfs_readdir,
+#else
+ .iterate = nnpfs_iterate,
+#endif
.flush = nnpfs_flush,
};
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_load.c arla-for-linux-3.18/nnpfs/linux/nnpfs_load.c
--- arla-cvs/nnpfs/linux/nnpfs_load.c 2006-10-31 11:02:41.000000000 +0100
+++ arla-for-linux-3.18/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-cvs/nnpfs/linux/nnpfs_message.c arla-for-linux-3.18/nnpfs/linux/nnpfs_message.c
--- arla-cvs/nnpfs/linux/nnpfs_message.c 2010-08-08 22:43:05.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_message.c 2016-01-11 20:48:18.770403715 +0100
@@ -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);
}
@@ -121,8 +127,14 @@ nnpfs_message_installnode(struct nnpfs *
struct inode *di, *inode;
struct dentry *parent = NULL;
struct qstr sqstr;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
struct list_head *alias;
-
+#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0))
+ struct hlist_node *alias;
+#endif
+#endif
+
NNPFSDEB(XDEBMSG, ("nnpfs_message_installnode\n"));
error = nnpfs_node_find(nnpfsp, &message->parent_handle, &dp);
@@ -176,12 +188,26 @@ nnpfs_message_installnode(struct nnpfs *
*
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
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);
+#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0))
+ hlist_for_each_entry(parent, alias, &di->i_dentry, d_alias) {
+#else
+ hlist_for_each_entry(parent, &di->i_dentry, d_alias) {
+#endif
+#endif
+#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",
@@ -233,7 +259,9 @@ nnpfs_message_installnode(struct nnpfs *
dput(dentry);
dentry = NULL;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
alias = alias->next;
+#endif
dput(parent);
}
NNPFSDEB(XDEBMSG, ("nnpfs_message_installnode: done installing\n"));
@@ -268,7 +296,11 @@ nnpfs_message_installattr(struct nnpfs *
}
inode = XNODE_TO_VNODE(t);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias);
+#else
+ dentry = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+#endif
NNPFSDEB(XDEBMSG, ("nnpfs_message_installattr name:%s\n",
dentry->d_name.name));
@@ -396,17 +428,38 @@ nnpfs_message_installdata(struct nnpfs *
static void
clear_all_children (struct inode *inode, int parent)
{
+ struct dentry *dentry;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
struct list_head *alias;
+#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0))
+ struct hlist_node *alias;
+#endif
+#endif
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
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
alias = inode->i_dentry.next;
while (alias != &inode->i_dentry) {
- struct dentry *dentry;
+#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0))
+ hlist_for_each_entry(dentry, alias, &inode->i_dentry, d_alias) {
+#else
+ hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
+#endif
+#endif
struct list_head *subdirs;
struct nnpfs_dentry_data *xd;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
dentry = list_entry(alias, struct dentry, d_alias);
+#endif
if (dentry == NULL) {
printk(KERN_EMERG "NNPFS Panic: dentry in alias list is null\n");
break;
@@ -442,14 +495,26 @@ 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;
}
}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
alias = alias->next;
+#endif
}
+#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
@@ -724,7 +789,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.
@@ -738,7 +807,6 @@ nnpfs_message_version(struct nnpfs *nnpf
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;
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_node.c arla-for-linux-3.18/nnpfs/linux/nnpfs_node.c
--- arla-cvs/nnpfs/linux/nnpfs_node.c 2007-01-03 14:52:02.000000000 +0100
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_node.c 2016-01-12 19:35:21.714083110 +0100
@@ -132,7 +132,13 @@ nnpfs_setsize(struct inode *inode, uint6
printk("nnpfs_setsize: truncating @0x%llu\n",
(unsigned long long)size);
#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0))
vmtruncate(inode, size); /* XXX retval */
+#else
+ if(!inode_newsize_ok(inode, size)) {
+ truncate_setsize(inode, size);
+ }
+#endif
nnpfs_block_truncate(xn, size);
}
}
@@ -150,9 +156,18 @@ nnpfs_attr2inode(const struct nnpfs_attr
struct timespec notime = {0};
inode->i_mode = 0;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
inode->i_uid = 0;
inode->i_gid = 0;
+#else
+ inode->i_uid = KUIDT_INIT(0);
+ inode->i_gid = KGIDT_INIT(0);
+#endif
+#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 +184,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);
@@ -510,11 +529,19 @@ nnpfs_has_pag(const struct nnpfs_node *x
int
nnpfs_node_users(struct inode *inode)
{
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
struct list_head *pos;
+#else
+ struct hlist_node *pos;
+#endif
int users = 0;
/* XXX this should probably be protected somehow */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
list_for_each(pos, &inode->i_dentry) {
+#else
+ hlist_for_each(pos, &inode->i_dentry) {
+#endif
struct dentry *dentry = list_entry(pos, struct dentry, d_alias);
if (nnpfs_dcount(dentry) > 1)
users++;
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_syscalls.c arla-for-linux-3.18/nnpfs/linux/nnpfs_syscalls.c
--- arla-cvs/nnpfs/linux/nnpfs_syscalls.c 2010-08-08 22:43:06.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_syscalls.c 2016-01-12 22:04:07.302380258 +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>
@@ -50,6 +52,11 @@
#include <linux/security.h>
#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
+#undef SYSCALLHACK
+/* the method to read 'lower_bound' does not work on later kernels, se nnpfs_syscalls-lossage.c */
+#endif
+
#if 0
#ifdef CONFIG_COMPAT
#include <linux/ioctl32.h>
@@ -82,12 +89,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
};
@@ -158,10 +175,14 @@ nnpfs_get_pag_sec(void)
if (pag)
return pag;
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28))
return current->uid;
#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
return current_uid();
+#else
+ { kuid_t kuid = current_uid(); return kuid.val; }
+#endif
#endif
}
@@ -199,7 +220,12 @@ find_pag(struct group_info *gi)
NNPFSDEB(XDEBSYS, ("find_pag: ngroups = %d\n", gi->ngroups));
for (i = gi->ngroups - 1; i >= 0; i--) {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
gid_t group = GROUP_AT(gi, i);
+#else
+ kgid_t kgroup = GROUP_AT(gi, i);
+ gid_t group = kgroup.val;
+#endif
if ((nnpfs_pag_t)group >= NNPFS_PAG_LLIM && (nnpfs_pag_t)group < NNPFS_PAG_ULIM) {
NNPFSDEB(XDEBSYS,
("find_pag: Existing pag %u at pos %u\n", group, i));
@@ -215,12 +241,17 @@ find_pag(struct group_info *gi)
static nnpfs_pag_t
nnpfs_get_pag_group(void)
{
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+#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();
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
nnpfs_pag_t ret = current_uid();
+#else
+ kuid_t kuid = current_uid();
+ nnpfs_pag_t ret = kuid.val;
+#endif
#endif
int i;
@@ -230,7 +261,11 @@ nnpfs_get_pag_group(void)
i = find_pag(gi);
if (i != NNPFS_PAG_NOTFOUND)
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
ret = GROUP_AT(gi, i);
+#else
+ { kgid_t kgid = GROUP_AT(gi, i); ret = kgid.val; }
+#endif
put_group_info(gi);
@@ -280,11 +315,18 @@ store_pag(nnpfs_pag_t pagnum)
count -= NGROUPS_PER_BLOCK;
}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
if (found)
GROUP_AT(new_gi, i) = pagnum;
else
GROUP_AT(new_gi, new_gi->ngroups - 1) = pagnum;
-
+#else
+ if (found)
+ { kgid_t kgid = KGIDT_INIT(pagnum); GROUP_AT(new_gi, i) = kgid; }
+ else
+ { kgid_t kgid = KGIDT_INIT(pagnum); GROUP_AT(new_gi, new_gi->ngroups - 1) = kgid; }
+#endif
+
set_current_groups(new_gi);
put_group_info(new_gi);
put_group_info(old_gi);
@@ -323,10 +365,14 @@ nnpfs_get_pag()
return nnpfs_get_pag_group();
#endif /* GROUPPAGS */
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28))
return current->uid;
#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
return current_uid();
+#else
+ { kuid_t kuid = current_uid(); return kuid.val; }
+#endif
#endif
}
@@ -432,7 +478,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;
@@ -522,11 +568,19 @@ nnpfs_debug_print (struct arlaViceIoctl
static struct dentry *
user_path2dentry (struct nameidata *nd, char *user_path, int follow)
{
- char *kname;
int flags = 0;
int error = 0;
- kname = getname (user_path);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
+ char *kname;
+ kname = getname(user_path);
+#else
+ const char *kname;
+ struct filename *fname;
+ fname = getname(user_path);
+ kname = fname->name;
+#endif
+
if (IS_ERR(kname))
return ERR_PTR(PTR_ERR(kname));
if (follow)
@@ -534,8 +588,16 @@ 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
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
putname(kname);
+#else
+ kmem_cache_free(names_cachep, (void *)kname);
+#endif
if (error)
return ERR_PTR(error);
return nd->path.dentry;
@@ -559,7 +621,11 @@ sys_afs_int (int operation,
if (msg == NULL)
return -ENOMEM;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
lock_kernel();
+#else
+ /* TODO: lock_kernel() is removed, consider adding an private lock */
+#endif
NNPFSDEB(XDEBSYS, ("sys_afs kernel locked\n"));
@@ -699,7 +765,11 @@ sys_afs_int (int operation,
NNPFSDEB(XDEBSYS, ("sys_afs kernel unlock\n"));
kfree(msg);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
unlock_kernel();
+#else
+ /* TODO: see the comment at lock_kernel() above */
+#endif
return error;
}
@@ -748,9 +818,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;
@@ -807,7 +883,11 @@ static int nnpfs_init_procfs(void)
nnpfs_procfs_dir->owner = THIS_MODULE;
#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0))
entry = create_proc_entry(NNPFS_PROC_NODE, 0666, nnpfs_procfs_dir);
+#else
+ entry = proc_create(NNPFS_PROC_NODE, 0, NULL, &nnpfs_procfs_fops);
+#endif
if (entry == NULL) {
NNPFSDEB(XDEBSYS, ("nnpfs_init_procfs: no node\n"));
remove_proc_entry("fs/" NNPFS_PROC_DIR, NULL);
@@ -817,7 +897,9 @@ static int nnpfs_init_procfs(void)
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
entry->owner = THIS_MODULE;
#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0))
entry->proc_fops = &nnpfs_procfs_fops;
+#endif
#ifdef SYSCALLCOMPAT
if (register_ioctl32_conversion(ARLA_VIOC_SYSCALL32, nnpfs_procfs_ioctl32)) {
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_syscalls-lossage.c arla-for-linux-3.18/nnpfs/linux/nnpfs_syscalls-lossage.c
--- arla-cvs/nnpfs/linux/nnpfs_syscalls-lossage.c 2010-08-08 22:43:05.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_syscalls-lossage.c 2016-01-12 13:37:05.657367471 +0100
@@ -50,8 +50,17 @@
RCSID("$Id: nnpfs_syscalls-lossage.c,v 1.19 2010/08/08 20:43:05 tol Exp $");
#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
+/* the method to read 'lower_bound' does not work on later kernels */
+#undef SYSCALLHACK
+#endif
+
#include <linux/kallsyms.h>
+#ifdef SYSCALLHACK
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
static void *lower_bound = &kernel_thread;
+#endif
+#endif
void * __attribute__((weak)) sys_call_table(void);
nnpfs_sys_call_function *nnpfs_sys_call_table =
@@ -66,6 +75,8 @@ const char * __attribute__((weak))
#ifdef __x86_64__
extern rwlock_t tasklist_lock __attribute__((weak));
#endif
+
+#ifdef SYSCALLHACK
static void **
get_start_addr(void) {
#ifdef __x86_64__
@@ -74,6 +85,7 @@ get_start_addr(void) {
return (void **)&mutex_lock;
#endif
}
+#endif
static inline int
kallsym_is_equal(unsigned long addr, const char *name)
@@ -142,6 +154,8 @@ verify(void **p) {
return 1;
}
+#ifdef SYSCALLHACK
+
static inline int looks_good(void **p)
{
if (*p <= (void*)lower_bound || *p >= (void*)p)
@@ -191,3 +205,5 @@ nnpfs_fixup_syscall_lossage(void)
return 0;
}
+
+#endif
diff -uprN -Xnodiff.txt arla-cvs/nnpfs/linux/nnpfs_vfsops.c arla-for-linux-3.18/nnpfs/linux/nnpfs_vfsops.c
--- arla-cvs/nnpfs/linux/nnpfs_vfsops.c 2010-08-08 22:43:06.000000000 +0200
+++ arla-for-linux-3.18/nnpfs/linux/nnpfs_vfsops.c 2016-01-12 20:23:08.738178558 +0100
@@ -50,7 +50,9 @@ RCSID("$Id: nnpfs_vfsops.c,v 1.111 2010/
struct nnpfs nnpfs[NNNPFS];
static void nnpfs_put_super(struct super_block *sb);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
static void nnpfs_write_super(struct super_block * sb);
+#endif
static int nnpfs_statfs(struct dentry *dentry, struct kstatfs *buf);
@@ -59,7 +61,9 @@ static struct super_operations nnpfs_sop
destroy_inode : nnpfs_node_free,
drop_inode : generic_delete_inode,
put_super : nnpfs_put_super,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
write_super : nnpfs_write_super,
+#endif
statfs : nnpfs_statfs,
};
@@ -86,7 +90,11 @@ nnpfs_fetch_root(struct inode *i)
* root's priviliges (usually none, and none is needed).
*/
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
msg.cred.uid = 0;
+#else
+ msg.cred.uid = KUIDT_INIT(0);
+#endif
msg.cred.pag = 0;
error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
@@ -121,8 +129,13 @@ make_root_inode(struct nnpfs *nnpfsp)
XA_SET_MODE(&node.attr, S_IFDIR | 0777);
XA_SET_NLINK(&node.attr, 100);
XA_SET_SIZE(&node.attr, 0);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0))
XA_SET_UID(&node.attr, 0);
XA_SET_GID(&node.attr, 0);
+#else
+ XA_SET_UID(&node.attr, KUIDT_INIT(0));
+ XA_SET_GID(&node.attr, KGIDT_INIT(0));
+#endif
XA_SET_ATIME(&node.attr, 0);
XA_SET_MTIME(&node.attr, 0);
XA_SET_CTIME(&node.attr, 0);
@@ -151,7 +164,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;
@@ -177,7 +194,11 @@ 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
@@ -225,6 +246,7 @@ nnpfs_fill_super (struct super_block *sb
return 0;
}
+#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,
@@ -232,12 +254,23 @@ nnpfs_get_sb(struct file_system_type *fs
{
return get_sb_nodev(fs_type, flags, data, nnpfs_fill_super, mnt);
}
+#else
+struct dentry*
+nnpfs_mount(struct file_system_type *fs_type,
+ int flags, const char *dev_name,
+ void *data)
+{
+ return mount_nodev(fs_type, flags, data, nnpfs_fill_super);
+}
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0))
static void
nnpfs_write_super(struct super_block * sb)
{
sb->s_dirt = 0;
}
+#endif
/*
* XXX is this good?
More information about the Arla-drinkers
mailing list