[linux-cifs-client] cifs 1.45 for 2.4.x

Yehuda Sadeh Weinraub Yehuda.Sadeh at expand.com
Sun Jul 30 05:47:32 GMT 2006


Hi,

The following patch is my rough backport of the cifs module (version
1.45) to 2.4 kernel (specifically to RedHat's 2.4.18-3 and 2.4.21-XX,
but it was also compiled against a vanilla kernel). It was only tested
basically, so you should use it with the appropriate caution.

Yehuda Sadeh-Weinraub

[part 1/2]

diff -urN cifs-2.6-old-kernels/fs/cifs/Makefile-24
cifs-2.4/fs/cifs/Makefile-24
--- cifs-2.6-old-kernels/fs/cifs/Makefile-24	Tue May 23 10:25:31 2006
+++ cifs-2.4/fs/cifs/Makefile-24	Sun Jul 30 08:38:09 2006
@@ -3,8 +3,7 @@
 #
 O_TARGET := cifs.o
 
-obj-y := nterr.o md4.o md5.o netmisc.o smbdes.o smbencrypt.o asn1.o
cifs_unicode.o cifsencrypt.o cifs_debug.o cifssmb.o connect.o misc.o
dir.o inode.o link.o transport.o cifsfs.o file.o
-
+obj-y := cifsfs.o cifssmb.o cifs_debug.o connect.o dir.o file.o inode.o
link.o misc.o netmisc.o smbdes.o smbencrypt.        o transport.o asn1.o
md4.o md5.o cifs_unicode.o nterr.o xattr.o cifsencrypt.o fcntl.o
readdir.o ioctl.o sess.o mempool_compat.o
 obj-m := $(O_TARGET)
 
 include $(TOPDIR)/Rules.make
diff -urN cifs-2.6-old-kernels/fs/cifs/Makefile.orig
cifs-2.4/fs/cifs/Makefile.orig
--- cifs-2.6-old-kernels/fs/cifs/Makefile.orig	Tue May 23 10:25:31 2006
+++ cifs-2.4/fs/cifs/Makefile.orig	Sun Jul 17 10:23:35 2005
@@ -1,6 +1,11 @@
 #
 # Makefile for Linux CIFS VFS client 
 #
-obj-$(CONFIG_CIFS) += cifs.o
+O_TARGET := cifs.o
+EXTRA_CFLAGS += -DMODULE
 
-cifs-objs := cifsfs.o cifssmb.o cifs_debug.o connect.o dir.o file.o
inode.o link.o misc.o netmisc.o smbdes.o smbencrypt.o transport.o asn1.o
md4.o md5.o cifs_unicode.o nterr.o xattr.o cifsencrypt.o fcntl.o
readdir.o ioctl.o ntlmssp.o
+obj-y := cifsfs.o cifssmb.o cifs_debug.o connect.o dir.o file.o inode.o
link.o misc.o netmisc.o smbdes.o smbencrypt.o transport.o asn1.o md4.o
md5.o cifs_unicode.o nterr.o cifsencrypt.o
+
+obj-m := $(O_TARGET)
+
+include $(TOPDIR)/Rules.make
diff -urN cifs-2.6-old-kernels/fs/cifs/cifs_compat.h
cifs-2.4/fs/cifs/cifs_compat.h
--- cifs-2.6-old-kernels/fs/cifs/cifs_compat.h	Thu Jan  1 02:00:00 1970
+++ cifs-2.4/fs/cifs/cifs_compat.h	Thu Jul 27 15:11:25 2006
@@ -0,0 +1,28 @@
+#ifndef _CIFS_COMPAT_H
+#define _CIFS_COMPAT_H
+
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
+#define LNXKERN26
+#else
+#define LNXKERN24
+#endif
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 4, 18)
+#define CIFS_HAVE_DUMP_STACK
+#endif
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 4, 20)
+#define CIFS_HAVE_VFS_ALLOC_INODE
+#define CIFS_HAVE_AIO
+#endif
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 21)
+#ifndef RED_HAT_LINUX_KERNEL
+#define CIFS_USE_MEMPOOL_COMPAT
+#endif
+#define CIFS_NEED_MEMPOOL_ALLOC_SLAB
+#endif
+
+#endif
diff -urN cifs-2.6-old-kernels/fs/cifs/cifsfs.c
cifs-2.4/fs/cifs/cifsfs.c
--- cifs-2.6-old-kernels/fs/cifs/cifsfs.c	Mon Jul 24 15:13:13 2006
+++ cifs-2.4/fs/cifs/cifsfs.c	Thu Jul 27 15:11:25 2006
@@ -23,6 +23,8 @@
 
 /* Note that BB means BUGBUG (ie something to fix eventually) */
 
+#include "cifs_compat.h"
+
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/mount.h>
@@ -31,7 +33,11 @@
 #include <linux/list.h>
 #include <linux/seq_file.h>
 #include <linux/vfs.h>
+#ifndef CIFS_USE_MEMPOOL_COMPAT
 #include <linux/mempool.h>
+#else
+#include "mempool_compat.h"
+#endif
 #include <linux/delay.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
@@ -41,9 +47,11 @@
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
 #include <linux/mm.h>
+#ifdef LNXKERN26
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)
 #include <linux/moduleparam.h>
 #endif
+#endif
 #define CIFS_MAGIC_NUMBER 0xFF534D42	/* the first four bytes of SMB
PDUs */
 
 #ifdef CONFIG_CIFS_QUOTA
@@ -66,16 +74,32 @@
 extern struct task_struct * dnotifyThread; /* remove sparse warning */
 struct task_struct * dnotifyThread = NULL;
 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
+#ifdef LNXKERN26
 module_param(CIFSMaxBufSize, int, 0);
+#else
+MODULE_PARM(CIFSMaxBufSize, "i");
+#endif
 MODULE_PARM_DESC(CIFSMaxBufSize,"Network buffer size (not including
header). Default: 16384 Range: 8192 to 130048");
 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
+#ifdef LNXKERN26
 module_param(cifs_min_rcv, int, 0);
+#else
+MODULE_PARM(cifs_min_rcv, "i");
+#endif
 MODULE_PARM_DESC(cifs_min_rcv,"Network buffers in pool. Default: 4
Range: 1 to 64");
 unsigned int cifs_min_small = 30;
+#ifdef LNXKERN26
 module_param(cifs_min_small, int, 0);
+#else
+MODULE_PARM(cifs_min_small, "i");
+#endif
 MODULE_PARM_DESC(cifs_min_small,"Small network buffers in pool.
Default: 30 Range: 2 to 256");
 unsigned int cifs_max_pending = CIFS_MAX_REQ;
+#ifdef LNXKERN26
 module_param(cifs_max_pending, int, 0);
+#else
+MODULE_PARM(cifs_max_pending, "i");
+#endif
 MODULE_PARM_DESC(cifs_max_pending,"Simultaneous requests to server.
Default: 50 Range: 2 to 256");
 
 static DECLARE_COMPLETION(cifs_oplock_exited);
@@ -87,19 +111,34 @@
 
 extern kmem_cache_t *cifs_oplock_cachep;
 
+#ifdef LNXKERN26
 static int
 cifs_read_super(struct super_block *sb, void *data,
 		const char *devname, int silent)
+#else
+static struct super_block *
+cifs_read_super(struct super_block *sb, void *data,
+		int silent)
+#endif
 {
 	struct inode *inode;
 	struct cifs_sb_info *cifs_sb;
 	int rc = 0;
+#ifdef LNXKERN24
+    void *devname = NULL;
+#endif
 
 	sb->s_flags |= MS_NODIRATIME; /* and probably even noatime */
+#ifdef LNXKERN26
 	sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info),GFP_KERNEL);
+#endif
 	cifs_sb = CIFS_SB(sb);
 	if(cifs_sb == NULL)
+#ifdef LNXKERN26
 		return -ENOMEM;
+#else
+		return 0;
+#endif
 
 	rc = cifs_mount(sb, cifs_sb, data, devname);
 
@@ -133,7 +172,11 @@
 		goto out_no_root;
 	}
 
+#ifdef LNXKERN26
 	return 0;
+#else
+    return sb;
+#endif
 
 out_no_root:
 	cERROR(1, ("cifs_read_super: get root inode failed"));
@@ -146,7 +189,11 @@
 			unload_nls(cifs_sb->local_nls);	
 		kfree(cifs_sb);
 	}
+#ifdef LNXKERN26
 	return rc;
+#else
+    return 0;
+#endif
 }
 
 static void
@@ -181,9 +228,13 @@
 }
 #endif
 
-
+#ifdef LNXKERN26
 static int
 cifs_statfs(struct super_block *sb, struct kstatfs *buf)
+#else
+static int
+cifs_statfs(struct super_block *sb, struct statfs *buf)
+#endif
 {
 	int xid; 
 	int rc = -EOPNOTSUPP;
@@ -232,7 +283,11 @@
 				   longer available? */
 }
 
+#ifdef LNXKERN26
 static int cifs_permission(struct inode * inode, int mask, struct
nameidata *nd)
+#else
+static int cifs_permission(struct inode * inode, int mask)
+#endif
 {
 	struct cifs_sb_info *cifs_sb;
 
@@ -251,7 +306,9 @@
 #endif /* LINUX version */
 }
 
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 static kmem_cache_t *cifs_inode_cachep;
+#endif
 static kmem_cache_t *cifs_req_cachep;
 static kmem_cache_t *cifs_mid_cachep;
 kmem_cache_t *cifs_oplock_cachep;
@@ -260,6 +317,7 @@
 mempool_t *cifs_req_poolp;
 mempool_t *cifs_mid_poolp;
 
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 static struct inode *
 cifs_alloc_inode(struct super_block *sb)
 {
@@ -267,18 +325,7 @@
 	cifs_inode = kmem_cache_alloc(cifs_inode_cachep, SLAB_KERNEL);
 	if (!cifs_inode)
 		return NULL;
-	cifs_inode->cifsAttrs = 0x20;	/* default */
-	atomic_set(&cifs_inode->inUse, 0);
-	cifs_inode->time = 0;
-	/* Until the file is open and we have gotten oplock
-	info back from the server, can not assume caching of
-	file data or metadata */
-	cifs_inode->clientCanCacheRead = FALSE;
-	cifs_inode->clientCanCacheAll = FALSE;
-	cifs_inode->vfs_inode.i_blksize = CIFS_MAX_MSGSIZE;
-	cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 =
CIFS_MAX_MSGSIZE */
-	cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;
-	INIT_LIST_HEAD(&cifs_inode->openFileList);
+    cifs_init_inode(VFS_I(cifs_inode));
 	return &cifs_inode->vfs_inode;
 }
 
@@ -287,7 +334,7 @@
 {
 	kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 }
-
+#endif
 /*
  * cifs_show_options() is for displaying mount options in /proc/mounts.
  * Not all settable options are displayed but most of the important
@@ -422,7 +469,7 @@
 };
 #endif
 
-#ifdef CONFIG_CIFS_EXPERIMENTAL
+//#ifdef CONFIG_CIFS_EXPERIMENTAL
 static void cifs_umount_begin(struct super_block * sblock)
 {
 	struct cifs_sb_info *cifs_sb;
@@ -467,8 +514,10 @@
 	.read_inode = cifs_read_inode,
 	.put_super = cifs_put_super,
 	.statfs = cifs_statfs,
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 	.alloc_inode = cifs_alloc_inode,
 	.destroy_inode = cifs_destroy_inode,
+#endif
 /*	.drop_inode	    = generic_delete_inode, 
 	.delete_inode	= cifs_delete_inode,  *//* Do not need the above
two functions     
    unless later we add lazy close of inodes or unless the kernel
forgets to call
@@ -478,6 +527,60 @@
 	.remount_fs = cifs_remount,
 };
 
+#ifdef LNXKERN24
+static ssize_t
+cifs_read_wrapper(struct file * file, char *read_data, size_t
read_size,
+          loff_t * poffset)
+{
+	if(file == NULL)
+		return -EIO;
+	else if(file->f_dentry == NULL)
+		return -EIO;
+	else if(file->f_dentry->d_inode == NULL)
+		return -EIO;
+
+	if(CIFS_I(file->f_dentry->d_inode)->clientCanCacheRead) {
+		return
generic_file_read(file,read_data,read_size,poffset);
+	} else {
+		/* BB do we need to lock inode from here until after
invalidate? */
+/*		if(file->f_dentry->d_inode->i_mapping) {
+
filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
+
filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
+		}*/
+/*		cifs_revalidate(file->f_dentry);*/ /* BB fixme */
+
+		/* BB we should make timer configurable - perhaps 
+		   by simply calling cifs_revalidate here */
+		/* invalidate_remote_inode(file->f_dentry->d_inode);*/
+		return
generic_file_read(file,read_data,read_size,poffset);
+	}
+}
+
+static ssize_t
+cifs_write_wrapper(struct file * file, const char *write_data,
+           size_t write_size, loff_t * poffset) 
+{
+	ssize_t written;
+
+	if(file == NULL)
+		return -EIO;
+	else if(file->f_dentry == NULL)
+		return -EIO;
+	else if(file->f_dentry->d_inode == NULL)
+		return -EIO;
+
+	/* check whether we can cache writes locally */
+	written =
generic_file_write(file,write_data,write_size,poffset);
+	if(!CIFS_I(file->f_dentry->d_inode)->clientCanCacheAll)  {
+		if(file->f_dentry->d_inode->i_mapping) {
+
filemap_fdatasync(file->f_dentry->d_inode->i_mapping);
+		}
+	}
+	return written;
+}
+#endif
+
+#ifdef LNXKERN26
 static struct super_block *
 cifs_get_sb(struct file_system_type *fs_type,
 	    int flags, const char *dev_name, void *data)
@@ -510,10 +613,11 @@
 
 	written = generic_file_writev(file, iov, nr_segs, ppos);
 	if (!CIFS_I(inode)->clientCanCacheAll)
-		filemap_fdatawrite(inode->i_mapping);
+		FILEMAP_SYNC(inode->i_mapping);
 	return written;
 }
-
+#endif
+#ifdef LNXKERN26
 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const char
__user *buf,
 				   size_t count, loff_t pos)
 {
@@ -521,10 +625,26 @@
 	ssize_t written;
 
 	written = generic_file_aio_write(iocb, buf, count, pos);
+
 	if (!CIFS_I(inode)->clientCanCacheAll)
-		filemap_fdatawrite(inode->i_mapping);
+		FILEMAP_SYNC(inode->i_mapping);
 	return written;
 }
+#else
+#ifdef CIFS_HAVE_AIO
+static ssize_t cifs_file_aio_write(struct file *file, struct kiocb
*req, struct iocb *iocb)
+{
+	struct inode *inode = file->f_dentry->d_inode;
+	ssize_t written;
+
+	written = generic_file_aio_write(file, req, iocb);
+
+	if (!CIFS_I(inode)->clientCanCacheAll)
+		FILEMAP_SYNC(inode->i_mapping);
+    return written;
+}
+#endif
+#endif
 
 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 {
@@ -534,9 +654,14 @@
 		if (retval < 0)
 			return (loff_t)retval;
 	}
+#ifdef LNXKERN26
 	return remote_llseek(file, offset, origin);
+#else
+	return generic_file_llseek(file, offset, origin);
+#endif
 }
 
+#ifdef LNXKERN26
 static struct file_system_type cifs_fs_type = {
 	.owner = THIS_MODULE,
 	.name = "cifs",
@@ -544,10 +669,21 @@
 	.kill_sb = kill_anon_super,
 	/*  .fs_flags */
 };
+#else
+static struct file_system_type cifs_fs_type = {
+	.name = "cifs",
+	.read_super = cifs_read_super,
+	.fs_flags = 0,
+	.owner = THIS_MODULE,
+};
+#endif
+
 struct inode_operations cifs_dir_inode_ops = {
 	.create = cifs_create,
 	.lookup = cifs_lookup,
+#ifdef LNXKERN26
 	.getattr = cifs_getattr,
+#endif
 	.unlink = cifs_unlink,
 	.link = cifs_hardlink,
 	.mkdir = cifs_mkdir,
@@ -569,7 +705,9 @@
 struct inode_operations cifs_file_inode_ops = {
 /*	revalidate:cifs_revalidate, */
 	.setattr = cifs_setattr,
+#ifdef LNXKERN26
 	.getattr = cifs_getattr, /* do we need this anymore? */
+#endif
 	.rename = cifs_rename,
 	.permission = cifs_permission,
 #ifdef CONFIG_CIFS_XATTR
@@ -601,19 +739,30 @@
 };
 
 struct file_operations cifs_file_ops = {
+#ifdef LNXKERN26
 	.read = do_sync_read,
 	.write = do_sync_write,
+#else
+	.read = cifs_read_wrapper,
+	.write = cifs_write_wrapper,
+#endif
+#ifdef LNXKERN26
 	.readv = generic_file_readv,
 	.writev = cifs_file_writev,
+#endif
+#ifdef CIFS_HAVE_AIO
 	.aio_read = generic_file_aio_read,
 	.aio_write = cifs_file_aio_write,
+#endif
 	.open = cifs_open,
 	.release = cifs_close,
 	.lock = cifs_lock,
 	.fsync = cifs_fsync,
 	.flush = cifs_flush,
 	.mmap  = cifs_file_mmap,
+#ifdef LNXKERN26
 	.sendfile = generic_file_sendfile,
+#endif
 	.llseek = cifs_llseek,
 #ifdef CONFIG_CIFS_POSIX
 	.ioctl	= cifs_ioctl,
@@ -634,7 +783,9 @@
 	.lock = cifs_lock,
 	.fsync = cifs_fsync,
 	.flush = cifs_flush,
+#ifdef LNXKERN26
 	.sendfile = generic_file_sendfile, /* BB removeme BB */
+#endif
 #ifdef CONFIG_CIFS_POSIX
 	.ioctl  = cifs_ioctl,
 #endif /* CONFIG_CIFS_POSIX */
@@ -644,18 +795,29 @@
 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 };
 struct file_operations cifs_file_nobrl_ops = {
+#ifdef LNXKERN26
 	.read = do_sync_read,
 	.write = do_sync_write,
+#else
+	.read = cifs_read_wrapper,
+	.write = cifs_write_wrapper,
+#endif
+#ifdef LNXKERN26
 	.readv = generic_file_readv,
 	.writev = cifs_file_writev,
+#endif
+#ifdef CIFS_HAVE_AIO
 	.aio_read = generic_file_aio_read,
 	.aio_write = cifs_file_aio_write,
+#endif
 	.open = cifs_open,
 	.release = cifs_close,
 	.fsync = cifs_fsync,
 	.flush = cifs_flush,
 	.mmap  = cifs_file_mmap,
+#ifdef LNXKERN26
 	.sendfile = generic_file_sendfile,
+#endif
 	.llseek = cifs_llseek,
 #ifdef CONFIG_CIFS_POSIX
 	.ioctl	= cifs_ioctl,
@@ -675,7 +837,9 @@
 	.release = cifs_close,
 	.fsync = cifs_fsync,
 	.flush = cifs_flush,
+#ifdef LNXKERN26
 	.sendfile = generic_file_sendfile, /* BB removeme BB */
+#endif
 #ifdef CONFIG_CIFS_POSIX
 	.ioctl  = cifs_ioctl,
 #endif /* CONFIG_CIFS_POSIX */
@@ -695,6 +859,7 @@
         .ioctl  = cifs_ioctl,
 };
 
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 static void
 cifs_init_once(void *inode, kmem_cache_t * cachep, unsigned long flags)
 {
@@ -702,17 +867,23 @@
 
 	if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==
 	    SLAB_CTOR_CONSTRUCTOR) {
-		inode_init_once(&cifsi->vfs_inode);
+		inode_init_once(VFS_I(cifsi));
 		INIT_LIST_HEAD(&cifsi->lockList);
 	}
 }
 
+#ifdef LNXKERN26
+#define CIFS_SLAB_FLAGS (SLAB_RECLAIM_ACCOUNT)
+#else
+#define CIFS_SLAB_FLAGS (SLAB_HWCACHE_ALIGN)
+#endif
+
 static int
 cifs_init_inodecache(void)
 {
 	cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 					      sizeof (struct
cifsInodeInfo),
-					      0, SLAB_RECLAIM_ACCOUNT,
+					      0, CIFS_SLAB_FLAGS,
 					      cifs_init_once, NULL);
 	if (cifs_inode_cachep == NULL)
 		return -ENOMEM;
@@ -726,6 +897,21 @@
 	if (kmem_cache_destroy(cifs_inode_cachep))
 		printk(KERN_WARNING "cifs_inode_cache: error
freeing\n");
 }
+#endif
+
+#ifdef CIFS_NEED_MEMPOOL_ALLOC_SLAB
+void *mempool_alloc_slab(int gfp_mask, void *pool_data)
+{
+    kmem_cache_t *mem = (kmem_cache_t *) pool_data;
+    return kmem_cache_alloc(mem, gfp_mask);
+}
+
+void mempool_free_slab(void *element, void *pool_data)
+{
+    kmem_cache_t *mem = (kmem_cache_t *) pool_data;
+    kmem_cache_free(mem, element);
+}
+#endif
 
 static int
 cifs_init_request_bufs(void)
@@ -828,14 +1014,16 @@
 					mempool_alloc_slab,
 					mempool_free_slab,
 					cifs_mid_cachep);
+
 	if(cifs_mid_poolp == NULL) {
 		kmem_cache_destroy(cifs_mid_cachep);
 		return -ENOMEM;
 	}
 
-	cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
+	cifs_oplock_cachep = kmem_cache_create("cifs_oplock_str",
 				sizeof (struct oplock_q_entry), 0,
 				SLAB_HWCACHE_ALIGN, NULL, NULL);
+
 	if (cifs_oplock_cachep == NULL) {
 		kmem_cache_destroy(cifs_mid_cachep);
 		mempool_destroy(cifs_mid_poolp);
@@ -866,8 +1054,12 @@
 	__u16  netfid;
 	int rc;
 
+#ifdef LNXKERN26
 	daemonize("cifsoplockd");
 	allow_signal(SIGTERM);
+#else
+	daemonize();
+#endif
 
 	oplockThread = current;
 	do {
@@ -897,10 +1089,14 @@
 				the call */
 				/* mutex_lock(&inode->i_mutex);*/
 				if (S_ISREG(inode->i_mode)) {
-					rc =
filemap_fdatawrite(inode->i_mapping);
+					rc =
FILEMAP_SYNC(inode->i_mapping);
 
if(CIFS_I(inode)->clientCanCacheRead == 0) {
 
filemap_fdatawait(inode->i_mapping);
+#ifdef LNXKERN26
 
invalidate_remote_inode(inode);
+#else
+
invalidate_inode_pages(inode);
+#endif
 					}
 				} else
 					rc = 0;
@@ -937,8 +1133,12 @@
 	struct list_head *tmp;
 	struct cifsSesInfo *ses;
 
+#ifdef LNXKERN26
 	daemonize("cifsdnotifyd");
 	allow_signal(SIGTERM);
+#else
+    daemonize();
+#endif
 
 	dnotifyThread = current;
 	do {
@@ -1010,7 +1210,9 @@
 		cFYI(1,("cifs_max_pending set to max of 256"));
 	}
 
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 	rc = cifs_init_inodecache();
+#endif
 	if (!rc) {
 		rc = cifs_init_mids();
 		if (!rc) {
@@ -1035,7 +1237,9 @@
 			}
 			cifs_destroy_mids();
 		}
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 		cifs_destroy_inodecache();
+#endif
 	}
 #ifdef CONFIG_PROC_FS
 	cifs_proc_clean();
@@ -1051,7 +1255,9 @@
 	cifs_proc_clean();
 #endif
 	unregister_filesystem(&cifs_fs_type);
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 	cifs_destroy_inodecache();
+#endif
 	cifs_destroy_mids();
 	cifs_destroy_request_bufs();
 	if(oplockThread) {
@@ -1068,6 +1274,8 @@
 MODULE_LICENSE("GPL");		/* combination of LGPL + GPL source
behaves as GPL */
 MODULE_DESCRIPTION
     ("VFS to access servers complying with the SNIA CIFS Specification
e.g. Samba and Windows");
+#ifdef LNXKERN26
 MODULE_VERSION(CIFS_VERSION);
+#endif
 module_init(init_cifs)
 module_exit(exit_cifs)
diff -urN cifs-2.6-old-kernels/fs/cifs/cifsfs.h
cifs-2.4/fs/cifs/cifsfs.h
--- cifs-2.6-old-kernels/fs/cifs/cifsfs.h	Mon Jul 24 15:13:14 2006
+++ cifs-2.4/fs/cifs/cifsfs.h	Thu Jul 27 15:11:25 2006
@@ -31,10 +31,22 @@
 #ifndef TRUE
 #define TRUE 1
 #endif
+
+#ifndef __user
+#define __user
+#endif
+
 #include <linux/version.h>
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
 #define current_fs_time(arg) CURRENT_TIME
 #endif
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
+#define LNXKERN26
+#else
+#define LNXKERN24
+#endif
+
 extern struct address_space_operations cifs_addr_ops;
 extern struct address_space_operations cifs_addr_ops_smallbuf;
 
@@ -52,17 +64,27 @@
 #else
 extern int cifs_create(struct inode *, struct dentry *, int);
 #endif
+#ifdef LNXKERN26
 extern struct dentry * cifs_lookup(struct inode *, struct dentry *,
 				  struct nameidata *);
+#else
+extern struct dentry * cifs_lookup(struct inode *, struct dentry *);
+#endif
 extern int cifs_unlink(struct inode *, struct dentry *);
 extern int cifs_hardlink(struct dentry *, struct inode *, struct dentry
*);
+#ifdef LNXKERN26
 extern int cifs_mknod(struct inode *, struct dentry *, int, dev_t);
+#else
+extern int cifs_mknod(struct inode *, struct dentry *, int, int);
+#endif
 extern int cifs_mkdir(struct inode *, struct dentry *, int);
 extern int cifs_rmdir(struct inode *, struct dentry *);
 extern int cifs_rename(struct inode *, struct dentry *, struct inode *,
 		       struct dentry *);
 extern int cifs_revalidate(struct dentry *);
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
 extern int cifs_getattr(struct vfsmount *, struct dentry *, struct
kstat *);
+#endif
 extern int cifs_setattr(struct dentry *, struct iattr *);
 
 extern struct inode_operations cifs_file_inode_ops;
diff -urN cifs-2.6-old-kernels/fs/cifs/cifsglob.h
cifs-2.4/fs/cifs/cifsglob.h
--- cifs-2.6-old-kernels/fs/cifs/cifsglob.h	Mon Jul 24 15:13:14 2006
+++ cifs-2.4/fs/cifs/cifsglob.h	Thu Jul 27 15:11:25 2006
@@ -19,6 +19,8 @@
 #include <linux/in6.h>
 #include <linux/version.h>
 #include "cifs_fs_sb.h"
+#include "cifs_compat.h"
+
 /*
  * The sizes of various internal tables and strings
  */
@@ -329,20 +331,28 @@
 	unsigned clientCanCacheRead:1; /* read oplock */
 	unsigned clientCanCacheAll:1;  /* read and writebehind oplock */
 	unsigned oplockPending:1;
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 	struct inode vfs_inode;
+#else
+	struct inode *vfs_inode;
+#endif
 };
 
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
+#ifndef container_of
+#define container_of list_entry
+#endif
+
+#ifdef CIFS_HAVE_VFS_ALLOC_INODE
 static inline struct cifsInodeInfo *
 CIFS_I(struct inode *inode)
 {
 	return container_of(inode, struct cifsInodeInfo, vfs_inode);
 }
 
-static inline struct cifs_sb_info *
-CIFS_SB(struct super_block *sb)
+static inline struct inode *
+VFS_I(struct cifsInodeInfo *cifs_inode)
 {
-	return sb->s_fs_info;
+	return &cifs_inode->vfs_inode;
 }
 #else
 static inline struct cifsInodeInfo *
@@ -351,6 +361,20 @@
 	return (struct cifsInodeInfo *)&(inode->u);
 }
 
+static inline struct inode *
+VFS_I(struct cifsInodeInfo *cifs_inode)
+{
+	return cifs_inode->vfs_inode;
+}
+#endif
+
+#ifndef LNXKERN24
+static inline struct cifs_sb_info *
+CIFS_SB(struct super_block *sb)
+{
+	return sb->s_fs_info;
+}
+#else
 static inline struct cifs_sb_info *
 CIFS_SB(struct super_block *sb)
 {
@@ -587,3 +611,39 @@
 GLOBAL_EXTERN unsigned int cifs_min_small;  /* min size of small buf
pool */
 GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to
server*/
 
+#ifdef LNXKERN26
+#define TIME_EQUAL(x, y) timespec_equal(&x, &y)
+#define FILEMAP_SYNC filemap_fdatawrite
+#else
+#define TIME_EQUAL(x, y) (x == y)
+#define FILEMAP_SYNC filemap_fdatasync
+#endif
+
+#ifdef CIFS_HAVE_DUMP_STACK
+#define DUMP_STACK() dump_stack()
+#else
+#define DUMP_STACK()
+#endif
+
+#ifndef WARN_ON
+#define WARN_ON(condition) do { \
+    if (unlikely((condition)!=0)) { \
+        printk("Badness in %s at %s:%d\n", __FUNCTION__, __FILE__,
__LINE__); \
+        DUMP_STACK(); \
+    } \
+} while (0)
+#endif
+
+#ifndef list_for_each_entry
+#define list_for_each_entry(pos, head, member)              \
+    for (pos = list_entry((head)->next, typeof(*pos), member),  \
+             prefetch(pos->member.next);            \
+         &pos->member != (head);                    \
+         pos = list_entry(pos->member.next, typeof(*pos), member),  \
+             prefetch(pos->member.next))
+
+#endif
+
+extern void cifs_init_inode(struct inode *inode);
+extern struct inode * get_cifs_inode(struct super_block * sb);
+
diff -urN cifs-2.6-old-kernels/fs/cifs/cifsproto.h
cifs-2.4/fs/cifs/cifsproto.h
--- cifs-2.6-old-kernels/fs/cifs/cifsproto.h	Mon Jul 24 15:13:14 2006
+++ cifs-2.4/fs/cifs/cifsproto.h	Thu Jul 27 15:11:25 2006
@@ -25,6 +25,10 @@
 
 struct statfs;
 
+#ifndef __user
+#define __user
+#endif
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8)
 #define kvec iovec
 #endif
@@ -87,8 +91,8 @@
 extern struct timespec cifs_NTtimeToUnix(u64 /* utc nanoseconds since
1601 */ );
 extern u64 cifs_UnixTimeToNT(struct timespec);
 #else
-extern u64 cifs_UnixTimeToNT(time_t);
-extern time_t cifs_NTtimeToUnix(u64 /* utc nanoseconds since 1601 */ );
+extern __u64 cifs_UnixTimeToNT(time_t);
+extern time_t cifs_NTtimeToUnix(__u64 /* utc nanoseconds since 1601 */
);
 #endif
 
 extern int cifs_get_inode_info(struct inode **pinode,
diff -urN cifs-2.6-old-kernels/fs/cifs/cifssmb.c
cifs-2.4/fs/cifs/cifssmb.c
--- cifs-2.6-old-kernels/fs/cifs/cifssmb.c	Mon Jul 24 15:13:14 2006
+++ cifs-2.4/fs/cifs/cifssmb.c	Thu Jul 27 15:11:25 2006
@@ -277,8 +277,12 @@
 				   reconnect, should be greater than
cifs socket
 				   timeout which is 7 seconds */
 			while(tcon->ses->server->tcpStatus ==
CifsNeedReconnect) {
+#ifdef LNXKERN26
 
wait_event_interruptible_timeout(tcon->ses->server->response_q,
 					(tcon->ses->server->tcpStatus ==
CifsGood), 10 * HZ);
+#else
+
interruptible_sleep_on_timeout(&tcon->ses->server->response_q, 10 * HZ);
+#endif
 				if(tcon->ses->server->tcpStatus == 
 						CifsNeedReconnect) {
 					/* on "soft" mounts we wait once
*/
diff -urN cifs-2.6-old-kernels/fs/cifs/dir.c cifs-2.4/fs/cifs/dir.c
--- cifs-2.6-old-kernels/fs/cifs/dir.c	Mon Jul 24 15:13:14 2006
+++ cifs-2.4/fs/cifs/dir.c	Thu Jul 27 15:11:25 2006
@@ -321,8 +321,13 @@
 	return rc;
 }
 
+#ifdef LNXKERN26
 int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, 
 		dev_t device_number) 
+#else
+int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode, 
+		int device_number) 
+#endif
 {
 	int rc = -EPERM;
 	int xid;
@@ -444,8 +449,13 @@
 }
 
 
+#ifdef LNXKERN26
 struct dentry *
 cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
struct nameidata *nd)
+#else
+struct dentry *
+cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry)
+#endif
 {
 	int xid;
 	int rc = 0; /* to get around spurious gcc warning, set to zero
here */
@@ -538,9 +548,13 @@
 	FreeXid(xid);
 	return ERR_PTR(rc);
 }
-
+#ifdef LNXKERN26
 static int
 cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
+#else
+static int
+cifs_d_revalidate(struct dentry *direntry, int flags)
+#endif
 {
 	int isValid = 1;
 
diff -urN cifs-2.6-old-kernels/fs/cifs/file.c cifs-2.4/fs/cifs/file.c
--- cifs-2.6-old-kernels/fs/cifs/file.c	Mon Jul 24 15:13:14 2006
+++ cifs-2.4/fs/cifs/file.c	Thu Jul 27 15:11:25 2006
@@ -21,16 +21,25 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA
  */
 #include <linux/fs.h>
+#ifdef LNXKERN26
 #include <linux/backing-dev.h>
+#endif
 #include <linux/stat.h>
 #include <linux/fcntl.h>
+#ifdef LNXKERN26
 #include <linux/mpage.h>
+#endif
 #include <linux/pagemap.h>
+#ifdef LNXKERN26
 #include <linux/pagevec.h>
+#endif
 #include <linux/smp_lock.h>
+#ifdef LNXKERN26
 #include <linux/writeback.h>
+#endif
 #include <linux/delay.h>
 #include <asm/div64.h>
+#include <asm/uaccess.h>
 #include "cifsfs.h"
 #include "cifspdu.h"
 #include "cifsglob.h"
@@ -39,6 +48,10 @@
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
 
+#ifdef LNXKERN24
+#define PageUptodate Page_Uptodate
+#endif
+
 static inline struct cifsFileInfo *cifs_init_private(
 	struct cifsFileInfo *private_data, struct inode *inode,
 	struct file *file, __u16 netfid)
@@ -96,7 +109,11 @@
 	struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
 	char *full_path, int xid)
 {
+#ifdef LNXKERN26
 	struct timespec temp;
+#else
+	time_t temp;
+#endif
 	int rc;
 
 	/* want handles we can use to read with first
@@ -120,7 +137,7 @@
 	/* if not oplocked, invalidate inode pages if mtime or file
 	   size changed */
 	temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
-	if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) && 
+	if (TIME_EQUAL(file->f_dentry->d_inode->i_mtime, temp) && 
 			   (file->f_dentry->d_inode->i_size == 
 			    (loff_t)le64_to_cpu(buf->EndOfFile))) {
 		cFYI(1, ("inode unchanged on server"));
@@ -131,13 +148,17 @@
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
 
filemap_write_and_wait(file->f_dentry->d_inode->i_mapping);
 #else
-
filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
+
FILEMAP_SYNC(file->f_dentry->d_inode->i_mapping);
 
filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
 #endif
 		}
 		cFYI(1, ("invalidating remote inode since open detected
it "
 			 "changed"));
+#ifdef LNXKERN26
 		invalidate_remote_inode(file->f_dentry->d_inode);
+#else
+		invalidate_inode_pages(file->f_dentry->d_inode);
+#endif
 	}
 
 client_can_cache:
@@ -428,7 +449,7 @@
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)
 
filemap_write_and_wait(inode->i_mapping);
 #else
-				filemap_fdatawrite(inode->i_mapping);
+				FILEMAP_SYNC(inode->i_mapping);
 				filemap_fdatawait(inode->i_mapping);
 #endif
 
@@ -606,19 +627,24 @@
 		cFYI(1, ("Posix"));
 	if (pfLock->fl_flags & FL_FLOCK)
 		cFYI(1, ("Flock"));
+#ifdef LNXKERN26
 	if (pfLock->fl_flags & FL_SLEEP) {
 		cFYI(1, ("Blocking lock"));
 		wait_flag = TRUE;
 	}
+#endif
 	if (pfLock->fl_flags & FL_ACCESS)
 		cFYI(1, ("Process suspended by mandatory locking - "
 			 "not implemented yet"));
 	if (pfLock->fl_flags & FL_LEASE)
 		cFYI(1, ("Lease on file - not implemented yet"));
 	if (pfLock->fl_flags & 
+#ifdef LNXKERN26
 	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
+#else
+	    (~(FL_POSIX | FL_FLOCK | FL_ACCESS | FL_LEASE)))
+#endif
 		cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
-
 	if (pfLock->fl_type == F_WRLCK) {
 		cFYI(1, ("F_WRLCK "));
 		numLock = 1;
@@ -829,8 +855,12 @@
 				current_fs_time(inode->i_sb);
 			if (total_written > 0) {
 				if (*poffset >
file->f_dentry->d_inode->i_size)
+#ifdef LNXKERN26
 
i_size_write(file->f_dentry->d_inode,
 					*poffset);
+#else
+                    file->f_dentry->d_inode->i_size = *poffset;
+#endif
 			}
 			mark_inode_dirty_sync(file->f_dentry->d_inode);
 		}
@@ -961,8 +991,12 @@
 			file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
 			if (total_written > 0) {
 				if (*poffset >
file->f_dentry->d_inode->i_size)
+#ifdef LNXKERN26
 
i_size_write(file->f_dentry->d_inode, 
 						     *poffset);
+#else
+					file->f_dentry->d_inode->i_size
= *poffset;
+#endif
 			}
 			mark_inode_dirty_sync(file->f_dentry->d_inode);
 		}
@@ -982,7 +1016,9 @@
 
 	if(cifs_inode == NULL) {
 		cERROR(1,("Null inode passed to cifs_writeable_file"));
+#ifdef CIFS_HAVE_DUMP_STACK
 		dump_stack();
+#endif
 		return NULL;
 	}
 
@@ -997,7 +1033,7 @@
 			read_unlock(&GlobalSMBSeslock);
 			if((open_file->invalidHandle) && 
 			   (!open_file->closePend) /* BB fixme -since
the second clause can not be true remove it BB */) {
-				rc =
cifs_reopen_file(&cifs_inode->vfs_inode, 
+				rc = cifs_reopen_file(VFS_I(cifs_inode),
 						      open_file->pfile,
FALSE);
 				/* if it fails, try another handle -
might be */
 				/* dangerous to hold up writepages with
retry */
@@ -1289,7 +1325,11 @@
 }
 #endif /* KERNEL_VERSION > 2.6.14 */
 
+#ifdef LNXKERN26
 static int cifs_writepage(struct page* page, struct writeback_control
*wbc)
+#else
+static int cifs_writepage(struct page* page)
+#endif
 {
 	int rc = -EFAULT;
 	int xid;
@@ -1322,7 +1362,11 @@
 	cFYI(1, ("commit write for page %p up to position %lld for %d", 
 		 page, position, to));
 	if (position > inode->i_size) {
+#ifdef LNXKERN26
 		i_size_write(inode, position);
+#else
+        inode->i_size = position;
+#endif
 		/* if (file->private_data == NULL) {
 			rc = -EBADF;
 		} else {
@@ -1390,7 +1434,7 @@
 	cFYI(1, ("Sync file - name: %s datasync: 0x%x", 
 		dentry->d_name.name, datasync));
 	
-	rc = filemap_fdatawrite(inode->i_mapping);
+	rc = FILEMAP_SYNC(inode->i_mapping);
 	if (rc == 0)
 		CIFS_I(inode)->write_behind_rc = 0;
 	FreeXid(xid);
@@ -1441,7 +1485,7 @@
 	   unlock inode for writing
 	   filemapfdatawrite appears easier for the time being */
 
-	rc = filemap_fdatawrite(inode->i_mapping);
+	rc = FILEMAP_SYNC(inode->i_mapping);
 	if (!rc) /* reset wb rc if we were able to write out dirty pages
*/
 		CIFS_I(inode)->write_behind_rc = 0;
 		
@@ -1910,7 +1954,7 @@
 		be closable if needed */
 		atomic_dec(&open_file->wrtPending);
 
-		cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
+		cifs_sb = CIFS_SB(VFS_I(cifsInode)->i_sb);
 		if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
 			/* since no page cache to corrupt on directio 
 			we can change size safely */
@@ -1968,7 +2012,9 @@
 #endif
 	.prepare_write = cifs_prepare_write,
 	.commit_write = cifs_commit_write,
+#ifdef LNXKERN26
 	.set_page_dirty = __set_page_dirty_nobuffers,
+#endif
 	/* .sync_page = cifs_sync_page, */
 	/* .direct_IO = */
 };
@@ -1986,7 +2032,9 @@
 #endif
 	.prepare_write = cifs_prepare_write,
 	.commit_write = cifs_commit_write,
+#ifdef LNXKERN26
 	.set_page_dirty = __set_page_dirty_nobuffers,
+#endif
 	/* .sync_page = cifs_sync_page, */
 	/* .direct_IO = */
 };


More information about the linux-cifs-client mailing list